From d65d82363bea8454e3ae7b014ecc086f46ed4992 Mon Sep 17 00:00:00 2001 From: m90 Date: Sat, 11 Oct 2014 17:31:47 +0200 Subject: add german translation of csharp tutorial --- de-de/csharp-de.html.markdown | 880 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 880 insertions(+) create mode 100644 de-de/csharp-de.html.markdown (limited to 'de-de') diff --git a/de-de/csharp-de.html.markdown b/de-de/csharp-de.html.markdown new file mode 100644 index 00000000..9feb1450 --- /dev/null +++ b/de-de/csharp-de.html.markdown @@ -0,0 +1,880 @@ +--- +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() { + {"Sarah", "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 DidWeCreateEnoughBycles() + { + // 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) \ No newline at end of file -- cgit v1.2.3 From bd247d01ded10c5e530aec7057dce2ae3dd939d5 Mon Sep 17 00:00:00 2001 From: m90 Date: Sat, 11 Oct 2014 17:58:44 +0200 Subject: fix yet-to-be-translated name --- de-de/csharp-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/csharp-de.html.markdown b/de-de/csharp-de.html.markdown index 9feb1450..bab3cd71 100644 --- a/de-de/csharp-de.html.markdown +++ b/de-de/csharp-de.html.markdown @@ -458,7 +458,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // Generics var phonebook = new Dictionary() { - {"Sarah", "212 555 5555"} // Fügt einen Eintrag zum Telefonbuch hinzu + {"Resi", "212 555 5555"} // Fügt einen Eintrag zum Telefonbuch hinzu }; // Hier könnte man auch unser generisches SetDefault von -- cgit v1.2.3 From 0af2d0dcbf400ee0bb8d1e5761fae51f3a01db6d Mon Sep 17 00:00:00 2001 From: m90 Date: Sat, 11 Oct 2014 18:28:05 +0200 Subject: typo --- de-de/csharp-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/csharp-de.html.markdown b/de-de/csharp-de.html.markdown index bab3cd71..66dfbc2c 100644 --- a/de-de/csharp-de.html.markdown +++ b/de-de/csharp-de.html.markdown @@ -763,7 +763,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // Auch Methoden können als static gekennzeichnet werden, nützlich // beispielsweise für Helper-Methoden - public static bool DidWeCreateEnoughBycles() + public static bool DidWeCreateEnoughBicycles() { // In einer statischen Methode können wir natürlich auch nur // statische Member der Klasse referenzieren -- cgit v1.2.3 From 99a669fe511d18b8feb35a99b320671045d2e3a5 Mon Sep 17 00:00:00 2001 From: m90 Date: Sat, 11 Oct 2014 18:40:15 +0200 Subject: them typographic mistakes --- de-de/csharp-de.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'de-de') diff --git a/de-de/csharp-de.html.markdown b/de-de/csharp-de.html.markdown index 66dfbc2c..54692f7c 100644 --- a/de-de/csharp-de.html.markdown +++ b/de-de/csharp-de.html.markdown @@ -877,4 +877,4 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; * [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) \ No newline at end of file +[C# Coding Conventions](http://msdn.microsoft.com/de-de/library/vstudio/ff926074.aspx) \ No newline at end of file -- cgit v1.2.3 From 54e44487302f84c9ed60f785b781eef22747c16a Mon Sep 17 00:00:00 2001 From: m90 Date: Sat, 11 Oct 2014 18:57:38 +0200 Subject: fix english comment and use non-american phone number --- de-de/csharp-de.html.markdown | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'de-de') diff --git a/de-de/csharp-de.html.markdown b/de-de/csharp-de.html.markdown index 54692f7c..32f254a4 100644 --- a/de-de/csharp-de.html.markdown +++ b/de-de/csharp-de.html.markdown @@ -330,7 +330,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // 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 + if (int.TryParse("123", out tryInt)) // gibt true oder false zurück { Console.WriteLine(tryInt); // 123 } @@ -458,7 +458,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // Generics var phonebook = new Dictionary() { - {"Resi", "212 555 5555"} // Fügt einen Eintrag zum Telefonbuch hinzu + {"Resi", "08822 / 43 67"} // Fügt einen Eintrag zum Telefonbuch hinzu }; // Hier könnte man auch unser generisches SetDefault von @@ -466,7 +466,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; 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 + Console.WriteLine(SetDefault(phonebook, "Resi", "kein Telefon")); // 08822 / 43 67 // Lambdas - konzise Syntax für Inline-Funktionen Func square = (x) => x * x; // Das letzte Element vom Typ T ist der Rückgabewert -- cgit v1.2.3 From a142c72ed4c0c7a772b63bd07e6a40f7b465e857 Mon Sep 17 00:00:00 2001 From: m90 Date: Sat, 11 Oct 2014 19:41:30 +0200 Subject: a plethora of smaller tweaks --- de-de/csharp-de.html.markdown | 84 +++++++++++++++++++++++-------------------- 1 file changed, 45 insertions(+), 39 deletions(-) (limited to 'de-de') diff --git a/de-de/csharp-de.html.markdown b/de-de/csharp-de.html.markdown index 32f254a4..c3da57ab 100644 --- a/de-de/csharp-de.html.markdown +++ b/de-de/csharp-de.html.markdown @@ -59,10 +59,10 @@ namespace Learning /////////////////////////////////////////////////// // Typen & Variablen - // - // Deklariere eine Variable mit /////////////////////////////////////////////////// + // Deklariere eine Variable mit + // Sbyte - Vorzeichenbehaftete 8-Bit Ganzzahl // (-128 <= sbyte <= 127) sbyte fooSbyte = 100; @@ -97,7 +97,7 @@ namespace Learning // float handelt // Decimal - ein 128-Bit-Datentyp mit mehr Genauigkeit als andere - // Fließkommatypen, und somit bestens geeignet für Berechnung von + // Fließkommatypen, und somit bestens geeignet für Berechnung von // Geld- und Finanzwerten decimal fooDecimal = 150.3m; @@ -108,7 +108,7 @@ namespace Learning char fooChar = 'A'; // Strings - im Gegensatz zu allen vorhergehenden Basistypen, die - // alle Werttypen sind ist String ein Referenztyp. Er ist somit + // 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); @@ -135,7 +135,7 @@ namespace Learning // 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"; +zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; // Die Keywords const oder readonly kennzeichnen eine unveränderliche // Variable/Konstante. Die Werte von Konstanten werden übrigens @@ -167,7 +167,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // List = new List(); List intList = new List(); List stringList = new List(); - List z = new List { 9000, 1000, 1337 }; // intialize + List z = new List { 9000, 1000, 1337 }; // Die <> kennzeichnen "Generics", mehr dazu unter "Coole Sachen" // Listen haben keinen Default-Wert. @@ -217,7 +217,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // Inkremente int i = 0; - Console.WriteLine("\n->Inc/Dec-rementation"); + Console.WriteLine("\n->Inkrement / Dekrement"); Console.WriteLine(i++); //i = 1. Post-Inkrement Console.WriteLine(++i); //i = 2. Pre-Inkrement Console.WriteLine(i--); //i = 1. Post-Dekrement @@ -240,7 +240,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; } else { - Console.WriteLine("Ich auch nicht"); + Console.WriteLine("Ich leider auch nicht"); } // Ternärer Operator @@ -286,9 +286,9 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // da String IEnumerable bereits implementiert) // Switch Struktur - // Ein Switch funktioniert mit byte, short, char und int Datentypen + // 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 + // die Klasse String, und ein paar Sonderklassen, die Wrapper für // Primitives sind: Character, Byte, Short und Integer int month = 3; string monthString; @@ -304,7 +304,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; monthString = "März"; break; // Man kann für mehrere Fälle auch das selbe Verhalten - // definierern. Jeder Block muss aber mit einem break-Statement + // definieren. Jeder Block muss aber mit einem break-Statement // abgeschlossen werden. Einzelne Fälle können über // `goto case x` erreicht werden case 6: @@ -336,7 +336,8 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; } // von Integer nach String - // Die Klasse Convert stellt Methoden zur Kovertierung von unterschiedlichsten Daten zur Verfügung + // Die Klasse Convert stellt Methoden zur Konvertierung von + // unterschiedlichsten Daten zur Verfügung: Convert.ToString(123); // "123" // oder tryInt.ToString(); // "123" @@ -355,7 +356,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; trek.SpeedUp(3); // Es empfiehlt sich immer Getter und Setter zu benutzen trek.Cadence = 100; - // ToString ist eine Konvention über die man überlicherweiser + // ToString ist eine Konvention über die man üblicherweiser // Informationen über eine Instanz erhält Console.WriteLine("Infos zu trek: " + trek.Info()); @@ -395,8 +396,8 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; return -1; } - // Methoden können überladen werden solange sie eine eindeutige - // Signatur haben + // Methoden können überladen werden, solange sie eindeutige + // Signaturen haben public static void MethodSignatures(string maxCount) { } @@ -417,7 +418,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; return result; } - // Über ihr Interface lassen sich die möglichen Typen auch beschränken + // Möglichen Typen lassen sich auch über ihr Interface beschränken: public static void IterateAndPrint(T toPrint) where T: IEnumerable { // Da T ein IEnumerable ist können wir foreach benutzen @@ -441,7 +442,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // Nullables - perfekt für die Interaktion mit // Datenbanken / Rückgabewerten - // Jeder Wert (d.h. keine Klassen) kann durch das Nachstellen eines ?s + // Jeder Wert (d.h. keine Klassen) kann durch das Nachstellen eines ? // nullable gemacht werden: ? = int? nullable = null; // Die explizite Langform wäre Nullable Console.WriteLine("Mein Nullable: " + nullable); @@ -451,8 +452,9 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // 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: + // Implizit typisierte Variablen + // Man kann auch den Typ einer Variable auch vom Compiler + // 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 @@ -464,8 +466,8 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // 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 + // TKey und TValue müssen nicht zwingend angegeben werden, da sie + // auch implizit vom Compiler ermittelt werden können Console.WriteLine(SetDefault(phonebook, "Resi", "kein Telefon")); // 08822 / 43 67 // Lambdas - konzise Syntax für Inline-Funktionen @@ -473,11 +475,11 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; 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 + // So gut wie alle Objekte 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 + // freigegeben werden: using (StreamWriter writer = new StreamWriter("log.txt")) { writer.WriteLine("Alles bestens!"); @@ -494,7 +496,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; 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 + // Schritt wird erst nach Beendigung aller Tasks ausgeführt Parallel.ForEach(websites, // maximal 3 Threads gleichzeitig new ParallelOptions() {MaxDegreeOfParallelism = 3}, @@ -515,7 +517,8 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // Dynamische Objekte (gut um mit anderen Sprachen zu arbeiten) dynamic student = new ExpandoObject(); - student.FirstName = "Christian"; // hier muss keine Klasse angegeben werden + // hier muss keine Klasse angegeben werden + student.FirstName = "Christian"; // Einem solchen Objekt kann man sogar Methoden zuordnen. // Das Beispiel gibt einen String zurück und erwartet einen String @@ -567,12 +570,14 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // LINQ-Operationen werden "lazy" ausgeführt. var db = new BikeRepository(); - // Die verzögerte Ausführung ist super für Datenbankabfragen + // Die verzögerte Ausführung ist optimal 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) @@ -601,7 +606,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; } } - // Syntax zur Deklaration einer Klasse + // Syntax zur Deklaration einer Klasse: // class { // // Datenfelder, Konstruktoren und Methoden leben alle // // innerhalb dieser Deklaration @@ -644,7 +649,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // 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 + // 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, @@ -656,8 +661,8 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; 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 dieser Typ in der Klasse "Bicycle" definiert ist, + // sollte Code ausserhalb der Klasse den Typen als Bicycle.Brand referenzieren // Nachdem das Enum deklariert ist, können wir den Typen verwenden: public BikeBrand Brand; @@ -665,7 +670,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // 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!"); + Console.WriteLine("Schon " + Bicycle.BicyclesCreated + " Fahrräder, nur für dieses Tutorial!"); static public int BicyclesCreated = 0; // readonly-Werte werden zur Laufzeit gesetzt @@ -673,7 +678,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // festgelegt werden readonly bool _hasCardsInSpokes = false; // readonly und private - // Konstruktoren bestimmen was bei einer Instantiierung passiert + // Konstruktoren bestimmen was bei einer Instantiierung passiert. // Das ist ein Default-Konstruktor: public Bicycle() { @@ -727,8 +732,8 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // 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 + // empfehlen. Diese können Getter und Setter haben, oder auch nur + // einen Getter bzw. einen Setter private bool _hasTassles; // private Variable public bool HasTassles // öffentliches Interface { @@ -738,7 +743,8 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // Das kann man auch kürzer schreiben: // Dieser Syntax erzeugt automatisch einen hinterlegten Wert, - // der gesetzt bzw. zurückgegeben wird: + // (entsprechend `private bool _isBroken`) der gesetzt + // bzw. zurückgegeben wird: public bool IsBroken { get; private set; } public int FrameSize { @@ -763,7 +769,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; // Auch Methoden können als static gekennzeichnet werden, nützlich // beispielsweise für Helper-Methoden - public static bool DidWeCreateEnoughBicycles() + public static bool DidWeCreateEnoughBicyclesYet() { // In einer statischen Methode können wir natürlich auch nur // statische Member der Klasse referenzieren @@ -807,7 +813,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; } // Interfaces (auch Schnittstellen genant) definieren nur die Signaturen - // ihrer Member, enthalten aber auf keinen Fall ihre Implementierung. + // ihrer Member, enthalten aber auf keinen Fall ihre Implementierung: interface IJumpable { // Alle Member eines Interfaces sind implizit public @@ -840,7 +846,7 @@ zur nächsten Zeile ""Wahnsinn!"", die Massen waren kaum zu halten"; } } - // Stellt eine Datenbankverbindung für das LinqToSql-Beispiel her. + // Das hier 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 -- cgit v1.2.3 From ea95b83e406e0badfb2b1b8a7d66458629850199 Mon Sep 17 00:00:00 2001 From: m90 Date: Sun, 12 Oct 2014 10:24:00 +0200 Subject: another round of improvements and corrections --- de-de/csharp-de.html.markdown | 89 ++++++++++++++++++++++--------------------- 1 file changed, 46 insertions(+), 43 deletions(-) (limited to 'de-de') diff --git a/de-de/csharp-de.html.markdown b/de-de/csharp-de.html.markdown index c3da57ab..dc77dda0 100644 --- a/de-de/csharp-de.html.markdown +++ b/de-de/csharp-de.html.markdown @@ -8,6 +8,7 @@ contributors: translators: - ["Frederik Ring", "https://github.com/m90"] filename: LearnCSharp-de.cs +lang: de-de --- 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. @@ -16,7 +17,7 @@ C# ist eine elegante, typsichere und objektorientierte Sprache, mit der Entwickl ```c# // Einzeilige Kommentare starten mit zwei Schrägstrichen: // /* -Mehrzeile Kommentare wie in C mit /* */ +Mehrzeile Kommentare wie in C Schrägstrich / Stern */ /// /// XML-Kommentare können zur automatisierten Dokumentation verwendet werden @@ -41,21 +42,21 @@ namespace Learning // handhaben führt aber unweigerlich ins Chaos (wirklich)! public class LearnCSharp { - // Zuerst kommen hier Syntax-Grundlagen, - // wenn du bereits Java oder C++ programmieren kannst, + // Zuerst erklärt dieses Tutorial die 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"); + // Mit Console.WriteLine kannst du einfachen Text ausgeben: + Console.WriteLine("Hallo Welt"); Console.WriteLine( "Integer: " + 10 + " Double: " + 3.14 + " Boolean: " + true); // Console.Write erzeugt keinen Zeilenumbruch - Console.Write("Hello "); - Console.Write("World"); + Console.Write("Hallo "); + Console.Write("Welt"); /////////////////////////////////////////////////// // Typen & Variablen @@ -96,9 +97,9 @@ namespace Learning // 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 - ein 128-Bit-Datentyp mit größerer Genauigkeit als + // andere Fließkommatypen, und somit bestens geeignet für + // die Berechnung von Geld- und Finanzwerten decimal fooDecimal = 150.3m; // Boolean - true & false @@ -108,20 +109,20 @@ namespace Learning 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. + // alle Werttypen sind, ist String ein Referenztyp. Strings sind + // 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: + // 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 + // 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); @@ -137,9 +138,9 @@ namespace Learning string bazString = @"Hier geht es zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; - // Die Keywords const oder readonly kennzeichnen eine unveränderliche - // Variable/Konstante. Die Werte von Konstanten werden übrigens - // bereits zur Compile-Zeit berechnet. + // 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; /////////////////////////////////////////////////// @@ -147,10 +148,10 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; /////////////////////////////////////////////////// // Arrays - Index beginnt bei Null - // Die Größe des Arrays wird bei der Deklaration festgelegt + // Die Größe des Arrays wird bei der Deklaration festgelegt. // Die syntaktische Struktur um ein neues Array zu erzeugen sieht // folgendermaßen aus: - // [] = new []; + // [] = new []; int[] intArray = new int[10]; // Arrays können auch über ein Array-Literal deklariert werden: @@ -158,13 +159,13 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; // Indizierung eines Arrays - Zugriff auf ein bestimmtes Element Console.WriteLine("intArray @ 0: " + intArray[0]); - // Arrays sind nicht veränderbar + // Arrays sind 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(); + // Durch ihre größere Flexibilität kommen Listen in C# 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 }; @@ -189,6 +190,7 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; Console.WriteLine("\n->Operatoren"); // kurze Schreibweise um mehrere Deklarationen zusammenzufassen: + // (Benutzung vom C# Styleguide aber ausdrücklich abgeraten!) int i1 = 1, i2 = 2; // Arithmetik funktioniert wie erwartet: @@ -246,13 +248,13 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; // Ternärer Operator // Anstatt eines einfachen if/else lässt sich auch folgendes schreiben: // ? : - string isTrue = (true) ? "Ja" : "Nein"; + string isTrue = true ? "Ja" : "Nein"; // while-Schleife int fooWhile = 0; while (fooWhile < 100) { - //Wird 100mal wiederholt, fooWhile 0->99 + // Wird 100mal wiederholt, fooWhile 0->99 fooWhile++; } @@ -260,14 +262,14 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; int fooDoWhile = 0; do { - //Wird 100mal wiederholt, fooDoWhile 0->99 + // 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 + // Wird 10mal wiederholt, fooFor 0->9 } // foreach-Schleife @@ -358,11 +360,11 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; // ToString ist eine Konvention über die man üblicherweiser // Informationen über eine Instanz erhält - Console.WriteLine("Infos zu trek: " + trek.Info()); + Console.WriteLine("Infos zu trek: " + trek.ToString()); // Wir instantiieren ein neues Hochrad PennyFarthing funbike = new PennyFarthing(1, 10); - Console.WriteLine("Infos zu funbike: " + funbike.Info()); + Console.WriteLine("Infos zu funbike: " + funbike.ToString()); Console.Read(); } // Ende der Methode main @@ -443,7 +445,7 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; // Nullables - perfekt für die Interaktion mit // Datenbanken / Rückgabewerten // Jeder Wert (d.h. keine Klassen) kann durch das Nachstellen eines ? - // nullable gemacht werden: ? = + // 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 @@ -502,7 +504,7 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; new ParallelOptions() {MaxDegreeOfParallelism = 3}, website => { - // Hier folgt eine sehr langwierige Operation + // Hier folgt eine langwierige, asynchrone Operation using (var r = WebRequest.Create(new Uri(website)).GetResponse()) { responses[website] = r.ContentType; @@ -517,7 +519,7 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; // Dynamische Objekte (gut um mit anderen Sprachen zu arbeiten) dynamic student = new ExpandoObject(); - // hier muss keine Klasse angegeben werden + // hier muss keine Typ angegeben werden student.FirstName = "Christian"; // Einem solchen Objekt kann man sogar Methoden zuordnen. @@ -564,7 +566,7 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; // Ein Traum für die Verarbeitung von großen Datenmengen // auf mehreren Cores! - // LINQ - bildet Auflistungstypen auf IQueryable Objekte ab + // LINQ - bildet einen Datenspeicher auf IQueryable Objekte ab // LinqToSql beispielsweise speichert und liest aus einer // SQL-Datenbank, LinqToXml aus einem XML-Dokument. // LINQ-Operationen werden "lazy" ausgeführt. @@ -629,7 +631,7 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; } private int _cadence; - // Das Keyword protected macht das Member nur für die Klasse selbst, + // Das Keyword protected macht das Member nur für die Klasse selbst // und ihre Subklassen zugänglich protected virtual int Gear { @@ -670,7 +672,7 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; // 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!"); + // Console.WriteLine("Schon " + Bicycle.BicyclesCreated + " Fahrräder, nur für dieses Tutorial!"); static public int BicyclesCreated = 0; // readonly-Werte werden zur Laufzeit gesetzt @@ -731,8 +733,8 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; } // 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 + // wenn es nur um den Zugriff auf Daten geht, ist eine Eigenschaft zu + // empfehlen. Diese können Getter und Setter haben, oder auch nur // einen Getter bzw. einen Setter private bool _hasTassles; // private Variable public bool HasTassles // öffentliches Interface @@ -756,7 +758,7 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; } // Diese Methode gibt eine Reihe an Informationen über das Objekt aus: - public virtual string Info() + public virtual string ToString() { return "Gang: " + Gear + " Kadenz: " + Cadence + @@ -804,7 +806,7 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; } } - public override string Info() + public override string ToString() { string result = "Hochrad "; result += base.ToString(); // ruft die "base"-Version der Methode auf @@ -847,7 +849,8 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; } // Das hier stellt eine Datenbankverbindung für das LinqToSql-Beispiel her. - // EntityFramework Code First ist großartig (ähnlich wie Ruby's ActiveRecord, aber bidirektional) + // EntityFramework Code First ist großartig + // (ähnlich zu Ruby's ActiveRecord, aber bidirektional) // http://msdn.microsoft.com/de-de/data/jj193542.aspx public class BikeRepository : DbSet { @@ -865,7 +868,7 @@ zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen"; * Flags * Attributes - * Static properties + * Statische Eigenschaften * Exceptions, Abstraction * ASP.NET (Web Forms/MVC/WebMatrix) * Winforms -- cgit v1.2.3