סתם משהו נחמד שנתקלתי בו ורציתי לשתף-

בגרסה 3.0 של C# הוכנס שינוי חביב: האפשרות לתחל שדות של אובייקט בעת יצירתו (ללא צורך בInitialization Constructor).

בהנחה שיש לנו את הClass הבא:

קוד:

 


public class Foo

{
public int Age
{
	 get {...}
	 set {...}
}
 
public string Name
{
	 get {...}
	 set {...}
}
}

אם אני מעוניין לתחל את Age ואת Name בעת יצירת האוביקט, בC# 2.0,1.1 אנחנו נייצר ctor מתאים:

קוד:

public Foo(int age, string name)

{
this.Age = age;
this.Name = name;
}

בגרסה 3.0 ניתן לתחל את השדות כך:

קוד:

Foo myFoo = new Foo() {Age = 18, Name="Pamela"};

דורון

כל הכבוד על היוזמה, יש לא מעט חידושים ב-3.0 וזה יהיה מעולה לסקור אותם מידי פעם בפורום.
לגבי הקוד, לא שיחקתי עדיין עם 3.0 אבל לפי ה-spec של MS אין צורך בסוגריים () ריקים ב-default ctor או בכלל כאשר מאתחלים mebmers בעזרת object initializers.

קוד:

 

var myFoo = new Foo {Age = 18, Name="Pamela"};

על הדרך הכנסתי עוד שינוי מעניין - Implicitly typed local variables. כאשר מציינים את המלה השמורה var לפני משתנה אין צורך לציין במפורש את הטיפוס של המשתנה והקומפיילר יבצע זאת עבורך.

במקרה הזה myFoo יהיה מטיפוס Foo כמובן, למרות שאין ציון מפורש לכך בקוד.
עוד כמה דוגמאות:

קוד:

var i = 5;
var s = "Hello";
var d = 1.0;
var numbers = new int[] {1, 2, 3};

שינוי מעניין? (אני מדבר על השינוי האחרון שציינת).
אני לא מפתח ב-C#, אבל אני לא חושב שלהחליק עם הגדרות של Strong Typed זה מעניין.

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

C pogrammers never die. They are just cast into void.

http://blogs.msdn.com/sreekarc/arch...ymous-type.aspx

באופן אישי, אני נגד שימוש בהגדרת Implicit types מהסוג הזה. אני לא בדקתי, אבל יש לי ספקות לגבי
הCLSCompliant של זה, ובנוסף - אחרי שבמשך 7 שנים הם מחכנים אותנו לעבודה Strong-Typed,
הם שוברים את זה עם פלאגיאט מעולם הסקריפטים והVB. אני גם יכול לראות את כמות הבאגים שייכנסו
בספריות חדשות (והצורך לבסס את התוכנית על isים למניהם)...

אבל.. כנראה כמו כל שינוי שהם מכניסים - בסופו של דבר (ובמיוחד לאור מה שסרייקר צ'ודרי כתב בבלוג
שלו) נאלץ לאמץ את זה...

דורון

אני מסכים ששני החידושים שהוזכרו יצרו לא מעט בילבול: לגבי המלה השמורה "var" - אמנם יש מתיחה מסויימת של הגבולות אבל עדיין זה שונה משפות סקריפט ויש שמירה על הסביבה כ-Strongly typed מכיוון שהקומפיילר מאפשר שימוש ב-var רק כאשר מתבצעת השמה ברורה למשתנה שבא אחריו בצורה שתאפשר לקומפיילר להבין מה סוג המשתנה ואז המתכנת מקבל את ההצהרה על הטיפוס במתנה. בזמן ריצה ההבדל הוא ברור, ב-python/perl משתנה יכול להכיל מידע נומרי (בהקבלה ל-int) בתחילת התוכנית ולאחר מכן לקבל string. ב-#C לעומת זאת, לאחר שהקומפיילר החליט שהמשתנה i הוא int לא תוכל לבצע אליו השמה מטיפוס אחר.
יש פה בלוג מעניין בקשר לזה: http://blah.winsmarts.com/2006/05/1...iables-var.aspx
אין ספק שיהיו לא מעט חריקות בעניין הזה (אפשר להתחיל עם דברים בסיסיים כמו כמויות הקוד הקיים שמופיע בו טיפוס עם השם var...) אבל אל תשכחו שכנהוג ב-MS לא מדובר בבאג אלא ב-feature...

לגבי Anonymous Types, המטרה היא לאפשר בניה של טיפוס on-the-fly שיוכל לשמור מבנה של נתונים המחוזרים כתוצאה משאילתת LINQ.
דוגמא מאותו הבלוג:

קוד:

 
var monster = new {hair="black", skin="green", teethCount=64} ;

ומאוחרי הקלעים נוצר טיפוס שהוא strongly-typed

קוד:

 
class __Anonymous1
{
private string _hair = "black";
private string _skin = "green";
private int _teeth = 64; 




 
 
public string hair {get { return _hair; } set { _hair = value; }}
public string skin {get { return _skin; } set { _skin = value; }}
public int teeth {get { return _teeth; } set { _teeth = value; }}
}
 
 
 
 

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

הם טוענים שהם ישחררו את הנושא הזה בבטא השני.

דורון