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 7 Weitere Möglichkeiten von C#
Pfeil 7.1 Namensräume (Namespaces)
Pfeil 7.1.1 Zugriff auf Namespaces
Pfeil 7.1.2 Die »using«-Direktive
Pfeil 7.1.3 Globaler Namespace
Pfeil 7.1.4 Vermeiden von Mehrdeutigkeiten
Pfeil 7.1.5 Namespaces festlegen
Pfeil 7.1.6 Der ::-Operator
Pfeil 7.2 Generics – generische Datentypen
Pfeil 7.2.1 Lösung mit einer generischen Klasse
Pfeil 7.2.2 Typparameter mit Constraints einschränken
Pfeil 7.2.3 Generische Methoden
Pfeil 7.2.4 Generics und Vererbung
Pfeil 7.2.5 Konvertierung von Generics
Pfeil 7.2.6 Generische Delegates
Pfeil 7.2.7 Generische Klassen in der .NET-Klassenbibliothek
Pfeil 7.3 Operatorüberladung
Pfeil 7.3.1 Syntax der Operatorüberladung
Pfeil 7.3.2 Operatorüberladungen in »GeometricObjectsSolution«
Pfeil 7.3.3 »true«- und »false«-Operatoren
Pfeil 7.3.4 Benutzerdefinierte Konvertierungen
Pfeil 7.4 Indexer
Pfeil 7.4.1 Überladen von Indexern
Pfeil 7.4.2 Parameterbehaftete Eigenschaften
Pfeil 7.5 Erweiterungsmethoden
Pfeil 7.6 Implizit typisierte Variablen (Typinferenz)
Pfeil 7.7 Lambda-Ausdrücke
Pfeil 7.8 Anonyme Typen
Pfeil 7.9 Nullable-Typen
Pfeil 7.10 Attribute
Pfeil 7.10.1 Das »Flags«-Attribut
Pfeil 7.10.2 Anmerkungen zu den Attributen
Pfeil 7.10.3 Benutzerdefinierte Attribute
Pfeil 7.10.4 Attribute auswerten
Pfeil 7.10.5 Festlegen der Assembly-Eigenschaften
Pfeil 7.11 Partielle Methoden
Pfeil 7.12 Dynamisches Binden
Pfeil 7.12.1 Eine kurze Analyse
Pfeil 7.12.2 Dynamische Objekte
Pfeil 7.13 Unsicherer (unsafe) Programmcode – Zeigertechnik in C#
Pfeil 7.13.1 Einführung
Pfeil 7.13.2 Das Schlüsselwort »unsafe«
Pfeil 7.13.3 Deklaration von Zeigern
Pfeil 7.13.4 Die »fixed«-Anweisung
Pfeil 7.13.5 Zeigerarithmetik
Pfeil 7.13.6 Der Operator »->«


Galileo Computing - Zum Seitenanfang

7.12 Dynamisches Binden Zur nächsten ÜberschriftZur vorigen Überschrift

Mit allzu vielen Neuerungen wartet C# 4.0 nicht auf. Man hat den Eindruck, dass diese Sprache »rund« ist, den allgemeinen Anforderungen genügt. Das war auch bereits beim Erscheinen von C# 3.0 ähnlich, obwohl in der Vorgängerversion mit LINQ eine neue Technologie eingeführt worden ist, die manche Spracherweiterung mit sich brachte, die eine Ergänzung der .NET-Sprachen erforderlich machte. Im Nachhinein betrachtet, möchte man auf die Erweiterungsmethoden nicht mehr verzichten, sie sind in meinen Augen sogar ein richtiges Highlight, ganz nach dem Motto: »Wenn man sie nicht kennt, braucht man sie nicht. Kennt man sie, möchte man sie nicht mehr missen.«

Mit der neuen Version 4.0 des .NET Frameworks versucht Microsoft nun eine Lücke zu anderen Technologien zu schließen. Bislang war der Zugriff auf dynamische Bibliotheken wie COM APIs nicht ganz einfach. Diese Lücke wird mit der Version 4.0 geschlossen. Die Programmierung beispielsweise von MS Office wird deutlich vereinfacht. Die schon in Kapitel 3, »Das Klassendesign«, behandelten optionalen Parameter gehören zu den Neuerungen, die im Zuge dessen in C# 4.0 Einzug gehalten haben.

Eine weitere wichtige Neuerung von C# 4.0 möchte ich Ihnen in diesem Kapitel zeigen. Es ist die Fähigkeit, nun auch das sogenannte späte Binden zu realisieren. Was ist darunter zu verstehen? Schauen wir uns dazu einmal das folgende Beispiel an:


class Program {
  static void Main(string[] args) {
    Mathematics math = new Mathematics();
    long result = math.Addition(56, 88);
  }
}
class Mathematics {
  public long Addition(int x, int y) {
    return x + y;
  }
}

Die Klasse Mathematics wird instanziiert – ein statischer Vorgang, der bereits zur Kompilierzeit durchgeführt wird.

Mithilfe der Reflection ließ sich ein solcher Aufruf auch früher schon dynamisch formulieren, wie das folgende Codefragment zeigt, das die Bekanntgabe des Namespace System.Reflection voraussetzt:


object math = new Mathematics();
Type mathType = math.GetType();
object obj = mathType.InvokeMember("Addition",
                                    BindingFlags.InvokeMethod,
                                    null, 
                                    math, 
                                    new object[] { 56, 88 });
long result = (long)obj;

Das Resultat des Konstruktoraufrufs von Mathematics wird einer Variablen vom Typ Object zugewiesen. Darauf besorgt man sich den Type des Objekts und ruft darauf die Methode InvokeMember auf. Unter Übergabe des Methodenbezeichners, des Elementtyps, der Referenz des abzurufenden Objekts und der Argumente für den Methodenaufruf wird ein Resultat gebildet, das am Ende nur noch in den Ergebnistyp long konvertiert werden muss.

In C# 4.0 können Sie dieses Coding unter Zuhilfenahme des neuen Schlüsselworts dynamic auch deutlich kürzer ausdrücken:


dynamic obj = new Mathematics();
long result = obj.Addition(56, 88);

Das dynamic-Schlüsselwort wird zur Kompilierzeit statisch geprüft. Die Methode Addition hingegen ist dynamisch und wird nicht zur Kompilierzeit geprüft. Natürlich werden Sie auch keine IntelliSense-Hilfe nach dem Punktoperator nutzen können, Sie müssen die Methode Addition manuell angeben.

Bei obj handelt es sich um ein dynamisches Objekt. Der Aufruf der Methode selbst ist dynamisch und wird erst zur Laufzeit geprüft.


Galileo Computing - Zum Seitenanfang

7.12.1 Eine kurze Analyse Zur nächsten ÜberschriftZur vorigen Überschrift

Lassen Sie uns an dieser Stelle die Objektvariablen betrachten und diese direkt miteinander vergleichen. Sie kennen mit dem in diesem Abschnitt beschriebenen Schlüsselwort dynamic inzwischen drei Varianten:

  • Object myObject = new Mathematics();
  • var myObject = new { ... };
  • dynamic myObject = new Mathematics();

Die zuerst aufgeführte Instanziierung deklariert eine Variable vom Typ Mathematics. Die Variable ist vom Typ System.Object. Der Code ist streng typisiert. Sie können der Variablen jedes Objekt zuweisen, vorausgesetzt, es ist vom Typ System.Object und bekannt.

Flexibler ist bereits der zweite Ausdruck. Auch hier liegt eine strenge Typisierung vor, aber der Typ muss erst zur Laufzeit gebildet werden. Typischerweise handelt es sich dabei um anonyme Typen, die zur Kompilierzeit gebildet werden.

Auch die letzte Variante mit dynamic wird sehr wohl statisch geprüft, aber der Aufruf auf der dynamic-Variablen erfolgt dynamisch. Zur Kompilierzeit steht noch nicht fest, welche Operationen mit dem Typ ausgeführt werden. Daher ist auch keine IntelliSense-Hilfe sichtbar.


Galileo Computing - Zum Seitenanfang

7.12.2 Dynamische Objekte topZur vorigen Überschrift

Mit der Einführung des Schlüssselworts dynamic wurden auch einige Klassen zum .NET Framework hinzugefügt, die auf dynamic aufsetzen. Diese Klassen befinden sich im Namespace System.Dynamic. Am interessantesten scheint hier die Klasse DynamicObject zu sein, mit der Klassen zur Laufzeit dynamisch erweitert werden können. Sie müssen die Klasse ableiten und können die abgeleitete Klasse zur Laufzeit um Objekteigenschaften erweitern und diese abrufen. Sehen wir uns das im folgenden Beispielprogramm an.


// ------------------------------------------
// Beispiel: ...\Kapitel 7\DynamicObjects
// -------------------------------------------
using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Reflection;
class Program {
  static void Main(string[] args) {
    dynamic pers = new Person();
    pers.Name = "Peter";
    pers.Alter = 12;
    pers.Ort = "Bonn";
    pers.Telefon = 0181812345;
    Console.WriteLine("{0}, {1}, {2}, {3}", 
                      pers.Name, pers.Alter, pers.Ort, pers.Telefon);
    Console.ReadLine();
  }
}
class Person : DynamicObject {
  Dictionary<string, Object> dic = new Dictionary<string, object>();
  public string Name { get; set; }
  public int Alter { get; set; }
  public override bool TryGetMember(GetMemberBinder binder, 
                                    out object result) {
    return dic.TryGetValue(binder.Name, out result);
  }
  public override bool TrySetMember(SetMemberBinder binder, object value) {
    dic[binder.Name] = value;
    return true;
  }
}

Es ist die Klasse Person definiert, die die Klasse DynamicObject ableitet. Mit Name und Alter sind zwei Eigenschaften konkret festgelegt. Darüber hinaus enthält die Klasse Person ein Feld vom Typ der generischen Klasse Dictionary<>. Hierbei handelt es sich um eine Array-ähnliche Liste, in der alle Daten mit einem Schlüssel-Werte-Paar beschrieben werden. Um den Programmcode zu verstehen, ist eine genauere Kenntnis der Klasse Dictionary<> nicht notwendig; wir werden im nächsten Kapitel noch genauer darauf eingehen.

Das Dictionary<>-Objekt speichert Eigenschaften, die zur Laufzeit bestimmt werden können. In Main sind das zum Beispiel die beiden Eigenschaften Ort und Telefon eines Person-Objekts, das zuvor mit dynamic erstellt wird – eine Voraussetzung für alle Typen, die von DynamicObject abgeleitet sind.

Damit die dynamischen Eigenschaften sich auch in das Objekt eintragen können, sind die beiden geerbten Methoden TrySetMember und TryGetMember überschrieben. Beide weisen mit GetMemberBinder und SetMemberBinder sehr ähnliche erste Parameter auf, die das dynamische Member repräsentieren. Der Bezeichner der dynamischen Eigenschaft ist in der Eigenschaft Name der beiden Binding-Objekte zu finden.

Interessant werden dürfte die Klasse DynamicObject vermutlich in Zukunft im Zusammenhang mit Daten, deren Strukturen nicht vorhersehbar sind oder sich von Fall zu Fall ändern. An diesem Zusammenhang sei auf die Tabellen einer Datenbank erinnert. Wie einfach ließen sich die Felder durch dynamische Member eines DynamicObject-Objekts beschreiben?



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.


[Rheinwerk Computing]

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