Syntax von C-Sharp

Glossar
· Hauptseite · Zufälliger Artikel · Portal liste
Diskussion
· Diskussion : Syntax von C-Sharp
Webkatalog
· Übersicht · Eigene Artikel · Seite vorschlagen
Aktuelles
· Seite der Woche · Newsletter · Today in History · Kreuzworträtsel
Weitere Inhalte
· Einkaufsmeile · Begriffslexikon · Multimedia
Suche
· Geschi.de · nach Jahren · Weltchronik.de · Geschichtsreferate
Interna
· Seitenneuigkeiten · Hilfe zur Seite · Impressum

Jahres-Sprung
Jahreszahl eingeben: >Chronik2000-Homepage<

Syntax von C-Sharp

Stichpunkte

Allgemein
	foreach) 1.4 Die Sprungbefehle break
	continue
	set und value) 1.9.4 Darstellung spezieller Zeichen oder Zeichenfolgen 1.10 Vererbung 1.10.1 Schnittstellen 1.10.2 Das SchlÃ¼sselwort base 1.10.3 Versiegelte Klassen 1.11 Typumwandlungen 1.12 Assemblies 1.13 Attribute (Metadaten) 1.14 Kommentare und Dokumentation 2 VerfÃ¼gbare Klassenbibliotheken [Bearbeiten]
	while
	Eigenschaften und Konstanten 1.9.1 Datentypen und Speicherbedarf 1.9.2 Konstanten (SchlÃ¼sselwort const) 1.9.3 Eigenschaften (SchlÃ¼sselwÃ¶rter get
	Dieser Artikel geht auf die Sprachelemente von C# ein. Inhaltsverzeichnis showTocToggle("Anzeigen"
	"Verbergen") 1 Sprachelemente 1.1 SchlÃ¼sselwÃ¶rter 1.2 Bedingte AusfÃ¼hrung (if
	do
	else) 1.3 Schleifen (for
	goto und return 1.5 Objekte und Klassen 1.5.1 Die Klasse namens "object" 1.6 Strukturen (struct) 1.7 AufzÃ¤hlungen (Enumerationen) 1.7.1 Flags 1.8 Zugriffsmodifikatoren 1.9 Datentypen
Sprachelemente
	[Bearbeiten]
SchlÃ¼sselwÃ¶rter
	abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual volatile void while [Bearbeiten]
Bedingte AusfÃ¼hrung (if, else)
	if (Bedingung) { Anweisungen; } [else if (Bedingung) { Anweisungen; }] [else { Anweisungen; }] [Bearbeiten]
Schleifen (for, do, while, foreach)
	for (Startausdruck; GÃ¼ltigkeitsbedingung; Inkrementierungsausdruck) { Anweisungen; } Die Bedingung der While-Schleife wird immer vor dem Anweisungsblock ausgefÃ¼hrt
	Wenn die Bedingung von Anfang an nicht erfÃ¼llt ist
	wird die Schleife also nicht durchlaufen. while (Bedingung) { Anweisungen; } Die Bedingung der Do-While-Schleife wird immer nach dem Anweisungsblock ausgefÃ¼hrt
	Die Schleife wird daher mindestens ein mal durchlaufen. do { Anweisungen; } while (Bedingung); Mit der foreach-Schleife wird durch alle Mitglieder einer Collection iteriert
	In der Schleife besteht nur lesender Zugriff auf die Variable. foreach(Datentyp Variablename in Collection) { Anweisungen; } [Bearbeiten]
Die Sprungbefehle break, continue, goto und return
	for (int i = 0; i < 10; ++i) { if (i < 8) continue; Console.WriteLine("Continue wurde nicht ausgefÃ¼hrt."); } Mit dem Befehl continue wird der nÃ¤chste Durchlauf einer Schleife veranlasst. (Dabei wird der restliche Code in der Schleife nach dem continue Befehl Ã¼bersprungen
	Im Beispiel wird der Text nur 2 mal ausgegeben. for (int i = 0; i < 100; ++i) { if (i == 5) break; Console.WriteLine(i); } Der Befehl break veranlasst das Programm
	die nÃ¤chste umschlieÃŸende Schleife (oder switch) zu verlassen
	2
	In diesem Beispiel werden nur die Zahlen 0
	1
	3 und 4 ausgegeben. int a = 1; Top: if (a == 5) ++a; goto Top; Console.WriteLine("Ende des Programs") Mit goto springt das Programm an die angegebene Markierung. int result = ImQuadrat(2); static int ImQuadrat(int x) { int a; a = x*x; return a; } Mit return wird die aktuelle Methode verlassen und der im Kopf der Methode vereinbarte Referenz- bzw
	Datentyp als RÃ¼ckgabewert zurÃ¼ckgeliefert
	Methoden ohne RÃ¼ckgabewert werden mit dem SchlÃ¼sselwort void gekennzeichnet. [Bearbeiten]
Objekte und Klassen
	Wenn man von einem Objekt spricht
	handelt es sich dabei in der Umgangssprache normalerweise um ein reales Objekt oder einen Gegenstand des tÃ¤glichen Lebens
	Beispielsweise kann das ein Tier
	ein Fahrzeug
	ein Konto oder Ã¤hnliches sein
	Jedes Objekt kann durch verschiedene Attribute beschrieben werden und verschiedene ZustÃ¤nde annehmen und diese auch auslÃ¶sen. Ãœbertragen auf die objektorierentierte Programmierung und C# ist ein Objekt die Instanz (siehe SchlÃ¼sselwort new) einer Klasse
	Eine Klasse kann man dabei als Bauplan oder GerÃ¼st eines Objektes ansehen
	Eine Klasse besitzt Eigenschaften (Variablen) bzw
	die die Folge von ZustÃ¤nden sind bzw. diese auslÃ¶sen. Klasse Attribut(e) Methode(n) Ereignis(se) [Bearbeiten]
	Attribute
	Methoden (die ZustÃ¤nde/TÃ¤tigkeiten darstellen) und Ereignisse
Die Klasse namens "object"
	von dem jede Klasse abgeleitet wird
	Die Klasse object ist ein Referenztyp
	So kann durch explizite Typumwandlung jeder Objekttyp in object umgewandelt werden
	Im Unterschied zu anderen Sprachen unterscheidet C# nicht zwischen elementaren Datentypen und Referenztypen
	Auch bei elementaren Datentypen handelt es sich in C# um Referenztypen
	die von object abgeleitet werden. [Bearbeiten]
*Strukturen (struct)*
	Strukturen sind bereits als Sprachmittel aus Sprachen wie C++ oder Delphi (Records) bekannt
	Sie dienen primÃ¤r zur Erstellung eigener komplexer Datenstrukturen oder eigener Datentypen
	double z) { this.x = x; this.y = y; this.z = z; } public override string ToString() { return(string.Format("x: {0}
	x
	z: {2}"
	durch eine Datenstruktur Koordinate abgebildet werden
	y
	einer Y- und einer Z-Position
	double y
	die sich aus drei Gleitkommazahlen einfacher oder doppelter Genauigkeit zusammensetzt. public struct Koordinate { public double x; public double y; public double z; public Koordinate(double x
	y: {1}
	bestehend aus einer X-
	So kann zum Beispiel eine Raumkoordinate
	z)); } } C# fasst eine Ã¼ber das SchlÃ¼sselwort struct definierte Struktur als einen Wertetyp auf â€“ anders als beispielsweise C++
	Konstruktoren und andere Elemente von Klassen aufweisen; sie kÃ¶nnen aber nicht beerbt werden
	Eigenschaften
	Strukturen in C# kÃ¶nnen auÃŸerdem Methoden
	Der Unterschied einer Struktur im Vergleich zu einer Klasse besteht in ihrer ReprÃ¤sentation im Speicher
	wie es beim Objekt einer Klasse erforderlich ist (Referenztyp)
	Da keine zusÃ¤tzlichen Speicherreferenzen benÃ¶tigt werden
	kÃ¶nnen Strukturen wesentlich ressourcenschonender eingesetzt werden
	So basieren beispielsweise alle Datentypen in C# auf Strukturen. [Bearbeiten]
AufzÃ¤hlungen (Enumerationen)
	AufzÃ¤hlungen dienen zur automatischen Nummerierung der in der AufzÃ¤hlung enthaltenen Elemente
	Die Syntax fÃ¼r die Definition von AufzÃ¤hlungen verwendet das SchlÃ¼sselwort enum (AbkÃ¼rzung fÃ¼r Enumeration)
	dass ein optionaler ganzzahliger Datentyp fÃ¼r die Nummerierung der Elemente angegeben werden kann
	mit der Ausnahme
	Der in C# verwendete AufzÃ¤hlungstyp Ã¤hnelt dem in C++
	AufzÃ¤hlungstypen durch finalisierte statische Attribute in Klassen oder Schnittstellen nachgebildet (ab Java 1.5 sind sie aber auch ein Bestandteil der Sprache Java). public enum Woche { Montag = 1
	Donnerstag
	im Unterschied zur Sprache C#
	Mittwoch
	Samstag
	Sonntag } Die Elementnummerierung in C# beginnt bei 0
	Dienstag
	Freitag
	Ohne Angabe eines Datentyps wird int verwendet. In Java werden
	jedem Element â€“ oder nur dem ersten Element â€“ einen eigenen Startwert zuzuweisen (wie im obigen Beispiel)
	Es ist aber auch mÃ¶glich
	wie in C++
	Dabei kÃ¶nnen sich die Anfangswerte wiederholen
	Die ZÃ¤hlung beginnt dann jeweils von neuem bei dem definierten Startwert und Element
	In C# ist es auch mÃ¶glich
	ein bestimmtes Element einer Enumeration Ã¼ber seine Ordinalzahl anzusprechen
	Hierzu ist aber eine explizite Typumwandlung notwendig. Woche Tag = Woche.Mittwoch; System.Console.WriteLine(Tag); // Ausgabe: Mittwoch System.Console.WriteLine((int)Tag); // Ausgabe: 3 System.Console.WriteLine((Woche)3); // Ausgabe: Mittwoch [Bearbeiten]
Flags
	Neben der beschriebenen Variante des enum-AufzÃ¤hlungstyps existiert noch eine spezielle Variante von Enumeration
	Flags definieren Enumerationen auf Bitebene und werden durch die Metainformation [Flags] vor der Enum-Deklaration definiert
	Flag-Elemente kÃ¶nnen auf Bitebene verknÃ¼pft werden. [Bearbeiten]
Zugriffsmodifikatoren
	Variablen
	Felder und Ereignisse) in C#
	Eigenschaften
	Zugriffsmodifikatoren regeln den Zugriff auf Klassen und deren Mitglieder (Methoden
	Die folgende Tabelle fÃ¼hrt die von C# unterstÃ¼tzten Zugriffsmodifikatoren auf und beschreibt deren Wirkung und den Sichtbarkeitskontext. Name Wirkung internal internal beschrÃ¤nkt den Zugriff auf Klassen und deren Mitglieder auf eine Assembly
	andernfalls ist der Zugriff auf den aktuellen Namensraum und dessen Mitglieder beschrÃ¤nkt (unter Java entspricht das der BeschrÃ¤nkung auf ein package). private BeschrÃ¤nkt den Zugriff auf eine Klasse und deren Mitglieder
	Im einfachsten Falle ist das die aktuelle Klasse (sofern kein Namensraum (namespace) definiert wurde)
	oder die statische Funktion Main
	Eine mit private deklarierte Klasse kann nur innerhalb der Klasse selbst instanziert werden (beispielsweise kann ein Ã¶ffentlicher Konstruktor einer Klasse
	der nicht von auÃŸen aufgerufen werden kann). Oft wird private verwendet
	um das Singelton-Muster umzusetzen (z.B. bei der Verwendung einer Klasse als Fabrik; siehe Fabrikmuster) oder die Vererbung zu beeinflussen oder zu verbieten (siehe auch SchlÃ¼sselwort sealed)
	einen privaten Konstruktor aufrufen
	Hinweis: Eine abgeleitetet Klasse kann auf private Mitglieder der Basisklasse (vgl
	SchlÃ¼sselwort base) ebenfalls nicht zugreifen
	bis auf einen Unterschied
	Soll ein solcher Zugriff mÃ¶glich sein
	so muss der Zugriffsmodifizierer protected verwendet werden. protected Dieser Modifikator ist mit dem Modifikator private identisch
	kÃ¶nnen auch abgeleitete Klassen auf die Mitglieder einer Basisklasse (vgl
	Sofern die Klasse nicht mit dem SchlÃ¼sselwort sealed gegen das Beerben "versiegelt" wurde
	SchlÃ¼sselwort base) zugreifen oder diese Ã¼berschreiben
	Ansonsten ist die Sichtbarkeit auf die Klasse selbst beschrÃ¤nkt. public Auf als public gekennzeichnete Klasse oder Klassenmitglieder (z.B
	kann unbeschrÃ¤nkt zugegriffen werden
	Methoden oder Eigenschaften)
	Sie werden deshalb auch als "Ã¶ffentlich" bezeichnet
	automatisch als private deklariert
	muss immer als public deklariert werden
	Eine Klasse die eine statische Funktion Main enthÃ¤lt oder sonstige statische Methoden
	da sonst kein Zugriff mÃ¶glich ist und es zu einem Fehler kommt. Hinweise: Per Voreinstellung sind Klassenmitglieder (Methoden
	denen kein Zugriffsmodifikator zugewiesen wurde
	Eigenschaften usw.)
	Klassen selbst dagegen besitzen automatisch den Modifikator internal und sind nur im aktuellen Namensraum (namespace) sichtbar
	Wurde kein Namensraum zugewiesen
	so gilt der so genannte globale Deklarationsraum als Standardnamensraum. Die Modifikatoren kÃ¶nnen bis auf protected und internal nicht miteinander kombiniert werden. protected internal spielt im Zusammenhang mit der Vererbung von Komponenten eine Rolle
	Die Sichtbarkeit der Basisklasse wird von der abgeleiteten Klasse Ã¼bernommen. Schnittstellen sind immer Ã¶ffentlich definiert
	Die Zuordnung eines Zugriffsmodifikators (mit Ausnahme von public) ist nicht zulÃ¤ssig. [Bearbeiten]
Datentypen, Eigenschaften und Konstanten
	C# kennt zwei Arten von Datentypen: Wertetypen und Referenztypen
	wie sie u.a. aus der Sprache C++ bekannt sind
	Referenztypen dÃ¼rfen dabei nicht mit Zeigern gleichgesetzt werden
	Diese werden von C# auch unterstÃ¼tzt
	aber nur im "unsicheren Modus" (engl. unsafe mode)
	wobei Referenztypen im Gegensatz dazu nur Verweise auf die eigentlichen Daten
	oder besser
	Wertetypen enthalten die Daten direkt
	Objekte darstellen
	Beim Lesen und Schreiben von Wertetypen werden die Daten dagegen Ã¼ber einen Automatimus
	Autoboxing genannt
	in einer Instanz der jeweiligen HÃ¼llenklasse (engl. wrapper) gespeichert oder aus ihr geladen
	Die Zuweisung eines Wertes bzw. einer Referenz kann wÃ¤hrend der Deklaration erfolgen oder spÃ¤ter
	sofern die Variable nicht als Konstante deklariert wurde
	k; i = j = k = 123; Einen Sonderfall der Zuweisung stellt die Deklaration von Feldern (Arrays) dar
	...; int i
	k = 3; System.Collections.IList liste = new System.Collections.ArrayList(); Auch die Mehrfachzuweisung eines Wertes an verschiedene Variablen ist mÃ¶glich: int i
	j
	j
	Die Deklaration erfolgt durch Angabe eines Datentyps gefolgt von einem Variablennamen: // Datentyp Variable; int i; System.Collections.IList liste; Es kÃ¶nnen auch mehrere Variablen des gleichen Typs zeitgleich deklariert werden: // Datentyp Variable1
	der Variablen bei der Deklaration auch gleich einen Wert oder eine Referenz zuzuweisen (Initialwert): // Datentyp Variable=Wert/Referenz; int i = 5; int j = 2
	k; System.Collections.IList liste1
	Variable2
	liste2; Ferner besteht die MÃ¶glichkeit
	NÃ¤heres hierzu im entsprechenden Abschnitt. [Bearbeiten]
Datentypen und Speicherbedarf
	Datentyp Bit Vorz. HÃ¼llenklasse (struct type) bool 1 - System.Boolean byte 8 J System.Byte char 16 - System.Char decimal 128 - System.Decimal double 64 - System.Double float 32 - System.Single int 32 J System.Int32 long 64 J System.Int64 sbyte 8 J System.SByte short 16 J System.Int16 uint 32 N System.UInt32 ulong 64 N System.UInt64 ushort 16 N System.UInt16 Datentypen sind in C# nicht elementar
	sondern objektbasiert
	Jeder der in der Tabelle aufgefÃ¼hrten Datentypen stellt einen Alias auf eine Klasse des Namensraumes System dar
	Beispielsweise wird der Datentyp bool durch die Klasse System.Boolean abgebildet
	Man spricht dabei auch von einer HÃ¼llenklasse (engl. wrapper class)
	Methoden auf Datentypen anzuwenden
	und anders als bei Java
	Durch die Objektbasiertheit ist es mÃ¶glich
	die die entsprechende HÃ¼llenklasse bereitstellt: 1234.ToString();int i = 17;i.ToString(); Vergleichbar mit C++
	gibt es unter C# vorzeichenbehaftete und vorzeichenlose Datentypen
	ushort
	uint
	Diese werden durch Voranstellen des Buchstabens s (fÃ¼r signed
	ulong
	englisch fÃ¼r vorzeichenlos) gekennzeichnet (sbyte
	englisch fÃ¼r vorzeichenbehaftet) und durch Voranstellen des Buchstabens u (fÃ¼r unsigned
	mit Ausnahme von short)
	Die FlieÃŸkomma- bzw
	double
	Gleitkomma-Datentypen (float
	decimal) kÃ¶nnen neben einfacher auch doppelte Genauigkeit aufweisen und haben einen variierenden Speicherbedarf
	Dadurch Ã¤ndert sich die Genauigkeit
	was in der Anzahl der mÃ¶glichen Nachkommastellen zum Ausdruck kommt. [Bearbeiten]
*Konstanten (SchlÃ¼sselwort const)*
	Einem mit const deklarierten "Objekt" kann nach der Deklaration und Initialisierung kein neuer Inhalt zugewiesen werden
	von welchem der Compiler feststellen kann ob er auch konstant ist
	Das "Objekt" wird dadurch zu einer Konstanten. Eine Konstante kann dabei nur ein von einem Typ sein
	Dies geht bei allen Grunddatentypen die der Compiler versteht
	sowie allen Enums
	Bei allen anderen Wertdatentypen (Structs) sowie Referenzetypen ist eine Deklaration einer Variablen als const<code> nicht mÃ¶glich
	Grund dafÃ¼r ist
	dass der Compiler alle Verwendungen zum Zeitpunkt des Kompelieren ersetzt
	Bei Referenzedatentypen mÃ¼sste er dort bereits die Speicheraddresse zur Laufzeit wissen
	fm); //Daten Lesen fs.Read(readBuffer
	Strukturen kÃ¶nnten ebenfalls nicht konstant sein
	welche die Zugriffart auf eine Datei beschreibt (Enum) const FileMode fa = FileMode.Open; //Es wird eine Konstante festgelegt
	da sie in einem Konstruktor einen Zufallsgenerator benutzen kÃ¶nnten. Fehlerhafte Zuweisungen einer Konstanten werden mit dem Kompilerfehler CS0133 vom C-Sharpkompiler moniert. <code> using System; using System.IO; public class ConstBeispiel { public static void Main() { //Es wird eine Konstante fÃ¼r die LÃ¤nge eines Arrays angelegt const int arrayLength = 1024; //Es wird eine Konstante festgelegt
	welcher der C# Kompiler nicht kennt const TimeSpan zeitSpanne = new TimeSpan(10); } } Konstanten gibt es auch in anderen Sprachen (z.B
	welche den Namen der zu Ã¶ffnende Datei festlegt const string fileName = "beispiel.txt"; //Buffer erstellen byte[] readBuffer = new byte[arrayLength]; //Stream zur Datei Ã¶ffnen Filestream fs = new FileStream(fileName
	nicht konstant const IList liste = new ArrayList(); // FEHLER: IList wird ein Struct zugewiesen
	readBuffer.Length); //Stream schliesen fs.Close(); //Daten ggf. bearbeiten. ... // FEHLER: IList wird ein Referenzdatentyp zugewiesen
	0
	Java)
	C++
	In Java werden Konstanten durch das SchlÃ¼sselwort final gekennzeichnet
	in Fortran durch PARAMETER. [Bearbeiten]
*Eigenschaften (SchlÃ¼sselwÃ¶rter get, set* und value)**
	Eine Eigenschaft (property) ist eine Sicht auf eine Ã¶ffentliche Variable einer Klasse
	Die Variable selbst wird durch einen Zugriffsmodifizierer wie private oder protected (bei Variablen
	die in abgeleiteten Klassen Ã¼berschreiben werden sollen) fÃ¼r den Zugriff von auÃŸen gesperrt und Ã¼ber eine Eigenschaft zugÃ¤nglich gemacht. Ãœber die Eigenschaft kann dann bestimmt werden
	ob ein lesender oder schreibender Zugriff auf die referenzierte Variable erfolgen darf
	Beide MÃ¶glichkeiten sind auch miteinander kombinierbar
	Eine Eigenschaft wird durch Zuweisung eines Datentyps (der dem Datentyp der Variable entsprechen muss) zu einem Eigenschaftsnamen angelegt und hat eine Ã¤hnliche Struktur wie die Syntax einer Methode
	Die Eigenschaft ist dabei wie eine Variable ansprechbar und ihr kann auch ein Zugriffsmodifizierer zugewiesen werden
	sondern bildet diese auf die referenzierte Variable ab (vergleichbar mit einem Zeiger)
	Eine Eigenschaft enthÃ¤lt selbst keine Daten
	Zur Abfrage einer Eigenschaft existiert in C# das SchlÃ¼sselwort get und zum Setzen eines Wertes das SchlÃ¼sselwort set
	Von auÃŸen stellt sich die Eigenschaft dann wie eine Variable dar und der Zugriff kann entsprechend erfolgen (vgl
	VisualBasic)
	Die Programmiersprache Java verfolgt mit den Set- und Get-Methoden (Bean-Pattern
	sondern Ã¼ber die entsprechende Methode
	Introspection) das gleiche Ziel - alle Zugriffe erfolgen nie direkt Ã¼ber eine Variable
	Beispiel einer Eigenschaftsdefinition Wohnort fÃ¼r eine private Variable (_wohnort): public class EigenschaftBeispiel { private string _wohnort; public string Wohnort { get { return _wohnort; } set { _wohnort = "12345 " + value; } } } Durch das "Weglassen" des SchlÃ¼sselwortes set oder des SchlÃ¼sselwortes get kann gesteuert werden
	ob die Eigenschaft nur gelesen oder nur geschrieben werden darf
	der gesetzt werden soll
	Das SchlÃ¼sselwort value ist dabei ein Platzhalter fÃ¼r den der Eigenschaften zugewiesenen Wert
	Er kann nur in Verbindung mit dem SchlÃ¼sselwort set im entsprechenden Block verwendet werden (und entspricht in etwa einer temporÃ¤ren lokalen Variable)
	so wÃ¼rde der lesende Zugriff zu einem Zugriffsfehler fÃ¼hren (im Beispiel in der Zeile
	Beispiel fÃ¼r den Zugriff auf die oben definierte Eigenschaft Wohnort: EigenschaftBeispiel instanz = new EigenschaftBeispiel(); instanz.Wohnort = "Musterstadt"; Console.WriteLine(instanz.Wohnort); // Ausgabe: 12345 Musterstadt WÃ¼rde bei der obigen Definition der Eigenschaft 'Wohnort' der get-Block weggelassen
	in der die Ausgabe erfolgt)
	bevor er der Variablen zugewiesen wird
	kÃ¶nnen im set-Block bzw. get-Block auch Operationen ausgefÃ¼hrt werden
	beispielsweise die Potenzierung eines bei set Ã¼bergebenen Wertes (value mal Exponent)
	Neben dem einfachen Setzen oder Lesen einer Eigenschaft
	Das gleiche gilt fÃ¼r das SchlÃ¼sselwort get
	Theoretisch kann somit ein Zugriff fÃ¼r den Benutzer einer Klasse ganz unerwartete Ergebnisse bringen
	Deshalb sollten alle Operationen
	die VerÃ¤nderungen auf einen Wert durchfÃ¼hren Ã¼ber normale Methoden abgebildet werden
	Ausgenommen sind natÃ¼rlich WertprÃ¼fungen bei set
	Das Beispiel konkateniert den der Eigenschaft Ã¼bergebenen Wert (hier: Musterstadt) zur Zeichenkette "12345 "
	sie sollte dennoch in einer Methode ausgefÃ¼hrt werden. [Bearbeiten]
	Diese Aktion ist syntaktisch und semantisch richtig
Darstellung spezieller Zeichen oder Zeichenfolgen
	vertikal 0x000B x Hexadezimale Zeichenfolge fÃ¼r ein einzelnes Unicode-Zeichen u Zeichenfolge fÃ¼r Unicode-Zeichen in Zeichenliteralen. U Zeichenfolge fÃ¼r Unicode-Zeichen in Zeichenketten-Literalen. Ein auf das Zeichen "" (umgekehrter SchrÃ¤gstrich
	Seq. Beschreibung Hexadezimal Einleitung alternativer Interpretation 0x001B ' Einfaches AnfÃ¼hrungszeichen 0x0007 " Doppeltes AnfÃ¼hrungszeichen 0x0022 \ Umgekehrter SchrÃ¤gstrich 0x005C Null 0x0000 a Signalton (engl. alarm) 0x0007 b RÃ¼ckschritt (engl. backspace) 0x0008 f Seitenvorschub (engl. form feed) 0x000C n Zeilenwechsel (engl. new line) 0x000A r WagenrÃ¼cklauf (engl. carriage return) 0x000D t Tabulator
	horizontal 0x0009 v Tabulator
	engl. backslash) folgendes Zeichen wird anders interpretiert als sonst
	Dabei handelt es sich meistens um nicht darstellbare Zeichen
	Soll der umgekehrte SchrÃ¤gstrich selbst dargestellt werden
	so muss er doppelt angegeben werden ("\")
	Hexadezimale Zeichenfolge als Platzhalter fÃ¼r ein einzelnes Unicode-Zeichen: Das Zeichen wird dabei aus dem Steuerzeichen x gefolgt von dem hexadezimalen Wert des Zeichens gebildet. Zeichenfolge fÃ¼r Unicode-Zeichen in Zeichenliteralen: Das Zeichen wird dabei aus dem Steuerzeichen u gefolgt von dem hexadezimalen Wert des Zeichens gebildet
	Der Wert muss zwischen U+0000 und U+FFFF liegen. Zeichenfolge fÃ¼r Unicode-Zeichen in Zeichenkettenliteralen: Das Zeichen wird dabei aus dem Steuerzeichen U gefolgt von dem hexadezimalen Wert des Zeichens gebildet
	Der Wert muss zwischen U+10000 und U+10FFFF liegen
	Hinweis: Unicode-Zeichen im Wertbereich zwischen U+10000 und U+10FFFF sind nur fÃ¼r Zeichenfolgen-Literale zulÃ¤ssig und werden als zwei Unicode-"Ersatzzeichen" kodiert bzw. interpretiert (s. a
	UTF-8). [Bearbeiten]
Vererbung
	[Bearbeiten]
Schnittstellen
	ihrer RÃ¼ckgabewerte sowie von mÃ¶glichen Ausnahmen. An dieser Stelle ein Anwendungsbeispiel fÃ¼r die Mehrfachvererbung: public class MyInt : IComparable
	ihrer Parameter
	Mehrfachvererbung wird in C# nur in Form von Schnittstellen (interface) unterstÃ¼tzt. Schnittstellen (engl. interfaces) dienen in C# zur Definition von Methoden
	IDisposable { // Implementierung } Schnittstellen in C# Ã¤hneln den Schnittstellen der Programmiersprache Java
	dÃ¼rfen Schnittstellen in C# keine Konstanten oder Konstruktoren enthalten und auch keine Zugriffsmodifizierer bei der Definition einer Methode vereinbaren. public interface A { void MethodeA(); } public interface B { void MethodeA(); void MethodeB(); } public class Klasse : A
	Anders als in Java
	muss jede in der Schnittstelle definierte (virtuelle) Methode implementieren
	die ein oder mehrere Schnittstellen einbindet
	B { void A.MethodeA() {Console.WriteLine("A.A");} // MethodeA aus Schnittstelle A void B.MethodeA() {Console.WriteLine("A.B");} // MethodeA aus Schnittstelle B public void MethodeA() {Console.WriteLine("A.C");} //MethodeA fÃ¼r Klasse public void MethodeB() {Console.WriteLine("B.B");} // MethodeB aus Schnittstelle B } Eine Klasse
	so muss die jeweilige Methode in der implementierenden Klassen durch das Voranstellen des Namens der Schnittstelle gekennzeichnet werden
	die Methoden mit dem gleichen Namen und der gleichen Struktur besitzen (d.h. gleiche Parametertypen
	Werden mehrere Schnittstellen eingebunden
	RÃ¼ckgabewerte usw.)
	Dabei wird die jeweilige Funktion nur dann aufgerufen
	wenn der Zeiger auf das Object vom entsprechenden Typ ist: public static void Main() { Klasse k = new Klasse(); (k as A).MethodeA(); (k as B).MethodeA(); k.MethodeA(); Console.ReadLine(); } Ausgabe: A.A A.B A.C Auch Schnittstellen ohne Methodendefinition sind mÃ¶glich
	Sie dienen dann als so genannte Markierungsschnittstellen (engl. marker interface)
	Das Einbinden einer Schnittstelle
	erfolgt analog zur Beerbung einer Klasse. [Bearbeiten]
	deren Klassenname oft mit einem I beginnt um sie als Interface zu kennzeichnen
Das SchlÃ¼sselwort base
	Das SchlÃ¼sselwort wird im Zusammenhang von Vererbung genutzt
	das fÃ¼r die Basisklasse
	vereinfacht gesagt
	Es ist
	was this fÃ¼r die aktuelle Klasse ist
	Nun folgt ein Beispiel
	das die Verwendung von base zeigt: public class Example : Basisklasse { private int myMember; public Example() : base(3) { myMember = 2; } } In diesem Beispiel wurde die Verwendung nur anhand des Basisklassenkonstruktors gezeigt
	Wie in der Einleitung beschrieben kann base auch fÃ¼r den Zugriff auf die Mitglieder der Basisklasse benutzt werden
	Die Verwendung erfolgt Ã¤quivalent zur Verwendung von this bei der aktuellen Klasse. [Bearbeiten]
Versiegelte Klassen
	Versiegelte Klassen sind Klassen
	von denen keine Ableitung mÃ¶glich ist und die folglich nicht als Basisklassen benutzt werden kÃ¶nnen
	Bekanntester Vertreter dieser Art von Klassen ist die Klasse String aus dem Namensraum System
	Der Modifizierer sealed kennzeichnet Klassen als versiegelt. [Bearbeiten]
Typumwandlungen
	In C# ist jeder Variablen ein Datentyp zugeordnet
	Manchmal ist es nÃ¶tig
	Typen von Variablen ineinander umzuwandeln
	Zu diesem Zweck gibt es Typumwandlungsoperationen
	Dabei gibt es implizite und explizite Typumwandlungen
	Eine implizite Typumwandlung erscheint nicht im Quelltext
	Sie wird vom Compiler automatisch in den erzeugten Maschinen-Code eingefÃ¼gt
	Voraussetzung dafÃ¼r ist
	dass zwischen Ursprungs- und Zieltyp eine implizierte Typumwandlungsoperation existiert
	FÃ¼r explizite Typumwandlungen sind in C# zwei Konstrukte vorgesehen: (Zieldatentyp) Variable_des_Ursprungsdatentyps Variable_des_Ursprungsdatentyps as Zieldatentyp WÃ¤hrend erstere Umwandlung im Fall einer ungÃ¼ltigen Typumwandlung eine Ausnahme auslÃ¶st
	wenn der Zieldatentyp ein Referenzdatentyp ist
	ist letztere nur mÃ¶glich
	Bei einer ungÃ¼ltigen Typumwandlung wird hier dem Ziel der Nullzeiger zugewiesen. using System.Collections; public class CastBeispiel { public static void Main() { long aLong = long.MaxValue; //Typumwandlung nach int
	aInt hat danach den Wert von int.MaxValue int aInt = (int) aLong; //Umwandlung nach object object aObject = aInt as object; //ungÃ¼lgtige Typumwandlung
	lÃ¶st zur Laufzeit eine InvalidCastException aus
	da aObject nicht vom Typ Liste ist. IList liste = (IList)aObject; //LÃ¶st den Compierfehler CS0077 aus
	liste2 erhÃ¤lt den Wert null IList liste2 = aObject as IList; //ungÃ¼ltige Typumwandlung
	da int kein Referenzetyp ist int aInt2 = aLong as int; } } Zu den Typumwandlungen gehÃ¶rt auch das so genannte "Boxing"
	Es bezeichnet die Umwandlung zwischen Wert- und Referenztypen
	Der Zieltyp wird wie bei der expliziten Konvertierung in Klammern vor den umzuwandelnden Typ geschrieben
	Erfolgt dies implizit
	so spricht man von "Autoboxing"
	Siehe auch: Explizite Typumwandlung [Bearbeiten]
Assemblies
	Siehe .net Assemblies [Bearbeiten]
Attribute (Metadaten)
	Strukturen oder Attribute anzugeben
	Attribute geben die MÃ¶glichkeit Daten fÃ¼r Funktionen
	Klassen
	Parameter
	fÃ¼r die Laufzeitumgebung oder Ã¼ber Reflexion wÃ¤hrend der Laufzeit ausgelesen werden
	Diese kÃ¶nnen Informationen fÃ¼r den Compiler enthalten
	In C# werden diese mit eckigen Klammern Ã¼ber dem Ziel angegeben
	Das STAThread-Attribut wird z.B. benÃ¶tigt wenn ein Programm COM InteropalitÃ¤t unterstÃ¼tzen soll. [STAThread()] public static void Main(string[] argumente) { //... } [Bearbeiten]
Kommentare und Dokumentation
	In C# sind
	C++ und Java
	wie in C
	sowohl Zeilen- als auch Blockkommentare mÃ¶glich
	Zeilenkommentare beginnen dabei mit zwei aufeinanderfolgenden SchrÃ¤gstrichen (//) und enden in der gleichen Zeile mit dem Zeilenumbruch
	Alles was nach den SchrÃ¤gstrichen folgt
	wird bis zum Zeilenende als Kommentar angesehen und vom Compiler Ã¼bergangen
	beginnen mit der Zeichenkombination /* und enden mit */
	die sich Ã¼ber mehrere Zeilen erstrecken kÃ¶nnen
	Blockkommentare
	Sowohl Zeilen- als auch Blockkommentare kÃ¶nnen zu Beginn oder auch mitten in einer Zeile beginnen
	der vom Compiler ausgewertet wird
	Blockkommentare kÃ¶nnen in der selben Zeile enden und es kann ihnen Quelltext folgen
	der in der gleichen Zeile endet / System.Console.WriteLine("Ein weiterer Befehl"); / Ein mehrzeiligerBlockkommentar /System.Console.WriteLine("Noch einer"); System.Console.WriteLine("Befehl 1"); / Kommentar */ System.Console.WriteLine("Befehl 2"); Hinweis: Es sind auch Kommentare innerhalb eines Befehls z.B. zur Kommentierung einzelner Methodenparameter mÃ¶glich
	Alles was innerhalb des Blockkommentars steht
	der mit dem Zeilenumbruch endet System.Console.WriteLine("Ein Befehl"); // Ein Zeilenkommentar am Zeilenende /* Dies ist ein Blockkommentar
	wird vom Compiler Ã¼bergangen. <code> // Dies ist ein Zeilenkommentar
	Diese Art von Kommentaren sollte aus GrÃ¼nden der Lesbarkeit und Wartbarkeit vermieden werden
	der es ermÃ¶glicht
	eine XML-basierte Dokumentation erzeugen zu lassen
	Zur Dokumentation von Methoden stellt C# in Form von Metadaten (Attribute) einen Mechanismus bereit
	Klassen und deren Elemente wie Attribute oder Methoden) steht eine spezielle Form von Zeilenkommentaren bereit
	Zur Dokumentation von Typen (das heiÃŸt
	dritten SchrÃ¤gstrich (///) und befindet sich direkt Ã¼ber dem zu dokumentierenden Typ (z
	Hierzu beginnt der Zeilenkommentar mit einem weiteren
	B. einer Methode)
	die jeweils eine bestimmte Funktion bei der Dokumentation Ã¼bernehmen
	beispielsweise eine Zusammenfassung durch einen Summary-Tag. /// <summary> /// Diese Funktion gib den grÃ¶ÃŸeren Betrag zurÃ¼ck /// </summary> /// <param name="a">Der erste Ãœbergabeparameter</param> /// <param name="b">Der zweite Ãœbergabeparameter</param> /// <returns>Die Zahl mit dem grÃ¶ÃŸeren Betrag </returns> /// <remarks>Diese Funktion gibt den grÃ¶ÃŸeren Betrag der beiden Ãœbergegeben <see cref="Int32"/> zurÃ¼ck. /// Sind die BetrÃ¤ge gleich groÃŸ ist dies ein Fehler</remarks> /// <exception cref="ArgumentException">Der Betrag der beiden Zahlen sind gleich groÃŸ</exception> public int GetGreaterAbs(int a
	Es folgen nun XML-Tags
	int b) { int absA = Math.Abs(a); int absB = Math.Abs(b); if(absA==absB) { throw new ArgumentException("Der Betrag dieser beiden Zahlen ist gleich groÃŸ"); } else if(absA>absB) { return absA; } else { return absB; } } Alternativ kann auch eine externe Ressource referenziert werden
	die die Dokumentation enthÃ¤lt: /// <include file='xml_include_tag.doc' path='MyDocs/MyMembers[@name="test"]/*' /> Dokumentation im XMLDoc-API-Dokumentationsformat wird vom Compiler als ein normaler Zeilenkommentar angesehen
	Erst durch Angabe der Compiler-Option "/doc" werden Kommentare
	die mit drei SchrÃ¤gstrichen beginnen
	als XMLDoc erkannt und aus dem Quellcode in eine Datei extrahiert
	z.B. Ã¤hnlich wie bei Javadoc zur Erstellung einer HTML-Hilfe verwendet werden. (z.B mit NDoc (http://ndoc.sourceforge.net/)) test Siehe auch: Kommentar (Programmierung) [Bearbeiten]
	Diese kann dann weiterverarbeitet werden
VerfÃ¼gbare Klassenbibliotheken
	Collection Threads Reflection CodeDOM ADO.NET ASP.NET Windows.Forms en:C Sharp programming language ja:C Sharp nl:C sharp uk:C Sharp zh:Cï¼ƒç¼–ç¨‹è¯è¨€

[X] Schliessen

Dieser Artikel basiert auf dem Artikel Syntax von C-Sharp aus der freien Enzyklopädie wikipedia und steht unter der GNU Lizenz für freie Dokumentation. In der wikipedia ist eine Liste der Autoren verfügbar.

Cholesterin C64 Culpa in contrahendo Chile Ceratophyllaceae Commelinaceae Caryophyllaceae Cucurbitaceae Cornaceae

[Zurück ]

Inhalt Glossar:

Diese Seite einem Freund, Kollegen oder Bekannten weiterempfehlen? Hier klicken!

Allgemein

Sprachelemente

SchlÃ¼sselwÃ¶rter

Bedingte AusfÃ¼hrung (if, else)

Schleifen (for, do, while, foreach)

Die Sprungbefehle break, continue, goto und return

Objekte und Klassen

Die Klasse namens "object"

Strukturen (struct)

AufzÃ¤hlungen (Enumerationen)

Flags

Zugriffsmodifikatoren

Datentypen, Eigenschaften und Konstanten

Datentypen und Speicherbedarf

Konstanten (SchlÃ¼sselwort const)

Eigenschaften (SchlÃ¼sselwÃ¶rter get, set und value)

Darstellung spezieller Zeichen oder Zeichenfolgen

Vererbung

Schnittstellen

Das SchlÃ¼sselwort base

Versiegelte Klassen

Typumwandlungen

Assemblies

Attribute (Metadaten)

Kommentare und Dokumentation

VerfÃ¼gbare Klassenbibliotheken