LINQ - Language Integrated Query.
LINQ som er den store nyskabelse i .NET 3.0 står for Language Integrated Query. Idéen er at skabe et querysprog som er generelt anvendeligt uanset hvilken type data der er tale om, og at gøre querys til "first class citizens" som Anders Hejlsberg ynder at udtrykke det. Med andre ord vil det sige at querys skal væk fra at være noget man skjuler i et datalag og op hvor de hører hjemme som en naturlig del af logikken. Derudover for man compile time type checking og intellisence da det ikke blot er strenge man arbejder med.
Som udgangspunkt findes der 3 datadomæner der udgør 5 typer som LINQ kan arbejde med, men lige som med alt andet i .NET er det naturligvis muligt at lave sine egne klasser til at håndrere andre former. .NET shippes med support for LINQ to Objects, LINQ to XML, LINQ to SQL, LINQ to DataSet og LINQ to Entities.
LINQ basics.
LINQ kan arbejde med alt der implementerer IEnumerable<T>, da det giver mulighed for at data kan traverseres sekventielt. Klasserne til at behandle sekventielle querys findes i System.Query.Sequence.
Funktioner, som where, from, select, union osv. er defineret som extension methods (se evt artikel om .NET 3.5 og Orcas), med en høj grad af inferens sådan at de kan bruges som udtryk uden at alle typer skal specificeres minutiøst. Inferens er vigtig for kodens læsbarhed da man derved kan skrive "from c in customers" uden at skulle skrive specifikt at c er af typen Customer.
IQueryable<T> arver fra IEnumerable<T> og tilføjer på overfladen blot de to metoder CreateQuery<T> og Execute<T>, men det er dem der gør det muligt at bygge et expression tree ved hjælp af klasserne i System.Query.Queryable og afvikle det som et query imod sine data. Det er derved muligt at lave optimerede og dynamiske querys hvis det skulle være nødvendigt. Det er denne type optimerede querys vi omtaler som LINQ to SQL, LINQ to XML osv. som er rettet imod at lave effektive querys imod specifikke datakilder.
LINQ to Objects.
I forbindelse med querys imod objekter for man mulighed for at finde frem til objekter med bestemte egenskaber på en pænere måde end man traditionelt kan idet man er nød til at skrive loops inden i loops for at gennemløbe hirakisk struktureret data.
Et simpelt eksempel som du kan se her viser syntaksen for hvordan man i en liste af customers kan finde customers der kommer fra en by der starter med bogstavet "O".
IEnumerable<Customer> list = from customer in customers
where customer.City.StartsWith("O")
select customer;
Men udover de helt banale metoder til at filtrere data er der en række metoder til f.eks. at lave unions, paging, order by, returnere resultatet som List eller Array osv. Her et et eksempel hvor den 3 og 4 customer hvis navn starter med "C" i 2 collections returneres sorteret efter navn som en Liste der bruges som argument til instantieringen af en Collection<Customer>.
Collection <Customer> list = new Collection<Customer>(
(from customer in customers.Union(customers2)
where customer.Name.StartsWith("C")
orderby customer.Name
select customer).Skip(2).Take(2).ToList());
LINQ to XML.
LINQ to XML giver naturligvis de samme muligheder for at skrive querys og udtrække de data man har behov for. Udover det følger der en række klasser med der bruges til at arbejde med XML, og disse kan genkendes ved at de er prefixet med X. Her er et eksempel på hvordan man kan bygge et simpelt xml dokument.
XElement element = new XElement("contacts",
new XElement("contact", new XAttribute("name", "Christian")),
new XElement("contact", new XAttribute("name", "Mia")));
VB får faktisk mulighed for at gøre dette endnu enklere, idet xml'en kan skrives direkte inline. Herefter vil compileren automatisk generere kode som i ovenstående eksempel.
Når man så enten har bygget eller loadet sit xml fra en fil kan querys laves med følgende syntaks:
var names = from el in element.Descendants("contact")
where el.Attribute("name").Value.StartsWith("C")
select el.Attribute("name");
LINQ to SQL || LINQ to Entities || LINQ to Dataset.
LINQ to SQL og LINQ to Entities er til at arbejde med data fra en database, men derudover shippes også LINQ to Dataset til at lave querys imod disconnectede data. LINQ to SQL og Entities fungerer ved at man designer en mapningsstruktur lidt på samme måde som ved brug af strongly typed datasets. Editoren til at gøre dette kan undværes, da der er også er et commandline tool ved navn sqlmetal. Det er muligt ved hjælp af switchen "/sprocs" af få genereret metoder til at bruge stored procedures.
sqlmetal /server:localhost /database:AdventureWorks /user:username
/password:password /sprocs /code:AdventureWorks.cs
En overordnet måde at se denne slags mapning på er:
Database -> DataContext
Table -> Class
Column -> Property
Stored Procedure -> Method
LINQ to Entities bygger på Entities frameworket som er en del af ADO og er et superset af den funktionalitet LINQ to SQL tilbyder. Det er derved muligt at lave en logisk model oven på sin database, og arbejde med arv, mange-til-mange relationer og sammensatte klasser bestående af værdier fra forskellige tabeller i databasen. Alternativt kan man arbejde med LINQ to SQL der er mere simpelt, og så enten binde direkte til datasources, eller lave sin egen mapning af objekter.
Når LINQ kommer kan man altså enten arbejde direkte med data eller bruge en container i form af datasets eller entities.
For at give et indtryk af hvordan man arbejder med databaser er her en række eksempler.
Et typisk eksempel på et query imod et dataset kan så se ud som sådan:
var query = from dataRow in ds.customerTable.AsEnumerable()
where r.Field<string>("LastName") == "Nielsen"
select r.Field<string>(“FirstName”);
Ligeledes vil et query der returnerer autogenererede custom entities se sådan ud:
Databases.MyDB db = new Databases.MyDB(connectionString);
var nameList = from c in db.Customers
join a in db.Adresses
on c.AdressID equals a.ID
orderby c.Name
select new Customer{Name = c.Name};
Sidst men ikke mindst skal man jo også kunne submitte ændringer tilbage til databasen. Dette er så enkelt som det kan være, så jeg vil lade et insert og delete kodeeksempel tale for sig selv.
MyDB db = new MyDB(connection);
Customer c = new Customer();
c.Name = "Luffe";
Customer c2 = new Customer();
c2.Name = "Ole";
db.Customers.Add(c);
db.Customers.Remove(c2);
db.SubmitChanges();
Som man næsten kan gætte er updates lige så enkle, men for god ordens skyld er her et eksempel.
var customer = db.Customers.Single( c => c.Name == "Bo" );
customer.Name = "Ib";
db.SubmitChanges();
Dynamiske querys.
Til lidt mere advanceret brug er det også muligt at bygge sine querys dynamisk. Det følgende eksempel viser hvordan man eksempelvis kan konstruere et query der finder Customers fra Odense.
IQueryable queryable = customers.ToQueryable();
ParameterExpression parameter = Expression.Parameter(typeof(Customer), "c");
Expression body = Expression.EQ(
Expression.Property(parameter, typeof(Customer).GetProperty("City")),
Expression.Constant("Odense"));
LambdaExpression predicate = QueryExpression.Lambda(body, parameter);
Expression where = QueryExpression.Where(queryable.Expression, predicate);
queryable = queryable.CreateQuery(where);
Subscribe