Lexikon zu Modul 1
(Microsoft Exam 70-316)

.NET Framework

Eine Umgebung für die Entwicklung und Ausführung von Anwendungen. Es verwaltet alle Aspekte der Programmausführung.

• Speicherreservation/Speicherfreigabe
• Erteilen/Verweigern passender Berechtigungen

Es besteht im Wesentlichen aus zwei Teilen: der Common Language Runtime (CLR) und der .NET Framework Class Library.

Das .NET Framework gewährleistet eine programmiersprachenübergreifende Kompatibilität, so dass Komponenten aus verschiedenen Sprachen zusammenarbeiten können. Zu dieser Interoperabilität gehört auch die Vererbung. Dies wird möglich, da beim Kompilieren der Quellcode in die Intermediate Language (IL) übersetzt wird. Alle .NET exe- und dll-Dateien enthalten IL Code, wodurch beliebige Kooperation ermöglicht wird.

.NET Framework Configuration Tool

Starten: Systemsteuerung > Verwaltung > Microsoft .NET Framework 1.1 Configuration.

Ermöglicht folgende Arbeiten:

• Inhalt des GAC verwalten
• Verwaltung von remoting channels welche Kommunikation mit Objekten auf anderen Computern ermöglicht
• Konfigurieren der Security Policy
• Eigenschaften (settings) von Applikationen verwalten

Abstrakte Klassen und Member

Abstrakte Klassen sind eine Mischung aus Klasse und Interface. Es handelt sich um Klassen bei welchen mindestens ein Member abstrakt (= nicht implementiert und mit abstract deklariert) ist und die abgeleitet werden müssen, da sie nicht selbst instanziierbar sind. Es ist aber möglich, Variablen dieses Typs zu erzeugen. Die ableitende Klasse muss Implementationen für alle abstrakten Member liefern, es sei denn sie ist selbst abstrakt. Abstrakte Klassen können auch implementierte Member haben, die von der Kindklasse so geerbt werden oder überschrieben werden können. Abstrakte Klassen und Member werden mit dem Schlüsselwort abstract definiert.

Implementieren abstrakte Klassen Interfaces, müssen sie nicht Implementationen für die Member des Interfaces liefern. Die Member des Interfaces müssen aber (mit abstract) deklariert werden.

Access und ADO.NET

Accessibility

Unter Accessibility versteht man behindertengerechter Entwurf von Software.

Zu den entsprechenden Prinzipien gehören:

• Flexibilität
• Auswahl zwischen mehreren Eingabemethoden
• Auswahl zwischen mehreren Ausgabemethoden
• Konsistenz
• Kompatitilität zu Eingabehilfen

Anforderungen an eine behindertengerechte Applikation:

Standardeinstellungen des System müssen unterstützt werden
Die Einstellungen des Systems für Grösse, Farbe, Schrift und Eingabe sollten übernommen werden. Dies kann mit Klassen aus dem Namespace System implementiert werden. Legt man eine Schritftgrösse fest, muss diese mindestens 10 sein.

...

Eigenschften von Windows Forms-Steuerelementen vereinfachten Zugriff:

ADO.NET

Eine verbesserte und erweiterte Version der ActiveX Data Objects (ADO). Die Klassen von ADO.NET befinden sich im Namespace System.Data. In ADO.NET gibt es keine Redordsets mehr, statt dessen DataAdapter und DataSets, welche auch verbindungslosen Zugriff und Datenoperationen ermöglichen. Der Hauptgrund für verbindungslosen Zugriff ist das Internet. Bei Web-Anwendungen ist eine permanente Verbindung nicht möglich. Verbindungsloser Zugriff hat die Vorteile, dass ressourcensparender gearbeitet werden kann und die Anwendungen besser skalierbar sind.

AppDomain (Klasse)

Namespace: System. Stellt eine Anwendungsdomäne dar.

Application (Klasse)

Namespace: System.Windows.Forms. Ist für das Managen einer Windows-Applikation zuständig. Alle Member sind statisch.

AppSettingsReader (System.Configuration)

Wird benutzt um Einstellungen aus der Konfigurationsdatei zu lesen.

Beispiel für eine .config-Datei

<?xml version="1.0" encoding="utf-8"?>

  <configuration>

	  <appSettings>

		  <add key="HelpPath" value="C:\TrainerHLP\Trainer.chm" />

    </appSettings>

  </configuration>

Die .config-Datei muss im gleichen Verzeichnis wie die .exe-Datei liegen und den selben Namen wie diese zuzüglich ".config" haben.

Arrays

Ein Array ist eine Serie von Variablen gleichen Typs auf welche mit einem Index zugegriffen werden kann.

Definition:

int[] meineInts;

meineInts = new int[4];

Hiermit wird ein Array mit 4 Elementen mit den Indizes 0 - 3 erzeugt. Deklaration und Initialisierung sind auch in einer Linie möglich: int[] meineInts = new int[4];

Die Arraygrösse kann zur Laufzeit durch Neuinitialisierung verändert werden, dabei gehen aber alle Daten verloren:

int[] meineInts = new int[32];

meineInts = new int[38];

Erzeugt und initialisiert man einen Array von Verweistypen, wird der Array nicht automatisch mit Instanzen dieses Typs gefüllt, er enthält lediglich null-Referenzen.

Mehrdimensionale Arrays:

int[ , ] meineInts = new int[4, 8];

Jagged Arrays:

Ein jagged Array ist ein Array von Arrays, welche nicht alle die selbe Länge haben müssen.

Definition:

string[][] Schüler = new string[3][];

Schüler[0] = new string[] {"Stefan", "Erika", "Thomas", "Lukas"};

Schüler[1] = new string[] {"Philip", "Maria", "Sebastian"};

Schüler[2] = new string[] {"Karin", "Sandra"};

ArrayList (System.Collections)

Eine Collection-Klasse die allgemeine Auflistungsfunktionalität bietet. Elemente werden mit der Methode Add() hinzugefügt, welche einen Parameter vom Typ object entgegennimmt. Auf die Elemente einer ArrayList kann dank Indexern mit der Array-Syntax zugegriffen werden.

Beispiel:

ArrayList myList = new ArrayList();

Ding ding1 = new Ding();

Ding ding2 = new Ding();

myList.Add(ding1);

myList.Add(ding2);

object obj = myList[1]; // obj wird ding2 zugewiesen

Mit den Methoden Remove() und RemoveAt() können Elemente wieder aus der Auflistung entfernt werden. Remove() benötigt als Parameter einen Verweis auf das zu entfernende Objekt, RemoveAt() den entsprechenden Index. Beim Entfernen von Elementen werden die Indizes der dahinter liegenden Objekte um 1 reduziert, damit die Indizes weiterhin fortlaufend sind. Versucht man ein nicht existierendes Objekt zu entfernen erzeugt dies keinen Fehler.

Die Eigenschaft Count gibt immer die Anzahl Objekte zurück.

as (Operator)

Wird verwendet, um Typkonvertierungen durchzuführen. Im Gegensatz zu expliziten Casts mit "(<neuer_Typ>)" löst as niemals eine Ausnahme aus. Ist keine Konvertierung möglich, ist die zurückgegebene Referenz vom Wert null. Man bezeichnet dies auch als Save-Cast.

Beispiel:

KlasseB b = new KlasseB();

KlasseA a = b as KlasseA; // Löst sicher keine Ausnahme aus

Assembly

Die Grundheinheit einer .NET Anwendung. Es handelt sich um eine sich selbst beschreibende Sammlung von Ressourcen und Metadaten.

Assemblies bestehen aus:

• Assemblymanifest
• Metadaten über die Typen
• IL-Code
• Ressourcendateien

Jede Assembly hat genau ein Manifest, welches folgende Informationen (Metadaten) über den Inhalt der Assembly zur Verfügung stellt. Diese Informationen werden von der CLR gelesen.

• Informationen zur Identität (Name, Versionsnummer, Hersteller usw.)
• Liste aller öffentlichen Typen
• Liste der Dateien
• Liste aller anderen Assemblys die erforderlich sind
• Liste aller Berechtigungen, welche die Assembly benötigt

Sowohl die Assembly als auch das Manifest enthalten Metadaten. Das Assemblymanifest kann in einer separaten Datei oder in einem Modul enthalten sein. Assemblys enthalten ein oder mehrere Module welche den Code und Metadaten enthalten. Weiter enthalten Assemblies IL-Code und Ressourcendateien. Vereinfacht gesagt ist eine Assembly ein Projekt welches in eine .exe oder .dll-Datei kompiliert wird.

Das Assemblymanifest wird automatisch kompiliert und der CLR zugänglich gemacht. Die Metadaten welche die Identität beschreiben müssen aber vom Entwickler explizit festgelegt werden.

Assemblies ermöglichen Wiederverwendung, Versionskontrolle, Sicherheit und Codeweitergabe.

Private Assemblies

Werden standardmässig benutzt und machen dem Entwickler am wenigsten Ärger. Sie können nur von einer einzigen Anwendung verwendet werden. Fügt man einem Projekt einen Verweis auf eine private Assembly hinzu, wird eine Kopie davon erstellt und im Anwendungsordner gespeichert.

Freigegebene Assemblies

Existieren auf dem Computer nur einmal, mehrere Anwendung können sie benutzen. Eine Assembly wird freigegeben, indem man sie im GAC (Global Assembly Cache) installiert. Freigegebene Assemblies müssen über einen starken Namen verfügen.

Ressourcenassemblies

Ressourcen sind Daten die in eine Anwendung eingebettet, aber nicht ausführbar sind. Ressourcenassemblies sind Assemblies welche nur Ressourcen enthalten, dies ermöglicht, Ressourcen umzustellen ohne die Anwendung neu kompilieren zu müssen.

Eine Ressourcenassembly erstellt man indem man ein neues Projekt mit der Vorlage "Klassenbibliothek" erstellt. Diesem fügt man lediglich Ressourcendateien hinzu (die Xxxx.cs-Datei kann man löschen).

Satellitenassemblies

Ermöglichen, dass von mehreren Ressourcendateien automatisch die zur CurrentUICulture passende geladen wird. Dafür müssen die Ressourcendateien über einen entsprechenden Namen verfügen (sie in seperate Assemblies zu kompilieren ist nicht notwendig:

Bsp. für deutschsprachige Benutzeroberflächen: MyResource.de.resx
Bsp. für luxemburgisches Deutsch: MyResource.de-LU.resx

Beim Laden der Ressourcen mit der Klasse ResourceManager muss man als zweites Argument die aktuelle CultureInfo übergeben.

Bsp, falls Ressourcenfiles in der gleichen Assembly:
ResourceManager resMan;
resMan = new ResourceManager("<namespace>.<Ressourcenname>", this.GetType().Assembly);
string resString = resMan.GetString("<Stringname>", System.Threading.Thread.CurrentThread.CurrentCulture);

AssemblyInfo.cs

In dieser Datei liegt (zum Entwicklungszeitpunkt) die Identität der Assembly. Sie enthält für diverse Identitätsattribute den Standardwert null.

Attribut

Eine Möglichkeit für Programmierer, neue Arten deklarativier Informationen zu erfinden. Attribute können verschiedenen Programmeinheiten zugeordnet werden und die Informationen sind zur Laufzeit abrufbar.

Attribute werden durch die Deklaration von Attributsklassen definiert. Sie sind von der abstrakten Klasse System.Attribute abgeleitet und stellen positionale Parameter und benannte Parameter zur Verfügung. Der Konvention folgend besitzen Attributsklassen das Suffix Attribute. Bei ihrer Verwendung kann dieses jedoch weggelassen werden.

Positionale Parameter

Jeder öffentliche Instanzenkonstruktor einer Attributsklasse definiert eine gültige Folge von positionalen Parametern für das Attribut.

Benannte Parameter

Jedes öffentliche nicht-statische Feld und jede Eigenschaft mit Schreib- und Leseberechtigung definiert einen benannten Parameter.

Aufgabenliste

Ein Doppelklick auf einen Fehler in der Aufgabenliste führt dazu, dass der betreffende Code hervorgehoben wird. Benötigt man weitere Informationen, kann man mit der Taste F1 zum hervorgehobenen Element Hilfe anfordern. Siehe auch TODO:

Auflistungen

Auflistungen (Collections) bieten Funktionalität zur Verwaltung einer Gruppe von Objekten. Wie bei Arrays können die Member mit einem Index angesprochen werden, im Gegensatz zu Arrays ist es möglich, die Grösse ohne Datenverlust dynamisch zu ändern.

Einige Collections aus dem Namensraum System.Collection:

Auflistungen geben den Typ object zurück, was meist eine explizite Konvertierung notwendig macht. Die Indizes beginnen immer mit 0 und sind fortlaufend.

Um alle Objekte einer Auflistung oder eines Arrays zu durchlaufen verwendet man am besten die foreach-Anweisung, sie ist aber viel langsamer als eine for-Schleife.

Ausnahme

Ausnahmen sind Instanzen von Klassen die von System.Exception abgeleitetet wurden. Sie werden ausgelöst wenn ein Laufzeitfehler auftritt und verfügen über Funktionalität zur Diagnose und Behandlung von Fehlern. Sie ermöglichen es, dass sich verschiedene Anwendungsteile über Fehlerzustände benachrichtigen können. Benutzerdefinierte Ausnahmen können durch das Ableiten von System.ApplicationException erstellt werden. ApplicationException kapselt die für Ausnahmen notwendige Funktionalität, z.B. die Eigenschaften Message, StackTrace und InnerException.

Beim Ableiten von ApplicationException sollten drei Konstruktoren geschrieben werden. Eine ohne Parameter, eine mit string Message und eine mit string Message, Exception InnerException.

Beim Auftreten eines Laufzeitfehlers erzeugt das Programm eine Instanz der passenden Exception und übergibt sie in der Aufrufliste nach oben bis eine Struktur zur Ausnahmebehandlung (Exception Handling) gefunden wird. Ist kein Fehlerbehandlungsmechanismus vorhanden, wird der Standardfehlerbehandler aufgerufen, welcher in einem Meldungsfeld den Ausnahmetyp sowie weitere Informationen anzeigt. Die Anwendung wird beendet ohne dass der Benutzer Gelegenheit zum Speichern zu geben und ohne den Versuch, sich vom Fehler zu "erholen".

Es ist möglich, sämtliche Ausnahmen abzufangen, auch solche die durch COM-Code oder sogar nicht COM-Code geworfen werden.

Ausnahmehandler

Methoden die Ausnahmen auslösen könnten, sollten einen geeigneten Ausnahmehandler haben. Die Syntax zur Ausnahmebehandlung gliedert sich in einen try-, einen oder mehrere catch- und ev. einen finally-Block.

try-Block
Enthält den Code, welcher eine Exception auslösen könnte.

catch-Blöcke
Enthalten den Code zur Behandlung der Ausnahme. Sie können generisch sein und alle Exceptions auffangen oder spezifisch nur die Ausnahme einer bestimmten Exception-Klasse. Verwendet man mehrere catch-Blöcke müssen diese vom Spezifisten zum Allgemeinsten geordnet sein.
Bei generischen catch-Blöcken fehlen die runden Klammern mit der Deklaration einer Ausnahme. Sie fangen alle Ausnahmen ab.
Stellt ein catch-Block fest, dass er eine Ausnahme nicht, oder nur teilweise behandeln kann, kann er sie mit throw <expeption>; oder throw; erneut auslösen (throw in einem catch-Block wirft immer die "gecatchte" Exception). Beim erneuten Auslösen resp. Weiterreichen kann man die Ausnahme auch in eine neue einhüllen, welche eine weitere oder detailliertere Problembeschreibung enthält. Die Eigenschaft InnerException wird im Konstruktor der neuen Ausnahme als zweiter Parameter zugewiesen.

finally-Block
Enthält Code, der in jedem Fall ausgeführt werden muss, egal ob ein Ausnahme geworfen wurde oder nicht, resp. sie von einem catch-Block aufgefangen wurde oder nicht.

Will man eine Ausnahme nicht behandeln, sonder sie an den Aufrufer weiterreichen, schreibt man trotzdem einen try und einen finally-Block, lässt aber die catch-Blöcke weg.

AxtiveX - Steuerelemente

Sollten nur verwendet werden, wenn es nicht anders geht, da sie zu hohen Performance-Einbussen führen.

base

Durch das Voranstellen von "base." kann man in einer abgeleiteten Klasse Member der Vaterklasse ansprechen.

Bedingte Kompilierung

An erster Stelle im Code kann man mit #define <symbol> bestimmte Symbole setzen.

Code welcher zwischen #if <symbol> und #endif steht, wird nur kompiliert falls dieses Symbol gesetzt ist.

Kompiliert man im DEBUG-Modus, sind die Symbole DEBUG und TRACE automatisch gesetzt, im RELEASE-Modus lediglich TRACE.

Mit #undef <symbol> kann man ein Symbol ausschalten. Setzt man die Direktive #undef DEBUG in den Code und kompiliert im DEBUG-Modus, wird das Projekt wie im RELEASE-Modus kompiliert.

Startet man den C#-Kompiler von der Kommandozeile, kann man mit der Option /define (/d als Abk.) Symbole setzen.

Mit dem Conditional-Attribut kann man ganze Methoden bedingt kompilieren.

Beispiel:

[Conditional("DEBUG")]
private void bedingteMethode() {...}

Benutzersteuerelement

Mehrere vorhandene Steuerelemente werden in einem Container zusammengefügt und dieser verhält sich wie ein einzelnes Steuerelement. Benutzersteuerelemente werden von System.Windows.Forms.UserControl abgeleitet können zur Toolbox hinzugefügt werden.

Um ein neues Benutzersteuerelement zu erzeugen geht man zum Menu Datei|Neues Element hinzufügen... und wahlt im Dialog "Benutzersteuerelement".

Bezeichner [engl. identifier]

Bei der Verwendung von Code aus anderen Programmiersprachen kann es vorkommen, dass Bezeichner vorkommen welche C# Schlüsselwörtern entsprechen. Diesen Bezeichnern stellt man im C#-Code ein @ voran.

Binding (Klasse)

Namespace: System.Windows.Forms.
Oberklasse: System.Object.

Repräsentiert die einfache Datenbindung zwischen einer Eigenschaft eines Objekts und einer Eigenschaft eines Steuerelements.

Die beiden Ereignisse Format und Parse übergeben ein Argument vom Typ System.Windows.Forms.ConvertEventArgs. Es verfügt unter anderem über die Member DesiredType und Value.

Das Format -Ereignis und das Parse -Ereignis ermöglichen das Erstellen benutzerdefinierter Formate für die Anzeige von Daten. Wenn die Daten in einer Tabelle z. B. vom Typ Decimal sind, können Sie diese im lokalen Währungsformat anzeigen lassen, indem Sie die Value -Eigenschaft des ConvertEventArgs -Objekts im Format -Ereignis auf den formatierten Wert festlegen. Sie müssen die Formatierung des angezeigten Wertes folglich im Parse -Ereignis aufheben.

BindingManagerBase (abstrakte Klasse)

Namespace: System.Windows.Forms
Oberklasse: object
Unterklassen: CurrencyManager, PropertyManager

Wird von Form.BindingContext[] zurückgegeben.

Bitmap (Klasse)

Namespace: System.Drawing. Ist von der abstrakten Klasse Image abgeleitet. Dem Konstruktor kann ein Filename übergeben werden. Mögliche Dateiformate sind u.a. .jpg, .png, .bmp, .gif, .tif. Ein Bitmap kann z.B. mit Graphics.DrawImage ausgegeben werden.

Boxing

Die implizite Konvertierung eines Werttyps in einen Verweistyp. Wird beispielsweise eine der Methoden Equals, GetHashCode, GetType oder ToString aufgerufen wird, erzeugt die Laufzeitumgebung automatisch eine temporäre Referenz um den Wert als Verweistyp behandeln zu können. Von Unboxing spricht man, wenn die geboxte Variable wieder in den ursprünglichen Typ zurückverwandelt wird. Dies muss explizit erfolgen.

CancelEventArgs (Klasse)

System.ComponentModel.CancelEventArgs. Eine Instanz dieser Klasse wird z.B. dem Event Form.Closing übergeben. Setzt man Cancel auf true, kann man das Schliessen des Formulars verhindern.

Char (Struktur)

Namespace: System.

Ein char-Literal wird in einfache Hochkommata eingeschlossen.
Beispiel:
char myChar = 'ü';

Ein Unicode-Zeichen kann mit einer vierstelligen Hexadezimalziffer mit vorangestelltem \u zugewiesen werden.
Beispiel:
char myChar = '\u01fc';

CAS

Code Access Security (Codezugriffssicherheit). Verwaltet die Sicherheit von .NET Quellcode. Ein Subsystem der CLR welches die Zugangskontrolle für geschützte Ressourcen verwaltet.

Funktionen der CAS im .NET-Framework:

• Berechtigungen / Berechtigungssätze für bestimmte Systemressourcen definieren.
• Administratoren die Konfiguration von Sicherheitsrichtlinien ermöglichen.
• Ermöglicht Code, die erforderlichen Berechtigungen anzufordern.
• Legt Berechtigungen fest, die bestimmtem Code nicht erteilt werden dürfen.

weiteres: Lektion 12 Folie 30

Siehe auch Role-based security (Rollenbasierte Autorisierung/Sicherheit).

Code Access Security kontrolliert, was Code auf einem Computer tun kann. CAS involviert Permissions um Ressourcen zu nützen.

caspol.exe

Code Access Security POLicy Tool. Ermöglicht, die Sicherheitsrichtlinien auf den Ebenen Organisation, Computer und Benutzer zu ändern.

CheckBox (Klasse)

checked / unchecked (Schlüsselwort)

checked und unchecked dienen zur Steuerung des Überlaufüberprüfungskontexts und können als Anweisung oder als Operator verwendet werden. Bei der Verwendung als Operator steht checked resp. unchecked vor einem Ausdruck in runden Klammern, z.B: checked (x = a * 100);. Bei der Verwendung als Anweisung steht checked resp. unchecked vor einem Block.

Folgende Operatoren werden durch den Überlaufüberprüfungskontext beeinflusst:

• ++ und --
• der unäre Operator -
• +, -, * und /
• explizite numerische Konvertierungen

Führt im checked-Kontext eine Operation zu einem Ergebnis, das für den Zieltyp zu gross ist, kommt es zu einem Compilierungsfehler, falls es sich um einen konstanten Ausdruck handelt, oder sonst zur Laufzeit zu einer System.OverflowException.

Im unchecked-Kontext wird das Ergebnis durch Verwerfen aller Höherwertigen Bits gekürzt.

Clipboard (Klasse)

Namespace: System.Windows.Forms. Diese versiegelte nicht instanziierbare Klasse stellt statische Methoden für die Arbeit mit der Zwischenablage bereit.

Code Group

Eine Codegruppe ist ein Set von Assemblies, welche sich den gleichen Sicherheitskontext teilen. Eine Assembly kann allerdings Mitglied mehrerer Codegruppen sein. In diesem Fall erhält diese Assembly die Übermenge aller Berechtigungen der Codegruppen bei welchen sie Mitglied ist.

Codegruppen gibt es auf verschiedenen Sicherheitsebenen. Bei der Evaluation der Berechtigungen einer Assembly beginnt die CLR bei der obersten (Enterprise Level), die Assembly erhält die Übermenge der Berechtigungen aller Codegruppen bei welchen sie Mitglied ist. Das gleiche wird auch für die unteren Sicherheitsebenen Machine und User gemacht. Danach erhält die Assembly die Schnittmenge der Berechtigungen der verschiedenen Sicherheitsebenen.

Enthält eine der Sicherheitsebenen das LevelFinal Property, werden die unteren Ebenen nicht mehr ausgewertet.

CollectionBase (abstrakte Klasse)

Namespace: System.Collections. Dient als Basisklasse für das Erstellen eigener Auflistungsklassen. Sie verfügt bereits über eine Clear-Methode und die Count-Eigenschaft sowie die protected Eigenschaft List vom Typ IList. Add, Remove und der Indexer für den Zugriff auf die Objekte müssen selbst implementiert werden.

Color (Struktur)

Namespace: System.Drawing. Repräsentiert eine Farbe. Siehe auch SystemColors.

ColorDialog (Klasse)

Namespace: System.Windows.Forms.

ComboBox (Control)

Command (Klasse)

System.Data.SqlClient.SqlCommand, System.Data.OleDb.OleDbCommand, System.Data.Odbc.OdbcCommand. Werden benötigt um in der DB SQL-Anweisungen auszuführen oder Stored-Procedures aufzurufen. Command-Objekte verfügen über alle notwendigen Informationen um das Kommando auszuführen und bieten eine sehr effiziente Möglichkeit mit der Datenbank zu interagieren. Die Auflistung Parameters speichert die Parameter für die Datenbankoperation, diese sind meist erst zur Laufzeit bekannt.

Beispiel:

OleDbCommand cmd = new OleDbCommand();

cmd.Connection = oleDbConnection1;

cmd.CommandText = "SELECT Vorname, Nachname FROM Adressen;";

oleDbConnection1.Open();

OleDbDataReader reader = cmd.ExecuteReader();

while (reader.Read()) {

  ...

}

reader.Close();

oleDbConnection1.Close();

Einige Exceptions im Zusammenhang mit Command-Objekten

CommandBuilder (Klasse)

System.Data.SqlClient.SqlCommandBuilder, System.Data.OleDb.OleDbCommandBuilder, System.Data.Odbc.OdbcCommandBuilder. Wird verwendet um das InsertCommand, UpdateCommand und DeleteCommand von DataAdaptern zu generieren. CommandBuilder kann nur verwendet werden, wenn die DataTable Daten aus einer einzlnen Tabelle der Datenbank enthält. Die Feldnamen dürfen keine Sonderzeichen oder Leerzeichen (den Feldnamen in [] zu setzen nützt auch nichts) enthalten. Die DataTable darf nicht mit anderen Tabellen im DataSet verknüpft sein resp. diese Verknüpfungen werden ignoriert.

Bevor CommandBuilder benutzt werden kann, muss man das SelectCommand des DataAdapters setzen. Der Primärschlüssel oder mindestens eine Spalte die als Schlüssel benutzt werden, kann muss zurückgegeben werden. Der CommandBuilder initialisiert nur die Commands des DataAdapters, welche null sind.

Dem CommandBuilder übergibt man im Konstruktor einen DataAdapter, dessen Commands durch den Konstruktor initialisiert werden.

Common Language Runtime (CLR)

Verwaltet die Codeausführung und bietet wichtige Dienste wie Kompilation, Specherreservation, Threadmanagement und Garbage Collection. Sie erzwingt Typsicherheit mit Hilfe des Common Type System (CTS) sowie Codesicherheit.

Common Language Specification (CLS)

Definiert die Mindestanforderungen an Compiler und gewährleistet damit, dass jeder mit einem .NET-Compiler übersetzte Code mit dem .NET-Framework zusammenarbeiten kann.

Common Type System (CTS)

Stellt die Typkompatibilität zwischen den .NET-Komponenten sicher, indem z.B. ein Integer aus Visual Basic und ein int aus C# in der IL beide als System.Int32 dargestellt werden.

Component (Klasse)

Namespace: System.ComponentModel. Stellt die Basisimplementierung für das Interface IComponent zur Verfügung. Nicht sichtbare Komponenten sollten hiervon abgeleitet werden.

Connection (Klasse)

System.Data.SqlClient.SqlConnection, System.Data.OleDb.OleDbConnection, System.Data.Odbc.OdbcConnection. Connection-Objekte repräsentieren die Verbindung zu einer Datenbank.

Um Username und Passwort nicht in den ConnectionString aufnehmen zu müssen, kann man z.B. eine DSN verwenden.

Um mit einer SqlConnection auf den lokalen SQL-Server zuzugreifen schreibt man im ConnectionString "server=(local)".

Die Variablennamen im ConnectionString sind case-insensitive, gewisse Werte jedoch schon.

Containersteuerelemente

Steuerelemente, die weitere Controls beinhalten können. Beispiele sind: Panel, GroupBox und TabControl. Eigenschaften von Containersteuerelementen können sich auf die darin enthaltenen Controls auswirken. Beispiele für solche Eigenschaften sind: Enabled, BackColor, ForeColor, Visible, Font.

ContextMenu (Klasse)

Namespace: System.Windows.Forms. Kontextmenüs öffnen sich beim Klick mit der rechten Maustaste auf ein Steuerelement. ContextMenu wird wie die Komponente MainMenu bearbeitet. Um ein Kontextmenü einem Control oder Formular zuzuweisen benutzt man dessen Eigenschaft ContextMenu.

Control (Klasse)

Namespace: System.Windows.Forms. Die Basisklasse aller Steuerelemente. Der Hauptunterschied zwischen Steuerelementen und Komponenten ist, dass Steuerelemente eine visuelle Darstellung haben.

csc.exe

Der C#-Compiler.

CurrencyManager (Klasse)

Namespace: System.Windows.Forms.
Oberklasse: BindingManagerBase.

Verwaltet eine Liste von Binding-Objekten.

DataAdapter (Klasse)

System.Data.SqlClient.SqlDataAdapter, System.Data.OleDb.OleDbDataAdapter. Ein DataAdapter wird benutzt um DataSets mit Daten aus der DB zu füllen, sowie Änderungen an den Daten in der DB zu speichern. DataAdapter nehmen also eine Brückenfunktion zwischen DataSet und Datenbank ein.

Die Verschiedenen Commands (UpdateCommand usw.) können in gewissen Fällen mit den CommandBuilder-Klassen erzeugt.

Nach dem Aufruf von Update (erst danach) sollte DataSet.AcceptChanges resp. DataTable.AcceptChanges aufgerufen werden.

Der DataAdapter kümmert sich selbst um das Öffnen und Schliessen der Connection.

DataColumn (Klasse)

Namespace: System.Data. Repräsentiert eine Spalte einer DataTable.

DataGrid (System.Windows.Forms)

Kann an DataSets, DataTables, DataViews und weiteres gebunden werden und stellt diese Daten dar.

Es ist möglich, Daten zu ändern, zu sortieren sowie Datensätze auszuwählen.

Eine Möglichkeit zur Darstellung einer DataTable ist:
dataGrid1.DataSource = dataSet1;
dataGrid1.DataMember = "Artikel";
somit wird die Tabelle Artikel aus dataSet1 in dataGrid1 dargestellt.

Eine weitere Möglichkeit ist, der Eigenschaft DataSource direkt die darzustellende Tabelle zuzuweisen.

Zum festlegen der Spaltenbreite oder zum Ausblenden von Spalten siehe System.Windows.Forms.DataGridTableStyle.

DataGridColumnStyle (System.Windows.Forms) [abstrakt]

Abgeleitete Klassen: System.Windows.Forms.DataGridBoolColumn, System.Windows.Forms.DataGridTextBoxColumn.

Instanzen dieser Klasse formatieren eine Spalte eines DataGrid's. Sie befinden sich in der Auflistung GridColumnStyles des DataGridTableStyle-Objekts welches dem DataGrid zugeordnet ist.

DataGridTableStyle (System.Windows.Forms)

Instanzen dieser Klasse formatieren die Darstellung einer Tabelle welche in einem DataGrid dargestellt wird. Die Instanz muss der Auflistung TableStyles des DataGrid's hinzugefügt werden.

Um einem DataGrid ein TableStyle (oder mehrere) hinzuzufügen, verwendet man am besten das Eigenschaftenfenster. Dort ist die Auflistung TableStyles sichtbar und man kann auch einer TableStyle GridColumnStyles hinzufügen, es ist auch bequem möglich einzelne Eigenschaftswerte im App.config speichern zu lassen.

Bindet man an ein DataGrid eine DataView, so muss DataGridTableStyle.MappingName auf den Namen der mit DataView dargestellten Tabelle gesetzt werden.

Anscheinend ist es aber nicht möglich, DataGridTableStyles gleichzeitig mit DataGrid-Autoformatierung zu benutzen.

DataObject (Klasse)

Namespace: System.Windows.Forms. Diese Klasse implementiert IDataObject und wird für die Datenübertragung via Zwischenablage sowie für Drag & Drop verwendet. In einer DataObject-Instanz können mehrere Datenmengen in verschiedenen Formaten gespeichert werden.

DataReader (Klasse)

System.Data.SqlClient.SqlDataReader, System.Data.OleDb.OleDbDataReader, System.Data.Odbc.OdbcDataReader. Bietet eine forward-only Möglichkeit, aus der Datenbank zu lesen. DataReader können nicht direkt instanziiert werden, Instanzen werden von Command.ExecuteReader() zurückgegeben. DataReader-Objekte benötigen exklusiv eine aktive Connection während ihrer gesamten Lebensdauer.

Beispiel:

while(myReader.Read()) {
  object obj1 = myReader[3];
  object obj2 = myReader["Vorname"];
}

myReader.Close();

Es ist mit einem DataReader auch möglich, streng typisierte Werte abzufragen. Dazu gibt es Methoden wie GetInt32, GetFloat usw.

DataRelation (Klasse)

Namespace: System.Data. Repräsentieren eine Verknüpfung zwischen Spalten zweier DataTables. Die DataTables müssen zum gleichen DataSet gehören. Verwendet man ein typisiertes DataSet, müssen die Spalten vom gleichen Typ sein. DataRelations müssen der Eigenschaft Relations des betreffenden DataSets zugewiesen werden.

Beispiel:

DataRelation myRelation = new DataRelation("Relation1", column1, column2);

myDataSet.Relations.Add(myRelation);

Siehe auch DataRow.GetChildRows und DataRow.GetParentRow;

DataRow (Klasse)

Namespace: System.Data. Ein Datensatz in einer DataTable. DataRows können nicht direkt instanziiert werden, sie werden über DataTable.NewRow() erzeugt.

Über einen Indexer kann man auf die einzelnen Werte dieses Datensatzes zugreifen.

myDataRow.BeginEdit();

myDataRow[0] = 3; // Dem ersten Feld wird der Wert 3 zugewiesen

myDataRow["Kundennummer"] = 3; // Dem Feld "Kundennummer" wird der Wert 3  zugewiesen

myDataRow.EndEdit();

Das Ändern von DataRows ist auch ohne Aufruf von BeginEdit und EndEdit möglich. Es sollte jedoch trotzdem mit Aufruf dieser zwei Methoden gemacht werden, da gewisse Features dies benötigen.

Aufgepasst!
Der Datentyp Integer aus Microsoft Access entspricht System.Int16.

Jede DataRow speichert zwei Zustände, eine unbearbeitete Version mit den ursprünglichen Werten und eine bearbeitete Version. Will man Änderungen in die Datenbank übertragen, darf man AcceptChanges erst aufrufen, nachdem man die Daten mit DataAdapter.Update in der Datenbank aktualisiert hat.

DataRowVersion (Enumeration)

Namespace: System.Data.

DataSet

DataSets können im Gegensatz zu den ADO Recordsets mehrere Tabellen beinhalten sowie auch Verknüpfungen zwischen den Tabellen. Man kann sich ein DataSet-Objekt als eine Kopie des relevanten Ausschnitts der Datenbank vorstellen. Meistens werden DataSets durch einen DataAdapter mit Daten aus einer Datenbankabfrage oder aus einer XML-Datei gefüllt, sie können aber auch im standalone-Modus existieren. Die Eigenschaft Tables ist vom Typ System.Data.DataTableCollection und verwaltet alle DataTables des DataSets.

Beispiel:

DataSet myDataSet = new DataSet();

DataTable myDataTable = new DataTable();

myDataSet.Tables.Add(myDataTable);

DataColumn columnName = new DataColumn("Name");

myDataSet.Tables[0].Columns.Add(columnName);

DataRow myRow = myDataSet.Tables[0].newRow();

myRow.Item[0] = "Herbert";

myDataSet.Tables[0].Rows.Add(myRow);

Typisierte DataSets

Sind von DataSet abgeleitet und werden aus einem XML-Schema (.xsd-Datei) erzeugt. Sie ermöglichen Typprüfung zur Kompilierzeit und bieten performanteren Zugriff auf Zeilen und Spalten. Statt mit dataSet1.Tables["Adressen"] kann man bei einem typisierten DataSet mit dataSet1.Adressen auf die Tabelle Adressen zugreifen.

Erzeugen eines typisierten DataSets:

Im Kontextmenü des Projekts Hinzufügen... | Komponente hinzufügen... wählen. Im erscheinenden Dialog DataSet auswählen.
Zeigt man das typisierte DataSet im Editor an, kann man zwischen den Ansichten DataSet und XML wählen. In der Ansicht DataSet ist es möglich, aus dem Server Explorer einzelne Tabellen oder sogar alle Tabellen gleichzeitig in das DataSet-Fenster zu ziehen.
Wechselt man zur Toolbox, wird das XML-Schema Tab sichtbar, und man kann durch Drag & Drop Elemente, Attribute, Schlüssel, Beziehungen und so weiter zum DataSet hinzufügen.

Klickt man im Projektmappen-Explorer auf "Alle Dateien anzeigen", wird unterhalb des DataSet.xsd Eintrag auch die Quellcode-Datei des DataSets sichtbar.

DataSets speichern die Daten intern im XML-Format. Siehe auch XmlDataDocument.

DataTable

Repräsentiert eine Tabelle innerhalb eines DataSets. Eine DataTable beinhaltet je eine Auflistung von DataColumn- und DataRow-Instanzen. Ein DataTable-Objekt kann auch ausserhalb eines DataSets existieren.

DataView (Klasse)

Ermöglichen, die Daten einer DataTable zu sortieren und zu filtern. Es können auch Steuerelemente an eine DataView gebunden werden.

Beispiel:

DataView myDataView = new DataView(myDataTable);

myDataView.Sort = "Kundennummer DESC, Wohnort"; // Standard ist ASC

myDataView.RowFilter = "Name = 'Müller' AND Wohnort = 'Zürich'";

Datenbindung

Eine Datenbindung ist eine Beziehung zwischen einem Datenprovider (Datenquelle) und einem Datennutzer (Datenkonsument).

Der Datenprovider ist das Objekt, welches die Daten zur Verfügung stellt, jedes Objekt das die Schnittstelle IList implementiert kann als Datenquelle verwendet werden. Typische Beispiele sind DataSets, DataTables, DataViews, es können aber auch Arrays, Collections oder eigene Klassen als Datenprovider verwendet werden. Jede Datenquelle hat ein CurrencyManager-Objekt, welches immer weiss, welcher Datensatz der aktuelle ist. Sämtliche CurrencyManager eines Formulars werden von dessen Eigenschaft BindingContext verwaltet.

Datennutzer sind Steuerelemente, sie stellen die Daten des Datenproviders dar und nehmen gegebenenfalls neue Werte entgegen.

Man unterscheidet zwischen einfacher Datenbindung und komplexer Datenbindung:

Bei der einfachen Datenbindung stellt das Steuerelement immer nur einen Eintrag dar. Ein Beispiel für einfache Datenbindung ist ein Label, dessen Eigenschaft Text an eine Spalte einer DataTable gebunden ist. Es kann immer nur den Wert des aktuellen Datensatzes darstellen. Einfache Datenbindung wird mit DataBindings.Add() realisiert.

Bei komplexer Datenbindung hingegen sind mehrere Datensätze gleichzeitig an das Steuerelement gebunden (ev. auch sichtbar). Ein Beispiel für komplexe Datenbindung ist eine ListBox, welche an eine ganze Spalte einer DataTable oder DataView gebunden ist. Komplexe Datenbindung realisiert man mit den Eigenschaften DataSource und DisplayMember.

Ein einfach gebundenes Steuerelement erstellen

Steuerelemente verfügen über die Eigenschaft DataBindings bei welcher es sich um eine Instanz der Klasse DataBindingsCollection handelt. DataBindings wird zur Entwurfszeit als erweiterbarer Knoten im Eigenschaftenfenster dargestellt.

Eine Datenbindung lässt sich durch Klick auf das Feld neben der entsprechenden Eigenschaft herstellen. Es öffnet sich eine Liste mit allen verfügbaren Datenquellen. Jede beliebige Eigenschaft eines Steuerelements lässt sich binden. Handelt es sich um eine Eigenschaft die unter DataBindings nicht aufgeführt wird, lässt sich durch Klick auf "(Erweitert)" und dann auf den Button mit "..." das Dialogfeld "Erweiterte Datenbindung" öffnen. Es listet sämtliche Eigenschaften des Steuerelements auf.

Datenbindung zur Laufzeit

Um zur Laufzeit eine Datenbindung herzustellen verwendet man die Eigenschaft Bindings des betreffenden Steuerelements. Es handelt sich dabei um eine Instanz der Klasse ControlBindingsCollection. Die Methode ControlBindingsCollection.Add() kann zum Einrichten einer neuen Bindung verwendet werden. Sie übernimmt drei Argumente. Der Name der zu bindenden Eigenschaft (des Controls) als String, die Datenquelle als Objekt und das zu bindende Member der Datenquelle als String.

textBox1.DataBindings.Add("Text", dataSet1.Tables["Customers"], "CustomerID");
Bindet die Spalte CustomerID der Tabelle Customers des DataSets dataSet1 and die Eigenschaft Text des Steuerlements textBox1. DataBindings ist eine Collection, die Objekte des Typs Binding verwaltet.
Verfügt die Datenquelle nicht über mehrere Spalten, übergibt man als drittes Argument einen Leerstring.

Sieh auch: BindingManagerBase, CurrencyManager, PropertyManager, BindingContext.

Datentypen

Datentypen verfügen auch über Membermethoden die nicht von object abgeleitet sind. Einige von diesen sind spezifisch für diesen Typ, alle Datentypen verfügen jedoch über die Methode Parse(). Sie konvertiert einen string in einen Wert des entsprechenden Typs.

DBNull (Klasse)

Namespace: System. Stellt den Wert NULL aus der Datenbankwelt dar. Das statische Feld Value ist die einzige Instanz dieser Klasse, es handelt sich also um ein Singleton.

decimal

Der Typ mit der grössten Wertspanne, er kann grössere Werte darstellen als long.

Deklarative Sicherheit

Die deklarative Sicherheit gibt an, welche Berechtigung eine Assembly laut ihrem Assemblymanifest verlangt. Permissions werden durch die Verwendung von Attributen verlangt. Siehe auch imperative Sicherheit.

Destruktor

Destruktoren tragen immer den selben Namen wie die Klasse mit einer Tilde (~) davor. Sie werden nicht vererbt, jede Klasse hat also nur den Destruktor, der in ihr deklariert wurde. Ein expliziter Aufruf ist nicht möglich.

Delegates

Spezielle Klassen welche äusserst wichtig für die Arbeit mit Ereignissen ist. Es handelt sich um typsichere Funktionszeiger, die auf eine Methode verweisen. Ein Delegat ist sozusagen ein Stellvertreter für eine Methode und ermöglicht, eine Methode aufzurufen deren Name erst zur Laufzeit bekannt ist. Delegates geben einer Signatur einen Namen, sodass jede Methode mit der gleichen Signatur und dem gleichen Rückgabetyp mit Hilfe des Delegaten aufgerufen werden kann.

Delegaten werden implizit von der Klasse Delegate resp. MulticastDelegate aus dem Namespace System abgeleitet. Die Deklaration erfolgt aber auf andere Weise.

Deklaration:

public delegate int myDelegate(string s);

Bei der Delegate-Deklaration muss ein Rückgabetyp und eine Parameterliste spezifiziert werden. Es gleicht einer Methodendeklaration die um das Schlüsselwort delegate erweitert wurde. Delegates können ausserhalb einer Klasse definiert werden.

Für die Ereignisse der .NET Framework Class Library werden Standarddelegaten zur Verfügung gestellt. Die Delegatklasse System.EventHandler ist beispielsweise für die Ereignisse der meisten Steuerelemente zuständig.

Methoden können Parameter vom Typ eines Delegates übernehmen. Somit ist es möglich, Methoden als Parameter zu übergeben (Funktionszeiger).

Digitale Signierung

Indem man Dateien eine digitale Signatur anheftet, kann man die Identität des Lieferanten sicherstellen und auch beweisen dass die Datei nach der Signierung nicht mehr verändert wurde.

Microsoft Authenticode ist eine Technologie anhand welcher verschiedenste Dateien mit Signaturen versehen werden können.

Assemblies können auch durch einen starken Namen signiert werden. Es ist möglich, beide Methoden, nur eine oder gar keine zu verwenden.

do...loop

do {

  Anweisungsblock

} while (Schleifenkriterium);

Dokumentationskommentare

Werden durch drei Slashes erzeugt. Unter Extras|Erstellen von Kommentarwebseiten... hat man die Möglichkeit auf den Dokumentationskommentaren basierende Webseiten zu erstellen.

DomainUpDown (Control)

Namespace: System.Windows.Forms. Erlaubt das Auswählen von String-Werten aus einer Liste analog zu NumericUpDown. Es ist auch möglich, selbst einen Wert einzugeben.

Enumerationen (Aufzählungen)

Stellen ein Set von Konstanten mit leicht zu merkenden Namen zur Verfügung.

Definition:

public enum Jahreszeiten

{

  Frühling = 1,

	Sommer = 2,

	Herbst = 3,

	Winter = 4

}

Zuweisung:

Jahreszeiten jz = Jahreszeiten.Frühling;

Enumerationen sind standardmässig vom Typ int, können aber von jedem Integertyp sein, in diesem Fall muss dieser bei der Definition angegeben werden.

Beispiel:

public enum Jahreszeiten : byte ...

Die Angabe von Werten ist optional, lässt man sie weg werden automatisch Werte beginnend mit 0 zugewiesen.

Es ist möglich, Methoden zu schreiben welche Parameter vom Typ einer Enumeration verlangen.

Eigenschaften (Properties)

Eigenschaften sind Member welche sowohl mit Feldern als auch mit Methoden Ähnlichkeiten haben. Werte werden von ausserhalb der Klasse mit der gleichen Syntax wie bei Feldern gesetzt und abgerufen. Dabei wird jedoch jeweils Code ausgeführt welcher den Wert validiert oder andere notwendige Aufgaben ausführt.

Definition:

private string name; // ein privates Feld welches den Wert der Eigenschaft speichert

public string Name

{

  get { return name;  }

  set { name = value; } // value (ein Schlüsselwort) ist der Wert, welcher der Eigenschaft zugewiesen wurde

}

Eigenschaften können wie Methoden überschrieben oder verborgen werden, folglich sind auch die Modifizierer virtual, override und new erlaubt.

Mit Attributen kann man steuern, ob Eigenschaften von visuellen Komponenten im Eigenschaftenfenster angezeigt werden, in welcher Kategorie und mit welcher  Beschreibung. Es werden jedoch nur die Eigenschaften der Basisklasse, nicht jene der aktuellen Klasse angezeigt.

Einheitentest (Unit test)

Methoden werden einzeln getestet. Dies anhand diverser Eingabewerte und Ausführungsparameter. Siehe auch Testfall.

Einheitentestplan erstellen

1. Testfälle erstellen, sodass jede betroffene Codezeile zur Ausführung gelangt.
2. Weitere Testfälle für jeden Weg, welcher der Datenfluss einschlagen kann.
3. Zusätzliche Testfälle für Grenzdaten, unzulässige Daten und Kombinationen von unzulässigen und zulässigen Daten.
4. Vor jedem Test wird das zu erwartende Ergebnis festgestellt.
5. Tests durchführen und tatsächliches Ergebnis mit erartetem vergleichen.

Ein Driver simuliert Aufrufe von anderen Einheiten.
Ein Stub simuliert eine aufgerufene Einheit.

Einzelschritt F11

Diese Debugfunktion steht im Unterbrechungsmodus zur Verfügung. Sie ermöglicht, die Programmausführung Zeile für Zeile zu untersuchen.

Ereignisse (Events)

Ereignisse sind wie Felder, Eigenschaften und Methoden, Member einer Klasse. Es handelt sich dabei um Nachrichten die auf ein Vorkommnis hinweisen und anderen Programmteilen die Möglichkeit geben, mittels Eventhandlern darauf zu reagieren. Ereignissen können Parameter übergeben werden, welche die Eventhandler auswerten können. Methoden die ein Ereignis behandeln, müssen die gleiche Signatur wie das Ereignis haben. Ein Ereignis kann mehrere Methoden auslösen und eine Methode kann mehrere Ereignisse behandeln. Ereignisse können auch statisch sein.

Deklaration von Ereignissen

Bei der Deklaration muss der Delegate-Typ angegeben werden, welcher das Ereignis verwendet.

Beispiel:

public delegate void motorStartenDelegate(double zeitPunkt);

public event motorStartenDelegate MotorStarten;

Ereignisse auslösen

Um das Ereignis auszulösen, kann man es wie eine Methode aufrufen. Löst man ein Ereignis aus, an welches keine Delegates gebunden sind, kommt es zu einer NullReferenceException. Daher sollte zuerst mit <Ereignis> != null geprüft werden, ob Delegates vorhanden sind.

Beispiel:
if (MotorStarten != null)MotorStarten(18.324);

Ereignisse mit einem Handler verknüpfen

Beispiel:
motor1.MotorStarten += new motorStartenDelegate(auto1.Anspringen);

Beim Instanziieren eines Delegaten übergibt man dem Konstruktor eine Methode mit der passenden Signatur (ohne die runden Klammern). Es ist natürlich auch möglich, ein Ereignis mit einem bereits vorhandenen Delegate zu verknüpfen.

Wird einem Ereignis mehr als ein Handler gegeben, werden diese beim Auslösen alle ausgeführt, und zwar in der Reihenfolge in welcher sie dem Ereignis zugewiesen wurden.

Entfernen von Handlern

motor1.MotorStarten -= new motorStartenDelegate(auto1.Anspringen);

Hiermit wird die Methode auto1.Anspringen() vom Ereignis motor1.MotorStarten abgekoppelt.

GetInvocationList

Ereignisse verfügen über die Methode GetInvocationList. Falls kein Delegate an das Ereignis gebunden ist, wird null zurückgegeben. Ansonsten gibt GetInvocationList().Length darüber Auskunft, wieviele Delegates an das Ereignis gebunden sind. Wird ein Delegate an das Ereignis gebunden und danach wieder entfernt, gibt GetInvocationList ebenfall null zurück.

Da das Auslösen eines Ereignisses an welches kein Delegate gebunden ist, eine NullReferenceException auslöst, sollte vor jedem Auslösen mit GetInvocationList() geprüft werden, ob deren Rückgabewert != null ist, und das Ereignis nur dann ausgelöst werden. Dummerweise löst allein der Aufruf von GetInvocationList() bereits ein NullReferenceException aus. Deswegen bleibt nur, die NullReferenceException abzufangen, oder im Konstruktor jedem Event eine Dummy()-Methode zuzuweisen.

ErrorProvider (Klasse)

Ein Extenderanbieter. ErrorProvider ermöglichen Steuerelementen, den Benutzer auf fehlerhafte Eingaben hinzuweisen. Kann auch bei gebundenen Steuerelementen verwendet werden.

Um auf eine falsche Eingabe aufmerksam zu machen verwendet man die Methode SetError(Control control, string message). Die Errormeldung löscht man mit SetError(<Ctonrol>, "") wieder.

Excel

Um Excel zu verwenden muss man einen COM-Verweis auf Microsoft Excel Object Library hinzufügen. Excel ist ein Objekt vom Typ Excel.Application (es muss immer ein vollqualifizierter Name verwendet werden). Instanziiert wird es interessanterweise mit = new Excel.ApplicationClass().

Excel.Application exApp;

Excel.Workbook newWorkbook; // Excel-File deklarieren

Excel.Worksheet sheet; // Tabellenblatt deklarieren

Excel.Range range; // Excel.Range-Objekt deklarieren

exApp = new Excel.ApplicationClass();

exApp.Visible = true; // Excel sichtbar machen

// Dieses Workbook enthält bereits eine Tabelle

newWorkbook = exApp.Workbooks.Add(Excel.XlWBATemplate.xlWBATWorksheet);

sheet = (Excel.Worksheet) newWorkbook.ActiveSheet;

range = (Excel.Range) sheet.Cells[1, 1];

range.Value2 = "1"; // "1" in Zelle A1 schreiben

range = (Excel.Range) sheet.Cells[2, 1];
range.Value2 = "1";
range = (Excel.Range) sheet.Cells[3, 1];
range.Formula = "=SUMME(A1; A2)";

Exception (Klasse)

Namespace: System. Vaterklasse aller Exceptions.

Will man eigene Exception-Klassen verwenden, sollte man diese von System.ApplicationException ableiten, siehe unter Ausnahme.

Extenderanbieter

Sind Klassen welche Steuerelementen zusätzliche Funktionalität hinzufügen können. Beispiele sind ToolTip und ErrorProvider.

Meist verwendet man pro Formular nur ein Extenderanbieter, da eine Instanz mehreren Steuerelementen Zusatzfunktionalität hinzufügen kann.

Feldprüfung

Prüft Werte bereits bei der Eingabe auf ihre Gültigkeit.

Steuerelemente die Tastatureingaben entgegennehmen verfügen über die Ereignisse KeyDown, KeyPress und KeyUp.

Ereignisse KeyDown und KeyUp:
Werden vom Steuerelement welches den Fokus hat ausgelöst, wenn der Benutzer eine Taste drückt resp. sie loslässt. Methoden zur Behandlung dieser Ereignisse müssen über einen Parameter vom Typ KeyEventArgs verfügen. Instanzen dieser Klasse beschreiben welche Tastenkombination gedrückt wurde.

Siehe auch Formularprüfung.

Fokus

Die Fähigkeit eines Steuerelements, Benutzereingaben entgegenzunehmen. Das Control welches den Fokus hat befindet sich immer auf dem aktiven Formular der Anwendung.

Um einem Steuerelement den Fokus zu geben ruft man dessen Methode Focus() auf. Sie gibt einen boolschen Wert zurück, der darüber Auskunft gibt, ob das Setzen des Fokus' erfolgreicht war. Unsichtbare oder deaktivierte Steuerelemente können den Fokus nicht erhalten. Die Eigenschaft CanFocus vom Typ bool sagt Ihnen, ob das Steuerelement den Fokus erhalten kann oder nicht.

Die Fokusereignisse treten in der folgenden Reihenfolge ein:

1. Enter
2. GotFocus
3. Leave
4. Validating
5. Validated
6. LostFocus

Enter und Leave werden ausgelöst, wenn das Control den Fokus erhält/verliert. GotFocus und LostFocus wenn es den Fokus erhalten/verloren hat.

Font (System.Drawing)

Wird am besten mit FontDialog erzeugt.

foreach (Schlüsselwort)

Mit einer foreach-Schleife kann man alle Elemente eines Arrays oder einer Auflistung durchlaufen.

Beispiel:

int[] myArray = new int[] {1, 2, 3, 4, 5};

foreach (int i in myArray) { // i ist die Iterationsvariable

  Console.WriteLine(i.ToString());

}

Die Array- oder Auflistungselemente müssen alle denselben Typ wie die Iterationsvariable (im Beispiel i) haben, ansonsten wird eine InvalidCastException ausgelöst. Eine gute Lösung ist, eine Iterationsvariable vom Typ object zu verwenden und mit der Methode GetType() den Typ des Elements abzufragen. Die Iterationsvariable ist schreibgeschützt, will man die Elemente durchlaufen und dabei Änderungen vornehmen verwendet man am besten die for-Schleife.

Es ist auch möglich eigene Collection-Klassen zu schreiben, deren Elemente mit foreach durchlaufen werden können.
Dafür muss die betreffende Klasse über eine Methode GetEnumerator() verfügen, welche ein Objekt zurückgibt das eine Methode bool MoveNext() und eine Eigenschaft Current besitzt. MoveNext() dient dazu, den Zeiger ein Element weiter zu bewegen und gibt true zurück solange weitere Elemente vorhanden sind. Die Eigenschaft Current gibt das aktuelle Objekt zurück.

Beispiel:

public class MyColl {

  string[] elements = {"Zebra", "Löwe", "Giraffe"}; // Die Elemente der Auflistung



  public string this[int index] {

    get { return elements[index]; }

  }



  public MyEnumerator GetEnumerator() {

    return new MyEnumerator(this);

  }



  public class MyEnumerator {

    int currIndex = -1; // speichert die aktuelle Zeigerposition

    MyColl coll;

    public MyEnumerator(MyColl coll) {

      this.coll = coll;

    }

    public bool MoveNext() {

      return(++currIndex < coll.elements.Length);

    }

    public string Current {

      get { return coll[currIndex]; }

    }

  }

}

public static void Main(string[] args) {

  MyColl meineColl = new MyColl();

  foreach (string s in meineColl) {

    Console.WriteLine(s);

  }

}

Das Durchlaufen eines Arrays mit foreach benötigt etwa 100 Mal länger als mit for (int i; ...).

for-Schleife

Ist auch mit zwei Zählervariablen möglich:

for (int x = 0, int y = 5; x < y; x += 2, y++)...

ForeignKeyConstraint (System.Data)

Die ForeignKeyConstraint tritt erst in Kraft, nachdem sie der Auflistung Constraints der DataTable hinzugefügt wurde.

Formulare (System.Windows.Forms)

Oberklasse: System.Windows.Forms.ContainerControl

Beim Anlegen eines neuen Windows Forms-Projekts wird automatisch ein Startformular mit dem Namen Form1 eingebunden. Weitere Formulare lassen sich mit Projekt|Windows Form hinzufügen... hinzufügen. In C# können nur Formulare welche über eine Main()-Methode verfügen als Startobjekt festgelegt werden (Projekt|Eigenschaften).

Formularprüfung

Diese Variante der Eingabevalidierung prüft die Daten nachdem der Benutzer sämtliche Felder ausgefüllt hat. Siehe auch Feldprüfung.

gacutil.exe

Ermöglicht unter anderem, eine Assembly im Globalen Assembly Cache (GAC) zu installieren. Am besten benutzt man es mit der Visual Studio .NET Eingabeaufforderung.

Beispiel:
gacutil /i myAssembly.dll

Garbage Collection

Normalerweise ein Thread mit niedriger Priorität. Er tritt in Aktion, wenn der Prozessor nicht ausgelastet ist. Wird der Speicher knapp, rückt der Garbage-Collection Thread in der Priorität nach oben. Das Vorgehen der Speicherfreigabe macht die Anwendung schneller, hat aber den Nachteil, dass es nicht deterministisch ist. Man hat keine Kontrolle darüber, wann der Destruktor eines Objekts aufgerufen wird.

GDI+

Im .NET-Framework steht die verwaltete Version von GDI (Graphics Device Interface) unter dem Namen GDI+ zur Verfügung. Diese Schnittstelle ist im Namespace System.Drawing.

Global Assembly Cache (GAC)

DLL-Assemblies mit starkem Namen können mit gacutil.exe in den GAC installiert werden. Das Kopieren der DLL-Datei in \WINDOWS\assembly\ führt zum gleichen Resultat.

Graphics (System.Drawing)

Graphics-Objekte stellen die Zeichenfläche eines visuellen Elements wie eines Formulars oder eines Steuerelements dar. Da sie immer mit einem visuellen Element verknüpft sind, können sie nicht direkt instanziiert werden. Alle Klassen die von Control erben (inkl. Form) verfügen über die Methode CreateGraphics welche einen Verweis auf das zugehörige Graphics-Objekt zurückgibt.

Graphics verfügt über eine vielzahl von Methoden für das Zeichnen von Linien und Formen. Methoden die mit Draw... beginnen, zeichnen Figuren die aus Linien bestehen, Methoden die mit Fill... beginnen zeichnen ausgefüllte Formen.

Für die meisten dieser Methoden gibt es auch eine Fill... - Version.

static Graphics FromImage(Image image)
Erzeugt ein Graphics-Objekt zu einem Bild. Mit dem Graphics-Objekt kann man das Bild bearbeiten, auch wenn es nicht sichtbar ist.

Grafik die dauerhaft auf einem Formular sichtbar sein soll, bindet man am besten an das Ereignis Form.Paint.

GroupBox (System.Windows.Forms)

Namespace: System.Windows.Forms. Ein Containersteuerelement mit Rahmen und der Möglichkeit, einen Titel festzulegen. Will man eine GroupBox mit Scrollbalken erzeugen, kann man ein Panel auf eine GroupBox legen, dessen Eigenschaft Dock auf DockStyle.Fill setzen und die Controls dem Panel hinzufügen.

Haltepunkt

Mit Haltepunkten kann man Codezeilen und/oder Bedingungen festlegen, welche die Programmausführung anhalten.

Einen Haltepunkt setzt man, indem man in den grauen Bereich links des Codefensters klickt. Bei Rechtsklick auf einen Haltepunkt erscheint ein Kontextmenü welches erlaubt, den Haltepunkt zu deaktivieren.

Haltepunkte (Fenster)

Hier sind alle Haltepunkte des Projekts mit ev. vorhandener Bedingung und Codestelle aufgelistet.

Das Kontrollkästchen links des Haltepunktes ermöglicht, den Haltepunkt zu deaktivieren.

Heap

Ein Speicherbereich in welchem Instanzen von Klassen gespeichert werden. Nicht mehr benötigte Objekte im Heap werden durch den Garbage Collector zerstört. Siehe auch Stack.

Help (System.Windows.Forms)

Nicht instanziierbare Klasse die nur statische Methoden enthält.

HelpProvider (Extenderanbieter)

Namespace: System.Windows.Forms.

Hinweis:
Kompilierte Hilfedateien vom Typ .chm können mit dem HTML-Help-Workshop erstellt werden (Programme\Visual Studio .NET\Common7\Tools\hcw.exe). Mit dem älteren Hilfeformat *.hlp kommt HelpProvider nicht zurecht.

IDataObject (System.Windows.Forms)

Inhalte der Zwischenablage (siehe Clipboard) werden als Objekt welches dieses Interface implementieren zurückgegeben.

Siehe auch DataObject.

IDisposable

Deklariert die Methode void Dispose(). Bei der Verwendung grosser Objekte kann es sinnvoll sein, die Speicherbereinigung explizit auszuführen. Da der Destruktor nicht explizit aufgerufen werden kann, geschieht dies über eine Methode.

Bei der Verwendung von IDisposable muss beachtet werden:

• Mehrfacher Aufruf von Dispose() darf nicht zu einem Fehler führen.
• Ein Aufruf von Dispose() impliziert, dass die Garbage Collection den Destruktor nicht mehr Aufrufen muss.
• Verfügt die Basisklasse ebenfalls über Dispose(), sollte diese ebenfalls aufgerufen werden.
• Wird Dispose() nicht explizit aufgerufen, muss sie vom Destruktor aufgerufen werden.

IIdentity (System.Security.Principal)

Imperative Sicherheit

Bei der imperativen Sicherheit werden Ausführungsberechtigungen zur Laufzeit angefordert. Man kreiert Permission-Objekte welche die Berechtigungen repräsentieren, die der Code verlangt. Siehe auch deklarative Sicherheit.

Indexer

Die aus Visual Basic bekannten Standardeigenschaften heissen in C# Indexer. Sie ermöglichen es, unter dem Namen des betreffenden Objekts eine ganze Gruppe von Objekten zur Verfügung zu stellen. Bei der Implementierung verwendet man statt eines Eigenschaftennamens das Schlüsselwort this.

Beispiel:

private int[] intArray;

  ...

  public int this[int index]
  {

    get { return intArray[index]; }

    set { intArray[index] = value; }

  }

Integertypen

Die ganzzahligen Typen (byte, short, int, long, sbyte, ushort, uint, ulong) werden unter dem Begriff Integertypen oder integrale Typen zusammengefasst. Man kann ihnen auch Literale in der hexadezimalen Schreibweise zuweisen, wenn man diesem 0x voranstellt.

Beispiel:

int myInteger = 0xAF; // entspricht 176

Interface (Schnittstelle)

Schnittstellen deklarieren Methodenköpfe, Eigenschaften und Ereignisse. Sie können von Klassen oder Strukturen implementiert werden, was bedeutet dass die Klasse alle im Interface deklarierten Member implementieren muss. Zugriffsmodifizierer sind in Interfaces nicht erlaubt. Alle Member sind implizit public.

Bei der expliziten Implementation eines Schnittstelle, (EII, Explicit Interface Implementation) stellt man den Namen der Schnittstelle vor die Implementierung des Members. Solche Member können nur mit Referenzen vom Typ der Schnittstelle angesprochen werden.

Intermediate Language (IL)

Maschinennahe Sprache, welche von der CLR verstanden wird. IL-Code befindet sich in .exe- und .dll-Dateien.

internal (Schlüsselwort)

Dieser Zugriffsmodifizierer setzt die Sichtbarkeit auf Assembly-Ebene.

IPermission (System.Security)

Alle Berechtigungen (Permission-Objekte) müssen diese Schnittstelle implementieren.

Siehe auch Permissions.

IPrincipal (Interface)

Namespace: System.Security.Principal.
Implementierende Klassen: GenericPrincipal, WindowsPrincipal.

Ein Principal stellt die Itentität und Rolle eines Benutzers dar. Principal-Instanzen kapseln eine Identity und eine Rolle. Die Rolle kann eine Windows-Benutzer Gruppe oder etwas selbst definiertes sein.

is (Operator)

is wird verwendet, um zu prüfen ob ein Objekt mit einem gegebenen Typen vereinbar ist. obj is TypA gibt true zurück, wenn obj mit dem Typ TypA vereinbar ist.

KeyEventArgs (Klasse)

Namespace: System.Windows.Forms.

KeyPressEventArgs (Klasse)

Namespace: System.Windows.Forms. Gibt das Zeichen an, das aus einem Tastendruck des Benutzers resultiert.

Klasse

Definition:

class <Name> : <Oberklasse>, <implementierte Interfaces>

{

  <Felder-, Eigenschaften-, Methoden- und Ereignisdefinitionen>

}

KnownColor (Enumeration)

Namespace: System.Drawing. Enthält vordefinierte Farben.

Konfigurationsdateien

In Konfigurationsdateien kann man Eigenschaften einer Anwendung konfigurieren und Informationen über den Speicherort und die Version von abhängigen Assemblies festlegen. Konfigurationsdateien müssen im gleichen Verzeichnis wie die Applikation liegen und folgendem Namens-Schema entsprechen: <Anwendungsname>.exe.config. Siehe auch AppSettingsReader.

Mit Ausnahme des <configuration>-Elements sind alle Elemente optional.

Wichtige Elemente von Konfigurationsdateien (innerhalb von <configuration>)

Konstanten

Definition:

public const double Pi = 3.14159;

Auf Konstanten kann nicht über Referenzen zugegriffen werden, sondern nur über den Klassennamen. Konstanten können vom Typ einer selbstdefinierten Enumeration sein, nicht jedoch einer selbstdefinierten Klasse oder Array. Wie bei Variablen, können bei Konstanten sämtliche Zugriffsmodifizierer (public, private, internal, protected) verwendet werden.

Konstruktor

Definiert man explizit einen Konstruktor, wird nicht automatisch ein Standardkonstruktor erzeugt. Beim Ausführen eines Konstruktors wird automatisch der Standardkonstruktor der Oberklasse aufgerufen, falls nicht explizit mit base ein anderer Konstruktor der Oberklasse aufgerufen wird.

Konstruktor der Oberklasse aufrufen

class Vater {

  public Vater(string name) {...}

	...

}



class Sohn : Vater {

  public Sohn(string name) : base(name) { // Ruft Konstruktor von Vater auf

	  ...

	}

	...

}

Um einen Oberklassenkonstruktor aufzurufen fügt man dem Konstruktorkopf einen Doppelpunkt und das Schlüsselwort base gefolgt von der Parameterliste hinzu.

Will man in einem Konstruktor einen anderen Konstruktor der selben Klasse aufrufen lässt sich die mit this.<Konstruktorname> machen.

Beispiel:
class MyComponent {
    private object myContainer;
    private string myName;
    public MyComponent(object container) {
      this.myContainer = container; 
    }
    public MyComponent(object container, string name) : this(container) { // ruft anderen Konstruktor auf
        this.myName = name;
    }
}

Laufzeitfehler

Treten auf, wenn eine Anweisung ausgeführt werden soll die unmöglich oder nicht erlaubt ist, beispielsweise eine Division durch 0 oder das Lesen aus einer Datei die nicht existiert. Wenn eine Anwendung auf einen Laufzeitfehler trifft, wird eine Ausnahme ausgelöst.

License (Klasse)

Namespace: System.ComponentModel. Abstrakte Basisklasse für alle Lizenzen. Eine Lizenz wird für eine bestimmte Instanz einer Komponente erteilt.

LicenseManager (Klasse)

Namespace: System.ComponentModel, versiegelt. Stellt Eigenschaften und Methoden bereit, um eine Komponente mit einer Lizenz zu schützen.

LicenseProvider (Klasse)

Namespace: System.ComponentModel. Abstrakte Basisklasse zur Implementierung eines eigenen Lizenzproviders (empfohlen). Die von Microsoft zur Verfügung gestellte Implementation (LicFileLicenseProvider) ist eher zu Demonstrationszwecken gedacht.

Siehe auch: Lizenzierung, LicenseManager.

ListBox (Klasse)

Namespace: System.Windows.Forms. Der Collection Items kann mit Items.Add ein Objekt übergeben werden. In der Listbox dargestellt wird der Rückgabewert von ToString() des Objekts.

ListView (Klasse)

Namespace: System.Windows.Forms.

ListViewItem (Klasse)

Namespace: System.Windows.Forms. Die Einträge einer ListView.

Lizenzierung

Lizenzierung eines Steuerelements ermöglicht dessen Autor sein geistiges Eigentum zu schützen, so dass nur ermächtigte Personen es nutzen können.

Soll ein Steuerelement durch Lizenzierung geschützt werden, muss es ein LicenseProviderAttribute haben. Dieses gibt an, welcher LicenseProvider zur Validierung der Lizenz eingesetzt wird.

Eine .LIC-Datei wird vom Entwickler kreiert und kann sich überall befinden (wird vom LicenseProvider spezifiziert). Eine .LICX-Datei wird von Visual Studio basierend auf der .LIC-Datei erzeugt. Sie muss im gleichen Verzeichnis liegen wie die Assembly welche die lizenzierte Komponente benutzt.

Eine Lizenzverwaltung für ein Steuerelement implementieren:

1. Im LicenseProviderAttribute der Steuerelementklasse den zu verwendenden LicenseProvider angeben.
2. Lizenzdatei (*.lic) im Einklang mit der Implementierung des LicenseProviders erstellen.
3. Im Konstruktor des Steuerelements LicenseManager.Validate aufrufen.
4. In der Methode Dispose des Steuerelements die Lizenz bereinigen.

Beispiel:

[LicenseProvider(typeof(MyLicenseProvider))]

public class MyControl : Control {

  private License myLicense;

  public MyControl() {

    // Prüft Lizenz mit MyLicenseProvider

    LicenseManager.Validate(typeof(MyControl), this);

    ...

  }

}

MainMenu (Klasse)

Enthält eine Auflistung von von MenuItem-Steuerelementen welche die Menüstruktur bilden. Um einem Formular eine Menüleiste zu geben fügt man ihm eine MainMenu-Komponente hinzu. In der Menüleiste des Formulars erscheint ein Feld mit der Schrift "Hier eingeben", gibt man einen Text ein, erzeugt man damit ein neues Menüelement. Dabei wird automatsich eine neue Instanz von MenuItem erzeugt.

Trennlinien

Um mehrere Menüeinträge voneinander abzutrennen gibt man als Text eines Menüelements nur einen Bindestrich ein. Dieses wird dann als waagrechter Balken dargestellt.

Zugriffstasten (Access Keys)

Ermöglichen dem Benutzer ein Menü zu öffnen indem er auf ALT und die entsprechende Zugriffstaste drück. Im geöffneten Menü wählt er einen Eintrag aus, indem er wiederum die zugehörige Zugriffstaste drückt. Eine Zugriffstaste legt man fest, indem man in der Eigenschaft Text des Menüelements vor den betreffenden Buchstaben ein "&" setzt.

Tastenkombinationen (Shortcuts)

Ermöglichen direkt auf Menüelemente zuzugreifen, es kann sich auch um einzelne Tasten handeln. Tastenkombinationen werden im Menü rechts neben dem Menüelement angezeigt, es sei denn die Eigenschaft ShowShortcut ist auf false gesetzt. Tastenkombinationen können im Eigenschaftenfenster mit der Eigenschaft Shortcut eingestellt werden.

Menüereignisse

Click: wird beim Anklicken des Menüelements ausgelöst.

Select: wird ausgelöst, wenn der User ein Menüelement mit der Maus (ohne Klick) oder mit der Zugriffstaste anwählt.

Popup: wird unmittelbar bevor die Elemente eines Menüs angezeigt werden ausgelöst. Eignet sich um Menüelemente zur Laufzeit zu aktivieren/deaktivieren bevor sie angezeigt werden.

Menübefehle aktivieren und deaktivieren

Dazu kann die Eigenschaft Enabled auf true oder false gesetzt werden. Damit werden auch die Zugriffstasten und Tastenkombinationen deaktiviert.

Member

Die Methoden, Felder, Eigenschaften und Ereignisse einer Klasse oder Struktur.

MenuItem (Klasse)

Die Menüs, Menüeinträge und Untermenüs einer Menüleiste sind Instanzen von MenuItem.

Mergemodulprojekte

Ermöglichen die Weitergabe von Komponenten (z.B. Steuerelemente). Mergemodulprojekte erstellen ein verteilbares Paket, welches mit einem bestehenden Setup-Projekt zusammengelegt werden muss. Es beinhaltet auch Informationen darüber, wie und wo die Assembly installiert wird.

MessageBox (Klasse)

Namespace: System.Windows.Forms. Diese Klasse wird für das Anzeigen von Meldungen verwendet, die MessageBox kann ein Set von Buttons haben und je nach gedrücktem Button einen Wert zurückgeben. Der zurückgegebene Wert ist vom Typ DialogResult, eine Enumeration mit den Werten Ignore, No, None, OK, Retry, Yes.

Die Methode Show() ist mehrfach überladen. Um eine MessageBox mit Meldungstext, Titel und Ja- sowie Nein-Button zu erzeugen geht man wie folgt vor:

DialogResult dlgResult = MessageBox.Show(

  "Wollen Sie wirklich abbrechen?", // Meldungstext

	"Abbrechen", // Überschrift der MessageBox

	MessageBoxButtons.YesNo); // Ja- und Nein- Button

// dlgResult auswerten

MessageBoxButtons ist wiederum eine Enumeration mit den Werten AbortRetryIgnore, OK, OKCancel, RetryCancel, YesNo, YesNoCancel, welche je einem Set von Buttons entsprechen.

Methoden

Ohne Zugriffsmodifizierer deklarierte Methoden sind in C# private.

In C# hat jede Methode einen Rückgabetyp, bei Methoden die keinen Wert zurückgeben heisst dieser void. Innerhalb einer Methode deklarierte Variablen (lokale Variablen) existieren nur während deren Ausführung und sind nur innerhalb der Methode sichtbar. Innerhalb eines Blocks deklarierte Variablen sind sogar nur innerhalb dieses Blocks sichbar und existent. Im Gegensatz zu Visual Basic .NET ist es in C# nicht möglich, verschiedene Aufrufe überdauernde Variablen zu deklarieren.

Die Parameterübergabe erfolgt standardmässig by value, dies kann allerdings mit dem Schlüsselwort ref geändert werden. Objekte werden immer by reference übergeben.

Heisst ein Parameter oder eine lokale Variable gleich wie eine Instanzvariable der betreffenden Klasse, kann mit this.<Variablenname> auf die Instanzvariable zugegriffen werden.

Modul

Eine Datei die Quellcode enthält.

MouseEventArgs (Klasse)

Namespace: System.Windows.Forms
Oberklasse: System.EventArgs

Stellt Daten für die Ereignisse MouseUp, MouseDown und MouseMove bereit.

Namespace

Namensräume gruppieren logisch zusammengehörende Typen hierarchisch. Im Namespace System.Windows.Forms sind beispielsweise alle Typen für Windows-Formulare und Steuerelemente zusammengefasst. Auf untergeordnete Namespaces kann mit einem . zugegriffen werden.

Deklaration:

namespace Kunden

{

  class Stammkunde : Kunde

  {

    ...

  }

} // Ende Namespace Kunden

Ein Namespace kann sich über mehrere Dateien erstrecken, es können aber auch mehrere Namespaces in einer Datei definiert werden.

Folgende Schreibweisen sind äquivalent:

namespace TopNamespace {

  namespace SubNamespace {

    namespace SubSubNamespace {

      class bla ....

    }

  }

}

namespace TopNamespace.SubNamespace.SubSubNamespace {

  class bla ....

}

Tiefe Verschachtelung bringt keine Performanceeinbussen mit sich.

.NET Framework Class Library

Stellt (meist erweiterbare) Klassen und Schnittstellen zur Verfügung welche für die Integration in die CLR geschaffen wurden. Sie ist hierarchisch in Namespaces (Namensräume) aufgeteilt.

Ngen.exe

Der Native Image Generator erstellt ein systemeigenen Bild einer verwalteten Assembly. Nach dem Erstellen dieses Abbildes verwendet die CLR dieses bei jedem Ausführen der Assembly. Dies sorgt für schnelleres Laden und Ausführen.

Syntax:
Ngen [options] AssemblyName|AssemblyPath

NumericUpDown (Control)

Namespace: System.Windows.Forms. Erlaubt die Auswahl eines numerischen Wertes durch das Klicken auf Pfeile.

OleDbConnection (Klasse)

Namespace: System.Data.OleDb.

Beispiel für einen ConnectionString um auf Access-Datenbank zuzugreifen: "Provider=Microsoft.Jet.OLEDB.4.0;DataSource=C:\\Nordwind\\Nordwind.mdb".

OleDbParameter (Klasse)

Namespace: System.Data.OleDb. Werden in der Parameters-Auflistung von OleDbCommand-Objekten verwaltet. Für die Parameter werden im CommandText des OleDbCommands "?" als Platzhalter verwendet. Die Reihenfolge muss mit der Reihenfolge der Parameter in der Auflistung Parameters übereinstimmen.

OleDbType (Enumeration)

Namespace: System.Data.OleDb. Aufzählung aller OleDB-Datentypen.

Operatoren

C# erlaubt es, Operatoren für selbstdefinierte Struktur-Typen zu überladen.

Es gelten folgende Einschränkungen:

• Der Vorrang kann nicht geändert werden. * bindet beispielsweise immer stärker als +.
• Die Anzahl der Operanden kann nicht geändert werden.
• Man kann keine neuen Symbole für Operatoren erfinden.
• Gewisse Operatorsymbole wie z.B. "." für den Memberzugriff können nicht überladen werden.

Beispiel: Operatoren für die Struktur Complex (komplexe Zahl)

struct Complex {

  double r;

  double i;

  public Complex(double r, double i) {

    this.r = r;

    this.i = i;

  }

  public static Complex operator+ (Complex links, Complex rechts) {

    return new Complex(links.r + rechts.r, links.i + rechts.i);

  }

  public static Complex operator* (Complex links, Complex rechts) {

    return new Complex(links.r * rechts.r - links.i * rechts.i, links.r * rechts.i + links.i * rechts.r);

  }

}

Panel (Control)

Namespace: System.Windows.Forms. Ein Containersteuerelement welches zwar keine Überschrift, dafür Bildlaufleisten zur Verfügung stellt.

Parameter

Parameter werden in C# standardmässig by value übergeben. Eine Übergabe als Referenz lässt sich mit dem Schlüsselwort ref erzwingen. Verweistypen werden immer als Referenz übergeben.

Parameterarray

Ein Parameter der mit dem Modifizierer params deklariert ist und einem eindimensionalen Array-Typ angehört (jagged-Arrays sind auch möglich, da sie eigentlich eindimensionale Arrays sind). Eine Methode kann nur einen Parameter-Array aufweisen, dieser muss der letzte sein.

Beispiel:

public int Calculate(char operator, params int[] values) {...

Diese Methode kann wie folgt aufgerufen werden:

int X = <Klassenname>.Calculate('+', 1, 4);

int X = <Klassenname>.Calculate('-', 1, 6, 4, 6);

Der Parameter-Array ermöglicht also, eine beliebige Anzahl (auch 0) von Parametern des enstprechenden Typs zu übergeben. Es ist auch möglich, einen Ausdruck zu übergeben der implizit in einen Array des entsprechenden Typs konvertiert werden kann.

Pen (Klasse)

Namespace: System.Drawing. Repräsentiert einen Stift mit einer Farbe und einer Strichdicke. Wird benötigt um mit Graphics-Methoden Figuren zu zeichnen.

Konstruktoren:
Pen(Color color)
Pen(Color color, float width)

Pens (Klasse)

Namespace: System.Drawing. Versiegelte Klasse mit statischen Membern vom Typ System.Drawing.Pen.

perfmon.exe

Windows 2000 und Windows XP verfügen über das Tool perfmon.exe mit welchem man die Leistung eines Programms messen kann. Er erlaubt, Leistungsdaten grafisch anzuzeigen oder in eine Protokolldatei zu schreiben.

Permissions (Berechtigungen)

Permission-Objekte repräsentieren die Berechtigung auf eine geschützte Ressource zuzugreifen. Sie beschreiben auch, welche Operationen auf die Ressource angewendet werden dürfen. Permissions werden von der CLR gewährt oder verweigert. Man kann Permissions durch zusätzliche Informationen genauer definieren.

Beispiel:
Eine FileIOPermission kann so konfiguriert werden, dass nur Zugriffe auf eine bestimmte Datei erlaubt sind.

Aufgerufener Code kann verlangen, dass der Aufrufer bestimmte Permissions hat (Demanding Permissions).

Alle Permissions sind von System.Security.CodeAccessPermission abgeleitet.

Es werden drei Typen von Permissions unterschieden:

Code Access Permissions: involviert Zugriff auf geschützte Ressourcen.

Identity Permissions: involviert Zugriff aufgrund Legitimationen (Credentials) welche Teil des Codes selbst sind

Role-based Permissions: steuern Zugriff basierend auf dem Benutzer unter welchem der Code läuft.

Mehrere Permissions können zu Permission Sets zusammengefasst werden, eine oder mehrere Permissions die als eine Einheit gewährt werden. Es ist nicht möglich, eine Permission selbst zu gewähren, will man eine einzelne gewähren muss man sie in ein Permission Set kapseln.

Mit der Methode Demand() fordert die Permission die Berechtigung welche sie repräsentiert vom System an. Wird sie nicht gewährt, wird eine Exception ausgelöst.

Siehe auch IPermission

Point (Struktur)

Namespace: System.Drawing. Stellt einen Punkt mit int-Werten für X und Y dar.

Policy

Die CLR stützt sich bei der Entscheidung ob Code ausgeführt werden kann auf Vorgaben und Regeln, der sogenannten Policies. Diese sind hierarchisch auf den Ebenen Enterprise, Machine, User, AppDomain organisiert.

Die Konfiguration wird über XML-Dateien vorgenommen:
Auf Maschinen-Ebene: %CLRInstallationsVereichnis%\config\
auf User-Ebene: %USERPROFILE%\application data\Microsoft\CLR security config\vxx.xx\

PrintDialog (Klasse)

Namespace: System.Drawing.Printing. Ermöglicht dem Benutzer einen Drucker auszuwählen. Sollte vor PrintPreviewDialog angezeigt werden.

PrintDocument (Klasse)

Namespace: System.Drawing.Printing. Stellt ein gedrucktes Dokument dar.

PrintPageEventArgs (Klasse)

Namespace: System.Drawing.Printing.

PrintPreviewDialog (Klasse)

Namespace: System.Drawing.Printing.

Das Anzeigen des PrintPreviewDialogs führt zum Aufruf der Print-Methode. Klickt man im PrintPreviewDialog auf die Schaltfläche "Drucken" wird diese Methode erneut ausgeführt, deswegen muss man dafür sorgen, dass die Seitenzählung wieder auf 0 gesetzt wird.

Programmausführung

Die Assembly mit dem Einstiegspunkt wird in den Arbeitsspeicher geladen und das Assemblymanifest von der CLR untersucht. Sie vergleicht die für die Ausführung erforderlichen Bedingungen mit der Sicherheitsrichtlinie des Systems. Falls diese erforderliche Rechte verweigert, wird die Anwendung nicht ausgeführt.

Beim Programmstart wird der erste auszuführende Codeteil in den Arbeitsspeicher geladen und vom Just in Time Compiler (JIT) in native code kompiliert und ausgeführt. Erst wenn die Anwendung zu Code verzweigt der noch nicht kompiliert ist, tritt der JIT wieder in Aktion. Somit wird nur der wirklich auszuführende Code kompiliert.

PropertyManager (Klasse)

Namespace: System.Windows.Forms.
Oberklasse: BindingManagerBase

Verwaltet ein Objekt, von welchem idR. mehrere Eigenschaften an Steuerelemente gebunden sind. Diese einzelnen Bindungen sind in der Auflistung Bindings, welche Binding-Instanzen zurückgibt.

protected (Schlüsselwort)

Dieser Zugriffsmodifizierer erlaubt nur erbenden Klassen auf das entsprechende Member zuzugreifen.

RadioButton (Klasse)

Namespace: System.Windows.Forms. RadioButtons können im Gegensatz zur CheckBox nicht den Zustand Indeterminate annehmen. Bei mehreren RadioButtons in einem Container kann immer nur einer ausgewählt (also Checked == true) sein.

Rectangle (Struktur)

Namespace: System.Drawing. Repräsentiert einen rechteckigen Bereich auf der Zeichenfläche.

Top: y-Koordinate des oberen Randes
Bottom: y-Koordinate des unteren Randes
Right: x-Koordinate des rechten Randes
Left: x-Koordinate des linken Randes

RCW (Runtime Callable Wrapper)

Runtime Callable Wrapper.

ResEditor

Eine Beispielanwendung für das Erstellen von Text- und Bildressourcendateien. Sie liegt unkompiliert im Ordner Programme\Microsoft Visual Studio .NET\FrameworkSDK\Samples\Tutorials\resourceandlocalization\reseditor.

Mit dem ResEditor kann man Name und Typ von der Ressourcen angeben. Danach kann man für Zeichenfolgen Werte eingeben oder Bilder liefern welche als Ressource eingebunden werden sollen. Die Ressourcendateien können im Binärformat mit Endung .resources oder als XML-Datei mit Endung .resx gespeichert werden.

ResourceManager (Klasse)

Namespace: System.Resources. Ermöglicht, Zeichenfolgen und Objekte aus Ressourcendateien zu laden. Jede Instanz ist mit einer Assembly verknüpft welche Ressourcen enthält.

Dem Konstruktor übergibt man den Basisnamen der eingebetteten Ressourcendatei und die Assembly in welcher diese vorliegt. Der Basisname (der Ressourcendatei) ist deren Namespace und durch einen "." getrennt der Dateiname ohne Erweiterung.

Beispiel für das Anlegen eines ResourceManagers für eine Ressource namens myResource die in gleicher Assembly liegt:

using System.Resources;
namespace myNamespace {
...
ResourceManager resMan = new ResourceManager("myNamespace.myResource", this.GetType().Assembly);

Falls die Ressource nicht in der selben Assembly liegt:

using System.Reflection; // Namespace der Klasse Assembly

using System.Resources;
...

Assembly resAssembly;

// Load ist statische Methode von Assembly

resAssembly = Assembly.Load("ResourceAssembly");

ResourceManager resMan;

resMan = new ResourceManager("ResourceAssembly.myResource", resAssembly);

Es muss ein Verweis auf die RessourcenAssembly hinzugefügt werden.

Ressourcendateien

Können mit dem ResEditor angelegt werden. Der ResEditor liegt als Quellcode im Verzeichnis Programme\Microsoft Visual Studio.NET\FrameworkSDK\Samples\Tutorials\resourcesandlocalization\reseditor. Am besten kompiliert man es mit VS.NET.

Rollenbasierte Autorisierung / Sicherheit

Die Rollenbasierte Autorisierung steuert den Zugriff anhand der Identität und Rolle des Benutzers.

Die rollenbasierte Sicherheit ist einfach zu realisieren, aber recht unflexibel.

• Wenn ein User mit wenig Rechten ein vertrauenswürdiges Programm ausführen will, welches mehr Rechte benötigt, wird dieses nicht laufen.
• Lädt ein Administrator ein Programm aus dem Internet herunter und führt es aus, verfügt dieses Programm über sämtliche Rechte.

Oft ist des daher sinnvoller, einem Programm unabhängig vom User Rechte zu vergeben. Siehe auch Code Access Security.

Schlüsselpaar

Um eine Assembly freizugeben benötigt diese über ein Schlüsselpaar aus privatem und öffentlichem Schlüssel.

Ein solches Schlüsselpaar kann man mit sn.exe erstellen (am besten in der Visual Studio .NET-Eingabeaufforderung). Mit dem Flag -k kann man eine Ausgabedatei für das Schlüsselpaar angeben. Schlüsselpaare haben die Dateiendung .snk.

Beispiel:
sn -k meinSchluessel.snk

Um eine Assembly mit einem starken Namen zu signieren muss man zuerst sicherstellen, dass sie über eine Versionsnummer verfügt (Attribut AssemblyVersion in AssemblyInfo.cs). Mit dem Attribut AssemblyKeyFile kann man die Datei mit dem Schlüsselpaar angeben. Es kann sich um einen absoluten oder relativen Pfad handeln.

Beispiel:
[assembly: AssemblyVersion("1.0.0.1")]
[assembly: AssemblyKeyFile("..\\meinSchluessel.snk")]

sealed (Schlüsselwort)

sealed wird verwendet, um zu verhindern dass Klassen abgeleitet, resp. Methoden überschrieben werden können. Es können nur mit override deklarierte Methoden versiegelt werden.

Beispiel:

sealed class Auto {... // Auto kann nicht abgeleitet werden

Setup-Projekte

Mit Setup-Projekten werden im Gegensatz zu Mergemodulprojekten ganze ausführbare Anwendungen weitergegeben.

Windows Installer Dateien (.MSI)

Enthalten alle Informationen und Inhalte welche zur Installation benötigt werden.

Size (Struktur)

Namespace: System.Drawing. Stellt eine Rechteck-Grösse (ohne Position) mit int-Werten für Breite (Width) und Höhe (Height) dar. Siehe auch Rectangle.

SizeF entspricht Size, Height und Width sind aber vom Typ float. SizeF verfügt über die Methode ToSize(), welche dieselbe Grösse als Size zurückgibt.

sn.exe

Generiert ein Paar aus öffentlichem und privatem Schlüssel (siehe Schlüsselpaar). Dieses wird benötigt, um eine Assembly mit einem starken Namen zu signieren.

SolidBrush (Klasse)

Namespace: System.Drawing. Ein Pinsel mit einer einzigen Volltonfarbe.

Konstruktor: SolidBrush(Color color)

SqlCommand (Klasse)

Namespace: System.Data.SqlClient.

Beispiel für ein Update-Command:

// zu sqlConnection1 passendes SqlCommand erzeugen

SqlCommand cmdUpdate = sqlConnection1.CreateCommand();

cmdUpdate.CommandText = "UPDATE Customers SET " +

  "ContactName = @ContactName WHERE CustomerID = @CustomerID;";

// Parametername, SQL-Server-Datentyp, Länge, Feldname in DB

cmdUpdate.Parameters.Add("@ContactName", SqlDbType.NVarChar, 30, "ContactName");

cmdUpdate.Parameters.Add("@CustomerID", SqlDbType.NChar, 5, "CustomerID");

// @CustomerID soll urspr. Wert enthalten da in WHERE-Klausel verwendet

cmdUpdate.Parameters["@CustomerID"].SourceVersion = DataRowVersion.Original;

sqlDataAdapter1.UpdateCommand = cmdUpdate;

SqlConnection (Klasse)

Namespace: System.Data.SqlClient.

ConnectionString Beispiel:

"server=(local); user id=sa; initial catalog=PersonenSQL"

sa ist ein Standarduser ohne Passwort der bei der Installation von MSDE automatisch erzeugt wird.

SqlException (Klasse)

Namespace: System.Data.SqlClient. Eine Ausnahme dieses Typs wird ausgelöst, wenn der SQL-Server einen Fehler oder eine Warnung zurückgibt.

SqlParameter (Klasse)

Namespace: System.Data.SqlClient.

Stack

Eine Speicherstruktur die nach dem Stapelprinzip funktioniert und Wertevariablen (primitive Typen, Enumerationen und Strukturen) sowie Referenzen beinhält. Siehe auch Heap.

starker Name

Ein Name für eine Assembly welcher ihre Identität garantiert. Die Identitätsinformationen werden mit dem privaten Schlüssel des Schlüsselpaares verschlüsselt und lassen sich mit dem öffentlichen Schlüssel wieder entschlüsseln. Nur der Entwickler verfügt über den privaten Schlüssel, weshalb der starke Name von niemandem sonst reproduziert werden kann.

Ein starker Name besteht aus einem String welcher sich aus dem Dateinamen der Assembly, einem öffentlichen Schlüssel und einer digitalen Signatur besteht.

Zwei Assemblies mit verschiedenen starken Namen werden von der CLR immer als zwei völlig verschiedene behandelt. Assemblies mit gleichem starken Namen immer als die selbe.

Visual Studio .NET generiert beim Kompilieren einen starken Namen, falls ein Schlüsselpaar vorhanden ist.

Steuerelement

in Internet Explorer laden

Alle Steuerelemente können auch in den Internet Explorer geladen werden. Dazu muss es entweder im GAC installiert sein oder im gleichen virtuellen Verzeichnis wie die HTML-Seite liegen.

Zur Einbindung in die HTML-Seite wird das <OBJECT>-Tag verwendet. Das HTML-Attribut classid enthält den Pfad zur Assembly und durch ein # getrennt den vollständigen Namen der Steuerelementklasse (inkl. Namespace).

Beispiel:

<OBJECT id="xyz" classid="http:ControlLibrary.dll#ControlLibrary.MyControl"></OBJECT>

StreamReader (Klasse)

Namespace: System.IO. Ermöglicht das Lesen aus Textdateien.

string (Klasse)

Struktur

Strukturen sind etwas ähnliches wie Klassen, es handelt sich aber um Werttypen. Sämtliche Daten befinden sich also auf dem Stack.

public struct Player
{
  string name;
  int posX;
  int posY
  public Player(string name, int x, int y)
  {
    this.name = name;
    posX = x;
    posY = y;
  }
}

Strukturen benötigen ebenfalls einen Konstruktor und müssen mit new instanziiert werden. Da sich Instanzen von Strukturen auf dem Stack befinden, sind sie besser für Objekte mit kurzer Lebensdauer oder wenigen Daten geeignet.

Unterschiede zwischen Klassen und Strukturen:

• Strukturen sind Wertetypen.
• Strukturvariablen werden bei Zuweisungen immer kopiert, man spricht in diesem Zusammenhang auch von Wertesemantik, im Gegensatz zu Verweissemantik bei Verweistypen.
• Alle Strukturen erben (implizit) von System.ValueType.
• Strukturen können Interfaces implementieren, aber nicht von einer Basisklasse erben (sie erben immer von System.ValueType).
• Für Strukturen kann man keinen Standardkonstruktor (parameterlos) deklarieren, der Compiler erstellt einen eigenen, welcher alle Felder auf den Standardwert (0, null oder false) setzt.
• In selbstgeschriebenen Konstruktoren müssen alle Felder initialisiert werden. Im Gegensatz zu Klassen werden bei Strukturen nicht initialisierte Felder nicht vom Compiler automatisch auf den Standardwert gesetzt.
• Felder können nicht gleich bei der Deklaration initialisiert werden.
• Für Strukturen darf man keinen Destruktor deklarieren.

Hinter den "primitiven Datentypen" wie int, bool oder double verstecken sich in Wirklichkeit Strukturen. System.Int32, System.Boolean usw. sind Strukturtypen.

Beim Deklarieren eigener Strukturtypen implementiert der Compiler nicht automatisch eigene Operatoren. Es ist beispielsweise nicht möglich den Operator == anzuwenden, ohne ihn zuerst selbst zu implementieren.

Syntaxfehler

Liegen vor, wenn der Compiler den Code nicht verstehen kann. Codestellen mit Syntaxfehlern werden von Visual Studio .NET automatisch unterstrichen und erscheinen in der Aufgabenliste.

SystemColors (Klasse)

Namespace: System.Drawing. Stellt statische Eigenschaften vom Typ System.Drawing.Color zur Verfügung, welche den aktuellen Systemfarben entsprechen. Damit wird es möglich das Farbschema zu verwenden, das der Benutzer auf seinem Rechner eingestellt hat.

Beispiel:

Color myColor = SystemColors.HighlightText;

TabControl

Namespace: System.Windows.Forms. Dieses Containersteuerelement bietet die Möglichkeit, andere Steuerelemente auf einer Reihe von Registerkarten (vom Typ TabPage) zu plazieren. Die Eigenschaft TabPages ist eine Auflistung aller TabPage's.

Tabulatorreihenfolge

Kann in der IDE bequem mit Ansicht|Tabulatorreihenfolge eingesehen werden. Es erscheint bei jedem Steuerelement ein blaues Kästchen welches TabIndex angibt. Um die Tabulatorreihenfolge zu ändern kann man die Controls in der gewünschten Reihenfolge anklicken. Wird mit Control.TabIndex festgelegt.

Testfall

Nach logischen Kriterien werden Eingaben für einen Einheitentest auf einige repräsentative Beispiele festgelegt. Diese Beispiele sind je ein Testfall.

Dabei muss jede Codezeile getestet werden. Bei Methoden mit Entscheidungsstrukturen braucht man also Testfälle für jeden möglichen Weg.

Es sind folgende Daten zu testen:

Normale Daten:
Die Methode wird mit Daten innerhalb des zulässigen Bereichs getestet

Grenzbedingungen:
Dazu gehören Testfälle mit Mindest- und Höchstwert des gültigen Bereichs, aber auch Daten die um 1 davon abweichen. Beispielsweise um auf die fälschliche Verwendung von < statt <= zu testen.

Unzulässige Daten:
Diese Testfälle prüfen, ob ein Programm bei ungültigen Daten nicht abstürzt, oder nicht normal weiterläuft und falsche Ausgaben liefert.

Datenkombinationen:
Ausserdem sollten Kombinationen der zuvor erwähnten Datenarten abgedeckt werden. Gewisse Fehler treten nur auf, wenn eine entsprechende Datenkombination auftritt.

TextBox (Klasse)

Namespace: System.Windwos.Forms.

Tlbimp.exe

Type Library Importer Tool. Es konvertiert Typdefinitionen einer COM-Bibliothek in entsprechende Typdefinitionen einer CLR-Assembly. Die Ausgabe ist eine Assembly.

TODO:

Durch // TODO: <Aufgabentext> lassen sich Aufgaben erstellen, die in der Aufgabenliste erscheinen. Erscheinen die TODO:-Kommentare nicht im Aufgabenfenster, muss man dies im Kontextmenü einstellen.

ToolTip (Klasse)

Namespace: System.Windows.Forms. Normalerweise teilen sich mehrere Steuerelemente eine Instanz von ToolTip. Fügt man einem Formular ein ToolTip hinzu, heisst diese toolTip1 und es erscheint im Eigenschaftenfenster eine neue Eigenschaft "ToolTip auf toolTip1" welche man auf den ToolTip-Text für dieses Steuerelement setzen kann.

Dynamisch kann man den ToolTip-Text für ein Steuerelement folgendermassen setzen:

this.toolTip1.SetToolTip(this.textBox1, "Schreib in mich!");

Der erste Parameter ist also das Steuerelement, der zweite der ToolTip-Text.

Trace (Klasse)

Namespace: System.Diagnostics. Erlaubt das Protokollieren von Ereignissen auch wenn die Anwendung nicht im Debug-Modus läuft. Sämtliche Member von Trace sind statisch und kommen auch in der Klasse Debug vor.

Beispiel: Ausgaben von Trace in eine Textdatei schreiben

FileStream logStream = new FileStream(@"C:\log.txt"); // sollte wieder geschlossen werden

TextWriterTraceListener traceListener = new TextWriterTraceListener(logStream);

Trace.Listeners.Add(traceListener);

Trace.AutoFlush = true; // spart Aufruf von Flush() nach jedem Log-Eintrag

/* Trace-Schalter erzeugen, "BoolSwitch" ist der name aus der .config-Datei. */

BooleanSwitch myBooleanSwitch = new BooleanSwitch("BoolSwitch", "Beschreibung");

/* Eine Log-Information schreiben */

// 1. Parameter muss vom Typ bool und true sein

Trace.WriteLineIf(myBooleanSwitch.Enabled, "Log-Information"); 

Die .config-Datei:

<?xml version="1.0" encoding="utf-8" ?>

	<configuration>

		<system.diagnostics>

			<switches>

				<!-- Jeder Wert != 0 bedeutet dass der Schalter on ist -->

				<add name="BoolSwitch" value="1" />

			</switches>

		</system.diagnostics>

	</configuration>

Die .config-Datei muss gleich wie der .exe-File (also z.B. "WindowsApplication1.exe.config") heissen und im gleichen Verzeichnis wie der .exe-File liegen. Die .config-Datei ermöglicht, Trace-Schalter auch nach dem Compilieren ein- und auszuschalten.

TraceListener

Namespace: System.Diagnostics. Abstrakte Basisklasse für alle TraceListeners; es gibt folgende Implementationen:

TraceListeners müssen mit Debug.Listerners.Add() oder Trace.Listeners.Add() der Listeners-Auflistung hinzugefügt werden. ACHTUNG: Debug und Trace verwenden die gleiche Listeners-Auflistung!

TraceSwitch

Namespace: System.Diagnostics. Ermöglicht Trace-Messages via Konfigurationsdatei zu steuern.

Transaktionen

Eine Transaktion ist eine zusammenhängende Anzahl Datenbankoperationen die als Einheit ausgeführt werden. Entweder haben alle Erfolg oder es werde alle rückgängig gemacht.

Eine Transaktion leitet man ein, indem man die Methode BeginTransaction eines Connection-Objekts aufruft. Sie gibt einen Verweis auf ein Transaction-Objekt zurück. Danach wird dieses Objekt der Transaction-Eigenschaft jedes beteiligten Befehls (Commands) zugewiesen. Nach dem Ausführen dieser Befehle kann mit Transaction.Commit() die Transaktion bestätigt oder mit Transaction.Rollback()rückgängig gemacht werden.

Beispiel:

try {

  myTransaction = myConnection.BeginTransaction();

  myCommand1.Transaction = myTransaction;

  myCommand2.Transaction = myTransaction;

  myCommand1.ExecuteNonQuery();

  myCommand2.ExecuteNonQuery();

  myTransaction.Commit(); // Transaktion bestätigen falls keine Exception

}

catch (Exception ex) {

  myTransaction.Rollback(); // Transaktion rückgängig falls Exception

}

finally {

  myConnection.Close(); // Auf jeden Fall: Verbindung schliessen

}

Transaktionen sind nur möglich, wenn die Datenquelle Transaktionen unterstützt.

Transaktionen können auch mit DataAdaptern verwendet werden. Das Transaction-Objekt muss der Eigenschaft Transaction von InsertCommand, UpdateCommand und DeleteCommand jedes beteiligten DataAdapters zugewiesen werden. Nach dem Aufruf von Update() sämtlicher beteiligter DataAdapters kann man Commit() oder Rollback() des Transaction-Objekts aufrufen.

TreeNode (Klasse)

Namespace: System.Windows.Forms. Die Einträge einer TreeView.

TreeView (Klasse)

Namespace: System.Windows.Forms. Die Einträge einer TreeView sind vom Typ TreeNode.

Type (abstrakte Klasse)

Namespace: System.

Typecasting

Implizites Typecasting wird automatisch vorgenommen, wenn kein Präzisionsverlust auftreten kann, beispielsweise wenn man eine int-Variable einer long-Variable zuweist oder einer Methode welche einen double-Parameter erwartet eine int-Variable übergibt.

Typen

Die .NET-Sprachen sind streng typisiert, dies bedeutet dass bei Zuweisungen und Parameterübergaben die Typ-Konformität beachtet werden muss. Alle .NET-Typen sind von object abgeleitet, weshalb sie mindestens über die folgenden Methoden verfügen:

• Equals()
• GetHashCode()
• GetType()
• ToString()

Siehe auch: Boxing

typeof (Operator / Schlüsselwort)

typeof(myObject) liefert für myObject eine Instanz der Klasse System.Type zurück.

Typzugriffsmodifizierer

Zugriffsmodifizierer von Klassen und Strukturen. Als public deklarierte Typen können von jedem Objekt der betreffenden Anwendung instanziiert werden. private und protected können nur für verschachtelte Typen eingesetzt werden, sie können nur von Klassen mit demselben Typ oder einem darin verschachtelten Typ instanziiert werden. Klassen und Strukturen die ohne Zugriffsmodifizierer definiert werden sind implizit public.

Überladen

Von Überladen spricht man, wenn eine Klasse mehrere Methoden gleichen Namens hat. Die überladenen Methoden müssen sich in ihrer Signatur unterscheiden. Rückgabetyp und Zugriffsebene können gleich oder verschieden sein.

Überschreiben

Beim Überschreiben wird ein Member welches in der Basisklasse mit virtual deklariert ist in der abgeleiteten Klasse neu definiert und mit dem Schlüsselwort override versehen. Der Typ des Objekts entscheidet, welche Methode ausgeführt wird. Siehe auch Verbergen.

Unterbrechungsmodus

Im Unterbrechungsmodus wird die Ausführung angehalten und man kann den Code zeilenweise ausführen, Werte von Variablen und den Code mit Debugtools aus dem Menü Debug untersuchen.

using (Schlüsselwort)

Ermöglicht das "importieren" von Namensräumen. Somit kann man den Namensraum vor einem Typ weglassen. Die using-Direktive muss vor allen anderen Namespaceelementen wie Klassen oder Strukturen stehen. Existieren in den importierten Namespaces gleichnamige Typen, müssen jedoch wieder die vollen Namen verwendet werden. Diese lassen sich glücklicherweise mit einem Alias abkürzen.

Beispiel, Definition eines Aliases: using frms = System.Windows.Forms;

Variable

C# definiert sieben Kategorien von Variablen: statische Variablen, Instanzvariablen, Array-Elemente, Werteparameter, Verweisparameter, Ausgabeparameter und lokale Variablen.

Verbergen

Beim Verbergen ersetzt man die vorhandene Implementierung in der Basisklasse durch eine neue. Die neue Implementierung muss die selbe Signatur haben, kann aber eine andere Zugriffsebene und einen anderen Rückgabetyp aufweisen. Das verbergende Member (in der abgeleiteten Klasse) muss mit dem Schlüsselwort new eingeleitet werden. Bei verborgenen Membern entscheidet der Typ der Referenz, welche Version ausgeführt wird. Es ist auch möglich, in der Oberklasse mit virtual deklarierte Methoden zu verbergen. Siehe auch Überschreiben.

Verschachtelte Typen

Typen die innerhalb eines anderen Typs definiert werden. Eignen sich besonders, wenn ein Objekt mehrere Instanzen eines anderen Typs beinhaltet und diese nur innerhalb dieses Objekts vorkommen. Definiert man einen verschachtelten Typ jedoch mit public, ist es auch für andere Objekte möglich diesen Typ zu instanziieren. Siehe auch Typzugriffsmodifizierer.

Verweisparameter

Ein mit dem Modifizierer ref deklarierter Parameter.

Verweistypen

Variablen von Verweistypen speichern die Adresse eines Objekts, dieses befindet sich auf dem Heap. Die Variable selbst (also die Referenz) liegt jedoch auch auf dem Stack. Die Verweistypen unterteilen sich in Klassentypen, Interface-Typen, Array-Typen und Delegate-Typen. Siehe auch Werttyp.

virtual (Keyword)

Mit virtual deklarierte Methoden können in abgeleiteten Klassen überschrieben werden. Siehe auch Überschreiben.

Visual Studio .NET

Enthält Programmiersprachen wie Visual Basic .NET, C# und Visual C++ sowie die Skriptsprache JScript. Desweiteren gibt es von Fremdherstellern Compiler für Fortran .NET, Cobol .NET, Perl .NET andere Sprachen.

Werttypen

Eine Variable eines Werttyps speichert direkt den Wert, welcher sich auf dem Stack befindet.

Deklaration: int myInteger;

Zuweisung/Initialisierung: myInteger = 17;

Deklaration und Initialisierung können auch zu int myInteger = 17; zusammengefasst werden (ohne Performanceeinbusse).

Windows API

Die Funktion Beep der Windows API kann wie folgt verfügbar gemacht werden:

[System.Runtime.InteropServices.DllImport("kernel32")]

private static extern int Beep(int dwFreq, int dwDuration);

Hiermit steht die Methode Beep in der betreffenden Klasse zur Verfügung.

WindowsIdentity (Klasse)

Namespace: System.Security.Principal. Stellt einen Windows-Benutzer dar.

WindowsPrincipal (Klasse)

Namespace: System.Security.Principal. Implementiert IPrincipal. Ermöglicht, die Mitgliedschaft eines Windows Benutzers in einer Gruppe zu prüfen. Der Principal des aktuellen Threads kann mit Thread.CurrentPrincipal beschafft werden.

Beispiel:
WindowsPrincipal myPrincipal;
myPrincipal = (WindowsPrincipal)System.Threading.Thread.CurrentPrincipal;
WindowsIdentity myItentity;
myItentity = (WindowsIdentity)myPrincipal.Identity;

XCOPY

Kann in einfachen Fällen zur Installation einer Anwendung verwendet werden.

Syntax:
XCOPY <Quellverzeichnis> <Zielverzeichnis> /s
/s gibt an, dass auch die Unterverzeichnisse kopiert werden sollen.

XmlAttribute (System.Xml)

Repräsentiert ein Attribut.

XmlDataDocument (Klasse)

Namespace: System.Xml. Arbeitet eng mit der Klasse DataSet zusammen. Ein XmlDataDocument ist eine Arbeitsspeicherdarstellung von XML-Daten und kann als Quelle für XSLT (Extensible Style Sheet Transformations) verwendet werden.

Zu jedem XmlDataDocument gehört ein DataSet. Es existiert ein Konstruktor, welcher ein DataSet als Parameter übernimmt. Die Daten und das Schema des DataSets werden in das XmlDataDocument übernommen. Eine Änderung des einen wird vom anderen automatisch übernommen.

XmlDocument (Klasse)

Namespace: System.Xml. Repräsentiert einen XML-File mit XML-DOM. Es wird jeweils das ganze XML-Dokument geladen und die entsprechenden Objekte erzeugt. Daher kann diese Methode bei grossen Dokumenten zu Performance- und Ressourcenproblemen führen.

XmlNodeReader (Klasse)

Namespace: System.Xml. Abgeleitet von der abstrakten Klasse XmlReader. Bietet schnellen Vorwärtszugriff auf XML-Daten.

XmlTextReader (System.Xml)

Bietet mit XmlTextWriter zusammen einen Stream-basierten Zugriff auf XML-Dokumente, was auch bei grossen Dokumenten nicht zu Performance- oder Ressourcenproblemen führt.

XmlTextWriter (System.Xml)