Thorsten Kansy LINQ. Direkte Abfragen mit Language Integrated Query

Transkript

1

2 Thorsten Kansy LINQ

3

4 Thorsten Kansy LINQ Direkte Abfragen mit Language Integrated Query

5 Thorsten Kansy: LINQ Direkte Abfragen mit Language Integrated Query ISBN: entwickler.press Ein Imprint der Software & Support Verlag GmbH Bibliografische Information Der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über abrufbar. Ihr Kontakt zum Verlag und Lektorat: Software & Support Verlag GmbH entwickler.press Goethestraße München Tel: +49(0) Fax: +49(0) Lektorat: Sandra Michel, Fachkorrektorat: Walter Saumweber Korrektorat: mediaservice, Siegen Satz: mediaservice, Siegen Umschlaggestaltung: Melanie Hahn, Maria Rudi Belichtung, Druck & Bindung: M.P. Media-Print Informationstechnologie GmbH, Paderborn Alle Rechte, auch für Übersetzungen, sind vorbehalten. Reproduktion jeglicher Art (Fotokopie, Nachdruck, Mikrofilm, Erfassung auf elektronischen Datenträgern oder andere Verfahren) nur mit schriftlicher Genehmigung des Verlags. Jegliche Haftung für die Richtigkeit des gesamten Werks kann, trotz sorgfältiger Prüfung durch Autor und Verlag, nicht übernommen werden. Die im Buch genannten Produkte, Warenzeichen und Firmennamen sind in der Regel durch deren Inhaber geschützt.

6 You are my inspiration, You are my battle cry Für Ursula

7

8 Inhaltsverzeichnis 1 Vorwort und Einleitung 13 2 Einführung Überblick Die technischen Bausteine von LINQ 19 Erweiterungsmethoden 19 Lambda-Funktionen 22 Lokale Typinferenz 25 Anonyme Typen 28 Kompaktere Initialisierung von Objekten Die LINQ-Schnittstellen Abfrage-Syntax Sequenz vs. Auflistung Verzögerte Ausführung Sofortige Ausführung Performance 41 LINQ to Objects 42 LINQ to SQL 43 3 Operatoren Projektionsoperatoren 46 Select 47 SelectMany Filteroperatoren 53 Where 53 OfType Sortierungsoperatoren 56 OrderBy/OrderBy Descending 57 ThenBy/ThenByDescending 60 Reverse Gruppierungsoperatoren 65 GroupBy Join-Operatoren 71 Join 71 GroupJoin 75 LINQ 7

9 Inhaltsverzeichnis 3.6 Mengenoperatoren 78 Distinct 78 Union 81 Intersect 84 Except Aggregationsoperatoren 90 Count/LongCount 90 Sum 92 Min/Max 95 Average 100 Aggregate Generierungsoperatoren 107 Range 107 Repeat 108 Empty Quantifizierungsoperatoren 111 All 111 Any 113 Contains Aufteilungsoperatoren 118 Take 118 TakeWhile 119 Skip 121 SkipWhile Elementoperatoren 125 First/Last 125 FirstOrDefault/LastOrDefault 128 ElementAt 130 ElementAtOrDefault 131 Single 132 SingleOrDefault 134 DefaultIfEmpty Konvertierungsoperatoren 139 ToArray 139 ToList 140 ToDictionary 141 ToLookup 144 AsEnumerable 148 AsQueryable 149 Cast Sonstige Operatoren 151 Concat 151 SequenceEqual 152 8

10 Inhaltsverzeichnis 4 LINQ-Operatoren entwickeln Grundlagen 157 Parametername 157 So generisch wie möglich implementieren 158 Generische Datentypen 158 Den Yield-Operator verwenden 159 Verzögerte Ausführung 160 Alle Parameter überprüfen 162 Func, Predicate und Action CreateSequence-Operator I CreateSequence-Operator II Identity-Operator Standardoperatoren überladen LINQ to Objects LINQ to SQL DataContext 183 Erzeugen 185 Unabhängige Verbindungen zur Datenbank Entitäten-Klassen 189 Database-Attribut 190 Table-Attribut 190 Column-Attribut 191 Association-Attribut 192 Das InheritanceMapping-Attribut 195 Die Function- und Parameter-Attribute 196 Entitäten-Klassen mit Business-Logik erweitern 204 Datenbankstruktur aus Metadata erstellen/löschen Entitäten-Klassen generieren 208 Manuell per Code 209 SqlMetal-Anwendung 209 Mit Visual Studio 2005/2008 arbeiten Parallelitätskonflikte 216 Pessimistisch 216 Ignorant 216 Optimistisch Transaktionen 218 ADO.NET-Transaktionen 218 TransactionScope Daten abfragen, modifizieren und in die Datenbank schreiben 220 LINQ-Abfragen 220 Optionen für das Laden von Daten 220 Verzögertes Laden umgehen 222 LINQ 9

11 Inhaltsverzeichnis Daten verändern 223 Änderungen in Datenbank schreiben 225 Daten erneut aus Datenbank laden 229 Abfragen kompilieren 230 Disconnected Mode 232 Abfragen protokollieren LINQ to DataSets DataSets Grundlagen Übersicht Untypisierte DataSets 240 Struktur per Code anlegen 241 DataSet befüllen 242 Daten mit LINQ abfragen 244 Daten ändern 245 Änderungen speichern Typisierte DataSets 249 Struktur anlegen 249 DataSet befüllen 251 Daten mit LINQ abfragen 251 Daten ändern 252 Änderungen speichern LINQ to XML LINQ to XML im Einsatz 256 XML abfragen 257 XML erzeugen X-Klassen 261 Die XDocument-Klasse 262 XDeclaration-Klasse 270 XDocumentType-Klasse 272 XComment-Klasse 275 XElement-Klasse 277 XAttribute-Klasse 284 XCData-Klasse Änderungen überwachen LINQ to Entities Entities vs. Entities Mehr als nur CRUD Datenmodelle Der grafische Designer 297 Entitäten, Zuordnungen, Vererbungen 299 Gespeicherte Prozeduren

12 Inhaltsverzeichnis 9.5 Modellbrowser Abfragen Werte ändern Objekte hinzufügen Objekte löschen Änderungen in der Datenbank speichern Datenbindung Windows Forms 307 Via DataSource-Eigenschaft 307 Via DataBindings ASP.NET WPF 317 Eigenständige WPF-Anwendung 319 XBAP-Anwendung 323 A LINQ-Operatoren 329 Stichwortverzeichnis 333 LINQ 11

13

14 Vorwort und Einleitung Willkommen! Schön, dass Sie einen Blick in dieses Buch werfen. Es hat, wie der Titel schon verrät, die neue Abfragesprache LINQ zum Inhalt und versucht, mit einfachen Worten sowie mit vielen anschaulichen Beispielen dem Leser dieses Thema näher zu bringen. Von mir, dem Autor, wurde alles Wissenswerte mit Sorgfalt zu Papier gebracht. Dabei nutze ich meine langjährige Erfahrung als Entwickler und Softwarearchitekt, um auf die Fragen Antworten zu finden, auf die Sie in Ihrer täglichen Arbeit mit LINQ stoßen können. Hilfreich waren dabei auch die unzähligen Schulungen und Gespräche mit Entwicklern. Es ist also ein Buch von einem Programmierer für Programmierer. Ich hoffe, dass sich dies alles positiv in diesem Werk bemerkbar macht. Für wen ist dieses Buch? Dieses Entwicklerbuch richtet sich sowohl an den Anfänger, der bereits etwas Erfahrung in der C#-Programmierung mitbringt, als auch an den Profi, der auf der Höhe der Zeit bleiben möchte. In ein paar Stichworte gefasst, sollte der optimale Leser die folgenden Eigenschaften mitbringen: Interesse und Spaß an der Technik und Programmierung Neugier und Geduld Kenntnisse in C# einige Kenntnisse in SQL und den relationalen Datenbanken, vielleicht sogar SQL Server Aber keine Panik, wenn Ihnen die eine oder andere Grundlage fehlt dieses Buch lässt Sie an den entscheidenden Stellen nicht im Stich. Warum dieses Buch? Dieses Buch deckt alle wichtigen Aspekte von LINQ ab. Kapitel 2 erläutert die technischen Grundlagen. Kapitel 3 und 4 beschreiben alle Standardoperatoren (LINQ-Befehle) und zeigen Ihnen, wie Sie eigene Operatoren selbst implementieren können. Die anschließenden Kapitel gehen dann auf Details von LINQ für Objekte, LINQ für SQL, LINQ für DataSets, LINQ für XML etc. ein. Das letzte Kapitel sozusagen der krönende Abschluss zeigt, wie Daten aus LINQ-Abfragen direkt an Steuerelemente der Oberfläche gebunden werden können. LINQ 13

15 1 Vorwort und Einleitung Das Buch ist also so etwas wie das Rundum-sorglos-Paket für den LINQ-interessierten Entwickler. Um Ihnen, dem Leser, das Lesen und Suchen nach bestimmten (Kern-)Informationen zu erleichtern, folgt dieses Buch einigen Konventionen bezüglich der verwendeten Schriftarten und Formatierungen. Quelltexte werden auf diese Weise hervorgehoben. Wichtige Details oder Änderungen werden zusätzlich noch fett hervorgehoben, damit Sie schneller ins Auge fallen. Schlüsselwörter, Methoden, Eigenschaften und Programmausgaben werden mit diesem Format versehen. Links für Ressourcen im Internet erscheinen in diesem Format. Wird mit Querverweisen auf andere, zum aktuellen Thema passende Inhalte verwiesen, so kommt dieses Format zum Einsatz. Tastaturkürzel wie z.b. (STRG+A) sind ebenfalls hervorgehoben. Besonders wichtige Informationen werden in Kästen wie den folgenden geliefert. Achtung Um Sie vor Fehlern oder Trugschlüssen zu bewahren, finden Sie Warnungen in solchen Kästen. Diese sollten Sie auf jeden Fall lesen. Hinweis Hinweise, die Ihnen Ihre tägliche Arbeit mit LINQ einfacher machen können, werden auf diese Weise präsentiert. Tipp Tipps und Tricks haben in solchen Kästen ihren Platz. Mit diesen Tricks lässt sich LINQ noch einen Tick einfacher und besser verstehen. Desweiteren wurden alle Anstrengungen unternommen, um dieses Werk möglichst fehlerfrei drucken zu können. Sollten Sie (was ich natürlich nicht hoffe) Fehler/Unstimmigkeiten finden, Anregungen oder Kritik (auch positive) für mich haben oder Unterstützung benötigen, so freue ich mich über eine unter Zudem empfängt meine Webseite rund um die Uhr Besucher. 14

16 Schulung, Consulting & Co Sie können mich, meine Erfahrung und mein Know-How übrigens auch buchen. Ich biete meinen Kunden weit gefächerte Dienstleistungen rund um.net und SQL Server an. Dazu gehören auch, jedoch nicht ausschließlich: Schulungen rund um.net (ASP.NET, AJAX, LINQ, WCF, WF, ) in C# und VB.NET und SQL Server in jeder Version Projektbegleitende Unterstützung Analyse Softwarearchitektur Prototyping Coaching Hotline Übersichtvermittlung Vorträge Sprechen Sie mich einfach an, über oder meine Webseite, wie Sie möchten. Danksagung Als Letztes möchte ich mich noch, bevor ich Sie den nächsten Kapiteln überlasse, bei allen bedanken, die mich bei meiner Arbeit unterstützt haben. Allen voran den Mitarbeitern des Software & Support Verlages und meinen Freunden. Ohne sie wäre ich wohl niemals fertig geworden. Viersen, im August 2008 Thorsten Kansy MCPD MCTS MCAD MCSD MCDBA MCSE+I MCT Consultant, Software Designer, Trainer, Fachautor tkansy@dotnetconsulting.eu LINQ 15

17

18 Einführung Language Integrated Query (LINQ) ist einer der neuen Bestandteile des.net Framework 3.5, mit dem der Entwickler unterschiedlichste Daten mittels einer einheitlichen Abfragesprache verarbeiten kann. LINQ ist dabei in die neuen Versionen der Sprachen C# und Visual Basic direkt eingebaut, so dass der Compiler ein hohes Maß an Kontrolle darüber hat. Die Vorteile sollen an dieser Stelle kurz vorgestellt werden. LINQ vereinheitlicht Abfragen auf die unterschiedlichsten Datenquellen. Ob XML, DataSets, einfache Auflistungen oder relationale Datenbanken wie Microsoft SQL Server: Die Syntax für den Zugriff ist immer dieselbe. Im Gegensatz zu T-SQL-Anweisungen, die im Code als Zeichenketten in der Anwendung vorgehalten und als solche auch an den SQL Server gesandt werden, ohne dass der Compiler Syntax und Inhalt überwachen kann, ist bei LINQ der Compiler in der Lage, Fehler und Unstimmigkeiten frühzeitig zu erkennen. LINQ ist typsicher und vollzieht damit den Brückenschlag zwischen Daten und Anwendung. Der Compiler kann zur Entwurfszeit überprüfen, ob Spalten und Rückgabewerte korrekt sind und zueinander passen. Programmierer müssen sich in Verbindung mit LINQ nur noch in eine Sprache wie C# einarbeiten. Ob LINQ wirklich die universelle Abfragesprache wird, bleibt abzuwarten. Die technischen Voraussetzungen sind auf jeden Fall gegeben und werden in den nächsten Abschnitten beschrieben. 2.1 Überblick Wie bereits erwähnt, ist die Abfragesprache LINQ an sich unabhängig von der Art der Datenquelle. Um dies möglich zu machen, bedient sich LINQ eines Mehrschichtenmodells, in dem die Abfragesprache nur die oberste Schicht darstellt. Über eine Vielzahl von datenquellenspezifischen Implementierungen werden die Daten aus so genannten LINQ-fähigen Datenquellen (LINQ enabled data sources) bereitgestellt. Die folgende Grafik zeigt den Aufbau. LINQ 17

19 2 Einführung Abbildung 2.1: Schematischer Aufbau der LINQ-Integration Durch diese Trennung zwischen Abfragesprache und Datenquellen wird es in Zukunft möglich sein, weitere Quellen zu implementieren. Folgende LINQ-Varianten von Microsoft existieren, die auch in diesem Buch behandelt werden: LINQ für SQL: LINQ-Abfragen werden zu SQL-Anweisungen umgewandelt und gegen eine relationale Datenbank ausgeführt. Daten können so abgefragt und auch dauerhaft geändert werden. LINQ für Entitäten: Diese Variante stellt im Vergleich zu LINQ für SQL eine größere Abstraktionsstufe zur Datenbank dar und lässt dem Entwickler mehr Freiheiten zu bestimmen, in welcher Spalte und wie welche Werte gespeichert werden sollen. LINQ für DataSets: Über LINQ können hier Daten verarbeitet werden, die bereits im Speicher in Form von DataSets vorliegen. LINQ für Objekte: LINQ-Abfragen können auf allen Auflistungen durchgeführt werden, die die System.Collection.Generic.IEnumerable<>-Schnittstelle implementieren. LINQ für XML: LINQ-Abfragen können auf XML-Dokumente angewendet werden. Andere Softwareanbieter und Entwickler bieten darüber hinaus weitere Varianten für die unterschiedlichsten Datenquellen an. 18

20 Die technischen Bausteine von LINQ Hinweis LINQ to SQL, LINQ to DataSets und LINQ to Entities werden zusammen als LINQ to ADO.NET bezeichnet. Zunächst jedoch die technischen Bausteine, von denen LINQ profitiert. 2.2 Die technischen Bausteine von LINQ Aus technischer Sicht basiert LINQ im Wesentlichen auf einer Reihe von Neuerungen, die in C# mit der Version 3.x eingeführt wurden. Diese Neuerungen waren notwendig, damit sich LINQ nahtlos in das bestehende Konstrukt der Sprache einfügen kann. Hinweis Die neuen Features wurden natürlich nicht nur in C#, sondern z.b. auch in Visual Basic 9.0 eingebaut, damit auch mit dieser Sprache LINQ verwendet werden kann. Da sich dieses Buch jedoch mit C# als.net-programmiersprache beschäftigt, sei diese etwas einseitige Sicht erlaubt. Im Folgenden werden nun die Neuerungen im Einzelnen erklärt und in Beziehung zu LINQ gesetzt Erweiterungsmethoden Die meisten Erweiterungen, die für LINQ notwendig sind, wurden durch so genannte Erweiterungsmethoden realisiert. Solche Methoden erweitern die entsprechenden Klassen, indem sie quasi angeklebt werden. Dies darf nicht mit der objektorientierten Technik der Vererbung verwechselt werden. Die Vererbung gestattet den Zugriff auf Mitglieder, die mit protected gekennzeichnet sind, wenn die Klasse nicht mit sealed versehen wurde. Erweiterungsmethoden können nur auf solche Mitglieder zugreifen, die auch jedem Anwender der Klasse zur Verfügung stehen. Achtung Auch wenn konkret eine Klasse erweitert wird, kann die Erweiterungsmethode so definiert werden, dass jede Klasse, die eine bestimmte Schnittstelle implementiert, um diese Methode erweitert wird. LINQ nutzt dies massiv, da viele Erweiterungen sich auf die IEnumerable<>-Schnittstelle beziehen. Als Beispiel soll die prominenteste Klasse verwendet werden, von der (leider) nicht abgleitet werden kann: System.String. Während der nachfolgende Code hier einen Fehler erzeugt, LINQ 19

21 2 Einführung // String ist versiegelt, keine Ableitung möglich public class MyString : String {} kann durch Erweiterung der Klasse im folgenden Fragment eine weitere Methode (set- Numeric) angefügt werden. Wichtig ist dabei, dass eine Erweiterungsmethode als public und static deklariert wird. Die Klasse, in der sie sich befindet, ist nebensächlich. Hauptsache, die Klasse steht als Projekt oder als Assembly-Verweis zur Verfügung. public static class StringErweiterung { public static string setnumeric(this string s,int i) { return i.tostring(); } } Vor dem ersten Parameter steht zwingend das Schlüsselwort this. Hinter dem Schlüsselwort steht die Klasse oder die Schnittstelle, die mit dieser Methode erweitert werden soll. Die restlichen, nicht obligatorischen Parameter werden für den Aufruf selbst verwendet. Achtung Genau wie nur nicht-statische Klassen vererben können (statische müssen immer von Object ableiten), können auch nur nicht-statische Klassen mit Methoden erweitert werden. Der Grund liegt darin, dass intern der Methode eine Instanz der Klasse als erster Parameter übergeben wird etwas, was für statische Klassen nicht möglich ist, da von diesen keine Instanzen erzeugt werden können. Ein Aufruf sieht so aus und führt dieses einfache Beispiel auch schon an seine Grenzen, da die übergebene Instanz der Zeichenkette nicht verändert werden kann, weil hierfür das out-schlüsselwort für den ersten Parameter notwendig wäre. Die Kombination aus this und out ist jedoch nicht zulässig. // Es wird eine Variable vom Typ String benötigt, die nicht null ist string s = String.Empty; // Über diese Variable kann die Methode aufgerufen und das Ergebnis // gespeichert werden s = s.setnumeric(100); // Ausgabe Debug.Print("Inhalt von s: '{0}'", s); 20

22 Die technischen Bausteine von LINQ Erweiterungsmethoden funktionieren durch den Trick, dass der Compiler einen Aufruf wie intern als umsetzt. Auch dann, wenn die Variable s lediglich den Wert null aufweist. Erweiterungsmethoden lassen Code also eigentlich nur objektorientierter erscheinen, ohne dass die Implementierung es tatsächlich ist. Dieses Vorgehen des Übersetzens ist auch der Grund, warum alle Erweiterungsmethoden auf diese beiden unterschiedlichen Arten aufgerufen werden können das Ergebnis ist dabei identisch. Die Punkte, die beim Einsatz von Erweiterungsmethoden berücksichtigt werden müssen, lassen sich wie folgt zusammenfassen: Inhalt von s: '100' s = s.setnumeric(100); s = setnumeric(s,100); Erweiterungsmethoden können sowohl für Werte als auch für Referenztypen implementiert werden. Alle Erweiterungsmethoden müssen statisch sein und sich in statischen, nicht-generischen und nicht-verschachtelten Klassen befinden. Die Klassen dürfen also nicht innerhalb anderer Klassen definiert worden sein. Ihr Name ist unerheblich. Vor dem ersten Parameter muss sich das this-schlüsselwort befinden, gefolgt von dem Typ, der erweitert werden soll. Alle weiteren Parameter sind Parameter, die beim Aufruf der Erweiterungsmethode angegeben werden müssen. Erweiterungsmethoden können nach den üblichen Regeln überladen werden. Erweiterungsmethoden müssen nicht zwangsläufig einen Wert zurückliefern, sondern können auch mittels void deklariert werden. Allerdings sind Werteänderungen bei Wertetypen nicht direkt möglich, sondern nur durch Rückgabe eines neuen Wertes und dessen Zuweisung durch den Aufrufer. Da das erste Bespiel nicht besonders prägnant war, hier noch ein zweites, das die System.Data.DataRow-Klasse erweitert, die bei der Arbeit mit DataSets Verwendung findet. Durch die Methode DbNullSaveField() kann auf den Inhalt einer Spalte zugegriffen werden, ohne vorher prüfen zu müssen, ob deren Wert lediglich DbNull enthält. Ist dies nämlich der Fall, dann wird ein Ersatzwert (Fallback-Wert) zurückgegeben, der als Parameter übergeben werden kann. Durch eine generische Implementierung ist ein universeller Einsatz unabhängig vom Datentyp möglich. LINQ 21

23 2 Einführung // Namensraum für Zugriff aus DataRow-Klasse einführen using System.Data; public static class MeineDataRowErweiterung { // Überladung für Angabe des Spaltennamens public static T DbNullSaveField<T>(this DataRow row, string columnname,t FallBackValue) { // Auf DBNull prüfen und Wert oder FallBackValue zurückliefern return!row.isnull(columnname)? row.field<t>(columnname) : FallBackValue; } } Durch die Überladungen kann der Entwickler wählen, ob er für den Zugriff den Namen oder den Index der gewünschten Spalte übergeben möchte. Der Aufruf kann daher auf folgende Art und Weise geschehen: // Kunde ist ein gültiges DataRow-Objekt und es existiert eine Spalte // mit dem Namen Ort string Ort = Kunde.DbNullSaveField<string>("Ort","unbekannt"); // Der Zugriff via Spaltenindex int Anzahlmitarbeiter = Kunde.DbNullSaveField<int>("Anzahlmitarbeiter", 0); Eine Überprüfung auf den richtigen Datentyp findet hier nicht statt. Eine entsprechende Unstimmigkeit führt zu einer Ausnahme Lambda-Funktionen Lambda-Funktionen sind eine syntaktische Vereinfachung bei der Arbeit mit Methoden als Parametern und Delegaten. Eine Lambda-Funktion ist quasi nur noch der Kern der Funktionsdefinition, der beschreibt, wie aus mindestens einem Wert das Ergebnis berechnet wird. Das folgende Beispiel wird schnell Klarheit darüber schaffen und die syntaktischen Alternativen wie anonyme Methoden zum Vergleich stellen. Als Erstes soll eine Methode definiert werden, die drei Parameter akzeptiert: zwei Nachkommazahlen (decimal) und eine Rechenvorschrift, welche diese beiden Werte zu einem Ergebnis verknüpft. public static decimal Rechne( decimal Wert1, decimal Wert2, 22

24 Die technischen Bausteine von LINQ { } Func<decimal,decimal,decimal> Rechenvorschrift) return Rechenvorschrift.Invoke(Wert1, Wert2); Diese Rechenvorschrift wird durch Func<decimal,decimal,decimal> beschrieben. Dabei ist die letzte Typenangabe in den spitzen Klammern der Typ des Ergebnisses, während die restlichen Angaben die Typen der Werte darstellen. Umgangssprachlich steht dort also lediglich:»verwende zwei decimal und erzeuge/berechne daraus ein Ergebnis vom Typ decimal«. Es folgen drei Aufrufmöglichkeiten, die das gleiche Ergebnis erzeugen, sich jedoch durch einen unterschiedlichen Aufwand beim Programmieren unterscheiden. Hinweis Das Func-Schlüsselwort ist bereits eine Vereinfachung für Stellen, an denen sonst eine Delegatendefinition stehen würde. Somit ist die folgende Definition identisch mit folgendem Code: // Delegatendefinition für die Rechne2()-Methode public delegate decimal RechneDelegate(decimal Wert1, decimal Wert2); public static decimal Rechne2( decimal Wert1, decimal Wert2, RechneDelegate Rechenvorschrift) { return Rechenvorschrift.Invoke(Wert1, Wert2); } Func hat also die anonyme Definition eines Delegaten erzeugt, der für die Beschreibung einer entsprechenden Methode als Parameter dient. Aufruf mit einer Methode Für den Aufruf mit einer Methode wird als Erstes die Methodendefinition benötigt, deren Signatur vorgegeben ist. // Methode zur Berechnung des Ergebnisses decimal Addiere(decimal Wert1, decimal Wert2) { return Wert1 + Wert2; } Diese Methode kann durch Angabe des Namens beim Funktionsaufruf verwendet werden. LINQ 23

25 2 Einführung // Aufruf mit Methode decimal Ergebnis1 = Rechne(10m, 2.5m, Addiere); // Ausgabe Debug.Print("Ergebnis1: {0}", Ergebnis1); Das Ergebnis von 12,5 dürfte an dieser Stelle nicht weiter überraschen. Aufruf mit einem anonymen Delegaten Bei der Verwendung von anonymen Delegaten kommt die Implementierung ohne Methode aus, da deren Codeblock direkt notiert wird. Dies hat daher den Hang zur Unübersichtlichkeit, auch wenn sich dadurch die Codemenge reduziert. // Aufruf mit anonymen Delegaten decimal Ergebnis2 = Rechne(10m, 2.5m, delegate(decimal Wert1, decimal Wert2) { return Wert1 + Wert2; }); Wie leicht zu erkennen ist, ist das Ergebnis das gleiche. Aufruf mit einer Lambda-Funktion Eine Lambda-Funktion macht den benötigten Code noch ein wenig übersichtlicher, hat jedoch den Nachteil, dass der Code nur aus einer (logischen) Zeile bestehen darf. Damit sind Fehlerbehandlung, Schleifen oder bedingte Ausführungen Tabu. Eine Lambda- Funktion ist wenig mehr als eine (mathematische) Formel, die ein Ergebnis erzeugt. Die Methode des obigen Beispiels sieht dementsprechend so aus: // Aufruf mit Lambda-Funktion decimal Ergebnis3 = Rechne(10m, 2.5m,(Wert1, Wert2) => Wert1+Wert2); Eine Lambda-Funktion ist auf die folgenden Operationen oder eine Kombination aus diesen beschränkt. Außerdem muss eine Lambda-Funktion immer ein Ergebnis zurückliefern. Verwendung von Operatoren (unär, binär, ternär, Vergleich, etc.) unäre: NextValue => ++(NextValue) binäre: (Wert1, Wert2) => Wert1 + Wert2 tenäre: (Wert) => Wert > 100m? 100m : Wert Vergleich: (Wert1, Wert2) => Wert1 == Wert2 Erzeugen neuer Instanzen von expliziten oder anonymen Typen explizit: (Vorname, Name) => new Person (Vorname, Name) anonym: (Vorname, Name) = > new { Vorname, Name } 24

26 Die technischen Bausteine von LINQ Zugriff auf Mitglieder wie Methoden, Eigenschaften und Felder Methode: Name => Name.ToUpper() Eigenschaft: Eigenschaft: => Name.Length Verkettung von Lambda-Funktionen Name => Name.Trim() => Name.ToUpper() Tipp Wenden Sie Lambda-Ausdrücke nur an, wo es möglich und übersichtlich erscheint. In allen anderen Fällen sind Methoden die bessere Wahl in Hinblick auf Entwicklung und Fehlersuche. LINQ verwendet Lambda-Funktionen für vielerlei Zwecke wie Projektionen, Prädikate beim Filtern, etc. Der Nutzen durch kompakteren Code multipliziert sich also um ein Vielfaches. Zum Abschluss sei noch ein weiteres Beispiel gezeigt, das Lambda-Ausdrücke mit generischer Programmierung kombiniert und das vorherige Bespiel so erweitert, dass diese Methode mit allen Wertetypen (struct) funktioniert. // Generische Variante, die nur Wertetypen akzeptiert public static T Rechne<T>( T Wert1, T Wert2, Func<T, T, T> Rechenvorschrift) where T: struct { return Rechenvorschrift.Invoke(Wert1, Wert2); } Am Aufruf dieser Erweiterungsmethode ändert sich nichts. // Aufruf mit Lambda-Funktion int Ergebnis3 = Rechne(99, 1,(Wert1, Wert2) => Wert1+Wert2); Lokale Typinferenz Der Einsatz der neuen Typinferenz für lokale Variablen ist ein mächtiges Mittel, um lockeren Code zu schreiben und gleichzeitig die Typsicherheit zu bewahren. Im Kern wird bei Typinferenz eine Variable erst durch ihre Zuweisung implizit einem festen Typ zugeordnet. Das Schlüsselwort var steht dabei an der Stelle, an der sonst der konkrete Datentyp erwartet wird. Möglich ist dies, weil der Compiler den Typ anhand des zugewiesenen Wertes bestimmen kann. Ein Boxing/Unboxing, wie es z.b. bei der Verwendung von Object benötigt würde, entfällt. LINQ 25

27 2 Einführung Hinweis Verwenden Sie lokale Typinferenz nach Möglichkeit nur an Stellen, an denen es nicht anders machbar ist, weil der konkrete Datentyp noch nicht bekannt ist. Quelltext wird nicht lesbarer, wenn jedes Mal erraten werden muss, welcher Datentyp zum Einsatz kommt. Lokale Typinferenz ist nicht zur Unterstützung von (Tipp-)Faulheit gedacht! Bei längeren Namen von Datentypen ist die IntelliSense-Funktion des Visual Studio 2008 eine große Hilfe. Das folgende Beispiel demonstriert dies: var s1 = "Hallo LINQ-Welt"; MessageBox.Show(s1.GetType().ToString(), "Typinferenz"); Die Ausgabe der Variablen durch die Messagebox.Show()-Methode lässt erkennen, dass die Variable s tatsächlich vom Typ System.String ist. Abbildung 2.2: Der automatisch verwendete Datentyp ist System.String Das Beispiel ist damit gleichbedeutend mit dem folgenden Codefragment: string s2 = "Hallo LINQ-Welt"; MessageBox.Show(s2.GetType().ToString(),"Mit fester Typenvergabe"); Fehlt bei der Deklaration mit var eine Initialisierung mit einem Wert, so kommt es konsequenterweise zu einem Compilerfehler, da so nicht erkennbar ist, welcher Datentyp verwendet werden muss. Eine Zeile wie var i; ist daher nicht gültig. Abbildung 2.3: Mit var deklarierte Variablen müssen initialisiert werden 26

28 Die technischen Bausteine von LINQ Trotz der Tatsache, dass dem Compiler die Wahl des konkreten Typs überlassen wird, herrscht strikte Typsicherheit. Dies ist leicht am folgenden Fragment erkennbar, welches einen Fehler erzeugt. var s3 = "Hallo LINQ-Welt"; s3 = 10; Dieser Fehler ist identisch mit dem, den der folgende Code erzeugt. string s4 = "Hallo LINQ-Welt"; s4 = 10; Abbildung 2.4: Die Typen int und string können nicht implizit konvertiert werden. Wie der Name lokale Typinferenz schon vermuten lässt, kann dieses Feature nicht überall im Code verwendet werden. Und in der Tat kann es nur für lokale Variablen verwendet werden. Vorrangig sind dies: lokale Variablen innerhalb von Methoden Schleifenvariablen using-blöcke Eine Verwendung z.b. als Methodenparameter hingegen führt postwendend zu einem Compilerfehler. Wann lokale Typinferenz einsetzen und wann nicht? Lokale Typinferenz kann also im lokalen Kontext an Stelle eines expliziten Datentyps verwendet werden. Es stellt sich daher die Frage, wann dieses Feature eingesetzt werden sollte und wann nicht. Dies ist nicht nur eine rein technische Frage und sollte auch nach der Forderung nach einem lesbaren Quellcode beantwortet werden. Quelltexte, die an allen erlaubten Stellen var bei der Deklaration verwenden, leiden schnell darunter, dass deren Sinn durch den nicht immer auf den ersten Blick erkennbaren Datentyp schwerer zu erfassen ist. Der Einsatz der lokalen Typinferenz sollte sich also auf Stellen beschränken, an denen keine andere sinnvolle Möglichkeit existiert. Dies ist bei anonymen Typen (siehe Abschnitt Anonyme Typen) und Auflistungen von solchen der Fall. Die Zeile var unbekannt = new { Text = "LINQ ist toll" }; LINQ 27

29 2 Einführung erzeugt einen solchen anonymen Typ und es liegt in dessen Natur, dass dessen Name unbekannt ist. Hier hat der Compiler sowohl den Typen für den Programmierer erzeugt als auch diesen der Variable zugewiesen. Ähnlich verhält es sich mit Ergebnissen von LINQ-Abfragen, die oft gleich ganze Auflistungen solcher Typen liefern. Hier gilt das Gleiche: lokale Typinferenz ist die einzig sinnvolle Lösung. // Namensraum für Zugriff auf Prozesse einführen using System.Diagnostics; // Alle laufenden Prozesse sortiert nach Namen // abfragen. Von den Prozessen jeweils Namen und // Anzahl der Threads aufnehmen. var procs = from p in Process.GetProcesses() orderby p.processname select new { p.processname, p.threads }; In anderen Fällen, in denen der Typ einer Variablen bekannt ist, sollte die lokale Typinferenz nicht verwendet werden Anonyme Typen Anonyme Typen sind solche, die ohne festen Namen und Definitionen auskommen. Stattdessen ermittelt der Compiler die benötigten Felder nebst Datentypen und erzeugt einen internen Namen, der zwar wie gewohnt mit der GetType()-Methode abgerufen werden kann, jedoch konsequenterweise nicht im Code stehen darf. Somit ist bei einer entsprechenden Deklaration einer Variablen lokale Typinferenz zwingend notwendig, wenn auf Typsicherheit nicht verzichtet werden soll. Anonyme Typen eigenen sich hervorragend für das sorgenfreie Speichern und Abrufen von Werten. Hinweis Durch das Fehlen jeglicher expliziter Definition besteht ein anonymer Typ lediglich aus den benötigten Feldern. Zusätzlich wurde die ToString()-Methode so überschrieben, dass eine Ausgabe mit den Werten aller Felder möglich ist. Weitergehende Einschränkungen auf diese Felder (z.b. durch private, public, etc.) oder Methoden sind nicht möglich. Ein einfacher anonymer Typ kann mit der folgenden Zeile erzeugt werden. var unbekannt = new { Text = "LINQ ist toll", Seiten = 100 }; 28

30 Die technischen Bausteine von LINQ Dieser Typ besitzt zwei Eigenschaften mit den Namen Text und Seiten, deren Datentypen (System.String und System.Int32) durch die zugewiesenen Werte bestimmt wurden. Sowohl Inhalt als auch Typ der Eigenschaften können wie gewohnt ermittelt werden. // Ausgabe von Typ und Inhalt der Felder Debug.Print("Text: {0} ({1})", unbekannt.text, unbekannt.text.gettype()); Debug.Print("Seiten: {0} ({1})", unbekannt.seiten, unbekannt.seiten.gettype()); Die Ausgabe sieht so aus: Text: LINQ ist toll (System.String) Seiten: 100 (System.Int32) Die Namen der Eigenschaften können entweder festgelegt werden oder bei einer Zuweisung durch eine Eigenschaft/ein Feld eines anderen Objekts automatisch entfallen. In diesem Fall wird der Name der (des) Quelleneigenschaft(-feldes) verwendet. Das folgende Fragment verdeutlicht dies. var buch = new { Titel = "Das Leben im Jetzt", DateTime.Now }; // Ausgabe Debug.WriteLine(buch); { Titel = Das Leben im Jetzt, Now = :52:25 } Ein Ändern der Werte durch eine Zuweisung ist selbstverständlich auch möglich. unbekannt.seiten = 99; Der Wert der Felder muss nicht wie in diesem Beispiel durch eine Konstante initialisiert werden, sondern es können auch Methoden zum Einsatz kommen, die den gewünschten Wert zurückliefern. // Methode zur Ermittlung der Seitenzahl private int ermittleseiten() { // Ermitteln und zurückgeben return 100; } // Zur Initialisierung die Methode verwenden var unbekannt = new { Text = "LINQ ist toll", Seiten = ermittleseiten() } Das Resultat ist das gleiche wie im vorherigen Beispiel. LINQ 29