Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort zur 5. Auflage
1 Allgemeine Einführung in .NET
2 Grundlagen der Sprache C#
3 Klassendesign
4 Vererbung, Polymorphie und Interfaces
5 Delegates und Ereignisse
6 Weitere .NET-Datentypen
7 Weitere Möglichkeiten von C#
8 Auflistungsklassen (Collections)
9 Fehlerbehandlung und Debugging
10 LINQ to Objects
11 Multithreading und die Task Parallel Library (TPL)
12 Arbeiten mit Dateien und Streams
13 Binäre Serialisierung
14 Einige wichtige .NET-Klassen
15 Projektmanagement und Visual Studio 2010
16 XML
17 WPF – Die Grundlagen
18 WPF-Containerelemente
19 WPF-Steuerelemente
20 Konzepte der WPF
21 Datenbindung
22 2D-Grafik
23 ADO.NET – verbindungsorientierte Objekte
24 ADO.NET – Das Command-Objekt
25 ADO.NET – Der SqlDataAdapter
26 ADO.NET – Daten im lokalen Speicher
27 ADO.NET – Aktualisieren der Datenbank
28 Stark typisierte DataSets
29 LINQ to SQL
30 Weitergabe von Anwendungen
Stichwort

Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Visual C# 2010 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual C# 2010

Visual C# 2010
geb., mit DVD
1295 S., 49,90 Euro
Rheinwerk Computing
ISBN 978-3-8362-1552-7
Pfeil 8 Auflistungsklassen (Collections)
Pfeil 8.1 Die Listen des Namespace »System.Collections«
Pfeil 8.1.1 Die elementaren Schnittstellen der Auflistungsklassen
Pfeil 8.2 Die Klasse »ArrayList«
Pfeil 8.2.1 Einträge hinzufügen
Pfeil 8.2.2 Datenaustausch zwischen einem Array und einer ArrayList
Pfeil 8.2.3 Die Elemente einer ArrayList sortieren
Pfeil 8.2.4 Sortieren von Arrays mit »ArrayList.Adapter«
Pfeil 8.3 Die Klasse »Hashtable«
Pfeil 8.3.1 Methoden und Eigenschaften der Schnittstelle »IDictionary«
Pfeil 8.3.2 Beispielprogramm zur Klasse »Hashtable«
Pfeil 8.4 Die Klassen »Queue« und »Stack«
Pfeil 8.4.1 Die »Stack«-Klasse
Pfeil 8.5 Objektauflistungen im Überblick
Pfeil 8.6 Generische Auflistungsklassen
Pfeil 8.6.1 Die Interfaces der generischen Auflistungsklassen
Pfeil 8.6.2 Die generische Auflistungsklasse »List<T>«
Pfeil 8.7 Eigene Auflistungen mit »yield« durchlaufen


Galileo Computing - Zum Seitenanfang

8.7 Eigene Auflistungen mit »yield« durchlaufen topZur vorigen Überschrift

Nehmen wir an, wir hätten eine Klassendefinition wie folgt:


public class Months {
  string[] months = { "Januar", "Februar", "März", "April", 
                      "Mai", "Juni", "Juli", "August", 
                      "September", "Oktober", "November", "Dezember"};
}

Wäre es nicht schön, mit einer foreach-Schleife den Datenspeicher des Objekts months zu durchlaufen und Zugriff auf alle Elemente zu erhalten, etwa wie folgt:


Months monate = new Months();
foreach(string temp in monate) {
  Console.WriteLine(temp);
}

Dass daran Bedingungen geknüpft sind, wurde in Abschnitt 8.1.1, »Die elementaren Schnittstellen der Auflistungsklassen«, schon erwähnt. Die Klasse Months muss dazu die Schnittstelle IEnumerable implementieren.


public class Months : IEnumerable

Die einzige in IEnumerable definierte Methode GetEnumerator liefert ein Objekt, das wiederum die Schnittstelle IEnumerator unterstützt.


IEnumerator GetEnumerator();

Das IEnumerator-Objekt muss die Methoden MoveNext und Reset sowie die Eigenschaft Current implementieren. Damit wird das Durchlaufen der Klasse mit foreach möglich.

Die Beschreibung macht deutlich, dass einiges an Tippaufwand für die Codierung erforderlich ist. Durch den Einsatz des Schlüsselwortes yield geht es aber auch einfacher. Sie müssen zwar immer noch die Schnittstelle IEnumerable oder deren generisches Pendant und damit auch die Methode GetEnumerator implementieren, benötigen aber keinen IEnumerator-Typ mehr. Stattdessen liefern Sie die Daten nur noch mit dem neuen Schlüsselwort yield, gefolgt von return, aus.


// --------------------------------------------------------------
// Beispiel: ...\Kapitel 8\YieldSample
// --------------------------------------------------------------
class Program {
  static void Main(string[] args) {
    Months months = new Months();
    foreach(string temp in months)
      Console.WriteLine(temp);
    Console.ReadLine();
  }
}
public class Months : IEnumerable {
  string[] month = { "Januar", "Februar", "März", "April", 
              "Mai", "Juni", "Juli", "August", "September", 
              "Oktober", "November", "Dezember"};
  // Methode der Schnittstelle 'IEnumerable'
  public IEnumerator GetEnumerator() {
    for (int i = 0; i < month.Length; i++)
      yield return month[i];
  }
}

yield in Kombination mit return wird zur Angabe des zurückgegebenen Wertes verwendet. Bei Erreichen von yield return wird die aktuelle Position gespeichert, und beim nächsten Aufruf der Schleife wird die Ausführung von dieser Position neu gestartet. Mehr haben Sie nicht zu tun, denn im Hintergrund generiert der Compiler automatisch die Methoden Current und MoveNext der IEnumerator-Schnittstelle, wenn er yield erkennt.

Sie können das Programm sogar noch einfacher schreiben und auf die Implementierung von IEnumerable verzichten. Überlassen Sie einfach alles dem Compiler und yield return. Dazu schreiben Sie ebenfalls eine Methode, deren spezielle Aufgabe es ist, die Objektmenge zurückzuliefern. Die Methode dürfen Sie beliebig nennen. Der Rückgabewert ist ein Objekt, das die Schnittstelle IEnumerable implementiert – und somit auch implizit die Methode GetEnumerator. Hinter den Kulissen wird der Compiler dafür sorgen, dass der Iterator der anfragenden foreach-Schleife alle Daten der Reihe nach übergibt.

Das folgende Coding zeigt, wie einfach jetzt der Code ist. Beachten Sie bitte auch, dass in der foreach-Schleife nun die Methode GetList für die Bereitstellung der Objekte sorgt. In diesem Code wird die generische Schnittstelle IEnumerable<T> angegeben. Sie können natürlich auch die untypisierte benutzen, was in diesem Fall gleichwertig ist.


class Program {
  static void Main(string[] args) {
    Months months = new Months();
    foreach(string temp in months.GetList())
      Console.WriteLine(temp);
    Console.ReadLine();
  }
}
public class Months {
  string[] month = { "Januar", "Februar", "März", "April", 
                     "Mai", "Juni", "Juli", "August", "September", 
                     "Oktober", "November", "Dezember"};
  public IEnumerable<string> GetList() {
    for (int i = 0; i < month.Length; i++)
      yield return month[i];
  }
}

Weitere Möglichkeiten

yield return ist für den Compiler der Anstoß, automatisch einen Iterator zu erzeugen, der von einer foreach-Schleife genutzt werden kann. Sie können auch mehrfach hintereinander yield aufrufen, wie das folgende Codefragment zeigt:


// Methode der Schnittstelle 'IEnumerable'
public IEnumerator GetEnumerator() {
  yield return "Januar";
  yield return "Februar";
  yield return "März";
}

Zum Abbruch einer Iteration kombinieren Sie yield mit break:


yield break;

Einschränkungen von »yield return«

Der Einsatz von yield return unterliegt zwei Einschränkungen:

  • yield return kann nicht innerhalb einer anonymen Methode codiert werden.
  • yield return darf weder in einem catch-Block noch in einem try-Block verwendet werden, wenn Letzterer eine catch-Klausel hat. Die Verwendung in einem try-Block, dem sich nur noch ein finally-Block anschließt, ist jedoch möglich.

In Kapitel 9, »Fehlerbehandlung und Debugging«, werden Sie alles über die Behandlung von Ausnahmen (Exceptions) mit try-catch erfahren.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück
  Zum Katalog
Zum Katalog: Visual C# 2010

Visual C# 2010
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Professionell entwickeln mit Visual C# 2012






 Professionell
 entwickeln mit
 Visual C# 2012


Zum Katalog: Windows Presentation Foundation






 Windows Presentation
 Foundation


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++ Handbuch






 C++ Handbuch


Zum Katalog: C/C++






 C/C++


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2010
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


Nutzungsbestimmungen | Datenschutz | Impressum

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de

Cookie-Einstellungen ändern