Übersicht Einleitung zu LINQ LINQ Syntax LINQ to Objects (Übungen) LINQ to XML (Übungen) LINQ to...

28
LINQ (Language Integrated Query)

Transcript of Übersicht Einleitung zu LINQ LINQ Syntax LINQ to Objects (Übungen) LINQ to XML (Übungen) LINQ to...

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

LINQ (Language Integrated Query)

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

ÜbersichtEinleitung zu LINQLINQ SyntaxLINQ to Objects(Übungen)LINQ to XML(Übungen)LINQ to SQL(Übungen)Fragen/Diskussion

Page 3: Übersicht Einleitung zu LINQ LINQ Syntax LINQ 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

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

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

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

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);}

}}

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

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“)

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

Restriction Operators

Where• from customer in Customers where customer.Fax != null select customer

• Customers.Where((customer, index) => customer.Fax != null && index < 5)

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

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()))

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

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)

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

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()

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

Grouping Operators

GroupBy• from customer in Customers group customer by customer.City into city select city

• Customers.GroupBy(customer => customer.City)

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

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))

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

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()

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

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()

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

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>()

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

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)

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

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)

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

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 })

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

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}

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

LINQ to XMLErlaubt Lesen, schreiben von XML

DokumentenVereinfacht lesen und schreiben von XML

Daten

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

Object Model

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

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 &lt; zB. nötig <![CDATA[<Customer>Adrian</Customer>]]>

XElement• Child Element/Node im XML <Customer></Customer>• XElement.Parse(String) erlaubt erstellen von Xelement aus string

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

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

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

Beispiel SEPA

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

Beispiel SEPA 2

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

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()

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

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)

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

Das wars… vorerst ;)