C# - TCP / IP
פרקי ההרצאה: C# - TCP / IP
תמלול ההרצאה: C# - TCP / IP
הטקסט המלא של הדקות הראשונות בהרצאה «C# - TCP / IP» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אנחנו מגיעים לנושא מאוד מאוד מעניין שנקרא TCP/IP. TCP/IP זה קיצור של Transmission Control Protocol, אינטרנט פרוטוקול.
בעצם מה שזה אומר זה איזשהו פרוטוקול תקשורת בין מחשבים שאפשר דרכו להעביר מידע. אנחנו יכולים בצורה כזאת להתחבר בין שני מחשבים ולהעביר מידע ממחשב אחד למחשב השני ומהמחשב השני למחשב הראשון.
מה זה אומר פרוטוקול? זה אומר שיש סדרה קבועה וברורה של צעדים שמתבצעים במהלך התקשורת הזאת בכדי להצליח להעביר את המידע מהמחשב א' למחשב ב'.
אנחנו לא הולכים לראות נתונים פנימיים בתוך תקשורת הנתונים הזאת ואיך זה מתבצע מאחורי הקלעים, ואיך המערכת מעבירה ביטים מצד אחד לצד השני. כל הנושא הזה שייך לתקשורת נתונים, וכמובן שיש קורסים שעוסקים בזה.
אנחנו הולכים לראות איך להצליח לבצע את אותה תקשורת נתונים בפרוטוקול TCP/IP מבחינת פיתוח תוכנה. פרוטוקול TCP/IP זה אחד הפרוטוקולים הבסיסיים שעליו מסתבכים הרבה פרוטוקולים אחרים, והפרוטוקול הזה נחשב יחסית מאוד מהיר, ואנחנו יכולים דרכו להעביר מידע ממחשב א' למחשב ב'.
דבר ראשון מה שאנחנו הולכים לראות זה כל מיני מונחים בעולם הזה שקשורים ל-TCPIP בשביל שנוכל להיכנס אחר כך ולכתוב קוד כאשר תוך כדי הכתיבה אנחנו משתמשים במונחים האלה בשביל להצליח לבסס את תקשורת הנתונים בין שני מחשבים.
הדבר הבא שאנחנו הולכים לראות זה איך לבצע את זה מבחינת תוכנה. אנחנו הולכים להרים שתי תוכנות שתוכנה א' שולחת מידע לתוכנה ב', תוכנה ב' מקבלת את המידע, עושה איתו משהו, לדוגמה מציגה אותו, תוכנה ב' שולחת את המידע לתוכנה א', תוכנה א' מקבלת אותו ומציגה אותו.
בזה בעצם מסתיימת דוגמה פשוטה ובסיסית ביותר ל-TCPIP. עכשיו כמובן אנחנו רוצים להרים איזושהי מערכת קצת יותר מורכבת מלשלוח מידע לקבל ולשלוח ולקבל, שעושה משהו קצת לוגי יותר חכם ופה זה כבר יהיה איך אנחנו משתמשים עם זה זאת תהיה כבר דוגמה מפורטת יותר בהמשך איך אנחנו משתמשים עם מה שאנחנו לומדים בסרטון הזה בשביל להרים
משהו קצת יותר מורכב שהוא לוגית מאפשר לעשות משהו מאוד מעניין אז בואו קודם כל נזרום לתוך המונחים בעולם ה-DCPIP דבר ראשון כאשר אנחנו מתעסקים בתקשורת בין מחשבים יש לנו מחשב שהוא נחשב סרבר סרבר מהמילה to serve, לשרת, הוא נותן שירות למחשבים אחרים.
המחשבים שמתחברים אליו נקראים קליינטס. פה בדוגמה הזאת אנחנו רואים סרבר אחד וקליינט אחד. קודם כל כמובן הסרבר חייב להיות באוויר ומאזין להתחברות לקוחות, ורק לאחר מכן לקוח יכול בכלל להתחבר לסרבר.
אחרי שהוא מתחבר אליו יש קו תקשורת ביניהם ואז הם יכולים לתקשר. אנחנו כבר הולכים לראות איך זה מתבצע. אבל הסרבר זה איזשהו מחשב שקיים איפשהו ברשת ונמצא באוויר, עובד, פעיל, והלקוחות אמורים להכיר את הסרבר.
הסרבר לא אמור להכיר את הלקוחות מבחינת התחברות ראשונית. זאת אומרת, אם אנחנו רוצים לבסס קו תקשורת, קודם כל אנחנו מרימים איזשהו סרבר לאוויר, איזשהו מחשב, בסך הכל יכול להיות מחשב רגיל לגמרי, הוא משחק בתפקיד הסרבר, השרת ואז רק אנחנו יכולים להרים קליינט שאמור לדעת את המיקום
של הסרבר ולהתחבר אליו. אחרי שהקליינט יתחבר שניהם יכולים לתקשר. מה זאת אומרת הקליינט מכיר אותו ויכול להתחבר אליו?
לכל מחשב באותה הרשת יש כתובת, הכתובת הזאת נקראת IP Address. היא אמורה להיות כתובת ייחודית באותה הרשת. דוגמא, למחשב שלכם, אם הוא מחובר לרשת האינטרנט, יש לו איזושהי כתובת מסוימת, זה יכול להיות כתובת שבנויה לדוגמא מארבעה מספרים מחוברים עם נקודות, או שישה מספרים מחוברים עם נקודות, יש כל מיני פורמטים של כתובות,
והכתובת הזאת נקראת IP Address והיא אמורה להיות ייחודית עבור אותו מחשב באותה הרשת. אם יש לכם רשת פנימית בחברה, אז כמובן הכתובת באותה הרשת הפנימית היא ייחודית עבור אותה הרשת הפנימית.
אז למחשב של הסרבר כמובן ישנה כתובת ובעזרת הכתובת הזאת ניתן למצוא אותו ברחבי הרשת. זאת אומרת שאם אנחנו רוצים לבסס את הקו תקשורת הספציפי הזה הקליינט אמור לדעת מהו ה-IP אדרס של הסרבר והסרבר לא אמור לדעת לפחות ברוב המקרים בתקשורת קלאסית מהו ה-IP אדרס של הקליינט כי מי שמבסס את קו התקשורת הזה
ומי שיוזם אותו בוא נניח זה הקליינט שבא לסרבר ואומר לו שלום אני בבקשה רוצה להתחבר אליך בשביל להתחיל לתקשר איתך אז הקליינט צריך לאתר את הסרבר בכל הרשת לפי ה-IP אדרס של הסרבר ולכן הקליינט צריך להכיר את ה-IP אדרס הזאת.
לקליינט כמובן גם יש IP אדרס אבל הסרבר לא אמור להכיר אותו ולכן בתקשורת מבחינתנו אנחנו לא מתעסקים עם ה-IP אדרס של הקליינט אלא רק של הסרבר מבחינת כתיבה, משהו שאנחנו חייבים להכיר.
הדבר הבא שאנחנו צריכים להכיר זה מונח שנקרא פורט. פורט זה בעצם איזושהי נקודה מסוימת שנמצאת בתוך המחשב שהמידע שנכנס לכרטיס הרשת או דרך כבל הרשת מתייצב בנקודה הזאת.
מה זה אומר? תחשבו שיש לי מחשב סרבר, בואו ניקח את הדוגמה של הסרבר. עכשיו, כמה קווי תקשורת יוצאים לכם מהמחשב?
נניח שהמחשב שלכם הוא פרוור, כמה קווי תקשורת יוצאים לעולם מבחינת כבל פיזי? אז אם אתם בטח פעם התחברתם עם המחשב שלכם לאינטרנט, אז כנראה ראיתם שישנו כבל אחד ויחיד שמתחבר מהאינטרנט למחשב שלכם.
אז איך זה יכול להיות שעם כבל אחד ויחיד כל התוכנות שרוצות לתקשר לתוך המחשב שלכם יכולות, הרי זה רק כבל אחד. מה שקורה כאשר תוכנה רוצה לשלוח מידע לתוך המחשב, כל המידע יעבור באותו הכבל אבל אנחנו צריכים לציין לאיזה פורט פנימי בתוך המחשב המידע זה חייב להיכנס.
למה? כי ככה אנחנו יכולים שהרבה תוכנות יצליחו להעביר מידע על אותו הקו תקשורת כי כל מידע מנותב לכתובת אחרת ואז התוכנה שאמורה להקשיב למידע ולקבל את המידע היא יודעת לאיזה פורט להקשיב.
פורט זה סך הכל כתובת, יש טיפה מעל 65 אלף כתובות כאלה ולכן יכול להיות המון המון תוכנות שמתקשרות עם המחשב שלנו וכל מה שאנחנו צריכים לדעת זה לאיזה פורט בסרבר אנחנו רוצים לשלוח את המידע כי התוכנה של הסרבר תאזין על אותו הפורט.
שוב, זה סך הכל מספר שיכול להיות עד 65,000. לא נהוג לקחת פורטים נמוכים, כי בדרך כלל יש להם סיכוי גבוה להיות דפוסים. בטח שמרתם כבר שאולי אינטרנט אקספלורר עובדת על פורט 80, או אימייל אדרס עובד על פורט 25, איזשהו אימייל אדרס, או כל מיני פורטים, בטח נתקלתם בהם שהם תפוסים על ידי כל מיני תוכנות והם כאילו ידועות
שהתוכנות האלה תפסו את הפורטים האלה. אם אתם רוצים לתפוס איזשהו פורט עדיף שתתפסו פורט גבוה כמה אלפים בטוח מעל אלף בכדי שכנראה הוא יהיה פנוי אצלכם במחשב.
מקסימום אתם בודקים ורואים אם הפורט תפוס או פנוי אם אתם חוטפים אקספצ'ן בסרבר הפורט יהיה תפוס אז צריך למצוא פורט שהוא פנוי. גם לקליינט קיים פורט כי הסרבר שולח אליו מידע אז כמובן שהוא צריך לנתב את המידע לפורט שהקליינט מאזין כאשר אנחנו הולכים לכתוב קוד אנחנו צריכים להחליט רק על הפורט של הסרבר מבחינת
מתכנתים הפורט של הקליינט יינתן לנו אוטומטית כפורט פנוי והוא בכלל לא מעניין אותי מהו המערכת תמצא לי אוטומטית עבור הקליינט איזשהו פורט פנוי מכדי שהמידע מהסרבר ייכנס אליו אוקיי הדבר הבא שאנחנו צריכים להכיר זה זה מונח שנקרא Socket.
Socket בתרגום חופשי זה יהיה שקע, זה איזשהו קו יציאה של המידע, זה איזשהו רכיב שאנחנו יכולים לכתוב אליו ולקרוא ממנו.
אם אנחנו כותבים אליו, אז הוא אמור לשלוח את הנתונים לצד השני שהוא מתחבר אליו. אם הצד השני שולח מידע שמתקבל ל-socket, אנחנו יכולים לקרוא את המידע הזה מהסוקט.
אז סוקט זה נקודת הקצה, זה כמו שקע שיש אצלכם בקיר, שמחובר אבל רק לנקודה אחת כלשהי איפשהו בעולם.
אם אתם כותבים אליו, הצד השני יקבל את זה, אם הצד השני כותב לנקודה שלו, אתם תקבלו. אז יש לנו פה את הסוקט, שמבחינתנו זה איזשהו רכיב תוכנה שאנחנו הולכים להרים, והסוקט, מתחבר לאיזשהו פורט, אנחנו נראה את זה.
אוקיי, גם בצד השני קיים סוקט. מה שקורה זה שקודם כל הסרבר מאזין להתחברות לקוחות, זה משהו שאנחנו תמיד צריכים לבכור. הסרבר מאזין להתחברות לקוחות. כאשר איזשהו לקוח מתחבר לסרבר ואומר, אני רוצה לתקשר עם סרבר שיש לו IP אדרס ספציפי, שהנה בבקשה אני נותן לכם את ה-IP אדרס הזה, ושיש לו איזשהו פורט ספציפי, הנה בבקשה אני רוצה לתקשר לפורט הזה, אוטומטית הסרבר יוצר סוקט עבורו,
אנחנו רואים פה את הסוקט והקליינט גם יוצר איזשהו סוקט ושני הסוקטים האלה מתחברים ביחד ואז מגיע לנו איזשהו ערוץ תקשורת או שנוצר לנו ערוץ תקשורת בגלל היזומה של אותו קליינט שרצה להתחבר ואנחנו יכולים מהסרבר לשלוח מידע דרך הסוקט, ואז המידע הזה יוצא מהצד השני של הקליינט שמקבל אותו.
הקליינט כמובן גם הוא יכול לשלוח מידע, המידע נכנס לסוקט של הקליינט, ולכן יוצא מהצד השני מהסוקט של הסרבר, שהסרבר יכול עכשיו לקרוא את המידע.
אבל ישנה איזושהי בעיה תכנותית קטנה בקשר לסוקט. סוקט זה רכיב מבחינת תוכנה מאוד מאוד פרימיטיבי אפשר לקרוא לו או מאוד קרוב לברזלים.
מה זה אומר? זה אומר שהרכיב הזה יכול לשלוח מידע ולקבל מידע שהמידע הזה הוא אך ורק מערך בתים. זאת אומרת אם יש לי מערך כלומר בית הרי רגיל לגמרי אין לי שום בעיה לשלוח את המערך הזה דרך הסוקט מהסרבר לקליינט ובקליינט לקרוא אותו או מהקליינט לסרוור ולסרוור לקרוא אותו אנחנו הולכים מיד לעשות את זה אבל מה אני בדיוק בתור מתכנת אמור לעשות עם
מערך בתים? אני רוצה להעביר מידע שאפשר לעבוד איתו, אני רוצה להעביר מכרוזות, אני רוצה להעביר אובייקטים, אני רוצה להעביר הודעות, אני רוצה להעביר מידע לוגי, מוצרים, לקוחות, ספקים, אני רוצה להעביר אובייקטים.
מה, אני עכשיו אקח אובייקט ואני אתחיל לפרק אותו לבתים בתים בתים? מה אני בדיוק אעשה עם זה? איך בדיוק אני מפרק אובייקט לבתים? זה קצת קשה לעבוד עם ה-socket.
אז לכן אנחנו יכולים בתור מתכנתים להשתמש בעוד רכיב שנקרא Network Stream. Network Stream זה רכיב שאנחנו יכולים להלביש אותו על ה-socket בצד של הסרבר וגם בצד של הקליינט, וה-Network Stream כל מה שהוא עושה הוא מתחבר לסוקט ומאפשר לנו להביא לו אובייקט ולזרוק את האובייקט הזה דרך ביטים לצד השני.
או ליתר דיוק, אנחנו יכולים עכשיו, אם יש לנו סטרים שיכול להעביר מידע לסוקט, אנחנו יכולים דרך מנגנון סריאליזיישן לשפוך מידע לצד השני. הרי אם תיזכרו במנגנון הסריאליזיישן שלמדנו בתחילת הקורס, אז תיזכרו בזה שמנגנון הסריאליזיישן אומר, תביאו לי סטרים ותביאו לי אובייקט, ואני אשפוך את האובייקט הזה לצד השני של הסטרים,
לאן שהסטרים מצביע עליו, ואני אשפוך את האובייקט הזה. הסטרים, דרך הסוקט, מצביע לצד השני של העולם, לנטוורק סטרים השני.
לכן, דרך מנגנון ה-serialization אנחנו יכולים להביא את הסטרים, שבמקרה הזה זה נטוורק סטרים, להביא אותו, להביא אובייקט, לתת את האובייקט ואת הסטרים למנגנון ה-serialization, ולהגיד לו, הנה אובייקט, שלח אותו בבקשה לצד השני של הסטרים.
ואז מנגנון הסריליזיישן הוא זה שייקח את האובייקט, יהפוך אותו למערך בתים איך שהוא יודע הכי טוב לעשות את זה, ואז הוא יעביר אותו לסוקט וזה יהיה לנו בתור מתכנתים הרבה יותר קל להשתמש עם השיטה הזאת.
אנחנו לא צריכים להתעסק עם איך בדיוק אני לוקח אובייקט פרודקט, חותך אותו לבתים ושולח אותו לצד השני, או איך אני לוקח מערך בתים שאמור לתאר לי אובייקט פרודקט ומפרק אותו בחזרה ומוציא ממנו אובייקט פרודקט.
לא מתעסקים עם זה, פשוט שולחים אובייקטים. אוקיי, עכשיו אם יש לנו את הנטוורק סטרים אנחנו יכולים לשלוח מידע אליו ואז המידע הזה מגיע לצד השני ויוצא כמידע טהור או כמובן שהקליינט יכול לשלוח מידע לסרוור והסרוור מקבל אותו בצד השני ומשיג את המידע.
כמובן זה לא חייב להיות שהסרוור קודם כל שולח ואז הקליינט מקבל. יכול להיות שפשוט הקליינט קודם כל שולח, אנחנו מחליטים על התקשורת הזאת בינינו לבין עצמנו.
אחרי שראינו את כל המונחים האלה אנחנו יכולים להיכנס לוויז'ל סטודיו ולהרים דוגמה לאוויר וכאמור הדוגמה הזאתי מכילה גם תוכנה שהיא סרבר וגם תוכנה שהיא קליינט, אלו שתי תוכנות שונות לגמרי שכל אחת רצה על המחשב הייעודי שלה.
כרגע יש לנו סרבר אחד וקליינט אחד ויחיד, בהמשך אנחנו נראה איך אנחנו יכולים לבנות מערכת שיש בה כמובן הרבה קליינטים וכמובן סרבר אחד שהתפקיד שלו זה לתת שירות לכל הקליינטים האלה.
אז בואו נצלול לתוך הקוד ונראה איך זה מתבצע. אז פתחתי פה סולושן ריק לגמרי ואנחנו רוצים להוסיף שני פרויקטים חדשים לסולושן ובואו נבחר פרויקט מסוג Console Application גם לסרבר וגם לקליינט בכדי שכל הקוד הזה יהיה כמה שיותר פשוט.
בתור התחלה כל מה שאנחנו רוצים לעשות זה להתחבר בין קליינט לסרבר להעביר מידע מהקליינט לסרבר ומהסרבר לקליינט או הפוך איך שבא לנו התוכנה הראשונה שנרים תהיה סרבר אז אני פשוט קורא לתוכנה הזאת סרבר נבצע אוקיי ואנחנו יכולים להרים את התוכנה הבאה בתור שהיא הקליינט בואו נצרף עוד קונסול אפליקיישן
זאת תהיה קליינט, נבצע אוקיי ונתחיל קודם כל עם הסרבר. הדבר הראשון, בואו ניגש לסרבר ובכדי שנדע שהדבר הזה זה סרבר אז נגדיר console.title=server בצד של הקליינט נגדיר console.title=client כדי שנוכל ישר על הקונסול להבדיל ביניהם וקודם
קודם כל נלך ונבנה את צד הסרבר כי הוא זה שצריך קודם כל להעלות לאוויר ולהאזין. אז איך אנחנו מבצעים את ההאזנה? אז דבר ראשון, מה שאנחנו צריכים לעשות זה להרים לאוויר איזשהו רכיב תכנותי שמסוגל להאזין להתחברות לקוחות.
הרכיב הזה נקרא TCP Listener. בואו נבנה אובייקט חדש ממנו ופעימו לב שהוא אומר לנו תביאו לי בבקשה פורט אם אתם צריכים להגיד לי פורט רק לאיפה אתם רוצים שאני אאזין במחשב הנוכחי ואני אאזין אליו כי הקליינט כשהוא שולח לי מידע הוא אמור לשלוח לי את המידע הזה ספציפית
לפורט הזה כי הרי יש מלא פורטים שכולם קשורים לכל מיני תוכנות אחרות אני רוצה פורט אחד שאני אאזין עליו וכמובן דרכו גם אני אשלח מידע לקליינט אם אתם רוצים אז בואו נמציא פורט נמציא את הפורט 80, 85, נקווה שהוא פנוי, אם הוא לא פנוי מקסימום אנחנו נחטוף עליו אקספצ'ן, יגידו
לנו שהפורט הזה תפוס ואנחנו יכולים למצוא פורט אחר. כמו שאתם רואים קיבלנו פה איזושהי הערת קומפילציה, בואו נרחף מעליה ונראה שמה שאומרים לנו זה שהקונסטרקטור הזה שמקבל אינטג'ר הוא אובסוליט, כלומר מיושן וממליצים לנו להשתמש באיזשהו קונסטרקטור אחר שמקבל אובייקט מסוג IP אדרס שמצביע על
ה-Local Address. מה זה אומר לוקל אדרס? ה-IP אדרס של הסרבר וגם פורט. יש כמה אפשרויות לפתור את האישו הזה. אפשרות ראשונה להתעלם לגמרי מההערה הזאתי ולעבוד איתה, זה עובד פרפקט לפי הניסיון שלי.
אפשרות שנייה זה להשתיק את ההערה, אם אתם רוצים להשתיק הערת קומפיילר אתם יכולים לבוא לכאן ולרשום pragma warning disable 618. 618 זה בעצם מספר של ההערה הספציפית שמציינת שמשהו אובסוליט, הוא מיושן.
ושימו לב שאיך שכתבנו את זה ההערה נעלמה והשיטה אולי היותר מומלצת זה פשוט לעשות את מה שהם אומרים. מה שהם אומרים לנו זה basically לבוא לפה ולתת אובייקט מסוג IP address.
איך אנחנו עושים את זה? בואו ניקח IP address.parse וניתן לו את ה-IP של המחשב המקומי. מה ה-IP address של המחשב שלי?
אז אנחנו יכולים להיכנס ל-run.cmd ולכתוב כאן IP config. הפקודה הזאתי אם אתם מריצים אותה תראה לכם את ה-IP אדרס של המחשב שלכם ואז תוכלו לגלות מה ה-IP אדרס בואו נעשה את זה ונראה שהוא אומר לנו שה-IP אדרס שלנו זה 192.168.56.1 אוקיי אז אנחנו יכולים להעתיק את ה-IP אדרס הזאת ולהשתמש בה כ-IP אדרס של המחשב
שלנו בואו נצא החוצה אבל יש שיטה קצת יותר נוחה לפחות בתור התחלה. אנחנו יכולים לרשום את ה-IP אדרס Localhost, שזה בעצם IP אדרס או שם קבוע ל-IP אדרס שמתאר את המחשב הנוכחי, או במילים אחרות 127.0.0.1 זה Localhost, זה גם כן אומר שזה IP אדרס של המחשב הנוכחי שעליו רצה התוכנה הזאת.
בה אנחנו רואים כרגע שיש לנו כאן את האפשרות להגדיר את ה-tcp-listener שכאמור מאזין להתחברות של לקוחות כל הזמן מאזין מאזין מאזין עד שלקוח מתחבר.
הדבר הבא שאנחנו צריכים לעשות זה listener.start בסוף בסוף בסוף listener.stop בשביל להיפטר ממשאבים בצורה כזאת בואו ניפטר קודם כל מכל מיני ניימספייסים שאנחנו לא משתמשים איתם אני אשאיר את ההערה הזאת כאן בכדי שנזכור אולי כן ירצה בעתיד להשתמש בזה ולא בשיטה הזאת ויש לנו עכשיו את הליסנר שמסוגל להאזין והוא באמת באוויר בעצם.
איך אנחנו מאזינים להתחברות לקוחות? listener.acceptSocket הפונקציה הזאת זו פונקציה שלא מקבלת כלום ומחזירה לנו את אותו אובייקט סוקט שראינו בפרזנטציה בהתחלה.
ואנחנו יכולים עכשיו לקבל את אובייקט סוקט. הסוקט הזה זה הסוקט שמצביע לנו לקליינט. ברגע שקליינט יתחבר, רק אז אנחנו מקבלים את הסוקט אליו. אז מה קורה אם אנחנו מריצים את הפקודה וקליינט לא יתחבר? כי קליינט יכול להתחבר עכשיו, הוא יכול להתחבר גם בעוד חמש שעות.
אז הפקודה הזאת נחשבת ל-Blocking Operation. לוקינג אופריישן זאת פקודה שממתינה ונתקעת עד שלא מתחברים אלינו. אם מישהו מתחבר אלינו, רק אז הפקודה הזאת מחזירה לנו את הסוקט שלו, את הסוקט אליו, קו תקשורת אליו, ואנחנו פה כבר יכולים לתקשר איתו.
שימו לב רק שכמובן בגלל שהדבר הזה תוקע לנו את הזרימה של התוכנית, במציאות אנחנו נרצה להריץ את זה בטרד נפרד בשביל לשחרר את התוכנית. אנחנו כמובן נעשה את זה בהמשך.
כרגע אני רוצה את הדבר הכי פשוט, להאזין ללקוח, להתחבר אליו, לשלוח לו מידע, לקבל ממנו מידע ופה לסיים את כל התקשורת.
למה אנחנו עושים את זה כל כך פשוט? רק בכדי להכיר את הנפשות הפועלות בכל הסיפור הזה של TCP/IP. יש לנו עכשיו סוקט ללקוח. מה אנחנו רוצים לעשות?
סוקט, נקודה, בואו נתחיל עם send כמו בפרזנטציה. אנחנו יכולים לבצע send ולשלוח אליו מערך בתים. שימו לב, אם אנחנו חופרים פה, אנחנו רואים שיש לנו כל מיני שיטות שונות של מערכי בתים, אבל אנחנו עובדים עם הרמה הנמוכה ביותר של מידע שאנחנו יכולים להעביר.
הסוקט לא יכול להגיד לנו תביאו לי אובייקט פרסון או תביאו לי אפילו סטרינג, הוא לא יכול להגיד לנו את זה, הוא אומר לנו תביאו לי בתים, אני אזרוק אותם לצד השני וזהו, אני לא יודע מה אתם מביאים לי, מה הבתים האלה מייצגים, אני ממש אובייקט לואו-לבל מה שנקרא.
טוב, בשביל שהדוגמה הזאת תהיה מאוד מאוד פשוטה, בואו נעשה מערך בתים. בואו ניצור כאן בית בצורה כזאת, ונכניס לתוך הבית הזה סדרה של בתים.
בואו נכניס סך הכל ארבעה בתים בצורה כזאת ונשלח את המערך. זאת אומרת, מה שעשינו עכשיו זה שלחנו מידע מהסרבר לצד השני.
מי זה הצד השני? הקליינט. אז כרגע זו הייתה שליחת המידע מהסרבר לקליינט. הקליינט הולך כמובן לקבל את המידע וכנראה שהוא יציג אותו.
אחרי זה אנחנו נבצע שהקליינט ישלח לנו בחזרה מידע ואנחנו עכשיו רוצים לקבל את המידע בחזרה. לסוקט יש פונקציה שנקראת receive. פונקציית receive אומרת לנו תביאו לי מערך בתים שהוא ריק ואני אמלא אותו במידע שיתקבל.
אוקיי בואו לצורך הדוגמה נבצע כאן כזה דבר הרי בוא נקרא לזה bytes to send ונשלח אותם ובואו ניקח פה מערך אחר בייטס רסיב נכין את המערך עצמו וגם כן נכין מערך בגודל 4. במציאות אנחנו בכלל לא נתעסק עם מערכי בתים אז לא יהיה לנו קושי בלהבין איזה בתים הם שולחים לנו הנה המערך והמערכת אמורה למלא אותו בנתונים בסדר אחרי שקיבלנו בחזרה את המערך מהפליינט כל מה שאנחנו רוצים לעשות זה לרוץ ולהציג את המידע על המסך.
בואו נרוץ פה על בייטס אייטם אין בייטס רסיבד ונציג את האייטם בצורה כזאת ופשוט נכתוב פה בייטס רסיבד פרום דה קליינט ואז אנחנו אמורים לראות את מה שהקליינט שלח לנו.
בואו נראה מה עוד יש לנו כאן נראה אם לסוקט יש דיספוז יש לסוקט דיספוז אם לסוקט יש דיספוז אז אנחנו צריכים את כל הסיפור הזה לבצע על ידי יוזינג בואו כרגע לצורך הדוגמה בואו נעשה פה יוזינג בצורה כזאת ובעצם מה שעשינו פה זה שחררנו את המשאבים של הסוקט מה עוד שווה לעשות אולי כדאי שאת
זה נבצע כאן אנחנו לא בעצם אנחנו לא יכולים כי המערך הזה בפנים בסדר נשאיר את זה בפנים מעולה בעצם סיימנו את הפרויקט של הסרבר שכל מה שהוא עושה הוא מאזין להתחברות של הלקוח.
רק כאשר הלקוח התחבר אז אנחנו ממשיכים ושולחים לו בעצם מידע ואז פה אנחנו ממתינים למידע של הלקוח וחשוב לציין שגם הפקודה הזאת היא בלוקינג אופריישן.
כאשר אנחנו מאזינים אז אנחנו לא נזוז עד שלא קיבלנו את המידע. רק כשקיבלנו את המידע אנחנו נזוז ונעשה איתו פעולה כלשהי. במציאות גם הפקודה הזאת תתבצע על ידי טרד נפרד בלי קשר לפקודה הזאת שמאזינה להתחברות של הכוחות שגם היא בטרד נפרד.
אוקיי אז בואו נעבור עכשיו לצד של הקליינט. הנה הצד של הקליינט נשים את שניהם סייד ביי סייד כדי לראות מה בדיוק עשינו אחד ליד השני. הדבר שאנחנו רוצים לעבוד עם הקליינט זה לא להשתמש ב-tcp listener כי זה רכיב שמאזין להתחברות לקוחות לקליינט.
הקליינט עצמו לא צריך להאזין להתחברות לקוחות הוא צריך להתחבר לסרבר והוא עושה את זה על ידי רכיב שנקרא tcp client. כאן אנחנו יוצרים אובייקט חדש מ-tcp client ואנחנו משתמשים בפונקציה שנקראת קונקט בשביל להתחבר