תחומים - פורום חרדי מקצועי

dovid

הבעיה שלי כרגע היא שהפרוייקט מוגדר תחת namespace אחר (למרות שחשבתי על זה ולכן מראש יצרתי אותו ע"י file>add>new project
אבל זה לא עזר (מלבד זה ששני הפרוייקטים מופיעים לי בחלונית הניווט בצד..)
אח"כ הוספתי את המרחב שמות הראשון של המחלקות ע"י project>add refernce ומתוך הsolution > project בחרתי בו.
עכשיו אני מנסה להפנות אליו ע"י using אבל הוא ממאן להוסיף אותו וכותב לי הודעת שגיאה..

המושג namespace הוא מאוד מאוד קוסמטי. במקרה שלך המילה הנכונה היא לא namespace (שיכולים להיות רבים בפרוייקט אחד והמושג "ייבוא" לגביהם עשוי בד"כ סה"כ לחסוך את הכתיבה המלאה), אלא אסמבלי ("יחידה". זה שם שנתנו מפתחי הדוט נט ליחידת קוד דוט נטית - DLL או EXE וכו'). כל פרוייקט מקומפל לאסמבלי משלו, וכדי לפנות מאסמבלי אחד למחלקה שנמצאת באסמבלי אחר יש לבצע Reference.
אם אני מבין נכון: יש לך solution עם פרוייקט מתפללים ופרוייקט חלונאי של WPF. עשית refernce מהWPF למתפללים. בנתיים הכל מעולה, ולכתחילה. רק שאתה נתקל בשגיאה. אנא פרט השגיאה.

@avr416

חשבתי להגדיר לו כתגובה לאירוע הלחיצה שיצור מתפלל חדש בתוך list של מתפללים, ואז לתת שם לכל תיבת טקסט בנפרד ולהגדיר שהתוכן שבתיבה הזאת = מאפיין הנ"ל וכן הלאה. אלא שאינני יודע מהו הקוד שיודע לזהות את התוכן שבתיבה ולשים אותו במשתנה?

בWPF יש שתי אופציות לתקשור עם הUI. או לתת שמות לפקדים ואז יש לך גישה אליהם כמו בWINFORMS. כלומר אם יש לך תיבת טקסט ואתה מוסיף בה את האטריביוט Name (ברירת מחדל בגירסאות ישנות או חדשות של VS למעט 2013) אז אתה יכול לפנות למופע של החלון נקודה שם התיבה שבחרת. זה אופציה א', היא פחות "טובה" (כי יש תלות בין הקוד לתצוגה, כלומר אם תחליף תצוגה תצטרך לשנות חלקים בלוגיקה) אבל היא יותר פשוטה והייתי ממליץ לך עליה במקרים פשוטים או בתור התחלה.
האופציה השניה והמומלצת בד"כ זה עבודה עם Binding. בדרך זו נותנים באיזה שהוא אופן לDataContext של אלמנט ב"עץ" של התצוגה את האובייקט שלך, נניח מתפלל חדש. כעת כל מאפיין של אלמנט כמו Text של TextBox ניתן ל"איגוד" למאפיין של המחלקה מתפלל ע"י ביטוי Binding. זה נראה ככה

Text="{Binding LastName}"

(זה בהנחה שהDataContect של הtextBox או אחד מאבותיו מוגדר, ולמחלקה שלה יש מאפיין בשם LastName).

@avr416

כמו כן, ראיתי שבwin form יש לו אפשרות ליצור אוטומטית תפריט סטנדרטי של תוכניות וינדוס, האם גם בWPF יש דבר כזה? (לא מצאתי..)

לא יודע בדיוק למה אתה מתכוון, כנראה שאין את זה בWPF.

@avr416

נ.ב. דוד ל.ט., שמרתי את המדריכים שלך, ועוד כמה תשובות שענית בפורום כקובץ PDF ואני אדפיס אותם מחר (בלנ"ד) כדי שאוכל לשבת וללמוד אותם בכובד ראש בהמשך!! כה לחי!!

דוקא אני ממליץ לך להמתין עם זה.
אני לא חושב שהמדריכים שלי נחוצים לך בשלב זה (הם נקודתיים מאוד).

פורסם במקור בפורום CODE613 ב25/05/2015 12:20 (+03:00)

dovid

השאלות שלך דבש!

א. בשביל להגדיר מאפייני מחלקה אין צורך בכלל לקבוע בנאי שעושה את העבודה הזאת (X=x' Y=y...). ובכלל בנאי הוא לא חובה כלל (למעשה כשאין בנאי הקומפיילר יוצר אחד בעצמו ללא פרמטרים).
קביעת מאפיינים נעשית דרך שם המחלקה נוקדה שם המאפיין והשמה:

var obj = new MyClass();
obj.SomeProperty = "some value";

לנוחות קביעת המאפיינים עם בניית המחלקה אפשר להשתמש בתחביר Object Initializer, ככה:

var obj = new MyClass
{
    SomeProperty = "some value",
    anotherProperty = "123"
};

ב. בדרך כלל משתמשים בבנאי בשביל לקבוע "התקנה" של המחלקה שלנו. כלומר דברים שנחוץ לעשות מייד ביצירת המחלקה, בשביל זה עושים בנאי. לפעמים העבודה הזאת דורשת פרמטרים. למשל כשיוצרים מחלקה מסוג FileInfo יש בנאי שמקבל טקסט שמייצג את השם המלא של הקובץ.
במחלקות מסוג struct חובה לאתחל את המאפיינים בבנאי ולכן יש מחלקות שמקבלים כפרמטרים ערכים למאפיינים שלהם, והם לא נסמכים על הObject Initalizer או על Set של המאפיינים.

ג. אפשר להגדיר בנאי אחד עם הרבה פרמטרים, ולאפשר הזנה חלקית שלהם (זה למעשה מאפיין כל מתודה לא רק בנאי). זו תכונה ששמה Optional Argument. פשוט מזינים אחרי הפרמטר סימן שווה וערך ככה:

public MyClass(int property1, int property2 = 50) { ... }

הפרמטר הראשון הוא חובה, השני ניתן להשמטה ואז הערך המתקבל לבנאי הוא 50. בערכים שמקבלים null אפשר כמובן להשתמש בnull בהשמה.
כעת מה אם רוצים לשים חלק מפרמטרים אופציונליים? כאשר אלה שמשמיטים הם אחרונים בסדר הפרמטרים אין שום בעיה, אבל אם אני ורצה להציב ערך בפמרטר הראשון והשלישי אז משתמשים בתכונת Named Argumnts, שזה אופציה לא לשייך את הפרמטרים "לפי מיקום" אלא לפי שם:
נניח זה הבנאי:

public MyClass(int property1 = 20, int property2 = 50, string property3 = "default value") { ... }

כל הפרמטרים אופציונליים ואפשר להשמיט את כולם. כמו"כ אם רוצים להציב רק בראשון/ראשון+שני, פשוט כותבים רק פרמטר/שתיים. אך מה אם רוצים את הראשון והשלישי? כותבים ככה:

var obj = new MyClass(25, property3: "MyValueForProperty3");

הפרמטר הראשון מזוהה לפי מיקומו ונשלח לproperty1. אבל השני שיש לו תוית עם נקודתיים מזוהה לפי שמו, ומועבר לפרמטר השלישי.

שוב, במקרה הקלאסי של הגדרת מאפיינים, אל תשתמש בכלל בבנאי.

פורסם במקור בפורום CODE613 ב20/05/2015 13:06 (+03:00)

dovid

השרת אליו פונה הAJAX נמצא באותו שרת שהחזיר את הדף?
או שמדובר בדומיינים נפרדים?
כמו"כ נסו לאפשר GET ולראות האם זה מגיב לבקשות.

פורסם במקור בפורום CODE613 ב18/05/2015 21:41 (+03:00)

dovid

לגבי JS...
אני לא באמת יודע. הנה הרגע גיליתי שטעיתי במשפט הזה:
@דוד ל.ט.

התשובה הזו נכונה גם לJS שהרי אובייקט לא נותן את הפונקציונליות הראשית של מערך שזה מבנה נתונים רציף חסר שם לגישה מהירה.

בJS מערך זה לא באמת מערך http://blog.niftysnippets.org/2011/01/myth-of-arrays.htmlblog.niftysnippets.org/2011/01/myth-of-arrays.html.

ומערך אמיתי זה כנראה פה https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays.

פורסם במקור בפורום CODE613 ב21/05/2015 17:32 (+03:00)

dovid

אתה רוצה ליישם בעצמך אלגוריתמים.
אבל שתדע מראש: כל הדברים האלו קיימים בצורה מיטבית (בכל שפה). כך שאתה עובד נטו בשביל הספורט (בריא אמנם).

פורסם במקור בפורום CODE613 ב21/05/2015 16:22 (+03:00)

dovid

@אהרן

דבר נוסף
אשמח להסביר על HASH
המרת מחרוזת לערך מספרי
ככל שאני מבין החישוב הוא כך
ערך איבר 1 * 1

ערך איבר 2 * (ערך מקסימלי של איבר 1 + 1 *1 = אינדקס 2)

ערך איבר 3 * (ערך מקסימלי של איבר 1 + 1 * אינדקס 2 = אינדקס 3)
אכן?
יש טכניקה המאפשרת להקטין את ערך המספר הסופי?

HASH זה מטרה עם המון אלגורותמים.
והמטרה היא להפוך ערך לערך אחר בעל אורך מצומצם שבכל אופן ייצג אותו.
זה לא קשור לשפה כזו או אחרת, ויש לזה המון מימושים (צורות שונות להגיע לתוצאה דומה), אני לא מכיר אפי' אחת (:) אני מתכנת, לא מושעמם. או אני מתכנת, לא חכם... או "בשביל מה יש כבר ספריות מוכנות בשביל זה?" או "כבר גמרתי את הלימודים") אז אני לא יכול לעזור לך, אבל אני זוכר שבויקי יש הרבה.

@אהרן

השאלה היתה על כלל השפות
זה נכון גם לגביהם?

@אהרן

אשמח גם להסבר מה ההבדל בין מערך לאוביקט
איברים במערך לא שווים למתודות באובייקט?

בעיקרון השוואת שפות בנושאים האלו רגישה: יש שפות שאין בכלל אובייקטים...
המילים "מתודת באובייקט לא שווים לאיברים במערך" מריחים JS למרחוק :). אני לא מספיק יודע איך מסודרים האובייקטים בשפות אחרות מJS, ואני מאמין שברמת המחשב זה דומה, אבל במרת המתכנת מתודה היא לא איבר ולא כלום. היא נטו כלי לשימוש חוזר ע"י קריאה אליו. ברוב השפות המודרניות, קוד בשביל לדעת איזה מתודות יש במחלקה בה אני נמצא (שבJS זה פשוט הkeys במחלקה Object) נחשבת לנושא מתקדם בשם Reflection (שיקוף - כמו צילום רנטגן לראות את העצמות, אתה רוצה לראות "מבחוץ" את המתודות של המחלקה) והצורך שלו מוגדר למקרים חריגים, והוא לא קיים בכל שפה!.
המושג מערך זה מבנה נתונים - צורת שמירה בזיכרון, רציפה, כאשר כל איבר מופיע לפי הסדר במקומו בזיכרון. הכתיבה והקריאה למערך מבוססת על מיקום הערך. והשמה במיקום גבוה פירושו שיש רצף מתחילת הזיכרון עד למקום הגבוה (נגיד a[500] = 4 אומר שיש בזיכרון מקום עבור 400 מספרים (תא למס' שלם בד"כ זה 32 סיביות - 4 בתים) לכל הפחות ברצף).
הקריאה והכתיבה למערך היא מהירה מאוד, בגלל שלא מבוצע חיפוש אלא מיד משוקללת הכתובת (כתובת המערך - שזה איבר ראשון + (היסט שזה האינדקס * גודל תא).
בכל השפות עיליות העבודה מול מערך נעשית ע"י אובייקט המוגדר בספריה היסודית של השפה. ממילא המערך עצמו הוא סוג של אובייקט, אך אובייקט בכלל לא נותן פונציונליות של מערך. לא מינה ולא מקצתה, שלא כמו בJS, שם כל אובייקט זה "מילון" של שם וערך.
ניתן להשוות את השניים בשאר השפות כמו שאלה מה ההבדל בין חתיכת ברזל לבין מברג פיליפס. המברג הוא אכן וריאציה של חתיכת ברזל, אבל חתיכת ברזל לא מבריגה. התשובה הזו נכונה גם לJS שהרי אובייקט לא נותן את הפונקציונליות הראשית של מערך שזה מבנה נתונים רציף חסר שם לגישה מהירה.

פורסם במקור בפורום CODE613 ב21/05/2015 15:02 (+03:00)

dovid

בקשר לJS: טריד אחד בלבד. הוא עושה רק פעולה אחת בו זמנית. לא יכול לעשות שתיים. רק סדר הפעולות הוא לפי זמינות. כשהוא קרוא לGET מהאינטרנט ומחכה לתשובה הוא עושה פעולה אחרת ואח"כ לוקח את התשובה הגיע ע"י EVENT. כך נראה לי.
לא דברתי על פוקנציה תלויה בפונקציה וכו'.
כעת לתכונות המבלבלות של JS. אז בJS הכל זה אובייקטים. הכל אבל הכל. דוגמה:

var MyFunction = function() { console.log("hi hi hi"); };
MyFunction.p = 1;

המשתנה MyFunction הוא אובייקט שמכיל איבר חסר שם מסוג פונקציה, שהוא זה שמופעל אם תכתוב את שמו עם סוגריים אחריו. יש לו בנוסף עוד איברים בעלי שם כמו p שהוגדר להכיל 1.
כעת כשיש לך אובייקט כל שהוא ואתה כותב ככה:

MyFunction["p"] = 123;

זה שקול לגמרי לזה:

MyFunction.p = 123;

סה"כ השמת מאפיין. יש הבדל, והוא שע"י סוגריים מרבעות אפשר לבחור שמות שמורים ועם רווח וכו'.
כדי לראות את כל ההשמות הללו:

Object.keys(MyFunction);

כעת מערך, הוא דבר ראשון גם אובייקט וחלות עליו כל הבלבולים שהראתי בפונקציה. נוסף עליו תכונות המערך שהם גישה לפי מיקום, זה נראה בדיוק כמו אובייקט אבל א: אין שמות לאיברים. הם פשוט נמצאים במקום שנקבע להם. ב. האיברים מוצבים ע"י מספר למיקום. אם שמת באינדקסר (הסוגריים המרובעות) טקסט זה לא ייכנס כאיבר במערך אלא כמאפייין נוסף באובייקט המערך. ג. השליפה וההשמה מבוצעים ביעילות רבה יותר מאשר באובייקט.

בהצלחה בבלבול, ואולי תלמד דחוף שפה נוספת כדי שתידע מה JS רוצה מהחיים שלך :).

פורסם במקור בפורום CODE613 ב20/05/2015 19:25 (+03:00)

dovid

avr416 ממש תודה שנפלת לפה (מהשמים.. ).
אני ממש שמח מבואך ומאחל שלא תתאדה כמו אורחים קודמים .
תודה על שפע המחמאות והתודות (תתחיל להתקמצן, אחרת נפסיק להתרגש ).
אני לוקח את הערות שלך לתשומת ליבי.

@avr416

במדריך על הDelegate עדיין לא הצלחתי להבין מדוע להשתמש בו? מה רע לקרוא ישירות למתודה עצמה? למה אנחנו צריכים לקרוא לדבר שמייצג אותה?

אתה קראת הכל? יש דוגמאות שמה. אבל אולי הם לא ברורות מספיק.

פורסם במקור בפורום CODE613 ב18/05/2015 17:03 (+03:00)

dovid

חברה, מחיאות כפיים בבקשה.
אני כותב מדריך על תהליכים בC# (הנה הלינק http://tchumim.com/topic/667 למי שלא דורך בפורום מדריכים ולא נכנס לפורום דרך הקישור החביב הצג נושאים פעילים).
נו ומה אני רוצה? טוב אז דבר ראשון צומי :roll: .
דבר שני לדעת האם יש לאנשים הערות/רעיונות על דרך כתיבתי ועל הנושאים לכתוב בהווה ובעתיד.
אני יודע די טוב C#, WPF. נוגע הרבה בEntityFramwork וכעת גם בASP.NET MVC.

תודה מראש למתייחסים .

פורסם במקור בפורום CODE613 ב18/05/2015 13:03 (+03:00)

dovid

@Pesia

איזה התקפה...

לא ראיתי התקפה, הוא רק אמר את דעתו.
והוא מתכנת מקצועי לפי מה שנראה בפורום.

ואני חושב שבישקול הוא קריאות. אם זה מסובך בהתבוננות ראשונה, לפרק. אם לא, זה עניין של טעם.

פורסם במקור בפורום CODE613 ב19/05/2015 19:32 (+03:00)

dovid

אני חושב שהתכונת לזה.

string str = base.ToString() + "Birthday:" + birthday.ToString();
return str;

פורסם במקור בפורום CODE613 ב17/05/2015 14:32 (+03:00)

dovid

אני מנחש שאתה לא עושה את העצה של ClickOne כי זה גדול עליך.
אז לאט לאט.

הוסף למודול VB מתודה ריקה ופונקציה ככה:

Sub TestSkill()
   MsgBox ClickOneImplation("כתובת קלאסית לבדיקה 5/2 ב'")
End Sub

Function ClickOneImplation(unput As String)
    
    
    ClickOneImplation = "פה בסוף תתן את הפלט"
End Function

כנס עם הסמן למתודה הנקראת TestSkill והקש F5.
לאט לאט נסה להבין מה ואיך ולבצע צעד אחר צעד את הרעיון של ClickOne. כשההודעה תביא את הטקסט הרצוי, תעתיק את הרעיון ללולאה שעוברת על כל הרשומות.

פורסם במקור בפורום CODE613 ב14/05/2015 17:31 (+03:00)

dovid

@avr416

אם אני מבין נכון, נכון לומר שwpf זה פלטפורמה לפיתוח תוכנה שולחנית עם ממשק משתמש מעוצב גרפית. אבל המימוש של התוכנה עדיין משתמש באותה שפה

בדיוק.

@avr416

ולא מספיק (או שלא מומלץ..) לבנות כמה טפסים שפשוט מזינים אוטומטית את הנתונים ישירות למסד הנתונים המרכזי

אין כזה דבר. לא שלא מומלץ, זה פשוט לא קיים. בשביל זה יש את אקסס או תוכנה שמישהו בנה, בWPF למשל

@avr416

הבנתי שעכשיו מיקרוסופט מאפשרים לפתח אפליקציה שיודעת לרוץ על כל סוגי הפלטפורמות (מחשב נייח/נייד) האם זו פלטפורמת פיתוח שונה, או שזה שכלול של WPF?
פותח כבר, רק השתדרג לקראת WIN10 לרוץ גם על פלפורמות זרות (מק לינוקס אנדואיד).

זה פלטפורמה חדשה מעט, דומה מאוד מאוד לWPF. רק מוגבלת בכמה דברים מטבעה - התוכנה רצה בתוך ארגז חול - כמו JS בדפדפן שלא יכול לעשות הרבה בלי רשות.

@avr416

כמו כן, האם נכון לומר שASPNET זה בעצם פלטפורמה לתכנות אתרי אינטרנט, או שלאו בהכרח?

בדיוק.

@avr416

האם בעצם עדיף לקחת נושא אחד ללמוד אותו היטב ולהתמקצע בו או שעדיף (או שצריך) לנסות להקיף וללמוד כמה פלטפורומות כי בסוף צריך לדעת להשתמש בכל הכלים? כלומר, האם עדיף סיני או עוקר הרים :lol:

לא יודע...
מצד אחד צריכים להשקיע בכל דבר שלומדים, אבל מאידך הפיזור עוזר להחליט במה לבנות מערכת, מה החסרונות והתירונות של כל פלטפורמה.

@avr416

(כמו כן, האם יש ספר מומלץ ללימוד WPF?)

אני קניתי את הספר הזה WPF 4.5 Unleashed. אבל יש הרבה אחרים.
יש גם מדריכים אינטרנטיים לרוב:
http://webmaster.org.il/articles/wpf
http://www.codeproject.com/Articles/22980/WPF-A-Beginner-s-Guide-Part-of-n כבד ובאנגלית - אבל יסודי.
http://www.wpftutorial.net/LearnWPFin14Days.html
https://joshsmithonwpf.wordpress.com/a-guided-tour-of-wpf/ תוכן לסדרה בcodeproject

פורסם במקור בפורום CODE613 ב18/05/2015 11:28 (+03:00)

dovid

@avr416

אם אני רוצה לבנות תוכנה עם ממשק משתמש בWPF האם גם בשביל זה אני צריך להגדיר מחלקות וכדו' או שבשביל זה אני מכניס בממשק טבלה והמשתמש מזין לתוכה את נתוני המתפללים, ואח"כ אני יכול להגדיר פונקציות שיפעלו עליה, או כל דבר אחר. או שגם בשביל זה הכי טוב זה לבנות מחלקות, ואח"כ לממש אותם דרך ממשק המשתמש (שאת זה עדיין אין לי מושג איך עושים.. אבל אני מניח שזה השלב הבא שאני צריך ללמוד, כלומר WPF..)?

C# נשארת אותה שפה בכל הפלפורמות. WPF זה פלטפורמה אחת. אני ממליץ לך ללמוד אותה אם אתה רוצה לעשות תוכנות שולחניות.

@avr416

האם ללמוד ASP.NET MVC, SQL? או שיש דברים יותר בסיסים שצריך להשלים, כיון שאין לי מושג איך כותבים תוכנה שיכולה גם להסתנכרן עם מאגרי מידע באינטרנט/GPS ודברים כאלה? או שזה מה שאני אלמד בASP ודומיו?
אם מישו יוכל לעשות לי קצת סדר בנושאים הללו אשמח..
תודה רבה!

כמעט כל תוכנה שתכתוב תהיה קשורה לנתונים. אז כדאי קצת לעבור על SQL.
ASPNET MVC זה פלטפורמה (ווב) + וMVC זה ללמוד מתודלוגיה (סגנון תכנות, תבנית עבודה). זה מאוד מומלץ אבל זה חתיכת לימוד.

לא יודע כ"כ לכוון אותך כי ייתכן שכדאי להתחיל אחרת ממה שצעדתי אני. אני שנים הייתי בWPF. כעת אני קצת נמצא בMVC.

פורסם במקור בפורום CODE613 ב17/05/2015 14:39 (+03:00)

dovid

שלום! מקוה שתתמיד איתנו גם אחרי שכבגר לא תהיה ירוק (אלא כריש בס"ד)!
@avr416

חוצמיזה, אני מנסה להבין האם כדי לבנות תוכנה כזאת, צריך לבנות מחלקות של אנשים ומתפללים וכן על זה הדרך? האם לא יותר פשוט לעשות טבלה עם נתונים ופשוט כל פעם לשלוף אותם משם? או בשביל מה בעצם צריך את כל הדרך המסורבלת הזאת של הגדרת קלאסים וממשקים?

יפה מאוד שקלטת את ה"מונחה אובייקטים" שזה שאיפה להסתכל על הכל כאובייקטים. אבל ודאי שאינך חייב לשום מתודולגיה.
אבל הכי מעניין זה מה שאתה שואל "בשביל מה בעצם צריך את כל הדרך המסורבלת הזאת של הגדרת קלאסים וממשקים"
במילים אחרות בשביל מה החיה הזאת ששמה OOP.
אז התשובה היא כדי להעביר כמה שיותר את התפיסה האנושית שלך לקוד ה"גולם". במקום שאתה תידע שיש מתפלל, אך הקוד יתייחס אליו כרשומה נוספת, ואתה בכח הידע שלך תתרגם את הסתום בקוד לבעל משמעות כל פעם מחדש בעזרת לוגיקה בראש שלך ולפי זה תפעל עליו בהתאם פעולות, אתה פורס את התפיסה שלך בפני המחשב. ואז שאתה כבר לא צריך להיכנס לתוך הגולמות של הקוד הרבה יותר קל לכתוב ולהחזיק ראש ב"מערכת" אותה אתה בונה.
הכי טוב זה דוגמאות. אני מקוה לכתוב על זה בשבוע הקרוב בל"נ.

@avr416

חוצמיזה, אם אני רוצה לעשות ממשק משתמש קלאסי (כגון דרך WPF או windowsForm) האם עדיין צריך לכתוב את התוכנה בצורה הזאת, או ששם זה משהו אחר..

הכל אותו דבר. C# זה C#, והממשק זה סתם ספרייה מוכנה.

@avr416

אני מבין שזו שאלה של בור.. אבל לא הביישן למד..

ממש לא שאלה של בור, וגם אם כן זכותך להיות בור במתכנות כמו שאני בכל מה שלא תכנות (סידור פרחים למשל. אבל אני מניח שגם אתה לא מבין בזה :)).

@avr416

שאלה נוספת האם יש טעם ללמוד WindowsForm

אין טעם. הוא לא מחליף לגמרי (הWinFoms נחשב לקומפקטי בתוכנות זעירות), אבל זה כבר לא שווה דקה לימוד לדעתי.

פורסם במקור בפורום CODE613 ב14/05/2015 15:54 (+03:00)

dovid

Foreground/Background Thread
טריד יכול להיות טריד רקע - Background והמשמעות היחידה של זה היא שכשהתהליך הראשי באפליקציה גומר הוא מפסיק אותו באמצע. לעומת זאת בטריד Foreground (וזה הברירת מחדל של טריד) האפליקציה ממתינה לסיומו.
הגדרת תהליך כBackground נעשית ע"י הצבת true למאפיין IsBackground.

Thread Priority
ניתן לתת לThread רמת עדיפות ביחס לטרידים האחרים באפליקציה שלנו (ל ביחס לתהליכים של אפליקציות אחרות במחשב. זה ניתן לשינוי אבל זה לא קשור לנושא שלנו). ע"י הצבה של ערך במאפיין Priority הערכים האפשריים הם: Lowest, BelowNormal, Normal, AboveNormal, Highest.

Thread Safety
הבעיה מס' 1 בריבוי טרידים זה מה שנקרא Thread Safety. כלומר בטיחות המידע מפני גישה של תהליכים בו זמנית.
המצב שתהליך פונה למשאב משותף ומשנה אותו בה בעת שתהליך אחר משתמש בו עשוייה להביא לתוצאות בלתי צפויות. דוגמה פשוטה: כשאנחנו עושים מונה בלולאה או בכל מקום אחר בקוד אנחנו כותבים משתנה++. המשמעות המלאה של זה היא: 1. קח את ערך המשתנה, 2. הוסף לו אחד, 3. ואכלס את ערך התוצאה במשתנה הזה (תוך דריסת הערך הקודם). עכשיו בריבוי תהליכים יכול להיות מצב שתהליך א' עושה את הפרצדורה 1 ו2, ובה בעת תהליך אחר גם כן. כעת כששניהם אוחזים בשלב 3, במקום שהמשתנה "יגדל" בשניים, הוא יגדל רק באחד. ייתכן שתהליך אחד הגדיל את המשתנה כבר בשתי פעימות, ותהליך אחר יחזיר אותו אחרוה ע"י השמת החישוב של משתנה+1 המעודכן ללפני כמה מילישניות.

הנה המחשה:

static int result = 0;           //משאב משותף לשתי התהליכים

private static void Main(string[] args)
{
    //יצירת שתי טרידים.
    var t1 = new Thread(Do);
    var t2 = new Thread(Do);
    //הרצת התהליכים.  
    t1.Start();
    t2.Start();
    //הרצת המתודה גם בתהליך הראשי/נוכחי
    Do(); 
    //וידוא שהתהליכים יגמרו לפני הדפסת התוצאה
    t1.Join();
    t2.Join();
    //הדפסת התוצאה
    Console.WriteLine(result);

    Console.ReadLine();
}

static void Do()
{
    for (int i = 0; i < 10; i++)
    {
        Thread.Sleep(1);     //האטת התהליך הנוכחי כדי שתהיה חפיפה בזמני הריצה.
        result++;
    }
}

הקוד הזה מריץ את הפונקציה Do משתי תהליכים ובנוסף מהתהליך הראשי. הפונקציה פונה שוב ושוב, 10 פעמים, למשתנה result בוחנת את ערכו ומשימה בו את הערך אות בחנה + 1. לפי החשבון המשתנה result צריך להכיל לבסוף את הערך 30, שהרי זה מס' הפעמים בהם הועלה ערכו ב1. אבל בגלל ההתנגשויות בין התהליכים הערך יהיה כל פעם משהו אחר נמוך מ30 בדרך כלל.
כמובן שהקוד הזה חסר תכלית אז קשה להציע בו שינוי מועיל.
בהודעה הבאה אציע מקרה ממחיש יותר. בו תהיה הבעיה ופתרון הLocking - בלוק קוד שרק תהליך אחד יכול להיכנס אליו בו זמנית. זה פותר את הבעיה של משתנה++. כי מתחילת התהליך עד סופו, יש רק תהליך אחד שעושה את הפעולה ברגע נתון.

רגע, מה אם JS? וNode.js? איך הם מתגוננים מכזה דבר? התשובה היא שהם עובדים על טריד אחד תמיד. האסינכרוניות שלהם עובדת על אירועים ותזמון. ממילא לעולם לא רצים במקביל שתי פקודות שעלולות לשבש או לסתור אחת את השניה. תמיד יש אחת ראשונה ואחת שניה. אכן, זה חולשה של JS בעיבוד, אבל זה לא כ"כ התפקיד שלו

פורסם במקור בפורום CODE613 ב18/05/2015 12:53 (+03:00)

dovid

Lambda כדרך להעברת פרמטרים לטריד
אם משתמשים בביטוי למדה המצב הוא אלגנטי בהרבה:

private static void Main(string[] args)
{
    Console.WriteLine("enter min value to check: ");
    var min = int.Parse(Console.ReadLine());
    Console.WriteLine("enter max value to check: ");
    var max = int.Parse(Console.ReadLine());

    List<int> results = new List<int>();

    Thread t = new Thread(() => Do(min, max,  results));
    ...
    ...
}

private static void Do(int minValue, int maxValue, List<int> results)
{
    for (int i = minValue; i < maxValue; i++)
    {
        bool exsistDivisor = false;
        for (int j = 2; j < (i / 2); j++)
        {
            if (i % j == 0)
            {
                exsistDivisor = true;
                break;
            }
        }
        if (!exsistDivisor) results.Add(i);
    }
}

מה זה ביטוי למ(ב)דה? זה לא כ"כ המקום להסביר אבל בשתי מילים: דרך מקוצרת ליצור מתודה אנונימית לשימוש מקומי, רק נגדיר את הצורך והכללים:
הצורך - אני במהלך פונקציה מסויימת צריך לבדוק חמש פעמים את האורך של טקסט לחלק ל12. אז במקום לכתוב כמה פעמים את התהליך אז אני רוצה פונקציה (מה שנקרא Reuse -לא לכתוב קוד פעמיים). אין שום טעם ליצור פונקציה חיצונית כשהמקום היחידי בה היא באה לשימוש זה בתוך הפונקציה שלי.
האופן: מבנה פונקציה רגילה בC# היא ככה

מציין גישה (פרטי ציבורי וכו')

ערך מוחזר

שם

פרמטרים נדרשים - סוג ושם

גוף הפונקציה שכללי הגוף הם: א. מוקף בסוגריים מסולסלים חובה, ב. חובה לכלול return כשמחזיר ערך ג. כל פקודה אפי' יחידה מסתיימת בנקודה פסיק.
ובכן למדה תמיד מכניסים לתוך משתנה/פרמטר שהוא כבר הגדיר את חתימת הפוקנציה - מה היא מחזירה ומקבלת (2, 4). וגם השם מיותר (3) (כי הרי בפרמטר אין לנו צורך להעניק שם ובמשתנה הלא אנו "מחזיקים ביד" את המשתנה). אבל יש צורך לתת שם לפרמטרים. כי אנחנו צריכים לדעת איך להתייחס אליהם מגוף הפונקציה. מציין גישה (1) ודאי שלא צריך. אז נשאר: שמות פרמטרים (במידה ויש יותר מאחד מופסקים בפסיק וחובת עטיפתם בסוגריים) ובלוק הפונקציה. אבל שתי דברים :
א. בין שמות הפרמטרים שלגוף התחביר הוא לשים =< היינו שווה ואח"כ "גדול מ" . (זה בא לומר הקלט משמאל (הפרמטרים מועברים לגוף הפונקציה מימין)
ב. בגוף הפונקציה עצמו ישנה "קולות" למקרה בו הפונקציה מכילה שורה אחת בלבד, 1 .לא צריך לעטוף בסוגריים מסולסלות 2. לא צריך נקודה פסיק בסוף הפקודה 3. לא צריך לפרש return להחזרת הערך אלא פשוט כותבים אותו וזהו.

פורסם במקור בפורום CODE613 ב14/05/2015 19:58 (+03:00)

dovid

[size=110:14bu1mwd]דרכים להעביר ולקבל מידע מהThread[/size:14bu1mwd]
כמו שראינו הטריד מקבל פרמטר שהוא מסוג דלגייט פשוט שככה נראה:

public delegate void ThreadStart();

זה מתודה שלא מקבלת פרמטרים (יש גירסה שמקבלת פרמטר מסוג ParameterizedThreadStart שכשמו הוא מקבל פרמטר אחד מסוג אוסייקט. אבל נשאיר את זה כי זה שיירים עלובים מתקופת האבן של דוט נט, כעת זה מיותר לגמרי).

מה אם אנחנו רוצים להעביר לטריד מידע? הדרך לאינראקציה עם Thread זה פשוט גישה לאותו משאב (משתנה/אובייקט) של התהליך הקורא או כלל התהליכים. זה מה שנקרא Shared Data.
Shared Data - שיתוף זכרון בין תהליכים
איך עוישם זאת? איך נגשי ם מטריד אחד למשאב של טריד אחר?
בעיקרון זה מידי קל. לכן, כלל ראשון במעלה: תהליך שניגש למידע משותף המשמש יותר מטריד אחד, הוא מצב שצריך למנוע אותו ככל האפשר, ובעצם זה שער לכל הבעיות של ריבוי-תהליכים.
פשוט מאוד. אם המתודה שמועברת לטריד פונה למשאב חיצוני (לא לוקלי מבחינת סקופ) למשל למאפיין/שדה החבר באותה המחלקה, או יותר מזה, למאפיין/שדה סטטי של מחלקה כל שהיא, אז בעצם הטריד פונה למידע הנגיש (לעיתים לקריאה בלבד לעיתים גם לכתיבה) לטריד אחר באותה מידה (והכי גרוע אולי באותה העת).
המצב האידאלי הוא שהמשאב הזה המשותף מוקדש כל כולו לצרכי הטריד הזר, ולא משתמשים בו בטריד הנוכחי כל עוד הטריד הזר בפעולה.
המצב שמומלץ להתרחק ממנו ככל האפשר, הוא משאב אחד המשמש בו זמנית שתי תהליכים.
טוב קיללתי בין השיטין הרבה את הדרך הזאת אז זה הזמן לומר שלפעמים זה לגיטימי לגמרי. נדבר בהמשך על ההשלכות של SharedData.

דוגמה לאינטראקציה בין התהליך הראשי לתהליך חדש:

private static void Main(string[] args)
{
    Thread t = new Thread(Do);


    Console.WriteLine("enter min value to check: ");
    minValue = int.Parse(Console.ReadLine());
    Console.WriteLine("enter max value to check: ");
    maxValue = int.Parse(Console.ReadLine());

    t.Start();
    Console.WriteLine("started!");
    Console.WriteLine("press any key for recive the status\result... for abort press X");


    while (t.IsAlive)
    {
        if (Console.ReadKey().Key == ConsoleKey.X && t.IsAlive)
        {
            t.Abort();
            return;
        }

        Console.WriteLine("the thread is busy (the current results count is " + results.Count + "). retry later!");
    }

    Console.WriteLine(" finsh! \n result count is: " + results.Count + "\n results list:");
    results.ForEach(Console.WriteLine);

    Console.ReadLine();
}


private static int minValue;
private static int maxValue;
private static List<int> results;

private static void Do()
{
    results=new List<int>();
    for (int i = minValue; i < maxValue; i++)
    {
        bool exsistDivisor = false;
        for (int j = 2; j < (i / 2); j++)
        {
            if (i % j == 0)
            {
                exsistDivisor = true;
                break;
            }
        }
        if (!exsistDivisor) results.Add(i);
    }
}

מה יש כאן? מתודה שבודקת על טווח מספרים אם הם ראשוניים. היא בעצם ניזונה משתי פרמטרים minValue וmaxValue שהם לא לוקליים בתוך הפונקציה, אלא חברים במחלקה (סטטיים במקרה שלנו). והפלט? נוסף לתוך אובייקט ליסט שגם הוא חבר במחלקה. בעצם ישנה גישה בו זמנית לתהליך הראשי ולחדש שרץ ברקע לכל המידע הזה.
זו דוגמה גרועה מאוד כי ממש מגושם ומעצבן לייחד מאפיין/משתנה ברמת המחלקה על כל פיסת מידע שרוצים להעביר לתהליך.
הדרך המומלצת כיום (פעם (NET 2) זה היה ParameterizedThreadStart אבל אפשר לשכוח ממנו) זה להשתמש בביטוי למדה.

פורסם במקור בפורום CODE613 ב14/05/2015 19:03 (+03:00)

dovid

עצם יצירת הטריד לא עושה מאומה, עד שקוראים למתודה Strat. החל ממתי שקוראים למתודה Start אפשר להשהות או לעצור את הטריד, עד שהוא נגמר.
המתודה Start היא חד פעמית. אחרי שטריד הורץ א"א להריץ אותו פעם נוספת.
לThread יש מאפיין כן/לא בשם IsAlive שמחזיר חיובי במידה והטריד עדיין פועל, לא נגמר וכבר התחיל.
יש גם מאפיין מפורט יותר בשם ThreadState שמחזיר את מצבו. המצבים הקלאסיים הם Unstarted ללפני ההרצה ע"י Start, בעת ההרצה זה Running ואם זה מושהה Suspend, נעצר (ע"י מתודה שנראה בהמשך) Aborted.

Join
אם רוצים לחכות בטריד אחד לסיומו של טריד אחר, אפשר להשתמש בפונקציה Join. היא בעצם תוקעת את הטריד הנוכחי עד שהטריד הזר גמר.
למתודה join יש גירסה שמקבלת פרק זמן קצוב, שאם לא נגמר הטריד בפרק הזה, התוכנית כן ממשיכה לרוץ. הפונקציה Join מחזירה ערך בוליאני שמציין האם ה"איחוד" עם הטריד הצליח, כלומר נגמר בפרק הזמן הקצוב.

Sleep
המתודה הסטטית Thread.Sleep() היא משהה את הטריד הנוכחי. היא מקבלת פרמטר מספרי שהוא מס' המילישניות בהם הטריד "ישן" (אפשר להעביר למתודה פרמטר TimeSpan במקום מס' מילישניות). זה פועל על הטריד הנוכחי, לא על טריד אחר.

פורסם במקור בפורום CODE613 ב13/05/2015 20:25 (+03:00)

dovid

לאחרונה אני מרפרף על JS ואני מאוד מסתבך מתכונת הדגל של השפה: אסינכרוניות.
התכונה כ"כ מובנית בשפה, שמסובך בה לפעול להפך.

בC# הכל בברירת מחדל סינכרוני, וכשרוצים אסינכרוני זה נחשב "נושא מתקדם".
אז אני רוצה לסכם הפעם מהקל אל הכבד את הנושא של מקביליות ובו זמניות בC#.

מתי יש צורך בזה? למה שהמחשב לא יעשה קודם א' ואח"כ ב'
הסיבות הנפוצות הם:

UI חי תוך כדי פעולה. בWPF או WINFORMS.
ביצוע בו זמני מהר יותר בפעולות: בפעולות עיבוד כשיש יותר ממעבד אחד במחשב, IO (קלט פלט) כשבזמן ההמתנה אפשר לבקש ואף לעבד את הבקשה הבאה בתור.

בדרך כלל הפעלת קטעי קוד שונים בו זמנית נעשים ע"י הטכנלוגיית "ריבוי-תהליכים" - Multi-Threading.
Thread - תהליך
לכל יישום שרץ במחשב יש לפחות תהליך אחד, תהליך ראשי. אבל יכול להיות ליישום עוד תהליכים שחולקים משאבים של זיכרון ועוד, אבל מבודדים מבחינת הריצה שלהם - כל אחד רץ כשלעצמו, כלומר עצירה או תקיעה של אחד לא מפריעה לשני.

איך יוצרים Thread (נוסף) בC#?
למה נוסף? כי האפליקציה עצמה היא כבר Thread אחד. אז בשביל ליצור אחד יש ליצור אובייקט Thread בקוד ו"להריץ" אותו.
הבנאי של Thread מקבל כמה גרסאות פרמטרים, הפשוטה שבהם זה delegate מסוג void ללא פרמטרים.
הנה דוגמה. ייבאתי את מרחב השמות System.Threading. אני יוצר טריד חדש, וכפרמטר אני נותן לו את שם המתודה Do שהיא void וללא פרמטרים.

private static void Main(string[] args)
{
    Thread t = new Thread(Do);

    Console.WriteLine(t.ThreadState);   //Unstated

    t.Start();

    Console.WriteLine(t.ThreadState);   //Running


    Console.ReadLine();
}

static void Do()
{
    Console.WriteLine("do do do!");
}

פורסם במקור בפורום CODE613 ב13/05/2015 18:19 (+03:00)

תחומים - פורום חרדי מקצועי

dovid

פוסטים