, אסינכרוני תכנותופיתוח תקשורת

אפליקציות Windows 8.1ל-

ואפליקציות Windows Phoneל-8

בשפת #Cשיפורים

C# Evolution של הראשונה הגרסה # Cמאז

. רבות יכולות לה התווספו

היכולות את להכיר מנת עלשל החדשות #Cהאסינכרוניות

מקצת 5 להכיר צריך. בשפה מהשיפורים

GenericsGenerics בגרסה .C# 2.0שהוצגו השפה של עוצמה רבת הרחבה הם

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

:יתרונותType-Safe ( – של מצב יתכן לא הטיפוס מה בדיוק יודע הקומפיילר ההקצאה ”(3,”1,2בזמן - ב השימוש את -Boxingמפחית .Unboxingו . בביצועים גדול שיפור.).... , מיון ) חיפוש באלגוריתמים חוזר שימוש

: כללי תחביר

< - ב .Tשימוש ריצה< בזמן יוגדר אשר גנרי טיפוס להגדרת

Generics:Genericsלפני

:Genericsעם

public class Stack { object[] m_Items; public void Push(object item) {...} public object Pop() {...} }

public class Stack<T> { T[] m_Items; public void Push(T item) {...} public T Pop() {...} }

Stack<int> stack = new Stack<int>(); stack.Push(1); stack.Push(2); int number = stack.Pop();

Object -> Reference TypeInt32 -> Value Type

Boxing - בין - Value Typeהמרה Referenceל Type.

Unboxing – בין -Reference Typeהמרה Valueל Type.

Type Safe – T. ריצה בזמן ולא כתיבה בזמן מוגדר

Generics

לפניGenerics:

public struct PointInt{ public int X; public int Y; }public struct PointDouble{ public double X; public double Y; }

: לחילופין אוpublic struct Point{ public object X; public object Y; }

עםGenerics:public struct Point<T>{ public T X; public T Y;}

Point<int> point;point.X = 1;point.Y = 2;

Point<double> point;point.X = 1.2;point.Y = 3.4;

: נוספת דוגמה

Generics

: List - שימושיםList<int> arr1 = new List<int>();arr1.Add(100);arr1.Add(200);arr1.Add(300);arr1.Add(400);arr1.Add(500);

List<Person> arr2 = new List<Person>();arr2.Add(new Person("Elimelech", "Zorkin",65,123456));arr2.Add(new Person("Zelda","Gurnisht",44,4545454));arr2.Add(new Person("Zrubavel","Berkovitch",32,8854646));arr2.Add(new Person("Vladimir","Swisa",12,3434843));

: קוד ListSampleדוגמת : קוד GenericListSampleדוגמת

Generics: שימושים מותאמות – רשימות יצירת

class MyGenericArray<T> { private T[] m_Arr; private int m_Counter; public MyGenericArray() { m_Arr = new T[16]; } public void Add(T t) { if (m_Counter >= m_Arr.Length) Array.Resize(ref m_Arr, m_Arr.Length + 16); m_Arr[m_Counter++] = t; } public T this[int index] { get { return m_Arr[index]; } } public void Print() { for (int i = 0; i < m_Counter; i++) { Console.WriteLine(m_Arr[i]); } } }

: קוד GenericSample01דוגמת

static void Main(string[] args) { MyGenericArray<int> arr1 = new MyGenericArray<int>(); arr1.Add(100); arr1.Add(200); arr1.Add(300); arr1.Add(400); arr1.Add(500); arr1.Print();

MyGenericArray<Person> arr2 = new MyGenericArray<Person>(); arr2.Add(new Person("Elimelech", "Zorkin",65,123456)); arr2.Add(new Person("Zelda","Gurnisht",44,4545454)); arr2.Add(new Person("Zrubavel","Berkovitch",32,8854646)); arr2.Add(new Person("Vladimir","Swisa",12,3434843)); arr2.Print();

}

Generics

: שימושים גנריות – מתודות

static void Swap<T>(ref T t1, ref T t2) { T tmp = t1; t1 = t2; t2 = tmp; } static void Main(string[] args) { int num1 = 11; int num2 = 22; Console.WriteLine("num1={0}, num2={1}", num1, num2); Swap(ref num1, ref num2); Console.WriteLine("num1={0}, num2={1}", num1, num2); string str1 = "Elchanan"; string str2 = "Sonya"; Console.WriteLine("str1={0}, str2={1}", str1, str2); Swap(ref str1, ref str2); Console.WriteLine("str1={0}, str2={1}", str1, str2); }

: קוד GenericMethodדוגמת

Genericsשל – שימושים <List : class MyGenericList<T>:List<Tהורשה

{ public void Print() { for (int i = 0; i < base.Count; i++) { Console.WriteLine(base[i]); } } }

הרחבת של היכולות

List

: קוד GenericMethodדוגמת

static void Main(string[] args) { MyGenericList<string> arr1 = new MyGenericList<string>(); arr1.Add("Shoshana"); arr1.Add("Yerachmiel"); arr1.Add("Zelda"); arr1.Add("Pirchiya"); arr1.Add("Zalman"); arr1.Add("Fruma"); arr1.Print(); }

Generics

: שימושים ממשקים –

interface IMyInterface<T> { void Print();

} class Person : IMyInterface<Person> { … } class MyGenericArray<T> { private T[] m_Arr; private int m_Counter; … } static void Main(string[] args) { MyGenericArray<Person> arr1 = new MyGenericArray<Person>(); arr1.Add(new Person("Elimelech", "Zorkin", 65)); arr1.Add(new Person("Zelda", "Gurnisht", 44)); arr1.Add(new Person("Muhamad", "Berkovitch", 32)); arr1.Add(new Person("Vladimir", "Swisa", 12)); arr1.PrintAll(); }

Generics

שימושים – Delegate :

public delegate void ChangeDelegate<T>(T t); class Person { private string m_FirstName; private string m_LastName; private int m_Age; public event ChangeDelegate<string> FirstNameChangeNotify; public event ChangeDelegate<string> LastNameChangeNotify; public event ChangeDelegate<int> AgeChangeNotify; . . . public string FirstName { get { return m_FirstName; } set { if (value != m_FirstName) { m_FirstName = value; FirstNameChangeNotify(m_FirstName); } } }

}

הגדרת Delegate גנרי

Eventהגדרת

Eventהפעלת

: קוד GenericDelegateדוגמת

Genericsשימושים – Delegate : static void Main(string[] args) המשך

{ ChangeDelegate<Person> del = new ChangeDelegate<Person>(Program.Func); Person p = new Person("Isaschar", "Shemyafe", 78); p.LastNameChangeNotify += LastNameChangeNotify; p.FirstNameChangeNotify += FirstNameChangeNotify; p.AgeChangeNotify += AgeChangeNotify; p.LastName = "Havakook"; p.LastName = "Loshemyafe"; p.Age = 100; del(p); }

static void AgeChangeNotify(int t) { Console.WriteLine("New Age: " + t); }

- ל Eventרישום

: קוד GenericDelegateדוגמת

Generics

(Generic Type Constraintאילוצים )

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

.NET. ריצה בזמן הטיפוסים בחירת את המגבילים אילוצים להגדיר מאפשרת

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

: אילוצים רשימת

where T : struct להיות חייב .ValueTypeהטיפוס

where T : class להיות חייב .Reference Typeהטיפוס

where T : BaseClass . מניגזרותיה אחת או בסיס מחלקת להיות חייב הטיפוס

where T : IInterface הממשק את לממש חייב .IInterfaceהטיפוס

where T : new() להיות חייב .Default Ctorלטיפוס

Genericsstatic void Swap<T>(ref T t1, ref T t2) where T:struct אילוצים

{ T tmp = t1; t1 = t2; t2 = tmp; } int num1 = 11; int num2 = 22; Swap(ref num1, ref num2); Other o1 = new Other(); Other o2 = new Other(); Swap(ref o1, ref o2);

static void Swap2<T>(ref T t1, ref T t2) where T : IMyInterface { T tmp = t1; t1 = t2; t2 = tmp; } class IMyInterface { } class MyClass : IMyInterface { } int num1 = 11; int num2 = 22; MyClass c1 = new MyClass(); MyClass c2 = new MyClass(); Swap2(ref c1, ref c2); Swap2(ref num1, ref num2);

: קוד GenericConstraints01דוגמת

Genericsאילוצים

class MyGenericArray1<T> where T: class { private T[] m_Arr; private int m_Counter; …. } class Base { } class Derived : Base { } class Other { } struct Point { }

MyGenericArray1<Derived> arr1 = new MyGenericArray1<Derived>(); MyGenericArray1<Point> arr2 = new MyGenericArray1<Point>();

: קוד GenericConstraints01דוגמת

Implicit Typing - Var Beginning in Visual C# 3.0, variables that are declared at method scope can have an

implicit type var. An implicitly typed local variable is strongly typed just as if you had declared the type yourself, but the compiler determines the type. The following two declarations of i are functionally equivalent:

Local variables can be given an inferred "type" of var instead of an explicit type. The var keyword instructs the compiler to infer the type of the variable from the expression on the right side of the initialization statement. The inferred type may be a built-in type, an anonymous type, a user-defined type, or a type defined in the .NET Framework class library. For more information about how to initialize arrays with var, see Implicitly Typed Arrays (C# Programming Guide) .

The following examples show various ways in which local variables can be declared with var:

It is important to understand that the var keyword does not mean "variant" and does not indicate that the variable is loosely typed, or late-bound. It just means that the compiler determines and assigns the most appropriate type.

The var keyword may be used in the following contexts:

On local variables (variables declared at method scope) as shown in the previous example.

In a for initialization statement.

var i = 10; // implicitly typed int i = 10; //explicitly typed

var i = 5; // s is compiled as a string  var s = "Hello";

foreach(var item in list){...}

Anonymous Methods , של והפעלה רישום הגדרה מציגה הבאה הפשוטה קוד :delegateדוגמת

המתודה - הבעיה - Funcלמעשה ה ידי על להיקרא יכולה Delegateשנועדה. לכך התכוונו שיוצריה מבלי התוכנית של אחר חלק כל ידי על להיקרא

delegate void MyDelgate(); class Program { static void Main(string[] args) { MyDelgate my_delegate = new MyDelgate(Func); my_delegate(); } public static void Func() { Console.WriteLine("Delegate Invoked"); } }

הגדרה

רישום

הפעלה

Anonymous Methods - מ - 2.0גרסה# Cהחל ה בין ישירות לחבר אמור Delegateניתן אשר הקוד קטע לבין

: מופעל הוא כאשר להתבצע

מפורשת בצורה מתודה להגדיר צריך לא- שה פעם בכל ירוץ אשר קוד מקטע כותבים , Delegateאלא יופעל

. קומפילציה בזמן המתודה את לייצר יודע כבר הקומפיילר

- ה ללא המימוש את להפעיל ניתן .Delegateלא

delegate void MyDelgate(); class Program { static void Main(string[] args) { MyDelgate my_delegate = delegate() { Console.WriteLine("Delegate Invoked"); }; my_delegate(); } }

הגדרה

רישום

הפעלה

Anonymous Methods ועםEvent:

delegate void MyDelegate(string msg); class Program { public static event MyDelegate MyEvent; static void Main(string[] args) { MyEvent += delegate(string msg) { Console.WriteLine("msg : {0}",msg); }; MyEvent("Event Invoked"); } }

הגדרה

אירוע

הפעלה

רישום

Lambda Expression 1.0בגרסה C# Delegate. מתודות הרבה של או מתודה של כתובת קיבל

של 2.0בגרסהC #האנונימית המתודה השפה של היכולות לארסנל התווספה(Anonymous Method - ה( בין ישירות לחבר הקוד Delegateשאפשרה קטע לבין

. מופעל הוא כאשר להתבצע אמור אשר

של השלישית את# Cהגרסה לממש ומאפשרת קדימה צעד עוד אותנו לוקחתלמבדה ) ביטוי באמצעות האנונימית (.Lambda Expressionהמתודה

את לפשט מנת על אנונימיות מתודות לכתיבת תמציתית מאוד שיטה הם למבדה ביטוייעם עובדים אנו בו - Delegateהאופן #.Cב

בגרסאות קיימות היו שלא יכולות או פונקציונאליות מוסיף אינו למבדה בביטויי השימוששל # יותר .Cהקדומות

Lambda Expression הם למבדה .Inline Delegateביטויי אנונימיות מתודות לטובת ייחודי תחביר מציגים אשר

שהכרנו ממה שונה לתחביר להסתגל דורשים אבל לשימוש יותר פשוטים הם למבדה ביטויי. כה עד

: חלקים משלושה מורכב למבדה ביטוי

x => x * xלדוגמה:

הנקרא בודד פרמטר מקבל .Xהביטוי בפרמטר, שימוש עושה עצמו הביטוישל :Xהטיפוס , מפורשת בצורה להגדירו ניתן אולם מרומזת בצורה מוגדר

x * ( =< int xלדוגמה: ) x; - , ה ידי על מוכתב הפרמטר טיפוס ממילא ההגדרות בין הבדל .Delegateאין

. עצמו )=<( הביטוי נכתב אופרטור הלמבדה לאחר

, תחומים להיות חייבים הפרמטרים זה במקרה פרמטרים מספר לקבל יכול למבדה ביטויי( : לדוגמה, n1,n2,n3>=)n1 + n2 + n3בסוגריים

Parameters => Execution Code

, הביטוי של הפרמטריםפרמטרים 0 יותר או

Lambda Operator

לביצוע קוד

Lambda ExpressionLambdaהמבנה התחבירי של ביטויי

:מבנה של משפט למבדה

params => expression

params.רשימת פרמטרים שהביטוי מקבל, אופציונאלי –

=<.)=( למבדה אופרטור, סדר הקדימות שלו זהה לאופרטור השמה -

expression.הביטוי –

x => x * x לדוגמה:, הביטוי עצמו עושה שימוש בפרמטר.Xהביטוי מקבל פרמטר בודד הנקרא

מוגדר בצורה מרומזת, אולם ניתן להגדירו בצורה מפורשת:Xהטיפוס של ;x * x( =< int xלדוגמה: )

.Delegateאין הבדל בין ההגדרות, ממילא טיפוס הפרמטר מוכתב על ידי ה- לאחר הלמבדה אופרטור )=<( נכתב הביטוי עצמו.

ביטויי למבדה יכול לקבל מספר פרמטרים, במקרה זה הפרמטרים חייבים להיותn1 + n2 + n3(=<n1,n2,n3תחומים בסוגריים, לדוגמה: )

Lambda Expression;delegate int MyDelegate(int i) דוגמה:

class Program { static void Main(string[] args) { // C# 1.0 - The traditional way MyDelegate del1 = new MyDelegate(Handler1); int result = del1(5); Console.WriteLine("C# 1.0 version - The traditional way : " + result); // C# 2.0 - With Anonymous Methods MyDelegate del2 = delegate(int x) { return x * x; }; result = del2(5); Console.WriteLine("C# 2.0 - With Anonymous Methods : " + result); // C# 3.0 - With Lambda Expression MyDelegate del = x => x * x; result = del(5); Console.WriteLine("C# 3.0 - With Lambda Expression :" + result); } public static int Handler1(int x) { return x * x; }

הגדרת Delegate

הוותיקה השיטה

Anonymous Methods

Lambda

: קוד דוגמתLambdaExpressionSample01

המוחזר לערך התייחסות שאין לב שימו - שה , Delegateלמרות זאת מחייב

בצורה מתבצעת הערך החזרתמרומזת.

Lambda Expression: פרמטרים, מספר שמקבל למבדה ביטוי דוגמה

public delegate int CalcSomething(int n1, int n2, int n3); class Program { static void Main(string[] args) { CalcSomething sum_del = (n1, n2, n3) => n1 + n2 + n3; CalcSomething mul_del = (n1, n2, n3) => n1 * n2 * n3; CalcSomething div_del = (n1, n2, n3) => n1 / n2 / n3;

Console.WriteLine(sum_del(11, 22, 33)); Console.WriteLine(mul_del(2, 3, 4)); Console.WriteLine(div_del(1000, 10, 2));

} }

הגדרת Delegate

Lambda

: קוד דוגמתLambdaExpressionSample02

Lambda Expression . פקודות או משפטים מספר להכיל יכולים למבדה ביטויי

. מסולסלים בסוגריים תחום להיות חייב הביטוי זה במקרה

משפת נפרד בלי חלק הן למבדה - Cביטויי להשתמש NET Frameworkו# ניתן ולכן - ב המוגדרות ומחלקות השפה פקודות .NET Frameworkבכל למבדה ביטויי בתוך

: קוד דוגמתLambdaExpressionSample03

public delegate void CalcSomething(int num1, int num, params int[] arr); …CalcSomething sum_del = (n1, n2, arr) => } int sum = n1 + n2; foreach (int n in arr) { sum += n; { return sum;{; …var result1 = sum_del(1, 2, 3, 4, 5, 6, 7);

הגדרת Delegate

Lambda

Return מפורש

Lambda Expression

של הפיתוח המוצר Genericsבעקבות מנהלי הבחינו בהם בשימוש שהצטבר ומהניסיון-NET Frameworkשל . של 99.99%שב סוגים בשלושה רק משתמשים אנחנו מהמקרים

Delegate:

.1Predicate - Delegate ומחזיר פרמטר .boolשמקבל

.2Action - Delegate בין .1-16שמקבל ערך מחזיר ואינו פרמטרים

.3Func - Delegate בין . 1-16שמקבל ערך ומחזיר פרמטרים

" מועמסים* – " האחרונים השניים הערה

Lambda Expression

Predicate Delegate

public delegate bool Predicate<T>( T obj )

Delegate ומחזיר פרמטר .boolשמקבל

. קריטריונים של בסדרה עומד הפרמטר עם הבודקת מתודה מייצג

המתודהList<T>.FindAll(Predicate<T> match) אובייקטים אלו בודקת- ב . Listהנמצאים שלהם רשימה ומחזירה בקריטריונים עומדים

- ב שימוש עושה .Predicateהיא הבדיקה לביצוע הקריטריונים את להגדיר כדי

Lambda Expressionקוד - Predicate Delegate class Programדוגמת

{ static void Main(string[] args) { List<int> list = new List<int> { 1, 43, 6, 12, 5, 23, 7, 86, 3, 49 }; // C# 1.0 style List<int> greater_than_10 = list.FindAll(new Predicate<int>(GreaterThanTen)); foreach (int num in greater_than_10) { Console.Write(num + ","); } Console.WriteLine();

// C# 2.0 style greater_than_10 = list.FindAll(delegate(int num) { return num > 10; }); foreach (int num in greater_than_10) { Console.Write(num + ","); } Console.WriteLine();

// C# 3.0 style greater_than_10 = list.FindAll(num => num > 10); foreach (int num in greater_than_10) { Console.Write(num + ","); } Console.WriteLine(); } public static bool GreaterThanTen(int num) { return num > 10; } }

: קוד דוגמתLambdaExpressionSample04

Lambda ExpressionAction Delegate

public delegate void Action<T>( T obj )

Delegate בין ערך )1-16שמקבל מחזיר ואינו (.Overloadingפרמטרים

. , בלבד פעולה מייצג הוא כן כשמו class Program { private static int result = 0; static void Main(string[] args) { Action<int, int> Sum = (n1, n2) => result = n1 + n2; Sum(11, 22); Console.WriteLine(result);

string message1 = "The first line of a message."; string message2 = "The second line of a message."; string message3 = "The third line of a message."; Action<string, string, string> print = (s1, s2, s3) => WriteToConsole(s1, s2, s3); print(message1, message2, message3); } static void WriteToConsole(string string1, string string2, string string3) { Console.WriteLine("{0}\n{1}\n{2}", string1, string2, string3); }

שימוש תוך למבדה Actionב-

Delegate

שימוש תוך למבדה Actionב-

Delegate

: קוד דוגמתLambdaExpressionSample06

Lambda ExpressionAction Delegate

List<T>.ForEach( Action<T> action)

static void Main() { List<String> names = new List<String>() { "Elimelech", "Zrubavel", "Havakuk", "Yerachmiel" }; // C# 1.0 style names.ForEach(Print); // C# 2.0 style names.ForEach(delegate(String name) { Console.WriteLine(name); }); // C# 3.0 style names.ForEach(str=>Console.WriteLine(str)); } private static void Print(string s) { Console.WriteLine(s); }

: קוד דוגמתLambdaExpressionSample07

Lambda ExpressionFunc Delegate

public delegate TResult Func<T, TResult>( T arg )

Delegate בין . 1-16שמקבל ערך ומחזיר פרמטרים

. מוחזר ערך עם פעולה מייצג

Func<double, double> Square = x => x * x; var result1 = Square(5); Console.WriteLine(result1);

Func<double, double, double> Mul = (x, y) => x * y; var result2 = Mul(5,3); Console.WriteLine(result2);

Func<double[], double[], double> SumArray= (x, y) => { var dim = Math.Min(x.Length, y.Length); var sum = 0.0; x.ToList().ForEach(num => sum += num); y.ToList().ForEach(num => sum += num); return sum; }; double[] arr1 = new double[] { 1.1, 2.2, 3.3, 4.4 }; double[] arr2 = new double[] { 1.1, 2.2, 3.3 }; var result3 = SumArray(arr1, arr2);

שימוש תוך למבדהFunc Delegateב-

שימוש תוך למבדהFunc Delegateב-

שימוש תוך למבדהFunc Delegateב-

: קוד דוגמתLambdaExpressionSample08

Lambda ExpressionFunc Delegate

List<T>.Average<TSource> Method (IEnumerable<TSource>, Func<TSource, Decimal>)

static void Main(string[] args) { int[] arr = { 100,200,300,400,500 }; double average = arr.Average(num => num); Console.WriteLine("The average is {0}.", average); }

static void Main(string[] args) { int[] arr = { 100,200,300,400,500 }; double average = arr.Average(num => num + 100); Console.WriteLine("The average is {0}.", average); } static void Main(string[] args)

{ string[] fruits = { "Elimelech", "Zrubavel", "Havakuk", "Yerachmiel" }; double average = fruits.Average(s => s.Length); Console.WriteLine("The average string length is {0}.", average); }

: קוד דוגמתLambdaExpressionSample09

Lambda Expression - ב למבדה Listביטויי

List. למבדה ביטויי על המתבססות פונקציות מספר מכילה

- ה על נתבסס הבאות :Listבדוגמאות הבא

מיון:

: קוד דוגמתLambdaExpressionSample10

List<String> names = new List<String>() { "Elimelech", "Zelda", "Zrubavel", "Havakuk", "Yerachmiel", "Yona", "Zalman", "Pirhiya", "Fruma" };

var tmp1 = names.OrderBy(str => str).ToList(); tmp1.ForEach(str => Console.WriteLine(str));

Lambda Expression: יורד בסדר מיון

סינון:

var tmp2 = names.OrderByDescending(str => str).ToList(); tmp2.ForEach(str => Console.WriteLine(str));

var tmp3 = names.Where(str => str.Length > 6).ToList(); tmp3.ForEach(str => Console.WriteLine(str));

: קוד דוגמתLambdaExpressionSample10

Lambda Expression: " קריטריון פ ע מיון

קיבוץ:

names.Sort((str1, str2) => str1.Length.CompareTo(str2.Length)); names.ForEach(str => Console.WriteLine(str));

var tmp6 = names.GroupBy(str => str.Length).ToList(); tmp6.ForEach(arr => { Console.WriteLine(arr.Count()); arr.ToList().ForEach(str => Console.WriteLine(str));

});

Lambda Expression - ה על נתבסס הבאות :Listבדוגמאות הבא

: שדה בחירת

ביטויים :1שרשור

List<Dog> dogs = new List<Dog>() { new Dog { Name = "Shuka", Age = 14 }, new Dog { Name = "Lucy", Age = 2 }, new Dog { Name = "Atraf", Age = 13 }, new Dog { Name = "Sig", Age = 8 }, };

var names1 = dogs.Select(x => x.Name).ToList();names1.ForEach(str => Console.WriteLine(str));

dogs.Where(dog=>dog.Age%2==0). OrderBy(x => x.Name).ToList(). ForEach(dog => Console.WriteLine(dog.Name));

: קוד דוגמתLambdaExpressionSample10

Lambda Expressionביטויים :2שרשור

dogs.Where(dog => dog.Age > 5). OrderBy(dog => dog.Age).ToList(). ForEach(dog => Console.WriteLine(dog.Name));

: קוד דוגמתLambdaExpressionSample10

Lambda Expression: ואירועים למבדה

public MainWindow(){ InitializeComponent(); btn.Click += (sender, e) => lbl.Content = txt.Text;}

: קוד דוגמתLambdaExpressionWithWPF

Lambda Expression: למבדה Sample 01 // שעשועי

Func<int, int> Square = (int x) => x * x; var result1 = Square(10); Console.WriteLine("Sample 01 - " + result1);

// Sample 02 Func<int, int, int, int> Mul = (int num1, int num2, int num3) => num1 * num2 * num3; var result2 = Mul(2, 3, 4); Console.WriteLine("Sample 02 - " + result2);

// Sample 03 Func<int[], int> Biggest = (int[] arr) => { int biggest = int.MinValue; arr.ToList().ForEach(num => biggest = (num > biggest) ? num : biggest); return biggest; }; int[] arr1 = new int[] { 1, 43, 66, 2, 88, 34, 51, 78, 99, -1, 77, 62 }; var result3 = Biggest(arr1); Console.WriteLine("Sample 03 - " + result3);

Lambda Expression: למבדה שעשועי

//Sample 04 Func<string, int> SquareStringLength = (string s) => s.Length * s.Length; var result4 = SquareStringLength("Abra Kadabra"); Console.WriteLine("Sample 04 - " + result4); // Sample 05 Predicate<string> ErrorStr = (string s) => { if (s.Length == 0) return true; else return false; }; Func<string, string, string> WhoIsLonger = (string str1, string str2) => { if (ErrorStr(str1) || ErrorStr(str2)) return "Error"; if (str1.Length == str2.Length) return "String are same length"; if (str1.Length > str2.Length) return str1; else return str2; }; var result5 = WhoIsLonger("Nissim Veniflaot", "Abra Kadabra"); Console.WriteLine("Sample 05 - " + result5);

Lambda Expressionפתרונות - למבדה שעשועי

: קוד LambdaEXדוגמת

: , , ב להוריד ניתן מצגות חומרים הסילבוס את

. . .www corner co il