linq (language integrated query)

28
LINQ (Language Integrated Query)

Upload: marcin

Post on 24-Feb-2016

110 views

Category:

Documents


2 download

DESCRIPTION

LINQ (Language Integrated Query). Ü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 Datenquellen Modifizieren und neu erstellen von Daten - PowerPoint PPT Presentation

TRANSCRIPT

Page 1: LINQ  (Language Integrated Query)

LINQ (Language Integrated Query)

Page 2: LINQ  (Language Integrated Query)

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

Page 3: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

Vorteile und NachteileVorteile NachteileÜberprüfung durch Compiler Teilweise spürbar langsamer als

SchleifenGleicher Syntax für verschiedene Zwecke

Neuer Syntax zum erlernen

Code leserlicher und kürzer Debug wesentlich schwierigerPLINQ vereinfacht Multithreading

Page 5: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

Restriction Operators

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

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

Page 8: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

Grouping Operators

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

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

Page 12: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

LINQ to XMLErlaubt Lesen, schreiben von XML

DokumentenVereinfacht lesen und schreiben von XML

Daten

Page 21: LINQ  (Language Integrated Query)

Object Model

Page 22: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

Beispiel SEPA

Page 25: LINQ  (Language Integrated Query)

Beispiel SEPA 2

Page 26: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

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: LINQ  (Language Integrated Query)

Das wars… vorerst ;)