1. LINQ (Language Integrated Query)

2. Übersicht Einleitung zu LINQ LINQ Syntax LINQ to Objects (Übungen)
LINQ to XML
LINQ to SQL
Fragen/Diskussion

3. Was ist LINQ? Komponente zum Abfragen von Datenquellen
Modifizieren und neu erstellen von Daten
.Net 3.0 erste Version
.Net 3.5 erweitert (anfragemanipulierende Erweiterungsmethoden)
.Net 4.0 PLINQ (Parallel LINQ)
Standard Data Provider: LINQ to Objects, SQL, DataSets, XML

4. Vorteile und Nachteile
Überprüfung durch Compiler
Teilweise spürbar langsamer als Schleifen
Gleicher Syntax für verschiedene Zwecke
Neuer Syntax zum erlernen
Code leserlicher und kürzer
Debug wesentlich schwieriger
PLINQ vereinfacht Multithreading

5. Basiswissen Lambda Expression var keyword Object Initialization
x => x.Length > 5
(x, y) => x == y
var keyword
var myInteger = 1;
var myString = „I‘m a string.“;
Object Initialization
Person adrian = new Person {Vorname = „Adrian“, Nachname = „Weidermann“};
var adrian = new Person {Vorname = „Adrian“, Nachname = „Weidermann“};
Anonymous Types
var adrian = new {Vorname = „Adrian“, Nachname = „Weidermann“};
var tier = new {Gattung = „Nashorn“, Name = „Kleiner Muck“, Gewicht = 350, Alter = 2};
Extionsion Methods
/// <summary> /// Extends all Enumerables. /// </summary> public static class EnumerableExtension { /// <summary> /// Executes the action for every element in list. /// </summary> /// <typeparam name="T">The Target type.</typeparam> /// <param name="source">The enumerable source.</param> /// <param name="action">The action to do.</param> public static void ForEach<T>(this Ienumerable<T> source, Action<T> action) { foreach (var item in source) { action(item); } } }

6. Sprachdetails Query Syntax An SQL angelehnt
Übersichtlicher bei den meisten komplizierten Abfragen
from x in persons where x.Vorname == „Adrian“
Fluent Syntax
Platzsparender
Übersichtlicher bei den meisten einfachen Abfragen
persons.Where(x => x.Vorname == „Adrian“)

7. Restriction Operators
Where
from customer in Customers where customer.Fax != null select customer
Customers.Where((customer, index) => customer.Fax != null && index < 5)

8. Projection Operators Select SelectMany
from customer in Customers select new {Name = customer.ContactName.ToUpper(), Phone = customer.Phone}
Customers.Select((customer, index) => new {Name = customer.ContactName.ToUpper(), Phone = customer.Phone, Index = index})
SelectMany
from customer in Customers from order in customer.Orders select new {Name = customer.ContactName.ToUpper(), Phone = customer.Phone, order.OrderDate}
Customers.SelectMany((customer, index) => customer.Orders.Select(order => „Customer #“ + (index +1) + „ ordered on „ + order.OrderDate.ToString()))

9. Partitioning Operators
Take
(from customer in Customers select customer).Take(5)
Customers.Take(5)
Skip
(from customer in Customers select customer).Skip(5)
Customers.Skip(5)
TakeWhile
(from customer in Customers select customer).TakeWhile(customer => customer.Phone != null)
Customers.TakeWhile(customer => customer.Phone != null)
SkipWhile
(from customer in Customers select customer).SkipWhile(customer => customer.Phone != null)
Customers.SkipWhile(customer => customer.Phone != null)

10. Ordering Operators OrderBy OrderByDescending ThenBy ThenByDescending
from customer in Customers orderby customer.ContactName select customer
Customers.OrderBy(customer => customer.ContactName)
OrderByDescending
from customer in Customers orderby customer.ContactName descending select customer
Customers.OrderByDescending(customer => customer.ContactName)
ThenBy
from customer in Customers orderby customer.City descending, customer.ContactName select customer
Customers.OrderBy(customer => customer.City).ThenBy(customer => customer.ContactName)
ThenByDescending
from customer in Customers orderby customer.City descending, customer.ContactName descending select customer
Customers.OrderBy(customer => customer.City).ThenByDescending(customer => customer.ContactName)
Reverse
Customers.Reverse()

11. GroupBy Grouping Operators
from customer in Customers group customer by customer.City into city select city
Customers.GroupBy(customer => customer.City)

12. Set Operators Distinct Union Intersect Except
(from customer in Customers select customer).Distinct()
Customers.Distinct()
Union
(from customer in Customers select customer.ContactName).Union(from order in Orders select order.CustomerID)
Customers.Select(customer => customer.ContactName).Union(Orders.Select(order => order.CustomerID))
Intersect
(from customer in Customers select customer.ContactName).Intersect(from order in Orders select order.CustomerID)
Customers.Select(customer => customer.ContactName).Intersect(Orders.Select(order => order.CustomerID))
Except
(from customer in Customers select customer.ContactName).Except(from order in Orders select order.CustomerID)
Customers.Select(customer => customer.ContactName).Except(Orders.Select(order => order.CustomerID))

13. Conversion Operators ToArray ToList ToDictionary OfType Cast ToLookup
(from customer in Customers select customer).ToArray()
Customers.ToArray()
ToList
(from customer in Customers select customer).ToList()
Customers.ToList()
ToDictionary
(from customer in Customers select customer).ToDictionary(customer => customer.ContactName)
Customers.ToDictionary(customer => customer.ContactName)
OfType
(from customer in Customers select customer.PostalCode).OfType<Int32>()
Customers.Select(customer => customer.PostalCode).OfType<Int32>()
Cast
(from customer in Customers select customer.PostalCode).Cast<Int32>()
Customers.Select(customer => customer.PostalCode).Cast<Int32>()
ToLookup
(from customer in Customers select customer).ToLookup(customer => customer.City = "Vienna")
Customers.ToLookup(customer => customer.City = "Vienna")
AsEnumerable
(from customer in Customers select customer).AsEnumerable().Reverse()
Customers.AsEnumerable().Reverse()

14. Element Operators First FirstOrDefault Single SingleOrDefault
(from customer in Customers select customer).First(customer => customer.PostalCode == null)
Customers.First(customer => customer.PostalCode == null)
FirstOrDefault
(from customer in Customers select customer).FirstOrDefault(customer => customer.PostalCode == null)
Customers.FirstOrDefault(customer => customer.PostalCode == null)
Single
(from customer in Customers select customer).Single(customer => customer.PostalCode == null)
Customers.Single(customer => customer.PostalCode == null)
SingleOrDefault
(from customer in Customers select customer).SingleOrDefault(customer => customer.PostalCode == null)
Customers.SingleOrDefault(customer => customer.PostalCode == null)
ElementAt
(from customer in Customers select customer).ElementAt(1)
Customers.ElementAt(1)
ElementAtOrDefault
(from customer in Customers select customer).ElementAtOrDefault(1)
Customers.ElementAtOrDefault(1)
DefaultIfEmpty
(from customer in Customers select customer).DefaultIfEmpty().First()
Customers.DefaultIfEmpty().First()

15. Generation Operators Range Repeat Empty
from n in Enumerable.Range(100, 50) select new { Number = n, OddEven = n % 2 == 1 ? "odd" : "even" }
Repeat
Enumerable.Repeat(„RepeatMe“, 10)
Empty
Enumerable.Empty<string>()

16. Quantifiers
Any
(from customer in Customers select customer).Any(customer => customer.Country != null)
Customers.Any(customer => customer.Country != null)
All
(from customer in Customers select customer).All(customer => customer.Country != null)
Customers.All(customer => customer.Country != null)

17. Aggregate Operators Count LongCount Sum Min Max Average Aggregate
from customer in Customers group customer by customer.ContactTitle into customerGrouped select new { Customer = customerGrouped.Key, OrderCount = customerGrouped.Count() }
Customers.Count()
LongCount
from customer in Customers group customer by customer.ContactTitle into customerGrouped select new { Customer = customerGrouped.Key, OrderCount = customerGrouped.LongCount() }
Customers.LongCount()
Sum
(from order in Orders select order).Sum(order => order.Freight)
Min
(from order in Orders select order).Min(order => order.Freight)
Orders.Min(order => order.Freight)
Max
(from order in Orders select order).Max(order => order.Freight)
Orders.Max(order => order.Freight)
Average
(from order in Orders select order).Average(order => order.Freight)
Orders.Average(order => order.Freight)
Aggregate
(from order in Orders select order).Aggregate(100, (orderIDBalance, nextValue) => ((nextValue.OrderID <= orderIDBalance) ? (orderIDBalance - nextValue.OrderID) : orderIDBalance))
Orders.Select(order => order.OrderID).Aggregate((orderID, nextValue) => orderID * nextValue)

18. Miscellaneous Operators
Concat
(from customer in Customers select customer.ContactName).Concat(from order in Orders select order.ShipCity)
Customers.Select(customer => customer.ContactName).Concat(Orders.Select(order => order.ShipCity))
EqualAll
(from customer in Customers select customer.ContactName).SequenceEqual(from order in Orders select order.ShipCity)
Customers.Select(customer => customer.ContactName).SequenceEqual(Orders.Select(order => order.ShipCity))
Let
from customer in Customers let AddressInfo = customer.Address + " " + customer.PostalCode + " " + customer.City + " " + customer.Country select new { Name = customer.ContactName, Address = AddressInfo }
Customers.Select(customer => new { Customer = customer, AddressInfo = customer.Address + " " + customer.PostalCode + " " + customer.City + " " + customer.Country }).Select(newCustomer => new { Name = newCustomer.Customer.ContactName, Address = newCustomer.AddressInfo })

19. JoinOperators Join GroupJoin LeftOuterJoin
from customer in Customers join order in Orders on customer.CustomerID equals order.CustomerID select new { Name = customer.ContactName, OrderDate = order.OrderDate}
Customers.Join(Orders, customer => customer.CustomerID, order => order.CustomerID, (customer, order) => new { Name = customer.ContactName, OrderDate = order.OrderDate})
GroupJoin
from customer in Customers join order in Orders on customer.CustomerID equals order.CustomerID into groupedOrder select new { Name = customer.ContactName, OrderDate = groupedOrder}
Customers.GroupJoin(Orders, customer => customer.CustomerID, order => order.CustomerID, (customer, groupedOrder) => new { Name = customer.ContactName, OrderDate = groupedOrder})
LeftOuterJoin
from customer in Customers join order in Orders on customer.CustomerID equals order.CustomerID into groupedOrder from order in groupedOrder select new { Name = customer.ContactName, OrderDate = groupedOrder}

20. LINQ to XML Erlaubt Lesen, schreiben von XML Dokumenten
Vereinfacht lesen und schreiben von XML Daten

21. Object Model

22. Erklärung Object Models
XDocument
Ein XML Sheet (inkludiert laden und speichern)
XDocument.Parse(String) erlaubt erstellen von Xelement aus string
XDeclaration
Informationen zum Sheet
XDocumentType
Definiert den Dokumenten Typ <!DOCTYPE Customers SYSTEM „Customerss.dtd">
XText
Alle String Objekte
XCData
Übernimmt den Text 1 : 1 also kein < zB. nötig <![CDATA[<Customer>Adrian</Customer>]]>
XElement
Child Element/Node im XML <Customer></Customer>
XElement.Parse(String) erlaubt erstellen von Xelement aus string

23. XProcessingInstruction
XAttribute
Attribut eines Objektes <Customer Name=„Adrian“/>
XProcessingInstruction
Informationen für Anwendungen <?CustomerOption remove?>
XComment
Kommentar <!-- The customer -->
XNamespace
Namespace
XStreamingElement
Erlaubt einbetten von LINQ

24. Beispiel SEPA

25. Beispiel SEPA 2

26. Query Syntax Nodes Element(s) Anchestor Descendants Attribute
Customers.Nodes()
Customers.NodesBeforeSelf()
Customers.NodesAfterSelf()
Element(s)
Customers.Elements()
Customer.Element(„ContactName“)
Customers.ElementsAfterSelf()
Customers.ElementsBeforeSelf()
Anchestor
Orders.Anchestors()
Orders.AnchestorsAndSelf()
Descendants
Customers.Descendants()
Customers.DescendantsAndSelf()
Attribute
XElement.Attribute()
XElement.Attributes()
Annotation
XObject.Annotation()
XObject.Annotations()

27. Data Modification Add Remove ReplaceAll XContainer.Add(XElement)
XContainer.AddFirst(XElement)
XContainer.AddBeforeSelf(XElement)
XContainer.AddAfterSelf(XElement)
Remove
XNode.Remove()
IEnumerable<T>.RemoveAll()
ReplaceAll
XElement.ReplaceAll(XElement, XElement)

28. Das wars… vorerst ;)