เจเฉฐเจเจฐเจจเฉเจ เจฌเจนเฉเจค เจธเจฎเจพเจ เจชเจนเจฟเจฒเจพเจ เจฌเจฆเจฒ เจเจฟเจ เจนเฉ. เจเฉฐเจเจฐเจจเฉเจ เจฆเฉ เจฎเฉเฉฑเจ เจชเฉเจฐเฉเจเฉเจเฉเจฒเจพเจ เจตเจฟเฉฑเจเฉเจ เจเฉฑเจ - UDP เจฆเฉ เจตเจฐเจคเฉเจ เจเจชเจฒเฉเจเฉเจธเจผเจจเจพเจ เจฆเฉเจเจฐเจพ เจจเจพ เจธเจฟเจฐเจซเจผ เจกเฉเจเจพเจเฉเจฐเจพเจฎ เจ
เจคเฉ เจชเฉเจฐเจธเจพเจฐเจฃ เจชเฉเจฐเจฆเจพเจจ เจเจฐเจจ เจฒเจ เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเฉ, เจธเจเฉเจ เจจเฉเจเจตเจฐเจ เจจเฉเจกเจพเจ เจตเจฟเจเจเจพเจฐ "เจชเฉเจ
เจฐ-เจเฉ-เจชเฉเจ
เจฐ" เจเฉเจจเฉเจเจธเจผเจจ เจชเฉเจฐเจฆเจพเจจ เจเจฐเจจ เจฒเจ เจตเฉ เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเฉเฅค เจเจธเจฆเฉ เจธเจงเจพเจฐเจจ เจกเจฟเจเจผเจพเจเจจ เจฆเฉ เจเจพเจฐเจจ, เจเจธ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจตเจฟเฉฑเจ เจชเจนเจฟเจฒเจพเจ เจฌเจนเฉเจค เจธเจพเจฐเฉเจเจ เจเฉเจฐ-เจฏเฉเจเจจเจพเจฌเฉฑเจง เจตเจฐเจคเฉเจ เจนเจจ, เจนเจพเจฒเจพเจเจเจฟ, เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฆเฉเจเจ เจเจฎเฉเจเจ, เจเจฟเจตเฉเจ เจเจฟ เจเจพเจฐเฉฐเจเฉเจธเจผเฉเจฆเจพ เจกเจฟเจฒเฉเจตเจฐเฉ เจฆเฉ เจเจฎเฉ, เจเจฟเจคเฉ เจตเฉ เจเจพเจเจฌ เจจเจนเฉเจ เจนเฉเจ เจนเฉเฅค เจเจน เจฒเฉเจ UDP เจเฉฑเจคเฉ เจเจพเจฐเฉฐเจเฉเจธเจผเฉเจฆเจพ เจกเจฟเจฒเฉเจตเจฐเฉ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเจจ เจฆเจพ เจตเจฐเจฃเจจ เจเจฐเจฆเจพ เจนเฉเฅค
เจธเจฎเฉฑเจเจฐเฉ:
DisposeByTimeout เจขเฉฐเจ เจชเฉเจฐเจเจฟเจฐเจฟเจ เจชเฉเจเฉเจ เจตเจฟเจงเฉ เจชเฉเจเฉเจ เจตเจฟเจงเฉ เจชเฉเจฐเจพเจชเจค เจเจฐเฉ เจชเฉเจเฉเจ เจตเจฟเจงเฉ เจญเฉเจเฉ
เจเฉฐเจฆเจฐเจพเจเจผ
เจเฉฐเจเจฐเจจเฉเจ เจฆเฉ เจ
เจธเจฒ เจเจฐเจเฉเจเฉเจเจเจฐ เจจเฉ เจเฉฑเจ เจธเจฎเจพเจจ เจเจกเจฐเฉเฉฑเจธ เจธเจชเฉเจธ เจจเฉเฉฐ เจฎเฉฐเจจเจฟเจ เจเจฟเจธ เจตเจฟเฉฑเจ เจนเจฐเฉเจ เจจเฉเจก เจฆเจพ เจเฉฑเจ เจเจฒเฉเจฌเจฒ เจ
เจคเฉ เจตเจฟเจฒเฉฑเจเจฃ IP เจเจกเจฐเฉเฉฑเจธ เจธเฉ เจ
เจคเฉ เจเจน เจฆเฉเจเฉ เจจเฉเจกเจพเจ เจจเจพเจฒ เจธเจฟเฉฑเจงเจพ เจธเฉฐเจเจพเจฐ เจเจฐ เจธเจเจฆเจพ เจธเฉเฅค เจนเฉเจฃ เจเฉฐเจเจฐเจจเฉเจ, เจ
เจธเจฒ เจตเจฟเฉฑเจ, เจเฉฑเจ เจตเฉฑเจเจฐเจพ เจเจฐเจเฉเจเฉเจเจเจฐ เจนเฉ - เจเจฒเฉเจฌเจฒ IP เจชเจคเจฟเจเจ เจฆเจพ เจเฉฑเจ เจเฉเจคเจฐ เจ
เจคเฉ NAT เจกเจฟเจตเจพเจเจธเจพเจ เจฆเฉ เจชเจฟเฉฑเจเฉ เจฒเฉเจเฉ เจนเฉเจ เจจเจฟเฉฑเจเฉ เจชเจคเจฟเจเจ เจตเจพเจฒเฉ เจฌเจนเฉเจค เจธเจพเจฐเฉ เจเฉเจคเจฐเฅค
เจเฉฐเจเจฐเจจเฉเจ เจฆเจพ เจเจน เจเจฐเจเฉเจเฉเจเจเจฐ เจเจฒเจพเจเฉฐเจ-เจธเจฐเจตเจฐ เจธเฉฐเจเจพเจฐ เจฒเจ เจเจพเจซเจผเฉ เจธเจนเฉ เจนเฉ, เจเจฟเฉฑเจฅเฉ เจเจฒเจพเจเฉฐเจ เจชเฉเจฐเจพเจเจตเฉเจ เจจเฉเจเจตเจฐเจ เจตเจฟเฉฑเจ เจนเฉ เจธเจเจฆเฉ เจนเจจ, เจ เจคเฉ เจธเจฐเจตเจฐเจพเจ เจฆเจพ เจเฉฑเจ เจเจฒเฉเจฌเจฒ เจชเจคเจพ เจนเฉเฉฐเจฆเจพ เจนเฉเฅค เจชเจฐ เจเจน เจตเจฟเจเจเจพเจฐ เจฆเฉ เจจเฉเจกเจพเจ เจฆเฉ เจธเจฟเฉฑเจงเฉ เจเฉเจจเฉเจเจธเจผเจจ เจฒเจ เจฎเฉเจธเจผเจเจฒ เจชเฉเจฆเจพ เจเจฐเจฆเจพ เจนเฉ เจตเฉฑเจ - เจตเฉฑเจ เจชเฉเจฐเจพเจเจตเฉเจ เจจเฉเฉฑเจเจตเจฐเจ. เจชเฉเจ เจฐ-เจเฉ-เจชเฉเจ เจฐ เจเจชเจฒเฉเจเฉเจธเจผเจจเจพเจ เจเจฟเจตเฉเจ เจเจฟ เจตเฉเจเจธ เจเฉเจฐเจพเจเจธเจฎเจฟเจธเจผเจจ (เจธเจเจพเจเจช), เจเฉฐเจชเจฟเจเจเจฐ (เจเฉเจฎเจตเจฟเจเจ เจฐ) เจคเฉฑเจ เจฐเจฟเจฎเฉเจ เจชเจนเฉเฉฐเจ เจชเฉเจฐเจพเจชเจค เจเจฐเจจเจพ, เจเจพเจ เจเจจเจฒเจพเจเจจ เจเฉเจฎเจฟเฉฐเจ เจฒเจ เจฆเฉ เจจเฉเจกเจพเจ เจตเจฟเจเจเจพเจฐ เจธเจฟเฉฑเจงเจพ เจธเฉฐเจชเจฐเจ เจฎเจนเฉฑเจคเจตเจชเฉเจฐเจจ เจนเฉเฅค
เจตเฉฑเจ-เจตเฉฑเจ เจชเฉเจฐเจพเจเจตเฉเจ เจจเฉเฉฑเจเจตเจฐเจเจพเจ 'เจคเฉ เจกเจฟเจตเจพเจเจธเจพเจ เจตเจฟเจเจเจพเจฐ เจชเฉเจ เจฐ-เจเฉ-เจชเฉเจ เจฐ เจเจจเฉเจเจธเจผเจจ เจธเจฅเจพเจชเจค เจเจฐเจจ เจฒเจ เจธเจญ เจคเฉเจ เจชเฉเจฐเจญเจพเจตเจธเจผเจพเจฒเฉ เจขเฉฐเจเจพเจ เจตเจฟเฉฑเจเฉเจ เจเฉฑเจ เจจเฉเฉฐ เจนเฉเจฒ เจชเฉฐเจเจฟเฉฐเจ เจเจฟเจนเจพ เจเจพเจเจฆเจพ เจนเฉเฅค เจเจน เจคเจเจจเฉเจ เจเจฎ เจคเฉเจฐ 'เจคเฉ UDP เจชเฉเจฐเฉเจเฉเจเฉเจฒ 'เจคเฉ เจเจงเจพเจฐเจฟเจค เจเจชเจฒเฉเจเฉเจธเจผเจจเจพเจ เจจเจพเจฒ เจตเจฐเจคเฉ เจเจพเจเจฆเฉ เจนเฉเฅค
เจชเจฐ เจเฉเจเจฐ เจคเฉเจนเจพเจกเฉ เจเจชเจฒเฉเจเฉเจธเจผเจจ เจจเฉเฉฐ เจกเฉเจเจพ เจฆเฉ เจเจพเจฐเฉฐเจเฉเจธเจผเฉเจฆเจพ เจกเจฟเจฒเฉเจตเจฐเฉ เจฆเฉ เจฒเฉเฉ เจนเฉเฉฐเจฆเฉ เจนเฉ, เจเจฆเจพเจนเจฐเจจ เจฒเจ, เจคเฉเจธเฉเจ เจเฉฐเจชเจฟเจเจเจฐเจพเจ เจตเจฟเจเจเจพเจฐ เจซเจพเจเจฒเจพเจ เจเฉเจฐเจพเจเจธเจซเจฐ เจเจฐเจฆเฉ เจนเฉ, เจคเจพเจ UDP เจฆเฉ เจตเจฐเจคเฉเจ เจเจฐเจจ เจตเจฟเฉฑเจ เจเจธ เจคเฉฑเจฅ เจฆเฉ เจเจพเจฐเจจ เจฌเจนเฉเจค เจธเจพเจฐเฉเจเจ เจฎเฉเจธเจผเจเจฒเจพเจ เจนเฉเจฃเจเฉเจเจ เจเจฟ UDP เจเฉฑเจ เจเจพเจฐเฉฐเจเฉเจธเจผเฉเจฆเจพ เจกเจฟเจฒเฉเจตเจฐเฉ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจจเจนเฉเจ เจนเฉ เจ เจคเฉ เจเฉเจธเฉเจชเฉ เจฆเฉ เจเจฒเจ, เจเฉเจฐเจฎ เจตเจฟเฉฑเจ เจชเฉเจเฉเจ เจกเจฟเจฒเฉเจตเจฐเฉ เจชเฉเจฐเจฆเจพเจจ เจจเจนเฉเจ เจเจฐเจฆเจพ เจนเฉเฅค เจชเฉเจฐเฉเจเฉเจเฉเจฒเฅค
เจเจธ เจธเจฅเจฟเจคเฉ เจตเจฟเฉฑเจ, เจเจพเจฐเฉฐเจเฉเจธเจผเฉเจฆเจพ เจชเฉเจเฉเจ เจกเจฟเจฒเฉเจตเจฐเฉ เจจเฉเฉฐ เจฏเจเฉเจจเฉ เจฌเจฃเจพเจเจฃ เจฒเจ, เจเฉฑเจ เจเจชเจฒเฉเจเฉเจธเจผเจจ เจฒเฉเจ เจฐ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเจจ เจฆเฉ เจฒเฉเฉ เจนเฉเฉฐเจฆเฉ เจนเฉ เจเฉ เจฒเฉเฉเฉเจเจฆเฉ เจเจพเจฐเจเจธเจผเฉเจฒเจคเจพ เจชเฉเจฐเจฆเจพเจจ เจเจฐเจฆเจพ เจนเฉ เจ เจคเฉ UDP เจเฉฑเจคเฉ เจเฉฐเจฎ เจเจฐเจฆเจพ เจนเฉเฅค
เจฎเฉเจ เจคเฉเจฐเฉฐเจค เจจเฉเจ เจเจฐเจจเจพ เจเจพเจนเฉเฉฐเจฆเจพ เจนเจพเจ เจเจฟ เจตเฉฑเจ-เจตเฉฑเจ เจชเฉเจฐเจพเจเจตเฉเจ เจจเฉเจเจตเจฐเจเจพเจ เจตเจฟเฉฑเจ เจจเฉเจกเจพเจ เจตเจฟเจเจเจพเจฐ TCP เจเฉเจจเฉเจเจธเจผเจจ เจธเจฅเจพเจชเจค เจเจฐเจจ เจฒเจ เจเฉฑเจ TCP เจนเฉเจฒ เจชเฉฐเจเจฟเฉฐเจ เจคเจเจจเฉเจ เจนเฉ, เจชเจฐ เจฌเจนเฉเจค เจธเจพเจฐเฉ NAT เจกเจฟเจตเจพเจเจธเจพเจ เจฆเฉเจเจฐเจพ เจเจธเจฆเฉ เจฒเจ เจธเจฎเจฐเจฅเจจ เจฆเฉ เจเจฎเฉ เจฆเฉ เจเจพเจฐเจจ, เจเจธเจจเฉเฉฐ เจเจฎ เจคเฉเจฐ 'เจคเฉ เจเฉเฉเจจ เจฆเจพ เจฎเฉเฉฑเจ เจคเจฐเฉเจเจพ เจจเจนเฉเจ เจฎเฉฐเจจเจฟเจ เจเจพเจเจฆเจพ เจนเฉเฅค เจ เจเจฟเจนเฉ เจจเฉเจก.
เจเจธ เจฒเฉเจ เจฆเฉ เจฌเจพเจเฉ เจนเจฟเฉฑเจธเฉ เจฒเจ, เจฎเฉเจ เจธเจฟเจฐเจซเจผ เจเจพเจฐเฉฐเจเฉเจธเจผเฉเจฆเจพ เจกเจฟเจฒเฉเจตเจฐเฉ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเจจ 'เจคเฉ เจงเจฟเจเจจ เจเฉเจเจฆเจฐเจค เจเจฐเจพเจเจเจพเฅค UDP เจนเฉเจฒ เจชเฉฐเจเจฟเฉฐเจ เจคเจเจจเฉเจ เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเจจ เจฆเจพ เจตเจฐเจฃเจจ เจ เจเจฒเฉ เจฒเฉเจเจพเจ เจตเจฟเฉฑเจ เจเฉเจคเจพ เจเจพเจตเฉเจเจพเฅค
เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฒเฉเฉเจพเจ
- เจเฉฑเจ เจธเจเจพเจฐเจพเจคเจฎเจ เจซเฉเจกเจฌเฉเจ เจตเจฟเจงเฉ (เจ เจเฉเจคเฉ เจธเจเจพเจฐเจพเจคเจฎเจ เจฎเจพเจจเจคเจพ) เจฆเฉเจเจฐเจพ เจฒเจพเจเฉ เจญเจฐเฉเจธเฉเจฏเฉเจ เจชเฉเจเฉเจ เจกเจฟเจฒเจฟเจตเจฐเฉ
- เจตเฉฑเจกเฉ เจกเฉเจเจพ เจฆเฉ เจเฉเจธเจผเจฒ เจเฉเจฐเจพเจเจธเจซเจฐ เจฆเฉ เจเจผเจฐเฉเจฐเจค, เจฏเจพเจจเฉ. เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจจเฉเฉฐ เจฌเฉเจฒเฉเฉเฉ เจชเฉเจเฉเจ เจฐเฉเจฒเฉเจ เจคเฉเจ เจฌเจเจฃเจพ เจเจพเจนเฉเจฆเจพ เจนเฉ
- เจกเจฟเจฒเฉเจตเจฐเฉ เจชเฉเจธเจผเจเฉเจเจฐเจจ เจตเจฟเจงเฉ เจจเฉเฉฐ เจฐเฉฑเจฆ เจเจฐเจจเจพ เจธเฉฐเจญเจต เจนเฉเจฃเจพ เจเจพเจนเฉเจฆเจพ เจนเฉ (เจเฉฑเจ "เจธเจผเฉเฉฑเจง" UDP เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจตเจเฉเจ เจเฉฐเจฎ เจเจฐเจจ เจฆเฉ เจฏเฉเจเจคเจพ)
- เจนเจฐเฉเจ เจธเฉฐเจฆเฉเจธเจผ เจฆเฉ เจชเฉเจธเจผเจเฉ เจฆเฉ เจจเจพเจฒ, เจเจฎเจพเจเจก เจฎเฉเจก เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเจจ เจฆเฉ เจธเจฎเจฐเฉฑเจฅเจพ
- เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจเฉฑเจคเฉ เจกเฉเจเจพ เจเฉเจฐเจพเจเจธเจซเจฐ เจฆเฉ เจฎเฉเจฒ เจเจเจพเจ เจเฉฑเจ เจธเฉเจจเฉเจนเจพ เจนเฉเจฃเจพ เจเจพเจนเฉเจฆเจพ เจนเฉ
เจเจน เจฒเฉเฉเจพเจ เจตเฉฑเจกเฉ เจชเฉฑเจงเจฐ 'เจคเฉ เจญเจฐเฉเจธเฉเจฎเฉฐเจฆ เจกเฉเจเจพ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฆเฉเจเจ เจฒเฉเฉเจพเจ เจจเจพเจฒ เจฎเฉเจฒ เจเจพเจเจฆเฉเจเจ เจนเจจ เจเจฟเจจเฉเจนเจพเจ เจตเจฟเฉฑเจ เจตเจฐเจฃเจจ เจเฉเจคเจพ เจเจฟเจ เจนเฉ
เจเจนเจจเจพเจ เจฒเฉเฉเจพเจ เจจเฉเฉฐ เจธเจฎเจเจฃ เจฒเจ, เจเจ TCP เจ
เจคเฉ UDP เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฆเฉ เจตเจฐเจคเฉเจ เจเจฐเจฆเฉ เจนเฉเจ เจฆเฉ เจจเฉเจเจตเจฐเจ เจจเฉเจกเจพเจ เจตเจฟเจเจเจพเจฐ เจกเฉเจเจพ เจเฉเจฐเจพเจเจธเจซเจฐ เจฆเฉ เจธเจฎเฉเจ เจจเฉเฉฐ เจตเฉเจเฉเจเฅค เจฆเฉเจจเจพเจ เจฎเจพเจฎเจฒเจฟเจเจ เจตเจฟเฉฑเจ เจธเจพเจกเฉ เจเฉเจฒ เจเฉฑเจ เจชเฉเจเฉเจ เจเฉเฉฐเจฎ เจนเฉ เจเจพเจตเฉเจเจพเฅค
TCP เจเฉฑเจคเฉ เจเฉเจฐ-เจเฉฐเจเจฐเฉเจเจเจฟเจต เจกเฉเจเจพ เจฆเจพ เจเฉเจฐเจพเจเจธเจซเจฐ:
เจเจฟเจตเฉเจ เจเจฟ เจคเฉเจธเฉเจ เจเจฟเฉฑเจคเจฐ เจคเฉเจ เจฆเฉเจ เจธเจเจฆเฉ เจนเฉ, เจชเฉเจเฉเจ เจฆเฉ เจจเฉเจเจธเจพเจจ เจฆเฉ เจธเจฅเจฟเจคเฉ เจตเจฟเฉฑเจ, TCP เจเฉเฉฐเจฎ เจนเฉเจ เจชเฉเจเฉเจ เจฆเจพ เจชเจคเจพ เจฒเจเจพเจตเฉเจเจพ เจ
เจคเฉ เจเฉเฉฐเจฎ เจนเฉเจ เจนเจฟเฉฑเจธเฉ เจฆเฉ เจเจฟเจฃเจคเฉ เจชเฉเฉฑเจ เจเฉ เจญเฉเจเจฃ เจตเจพเจฒเฉ เจจเฉเฉฐ เจเจธเจฆเฉ เจฐเจฟเจชเฉเจฐเจ เจเจฐเฉเจเจพเฅค
UDP เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฆเฉเจเจฐเจพ เจกเจพเจเจพ เจเฉเจฐเจพเจเจธเจซเจฐ:
UDP เจจเฉเจเจธเจพเจจ เจฆเจพ เจชเจคเจพ เจฒเจเจพเจเจฃ เจฒเจ เจเฉเจ เจเจฆเจฎ เจจเจนเฉเจ เจเฉเฉฑเจเจฆเจพ เจนเฉเฅค UDP เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจตเจฟเฉฑเจ เจเฉเจฐเจพเจเจธเจฎเจฟเจธเจผเจจ เจเจฒเจคเฉเจเจ เจฆเจพ เจจเจฟเจฏเฉฐเจคเจฐเจฃ เจชเฉเจฐเฉ เจคเจฐเฉเจนเจพเจ เจเจชเจฒเฉเจเฉเจธเจผเจจ เจฆเฉ เจเจผเจฟเฉฐเจฎเฉเจตเจพเจฐเฉ เจนเฉเฅค
TCP เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจตเจฟเฉฑเจ เจเจฒเจคเฉ เจเฉเจ เจเฉฑเจ เจ เฉฐเจค เจจเฉเจก เจฆเฉ เจจเจพเจฒ เจเฉฑเจ เจเจจเฉเจเจธเจผเจจ เจธเจฅเจพเจชเจค เจเจฐเจเฉ, เจเจธ เจเจจเฉเจเจธเจผเจจ เจฆเฉ เจธเจฅเจฟเจคเฉ เจจเฉเฉฐ เจธเจเฉเจฐ เจเจฐเจเฉ, เจนเจฐเฉเจ เจชเฉเจเฉเจ เจนเฉเจกเจฐ เจตเจฟเฉฑเจ เจญเฉเจเฉ เจเจ เจฌเจพเจเจเจพเจ เจฆเฉ เจธเฉฐเจเจฟเจ เจจเฉเฉฐ เจฆเจฐเจธเจพเจเจเจฆเฉ เจนเฉเจ, เจ เจคเฉ เจเฉฑเจ เจฐเจธเฉเจฆ เจจเฉฐเจฌเจฐ เจฆเฉ เจตเจฐเจคเฉเจ เจเจฐเจเฉ เจฐเจธเฉเจฆเจพเจ เจจเฉเฉฐ เจธเฉเจเจฟเจค เจเจฐเจเฉ เจชเฉเจฐเจพเจชเจค เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเฉเฅค
เจเจธ เจคเฉเจ เจเจฒเจพเจตเจพ, เจเจพเจฐเจเฉเจเจผเจพเจฐเฉ เจตเจฟเฉฑเจ เจธเฉเจงเจพเจฐ เจเจฐเจจ เจฒเจ (เจเจฟเจตเฉเจ เจเจฟ เจเฉฑเจ เจฐเจธเฉเจฆ เจชเฉเจฐเจพเจชเจค เจเฉเจคเฉ เจฌเจฟเจจเจพเจ เจเฉฑเจ เจคเฉเจ เจตเฉฑเจง เจเฉฐเจก เจญเฉเจเฉ), TCP เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจ เจเฉเจคเฉ เจเจฐเจพเจเจธเจฎเจฟเจธเจผเจจ เจตเจฟเฉฐเจกเฉ เจฆเฉ เจตเจฐเจคเฉเจ เจเจฐเจฆเจพ เจนเฉ - เจกเฉเจเจพ เจฆเฉ เจฌเจพเจเจเจพเจ เจฆเฉ เจธเฉฐเจเจฟเจ เจเฉ เจเจฟ เจนเจฟเฉฑเจธเฉ เจฆเฉ เจญเฉเจเจฃ เจตเจพเจฒเฉ เจจเฉเฉฐ เจชเฉเจฐเจพเจชเจค เจเจฐเจจ เจฆเฉ เจเจฎเฉเจฆ เจนเฉเฅค
TCP เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฌเจพเจฐเฉ เจนเฉเจฐ เจเจพเจฃเจเจพเจฐเฉ เจฒเจ, เจตเฉเจเฉ
เจเจชเจฐเฉเจเจค เจคเฉเจ, เจเจน เจธเจชเฉฑเจธเจผเจ เจนเฉ เจเจฟ UDP เจเฉฑเจคเฉ เจเฉฑเจ เจญเจฐเฉเจธเฉเจฎเฉฐเจฆ เจธเฉเจจเฉเจนเจพ เจกเจฟเจฒเจฟเจตเจฐเฉ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฌเจฃเจพเจเจฃ เจฒเจ (เจเจธ เจคเฉเจ เจฌเจพเจ เจฆ เจเจธเจจเฉเฉฐ เจเจฟเจนเจพ เจเจพเจเจฆเจพ เจนเฉ เจญเจฐเฉเจธเฉเจฏเฉเจ UDP), เจเจน TCP เจฆเฉ เจธเจฎเจพเจจ เจกเฉเจเจพ เจเฉเจฐเจพเจเจธเจซเจฐ เจตเจฟเจงเฉ เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเจจ เจฆเฉ เจฒเฉเฉ เจนเฉเฅค เจ เจฐเจฅเจพเจค:
- เจเฉเจจเฉเจเจธเจผเจจ เจธเจฅเจฟเจคเฉ เจจเฉเฉฐ เจธเฉเจฐเฉฑเจเจฟเจ เจค เจเจฐเฉ
- เจเฉฐเจก เจจเฉฐเจฌเจฐเจฟเฉฐเจ เจฆเฉ เจตเจฐเจคเฉเจ เจเจฐเฉ
- เจตเจฟเจธเจผเฉเจธเจผ เจชเฉเจธเจผเจเฉเจเจฐเจจ เจชเฉเจเฉเจเจพเจ เจฆเฉ เจตเจฐเจคเฉเจ เจเจฐเฉ
- เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฅเฉเจฐเฉเจชเฉเฉฑเจ เจจเฉเฉฐ เจตเจงเจพเจเจฃ เจฒเจ เจเฉฑเจ เจธเจฐเจฒ เจตเจฟเฉฐเจกเฉเจฟเฉฐเจ เจตเจฟเจงเฉ เจฆเฉ เจตเจฐเจคเฉเจ เจเจฐเฉ
เจเจธ เจคเฉเจ เจเจฒเจพเจตเจพ, เจคเฉเจนเจพเจจเฉเฉฐ เจฒเฉเฉ เจนเฉ:
- เจเจจเฉเจเจธเจผเจจ เจฒเจ เจธเจฐเฉเจค เจจเจฟเจฐเจงเจพเจฐเจค เจเจฐเจจ เจฒเจ, เจเฉฑเจ เจธเฉฐเจฆเฉเจธเจผ เจฆเฉ เจธเจผเฉเจฐเฉเจเจค เจฆเจพ เจธเฉฐเจเฉเจค เจฆเจฟเจ
- เจเฉฑเจ เจธเฉเจจเฉเจนเฉ เจฆเฉ เจ เฉฐเจค เจจเฉเฉฐ เจธเฉฐเจเฉเจค เจเจฐเจฆเจพ เจนเฉ, เจชเฉเจฐเจพเจชเจค เจเฉเจคเฉ เจธเฉเจจเฉเจนเฉ เจจเฉเฉฐ เจ เฉฑเจชเจธเจเจฐเฉเจฎ เจเจชเจฒเฉเจเฉเจธเจผเจจ เจจเฉเฉฐ เจญเฉเจเจฃ เจ เจคเฉ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจธเจฐเฉเจคเจพเจ เจจเฉเฉฐ เจเจพเจฐเฉ เจเจฐเจจ เจฒเจ
- เจเฉเจจเฉเจเจธเจผเจจ-เจตเจฟเจธเจผเฉเจธเจผ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจจเฉเฉฐ "เจธเจผเฉเฉฑเจง" UDP เจฆเฉ เจคเฉเจฐ เจคเฉ เจเฉฐเจฎ เจเจฐเจจ เจฒเจ เจกเจฟเจฒเฉเจตเจฐเฉ เจชเฉเจธเจผเจเฉเจเจฐเจจ เจตเจฟเจงเฉ เจจเฉเฉฐ เจ เจธเจฎเจฐเฉฑเจฅ เจฌเจฃเจพเจเจฃ เจฆเฉ เจเจเจฟเจ เจฆเจฟเจ
เจญเจฐเฉเจธเฉเจฏเฉเจ UDP เจธเจฟเจฐเจฒเฉเจ
เจฏเจพเจฆ เจเจฐเฉ เจเจฟ เจเฉฑเจ UDP เจกเฉเจเจพเจเฉเจฐเจพเจฎ เจเฉฑเจ IP เจกเฉเจเจพเจเฉเจฐเจพเจฎ เจตเจฟเฉฑเจ เจธเจผเจพเจฎเจฒ เจนเฉเฉฐเจฆเจพ เจนเฉเฅค เจญเจฐเฉเจธเฉเจฏเฉเจ UDP เจชเฉเจเฉเจ เจจเฉเฉฐ UDP เจกเฉเจเจพเจเฉเจฐเจพเจฎ เจตเจฟเฉฑเจ "เจฒเจชเฉเจเจฟเจ" เจเจฟเจ เจนเฉเฅค
เจญเจฐเฉเจธเฉเจฏเฉเจ UDP เจธเจฟเจฐเจฒเฉเจ เจเจจเจเฉเจชเจธเฉเจฒเฉเจธเจผเจจ:
เจญเจฐเฉเจธเฉเจฏเฉเจ UDP เจธเจฟเจฐเจฒเฉเจ เจฆเฉ เจฌเจฃเจคเจฐ เจเจพเจซเจผเฉ เจธเจงเจพเจฐเจจ เจนเฉ:
- เจเฉฐเจกเฉ - เจชเฉเจเฉเจ เจเฉฐเจเจฐเฉเจฒ เจซเจฒเฉเจ
- MessageType - เจเจพเจธ เจธเฉเจจเฉเจนเจฟเจเจ เจฆเฉ เจฎเฉเจเจฌเจฐ เจฌเจฃเจจ เจฒเจ เจ เฉฑเจชเจธเจเจฐเฉเจฎ เจเจชเจฒเฉเจเฉเจธเจผเจจเจพเจ เจฆเฉเจเจฐเจพ เจตเจฐเจคเฉ เจเจพเจเจฆเฉ เจธเฉเจจเฉเจนเจพ เจเจฟเจธเจฎ
- เจเฉเจฐเจพเจเจธเจฎเจฟเจธเจผเจจ เจเจเจกเฉ - เจชเฉเจฐเจธเจพเจฐเจฃ เจฆเฉ เจธเฉฐเจเจฟเจ, เจชเฉเจฐเจพเจชเจคเจเจฐเจคเจพ เจฆเฉ เจชเจคเฉ เจ เจคเฉ เจชเฉเจฐเจ เจฆเฉ เจจเจพเจฒ, เจเฉเจจเฉเจเจธเจผเจจ เจฆเฉ เจตเจฟเจฒเฉฑเจเจฃ เจชเจเจพเจฃ เจเจฐเจฆเจพ เจนเฉ
- PacketNumber - เจชเฉเจเฉเจ เจจเฉฐเจฌเจฐ
- เจตเจฟเจเจฒเจช - เจตเจพเจงเฉ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจตเจฟเจเจฒเจชเฅค เจชเจนเจฟเจฒเฉ เจชเฉเจเฉเจ เจฆเฉ เจฎเจพเจฎเจฒเฉ เจตเจฟเฉฑเจ, เจเจธเจฆเฉ เจตเจฐเจคเฉเจ เจธเฉฐเจฆเฉเจธเจผ เจฆเฉ เจเจเจพเจฐ เจจเฉเฉฐ เจฆเจฐเจธเจพเจเจฃ เจฒเจ เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเฉ
เจเฉฐเจกเฉ เจนเฉเจ เจฒเจฟเจเฉ เจ เจจเฉเจธเจพเจฐ เจนเจจ:
- FirstPacket - เจธเฉเจจเฉเจนเฉ เจฆเจพ เจชเจนเจฟเจฒเจพ เจชเฉเจเฉเจ
- NoAsk - เจธเฉเจจเฉเจนเฉ เจจเฉเฉฐ เจธเจฎเจฐเฉฑเจฅ เจเจฐเจจ เจฒเจ เจเฉฑเจ เจฐเจธเฉเจฆ เจตเจฟเจงเฉ เจฆเฉ เจฒเฉเฉ เจจเจนเฉเจ เจนเฉ
- LastPacket - เจธเฉเจจเฉเจนเฉ เจฆเจพ เจเจเจฐเฉ เจชเฉเจเฉเจ
- RequestForPacket - เจชเฉเจธเจผเจเฉเจเจฐเจจ เจชเฉเจเฉเจ เจเจพเจ เจเฉเฉฐเจฎ เจนเฉเจ เจชเฉเจเฉเจ เจฒเจ เจฌเฉเจจเจคเฉ
เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฆเฉ เจเจฎ เจธเจฟเจงเจพเจเจค
เจเจฟเจเจเจเจฟ เจญเจฐเฉเจธเฉเจฎเฉฐเจฆ UDP เจฆเฉ เจจเฉเจกเจพเจ เจตเจฟเจเจเจพเจฐ เจเจพเจฐเฉฐเจเฉเจธเจผเฉเจฆเจพ เจธเฉฐเจฆเฉเจธเจผ เจชเฉเจฐเจธเจพเจฐเจฃ 'เจคเฉ เจเฉเจเจฆเฉเจฐเจฟเจค เจนเฉ, เจเจธ เจฒเจ เจเจน เจฆเฉเจเฉ เจชเจพเจธเฉ เจจเจพเจฒ เจเฉฑเจ เจเฉเจจเฉเจเจธเจผเจจ เจธเจฅเจพเจชเจค เจเจฐเจจ เจฆเฉ เจฏเฉเจ เจนเฉเจฃเจพ เจเจพเจนเฉเจฆเจพ เจนเฉเฅค เจเฉฑเจ เจเฉเจจเฉเจเจธเจผเจจ เจธเจฅเจพเจชเจค เจเจฐเจจ เจฒเจ, เจญเฉเจเจฃ เจตเจพเจฒเจพ เจซเจธเจเจชเฉเจเฉเจ เจซเจฒเฉเจ เจตเจพเจฒเจพ เจเฉฑเจ เจชเฉเจเฉเจ เจญเฉเจเจฆเจพ เจนเฉ, เจเจฟเจธ เจฆเฉ เจเจตเจพเจฌ เจฆเจพ เจฎเจคเจฒเจฌ เจนเฉเจตเฉเจเจพ เจเจฟ เจเฉเจจเฉเจเจธเจผเจจ เจธเจฅเจพเจชเจค เจนเฉ เจเจฟเจ เจนเฉเฅค เจธเจพเจฐเฉ เจเจตเจพเจฌ เจชเฉเจเฉเจ, เจเจพเจ, เจฆเฉเจเฉ เจธเจผเจฌเจฆเจพเจ เจตเจฟเฉฑเจ, เจฎเจพเจจเจคเจพ เจชเฉเจเฉเจ, เจนเจฎเฉเจธเจผเจพ PacketNumber เจซเฉเจฒเจก เจฆเฉ เจฎเฉเฉฑเจฒ เจจเฉเฉฐ เจธเจซเจฒเจคเจพเจชเฉเจฐเจตเจ เจชเฉเจฐเจพเจชเจค เจเฉเจคเฉ เจชเฉเจเฉเจเจพเจ เจฆเฉ เจธเจญ เจคเฉเจ เจตเฉฑเจกเฉ PacketNumber เจฎเฉเฉฑเจฒ เจคเฉเจ เจเฉฑเจ เจตเฉฑเจง เจธเฉเฉฑเจ เจเจฐเจฆเฉ เจนเจจเฅค เจญเฉเจเฉ เจเจ เจชเจนเจฟเจฒเฉ เจชเฉเจเฉเจ เจฒเจ เจตเจฟเจเจฒเจช เจเฉเจคเจฐ เจธเฉฐเจฆเฉเจธเจผ เจฆเจพ เจเจเจพเจฐ เจนเฉเฅค
เจเฉฑเจ เจธเจฎเจพเจจ เจตเจฟเจงเฉ เจเฉฑเจ เจเฉเจจเฉเจเจธเจผเจจ เจจเฉเฉฐ เจเจคเจฎ เจเจฐเจจ เจฒเจ เจตเจฐเจคเฉ เจเจพเจเจฆเฉ เจนเฉเฅค LastPacket เจซเจฒเฉเจ เจธเฉฐเจฆเฉเจธเจผ เจฆเฉ เจเจเจฐเฉ เจชเฉเจเฉเจ 'เจคเฉ เจธเฉเฉฑเจ เจเฉเจคเจพ เจเจฟเจ เจนเฉเฅค เจเจตเจพเจฌ เจชเฉเจเฉเจ เจตเจฟเฉฑเจ, เจเจเจฐเฉ เจชเฉเจเฉเจ + 1 เจฆเฉ เจธเฉฐเจเจฟเจ เจฆเจฐเจธเจพเจ เจเจ เจนเฉ, เจเจฟเจธเจฆเจพ เจชเฉเจฐเจพเจชเจค เจเจฐเจจ เจตเจพเจฒเฉ เจชเจพเจธเฉ เจฆเจพ เจฎเจคเจฒเจฌ เจนเฉ เจธเฉฐเจฆเฉเจธเจผ เจฆเฉ เจธเจซเจฒ เจกเจฟเจฒเฉเจตเจฐเฉเฅค
เจเจจเฉเจเจธเจผเจจ เจธเจฅเจพเจชเจจเจพ เจ
เจคเฉ เจธเจฎเจพเจชเจคเฉ เจเจฟเฉฑเจคเจฐ:
เจเจฆเฉเจ เจเฉเจจเฉเจเจธเจผเจจ เจธเจฅเจพเจชเจฟเจค เจนเฉ เจเจพเจเจฆเจพ เจนเฉ, เจกเฉเจเจพ เจเฉเจฐเจพเจเจธเจซเจฐ เจธเจผเฉเจฐเฉ เจนเฉเฉฐเจฆเจพ เจนเฉเฅค เจกเจพเจเจพ เจชเฉเจเจเจพเจ เจฆเฉ เจฌเจฒเจพเจเจพเจ เจตเจฟเฉฑเจ เจชเฉเจฐเจธเจพเจฐเจฟเจค เจเฉเจคเจพ เจเจพเจเจฆเจพ เจนเฉเฅค เจนเจฐเฉเจ เจฌเจฒเจพเจ, เจเจเจฐเฉ เจจเฉเฉฐ เจเฉฑเจก เจเฉ, เจตเจฟเฉฑเจ เจเฉฑเจ เจจเจฟเจธเจผเจเจฟเจค เจธเฉฐเจเจฟเจ เจฆเฉ เจชเฉเจเฉเจ เจนเฉเฉฐเจฆเฉ เจนเจจเฅค เจเจน เจชเฉเจฐเจพเจชเจค/เจชเฉเจฐเจธเจพเจฐเจฟเจค เจตเจฟเฉฐเจกเฉ เจเจเจพเจฐ เจฆเฉ เจฌเจฐเจพเจฌเจฐ เจนเฉเฅค เจกเจพเจเจพ เจฆเฉ เจเจเจฐเฉ เจฌเจฒเจพเจ เจตเจฟเฉฑเจ เจเฉฑเจ เจชเฉเจเฉเจ เจนเฉ เจธเจเจฆเฉ เจนเจจเฅค เจนเจฐเฉเจ เจฌเจฒเจพเจ เจจเฉเฉฐ เจญเฉเจเจฃ เจคเฉเจ เจฌเจพเจ
เจฆ, เจญเฉเจเจฃ เจตเจพเจฒเจพ เจชเฉฑเจ เจเฉฑเจ เจกเจฟเจฒเฉเจตเจฐเฉ เจชเฉเจธเจผเจเฉ เจเจพเจ เจเฉเฉฐเจฎ เจนเฉเจ เจชเฉเจเฉเจเจพเจ เจจเฉเฉฐ เจฆเฉเจฌเจพเจฐเจพ เจกเจฟเจฒเฉเจตเจฐ เจเจฐเจจ เจฆเฉ เจฌเฉเจจเจคเฉ เจฆเฉ เจเจกเฉเจ เจเจฐเจฆเจพ เจนเฉ, เจเจตเจพเจฌ เจชเฉเจฐเจพเจชเจค เจเจฐเจจ เจฒเจ เจชเฉเจฐเจพเจชเจค/เจชเฉเจฐเจธเจพเจฐเจฟเจค เจตเจฟเฉฐเจกเฉ เจจเฉเฉฐ เจเฉเฉฑเจฒเฉเจนเจพ เจเฉฑเจก เจเฉเฅค เจฌเจฒเจพเจ เจกเจฟเจฒเฉเจตเจฐเฉ เจฆเฉ เจชเฉเจธเจผเจเฉ เจชเฉเจฐเจพเจชเจค เจเจฐเจจ เจคเฉเจ เจฌเจพเจ
เจฆ, เจชเฉเจฐเจพเจชเจค/เจชเฉเจฐเจธเจพเจฐเจฟเจค เจตเจฟเฉฐเจกเฉ เจธเจผเจฟเจซเจ เจนเฉ เจเจพเจเจฆเฉ เจนเฉ เจ
เจคเฉ เจกเฉเจเจพ เจฆเจพ เจ
เจเจฒเจพ เจฌเจฒเจพเจ เจญเฉเจเจฟเจ เจเจพเจเจฆเจพ เจนเฉเฅค
เจชเฉเจฐเจพเจชเจค เจเจฐเจจ เจตเจพเจฒเจพ เจชเฉฑเจ เจชเฉเจเจ เจชเฉเจฐเจพเจชเจค เจเจฐเจฆเจพ เจนเฉเฅค เจนเจฐเฉเจ เจชเฉเจเฉเจ เจฆเฉ เจเจพเจเจ เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเฉ เจเจฟ เจเฉ เจเจน เจเฉเจฐเจพเจเจธเจฎเจฟเจธเจผเจจ เจตเจฟเฉฐเจกเฉ เจฆเฉ เจ
เฉฐเจฆเจฐ เจเจเจเจฆเจพ เจนเฉเฅค เจชเฉเจเจ เจ
เจคเฉ เจกเฉเจชเจฒเฉเจเฉเจ เจเฉ เจตเจฟเฉฐเจกเฉ เจตเจฟเฉฑเจ เจจเจนเฉเจ เจเจเจเจฆเฉ เจนเจจ, เจซเจฟเจฒเจเจฐ เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเจจ. เจเจฟเจเจเจเจฟ เจเฉเจเจฐ เจตเจฟเฉฐเจกเฉ เจฆเจพ เจเจเจพเจฐ เจซเจฟเจเจธ เจเฉเจคเจพ เจเจฟเจ เจนเฉ เจ
เจคเฉ เจชเฉเจฐเจพเจชเจคเจเจฐเจคเจพ เจ
เจคเฉ เจญเฉเจเจฃ เจตเจพเจฒเฉ เจฒเจ เจเฉฑเจเฉ เจเจฟเจนเจพ เจนเฉ, เจคเจพเจ เจชเฉเจเฉเจเจพเจ เจฆเฉ เจเฉฑเจ เจฌเจฒเจพเจ เจฆเฉ เจฌเจฟเจจเจพเจ เจจเฉเจเจธเจพเจจ เจฆเฉ เจกเจฟเจฒเฉเจตเจฐ เจเฉเจคเฉ เจเจพเจฃ เจฆเฉ เจธเจฅเจฟเจคเฉ เจตเจฟเฉฑเจ, เจตเจฟเฉฐเจกเฉ เจจเฉเฉฐ เจกเฉเจเจพ เจฆเฉ เจ
เจเจฒเฉ เจฌเจฒเจพเจ เจฆเฉ เจชเฉเจเฉเจ เจชเฉเจฐเจพเจชเจค เจเจฐเจจ เจฒเจ เจธเจผเจฟเจซเจ เจเฉเจคเจพ เจเจพเจเจฆเจพ เจนเฉ เจ
เจคเฉ เจเฉฑเจ เจกเจฟเจฒเจฟเจตเจฐเฉ เจชเฉเจธเจผเจเฉ เจนเฉเฉฐเจฆเฉ เจนเฉเฅค เจญเฉเจเจฟเจเฅค เจเฉเจเจฐ เจตเจฟเฉฐเจกเฉ เจตเจฐเจ เจเจพเจเจฎเจฐ เจฆเฉเจเจฐเจพ เจจเจฟเจฐเจงเจพเจฐเจค เจธเจฎเฉเจ เจฆเฉ เจ
เฉฐเจฆเจฐ เจจเจนเฉเจ เจญเจฐเจฆเฉ เจนเฉ, เจคเจพเจ เจเฉฑเจ เจเจพเจเจ เจธเจผเฉเจฐเฉ เจเฉเจคเฉ เจเจพเจตเฉเจเฉ เจเจฟเจธ 'เจคเฉ เจชเฉเจเฉเจ เจกเจฟเจฒเฉเจตเจฐ เจจเจนเฉเจ เจเฉเจคเฉ เจเจ เจนเจจ เจ
เจคเฉ เจฆเฉเจฌเจพเจฐเจพ เจกเจฟเจฒเฉเจตเจฐเฉ เจฒเจ เจฌเฉเจจเจคเฉเจเจ เจญเฉเจเฉเจเจ เจเจพเจฃเจเฉเจเจเฅค
เจฐเฉเจเฉเจฐเจพเจเจธเจฎเจฟเจธเจผเจจ เจกเจพเจเจเจฐเจพเจฎ:
เจธเจฎเจพเจ เจธเจฎเจพเจชเจคเฉ เจ
เจคเฉ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจเจพเจเจฎเจฐ
เจเฉเจจเฉเจเจธเจผเจจ เจธเจฅเจพเจชเจค เจจเจพ เจนเฉเจฃ เจฆเฉ เจเจ เจเจพเจฐเจจ เจนเจจเฅค เจเจฆเจพเจนเจฐเจจ เจฒเจ, เจเฉเจเจฐ เจชเฉเจฐเจพเจชเจค เจเจฐเจจ เจตเจพเจฒเฉ เจชเจพเจฐเจเฉ เจเจซเจผเจฒเจพเจเจจ เจนเฉเฅค เจเจธ เจธเจฅเจฟเจคเฉ เจตเจฟเฉฑเจ, เจเจฆเฉเจ เจเฉฑเจ เจเฉเจจเฉเจเจธเจผเจจ เจธเจฅเจพเจชเจค เจเจฐเจจ เจฆเฉ เจเฉเจธเจผเจฟเจธเจผ เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเฉ, เจคเจพเจ เจเฉเจจเฉเจเจธเจผเจจ เจเจพเจเจฎเจเจเจ เจฆเฉเจเจฐเจพ เจฌเฉฐเจฆ เจนเฉ เจเจพเจตเฉเจเจพเฅค เจญเจฐเฉเจธเฉเจฎเฉฐเจฆ UDP เจธเจฅเจพเจชเจจ เจธเจฎเจพเจ เจธเจฎเจพเจชเจค เจเจฐเจจ เจฒเจ เจฆเฉ เจเจพเจเจฎเจฐ เจตเจฐเจคเจฆเจพ เจนเฉเฅค เจชเจนเจฟเจฒเจพ, เจตเจฐเจเจฟเฉฐเจ เจเจพเจเจฎเจฐ, เจฐเจฟเจฎเฉเจ เจนเฉเจธเจ เจคเฉเจ เจเจตเจพเจฌ เจฆเฉ เจเจกเฉเจ เจเจฐเจจ เจฒเจ เจตเจฐเจคเจฟเจ เจเจพเจเจฆเจพ เจนเฉเฅค เจเฉ เจเจน เจญเฉเจเจฃ เจตเจพเจฒเฉ เจชเจพเจธเฉ เจซเจพเจเจฐ เจเจฐเจฆเจพ เจนเฉ, เจคเจพเจ เจเจเจฐเฉ เจญเฉเจเจฟเจ เจเจฟเจ เจชเฉเจเฉเจ เจฆเฉเจฌเจพเจฐเจพ เจญเฉเจเจฟเจ เจเจพเจเจฆเจพ เจนเฉเฅค เจเฉเจเจฐ เจชเฉเจฐเจพเจชเจคเจเจฐเจคเจพ 'เจคเฉ เจเจพเจเจฎเจฐ เจฆเฉ เจฎเจฟเจเจฆ เจชเฉเฉฑเจ เจเจพเจเจฆเฉ เจนเฉ, เจคเจพเจ เจเฉเฉฐเจฎ เจนเฉเจ เจชเฉเจเฉเจเจพเจ เจฆเฉ เจเจพเจเจ เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเฉ เจ เจคเฉ เจฎเฉเฉ เจกเจฟเจฒเฉเจตเจฐเฉ เจฒเจ เจฌเฉเจจเจคเฉเจเจ เจญเฉเจเฉเจเจ เจเจพเจเจฆเฉเจเจ เจนเจจเฅค
เจจเฉเจกเจพเจ เจตเจฟเจเจเจพเจฐ เจธเฉฐเจเจพเจฐ เจฆเฉ เจเจพเจ เจฆเฉ เจธเจฅเจฟเจคเฉ เจตเจฟเฉฑเจ เจเฉเจจเฉเจเจธเจผเจจ เจจเฉเฉฐ เจฌเฉฐเจฆ เจเจฐเจจ เจฒเจ เจฆเฉเจเฉ เจเจพเจเจฎเจฐ เจฆเฉ เจฒเฉเฉ เจนเฉเฉฐเจฆเฉ เจนเฉ. เจญเฉเจเจฃ เจตเจพเจฒเฉ เจชเจพเจธเฉ เจฒเจ, เจเจน เจเฉฐเจฎ เจเจฐเจจ เจตเจพเจฒเฉ เจเจพเจเจฎเจฐ เจฆเฉ เจฎเจฟเจเจฆ เจชเฉเฉฑเจเจฃ เจคเฉเจ เจคเฉเจฐเฉฐเจค เจฌเจพเจ เจฆ เจธเจผเฉเจฐเฉ เจนเฉเฉฐเจฆเจพ เจนเฉ, เจ เจคเฉ เจฐเจฟเจฎเฉเจ เจจเฉเจก เจคเฉเจ เจเจตเจพเจฌ เจฆเฉ เจเจกเฉเจ เจเจฐเจฆเจพ เจนเฉเฅค เจเฉเจเจฐ เจจเจฟเจธเจผเจเจฟเจค เจฎเจฟเจเจฆ เจฆเฉ เจ เฉฐเจฆเจฐ เจเฉเจ เจเจตเจพเจฌ เจจเจนเฉเจ เจฎเจฟเจฒเจฆเจพ, เจคเจพเจ เจเฉเจจเฉเจเจธเจผเจจ เจฌเฉฐเจฆ เจเจฐ เจฆเจฟเฉฑเจคเจพ เจเจพเจเจฆเจพ เจนเฉ เจ เจคเฉ เจธเจฐเฉเจค เจเจพเจฐเฉ เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเจจเฅค เจชเฉเจฐเจพเจชเจค เจเจฐเจจ เจตเจพเจฒเฉ เจชเจพเจธเฉ เจฒเจ, เจเฉฐเจฎ เจฆเฉ เจเจพเจเจฎเจฐ เจฆเฉ เจฆเฉ เจตเจพเจฐ เจเจคเจฎ เจนเฉเจฃ เจคเฉเจ เจฌเจพเจ เจฆ เจเฉเจจเฉเจเจธเจผเจจ เจเจฒเฉเจเจผ เจเจพเจเจฎเจฐ เจเจพเจฒเฉ เจนเฉ เจเจพเจเจฆเจพ เจนเฉเฅค เจชเฉเจธเจผเจเฉเจเจฐเจจ เจชเฉเจเฉเจ เจฆเฉ เจจเฉเจเจธเจพเจจ เจคเฉเจ เจฌเจเจพเจ เจฒเจ เจเจน เจเจผเจฐเฉเจฐเฉ เจนเฉเฅค เจเจฆเฉเจ เจเจพเจเจฎเจฐ เจฆเฉ เจฎเจฟเจเจฆ เจชเฉเฉฑเจ เจเจพเจเจฆเฉ เจนเฉ, เจคเจพเจ เจเฉเจจเฉเจเจธเจผเจจ เจตเฉ เจฌเฉฐเจฆ เจนเฉ เจเจพเจเจฆเจพ เจนเฉ เจ เจคเฉ เจธเจฐเฉเจค เจเจพเจฐเฉ เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเจจเฅค
เจญเจฐเฉเจธเฉเจฏเฉเจ UDP เจเฉเจฐเจพเจเจธเจฎเจฟเจธเจผเจจ เจธเจเฉเจ เจกเจพเจเจเฉเจฐเจพเจฎ
เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฆเฉ เจธเจฟเจงเจพเจเจค เจเฉฑเจ เจธเฉเจฎเจฟเจค เจธเจเฉเจ เจฎเจธเจผเฉเจจ เจตเจฟเฉฑเจ เจฒเจพเจเฉ เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเจจ, เจเจฟเจธเจฆเฉ เจนเจฐเฉเจ เจ
เจตเจธเจฅเจพ เจชเฉเจเฉเจ เจชเฉเจฐเฉเจธเฉเจธเจฟเฉฐเจ เจฆเฉ เจเฉฑเจ เจเจพเจธ เจคเจฐเจ เจฒเจ เจเจผเจฟเฉฐเจฎเฉเจตเจพเจฐ เจนเฉเฉฐเจฆเฉ เจนเฉเฅค
เจญเจฐเฉเจธเฉเจฏเฉเจ UDP เจธเจเฉเจ เจกเจพเจเจเฉเจฐเจพเจฎ:
เจฌเฉฐเจฆ - เจ
เจธเจฒ เจตเจฟเฉฑเจ เจเฉฑเจ เจฐเจพเจ เจจเจนเฉเจ เจนเฉ, เจเจน เจเจเฉเจฎเฉเจเจจ เจฒเจ เจเฉฑเจ เจธเจผเฉเจฐเฉเจเจค เจ
เจคเฉ เจ
เฉฐเจค เจฌเจฟเฉฐเจฆเฉ เจนเฉเฅค เจฐเจพเจ เจฒเจ เจฌเฉฐเจฆ เจเฉฑเจ เจเจฐเจพเจเจธเจฎเจฟเจธเจผเจจ เจเฉฐเจเจฐเฉเจฒ เจฌเจฒเจพเจ เจชเฉเจฐเจพเจชเจค เจนเฉเฉฐเจฆเจพ เจนเฉ, เจเฉ, เจเฉฑเจ เจ
เจธเจฟเฉฐเจเจฐเฉเจจเจธ UDP เจธเจฐเจตเจฐ เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเจฆเฉ เจนเฉเจ, เจชเฉเจเฉเจเจพเจ เจจเฉเฉฐ เจเจเจฟเจค เจเฉเจจเฉเจเจธเจผเจจเจพเจ เจฒเจ เจ
เฉฑเจเฉ เจญเฉเจเจฆเจพ เจนเฉ เจ
เจคเฉ เจธเจเฉเจ เจชเฉเจฐเฉเจธเฉเจธเจฟเฉฐเจ เจธเจผเฉเจฐเฉ เจเจฐเจฆเจพ เจนเฉเฅค
FirstPacketSending - เจธเจผเฉเจฐเฉเจเจคเฉ เจธเจฅเจฟเจคเฉ เจเจฟเจธ เจตเจฟเฉฑเจ เจเจเจเจเฉเจเฉฐเจ เจเจจเฉเจเจธเจผเจจ เจเจฆเฉเจ เจนเฉเฉฐเจฆเจพ เจนเฉ เจเจฆเฉเจ เจธเฉเจจเฉเจนเจพ เจญเฉเจเจฟเจ เจเจพเจเจฆเจพ เจนเฉเฅค
เจเจธ เจธเจฅเจฟเจคเฉ เจตเจฟเฉฑเจ, เจเจฎ เจธเฉฐเจฆเฉเจธเจผเจพเจ เจฒเจ เจชเจนเจฟเจฒเจพ เจชเฉเจเฉเจ เจญเฉเจเจฟเจ เจเจพเจเจฆเจพ เจนเฉเฅค เจฌเจฟเจจเจพเจ เจญเฉเจเจฃ เจฆเฉ เจชเฉเจธเจผเจเฉ เจฆเฉ เจธเฉเจจเฉเจนเจฟเจเจ เจฒเจ, เจเจน เจเฉฑเจเฉ เจเฉฑเจ เจธเจฅเจฟเจคเฉ เจนเฉ เจเจฟเฉฑเจฅเฉ เจชเฉเจฐเจพ เจธเฉเจจเฉเจนเจพ เจญเฉเจเจฟเจ เจเจพเจเจฆเจพ เจนเฉเฅค
เจญเฉเจเจฃ เจฆเจพ เจเฉฑเจเจฐ - เจธเฉฐเจฆเฉเจธเจผ เจชเฉเจเฉเจ เจฆเฉ เจชเฉเจฐเจธเจพเจฐเจฃ เจฒเจ เจเจผเจฎเฉเจจเฉ เจธเจฅเจฟเจคเฉเฅค
เจฐเจพเจ เจคเฉเจ เจเจธ เจตเจฟเฉฑเจ เจคเจฌเจฆเฉเจฒเฉ FirstPacketSending เจธเฉฐเจฆเฉเจธเจผ เจฆเจพ เจชเจนเจฟเจฒเจพ เจชเฉเจเฉเจ เจญเฉเจเฉ เจเจพเจฃ เจคเฉเจ เจฌเจพเจ เจฆ เจเฉเจคเจพ เจเจฟเจเฅค เจเจน เจเจธ เจธเจฅเจฟเจคเฉ เจตเจฟเฉฑเจ เจนเฉ เจเจฟ เจฐเฉเจเฉเจฐเจพเจเจธเจฎเจฟเจธเจผเจจ เจฒเจ เจธเจพเจฐเฉเจเจ เจฎเจพเจจเจคเจพเจตเจพเจ เจ เจคเฉ เจฌเฉเจจเจคเฉเจเจ เจเจเจเจฆเฉเจเจ เจนเจจ. เจเจธ เจคเฉเจ เจฌเจพเจนเจฐ เจจเจฟเจเจฒเจฃเจพ เจฆเฉ เจฎเจพเจฎเจฒเจฟเจเจ เจตเจฟเฉฑเจ เจธเฉฐเจญเจต เจนเฉ - เจธเฉฐเจฆเฉเจธเจผ เจฆเฉ เจธเจซเจฒ เจกเจฟเจฒเฉเจตเจฐเฉ เจฆเฉ เจฎเจพเจฎเจฒเฉ เจตเจฟเฉฑเจ เจเจพเจ เจธเจฎเจพเจ เจธเจฎเจพเจชเจค เจนเฉเจฃ เจฆเฉ เจฎเจพเจฎเจฒเฉ เจตเจฟเฉฑเจเฅค
เจชเจนเจฟเจฒเจพ เจชเฉเจเฉเจ เจชเฉเจฐเจพเจชเจค เจนเฉเจเจ - เจธเฉเจจเฉเจนเฉ เจฆเฉ เจชเฉเจฐเจพเจชเจคเจเจฐเจคเจพ เจฒเจ เจธเจผเฉเจฐเฉเจเจคเฉ เจธเจฅเจฟเจคเฉเฅค
เจเจน เจชเฉเจฐเจธเจพเจฐเจฃ เจฆเฉ เจธเจผเฉเจฐเฉเจเจค เจฆเฉ เจธเจผเฉเฉฑเจงเจคเจพ เจฆเฉ เจเจพเจเจ เจเจฐเจฆเจพ เจนเฉ, เจฒเฉเฉเฉเจเจฆเฉ เจขเจพเจเจเฉ เจฌเจฃเจพเจเจเจฆเจพ เจนเฉ, เจ เจคเฉ เจชเจนเจฟเจฒเฉ เจชเฉเจเฉเจ เจฆเฉ เจฐเจธเฉเจฆ เจฆเฉ เจฐเจธเฉเจฆ เจญเฉเจเจฆเจพ เจนเฉ.
เจเฉฑเจ เจธเฉเจจเฉเจนเฉ เจฒเจ เจเจฟเจธ เจตเจฟเฉฑเจ เจเฉฑเจ เจธเจฟเฉฐเจเจฒ เจชเฉเจเฉเจ เจนเฉเฉฐเจฆเจพ เจนเฉ เจ เจคเฉ เจกเจฟเจฒเฉเจตเจฐเฉ เจฆเฉ เจธเจฌเฉเจค เจฆเฉ เจตเจฐเจคเฉเจ เจเฉเจคเฉ เจฌเจฟเจจเจพเจ เจญเฉเจเจฟเจ เจเจฟเจ เจธเฉ, เจเจน เจเฉฑเจเฉ เจเฉฑเจ เจฐเจพเจ เจนเฉเฅค เจ เจเจฟเจนเฉ เจธเฉฐเจฆเฉเจธเจผ เจฆเฉ เจชเฉเจฐเจเจฟเจฐเจฟเจ เจเจฐเจจ เจคเฉเจ เจฌเจพเจ เจฆ, เจเฉเจจเฉเจเจธเจผเจจ เจฌเฉฐเจฆ เจนเฉ เจเจพเจเจฆเจพ เจนเฉเฅค
เจเจเฉฑเจ เฉ เจนเฉเจฃเจพ - เจธเฉเจจเฉเจนเจพ เจชเฉเจเฉเจ เจชเฉเจฐเจพเจชเจค เจเจฐเจจ เจฒเจ เจฎเฉเจฒ เจธเจฅเจฟเจคเฉเฅค
เจเจน เจ เจธเจฅเจพเจ เจธเจเฉเจฐเฉเจ เจฒเจ เจชเฉเจเฉเจ เจฒเจฟเจเจฆเจพ เจนเฉ, เจชเฉเจเฉเจ เจฆเฉ เจจเฉเจเจธเจพเจจ เจฆเฉ เจเจพเจเจ เจเจฐเจฆเจพ เจนเฉ, เจชเฉเจเฉเจเจพเจ เจฆเฉ เจเฉฑเจ เจฌเจฒเจพเจ เจ เจคเฉ เจชเฉเจฐเฉ เจธเฉฐเจฆเฉเจธเจผ เจฆเฉ เจกเจฟเจฒเจฟเจตเจฐเฉ เจฒเจ เจฐเจธเฉเจฆ เจญเฉเจเจฆเจพ เจนเฉ, เจ เจคเฉ เจเฉเฉฐเจฎ เจนเฉเจ เจชเฉเจเฉเจเจพเจ เจฆเฉ เจฎเฉเฉ เจกเจฟเจฒเฉเจตเจฐเฉ เจฒเจ เจฌเฉเจจเจคเฉเจเจ เจญเฉเจเจฆเจพ เจนเฉเฅค เจชเฉเจฐเฉ เจธเฉเจจเฉเจนเฉ เจฆเฉ เจธเจซเจฒเจคเจพเจชเฉเจฐเจตเจ เจชเฉเจฐเจพเจชเจคเฉ เจฆเฉ เจธเจฅเจฟเจคเฉ เจตเจฟเฉฑเจ, เจเฉเจจเฉเจเจธเจผเจจ เจฐเจพเจ เจตเจฟเฉฑเจ เจเจฒเจพ เจเจพเจเจฆเจพ เจนเฉ เจฎเฉเจเฉฐเจฎเจฒ, เจจเจนเฉเจ เจคเจพเจ, เจเฉฑเจ เจธเจฎเจพเจ เจธเจฎเจพเจชเจค เจนเฉ เจเจพเจเจฆเจพ เจนเฉเฅค
เจฎเฉเจเฉฐเจฎเจฒ - เจชเฉเจฐเฉ เจธเฉเจจเฉเจนเฉ เจฆเฉ เจธเจซเจฒเจคเจพเจชเฉเจฐเจตเจ เจชเฉเจฐเจพเจชเจคเฉ เจฆเฉ เจธเจฅเจฟเจคเฉ เจตเจฟเฉฑเจ เจเฉเจจเฉเจเจธเจผเจจ เจฌเฉฐเจฆ เจเจฐเจจเจพเฅค
เจเจน เจธเจฅเจฟเจคเฉ เจธเฉเจจเฉเจนเฉ เจฆเฉ เจ เจธเฉเจเจฌเจฒเฉ เจฒเจ เจ เจคเฉ เจเจธ เจเฉเจธ เจฒเจ เจเจผเจฐเฉเจฐเฉ เจนเฉ เจเจฆเฉเจ เจญเฉเจเจฃ เจตเจพเจฒเฉ เจฆเฉ เจฐเจธเจคเฉ เจตเจฟเฉฑเจ เจธเฉฐเจฆเฉเจธเจผ เจฆเฉ เจกเจฟเจฒเจฟเจตเจฐเฉ เจชเฉเจธเจผเจเฉ เจเจคเจฎ เจนเฉ เจเจ เจธเฉเฅค เจเจน เจ เจตเจธเจฅเจพ เจเฉฑเจ เจธเจฎเจพเจ เจธเจฎเจพเจชเจคเฉ เจฆเฉเจเจฐเจพ เจฌเจพเจนเจฐ เจ เจเจพเจเจฆเฉ เจนเฉ, เจชเจฐ เจเจจเฉเจเจธเจผเจจ เจจเฉเฉฐ เจธเจซเจฒเจคเจพเจชเฉเจฐเจตเจ เจฌเฉฐเจฆ เจฎเฉฐเจจเจฟเจ เจเจพเจเจฆเจพ เจนเฉเฅค
เจเฉเจก เจตเจฟเฉฑเจ เจกเฉเฉฐเจเฉ. เจธเฉฐเจเจพเจฐ เจเฉฐเจเจฐเฉเจฒ เจฏเฉเจจเจฟเจ
เจญเจฐเฉเจธเฉเจฏเฉเจ UDP เจฆเฉ เจฎเฉเฉฑเจ เจคเฉฑเจคเจพเจ เจตเจฟเฉฑเจเฉเจ เจเฉฑเจ เจเฉเจฐเจพเจเจธเจฎเจฟเจธเจผเจจ เจเฉฐเจเจฐเฉเจฒ เจฌเจฒเจพเจ เจนเฉเฅค เจเจธ เจฌเจฒเจพเจ เจฆเจพ เจเฉฐเจฎ เจฎเฉเจเฉเจฆเจพ เจเจจเฉเจเจธเจผเจจเจพเจ เจ
เจคเฉ เจธเจนเจพเจเจ เจคเฉฑเจคเจพเจ เจจเฉเฉฐ เจธเจเฉเจฐ เจเจฐเจจเจพ, เจธเฉฐเจฌเฉฐเจงเจฟเจค เจเจจเฉเจเจธเจผเจจเจพเจ เจตเจฟเฉฑเจ เจเจเจฃ เจตเจพเจฒเฉ เจชเฉเจเฉเจเจพเจ เจจเฉเฉฐ เจตเฉฐเจกเจฃเจพ, เจเฉฑเจ เจเฉเจจเฉเจเจธเจผเจจ เจฒเจ เจชเฉเจเฉเจ เจญเฉเจเจฃ เจฒเจ เจเฉฑเจ เจเฉฐเจเจฐเจซเฉเจธ เจชเฉเจฐเจฆเจพเจจ เจเจฐเจจเจพ, เจ
เจคเฉ เจชเฉเจฐเฉเจเฉเจเฉเจฒ API เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเจจเจพ เจนเฉเฅค เจเจฐเจพเจเจธเจฎเจฟเจธเจผเจจ เจเฉฐเจเจฐเฉเจฒ เจฌเจฒเจพเจ UDP เจชเจฐเจค เจคเฉเจ เจชเฉเจเฉเจ เจชเฉเจฐเจพเจชเจค เจเจฐเจฆเจพ เจนเฉ เจ
เจคเฉ เจเจนเจจเจพเจ เจจเฉเฉฐ เจชเฉเจฐเฉเจธเฉเจธเจฟเฉฐเจ เจฒเจ เจธเจเฉเจ เจฎเจธเจผเฉเจจ เจจเฉเฉฐ เจ
เฉฑเจเฉ เจญเฉเจเจฆเจพ เจนเฉเฅค เจชเฉเจเฉเจ เจชเฉเจฐเจพเจชเจค เจเจฐเจจ เจฒเจ, เจเจน เจเฉฑเจ เจ
เจธเจฟเฉฐเจเฉเจฐเฉเจจเจธ UDP เจธเจฐเจตเจฐ เจฒเจพเจเฉ เจเจฐเจฆเจพ เจนเฉเฅค
ReliableUdpConnectionControlBlock เจเจฒเจพเจธ เจฆเฉ เจเฉเจ เจฎเฉเจเจฌเจฐ:
internal class ReliableUdpConnectionControlBlock : IDisposable
{
// ะผะฐััะธะฒ ะฑะฐะนั ะดะปั ัะบะฐะทะฐะฝะฝะพะณะพ ะบะปััะฐ. ะัะฟะพะปัะทัะตััั ะดะปั ัะฑะพัะบะธ ะฒั
ะพะดััะธั
ัะพะพะฑัะตะฝะธะน
public ConcurrentDictionary<Tuple<EndPoint, Int32>, byte[]> IncomingStreams { get; private set;}
// ะผะฐััะธะฒ ะฑะฐะนั ะดะปั ัะบะฐะทะฐะฝะฝะพะณะพ ะบะปััะฐ. ะัะฟะพะปัะทัะตััั ะดะปั ะพัะฟัะฐะฒะบะธ ะธัั
ะพะดััะธั
ัะพะพะฑัะตะฝะธะน.
public ConcurrentDictionary<Tuple<EndPoint, Int32>, byte[]> OutcomingStreams { get; private set; }
// connection record ะดะปั ัะบะฐะทะฐะฝะฝะพะณะพ ะบะปััะฐ.
private readonly ConcurrentDictionary<Tuple<EndPoint, Int32>, ReliableUdpConnectionRecord> m_listOfHandlers;
// ัะฟะธัะพะบ ะฟะพะดะฟะธััะธะบะพะฒ ะฝะฐ ัะพะพะฑัะตะฝะธั.
private readonly List<ReliableUdpSubscribeObject> m_subscribers;
// ะปะพะบะฐะปัะฝัะน ัะพะบะตั
private Socket m_socketIn;
// ะฟะพัั ะดะปั ะฒั
ะพะดััะธั
ัะพะพะฑัะตะฝะธะน
private int m_port;
// ะปะพะบะฐะปัะฝัะน IP ะฐะดัะตั
private IPAddress m_ipAddress;
// ะปะพะบะฐะปัะฝะฐั ะบะพะฝะตัะฝะฐั ัะพัะบะฐ
public IPEndPoint LocalEndpoint { get; private set; }
// ะบะพะปะปะตะบัะธั ะฟัะตะดะฒะฐัะธัะตะปัะฝะพ ะธะฝะธัะธะฐะปะธะทะธัะพะฒะฐะฝะฝัั
// ัะพััะพัะฝะธะน ะบะพะฝะตัะฝะพะณะพ ะฐะฒัะพะผะฐัะฐ
public StatesCollection States { get; private set; }
// ะณะตะฝะตัะฐัะพั ัะปััะฐะนะฝัั
ัะธัะตะป. ะัะฟะพะปัะทัะตััั ะดะปั ัะพะทะดะฐะฝะธั TransmissionId
private readonly RNGCryptoServiceProvider m_randomCrypto;
//...
}
เจ เจธเจฟเฉฐเจเฉเจฐเฉเจจเจธ UDP เจธเจฐเจตเจฐ เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเจจเจพ:
private void Receive()
{
EndPoint connectedClient = new IPEndPoint(IPAddress.Any, 0);
// ัะพะทะดะฐะตะผ ะฝะพะฒัะน ะฑััะตั, ะดะปั ะบะฐะถะดะพะณะพ socket.BeginReceiveFrom
byte[] buffer = new byte[DefaultMaxPacketSize + ReliableUdpHeader.Length];
// ะฟะตัะตะดะฐะตะผ ะฑััะตั ะฒ ะบะฐัะตััะฒะต ะฟะฐัะฐะผะตััะฐ ะดะปั ะฐัะธะฝั
ัะพะฝะฝะพะณะพ ะผะตัะพะดะฐ
this.m_socketIn.BeginReceiveFrom(buffer, 0, buffer.Length, SocketFlags.None, ref connectedClient, EndReceive, buffer);
}
private void EndReceive(IAsyncResult ar)
{
EndPoint connectedClient = new IPEndPoint(IPAddress.Any, 0);
int bytesRead = this.m_socketIn.EndReceiveFrom(ar, ref connectedClient);
//ะฟะฐะบะตั ะฟะพะปััะตะฝ, ะณะพัะพะฒั ะฟัะธะฝะธะผะฐัั ัะปะตะดัััะธะน
Receive();
// ั.ะบ. ะฟัะพััะตะนัะธะน ัะฟะพัะพะฑ ัะตัะธัั ะฒะพะฟัะพั ั ะฑััะตัะพะผ - ะฟะพะปััะธัั ัััะปะบั ะฝะฐ ะฝะตะณะพ
// ะธะท IAsyncResult.AsyncState
byte[] bytes = ((byte[]) ar.AsyncState).Slice(0, bytesRead);
// ะฟะพะปััะฐะตะผ ะทะฐะณะพะปะพะฒะพะบ ะฟะฐะบะตัะฐ
ReliableUdpHeader header;
if (!ReliableUdpStateTools.ReadReliableUdpHeader(bytes, out header))
{
// ะฟัะธัะตะป ะฝะตะบะพััะตะบัะฝัะน ะฟะฐะบะตั - ะพัะฑัะฐััะฒะฐะตะผ ะตะณะพ
return;
}
// ะบะพะฝััััะธััะตะผ ะบะปัั ะดะปั ะพะฟัะตะดะตะปะตะฝะธั connection recordโะฐ ะดะปั ะฟะฐะบะตัะฐ
Tuple<EndPoint, Int32> key = new Tuple<EndPoint, Int32>(connectedClient, header.TransmissionId);
// ะฟะพะปััะฐะตะผ ัััะตััะฒััััั connection record ะธะปะธ ัะพะทะดะฐะตะผ ะฝะพะฒัั
ReliableUdpConnectionRecord record = m_listOfHandlers.GetOrAdd(key, new ReliableUdpConnectionRecord(key, this, header.ReliableUdpMessageType));
// ะทะฐะฟััะบะฐะตะผ ะฟะฐะบะตั ะฒ ะพะฑัะฐะฑะพัะบั ะฒ ะบะพะฝะตัะฝัะน ะฐะฒัะพะผะฐั
record.State.ReceivePacket(record, header, bytes);
}
เจนเจฐเฉเจ เจธเฉเจจเฉเจนเจพ เจเฉเจฐเจพเจเจธเจซเจฐ เจฒเจ, เจเฉฑเจ เจขเจพเจเจเจพ เจฌเจฃเจพเจเจ เจเจพเจเจฆเจพ เจนเฉ เจเจฟเจธ เจตเจฟเฉฑเจ เจเฉเจจเฉเจเจธเจผเจจ เจฌเจพเจฐเฉ เจเจพเจฃเจเจพเจฐเฉ เจนเฉเฉฐเจฆเฉ เจนเฉเฅค เจ
เจเจฟเจนเฉ เจฌเจฃเจคเจฐ เจจเฉเฉฐ เจเจฟเจนเจพ เจเจพเจเจฆเจพ เจนเฉ เจเฉเจจเฉเจเจธเจผเจจ เจฐเจฟเจเจพเจฐเจก.
ReliableUdpConnectionRecord เจเจฒเจพเจธ เจฆเฉ เจเฉเจ เจฎเฉเจเจฌเจฐ:
internal class ReliableUdpConnectionRecord : IDisposable
{
// ะผะฐััะธะฒ ะฑะฐะนั ั ัะพะพะฑัะตะฝะธะตะผ
public byte[] IncomingStream { get; set; }
// ัััะปะบะฐ ะฝะฐ ัะพััะพัะฝะธะต ะบะพะฝะตัะฝะพะณะพ ะฐะฒัะพะผะฐัะฐ
public ReliableUdpState State { get; set; }
// ะฟะฐัะฐ, ะพะดะฝะพะทะฝะฐัะฝะพ ะพะฟัะตะดะตะปัััะฐั connection record
// ะฒ ะฑะปะพะบะต ัะฟัะฐะฒะปะตะฝะธั ะฟะตัะตะดะฐัะตะน
public Tuple<EndPoint, Int32> Key { get; private set;}
// ะฝะธะถะฝัั ะณัะฐะฝะธัะฐ ะฟัะธะตะผะฝะพะณะพ ะพะบะฝะฐ
public int WindowLowerBound;
// ัะฐะทะผะตั ะพะบะฝะฐ ะฟะตัะตะดะฐัะธ
public readonly int WindowSize;
// ะฝะพะผะตั ะฟะฐะบะตัะฐ ะดะปั ะพัะฟัะฐะฒะบะธ
public int SndNext;
// ะบะพะปะธัะตััะฒะพ ะฟะฐะบะตัะพะฒ ะดะปั ะพัะฟัะฐะฒะบะธ
public int NumberOfPackets;
// ะฝะพะผะตั ะฟะตัะตะดะฐัะธ (ะธะผะตะฝะฝะพ ะพะฝ ะธ ะตััั ะฒัะพัะฐั ัะฐััั Tuple)
// ะดะปั ะบะฐะถะดะพะณะพ ัะพะพะฑัะตะฝะธั ัะฒะพะน
public readonly Int32 TransmissionId;
// ัะดะฐะปะตะฝะฝัะน IP endpoint โ ัะพะฑััะฒะตะฝะฝะพ ะฟะพะปััะฐัะตะปั ัะพะพะฑัะตะฝะธั
public readonly IPEndPoint RemoteClient;
// ัะฐะทะผะตั ะฟะฐะบะตัะฐ, ะฒะพ ะธะทะฑะตะถะฐะฝะธะต ััะฐะณะผะตะฝัะฐัะธะธ ะฝะฐ IP ััะพะฒะฝะต
// ะฝะต ะดะพะปะถะตะฝ ะฟัะตะฒััะฐัั MTU โ (IP.Header + UDP.Header + RelaibleUDP.Header)
public readonly int BufferSize;
// ะฑะปะพะบ ัะฟัะฐะฒะปะตะฝะธั ะฟะตัะตะดะฐัะตะน
public readonly ReliableUdpConnectionControlBlock Tcb;
// ะธะฝะบะฐะฟััะปะธััะตั ัะตะทัะปััะฐัั ะฐัะธะฝั
ัะพะฝะฝะพะน ะพะฟะตัะฐัะธะธ ะดะปั BeginSendMessage/EndSendMessage
public readonly AsyncResultSendMessage AsyncResult;
// ะฝะต ะพัะฟัะฐะฒะปััั ะฟะฐะบะตัั ะฟะพะดัะฒะตัะถะดะตะฝะธั
public bool IsNoAnswerNeeded;
// ะฟะพัะปะตะดะฝะธะน ะบะพััะตะบัะฝะพ ะฟะพะปััะตะฝะฝัะน ะฟะฐะบะตั (ะฒัะตะณะดะฐ ัััะฐะฝะฐะฒะปะธะฒะฐะตััั ะฒ ะฝะฐะธะฑะพะปััะธะน ะฝะพะผะตั)
public int RcvCurrent;
// ะผะฐััะธะฒ ั ะฝะพะผะตัะฐะผะธ ะฟะพัะตััะฝะฝัั
ะฟะฐะบะตัะพะฒ
public int[] LostPackets { get; private set; }
// ะฟัะธัะตะป ะปะธ ะฟะพัะปะตะดะฝะธะน ะฟะฐะบะตั. ะัะฟะพะปัะทัะตััั ะบะฐะบ bool.
public int IsLastPacketReceived = 0;
//...
}
เจเฉเจก เจตเจฟเฉฑเจ เจกเฉเฉฐเจเฉ. เจฐเจพเจ
เจฐเจพเจ เจญเจฐเฉเจธเฉเจฏเฉเจ UDP เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฆเฉ เจฐเจพเจ เจฎเจธเจผเฉเจจ เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเจฆเฉ เจนเจจ, เจเจฟเฉฑเจฅเฉ เจชเฉเจเจเจพเจ เจฆเฉ เจฎเฉเฉฑเจ เจชเฉเจฐเจเจฟเจฐเจฟเจ เจนเฉเฉฐเจฆเฉ เจนเฉเฅค เจเจฌเจธเจเจฐเฉเจเจ เจเจฒเจพเจธ ReliableUdpState เจฐเจพเจ เจฒเจ เจเฉฑเจ เจเฉฐเจเจฐเจซเฉเจธ เจชเฉเจฐเจฆเจพเจจ เจเจฐเจฆเจพ เจนเฉ:
เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฆเจพ เจธเจพเจฐเจพ เจคเจฐเจ เจเจชเจฐเฉเจเจค เจชเฉเจธเจผ เจเฉเจคเฉเจเจ เจเจฒเจพเจธเจพเจ เจฆเฉเจเจฐเจพ เจฒเจพเจเฉ เจเฉเจคเจพ เจเจพเจเจฆเจพ เจนเฉ, เจเฉฑเจ เจธเจนเจพเจเจ เจเจฒเจพเจธ เจฆเฉ เจจเจพเจฒ เจเฉ เจธเจฅเจฟเจฐ เจตเจฟเจงเฉเจเจ เจชเฉเจฐเจฆเจพเจจ เจเจฐเจฆเจพ เจนเฉ, เจเจฟเจตเฉเจ เจเจฟ, เจเจจเฉเจเจธเจผเจจ เจฐเจฟเจเจพเจฐเจก เจคเฉเจ ReliableUdp เจธเจฟเจฐเจฒเฉเจ เจฆเจพ เจจเจฟเจฐเจฎเจพเจฃ เจเจฐเจจเจพเฅค
เจ เฉฑเจเฉ, เจ เจธเฉเจ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฆเฉ เจฌเฉเจจเจฟเจเจฆเฉ เจเจฒเจเฉเจฐเจฟเจฆเจฎ เจจเฉเฉฐ เจจเจฟเจฐเจงเจพเจฐเจค เจเจฐเจจ เจตเจพเจฒเฉ เจเฉฐเจเจฐเจซเฉเจธ เจคเจฐเฉเจเจฟเจเจ เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเจจ เจฌเจพเจฐเฉ เจตเจฟเจธเจฅเจพเจฐ เจตเจฟเฉฑเจ เจตเจฟเจเจพเจฐ เจเจฐเจพเจเจเฉเฅค
DisposeByTimeout เจขเฉฐเจ
DisposeByTimeout เจตเจฟเจงเฉ เจธเจฎเจพเจ เจธเจฎเจพเจชเจค เจนเฉเจฃ เจคเฉเจ เจฌเจพเจ
เจฆ เจเจจเฉเจเจธเจผเจจ เจธเจฐเฉเจคเจพเจ เจจเฉเฉฐ เจเจพเจฐเฉ เจเจฐเจจ เจ
เจคเฉ เจธเจซเจฒ/เจ
เจธเจซเจฒ เจธเฉฐเจฆเฉเจธเจผ เจกเจฟเจฒเฉเจตเจฐเฉ เจฆเฉ เจธเฉฐเจเฉเจค เจฆเฉเจฃ เจฒเจ เจเจผเจฟเฉฐเจฎเฉเจตเจพเจฐ เจนเฉเฅค
ReliableUdpState.DisposeByTimeout:
protected virtual void DisposeByTimeout(object record)
{
ReliableUdpConnectionRecord connectionRecord = (ReliableUdpConnectionRecord) record;
if (record.AsyncResult != null)
{
connectionRecord.AsyncResult.SetAsCompleted(false);
}
connectionRecord.Dispose();
}
เจเจน เจธเจฟเจฐเจซ เจฐเจพเจ เจตเจฟเฉฑเจ เจเจตเจฐเจฐเจพเจเจก เจนเฉ เจฎเฉเจเฉฐเจฎเจฒ.
เจชเฉเจฐเจพ เจนเฉเจเจเฅคDisposeByTimeout:
protected override void DisposeByTimeout(object record)
{
ReliableUdpConnectionRecord connectionRecord = (ReliableUdpConnectionRecord) record;
// ัะพะพะฑัะฐะตะผ ะพะฑ ััะฟะตัะฝะพะผ ะฟะพะปััะตะฝะธะธ ัะพะพะฑัะตะฝะธั
SetAsCompleted(connectionRecord);
}
เจชเฉเจฐเจเจฟเจฐเจฟเจ เจชเฉเจเฉเจ เจตเจฟเจงเฉ
ProcessPackets เจตเจฟเจงเฉ เจเฉฑเจ เจชเฉเจเฉเจ เจเจพเจ เจชเฉเจเฉเจเจพเจ เจฆเฉ เจตเจพเจงเฉ เจชเฉเจฐเจเจฟเจฐเจฟเจ เจฒเจ เจเจผเจฟเฉฐเจฎเฉเจตเจพเจฐ เจนเฉเฅค เจธเจฟเฉฑเจงเฉ เจเจพเจ เจชเฉเจเฉเจ เจตเฉเจ เจเจพเจเจฎเจฐ เจฆเฉเจเจฐเจพ เจเจพเจฒ เจเฉเจคเฉ เจเจเฅค
เจธเจฎเจฐเฉฑเจฅ เจเจเฉฑเจ เฉ เจนเฉเจฃเจพ เจตเจฟเจงเฉ เจจเฉเฉฐ เจเจตเจฐเจฐเจพเจเจก เจเฉเจคเจพ เจเจฟเจ เจนเฉ เจ
เจคเฉ เจเฉเฉฐเจฎ เจนเฉเจ เจชเฉเจเฉเจเจพเจ เจฆเฉ เจเจพเจเจ เจเจฐเจจ เจ
เจคเฉ เจฐเจพเจ เจตเจฟเฉฑเจ เจคเจฌเจฆเฉเจฒ เจเจฐเจจ เจฒเจ เจเจผเจฟเฉฐเจฎเฉเจตเจพเจฐ เจนเฉ เจฎเฉเจเฉฐเจฎเจฒ, เจเจเจฐเฉ เจชเฉเจเฉเจ เจชเฉเจฐเจพเจชเจค เจเจฐเจจ เจ
เจคเฉ เจธเจซเจฒ เจเจพเจเจ เจชเจพเจธ เจเจฐเจจ เจฆเฉ เจฎเจพเจฎเจฒเฉ เจตเจฟเฉฑเจ
เจ
เจธเฉเจเจฌเจฒเจฟเฉฐเจ.เจชเฉเจฐเฉเจธเฉเจธ เจชเฉเจเฉเจ:
public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
if (connectionRecord.IsDone != 0)
return;
if (!ReliableUdpStateTools.CheckForNoPacketLoss(connectionRecord, connectionRecord.IsLastPacketReceived != 0))
{
// ะตััั ะฟะพัะตััะฝะฝัะต ะฟะฐะบะตัั, ะพัััะปะฐะตะผ ะทะฐะฟัะพัั ะฝะฐ ะฝะธั
foreach (int seqNum in connectionRecord.LostPackets)
{
if (seqNum != 0)
{
ReliableUdpStateTools.SendAskForLostPacket(connectionRecord, seqNum);
}
}
// ัััะฐะฝะฐะฒะปะธะฒะฐะตะผ ัะฐะนะผะตั ะฒะพ ะฒัะพัะพะน ัะฐะท, ะดะปั ะฟะพะฒัะพัะฝะพะน ะฟะพะฟััะบะธ ะฟะตัะตะดะฐัะธ
if (!connectionRecord.TimerSecondTry)
{
connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
connectionRecord.TimerSecondTry = true;
return;
}
// ะตัะปะธ ะฟะพัะปะต ะดะฒัั
ะฟะพะฟััะพะบ ััะฐะฑะฐััะฒะฐะฝะธะน WaitForPacketTimer
// ะฝะต ัะดะฐะปะพัั ะฟะพะปััะธัั ะฟะฐะบะตัั - ะทะฐะฟััะบะฐะตะผ ัะฐะนะผะตั ะทะฐะฒะตััะตะฝะธั ัะพะตะดะธะฝะตะฝะธั
StartCloseWaitTimer(connectionRecord);
}
else if (connectionRecord.IsLastPacketReceived != 0)
// ััะฟะตัะฝะฐั ะฟัะพะฒะตัะบะฐ
{
// ะฒัััะปะฐะตะผ ะฟะพะดัะฒะตัะถะดะตะฝะธะต ะพ ะฟะพะปััะตะฝะธะธ ะฑะปะพะบะฐ ะดะฐะฝะฝัั
ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
connectionRecord.State = connectionRecord.Tcb.States.Completed;
connectionRecord.State.ProcessPackets(connectionRecord);
// ะฒะผะตััะพ ะผะพะผะตะฝัะฐะปัะฝะพะน ัะตะฐะปะธะทะฐัะธะธ ัะตััััะพะฒ
// ะทะฐะฟััะบะฐะตะผ ัะฐะนะผะตั, ะฝะฐ ัะปััะฐะน, ะตัะปะธ
// ะตัะปะธ ะฟะพัะปะตะดะฝะธะน ack ะฝะต ะดะพะนะดะตั ะดะพ ะพัะฟัะฐะฒะธัะตะปั ะธ ะพะฝ ะทะฐะฟัะพัะธั ะตะณะพ ัะฝะพะฒะฐ.
// ะฟะพ ััะฐะฑะฐััะฒะฐะฝะธั ัะฐะนะผะตัะฐ - ัะตะฐะปะธะทัะตะผ ัะตััััั
// ะฒ ัะพััะพัะฝะธะธ Completed ะผะตัะพะด ัะฐะนะผะตัะฐ ะฟะตัะตะพะฟัะตะดะตะปะตะฝ
StartCloseWaitTimer(connectionRecord);
}
// ััะพ ัะปััะฐะน, ะบะพะณะดะฐ ack ะฝะฐ ะฑะปะพะบ ะฟะฐะบะตัะพะฒ ะฑัะป ะฟะพัะตััะฝ
else
{
if (!connectionRecord.TimerSecondTry)
{
ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
connectionRecord.TimerSecondTry = true;
return;
}
// ะทะฐะฟััะบะฐะตะผ ัะฐะนะผะตั ะทะฐะฒะตััะตะฝะธั ัะพะตะดะธะฝะตะฝะธั
StartCloseWaitTimer(connectionRecord);
}
}
เจธเจฎเจฐเฉฑเจฅ เจญเฉเจเจฃ เจฆเจพ เจเฉฑเจเจฐ เจเจธ เจตเจฟเจงเฉ เจจเฉเฉฐ เจธเจฟเจฐเจซเจผ เจเฉฑเจ เจเจพเจเจฎเจฐ 'เจคเฉ เจฌเฉเจฒเจพเจเจ เจเจพเจเจฆเจพ เจนเฉ, เจ
เจคเฉ เจเจเจฐเฉ เจธเฉฐเจฆเฉเจธเจผ เจจเฉเฉฐ เจฆเฉเจฌเจพเจฐเจพ เจญเฉเจเจฃ เจฆเฉ เจจเจพเจฒ-เจจเจพเจฒ เจเจจเฉเจเจธเจผเจจ เจเจฒเฉเจเจผ เจเจพเจเจฎเจฐ เจจเฉเฉฐ เจธเจฎเจฐเฉฑเจฅ เจเจฐเจจ เจฒเจ เจเจผเจฟเฉฐเจฎเฉเจตเจพเจฐ เจนเฉเฅค
SendingCycle.ProcessPackets:
public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
if (connectionRecord.IsDone != 0)
return;
// ะพัะฟัะฐะฒะปัะตะผ ะฟะพะฒัะพัะฝะพ ะฟะพัะปะตะดะฝะธะน ะฟะฐะบะตั
// ( ะฒ ัะปััะฐะต ะฒะพัััะฐะฝะพะฒะปะตะฝะธั ัะพะตะดะธะฝะตะฝะธั ัะทะตะป-ะฟัะธะตะผะฝะธะบ ะทะฐะฝะพะฒะพ ะพัะฟัะฐะฒะธั ะทะฐะฟัะพัั, ะบะพัะพััะต ะดะพ ะฝะตะณะพ ะฝะต ะดะพัะปะธ)
ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, connectionRecord.SndNext - 1));
// ะฒะบะปััะฐะตะผ ัะฐะนะผะตั CloseWait โ ะดะปั ะพะถะธะดะฐะฝะธั ะฒะพัััะฐะฝะพะฒะปะตะฝะธั ัะพะตะดะธะฝะตะฝะธั ะธะปะธ ะตะณะพ ะทะฐะฒะตััะตะฝะธั
StartCloseWaitTimer(connectionRecord);
}
เจธเจฎเจฐเฉฑเจฅ เจฎเฉเจเฉฐเจฎเจฒ เจตเจฟเจงเฉ เจเฉฑเจฒ เจฐเจนเฉ เจเจพเจเจฎเจฐ เจจเฉเฉฐ เจฐเฉเจเจฆเฉ เจนเฉ เจ
เจคเฉ เจเจพเจนเจเจพเจ เจจเฉเฉฐ เจธเฉเจจเฉเจนเจพ เจญเฉเจเจฆเฉ เจนเฉเฅค
เจฎเฉเจเฉฐเจฎเจฒเฅคเจชเฉเจฐเฉเจธเฉเจธ เจชเฉเจเฉเจ:
public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
if (connectionRecord.WaitForPacketsTimer != null)
connectionRecord.WaitForPacketsTimer.Dispose();
// ัะพะฑะธัะฐะตะผ ัะพะพะฑัะตะฝะธะต ะธ ะฟะตัะตะดะฐะตะผ ะตะณะพ ะฟะพะดะฟะธััะธะบะฐะผ
ReliableUdpStateTools.CreateMessageFromMemoryStream(connectionRecord);
}
เจชเฉเจเฉเจ เจตเจฟเจงเฉ เจชเฉเจฐเจพเจชเจค เจเจฐเฉ
เจธเจฎเจฐเฉฑเจฅ เจชเจนเจฟเจฒเจพ เจชเฉเจเฉเจ เจชเฉเจฐเจพเจชเจค เจนเฉเจเจ เจตเจฟเจงเฉ เจฆเจพ เจฎเฉเฉฑเจ เจเฉฐเจฎ เจเจน เจจเจฟเจฐเจงเจพเจฐเจค เจเจฐเจจเจพ เจนเฉ เจเจฟ เจเฉ เจชเจนเจฟเจฒเจพ เจธเฉเจจเฉเจนเจพ เจชเฉเจเฉเจ เจ
เจธเจฒ เจตเจฟเฉฑเจ เจเฉฐเจเจฐเจซเฉเจธ 'เจคเฉ เจเจเจ เจนเฉ, เจ
เจคเฉ เจเจน เจตเฉ เจเจฟ เจเฉฑเจ เจธเจฟเฉฐเจเจฒ เจชเฉเจเฉเจ เจตเจพเจฒเฉ เจธเฉฐเจฆเฉเจธเจผ เจจเฉเฉฐ เจเจเฉฑเจ เจพ เจเจฐเจจเจพ เจนเฉเฅค
FirstPacketReceived.ReceivePacket:
public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket))
// ะพัะฑัะฐััะฒะฐะตะผ ะฟะฐะบะตั
return;
// ะบะพะผะฑะธะฝะฐัะธั ะดะฒัั
ัะปะฐะณะพะฒ - FirstPacket ะธ LastPacket - ะณะพะฒะพัะธั ััะพ ั ะฝะฐั ะตะดะธะฝััะฒะตะฝะฝะพะต ัะพะพะฑัะตะฝะธะต
if (header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket) &
header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
{
ReliableUdpStateTools.CreateMessageFromSinglePacket(connectionRecord, header, payload.Slice(ReliableUdpHeader.Length, payload.Length));
if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.NoAsk))
{
// ะพัะฟัะฐะฒะปัะตะผ ะฟะฐะบะตั ะฟะพะดัะฒะตัะถะดะตะฝะธะต
ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
}
SetAsCompleted(connectionRecord);
return;
}
// by design ะฒัะต packet numbers ะฝะฐัะธะฝะฐัััั ั 0;
if (header.PacketNumber != 0)
return;
ReliableUdpStateTools.InitIncomingBytesStorage(connectionRecord, header);
ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
// ััะธัะฐะตะผ ะบะพะป-ะฒะพ ะฟะฐะบะตัะพะฒ, ะบะพัะพััะต ะดะพะปะถะฝั ะฟัะธะนัะธ
connectionRecord.NumberOfPackets = (int)Math.Ceiling((double) ((double) connectionRecord.IncomingStream.Length/(double) connectionRecord.BufferSize));
// ะทะฐะฟะธััะฒะฐะตะผ ะฝะพะผะตั ะฟะพัะปะตะดะฝะตะณะพ ะฟะพะปััะตะฝะฝะพะณะพ ะฟะฐะบะตัะฐ (0)
connectionRecord.RcvCurrent = header.PacketNumber;
// ะฟะพัะปะต ัะดะฒะธะฝัะปะธ ะพะบะฝะพ ะฟัะธะตะผะฐ ะฝะฐ 1
connectionRecord.WindowLowerBound++;
// ะฟะตัะตะบะปััะฐะตะผ ัะพััะพัะฝะธะต
connectionRecord.State = connectionRecord.Tcb.States.Assembling;
// ะตัะปะธ ะฝะต ััะตะฑัะตััั ะผะตั
ะฐะฝะธะทะผ ะฟะพะดัะฒะตัะถะดะตะฝะธะต
// ะทะฐะฟััะบะฐะตะผ ัะฐะนะผะตั ะบะพัะพััะน ะฒััะฒะพะฑะพะดะธั ะฒัะต ััััะบัััั
if (header.Flags.HasFlag(ReliableUdpHeaderFlags.NoAsk))
{
connectionRecord.CloseWaitTimer = new Timer(DisposeByTimeout, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
}
else
{
ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
}
}
เจธเจฎเจฐเฉฑเจฅ เจญเฉเจเจฃ เจฆเจพ เจเฉฑเจเจฐ เจเจธ เจตเจฟเจงเฉ เจจเฉเฉฐ เจกเจฟเจฒเฉเจตเจฐเฉ เจชเฉเจฐเจพเจชเจคเฉเจเจ เจ
เจคเฉ เจฎเฉเฉ เจชเฉเจฐเจธเจพเจฐเจฃ เจฌเฉเจจเจคเฉเจเจ เจจเฉเฉฐ เจธเจตเฉเจเจพเจฐ เจเจฐเจจ เจฒเจ เจเจตเจฐเจฐเจพเจเจก เจเฉเจคเจพ เจเจฟเจ เจนเฉเฅค
SendingCycle.ReceivePacket:
public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
if (connectionRecord.IsDone != 0)
return;
if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.RequestForPacket))
return;
// ัะฐััะตั ะบะพะฝะตัะฝะพะน ะณัะฐะฝะธัั ะพะบะฝะฐ
// ะฑะตัะตััั ะณัะฐะฝะธัะฐ ะพะบะฝะฐ + 1, ะดะปั ะฟะพะปััะตะฝะธั ะฟะพะดัะฒะตัะถะดะตะฝะธะน ะดะพััะฐะฒะบะธ
int windowHighestBound = Math.Min((connectionRecord.WindowLowerBound + connectionRecord.WindowSize), (connectionRecord.NumberOfPackets));
// ะฟัะพะฒะตัะบะฐ ะฝะฐ ะฟะพะฟะฐะดะฐะฝะธะต ะฒ ะพะบะฝะพ
if (header.PacketNumber < connectionRecord.WindowLowerBound || header.PacketNumber > windowHighestBound)
return;
connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
if (connectionRecord.CloseWaitTimer != null)
connectionRecord.CloseWaitTimer.Change(-1, -1);
// ะฟัะพะฒะตัะธัั ะฝะฐ ะฟะพัะปะตะดะฝะธะน ะฟะฐะบะตั:
if (header.PacketNumber == connectionRecord.NumberOfPackets)
{
// ะฟะตัะตะดะฐัะฐ ะทะฐะฒะตััะตะฝะฐ
Interlocked.Increment(ref connectionRecord.IsDone);
SetAsCompleted(connectionRecord);
return;
}
// ััะพ ะพัะฒะตั ะฝะฐ ะฟะตัะฒัะน ะฟะฐะบะตั c ะฟะพะดัะฒะตัะถะดะตะฝะธะตะผ
if ((header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket) && header.PacketNumber == 1))
{
// ะฑะตะท ัะดะฒะธะณะฐ ะพะบะฝะฐ
SendPacket(connectionRecord);
}
// ะฟัะธัะปะพ ะฟะพะดัะฒะตัะถะดะตะฝะธะต ะพ ะฟะพะปััะตะฝะธะธ ะฑะปะพะบะฐ ะดะฐะฝะฝัั
else if (header.PacketNumber == windowHighestBound)
{
// ัะดะฒะธะณะฐะตะผ ะพะบะฝะพ ะฟัะธะตะผ/ะฟะตัะตะดะฐัะธ
connectionRecord.WindowLowerBound += connectionRecord.WindowSize;
// ะพะฑะฝัะปัะตะผ ะผะฐััะธะฒ ะบะพะฝััะพะปั ะฟะตัะตะดะฐัะธ
connectionRecord.WindowControlArray.Nullify();
// ะพัะฟัะฐะฒะปัะตะผ ะฑะปะพะบ ะฟะฐะบะตัะพะฒ
SendPacket(connectionRecord);
}
// ััะพ ะทะฐะฟัะพั ะฝะฐ ะฟะพะฒัะพัะฝัั ะฟะตัะตะดะฐัั โ ะพัะฟัะฐะฒะปัะตะผ ััะตะฑัะตะผัะน ะฟะฐะบะตั
else
ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, header.PacketNumber));
}
เจธเจฎเจฐเฉฑเจฅ เจเจเฉฑเจ เฉ เจนเฉเจฃเจพ ReceivePacket เจตเจฟเจงเฉ เจตเจฟเฉฑเจ, เจเจเจฃ เจตเจพเจฒเฉ เจชเฉเจเฉเจเจพเจ เจคเฉเจ เจเฉฑเจ เจธเฉฐเจฆเฉเจธเจผ เจจเฉเฉฐ เจเจเฉฑเจ เจพ เจเจฐเจจ เจฆเจพ เจฎเฉเฉฑเจ เจเฉฐเจฎ เจนเฉเฉฐเจฆเจพ เจนเฉเฅค
เจ
เจธเฉเจเจฌเจฒเจฟเฉฐเจเฅค เจชเฉเจฐเจพเจชเจค เจชเฉเจเฉเจ:
public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
if (connectionRecord.IsDone != 0)
return;
// ะพะฑัะฐะฑะพัะบะฐ ะฟะฐะบะตัะพะฒ ั ะพัะบะปััะตะฝะฝัะผ ะผะตั
ะฐะฝะธะทะผะพะผ ะฟะพะดัะฒะตัะถะดะตะฝะธั ะดะพััะฐะฒะบะธ
if (header.Flags.HasFlag(ReliableUdpHeaderFlags.NoAsk))
{
// ัะฑัะฐััะฒะฐะตะผ ัะฐะนะผะตั
connectionRecord.CloseWaitTimer.Change(connectionRecord.LongTimerPeriod, -1);
// ะทะฐะฟะธััะฒะฐะตะผ ะดะฐะฝะฝัะต
ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
// ะตัะปะธ ะฟะพะปััะธะปะธ ะฟะฐะบะตั ั ะฟะพัะปะตะดะฝะธะผ ัะปะฐะณะพะผ - ะดะตะปะฐะตะผ ะทะฐะฒะตััะฐะตะผ
if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
{
connectionRecord.State = connectionRecord.Tcb.States.Completed;
connectionRecord.State.ProcessPackets(connectionRecord);
}
return;
}
// ัะฐััะตั ะบะพะฝะตัะฝะพะน ะณัะฐะฝะธัั ะพะบะฝะฐ
int windowHighestBound = Math.Min((connectionRecord.WindowLowerBound + connectionRecord.WindowSize - 1), (connectionRecord.NumberOfPackets - 1));
// ะพัะฑัะฐััะฒะฐะตะผ ะฝะต ะฟะพะฟะฐะดะฐััะธะต ะฒ ะพะบะฝะพ ะฟะฐะบะตัั
if (header.PacketNumber < connectionRecord.WindowLowerBound || header.PacketNumber > (windowHighestBound))
return;
// ะพัะฑัะฐััะฒะฐะตะผ ะดัะฑะปะธะบะฐัั
if (connectionRecord.WindowControlArray.Contains(header.PacketNumber))
return;
// ะทะฐะฟะธััะฒะฐะตะผ ะดะฐะฝะฝัะต
ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
// ัะฒะตะปะธัะธะฒะฐะตะผ ััะตััะธะบ ะฟะฐะบะตัะพะฒ
connectionRecord.PacketCounter++;
// ะทะฐะฟะธััะฒะฐะตะผ ะฒ ะผะฐััะธะฒ ัะฟัะฐะฒะปะตะฝะธั ะพะบะฝะพะผ ัะตะบััะธะน ะฝะพะผะตั ะฟะฐะบะตัะฐ
connectionRecord.WindowControlArray[header.PacketNumber - connectionRecord.WindowLowerBound] = header.PacketNumber;
// ัััะฐะฝะฐะฒะปะธะฒะฐะตะผ ะฝะฐะธะฑะพะปััะธะน ะฟัะธัะตะดัะธะน ะฟะฐะบะตั
if (header.PacketNumber > connectionRecord.RcvCurrent)
connectionRecord.RcvCurrent = header.PacketNumber;
// ะฟะตัะตะทะฐะฟััะบะฐะผ ัะฐะนะผะตัั
connectionRecord.TimerSecondTry = false;
connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
if (connectionRecord.CloseWaitTimer != null)
connectionRecord.CloseWaitTimer.Change(-1, -1);
// ะตัะปะธ ะฟัะธัะตะป ะฟะพัะปะตะดะฝะธะน ะฟะฐะบะตั
if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
{
Interlocked.Increment(ref connectionRecord.IsLastPacketReceived);
}
// ะตัะปะธ ะฝะฐะผ ะฟัะธัะปะธ ะฒัะต ะฟะฐะบะตัั ะพะบะฝะฐ, ัะพ ัะฑัะฐััะฒะฐะตะผ ััะตััะธะบ
// ะธ ะฒัััะปะฐะตะผ ะฟะฐะบะตั ะฟะพะดัะฒะตัะถะดะตะฝะธะต
else if (connectionRecord.PacketCounter == connectionRecord.WindowSize)
{
// ัะฑัะฐััะฒะฐะตะผ ััะตััะธะบ.
connectionRecord.PacketCounter = 0;
// ัะดะฒะธะฝัะปะธ ะพะบะฝะพ ะฟะตัะตะดะฐัะธ
connectionRecord.WindowLowerBound += connectionRecord.WindowSize;
// ะพะฑะฝัะปะตะฝะธะต ะผะฐััะธะฒะฐ ัะฟัะฐะฒะปะตะฝะธั ะฟะตัะตะดะฐัะตะน
connectionRecord.WindowControlArray.Nullify();
ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
}
// ะตัะปะธ ะฟะพัะปะตะดะฝะธะน ะฟะฐะบะตั ัะถะต ะธะผะตะตััั
if (Thread.VolatileRead(ref connectionRecord.IsLastPacketReceived) != 0)
{
// ะฟัะพะฒะตััะตะผ ะฟะฐะบะตัั
ProcessPackets(connectionRecord);
}
}
เจธเจฎเจฐเฉฑเจฅ เจฎเฉเจเฉฐเจฎเจฒ เจตเจฟเจงเฉ เจฆเจพ เจเฉฑเจเฉ เจเฉฑเจ เจเฉฐเจฎ เจธเฉเจจเฉเจนเฉ เจฆเฉ เจธเจซเจฒเจคเจพเจชเฉเจฐเจตเจ เจกเจฟเจฒเฉเจตเจฐเฉ เจฆเฉ เจฎเฉเฉ-เจธเจตเฉเจเฉเจฐเจฟเจคเฉ เจญเฉเจเจฃเจพ เจนเฉเฅค
เจชเฉเจฐเจพ เจนเฉเจเจเฅคเจชเฉเจเจ เจชเฉเจฐเจพเจชเจค เจเจฐเฉ:
public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
// ะฟะพะฒัะพัะฝะฐั ะพัะฟัะฐะฒะบะฐ ะฟะพัะปะตะดะฝะตะณะพ ะฟะฐะบะตัะฐ ะฒ ัะฒัะทะธ ั ัะตะผ,
// ััะพ ะฟะพัะปะตะดะฝะธะน ack ะฝะต ะดะพัะตะป ะดะพ ะพัะฟัะฐะฒะธัะตะปั
if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
{
ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
}
}
เจชเฉเจเฉเจ เจตเจฟเจงเฉ เจญเฉเจเฉ
เจธเจฎเจฐเฉฑเจฅ FirstPacketSending เจเจน เจตเจฟเจงเฉ เจกเฉเจเจพ เจฆเจพ เจชเจนเจฟเจฒเจพ เจชเฉเจเฉเจ เจญเฉเจเจฆเฉ เจนเฉ, เจเจพเจ เจเฉเจเจฐ เจธเฉฐเจฆเฉเจธเจผ เจจเฉเฉฐ เจกเจฟเจฒเฉเจตเจฐเฉ เจชเฉเจธเจผเจเฉ เจฆเฉ เจฒเฉเฉ เจจเจนเฉเจ เจนเฉ, เจคเจพเจ เจชเฉเจฐเจพ เจธเฉเจจเฉเจนเจพเฅค
FirstPacketSending.SendPacket:
public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{
connectionRecord.PacketCounter = 0;
connectionRecord.SndNext = 0;
connectionRecord.WindowLowerBound = 0;
// ะตัะปะธ ะฟะพะดัะฒะตัะถะดะตะฝะธั ะฝะต ััะตะฑัะตััั - ะพัะฟัะฐะฒะปัะตะผ ะฒัะต ะฟะฐะบะตัั
// ะธ ะฒััะฒะพะฑะพะถะดะฐะตะผ ัะตััััั
if (connectionRecord.IsNoAnswerNeeded)
{
// ะะดะตัั ะฟัะพะธัั
ะพะดะธั ะพัะฟัะฐะฒะบะฐ As Is
do
{
ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, ReliableUdpStateTools. CreateReliableUdpHeader(connectionRecord)));
connectionRecord.SndNext++;
} while (connectionRecord.SndNext < connectionRecord.NumberOfPackets);
SetAsCompleted(connectionRecord);
return;
}
// ัะพะทะดะฐะตะผ ะทะฐะณะพะปะพะฒะพะบ ะฟะฐะบะตัะฐ ะธ ะพัะฟัะฐะฒะปัะตะผ ะตะณะพ
ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord);
ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header));
// ัะฒะตะปะธัะธะฒะฐะตะผ ััะตััะธะบ
connectionRecord.SndNext++;
// ัะดะฒะธะณะฐะตะผ ะพะบะฝะพ
connectionRecord.WindowLowerBound++;
connectionRecord.State = connectionRecord.Tcb.States.SendingCycle;
// ะะฐะฟััะบะฐะตะผ ัะฐะนะผะตั
connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
}
เจธเจฎเจฐเฉฑเจฅ เจญเฉเจเจฃ เจฆเจพ เจเฉฑเจเจฐ เจเจธ เจตเจฟเจงเฉ เจตเจฟเฉฑเจ, เจชเฉเจเฉเจเจพเจ เจฆเจพ เจเฉฑเจ เจฌเจฒเจพเจ เจญเฉเจเจฟเจ เจเจพเจเจฆเจพ เจนเฉเฅค
SendingCycle.SendPacket:
public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{
// ะพัะฟัะฐะฒะปัะตะผ ะฑะปะพะบ ะฟะฐะบะตัะพะฒ
for (connectionRecord.PacketCounter = 0;
connectionRecord.PacketCounter < connectionRecord.WindowSize &&
connectionRecord.SndNext < connectionRecord.NumberOfPackets;
connectionRecord.PacketCounter++)
{
ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord);
ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header));
connectionRecord.SndNext++;
}
// ะฝะฐ ัะปััะฐะน ะฑะพะปััะพะณะพ ะพะบะฝะฐ ะฟะตัะตะดะฐัะธ, ะฟะตัะตะทะฐะฟััะบะฐะตะผ ัะฐะนะผะตั ะฟะพัะปะต ะพัะฟัะฐะฒะบะธ
connectionRecord.WaitForPacketsTimer.Change( connectionRecord.ShortTimerPeriod, -1 );
if ( connectionRecord.CloseWaitTimer != null )
{
connectionRecord.CloseWaitTimer.Change( -1, -1 );
}
}
เจเฉเจก เจตเจฟเฉฑเจ เจกเฉเฉฐเจเฉ. เจเจจเฉเจเจธเจผเจจ เจฌเจฃเจพเจเจฃเจพ เจ
เจคเฉ เจธเจฅเจพเจชเจฟเจค เจเจฐเจจเจพ
เจนเฉเจฃ เจเจฆเฉเจ เจ
เจธเฉเจ เจฌเฉเจจเจฟเจเจฆเฉ เจฐเจพเจเจพเจ เจ
เจคเฉ เจฐเจพเจเจพเจ เจจเฉเฉฐ เจธเฉฐเจญเจพเจฒเจฃ เจฒเจ เจตเจฐเจคเฉ เจเจพเจฃ เจตเจพเจฒเฉ เจคเจฐเฉเจเจฟเจเจ เจจเฉเฉฐ เจฆเฉเจเจฟเจ เจนเฉ, เจเจ เจเฉเจ เจเจฆเจพเจนเจฐเจจเจพเจ เจจเฉเฉฐ เจคเฉเฉเฉเจ เจเจฟ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฅเฉเฉเจพ เจนเฉเจฐ เจตเจฟเจธเจฅเจพเจฐ เจตเจฟเฉฑเจ เจเจฟเจตเฉเจ เจเฉฐเจฎ เจเจฐเจฆเจพ เจนเฉเฅค
เจธเจงเจพเจฐเจฃ เจธเจฅเจฟเจคเฉเจเจ เจตเจฟเฉฑเจ เจกเฉเจเจพ เจชเฉเจฐเจธเจพเจฐเจฃ เจเจฟเฉฑเจคเจฐ:
เจฐเจเจจเจพ เจฌเจพเจฐเฉ เจตเจฟเจธเจฅเจพเจฐ เจตเจฟเฉฑเจ เจตเจฟเจเจพเจฐ เจเจฐเฉ เจเฉเจจเฉเจเจธเจผเจจ เจฐเจฟเจเจพเจฐเจก เจเจจเฉเจเจ เจเจฐเจจ เจ
เจคเฉ เจชเจนเจฟเจฒเจพ เจชเฉเจเฉเจ เจญเฉเจเจฃ เจฒเจเฅค เจเฉเจฐเจพเจเจธเจซเจฐ เจนเจฎเฉเจธเจผเจพ เจเจชเจฒเฉเจเฉเจธเจผเจจ เจฆเฉเจเจฐเจพ เจธเจผเฉเจฐเฉ เจเฉเจคเจพ เจเจพเจเจฆเจพ เจนเฉ เจเฉ เจญเฉเจเฉ เจธเฉเจจเฉเจนเจพ API เจจเฉเฉฐ เจเจพเจฒ เจเจฐเจฆเจพ เจนเฉเฅค เจ
เฉฑเจเฉ, เจเจฐเจพเจเจธเจฎเจฟเจธเจผเจจ เจเฉฐเจเจฐเฉเจฒ เจฌเจฒเจพเจ เจฆเฉ เจธเจเจพเจฐเจ เจเจฐเจพเจเจธเจฎเจฟเจธเจผเจจ เจตเจฟเจงเฉ เจจเฉเฉฐ เจฌเฉเจฒเจพเจเจ เจเจพเจเจฆเจพ เจนเฉ, เจเฉ เจจเจตเฉเจ เจธเฉฐเจฆเฉเจธเจผ เจฒเจ เจกเฉเจเจพ เจฆเจพ เจธเฉฐเจเจพเจฐ เจธเจผเฉเจฐเฉ เจเจฐเจฆเจพ เจนเฉเฅค
เจเฉฑเจ เจเจเจเจเฉเจเฉฐเจ เจเจจเฉเจเจธเจผเจจ เจฌเจฃเจพเจเจฃเจพ:
private void StartTransmission(ReliableUdpMessage reliableUdpMessage, EndPoint endPoint, AsyncResultSendMessage asyncResult)
{
if (m_isListenerStarted == 0)
{
if (this.LocalEndpoint == null)
{
throw new ArgumentNullException( "", "You must use constructor with parameters or start listener before sending message" );
}
// ะทะฐะฟััะบะฐะตะผ ะพะฑัะฐะฑะพัะบั ะฒั
ะพะดััะธั
ะฟะฐะบะตัะพะฒ
StartListener(LocalEndpoint);
}
// ัะพะทะดะฐะตะผ ะบะปัั ะดะปั ัะปะพะฒะฐัั, ะฝะฐ ะพัะฝะพะฒะต EndPoint ะธ ReliableUdpHeader.TransmissionId
byte[] transmissionId = new byte[4];
// ัะพะทะดะฐะตะผ ัะปััะฐะนะฝัะน ะฝะพะผะตั transmissionId
m_randomCrypto.GetBytes(transmissionId);
Tuple<EndPoint, Int32> key = new Tuple<EndPoint, Int32>(endPoint, BitConverter.ToInt32(transmissionId, 0));
// ัะพะทะดะฐะตะผ ะฝะพะฒัั ะทะฐะฟะธัั ะดะปั ัะพะตะดะธะฝะตะฝะธั ะธ ะฟัะพะฒะตััะตะผ,
// ัััะตััะฒัะตั ะปะธ ัะถะต ัะฐะบะพะน ะฝะพะผะตั ะฒ ะฝะฐัะธั
ัะปะพะฒะฐััั
if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage, asyncResult)))
{
// ะตัะปะธ ัััะตััะฒัะตั โ ัะพ ะฟะพะฒัะพัะฝะพ ะณะตะฝะตัะธััะตะผ ัะปััะฐะนะฝัะน ะฝะพะผะตั
m_randomCrypto.GetBytes(transmissionId);
key = new Tuple<EndPoint, Int32>(endPoint, BitConverter.ToInt32(transmissionId, 0));
if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage, asyncResult)))
// ะตัะปะธ ัะฝะพะฒะฐ ะฝะต ัะดะฐะปะพัั โ ะณะตะฝะตัะธััะตะผ ะธัะบะปััะตะฝะธะต
throw new ArgumentException("Pair TransmissionId & EndPoint is already exists in the dictionary");
}
// ะทะฐะฟัััะธะปะธ ัะพััะพัะฝะธะต ะฒ ะพะฑัะฐะฑะพัะบั
m_listOfHandlers[key].State.SendPacket(m_listOfHandlers[key]);
}
เจชเจนเจฟเจฒเจพ เจชเฉเจเฉเจ เจญเฉเจเจฃเจพ (FirstPacketSending State):
public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{
connectionRecord.PacketCounter = 0;
connectionRecord.SndNext = 0;
connectionRecord.WindowLowerBound = 0;
// ...
// ัะพะทะดะฐะตะผ ะทะฐะณะพะปะพะฒะพะบ ะฟะฐะบะตัะฐ ะธ ะพัะฟัะฐะฒะปัะตะผ ะตะณะพ
ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord);
ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header));
// ัะฒะตะปะธัะธะฒะฐะตะผ ััะตััะธะบ
connectionRecord.SndNext++;
// ัะดะฒะธะณะฐะตะผ ะพะบะฝะพ
connectionRecord.WindowLowerBound++;
// ะฟะตัะตั
ะพะดะธะผ ะฒ ัะพััะพัะฝะธะต SendingCycle
connectionRecord.State = connectionRecord.Tcb.States.SendingCycle;
// ะะฐะฟััะบะฐะตะผ ัะฐะนะผะตั
connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
}
เจชเจนเจฟเจฒเจพ เจชเฉเจเฉเจ เจญเฉเจเจฃ เจคเฉเจ เจฌเจพเจ
เจฆ, เจญเฉเจเจฃ เจตเจพเจฒเจพ เจฐเจพเจ เจตเจฟเฉฑเจ เจฆเจพเจเจฒ เจนเฉเฉฐเจฆเจพ เจนเฉ เจญเฉเจเจฃ เจฆเจพ เจเฉฑเจเจฐ - เจชเฉเจเฉเจ เจกเจฟเจฒเฉเจตเจฐเฉ เจฆเฉ เจชเฉเจธเจผเจเฉ เจฆเฉ เจเจกเฉเจ เจเจฐเฉ.
เจชเฉเจฐเจพเจชเจค เจเจฐเจจ เจตเจพเจฒเจพ เจชเฉฑเจ, EndReceive เจตเจฟเจงเฉ เจฆเฉ เจตเจฐเจคเฉเจ เจเจฐเจเฉ, เจญเฉเจเจฟเจ เจเจฟเจ เจชเฉเจเฉเจ เจชเฉเจฐเจพเจชเจค เจเจฐเจฆเจพ เจนเฉ, เจเฉฑเจ เจจเจตเจพเจ เจฌเจฃเจพเจเจเจฆเจพ เจนเฉ เจเฉเจจเฉเจเจธเจผเจจ เจฐเจฟเจเจพเจฐเจก เจ
เจคเฉ เจเจธ เจชเฉเจเฉเจ เจจเฉเฉฐ, เจเฉฑเจ เจชเฉเจฐเจต-เจชเจพเจฐเจธ เจเฉเจคเฉ เจธเจฟเจฐเจฒเฉเจ เจฆเฉ เจจเจพเจฒ, เจชเฉเจฐเฉเจธเฉเจธเจฟเฉฐเจ เจฒเจ เจฐเจพเจ เจฆเฉ เจฐเจฟเจธเฉเจตเจชเฉเจเฉเจ เจตเจฟเจงเฉ เจจเฉเฉฐ เจชเจพเจธ เจเจฐเจฆเจพ เจนเฉ เจชเจนเจฟเจฒเจพ เจชเฉเจเฉเจ เจชเฉเจฐเจพเจชเจค เจนเฉเจเจ
เจชเฉเจฐเจพเจชเจค เจเจฐเจจ เจตเจพเจฒเฉ เจชเจพเจธเฉ เจเฉฑเจ เจเฉเจจเฉเจเจธเจผเจจ เจฌเจฃเจพเจเจฃเจพ:
private void EndReceive(IAsyncResult ar)
{
// ...
// ะฟะฐะบะตั ะฟะพะปััะตะฝ
// ะฟะฐััะธะผ ะทะฐะณะพะปะพะฒะพะบ ะฟะฐะบะตัะฐ
ReliableUdpHeader header;
if (!ReliableUdpStateTools.ReadReliableUdpHeader(bytes, out header))
{
// ะฟัะธัะตะป ะฝะตะบะพััะตะบัะฝัะน ะฟะฐะบะตั - ะพัะฑัะฐััะฒะฐะตะผ ะตะณะพ
return;
}
// ะบะพะฝััััะธััะตะผ ะบะปัั ะดะปั ะพะฟัะตะดะตะปะตะฝะธั connection recordโะฐ ะดะปั ะฟะฐะบะตัะฐ
Tuple<EndPoint, Int32> key = new Tuple<EndPoint, Int32>(connectedClient, header.TransmissionId);
// ะฟะพะปััะฐะตะผ ัััะตััะฒััััั connection record ะธะปะธ ัะพะทะดะฐะตะผ ะฝะพะฒัั
ReliableUdpConnectionRecord record = m_listOfHandlers.GetOrAdd(key, new ReliableUdpConnectionRecord(key, this, header. ReliableUdpMessageType));
// ะทะฐะฟััะบะฐะตะผ ะฟะฐะบะตั ะฒ ะพะฑัะฐะฑะพัะบั ะฒ ะบะพะฝะตัะฝัะน ะฐะฒัะพะผะฐั
record.State.ReceivePacket(record, header, bytes);
}
เจชเจนเจฟเจฒเจพ เจชเฉเจเฉเจ เจชเฉเจฐเจพเจชเจค เจเจฐเจจเจพ เจ เจคเฉ เจฐเจธเฉเจฆ เจญเฉเจเจฃเจพ (FirstPacketReceived เจ เจตเจธเจฅเจพ):
public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket))
// ะพัะฑัะฐััะฒะฐะตะผ ะฟะฐะบะตั
return;
// ...
// by design ะฒัะต packet numbers ะฝะฐัะธะฝะฐัััั ั 0;
if (header.PacketNumber != 0)
return;
// ะธะฝะธัะธะฐะปะธะทะธััะตะผ ะผะฐััะธะฒ ะดะปั ั
ัะฐะฝะตะฝะธั ัะฐััะตะน ัะพะพะฑัะตะฝะธั
ReliableUdpStateTools.InitIncomingBytesStorage(connectionRecord, header);
// ะทะฐะฟะธััะฒะฐะตะผ ะดะฐะฝะฝัะต ะฟะฐะบะตั ะฒ ะผะฐััะธะฒ
ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
// ััะธัะฐะตะผ ะบะพะป-ะฒะพ ะฟะฐะบะตัะพะฒ, ะบะพัะพััะต ะดะพะปะถะฝั ะฟัะธะนัะธ
connectionRecord.NumberOfPackets = (int)Math.Ceiling((double) ((double) connectionRecord.IncomingStream.Length/(double) connectionRecord.BufferSize));
// ะทะฐะฟะธััะฒะฐะตะผ ะฝะพะผะตั ะฟะพัะปะตะดะฝะตะณะพ ะฟะพะปััะตะฝะฝะพะณะพ ะฟะฐะบะตัะฐ (0)
connectionRecord.RcvCurrent = header.PacketNumber;
// ะฟะพัะปะต ัะดะฒะธะฝัะปะธ ะพะบะฝะพ ะฟัะธะตะผะฐ ะฝะฐ 1
connectionRecord.WindowLowerBound++;
// ะฟะตัะตะบะปััะฐะตะผ ัะพััะพัะฝะธะต
connectionRecord.State = connectionRecord.Tcb.States.Assembling;
if (/*ะตัะปะธ ะฝะต ััะตะฑัะตััั ะผะตั
ะฐะฝะธะทะผ ะฟะพะดัะฒะตัะถะดะตะฝะธะต*/)
// ...
else
{
// ะพัะฟัะฐะฒะปัะตะผ ะฟะพะดัะฒะตัะถะดะตะฝะธะต
ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
}
}
เจเฉเจก เจตเจฟเฉฑเจ เจกเฉเฉฐเจเฉ. เจธเจฎเจพเจ เจธเจฎเจพเจชเจค เจนเฉเจฃ 'เจคเฉ เจเฉเจจเฉเจเจธเจผเจจ เจฌเฉฐเจฆ เจเฉเจคเจพ เจเจพ เจฐเจฟเจนเจพ เจนเฉ
เจเจพเจเจฎเจเจเจ เจนเฉเจเจกเจฒเจฟเฉฐเจ เจญเจฐเฉเจธเฉเจฏเฉเจ UDP เจฆเจพ เจเฉฑเจ เจฎเจนเฉฑเจคเจตเจชเฉเจฐเจจ เจนเจฟเฉฑเจธเจพ เจนเฉเฅค เจเฉฑเจ เจเจฆเจพเจนเจฐเจจ 'เจคเฉ เจตเจฟเจเจพเจฐ เจเจฐเฉ เจเจฟเจธ เจตเจฟเฉฑเจ เจเฉฑเจ เจตเจฟเจเจเจพเจฐเจฒเจพ เจจเฉเจก เจซเฉเจฒเฉเจน เจนเฉ เจเจฟเจ เจ
เจคเฉ เจฆเฉเจตเจพเจ เจฆเจฟเจธเจผเจพเจตเจพเจ เจตเจฟเฉฑเจ เจกเฉเจเจพ เจกเจฟเจฒเจฟเจตเจฐเฉ เจ
เจธเฉฐเจญเจต เจนเฉ เจเจเฅค
เจธเจฎเจพเจ เจธเจฎเจพเจชเจคเฉ เจฆเฉเจเจฐเจพ เจเฉเจจเฉเจเจธเจผเจจ เจฌเฉฐเจฆ เจเจฐเจจ เจฒเจ เจเจฟเฉฑเจคเจฐ:
เจเจฟเจตเฉเจ เจเจฟ เจเจฟเฉฑเจคเจฐ เจคเฉเจ เจฆเฉเจเจฟเจ เจเจพ เจธเจเจฆเจพ เจนเฉ, เจญเฉเจเจฃ เจตเจพเจฒเฉ เจฆเจพ เจเฉฐเจฎ เจเจพเจเจฎเจฐ เจชเฉเจเฉเจเจพเจ เจฆเฉ เจเฉฑเจ เจฌเจฒเจพเจ เจจเฉเฉฐ เจญเฉเจเจฃ เจคเฉเจ เจคเฉเจฐเฉฐเจค เจฌเจพเจ
เจฆ เจธเจผเฉเจฐเฉ เจนเฉเฉฐเจฆเจพ เจนเฉเฅค เจเจน เจฐเจพเจ เจฆเฉ SendPacket เจตเจฟเจงเฉ เจตเจฟเฉฑเจ เจตเจพเจชเจฐเจฆเจพ เจนเฉ เจญเฉเจเจฃ เจฆเจพ เจเฉฑเจเจฐ.
เจเฉฐเจฎ เจเจพเจเจฎเจฐ เจจเฉเฉฐ เจธเจฎเจฐเฉฑเจฅ เจเจฐเจจเจพ (SendingCycle เจธเจเฉเจ):
public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{
// ะพัะฟัะฐะฒะปัะตะผ ะฑะปะพะบ ะฟะฐะบะตัะพะฒ
// ...
// ะฟะตัะตะทะฐะฟััะบะฐะตะผ ัะฐะนะผะตั ะฟะพัะปะต ะพัะฟัะฐะฒะบะธ
connectionRecord.WaitForPacketsTimer.Change( connectionRecord.ShortTimerPeriod, -1 );
if ( connectionRecord.CloseWaitTimer != null )
connectionRecord.CloseWaitTimer.Change( -1, -1 );
}
เจเจฆเฉเจ เจเฉเจจเฉเจเจธเจผเจจ เจฌเจฃเจพเจเจ เจเจพเจเจฆเจพ เจนเฉ เจคเจพเจ เจเจพเจเจฎเจฐ เจชเฉเจฐเฉเจ เจก เจธเฉเฉฑเจ เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเจจเฅค เจชเฉเจฐเจต-เจจเจฟเจฐเจงเจพเจฐเจค เจธเจผเจพเจฐเจเจเจพเจเจฎเจฐ เจชเฉเจฐเฉเจ เจก 5 เจธเจเจฟเฉฐเจ เจนเฉเฅค เจเจฆเจพเจนเจฐเจจ เจตเจฟเฉฑเจ, เจเจธ เจจเฉเฉฐ 1,5 เจธเจเจฟเฉฐเจ 'เจคเฉ เจธเฉเฉฑเจ เจเฉเจคเจพ เจเจฟเจ เจนเฉเฅค
เจเฉฑเจ เจเจจเจเจฎเจฟเฉฐเจ เจเจจเฉเจเจธเจผเจจ เจฒเจ, เจเจพเจเจฎเจฐ เจเจเจฐเฉ เจเจจเจเจฎเจฟเฉฐเจ เจกเฉเจเจพ เจชเฉเจเฉเจ เจชเฉเจฐเจพเจชเจค เจเจฐเจจ เจคเฉเจ เจฌเจพเจ
เจฆ เจธเจผเฉเจฐเฉ เจนเฉเฉฐเจฆเจพ เจนเฉ, เจเจน เจฐเจพเจ เจฆเฉ เจฐเฉเจธเฉเจต เจชเฉเจเฉเจ เจตเจฟเจงเฉ เจตเจฟเฉฑเจ เจนเฉเฉฐเจฆเจพ เจนเฉ เจเจเฉฑเจ เฉ เจนเฉเจฃเจพ
เจตเจฐเจ เจเจพเจเจฎเจฐ เจจเฉเฉฐ เจธเจฎเจฐเฉฑเจฅ เจเจฐเจจเจพ (เจ
เจธเฉเจเจฌเจฒเจฟเฉฐเจ เจธเจเฉเจ):
public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
// ...
// ะฟะตัะตะทะฐะฟััะบะฐะตะผ ัะฐะนะผะตัั
connectionRecord.TimerSecondTry = false;
connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
if (connectionRecord.CloseWaitTimer != null)
connectionRecord.CloseWaitTimer.Change(-1, -1);
// ...
}
เจตเจฐเจเจฟเฉฐเจ เจเจพเจเจฎเจฐ เจฆเฉ เจเจกเฉเจ เจเจฐเจฆเฉ เจนเฉเจ เจเจเจฃ เจตเจพเจฒเฉ เจเฉเจจเฉเจเจธเจผเจจ 'เจคเฉ เจเฉเจ เจนเฉเจฐ เจชเฉเจเฉเจ เจจเจนเฉเจ เจเจเฅค เจเจพเจเจฎเจฐ เจฌเฉฐเจฆ เจนเฉ เจเจฟเจ เจ
เจคเฉ ProcessPackets เจตเจฟเจงเฉ เจจเฉเฉฐ เจฌเฉเจฒเจพเจเจ เจเจฟเจ, เจเจฟเฉฑเจฅเฉ เจเฉเฉฐเจฎ เจนเฉเจ เจชเฉเจเฉเจ เจฒเฉฑเจญเฉ เจเจ เจธเจจ เจ
เจคเฉ เจชเจนเจฟเจฒเฉ เจตเจพเจฐ เจฎเฉเฉ เจกเจฟเจฒเฉเจตเจฐเฉ เจฌเฉเจจเจคเฉเจเจ เจญเฉเจเฉเจเจ เจเจเจเจ เจธเจจเฅค
เจฎเฉเฉ เจกเจฟเจฒเฉเจตเจฐเฉ เจฌเฉเจจเจคเฉเจเจ เจญเฉเจเจฃเจพ (เจ
เจธเฉเจเจฌเจฒเจฟเฉฐเจ เจธเจเฉเจ):
public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
// ...
if (/*ะฟัะพะฒะตัะบะฐ ะฝะฐ ะฟะพัะตััะฝะฝัะต ะฟะฐะบะตัั */)
{
// ะพัะฟัะฐะฒะปัะตะผ ะทะฐะฟัะพัั ะฝะฐ ะฟะพะฒัะพัะฝัั ะดะพััะฐะฒะบั
// ัััะฐะฝะฐะฒะปะธะฒะฐะตะผ ัะฐะนะผะตั ะฒะพ ะฒัะพัะพะน ัะฐะท, ะดะปั ะฟะพะฒัะพัะฝะพะน ะฟะพะฟััะบะธ ะฟะตัะตะดะฐัะธ
if (!connectionRecord.TimerSecondTry)
{
connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
connectionRecord.TimerSecondTry = true;
return;
}
// ะตัะปะธ ะฟะพัะปะต ะดะฒัั
ะฟะพะฟััะพะบ ััะฐะฑะฐััะฒะฐะฝะธะน WaitForPacketTimer
// ะฝะต ัะดะฐะปะพัั ะฟะพะปััะธัั ะฟะฐะบะตัั - ะทะฐะฟััะบะฐะตะผ ัะฐะนะผะตั ะทะฐะฒะตััะตะฝะธั ัะพะตะดะธะฝะตะฝะธั
StartCloseWaitTimer(connectionRecord);
}
else if (/*ะฟัะธัะตะป ะฟะพัะปะตะดะฝะธะน ะฟะฐะบะตั ะธ ััะฟะตัะฝะฐั ะฟัะพะฒะตัะบะฐ */)
{
// ...
StartCloseWaitTimer(connectionRecord);
}
// ะตัะปะธ ack ะฝะฐ ะฑะปะพะบ ะฟะฐะบะตัะพะฒ ะฑัะป ะฟะพัะตััะฝ
else
{
if (!connectionRecord.TimerSecondTry)
{
// ะฟะพะฒัะพัะฝะพ ะพัััะปะฐะตะผ ack
connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
connectionRecord.TimerSecondTry = true;
return;
}
// ะทะฐะฟััะบะฐะตะผ ัะฐะนะผะตั ะทะฐะฒะตััะตะฝะธั ัะพะตะดะธะฝะตะฝะธั
StartCloseWaitTimer(connectionRecord);
}
}
TimerSecondTry เจตเฉเจฐเฉเจเจฌเจฒ เจจเฉเฉฐ เจธเฉเฉฑเจ เจเฉเจคเจพ เจเจฟเจ เจนเฉ เจเจน เจธเฉฑเจ เจนเฉ,. เจเจน เจตเฉเจฐเฉเจเจฌเจฒ เจเฉฐเจฎ เจเจฐเจจ เจตเจพเจฒเฉ เจเจพเจเจฎเจฐ เจจเฉเฉฐ เจฎเฉเฉ เจเจพเจฒเฉ เจเจฐเจจ เจฒเจ เจเจผเจฟเฉฐเจฎเฉเจตเจพเจฐ เจนเฉเฅค
เจญเฉเจเจฃ เจตเจพเจฒเฉ เจชเจพเจธเฉ, เจเฉฐเจฎ เจเจฐเจจ เจตเจพเจฒเจพ เจเจพเจเจฎเจฐ เจตเฉ เจเจพเจฒเฉ เจนเฉ เจเจพเจเจฆเจพ เจนเฉ เจ
เจคเฉ เจเจเจฐเฉ เจญเฉเจเจฟเจ เจเจฟเจ เจชเฉเจเฉเจ เจฎเฉเฉ เจญเฉเจเจฟเจ เจเจพเจเจฆเจพ เจนเฉเฅค
เจเจจเฉเจเจธเจผเจจ เจฌเฉฐเจฆ เจเจพเจเจฎเจฐ เจจเฉเฉฐ เจธเจฎเจฐเฉฑเจฅ เจเจฐเจจเจพ (SendingCycle เจธเจฅเจฟเจคเฉ):
public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
// ...
// ะพัะฟัะฐะฒะปัะตะผ ะฟะพะฒัะพัะฝะพ ะฟะพัะปะตะดะฝะธะน ะฟะฐะบะตั
// ...
// ะฒะบะปััะฐะตะผ ัะฐะนะผะตั CloseWait โ ะดะปั ะพะถะธะดะฐะฝะธั ะฒะพัััะฐะฝะพะฒะปะตะฝะธั ัะพะตะดะธะฝะตะฝะธั ะธะปะธ ะตะณะพ ะทะฐะฒะตััะตะฝะธั
StartCloseWaitTimer(connectionRecord);
}
เจเจธ เจคเฉเจ เจฌเจพเจ
เจฆ, เจเจเจเจเฉเจเฉฐเจ เจเฉเจจเฉเจเจธเจผเจจ เจตเจฟเฉฑเจ เจเจจเฉเจเจธเจผเจจ เจเจฒเฉเจเจผ เจเจพเจเจฎเจฐ เจธเจผเฉเจฐเฉ เจนเฉเฉฐเจฆเจพ เจนเฉเฅค
ReliableUdpState.StartCloseWaitTimer:
protected void StartCloseWaitTimer(ReliableUdpConnectionRecord connectionRecord)
{
if (connectionRecord.CloseWaitTimer != null)
connectionRecord.CloseWaitTimer.Change(connectionRecord.LongTimerPeriod, -1);
else
connectionRecord.CloseWaitTimer = new Timer(DisposeByTimeout, connectionRecord, connectionRecord.LongTimerPeriod, -1);
}
เจเจจเฉเจเจธเจผเจจ เจฌเฉฐเจฆ เจเจพเจเจฎเจฐ เจเจพเจเจฎเจเจเจ เจฎเจฟเจเจฆ เจฎเฉเจฒ เจฐเฉเจช เจตเจฟเฉฑเจ 30 เจธเจเจฟเฉฐเจ เจนเฉเฅค
เจฅเฉเฉเฉเจนเฉ เจธเจฎเฉเจ เจฌเจพเจ เจฆ, เจชเฉเจฐเจพเจชเจคเจเจฐเจคเจพ เจฆเฉ เจชเจพเจธเฉ เจฆเจพ เจเฉฐเจฎ เจเจฐเจจ เจตเจพเจฒเจพ เจเจพเจเจฎเจฐ เจฆเฉเจฌเจพเจฐเจพ เจเจพเจฒเฉ เจนเฉ เจเจพเจเจฆเจพ เจนเฉ, เจฌเฉเจจเจคเฉเจเจ เจฆเฉเจฌเจพเจฐเจพ เจญเฉเจเฉเจเจ เจเจพเจเจฆเฉเจเจ เจนเจจ, เจเจฟเจธ เจคเฉเจ เจฌเจพเจ เจฆ เจเจเจฃ เจตเจพเจฒเฉ เจเฉเจจเฉเจเจธเจผเจจ เจฒเจ เจเจจเฉเจเจธเจผเจจ เจฌเฉฐเจฆ เจเจพเจเจฎเจฐ เจธเจผเฉเจฐเฉ เจนเฉเฉฐเจฆเจพ เจนเฉ
เจเจฆเฉเจ เจจเจเจผเจฆเฉเจเฉ เจเจพเจเจฎเจฐ เจซเจพเจเจฐ เจเจฐเจฆเฉ เจนเจจ, เจคเจพเจ เจฆเฉเจตเฉเจ เจเฉเจจเฉเจเจธเจผเจจ เจฐเจฟเจเจพเจฐเจกเจพเจ เจฆเฉ เจธเจพเจฐเฉ เจธเจฐเฉเจค เจเจพเจฐเฉ เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเจจเฅค เจญเฉเจเจฃ เจตเจพเจฒเจพ เจ
เฉฑเจชเจธเจเจฐเฉเจฎ เจเจชเจฒเฉเจเฉเจธเจผเจจ เจจเฉเฉฐ เจกเจฟเจฒเจฟเจตเจฐเฉ เจ
เจธเจซเจฒเจคเจพ เจฆเฉ เจฐเจฟเจชเฉเจฐเจ เจเจฐเจฆเจพ เจนเฉ (เจญเจฐเฉเจธเฉเจฏเฉเจ UDP API เจตเฉเจเฉ).
เจเจจเฉเจเจธเจผเจจ เจฐเจฟเจเจพเจฐเจก เจธเจฐเฉเจค เจเจพเจฐเฉ เจเจฐเจจเจพ:
public void Dispose()
{
try
{
System.Threading.Monitor.Enter(this.LockerReceive);
}
finally
{
Interlocked.Increment(ref this.IsDone);
if (WaitForPacketsTimer != null)
{
WaitForPacketsTimer.Dispose();
}
if (CloseWaitTimer != null)
{
CloseWaitTimer.Dispose();
}
byte[] stream;
Tcb.IncomingStreams.TryRemove(Key, out stream);
stream = null;
Tcb.OutcomingStreams.TryRemove(Key, out stream);
stream = null;
System.Threading.Monitor.Exit(this.LockerReceive);
}
}
เจเฉเจก เจตเจฟเฉฑเจ เจกเฉเฉฐเจเฉ. เจกเจพเจเจพ เจเฉเจฐเจพเจเจธเจซเจฐ เจจเฉเฉฐ เจฌเจนเจพเจฒ เจเฉเจคเจพ เจเจพ เจฐเจฟเจนเจพ เจนเฉ
เจชเฉเจเฉเจ เจฆเฉ เจจเฉเจเจธเจพเจจ เจฆเฉ เจธเจฅเจฟเจคเฉ เจตเจฟเฉฑเจ เจกเฉเจเจพ เจเฉเจฐเจพเจเจธเจฎเจฟเจธเจผเจจ เจฐเจฟเจเจตเจฐเฉ เจกเจพเจเจเจฐเจพเจฎ:
เจเจฟเจตเฉเจ เจเจฟ เจธเจฎเจพเจ เจธเจฎเจพเจชเจค เจนเฉเจฃ 'เจคเฉ เจเฉเจจเฉเจเจธเจผเจจ เจจเฉเฉฐ เจฌเฉฐเจฆ เจเจฐเจจ เจฌเจพเจฐเฉ เจชเจนเจฟเจฒเจพเจ เจนเฉ เจเจฐเจเจพ เจเฉเจคเฉ เจเจ เจนเฉ, เจเจฆเฉเจ เจเฉฐเจฎ เจเจฐเจจ เจตเจพเจฒเฉ เจเจพเจเจฎเจฐ เจฆเฉ เจฎเจฟเจเจฆ เจชเฉเฉฑเจ เจเจพเจเจฆเฉ เจนเฉ, เจคเจพเจ เจชเฉเจฐเจพเจชเจคเจเจฐเจคเจพ เจเฉเฉฐเจฎ เจนเฉเจ เจชเฉเจเฉเจเจพเจ เจฆเฉ เจเจพเจเจ เจเจฐเฉเจเจพเฅค เจชเฉเจเฉเจ เจเฉเจเจเจฃ เจฆเฉ เจธเจฅเจฟเจคเฉ เจตเจฟเฉฑเจ, เจเจจเฉเจนเจพเจ เจชเฉเจเฉเจเจพเจ เจฆเฉ เจเจฟเจฃเจคเฉ เจฆเฉ เจธเฉเจเฉ เจคเจฟเจเจฐ เจเฉเจคเฉ เจเจพเจตเฉเจเฉ เจเฉ เจชเฉเจฐเจพเจชเจคเจเจฐเจคเจพ เจคเฉฑเจ เจจเจนเฉเจ เจชเจนเฉเฉฐเจเฉเฅค เจเจน เจจเฉฐเจฌเจฐ เจเฉฑเจ เจเจพเจธ เจเฉเจจเฉเจเจธเจผเจจ เจฆเฉ LostPackets เจเจฐเฉ เจตเจฟเฉฑเจ เจฆเจพเจเจฒ เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเจจ, เจ
เจคเฉ เจฎเฉเฉ เจกเจฟเจฒเฉเจตเจฐเฉ เจฒเจ เจฌเฉเจจเจคเฉเจเจ เจญเฉเจเฉเจเจ เจเจพเจเจฆเฉเจเจ เจนเจจเฅค
เจชเฉเจเฉเจเจพเจ เจจเฉเฉฐ เจฎเฉเฉ เจกเจฟเจฒเฉเจตเจฐ เจเจฐเจจ เจฒเจ เจฌเฉเจจเจคเฉเจเจ เจญเฉเจเจฃเจพ (เจ
เจธเฉเจเจฌเจฒเจฟเฉฐเจ เจธเจเฉเจ):
public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
//...
if (!ReliableUdpStateTools.CheckForNoPacketLoss(connectionRecord, connectionRecord.IsLastPacketReceived != 0))
{
// ะตััั ะฟะพัะตััะฝะฝัะต ะฟะฐะบะตัั, ะพัััะปะฐะตะผ ะทะฐะฟัะพัั ะฝะฐ ะฝะธั
foreach (int seqNum in connectionRecord.LostPackets)
{
if (seqNum != 0)
{
ReliableUdpStateTools.SendAskForLostPacket(connectionRecord, seqNum);
}
}
// ...
}
}
เจญเฉเจเจฃ เจตเจพเจฒเจพ เจฎเฉเฉ เจกเจฟเจฒเฉเจตเจฐเฉ เจฆเฉ เจฌเฉเจจเจคเฉ เจจเฉเฉฐ เจธเจตเฉเจเจพเจฐ เจเจฐเฉเจเจพ เจ
เจคเฉ เจเฉเฉฐเจฎ เจนเฉเจ เจชเฉเจเฉเจ เจญเฉเจเฉเจเจพเฅค เจเจน เจงเจฟเจเจจ เจฆเฉเจฃ เจฏเฉเจ เจนเฉ เจเจฟ เจเจธ เจธเจฎเฉเจ เจญเฉเจเจฃ เจตเจพเจฒเฉ เจจเฉ เจชเจนเจฟเจฒเจพเจ เจนเฉ เจเฉเจจเฉเจเจธเจผเจจ เจฌเฉฐเจฆ เจเจพเจเจฎเจฐ เจธเจผเฉเจฐเฉ เจเจฐ เจฆเจฟเฉฑเจคเจพ เจนเฉ เจ
เจคเฉ, เจเจฆเฉเจ เจเฉเจ เจฌเฉเจจเจคเฉ เจชเฉเจฐเจพเจชเจค เจนเฉเฉฐเจฆเฉ เจนเฉ, เจคเจพเจ เจเจธเจจเฉเฉฐ เจฐเฉเจธเฉเจ เจเฉเจคเจพ เจเจพเจเจฆเจพ เจนเฉเฅค
เจเฉเฉฐเจฎ เจนเฉเจ เจชเฉเจเฉเจ เจฎเฉเฉ เจญเฉเจเฉ เจเจพ เจฐเจนเฉ เจนเจจ (SendingCycle เจ
เจตเจธเจฅเจพ):
public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
// ...
connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
// ัะฑัะพั ัะฐะนะผะตัะฐ ะทะฐะบัััะธั ัะพะตะดะธะฝะตะฝะธั
if (connectionRecord.CloseWaitTimer != null)
connectionRecord.CloseWaitTimer.Change(-1, -1);
// ...
// ััะพ ะทะฐะฟัะพั ะฝะฐ ะฟะพะฒัะพัะฝัั ะฟะตัะตะดะฐัั โ ะพัะฟัะฐะฒะปัะตะผ ััะตะฑัะตะผัะน ะฟะฐะบะตั
else
ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, header.PacketNumber));
}
เจฐเฉเจธเฉเจเจ เจชเฉเจเฉเจ (เจกเจพเจเจเจฐเจพเจฎ เจตเจฟเฉฑเจ เจชเฉเจเฉเจ #3) เจเจเจฃ เจตเจพเจฒเฉ เจเฉเจจเฉเจเจธเจผเจจ เจฆเฉเจเจฐเจพ เจชเฉเจฐเจพเจชเจค เจเฉเจคเจพ เจเจพเจเจฆเจพ เจนเฉเฅค เจเจน เจตเฉเจเจฃ เจฒเจ เจเฉฑเจ เจเจพเจเจ เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเฉ เจเจฟ เจเฉ เจชเฉเจฐเจพเจชเจค เจตเจฟเฉฐเจกเฉ เจญเจฐเฉ เจนเฉเจ เจนเฉ เจ
เจคเฉ เจเจฎ เจกเจพเจเจพ เจธเฉฐเจเจพเจฐ เจจเฉเฉฐ เจฌเจนเจพเจฒ เจเฉเจคเจพ เจเจฟเจ เจนเฉเฅค
เจชเฉเจฐเจพเจชเจค เจตเจฟเฉฐเจกเฉ เจตเจฟเฉฑเจ เจนเจฟเฉฑเจ เจฆเฉ เจเจพเจเจ เจเฉเจคเฉ เจเจพ เจฐเจนเฉ เจนเฉ (เจ
เจธเฉเจเจฌเจฒเจฟเฉฐเจ เจธเจเฉเจ):
public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
// ...
// ัะฒะตะปะธัะธะฒะฐะตะผ ััะตััะธะบ ะฟะฐะบะตัะพะฒ
connectionRecord.PacketCounter++;
// ะทะฐะฟะธััะฒะฐะตะผ ะฒ ะผะฐััะธะฒ ัะฟัะฐะฒะปะตะฝะธั ะพะบะฝะพะผ ัะตะบััะธะน ะฝะพะผะตั ะฟะฐะบะตัะฐ
connectionRecord.WindowControlArray[header.PacketNumber - connectionRecord.WindowLowerBound] = header.PacketNumber;
// ัััะฐะฝะฐะฒะปะธะฒะฐะตะผ ะฝะฐะธะฑะพะปััะธะน ะฟัะธัะตะดัะธะน ะฟะฐะบะตั
if (header.PacketNumber > connectionRecord.RcvCurrent)
connectionRecord.RcvCurrent = header.PacketNumber;
// ะฟะตัะตะทะฐะฟััะบะฐะผ ัะฐะนะผะตัั
connectionRecord.TimerSecondTry = false;
connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
if (connectionRecord.CloseWaitTimer != null)
connectionRecord.CloseWaitTimer.Change(-1, -1);
// ...
// ะตัะปะธ ะฝะฐะผ ะฟัะธัะปะธ ะฒัะต ะฟะฐะบะตัั ะพะบะฝะฐ, ัะพ ัะฑัะฐััะฒะฐะตะผ ััะตััะธะบ
// ะธ ะฒัััะปะฐะตะผ ะฟะฐะบะตั ะฟะพะดัะฒะตัะถะดะตะฝะธะต
else if (connectionRecord.PacketCounter == connectionRecord.WindowSize)
{
// ัะฑัะฐััะฒะฐะตะผ ััะตััะธะบ.
connectionRecord.PacketCounter = 0;
// ัะดะฒะธะฝัะปะธ ะพะบะฝะพ ะฟะตัะตะดะฐัะธ
connectionRecord.WindowLowerBound += connectionRecord.WindowSize;
// ะพะฑะฝัะปะตะฝะธะต ะผะฐััะธะฒะฐ ัะฟัะฐะฒะปะตะฝะธั ะฟะตัะตะดะฐัะตะน
connectionRecord.WindowControlArray.Nullify();
ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
}
// ...
}
เจญเจฐเฉเจธเฉเจฏเฉเจ UDP API
เจกเฉเจเจพ เจเฉเจฐเจพเจเจธเจซเจฐ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจจเจพเจฒ เจเฉฐเจเจฐเฉเจเจ เจเจฐเจจ เจฒเจ, เจเฉฑเจ เจเฉเฉฑเจฒเฉ เจญเจฐเฉเจธเฉเจฎเฉฐเจฆ Udp เจเจฒเจพเจธ เจนเฉ, เจเฉ เจเฉเจฐเจพเจเจธเจซเจฐ เจเฉฐเจเจฐเฉเจฒ เจฌเจฒเจพเจ เจเฉฑเจคเฉ เจเฉฑเจ เจฐเฉเจชเจฐ เจนเฉเฅค เจเฉฑเจฅเฉ เจเจฒเจพเจธ เจฆเฉ เจธเจญ เจคเฉเจ เจฎเจนเฉฑเจคเจตเจชเฉเจฐเจจ เจฎเฉเจเจฌเจฐ เจนเจจ:
public sealed class ReliableUdp : IDisposable
{
// ะฟะพะปััะฐะตั ะปะพะบะฐะปัะฝัั ะบะพะฝะตัะฝัั ัะพัะบั
public IPEndPoint LocalEndpoint
// ัะพะทะดะฐะตั ัะบะทะตะผะฟะปัั ReliableUdp ะธ ะทะฐะฟััะบะฐะตั
// ะฟัะพัะปััะธะฒะฐะฝะธะต ะฒั
ะพะดััะธั
ะฟะฐะบะตัะพะฒ ะฝะฐ ัะบะฐะทะฐะฝะฝะพะผ IP ะฐะดัะตัะต
// ะธ ะฟะพััั. ะะฝะฐัะตะฝะธะต 0 ะดะปั ะฟะพััะฐ ะพะทะฝะฐัะฐะตั ะธัะฟะพะปัะทะพะฒะฐะฝะธะต
// ะดะธะฝะฐะผะธัะตัะบะธ ะฒัะดะตะปะตะฝะฝะพะณะพ ะฟะพััะฐ
public ReliableUdp(IPAddress localAddress, int port = 0)
// ะฟะพะดะฟะธัะบะฐ ะฝะฐ ะฟะพะปััะตะฝะธะต ะฒั
ะพะดััะธั
ัะพะพะฑัะตะฝะธะน
public ReliableUdpSubscribeObject SubscribeOnMessages(ReliableUdpMessageCallback callback, ReliableUdpMessageTypes messageType = ReliableUdpMessageTypes.Any, IPEndPoint ipEndPoint = null)
// ะพัะฟะธัะบะฐ ะพั ะฟะพะปััะตะฝะธั ัะพะพะฑัะตะฝะธะน
public void Unsubscribe(ReliableUdpSubscribeObject subscribeObject)
// ะฐัะธะฝั
ัะพะฝะฝะพ ะพัะฟัะฐะฒะธัั ัะพะพะฑัะตะฝะธะต
// ะัะธะผะตัะฐะฝะธะต: ัะพะฒะผะตััะธะผะพััั ั XP ะธ Server 2003 ะฝะต ัะตััะตััั, ั.ะบ. ะธัะฟะพะปัะทัะตััั .NET Framework 4.0
public Task<bool> SendMessageAsync(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, CancellationToken cToken)
// ะฝะฐัะฐัั ะฐัะธะฝั
ัะพะฝะฝัั ะพัะฟัะฐะฒะบั ัะพะพะฑัะตะฝะธั
public IAsyncResult BeginSendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, AsyncCallback asyncCallback, Object state)
// ะฟะพะปััะธัั ัะตะทัะปััะฐั ะฐัะธะฝั
ัะพะฝะฝะพะน ะพัะฟัะฐะฒะบะธ
public bool EndSendMessage(IAsyncResult asyncResult)
// ะพัะธััะธัั ัะตััััั
public void Dispose()
}
เจธเฉเจจเฉเจนเฉ เจเจพเจนเจเฉ เจฆเฉเจเจฐเจพ เจชเฉเจฐเจพเจชเจค เจเฉเจคเฉ เจเจพเจเจฆเฉ เจนเจจเฅค เจเจพเจฒเจฌเฉเจ เจตเจฟเจงเฉ เจฒเจ เจกเฉเจฒเฉเจเฉเจ เจฆเจธเจคเจเจค:
public delegate void ReliableUdpMessageCallback( ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteClient );
เจธเฉเจจเฉเจนเจพ:
public class ReliableUdpMessage
{
// ัะธะฟ ัะพะพะฑัะตะฝะธั, ะฟัะพััะพะต ะฟะตัะตัะธัะปะตะฝะธะต
public ReliableUdpMessageTypes Type { get; private set; }
// ะดะฐะฝะฝัะต ัะพะพะฑัะตะฝะธั
public byte[] Body { get; private set; }
// ะตัะปะธ ัััะฐะฝะพะฒะปะตะฝะพ ะฒ true โ ะผะตั
ะฐะฝะธะทะผ ะฟะพะดัะฒะตัะถะดะตะฝะธั ะดะพััะฐะฒะบะธ ะฑัะดะตั ะพัะบะปััะตะฝ
// ะดะปั ะฟะตัะตะดะฐัะธ ะบะพะฝะบัะตัะฝะพะณะพ ัะพะพะฑัะตะฝะธั
public bool NoAsk { get; private set; }
}
เจเฉฑเจ เจเจพเจธ เจธเฉเจจเฉเจนเจพ เจเจฟเจธเจฎ เจ เจคเฉ/เจเจพเจ เจเฉฑเจ เจเจพเจธ เจญเฉเจเจฃ เจตเจพเจฒเฉ เจฆเฉ เจเจพเจนเจเฉ เจฒเฉเจฃ เจฒเจ, เจฆเฉ เจตเจฟเจเจฒเจชเจฟเจ เจฎเจพเจชเจฆเฉฐเจก เจตเจฐเจคเฉ เจเจพเจเจฆเฉ เจนเจจ: ReliableUdpMessageTypes messageType เจ เจคเฉ IPendPoint ipEndPointเฅค
เจธเฉเจจเฉเจนเฉ เจฆเฉเจเจ เจเจฟเจธเจฎเจพเจ:
public enum ReliableUdpMessageTypes : short
{
// ะัะฑะพะต
Any = 0,
// ะะฐะฟัะพั ะบ STUN server
StunRequest = 1,
// ะัะฒะตั ะพั STUN server
StunResponse = 2,
// ะะตัะตะดะฐัะฐ ัะฐะนะปะฐ
FileTransfer =3,
// ...
}
เจธเฉเจจเฉเจนเจพ เจ เจธเจฟเฉฐเจเจฐเฉเจจเจธ เจญเฉเจเจฟเจ เจเจพเจเจฆเจพ เจนเฉ; เจเจธเจฆเฉ เจฒเจ, เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจเฉฑเจ เจ เจธเจฟเฉฐเจเฉเจฐเฉเจจเจธ เจชเฉเจฐเฉเจเจฐเจพเจฎเจฟเฉฐเจ เจฎเจพเจกเจฒ เจฒเจพเจเฉ เจเจฐเจฆเจพ เจนเฉ:
public IAsyncResult BeginSendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, AsyncCallback asyncCallback, Object state)
เจธเฉเจจเฉเจนเจพ เจญเฉเจเจฃ เจฆเจพ เจจเจคเฉเจเจพ เจธเจนเฉ เจนเฉเจตเฉเจเจพ - เจเฉเจเจฐ เจธเฉเจจเฉเจนเจพ เจธเจซเจฒเจคเจพเจชเฉเจฐเจตเจ เจชเฉเจฐเจพเจชเจคเจเจฐเจคเจพ เจคเฉฑเจ เจชเจนเฉเฉฐเจเจฟเจ เจ เจคเฉ เจเจฒเจค - เจเฉเจเจฐ เจเจจเฉเจเจธเจผเจจ เจธเจฎเจพเจ เจธเจฎเจพเจชเจคเฉ เจฆเฉเจเจฐเจพ เจฌเฉฐเจฆ เจเฉเจคเจพ เจเจฟเจ เจธเฉ:
public bool EndSendMessage(IAsyncResult asyncResult)
เจธเจฟเฉฑเจเจพ
เจเจธ เจฒเฉเจ เจตเจฟเจ เจฌเจนเฉเจค เจเฉเจ เจตเจฐเจฃเจจ เจจเจนเฉเจ เจเฉเจคเจพ เจเจฟเจ เจนเฉ. เจฅเฉเจฐเฉเจก เจฎเฉเจเจฟเฉฐเจ เจตเจฟเจงเฉ, เจ เจชเจตเจพเจฆ เจ เจคเฉ เจเจฒเจคเฉ เจนเฉเจเจกเจฒเจฟเฉฐเจ, เจ เจธเจฟเฉฐเจเฉเจฐเฉเจจเจธ เจธเฉฐเจฆเฉเจธเจผ เจญเฉเจเจฃ เจฆเฉ เจคเจฐเฉเจเจฟเจเจ เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเจจเจพเฅค เจชเจฐ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฆเจพ เจฎเฉเจฒ, เจชเฉเจฐเฉเจธเฉเจธเจฟเฉฐเจ เจชเฉเจเฉเจเจพเจ เจฒเจ เจคเจฐเจ เจฆเจพ เจตเฉเจฐเจตเจพ, เจเฉฑเจ เจเฉเจจเฉเจเจธเจผเจจ เจธเจฅเจพเจชเจค เจเจฐเจจเจพ, เจ เจคเฉ เจธเจฎเจพเจ เจธเจฎเจพเจชเจคเฉ เจจเฉเฉฐ เจธเฉฐเจญเจพเจฒเจฃเจพ, เจคเฉเจนเจพเจกเฉ เจฒเจ เจธเจชเฉฑเจธเจผเจ เจนเฉเจฃเจพ เจเจพเจนเฉเจฆเจพ เจนเฉเฅค
เจญเจฐเฉเจธเฉเจฏเฉเจ เจกเจฟเจฒเฉเจตเจฐเฉ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฆเจพ เจชเฉเจฐเจฆเจฐเจธเจผเจฟเจค เจธเฉฐเจธเจเจฐเจฃ เจชเจนเจฟเจฒเจพเจ เจชเจฐเจฟเจญเจพเจธเจผเจฟเจค เจฒเฉเฉเจพเจ เจจเฉเฉฐ เจชเฉเจฐเจพ เจเจฐเจจ เจฒเจ เจเจพเจซเจผเฉ เจฎเจเจผเจฌเฉเจค โโเจ เจคเฉ เจฒเจเจเจฆเจพเจฐ เจนเฉเฅค เจชเจฐ เจฎเฉเจ เจเจน เจเฉเฉเจจเจพ เจเจพเจนเฉเฉฐเจฆเจพ เจนเจพเจ เจเจฟ เจตเจฐเจฃเจฟเจค เจฒเจพเจเฉเจเจฐเจจ เจจเฉเฉฐ เจธเฉเจงเจพเจฐเจฟเจ เจเจพ เจธเจเจฆเจพ เจนเฉ. เจเจฆเจพเจนเจฐเจจ เจฒเจ, เจฅเฉเจฐเฉเจชเฉเฉฑเจ เจจเฉเฉฐ เจตเจงเจพเจเจฃ เจ เจคเฉ เจเจพเจเจฎเจฐ เจชเฉเจฐเฉเจ เจกเจพเจ เจจเฉเฉฐ เจเจคเฉเจธเจผเฉเจฒ เจฐเฉเจช เจตเจฟเฉฑเจ เจฌเจฆเจฒเจฃ เจฒเจ, เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจตเจฟเฉฑเจ เจธเจฒเจพเจเจกเจฟเฉฐเจ เจตเจฟเฉฐเจกเฉ เจ เจคเฉ RTT เจตเจฐเจเฉเจเจ เจตเจฟเจงเฉเจเจ เจจเฉเฉฐ เจเฉเฉเจฟเจ เจเจพ เจธเจเจฆเจพ เจนเฉ, เจเจน เจเจจเฉเจเจธเจผเจจ เจจเฉเจกเจพเจ เจฆเฉ เจตเจฟเจเจเจพเจฐ MTU เจจเฉเฉฐ เจจเจฟเจฐเจงเจพเจฐเจค เจเจฐเจจ เจฒเจ เจเฉฑเจ เจตเจฟเจงเฉ เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเจจ เจฒเจ เจตเฉ เจฒเจพเจญเจฆเจพเจเจ เจนเฉเจตเฉเจเจพ (เจชเจฐ เจเฉเจตเจฒ เจคเจพเจ เจนเฉ เจเฉเจเจฐ เจตเฉฑเจกเฉ เจธเฉเจจเฉเจนเฉ เจญเฉเจเฉ เจเจพเจเจฆเฉ เจนเจจ) .
เจคเฉเจนเจพเจกเฉ เจงเจฟเจเจจ เจฒเจ เจคเฉเจนเจพเจกเจพ เจงเฉฐเจจเจตเจพเจฆ, เจฎเฉเจ เจคเฉเจนเจพเจกเฉเจเจ เจเจฟเฉฑเจชเจฃเฉเจเจ เจ เจคเฉ เจเจฟเฉฑเจชเจฃเฉเจเจ เจฆเฉ เจเจกเฉเจ เจเจฐเจฆเจพ เจนเจพเจ.
PS เจเจนเจจเจพเจ เจฒเจ เจเฉ เจตเฉเจฐเจตเจฟเจเจ เจตเจฟเฉฑเจ เจฆเจฟเจฒเจเจธเจชเฉ เจฐเฉฑเจเจฆเฉ เจนเจจ เจเจพเจ เจธเจฟเจฐเจซ เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฆเฉ เจเจพเจเจ เจเจฐเจจเจพ เจเจพเจนเฉเฉฐเจฆเฉ เจนเจจ, GitHube 'เจคเฉ เจชเฉเจฐเฉเจเฉเจเจ เจฆเจพ เจฒเจฟเฉฐเจ:
เจเจชเจฏเฉเจเฉ เจฒเจฟเฉฐเจ เจ
เจคเฉ เจฒเฉเจ
- TCP เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจจเจฟเจฐเจงเจพเจฐเจจ:
เจ เฉฐเจเจฐเฉเจเจผเฉ เจตเจฟเฉฑเจ ะธเจฐเฉเจธเฉ เจตเจฟเฉฑเจ - UDP เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจจเจฟเจฐเจงเจพเจฐเจจ:
เจ เฉฐเจเจฐเฉเจเจผเฉ เจตเจฟเฉฑเจ ะธเจฐเฉเจธเฉ เจตเจฟเฉฑเจ - RUDP เจชเฉเจฐเฉเจเฉเจเฉเจฒ เจฆเฉ เจเจฐเจเจพ:
เจกเจฐเจพเจซเจ-ietf-sigtran-เจญเจฐเฉเจธเฉเจฏเฉเจ-udp-00 - เจญเจฐเฉเจธเฉเจฏเฉเจ เจกเจพเจเจพ เจชเฉเจฐเฉเจเฉเจเฉเจฒ:
เจเจฐเจเจซเจธเฉ 908 ะธเจเจฐเจเจซเจธเฉ 1151 - UDP เจเฉฑเจคเฉ เจกเจฟเจฒเฉเจตเจฐเฉ เจชเฉเจธเจผเจเฉเจเจฐเจจ เจฆเจพ เจเฉฑเจ เจธเจงเจพเจฐเจจ เจ
เจฎเจฒ:
.NET เจ เจคเฉ UDP เจจเจพเจฒ เจเจชเจฃเฉ เจจเฉเฉฑเจเจตเจฐเจเจฟเฉฐเจ เจฆเจพ เจชเฉเจฐเจพ เจจเจฟเจฏเฉฐเจคเจฐเจฃ เจฒเจ - NAT เจเจฐเจพเจตเจฐเจธเจฒ เจตเจฟเจงเฉ เจฆเจพ เจตเจฐเจฃเจจ เจเจฐเจจ เจตเจพเจฒเจพ เจฒเฉเจ:
เจชเฉเจ เจฐ-เจเฉ-เจชเฉเจ เจฐ เจธเฉฐเจเจพเจฐ เจธเจพเจฐเฉ เจจเฉเฉฑเจเจตเจฐเจ เจเจกเจฐเฉเฉฑเจธ เจ เจจเฉเจตเจพเจฆเจเจพเจ เจตเจฟเฉฑเจ - เจ
เจธเจฟเฉฐเจเฉเจฐเฉเจจเจธ เจชเฉเจฐเฉเจเจฐเจพเจฎเจฟเฉฐเจ เจฎเจพเจกเจฒ เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเจจเจพ:
CLR เจ เจธเจฟเฉฐเจเฉเจฐเฉเจจเจธ เจชเฉเจฐเฉเจเจฐเจพเจฎเจฟเฉฐเจ เจฎเจพเจกเจฒ เจจเฉเฉฐ เจฒเจพเจเฉ เจเจฐเจจเจพ ะธIAsyncResult เจกเจฟเจเจผเจพเจเจจ เจชเฉเจเจฐเจจ เจจเฉเฉฐ เจเจฟเจตเฉเจ เจฒเจพเจเฉ เจเจฐเจจเจพ เจนเฉ - เจ
เจธเจฟเฉฐเจเฉเจฐเฉเจจเจธ เจชเฉเจฐเฉเจเจฐเจพเจฎเจฟเฉฐเจ เจฎเจพเจกเจฒ เจจเฉเฉฐ เจเจพเจธเจ-เจ
เจงเจพเจฐเจฟเจค เจ
เจธเจฟเฉฐเจเฉเจฐเฉเจจเจธ เจชเฉเจเจฐเจจ (TAP เจตเจฟเฉฑเจ APM) เจตเจฟเฉฑเจ เจชเฉเจฐเจ เจเจฐเจจเจพ:
TPL เจ เจคเฉ เจชเจฐเฉฐเจชเจฐเจพเจเจค .NET เจ เจธเจฟเฉฐเจเฉเจฐเฉเจจเจธ เจชเฉเจฐเฉเจเจฐเจพเจฎเจฟเฉฐเจ
เจนเฉเจฐ เจ เจธเจฟเฉฐเจเจฐเฉเจจเจธ เจชเฉเจเจฐเจจเจพเจ เจ เจคเฉ เจเจฟเจธเจฎเจพเจ เจจเจพเจฒ เจเฉฐเจเจฐเฉเจช เจเจฐเฉ
เจ
เฉฑเจชเจกเฉเจ: เจงเฉฐเจจเจตเจพเจฆ
เจธเจฐเฉเจค: www.habr.com