Im letzten Posting habe ich die Möglichkeiten beschrieben einen Delegate als Paramter zu akzeptieren.

Auch dort haben wir bereits den weg über Predicate<T> verwendet:

   1: ... Demo1.GetDemos(  

   2:             delegate(Demo d)   

   3:                 {   

   4:                     return (d.Active && d.Name == "Test");

   5:                 }                  

   6:             );

Oft ist man (wie im letzten Beispiel) nicht mehr gezwungen für alles einen eigenen Delegate zu erstellen. Hierfür kann man nun Func<T> (oder auch Action<T>, …) verwenden.

Aussehen kanns dann so:

   1: Func<int, bool> f = (i) => i == 1;

   2: var res = f(10);

Variable “f” beinhaltet nun unsere eigentliche Logik (Zuweisung über Lambda-Schreibweise). Dessen Aufruf ist dann denkbar einfach und natürlich können wir auch hier wieder Funktionen definieren die einen Parameter Func<T> nimmt.

Funktionen/Methoden schreiben ist einfach. Paramter übergeben auch.

Schon mal eine Methode definiert die indirekt “Code” (einen Predicate<T>) als Parameter übernimmt?

Mithilfe eines Predicate<T> ermöglichen Sie die übergabe eines Delegates und schaffen somit die Möglichkeit Ihre eigene dynamischen (strongly Typed) Filter zu erstellen.

Wie kanns aussehen?

Zuerst die Funktion definieren die einen Predicate<T> als Paramter nimmt:

   1: public static class Demo1   

   2: {   

   3:     public static List<Demo> GetDemos(Predicate<Demo> p)

   4:     {

   5:         var lst = GetList(); //Ladet eine Liste die gefiltert werden soll   

   6:         foreach (v i in lst) 

   7:         {

   8:             if (p(i))

   9:                 yield return i;

  10:         }

  11:     }

  12: }

Aufruf:

   1: var lst = Demo1.GetDemos(

   2:                 delegate(Demo d) 

   3:                     {

   4:                         return (d.Active && d.Name == "Test");

   5:                     }

   6:                );

Und somit sollten auch die Technolgien die hinter LINQ Stecken wieder etwas 
verständlicher werden.

In einem Linq Model kann man ein “Join” relativ einfach hinbekommen wenn die Einzelnen Elemente bereits Beziehungen haben. (Stichwort EntitySet<T>)

 

Durch diese Beziehung kann man nun Abfragen (die mehr als ein Objekt/Tabelle betreffen) sehr einfach mit der . Schreibweise definieren.

   1: var query = from o in DB.Orders

   2:     select new

   3:     {

   4:         Name = o.Customer.CompanyName,

   5:         OrderID = o.OrderID

   6:     };

Doch oftmals gibts genau diese Beziehung zwischen den Objekten nicht (hier zwischen Customer u. Order).
Wie kommt man trotzdem zum Ergebnis? Join-Keyword!

   1: var query = from o in DB.Orders

   2:     join c in DB.Customers on o.CustomerID equals c.CustomerID

   3:     select new

   4:     {

   5:         Name = c.CompanyName,

   6:         OrderID = o.OrderID

   7:     };

Download Sample: LinqJoin.zip

Dieses Jahr werde ich auf der VSONE einen Workshop zum Thema “C# –> LINQ” halten.

Delegates, anonyme Methoden und Lambda Expression waren Ihnen immer schon ein Rätsel? Sie wollen mit weniger Code MEHR tun? Holen Sie sich noch einen der letzten Plätze.

Auf der Konferenz gibts eine kompakte Zusammenfassung zum Thema in der Session “C# 3.0 in LINQ”

Windows Live Mesh, zu finden unter https://www.mesh.com/ ist eine flexible Möglicheit Daten über mehrere Systeme zu synchronisieren.

zB Favoriten können damit mit 2 klicks

a) im Internet verfügbar gemacht werden
     und
b) über System synchronisiert werden.

Im Moment ist das Produkt noch Beta (und bietet 5 GB kostenlosen Speicher!)

Wie findet Ihr das Teil?

… all meinen Lesern/innen.

Spannendes steht uns bevor 2009: Windows 7, .net 4.0, Visual Studio 2010, Oslo, … (oder zumindest eine Beta davon)

Auf was freut ihr euch am meisten?