LINQ (Language Integrated Query)
ÜbersichtEinleitung zu LINQLINQ SyntaxLINQ to Objects(Übungen)LINQ to XML(Übungen)LINQ to SQL(Übungen)Fragen/Diskussion
Was ist LINQ?Komponente zum Abfragen von DatenquellenModifizieren 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
Vorteile und NachteileVorteile 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
BasiswissenLambda Expression
• 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);}
}}
SprachdetailsQuery 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“)
Restriction Operators
Where• from customer in Customers where customer.Fax != null select customer
• Customers.Where((customer, index) => customer.Fax != null && index < 5)
Projection OperatorsSelect• 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()))
Partitioning OperatorsTake
• (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)
Ordering OperatorsOrderBy
• 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()
Grouping Operators
GroupBy• from customer in Customers group customer by customer.City into city select city
• Customers.GroupBy(customer => customer.City)
Set OperatorsDistinct
• (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))
Conversion OperatorsToArray
• (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()
Element OperatorsFirst
• (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()
Generation OperatorsRange• 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>()
QuantifiersAny• (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)
Aggregate OperatorsCount
• 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)•Customers.Count()
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)
Miscellaneous OperatorsConcat
• (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 })
JoinOperatorsJoin
• 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}
LINQ to XMLErlaubt Lesen, schreiben von XML
DokumentenVereinfacht lesen und schreiben von XML
Daten
Object Model
Erklärung Object ModelsXDocument
• 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
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
Beispiel SEPA
Beispiel SEPA 2
Query SyntaxNodes
•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()
Data ModificationAdd• XContainer.Add(XElement)• XContainer.AddFirst(XElement)• XContainer.AddBeforeSelf(XElement)• XContainer.AddAfterSelf(XElement)
Remove• XNode.Remove()• IEnumerable<T>.RemoveAll()
ReplaceAll• XElement.ReplaceAll(XElement, XElement)
Das wars… vorerst ;)
