Console Self Host
ServiceContract מעל הממשק ICalculator.OperationContract מעל כל פונקציה שרוצים לחשוף.http://127.0.0.1:6065/MyCalculator. ה-MyCalculator הוא נתיב וירטואלי בלבד ואין לו קובץ פיזי במחשב.BasicHttpBinding.typeof(ICalculator).ServiceHost ומעבירים לו את הטיפוס Calculator, וההוסט יוצר את האובייקט בעצמו. מוסיפים endpoint באמצעות AddServiceEndpoint, ומעבירים לו לפי הסדר את הקונטרקט, את הביינדינג ואת האדרס.ServiceMetadataBehavior עם HttpGetUrl, שהוא הכתובת שבה יושב מסמך ה-WSDL, ועם HttpGetEnabled = true. ברירת המחדל של HttpGetEnabled היא false, ולכן צריך להפעיל אותו במפורש. מוסיפים את ההתנהגות להוסט.myHost.Open() מעלה את השירות לאוויר.Console.ReadLine() משאיר את הקונסול פתוח, כדי שהשירות לא ייסגר.פרקי ההרצאה: Console Self Host
תמלול ההרצאה: Console Self Host
הטקסט המלא של הדקות הראשונות בהרצאה «Console Self Host» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
כעת אנחנו הולכים לראות איך אנחנו חושפים את השירות החוצה לעולם. אנחנו הולכים לבנות את ה-host. לצורך כך יש לנו דבר קטן להוסיף בקלקולטור, בשירות שלנו.
אנחנו צריכים קודם כל להוסיף רפרנס שנקרא System Service Model, כדי להגדיר כמה הגדרות בשירות שהוא ה-DLL שלנו. אז אנחנו מוסיפים אותו ל-DLL, ומה שאנחנו צריכים להגדיר זה סך הכל את הדברים הבאים:
א', שאנחנו רוצים לחשוף החוצה, בעזרת WCF, את הממשק i-קלקולטור, יותר נכון את הקונטרקט, כי ממשק אינטרפייס שווה במילים אחרות קונטרקט.
ואנחנו רוצים לאפשר לעולם להכיר את החוזה הזה. אנחנו מגדירים כאן Service Contract, אטריביוט שנקרא Service Contract והוא נמצא מעל לאינטרפייס עצמו.
בנוסף, אנחנו צריכים להגדיר מעל כל פונקציה אטריביוט שאומר שאנחנו רוצים לחשוף אותה. אז בואו נגדיר מעל פונקציית add את האטריביוט, והאטריביוט נקרא Operation Contract.
נגדיר את זה גם מעל שאר הפונקציות. באמת השירות שבנינו הוא חשוף לעולם, או יותר נכון מוכן להיות חשוף לעולם. אוקיי, מה הדבר הבא שאנחנו צריכים לעשות? אנחנו עכשיו מוכנים ללכת ולבנות את ההוסט.
בואו נסגור את מה שלא צריך לראות, יש לנו את הקלקולטור, פורום, ונישאר כרגע עם הקונסול הוסט שלנו, פרוגרם CS. ברגע שאנחנו בונים פרויקט משלנו, שאנחנו מריצים בעצמנו, כמו קונסול אפליקיישן, Windows פורמס אפליקיישן, WPF וכדומה, זה נחשב כ-self host מפני שאנחנו
בעצמנו חושפים או מרימים יותר נכון את הפרויקט לאוויר. אם אנחנו היינו מרימים את הפרויקט הזה על IIS שאנחנו נראה בהמשך איך עושים את זה, אז זה לא נחשב כ-self host זה נחשב כ-IIS host.
אז אנחנו בונים console application שמריץ את זה ולכן זה עכשיו self host. דבר ראשון אנחנו צריכים להוסיף ל-self host שלנו שני DLLים. DLL ראשון זה ה-DLL שאנחנו בנינו כאן וזה בעצם השירות והוספנו אותו מקודם.
DLL שני זה אותו DLL שהוספנו מקודם והוא System.ServiceModel בואו נוסיף גם אותו ואנחנו מוכנים לבנות את ה-host ולחשוף החוצה את השירות לאוויר בשביל לחשוף את השירות לאוויר החוצה אנחנו צריכים להכיר מונח שנקרא ABC ABC זה קיצור של Address Binding Contract והמונח הזה סך הכל מתאר איפה בכל העולם נמצא השירות שלנו זה בעצם יהיה האדרס מהי שיטת תקשורת
הנתונים זה יהיה הביינדינג ומהו החוזה שנחשף לעולם וזה יהיה ה-contract שזה ה-i-calculator שבנינו. אנחנו צריכים לבנות את כל אחד מהם אז בואו נגדיר string address ונגדיר כתובת במחשב הזה שהשירות חי וקיים בכתובת הזאת או אמור להיות בכתובת הזאת.
אז נשתמש כרגע בפרוטוקול תקשורת HTTP בגלל שאנחנו במחשב הנוכחי ומתחברים ממנו אליו אז יהיה לנו 127.001 שזה בעצם כתובת המחשב הנוכחי לאחר מכן נמציא פורט ניקח 60.65 סתם פורט שהמצאתי ולבסוף אנחנו צריכים להגדיר נתיב וירטואלי נוסף שיושב בפורט הזה, ושם השירות יחיה או ייחשף לעולם.
ונגדיר מיי קלקולטור, משהו פשוט, אין דבר כזה במחשב, זה רק נתיב וירטואלי שהשירות מאזין בו, ואם מישהו יתחבר בדיוק לכתובת הזאת הוא יוכל לקבל את השירות.
לאחר מכן, אחרי שבנינו את האדרס, אנחנו צריכים לבנות את הביינדינג. יש כל מיני סוגי ביינדינג, אנחנו נראה בהמשך מה הם, אבל כרגע אנחנו ניקח את ה-HTTP הפשוט ביותר, והוא נקרא Basic HTTP Binding.
זה סך הכל אובייקט שאנחנו יוצרים מטיפוס Basic HTTP Binding, וזה מתאר את שיטת תקשורת הנתונים. לאחר מכן אנחנו צריכים להגדיר את הקונטרקט. קונטרקט ראינו זה האינטרפייס שאנחנו בנינו, זה החוזה בין מחלקות שמתאר מה חשוף במחלקה מסוימת.
זה מתואר על ידי אובייקט מטיפוס טייפ. נגדיר type of ואת i-קלקולטור. יש לנו כרגע את ה-ABC ואנחנו מסוגלים עכשיו לחשוף אותם לאוויר. לצורך חשיפה לאוויר אנחנו בונים אובייקט מטיפוס Service Host, נקרא לו My Host, ו-My Host אמור לדעת איזה שירות הוא משתמש איתו או חושף אותו.
אם היה לי את האובייקט של המחלקה Calculator מוכן הייתי יכול פשוט לתת אותו, אני רואה שאני מקבל פה Object, Singleton, לתת את האובייקט במחלקה Calculator וה-Service Host היה חושף אותו לאוויר, שאנחנו מגדירים לו את ה-ABC ועוד כל מיני הגדרות שאנחנו כבר הולכים לראות.
אבל אם אין לי אובייקט כזה, אז אני יכול פשוט לתת לו type of Calculator והוא ייצור בשבילי אובייקט כזה. הוא חייב ליצור אובייקט או שאני חייב לתת לו איזשהו אובייקט, מפני שהשירות שלי בפועל מתואר על ידי ה-i Calculator, אבל המחלקה שמספקת את השירות היא Calculator וחייב להיות לי איזשהו אובייקט שמספק את השירות
הזה, בניגוד לקונטרקט שרק מתאר מה השירות. אחרי שיש לנו את המיי הוסט, שזה בעצם הרכיב שהולך להרים להעביר את השירות, אנחנו צריכים לצרף לו את ה-abc שהגדרנו.
אנחנו פונים לפונקציה שנקראת addServiceEndpoint, ואנחנו מצרפים את שלושת הנקודות abc שמקודם הגדרנו. אז קודם כל נתחיל עם קונטרקט, זה הדבר הראשון שהוא מקבל.
לאחר מכן ביינדינג, ולבסוף אדרס, זה הסדר שצריך לשלוח לפונקציה. שוב, זאת נקודת הקצה והיא מתוארת על ידי ה-abc.
שלושת הרכיבים האלה האדרס והביינדינג והקונטרקט יוצרים לי מה שנקרא end point נקודת קצה שבה אנחנו יודעים מה הכתובת מה היא שיטת תקשורת הנתונים ומה השירות שאנחנו חושפים בעצם.
עכשיו אנחנו צריכים להבין דבר נוסף לגבי השימוש של הלקוח בשירות. איך בעצם הצרכן שלנו יותר נכון הולך להשתמש בשירות אנחנו ראינו לפני זה שהשירות יושב על שרת והצרכן שלנו זה בעצם אפליקציה שיכולה להיות אפליקציה חלונאית יכולה להיות dll יכולה להיות console יכול להיות website יכול להיות כל מיני אפליקציות אם מתכנת בונה את
האפליקציה הזאת והוא רוצה להשתמש בשירות שלנו אז הוא חייב לכתוב קוד הוא חייב לבנות אובייקט ממחלקה מסוימת שדרכה הוא הולך להגיע לשירות שלנו אבל איך אותו מתכנת מכיר את המחלקה הזאת.
אז המחלקה שהמתכנת בעצם אמור לבנות זה לא אובייקט מהמחלקה המקורית של השירות שלי, כי המחלקה שלי רצה בשרת ובכלל היא יכולה לגשת למסד נתונים, או להשתמש במשאבים של השרת.
לא יכול להיות שהוא יבנה אובייקט מהמחלקה כלקולטור אצלו במחשב.