--- language: c# contributors: - ["Irfan Charania", "https://github.com/irfancharania"] - ["Max Yankov", "https://github.com/golergka"] - ["Melvyn Laïly", "http://x2a.yt"] - ["Shaun McCarthy", "http://www.shaunmccarthy.com"] translators: - ["Frederik Ring", "https://github.com/m90"] filename: LearnCSharp-de.cs --- C# ist eine elegante, typsichere und objektorientierte Sprache, mit der Entwickler eine Vielzahl sicherer und robuster Anwendungen erstellen können, die im .NET Framework ausgeführt werden. [Mehr über C# erfährst du hier.](http://msdn.microsoft.com/de-de/library/vstudio/z1zx9t92.aspx) ```c# // Einzeilige Kommentare starten mit zwei Schrägstrichen: // /* Mehrzeile Kommentare wie in C mit /* */ */ /// /// XML-Kommentare können zur automatisierten Dokumentation verwendet werden /// // Zu Beginn werden die in der Datei verwendeten Namespaces aufgeführt using System; using System.Collections.Generic; using System.Data.Entity; using System.Dynamic; using System.Linq; using System.Linq.Expressions; using System.Net; using System.Threading.Tasks; using System.IO; // definiert einen Namespace um Code in "packages" zu organisieren namespace Learning { // Jede .cs-Datei sollte zumindest eine Klasse mit dem Namen der Datei // enthalten. Das ist zwar nicht zwingend erforderlich, es anders zu // handhaben führt aber unweigerlich ins Chaos (wirklich)! public class LearnCSharp { // Zuerst kommen hier Syntax-Grundlagen, // wenn du bereits Java oder C++ programmieren kannst, // lies bei "Interessante Features" weiter! public static void Syntax() { // Mit Console.WriteLine kannst du einfachen Text ausgeben Console.WriteLine("Hello World"); Console.WriteLine( "Integer: " + 10 + " Double: " + 3.14 + " Boolean: " + true); // Console.Write erzeugt keinen Zeilenumbruch Console.Write("Hello "); Console.Write("World"); /////////////////////////////////////////////////// // Typen & Variablen // // Deklariere eine Variable mit /////////////////////////////////////////////////// // Sbyte - Vorzeichenbehaftete 8-Bit Ganzzahl // (-128 <= sbyte <= 127) sbyte fooSbyte = 100; // Byte - Vorzeichenlose 8-Bit Ganzzahl // (0 <= byte <= 255) byte fooByte = 100; // Short - 16-Bit Ganzzahl // Vorzeichenbehaftet - (-32,768 <= short <= 32,767) // Vorzeichenlos - (0 <= ushort <= 65,535) short fooShort = 10000; ushort fooUshort = 10000; // Integer - 32-bit Ganzzahl int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647) uint fooUint = 1; // (0 <= uint <= 4,294,967,295) // Long - 64-bit Ganzzahl long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807) ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615) // Ganze Zahlen werden standardmäßig - je nach Größe - als int oder // uint behandelt. Ein nachgestelltes L markiert den Wert als long // oder ulong. // Double - Double-precision 64-bit IEEE 754 Fließkommazahl double fooDouble = 123.4; // Genauigkeit: 15-16 Stellen // Float - Single-precision 32-bit IEEE 754 Fließkommazahl float fooFloat = 234.5f; // Genauigkeit: 7 Stellen // Das nachgestellte f zeigt an dass es sich um einen Wert vom Typ // float handelt // Decimal - ein 128-Bit-Datentyp mit mehr Genauigkeit als andere // Fließkommatypen, und somit bestens geeignet für Berechnung von // Geld- und Finanzwerten decimal fooDecimal = 150.3m; // Boolean - true & false bool fooBoolean = true; // oder false // Char - Ein einzelnes 16-Bit Unicode Zeichen char fooChar = 'A'; // Strings - im Gegensatz zu allen vorhergehenden Basistypen, die // alle Werttypen sind ist String ein Referenztyp. Er ist somit // nullable, Werttypen sind dies nicht. string fooString = "\"maskiere\" Anführungszeichen, und füge \n (Umbrüche) und \t (Tabs) hinzu"; Console.WriteLine(fooString); // Jeder Buchstabe eines Strings kann über seinen Index referenziert // werden: char charFromString = fooString[1]; // => 'e' // Strings sind unveränderlich: // `fooString[1] = 'X';` funktioniert nicht // Ein Vergleich zweier Strings, unter Berücksichtigung der // aktuellen sprachspezifischen Gegebenheiten (also z.B. a,ä,b,c in // deutschsprachigen Umgebungen), und ohne Beachtung von // Groß- und Kleinschreibung: string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase); // Formatierung, genau wie "sprintf" string fooFs = string.Format("Mikrofon Check, {0} {1}, {0} {1:0.0}", 1, 2); // Datumsangaben und Formatierung DateTime fooDate = DateTime.Now; Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy")); // Durch ein vorangestelltes @ lässt sich ein mehrzeiliger String // schreiben. Um " zu maskieren benutzt man "" string bazString = @"Hier geht es zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // Die Keywords const oder readonly kennzeichnen eine unveränderliche // Variable/Konstante. Die Werte von Konstanten werden übrigens // bereits zur Compile-Zeit berechnet. const int HOURS_I_WORK_PER_WEEK = 9001; /////////////////////////////////////////////////// // Datenstrukturen /////////////////////////////////////////////////// // Arrays - Index beginnt bei Null // Die Größe des Arrays wird bei der Deklaration festgelegt // Die syntaktische Struktur um ein neues Array zu erzeugen sieht // folgendermaßen aus: // [] = new []; int[] intArray = new int[10]; // Arrays können auch über ein Array-Literal deklariert werden: int[] y = { 9000, 1000, 1337 }; // Indizierung eines Arrays - Zugriff auf ein bestimmtes Element Console.WriteLine("intArray @ 0: " + intArray[0]); // Arrays sind nicht veränderbar intArray[1] = 1; // Listen // Durch ihre größere Flexibilität kommen Listen weit häufiger // zum Einsatz als Arrays. Eine Liste wird so deklariert: // List = new List(); List intList = new List(); List stringList = new List(); List z = new List { 9000, 1000, 1337 }; // intialize // Die <> kennzeichnen "Generics", mehr dazu unter "Coole Sachen" // Listen haben keinen Default-Wert. // Bevor auf einen Index zugegriffen werden kann, muss dieser // auch gesetzt worden sein: intList.Add(1); Console.WriteLine("intList @ 0: " + intList[0]); // Andere interessante Datenstrukturen sind: // Stack/Queue // Dictionary (entspricht einer Hash Map) // HashSet // Read-only Collections // Tuple (.Net 4+) /////////////////////////////////////// // Operatoren /////////////////////////////////////// Console.WriteLine("\n->Operatoren"); // kurze Schreibweise um mehrere Deklarationen zusammenzufassen: int i1 = 1, i2 = 2; // Arithmetik funktioniert wie erwartet: Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3 // Modulo Console.WriteLine("11%3 = " + (11 % 3)); // => 2 // Vergleiche Console.WriteLine("3 == 2? " + (3 == 2)); // => false Console.WriteLine("3 != 2? " + (3 != 2)); // => true Console.WriteLine("3 > 2? " + (3 > 2)); // => true Console.WriteLine("3 < 2? " + (3 < 2)); // => false Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true // Bitweise Operatoren /* ~ Unäres bitweises NICHT << Verschieben nach links >> Verschieben nach rechts & Bitweises UND ^ Bitweises exklusives ODER | Bitweises inklusives ODER */ // Inkremente int i = 0; Console.WriteLine("\n->Inc/Dec-rementation"); Console.WriteLine(i++); //i = 1. Post-Inkrement Console.WriteLine(++i); //i = 2. Pre-Inkrement Console.WriteLine(i--); //i = 1. Post-Dekrement Console.WriteLine(--i); //i = 0. Pre-Dekrement /////////////////////////////////////// // Kontrollstrukturen /////////////////////////////////////// Console.WriteLine("\n->Kontrollstrukturen"); // If-Statements funktionieren wie in C int j = 10; if (j == 10) { Console.WriteLine("Ich werde ausgegeben"); } else if (j > 10) { Console.WriteLine("Ich nicht"); } else { Console.WriteLine("Ich auch nicht"); } // Ternärer Operator // Anstatt eines einfachen if/else lässt sich auch folgendes schreiben: // ? : string isTrue = (true) ? "Ja" : "Nein"; // while-Schleife int fooWhile = 0; while (fooWhile < 100) { //Wird 100mal wiederholt, fooWhile 0->99 fooWhile++; } // do-while-Schleife int fooDoWhile = 0; do { //Wird 100mal wiederholt, fooDoWhile 0->99 fooDoWhile++; } while (fooDoWhile < 100); //for-Schleifen => for(; ; ) for (int fooFor = 0; fooFor < 10; fooFor++) { //Wird 10mal wiederholt, fooFor 0->9 } // foreach-Schleife // Die normale Syntax für eine foreach-Schleife lautet: // foreach( in ) // foreach kann mit jedem Objekt verwendet werden das IEnumerable // oder IEnumerable implementiert. Alle Auflistungs-Typen // (Array, List, Dictionary...) im .NET Framework implementieren // eines dieser beiden Interfaces. foreach (char character in "Hallo Welt".ToCharArray()) { // Ein Durchgang für jedes Zeichen im String } // (ToCharArray() könnte man hier übrigens auch weglassen, // da String IEnumerable bereits implementiert) // Switch Struktur // Ein Switch funktioniert mit byte, short, char und int Datentypen // Auch Aufzählungstypen können verwendet werden, genau wie // die Klasse String, und ein paar Sonderklassen die Wrapper für // Primitives sind: Character, Byte, Short und Integer int month = 3; string monthString; switch (month) { case 1: monthString = "Januar"; break; case 2: monthString = "Februar"; break; case 3: monthString = "März"; break; // Man kann für mehrere Fälle auch das selbe Verhalten // definierern. Jeder Block muss aber mit einem break-Statement // abgeschlossen werden. Einzelne Fälle können über // `goto case x` erreicht werden case 6: case 7: case 8: monthString = "Sommer!!"; break; default: monthString = "Irgendein anderer Monat"; break; } /////////////////////////////////////// // Umwandlung von Datentypen und Typecasting /////////////////////////////////////// // Umwandlung // von String nach Integer // bei einem Fehler wirft diese Code eine Exception int.Parse("123"); //gibt die Ganzzahl 123 zurück // TryParse gibt bei einem Fehler den Default-Wert zurück // (im Fall von int: 0) int tryInt; if (int.TryParse("123", out tryInt)) // Function is boolean { Console.WriteLine(tryInt); // 123 } // von Integer nach String // Die Klasse Convert stellt Methoden zur Kovertierung von unterschiedlichsten Daten zur Verfügung Convert.ToString(123); // "123" // oder tryInt.ToString(); // "123" } /////////////////////////////////////// // Klassen /////////////////////////////////////// public static void Classes() { // Benutze das new-Keyword um eine Instanz einer Klasse zu erzeugen Bicycle trek = new Bicycle(); // So werden Methoden der Instanz aufgerufen trek.SpeedUp(3); // Es empfiehlt sich immer Getter und Setter zu benutzen trek.Cadence = 100; // ToString ist eine Konvention über die man überlicherweiser // Informationen über eine Instanz erhält Console.WriteLine("Infos zu trek: " + trek.Info()); // Wir instantiieren ein neues Hochrad PennyFarthing funbike = new PennyFarthing(1, 10); Console.WriteLine("Infos zu funbike: " + funbike.Info()); Console.Read(); } // Ende der Methode main // Main als Konsolenstartpunkt // Eine Konsolenanwendung muss eine Methode Main als Startpunkt besitzen public static void Main(string[] args) { OtherInterestingFeatures(); } /////////////////////////////////////// // Interessante Features /////////////////////////////////////// // Methodensignaturen public // Sichtbarkeit static // Erlaubt einen Zugriff auf der Klasse (nicht auf einer Instanz) int // Typ des Rückgabewerts, MethodSignatures( // Erstes Argument, erwartet int int maxCount, // setzt sich selbst auf 0 wenn kein anderer Wert übergeben wird int count = 0, int another = 3, // enthält alle weiteren der Methode übergebenen Parameter (quasi Splats) params string[] otherParams ) { return -1; } // Methoden können überladen werden solange sie eine eindeutige // Signatur haben public static void MethodSignatures(string maxCount) { } // Generische Typen // Die Typen für TKey und TValue werden erst beim Aufruf der Methode // festgelegt. Diese Methode emuliert z.B. SetDefault aus Python: public static TValue SetDefault( IDictionary dictionary, TKey key, TValue defaultItem) { TValue result; if (!dictionary.TryGetValue(key, out result)) { return dictionary[key] = defaultItem; } return result; } // Über ihr Interface lassen sich die möglichen Typen auch beschränken public static void IterateAndPrint(T toPrint) where T: IEnumerable { // Da T ein IEnumerable ist können wir foreach benutzen foreach (var item in toPrint) { // Item ist ein int Console.WriteLine(item.ToString()); } } public static void OtherInterestingFeatures() { // Optionale Parameter MethodSignatures(3, 1, 3, "Ein paar", "extra", "Strings"); // setzt explizit einen bestimmten Parameter, andere werden übersprungen MethodSignatures(3, another: 3); // Erweiterungsmethoden int i = 3; i.Print(); // Weiter unten definiert // Nullables - perfekt für die Interaktion mit // Datenbanken / Rückgabewerten // Jeder Wert (d.h. keine Klassen) kann durch das Nachstellen eines ?s // nullable gemacht werden: ? = int? nullable = null; // Die explizite Langform wäre Nullable Console.WriteLine("Mein Nullable: " + nullable); bool hasValue = nullable.HasValue; // true wenn nicht null // ?? ist "syntaktischer Zucker" um einen Defaultwert für den Fall // dass die Variable null ist festzulegen. int notNullable = nullable ?? 0; // 0 // Implizit typisierte (dynamische) Variablen // Man kann auch den Compiler den Typ einer Variable bestimmen lassen: var magic = "magic ist zur Compile-Zeit ein String, folglich geht keine Typsicherheit verloren"; magic = 9; // funktioniert nicht da magic vom Typ String ist // Generics var phonebook = new Dictionary() { {"Resi", "212 555 5555"} // Fügt einen Eintrag zum Telefonbuch hinzu }; // Hier könnte man auch unser generisches SetDefault von // weiter oben benutzen: Console.WriteLine(SetDefault(phonebook, "Xaver", "kein Telefon")); // kein Telefon // TKey und TValue müssen nicht angegeben werden, da sie auch implizit // vom Compiler ermittelt werden können Console.WriteLine(SetDefault(phonebook, "Resi", "kein Telefon")); // 212 555 5555 // Lambdas - konzise Syntax für Inline-Funktionen Func square = (x) => x * x; // Das letzte Element vom Typ T ist der Rückgabewert Console.WriteLine(square(3)); // 9 // Disposables - einfaches Management von nicht verwalteten Ressourcen // So gut wie alle Objekte über die auf nicht verwaltete Ressourcen // (Dateien, Geräte, ...) zugreifen implementieren das Interface // IDisposable. Das using Statement stellt sicher dass die vom // IDisposable benutzten Ressourcen nach der Benutzung wieder // freigegeben werden using (StreamWriter writer = new StreamWriter("log.txt")) { writer.WriteLine("Alles bestens!"); // Am Ende des Codeblocks werden die Ressourcen wieder // freigegeben - auch im Falle einer Exception } // Parallel Klasse // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx var websites = new string[] { "http://www.google.com", "http://www.reddit.com", "http://www.shaunmccarthy.com" }; var responses = new Dictionary(); // Für jeden Request wird ein neuer Thread erzeugt, der nächste // Schritt wird erst nach Beendigung aller Requests ausgeführt Parallel.ForEach(websites, // maximal 3 Threads gleichzeitig new ParallelOptions() {MaxDegreeOfParallelism = 3}, website => { // Hier folgt eine sehr langwierige Operation using (var r = WebRequest.Create(new Uri(website)).GetResponse()) { responses[website] = r.ContentType; } }); // Dieser Code wird erst nach Beendigung aller Requests ausgeführt foreach (var key in responses.Keys) { Console.WriteLine("{0}:{1}", key, responses[key]); } // Dynamische Objekte (gut um mit anderen Sprachen zu arbeiten) dynamic student = new ExpandoObject(); student.FirstName = "Christian"; // hier muss keine Klasse angegeben werden // Einem solchen Objekt kann man sogar Methoden zuordnen. // Das Beispiel gibt einen String zurück und erwartet einen String student.Introduce = new Func( (introduceTo) => string.Format("Hallo {0}, das ist {1}", student.FirstName, introduceTo)); Console.WriteLine(student.Introduce("Bettina")); // IQueryable - So gut wie alle Aufzählungstypen implementieren // dieses Interface, welches eine Vielzahl von funktionalen Methoden // wie Map / Filter / Reduce zur Verfügung stellt: var bikes = new List(); // sortiert die Liste bikes.Sort(); // sortiert nach Anzahl Räder bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); var result = bikes // diese Filter können auch aneinandergehängt werden .Where(b => b.Wheels > 3) // (gibt ein IQueryable des vorherigen Typs zurück) .Where(b => b.IsBroken && b.HasTassles) // diese Zuordnung gibt ein IQueryable zurück .Select(b => b.ToString()); // "Reduce" - addiert alle Räder der Aufzählung zu einem Wert var sum = bikes.Sum(b => b.Wheels); // So erzeugt man ein implizit typisiertes Objekt, basierend auf // den Parametern der Elemente: var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles }); // Auch wenn wir es hier nicht demonstrieren können: // In einer IDE wie VisualStudio kriegen wir hier sogar TypeAhead, // da der Compiler in der Lage ist, die passenden Typen zu erkennen. foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome)) { Console.WriteLine(bikeSummary.Name); } // AsParallel-Methode // Jetzt kommen die Schmankerl! Die AsParallel-Methode kombiniert // LINQ und parallele Operationen: var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name); // Diese Berechnung passiert parallel! Benötigte Threads werden // automatisch erzeugt, und die Rechenlast unter ihnen aufgeteilt. // Ein Traum für die Verarbeitung von großen Datenmengen // auf mehreren Cores! // LINQ - bildet Auflistungstypen auf IQueryable Objekte ab // LinqToSql beispielsweise speichert und liest aus einer // SQL-Datenbank, LinqToXml aus einem XML-Dokument. // LINQ-Operationen werden "lazy" ausgeführt. var db = new BikeRepository(); // Die verzögerte Ausführung ist super für Datenbankabfragen var filter = db.Bikes.Where(b => b.HasTassles); // noch keine Abfrage // Es können noch mehr Filter hinzugefügt werden (auch mit // Bedingungen) - ideal für z.B. "erweiterte Suchen" if (42 > 6) filter = filter.Where(b => b.IsBroken); // immer noch keine Abfrage var query = filter .OrderBy(b => b.Wheels) .ThenBy(b => b.Name) .Select(b => b.Name); // auch hier: immer noch keine Abfrage // Erst hier wird die Datenbankabfrage wirklich ausgeführt, // limitiert auf die Elemente die der foreach-Loop verwendet foreach (string bike in query) { Console.WriteLine(result); } } } // Ende der Klasse LearnCSharp // Eine .cs-Datei kann auch mehrere Klassen enthalten public static class Extensions { // Erweiterungsmethoden public static void Print(this object obj) { Console.WriteLine(obj.ToString()); } } // Syntax zur Deklaration einer Klasse // class { // // Datenfelder, Konstruktoren und Methoden leben alle // // innerhalb dieser Deklaration // } public class Bicycle { // Felder/Variablen der Klasse "Bicycle" // Das Keyword public macht das Member von überall zugänglich public int Cadence { get // get definiert eine Methode um die Eigenschaft abzurufen { return _cadence; } set // set definiert eine Methode um die Eigenschaft zu setzen { _cadence = value; // value ist der dem Setter übergebene Wert } } private int _cadence; // Das Keyword protected macht das Member nur für die Klasse selbst, // und ihre Subklassen zugänglich protected virtual int Gear { get; // erzeugt eine Eigenschaft für die kein "Zwischenwert" benötigt wird set; } // Das Keyword internal macht das Member innerhalb der Assembly zugänglich internal int Wheels { get; private set; // get/set kann auch über Keywords modifiziert werden } int _speed; // Member ohne vorangestellte Keywords sind standardmäßig // private, sie sind nur innerhalb der Klasse zugänglich. // Man kann aber natürlich auch das Keyword private benutzen. private string Name { get; set; } // Ein Enum ist ein klar definierter Satz an benannten Konstanten // Eigentlich ordnet es diese Konstanten nur bestimmten Werten zu // (einer int-Zahl, solange nicht anders angegeben). Mögliche Typen für // die Werte eines Enums sind byte, sbyte, short, ushort, int, uint, // long, oder ulong. Alle Werte in einem Enum sind eindeutig. public enum BikeBrand { Colnago, EddyMerckx, Bianchi = 42, // so kann man den Wert explizit setzen Kynast // 43 } // Nachdem dieser Typ in der Klasse "Bicycle" definiert ist // sollte Code ausserhalb der Klasse den Typen als Bicycle referenzieren // Nachdem das Enum deklariert ist, können wir den Typen verwenden: public BikeBrand Brand; // Als static gekennzeichnete Member gehören dem Typ selbst, // nicht seinen Instanzen. Man kann sie also ohne Referenz zu einem // Objekt benutzen Console.WriteLine("Schon " + Bicycle.bicyclesCreated + " Fahrräder, nur für dieses Tutorial!"); static public int BicyclesCreated = 0; // readonly-Werte werden zur Laufzeit gesetzt // Ihr Wert kann nur bei ihrer Deklaration, oder in einem Konstruktor // festgelegt werden readonly bool _hasCardsInSpokes = false; // readonly und private // Konstruktoren bestimmen was bei einer Instantiierung passiert // Das ist ein Default-Konstruktor: public Bicycle() { // Member der Klasse können über das Keyword this erreicht werden this.Gear = 1; // oft ist das aber gar nicht nötig Cadence = 50; _speed = 5; Name = "Bonanzarad"; Brand = BikeBrand.Kynast; BicyclesCreated++; } // Das ist ein spezifischer Konstruktor (d.h. er erwartet Argumente): public Bicycle(int startCadence, int startSpeed, int startGear, string name, bool hasCardsInSpokes, BikeBrand brand) : base() // ruft zuerst den "base"-Konstruktor auf { Gear = startGear; Cadence = startCadence; _speed = startSpeed; Name = name; _hasCardsInSpokes = hasCardsInSpokes; Brand = brand; } // Konstruktoren können aneinandergehängt werden: public Bicycle(int startCadence, int startSpeed, BikeBrand brand) : this(startCadence, startSpeed, 0, "richtig große Räder", true, brand) { } // Syntax für Methoden: // () // Klassen können Getter und Setter für Werte definieren, // oder diese Werte direkt als Eigenschaft implementieren // (in C# der bevorzugte Weg) // Parameter von Methoden können Default-Werte haben. // "SpeedUp" kann man also auch ohne Parameter aufrufen: public void SpeedUp(int increment = 1) { _speed += increment; } public void SlowDown(int decrement = 1) { _speed -= decrement; } // Eigenschaften mit get/set // wenn es nur um den Zugriff auf Daten geht ist eine Eigenschaft zu // empfehlen. Diese können Getter und Setter haben, oder auch nur Getter // bzw. Setter private bool _hasTassles; // private Variable public bool HasTassles // öffentliches Interface { get { return _hasTassles; } set { _hasTassles = value; } } // Das kann man auch kürzer schreiben: // Dieser Syntax erzeugt automatisch einen hinterlegten Wert, // der gesetzt bzw. zurückgegeben wird: public bool IsBroken { get; private set; } public int FrameSize { get; // für Getter und Setter kann der Zugriff auch einzeln // beschränkt werden, FrameSize kann also nur von innerhalb // der Klasse "Bicycle" gesetzt werden private set; } // Diese Methode gibt eine Reihe an Informationen über das Objekt aus: public virtual string Info() { return "Gang: " + Gear + " Kadenz: " + Cadence + " Geschwindigkeit: " + _speed + " Name: " + Name + " Hipster-Karten zwischen den Speichen: " + (_hasCardsInSpokes ? "Na klar!" : "Bloß nicht!") + "\n------------------------------\n" ; } // Auch Methoden können als static gekennzeichnet werden, nützlich // beispielsweise für Helper-Methoden public static bool DidWeCreateEnoughBicycles() { // In einer statischen Methode können wir natürlich auch nur // statische Member der Klasse referenzieren return BicyclesCreated > 9000; } // Wenn eine Klasse nur statische Member enthält, kann es eine gute Idee // sein die Klasse selbst als static zu kennzeichnen } // Ende der Klasse "Bicycle" // "PennyFarthing" ist eine Unterklasse von "Bicycle" class PennyFarthing : Bicycle { // (Hochräder - englisch Penny Farthing - sind diese antiken Fahrräder // mit riesigem Vorderrad. Sie haben keine Gangschaltung.) // hier wird einfach der Elternkonstruktor aufgerufen public PennyFarthing(int startCadence, int startSpeed) : base(startCadence, startSpeed, 0, "Hochrad", true, BikeBrand.EddyMerckx) { } protected override int Gear { get { return 0; } set { throw new ArgumentException("Ein Hochrad hat keine Gangschaltung, doh!"); } } public override string Info() { string result = "Hochrad "; result += base.ToString(); // ruft die "base"-Version der Methode auf return result; } } // Interfaces (auch Schnittstellen genant) definieren nur die Signaturen // ihrer Member, enthalten aber auf keinen Fall ihre Implementierung. interface IJumpable { // Alle Member eines Interfaces sind implizit public void Jump(int meters); } interface IBreakable { // Interfaces können Eigenschaften, Methoden und Events definieren bool Broken { get; } } // Eine Klasse kann nur von einer Klasse erben, kann aber eine beliebige // Anzahl von Interfaces implementieren class MountainBike : Bicycle, IJumpable, IBreakable { int damage = 0; public void Jump(int meters) { damage += meters; } public bool Broken { get { return damage > 100; } } } // Stellt eine Datenbankverbindung für das LinqToSql-Beispiel her. // EntityFramework Code First ist großartig (ähnlich wie Ruby's ActiveRecord, aber bidirektional) // http://msdn.microsoft.com/de-de/data/jj193542.aspx public class BikeRepository : DbSet { public BikeRepository() : base() { } public DbSet Bikes { get; set; } } } // Ende des Namespaces ``` ## In dieser Übersicht nicht enthalten sind die Themen: * Flags * Attributes * Static properties * Exceptions, Abstraction * ASP.NET (Web Forms/MVC/WebMatrix) * Winforms * Windows Presentation Foundation (WPF) ## Zum Weiterlesen gibt es viele gute Anlaufpunkte: * [DotNetPerls](http://www.dotnetperls.com) * [C# in Depth](http://manning.com/skeet2) * [Programming C#](http://shop.oreilly.com/product/0636920024064.do) * [LINQ](http://shop.oreilly.com/product/9780596519254.do) * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx) * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials) * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials) * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials) * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208) [C# Coding Conventions](http://msdn.microsoft.com/de-des/library/vstudio/ff926074.aspx)