Die Codekopie lautet wie folgt:
// einzelner Zeilenkommentar beginnt mit //
/*
So sind Multi-Line-Kommentare
*/
/// <summary>
/// xml Dokumentkommentare
/// </summary>
// den von der Anwendung verwendeten Namespace deklarieren
mit System verwenden;
mit System.Collectionss.generic;
mit System.Data.Entity;
mit System.dynamic;
mit System.linq;
unter Verwendung von System.linq.expressions;
mit System.net;
mit System.Threading.Tasks;
mit System.io;
// Definieren Sie den Umfang und organisieren Sie den Code in Pakete
Namespace -Lernen
{
// Jede .cs -Datei muss mindestens eine Klasse mit demselben Dateinamen wie wie
// Sie können dies nicht tun, aber das ist nicht gut.
öffentliche Klasse LearnCsharp
{
// Wenn Sie schon einmal Java oder C ++ verwendet haben, können Sie direkt zum folgenden Text "interessante Funktionen" springen
öffentliche statische Leere Syntax ()
{
// Verwenden Sie Console.writeLine, um Informationen zu drucken
Console.WriteLine ("Hello World");
Console.writeLine (
"Ganzzahl:" + 10 +
"Double:" + 3.14 +
"Boolean:" + wahr);
// mit Console.write ohne Zeilenumbruchsymbol drucken
Console.write ("Hallo");
Console.write ("welt");
////////////////////////////////////////////////// /
// Typen und Variablen
//
// <Typ> <name> Verwenden Sie Variablen, um Variablen zu definieren
////////////////////////////////////////////////// /
// sbyte - signierte 8 -Bit -Ganzzahl
// (-128 <= sbyte <= 127)
sbyte foosbyte = 100;
// Byte - Unsigned 8 -Bit -Ganzzahl
// (0 <= byte <= 255)
Byte foobyte = 100;
// Kurz - 16 -Bit -Ganzzahl
// signiert - (-32,768 <= kurz <= 32.767)
// nicht signiert - (0 <= uShort <= 65.535)
kurz Fooshort = 10000;
Ushort Fooushort = 10000;
// Ganzzahl - 32 -Bit -Ganzzahl
int fooint = 1;
uint foouint = 1;
// lang - 64 -Bit -Ganzzahl
Langes Dummkopf = 100000L;
Ulong fooulong = 10000L;
// Die Nummer stand in INT oder Uint (abhängig von der Größe) standardmäßig (abhängig von der Größe)
// LN LEBEN LN den variablen Werttyp als lang oder ulong an
// Doppel - Doppelte 64 -Bit IEEE 754 Schwimmpunktzahl
Double Foodouble = 123,4;
// Float - Single Precision 32 -Bit IEEE 754 Schwimmpunktnummer
Float FoofLoat = 234,5f;
// Verwenden Sie F, um anzugeben, dass der Variablenwerttyp float ist
// Decimal - 128 -Bit -Datentyp mit höherer Genauigkeit als andere schwimmende Punkttypen, die für Finanzen und Finanzen geeignet sind
Decimal Foodcimal = 150,3 m;
// boolescher Wert - True & False
bool fooboolean = true;
// char - einzelner 16 -Bit -Unicode -Zeichen
char foochar = 'a';
// Zeichenfolgen - Im Gegensatz zum vorherigen Grundtyp ist eine Zeichenfolge kein Wert, sondern eine Referenz. Dies bedeutet, dass Sie die Zeichenfolge auf null setzen können.
String fooString = " /" Escape /"Zitate und add /n (neue Zeilen) und /t (tabs)";
Console.WriteLine (FooString);
// Sie können auf jedes Zeichen einer Zeichenfolge über den Index zugreifen:
charchfromstring = fooString [1];
// String kann nicht geändert werden: FooString [1] = 'x' funktioniert nicht.
// Vergleiche Strings gemäß den aktuellen Gebietsschema -Einstellungen, Fall unempfindlich
String.comPare (FooString, "x", StringComparison
// String -Formatierung basierend auf Sprintf
String foofs = string.format ("Überprüfen Sie {0} {1}, {0} {1: 0.0}", 1, 2);
// Datum und Format
Datetime foodate = datetime.now;
Console.writeLine (foodate.tostring ("hh: mm, dd mmm yyyy"));
// Verwenden Sie das @ -Symbol, um Saiten über Zeilen zu erstellen. Verwenden Sie "" um darzustellen "
String bazstring = @"Hier sind ein paar Sachen
Auf einer neuen Linie! "Wow!" "
// Konst oder schreibgeschützt verwenden, um Konstanten zu definieren, und Konstanten werden während der Zusammenstellung berechnet
const int stunden_i_work_per_week = 9001;
////////////////////////////////////////////////// /
// Datenstruktur
////////////////////////////////////////////////// /
// Array - Das Zählen beginnt ab 0. Bei der Erklärung eines Arrays müssen Sie die Arraylänge bestimmen.
// Das Format der Deklaration eines Arrays lautet wie folgt:
// <DataType> [] <var name> = new <DataType> [<arraygröße>];
int [] intarrray = new int [10];
// andere Möglichkeiten, Arrays zu deklarieren und zu initialisieren:
int [] y = {9000, 1000, 1337};
// Zugriff auf die Elemente des Arrays zugreifen
Console.writeLine ("intarrray @ 0:" + intarrray [0]);
// Array kann geändert werden
Intarrray [1] = 1;
// Liste
// Listen werden häufiger verwendet als Arrays, da Listen flexibler sind.
// Das Format der Deklarationsliste lautet wie folgt:
// list <DataType> <var name> = new List <DataType> ();
List <intlist = New List <int> ();
List <String> StringList = New List <string> ();
Liste <int> z = Neue Liste <int> {9000, 1000, 1337};
// <> für Generika - Siehe Folgende
// Es gibt keinen Standardwert für die Liste.
intList.add (1);
Console.writeLine ("intlist @ 0:" + intlist [0]);
// andere Datenstrukturen:
// Stack/Warteschlange
// Wörterbuch (Implementierung der Hash -Tabelle)
// Hash -Sammlung
// schreibgeschützte Sammlung
// Tuple (.NET 4+)
/////////////////////////////// .////////// .////////
// Bediener
/////////////////////////////// .////////// .////////
Console.writeLine ("/n-> operatoren");
int i1 = 1, i2 = 2;
// Arithmetik direkt
Console.writeLine (i1 + i2 - i1 * 3/7);
// den Rest nehmen
Console.writeLine ("11%3 =" + (11%3));
// Betreiber vergleiche
Console.writeLine ("3 == 2?" + (3 == 2));
Console.writeLine ("3! = 2?" + (3! = 2));
Console.writeLine ("3> 2?" + (3> 2));
Console.writeLine ("3 <2?" + (3 <2));
Console.writeLine ("2 <= 2?" + (2 <= 2));
Console.writeLine ("2> = 2?" + (2> = 2));
// Bitbetreiber
/*
~ Umgekehrt
<< Links bewegen (signiert)
>> nach rechts bewegen (signiert)
& Und
^ Bitwise xor
|
*/
// Selbsterbeschreibung, Selbstverlust
int i = 0;
Console.writeLine ("/n-> inc/dec-rementation");
Console.writeLine (i ++);
Console.writeLine (++ i);
Console.writeLine (i--);
Console.writeLine (-i);
/////////////////////////////// .////////// .////////
// Kontrollstruktur
/////////////////////////////// .////////// .////////
Console.writeLine ("/n-> Kontrollstrukturen");
// Wenn C -Anweisung ähnelt wie C
int j = 10;
if (j == 10)
{
Console.writeLine ("Ich werde gedruckt");
}
sonst wenn (j> 10)
{
Console.writeLine ("Ich nicht");
}
anders
{
Console.writeLine ("Ich auch nicht");
}
// dreigliedrigen Ausdruck
// Eine einfache Anweisung/else -Anweisung kann geschrieben werden als:
// <Bedition>?
String iStrue = (wahr)?
// während Schleife
int foowhile = 0;
Während (foowhile <100)
{
// Iterationen 100 Mal, foowhile 0-> 99
foowhile ++;
}
// Tu während der Schleife
int foodowhile = 0;
Tun
{
// Iterationen 100 Mal, Foodowhile 0-> 99
foodowhile ++;
} während (foodowhile <100);
// für Schleife
// für Schleifenstruktur => für (<Anfangsbedingung>; <Bedition>; <Spe>)
für (int foofor = 0; foofor <10; foofor ++)
{
// Iterationen 10 Mal, Foofor 0-> 9
}
// foreach Loop
// foreach shoop struktur => foreach (<itertyp> <iter> in <Unumerable Struktur>)
// Die Foreach -Schleife ist für jedes Objekt geeignet, das IEnumerable oder iEnumerable implementiert.
// Sammlungstypen (Arrays, Listen, Wörterbücher ...) unter dem .NET -Framework implementieren diese Schnittstellen.
// im folgenden Code kann toCharArray () gelöscht werden, da die Zeichenfolge auch iEnumerable implementiert.
foreach (char charakter in "hello world" .tochararray ())
{
// durch alle Zeichen in der Zeichenfolge durchlaufen
}
// Anweisung Switch
// Switch eignet sich für Byte-, Short-, Char- und INT -Datentypen.
// auch für aufzählbare Typen, einschließlich Stringklassen, anwendbar.
// und einige Klassen, die die ursprünglichen Werte zusammenfassen: Zeichen, Byte, kurz und ganzzahl.
int Monat = 3;
String MonthString;
Schalter (Monat)
{
Fall 1:
MonthString = "Januar";
brechen;
Fall 2:
monatstring = "Februar";
brechen;
Fall 3:
MonthString = "März";
brechen;
// Sie können mehrere Fallanweisungen gleichzeitig abgleichen
//, aber Sie müssen Break verwenden, nachdem Sie die Fallanweisung hinzugefügt haben
// (ansonsten müssen Sie die GOTO -Fall x -Anweisung explizit verwenden)
Fall 6:
Fall 7:
Fall 8:
MonthString = "Sommerzeit !!";
brechen;
Standard:
monatstring = "ein anderer Monat";
brechen;
}
/////////////////////////////// .////////// .////////
// Die Zeichenfolge in eine Ganzzahl konvertieren, und eine Ausnahme wird ausgelöst, wenn die Konvertierung fehlschlägt:
/////////////////////////////// .////////// .////////
// Daten konvertieren
// Die Zeichenfolge in eine Ganzzahl konvertieren, und eine Ausnahme wird ausgelöst, wenn die Konvertierung fehlschlägt:
int.Parse ("123"); // zurück "123" des Ganzzahltyps
// tryParse versucht, den Typ zu konvertieren, und wenn er fehlschlägt, gibt es den Standardtyp zurück, wie z. B. 0
int tryint;
if (int.tryparse ("123", out tryint)) // funciton ist boolean
Console.writeLine (tryint);
// Ganzzahlen in Saiten umwandeln
// Die Konvertitklasse bietet eine Reihe bequemer Konvertierungsmethoden
Convert.ToString (123);
// oder
tryint.toString ();
}
/////////////////////////////// .////////// .////////
// Art
/////////////////////////////// .////////// .////////
öffentliche statische Leerklassen ()
{
// Siehe die Objektdeklaration am Ende der Datei
// Initialisieren Sie das Objekt mit neu
Fahrrad Trek = neues Fahrrad ();
// die Objektmethode aufrufen
Trek.Speedup (3); // Sie sollten immer Setter- und Getter -Methoden verwenden.
Trek.Cadence = 100;
// Zeigen Sie die Informationen des Objekts an.
Console.writeLine ("Trek Info:" + trek.info ());
// einen neuen Penny Farthing instanziieren
Pennyfarming funbike = neuer pennyfetthing (1, 10);
Console.writeLine ("Funbike Info:" + Funbike.info ());
Console.read ();
} // Hauptmethode beenden
// Terminalprogramm -Terminalprogramm muss eine Hauptmethode als Eintrag haben
öffentliche statische Leere Main (String [] Args)
{
Andere InteressesFeatures ();
}
//
// interessante Funktionen
//
// Standardmethode Signatur
öffentlich // Sichtbarkeit
Static // ermöglicht direkte Anrufe an Klassen, ohne zuerst Instanzen zu erstellen
int // Rückgabewert
Methodensignaturen (
Int MaxCount, // die erste Variable, ist eine Ganzzahl
int count = 0, // Wenn kein eingehender Wert übergeben wird, beträgt der Standardwert 0
int ein anderes = 3,
Params String [] Andere Params // andere Parameter erfassen
)
{
Return -1;
}
// Die Methode kann umbenannt werden, solange die Signatur anders ist
öffentliche statische Void -Methodensignatur (String MaxCount)
{
}
// Generika
// Die TKY- und TVAlue -Klassen werden angegeben, wenn die Funktion mit dem Benutzer aufgerufen wird.
// Die folgende Funktion simuliert den SetDefault von Python
öffentliches statisches TVAlue SetDefault <Tkey, TVAlue> (
IDictionary <tKey, TVAlue> Wörterbuch,
TKY KEY,
TVAlue defaultItem)
{
TVALUE -Ergebnis;
if (! Dictionary.trygetValue (Schlüssel, Out -Ergebnis))
Return Dictionary [Schlüssel] = defaultItem;
Rückgabeergebnis;
}
// Sie können den Bereich der eingehenden Werte einschränken
public static void iterateandprint <t> (t toprint) wobei t: iEnumerable <int>
{
// Wir können iterieren, weil T aufgezählt ist
foreach (var item in toprint)
// ITTM ist eine Ganzzahl
Console.writeLine (item.tostring ());
}
öffentliche statische Leere andere InteressesFeatures ()
{
// Optionale Parameter
Methodensignaturen (3, 1, 3, "einige", "extra", "Strings");
Methodenzeichen (3, ein anderer: 3);
// Methode erweitern
int i = 3;
I.Print (); // siehe die Definition unten,
// kann Null -Typ sein, ist sehr nützlich für die Datenbankinteraktion und die Rückgabewerte.
// Ein Werttyp (dh keine Klasse ist) wird nach dem Hinzufügen eines Suffix zu einem nullbaren Typ hinzugefügt?
// <typs>?
int?
Console.writeLine ("Nullable Variable:" + Nullierbar);
bool hasValue = nullable.hasValue;
// ?? wird syntaktischer Zucker verwendet, um Standardwerte anzugeben
// falls die Variable null ist
int notnullable = nullable? 0;
// variabler Typinferenz
// Sie können den Compiler variable Typen schließen lassen:
var Magic = "Magic ist eine Schnur zur Kompilierzeit, sodass Sie trotzdem die Sicherheit von Typ erhalten."
// Magic = 9; // funktioniert nicht, weil Magie eine Schnur ist, keine ganze Zahl.
// Generika
//
var melebook = new Dictionary <String, String> () {
{"Sarah", "212 555 5555"} // Fügen Sie dem Telefonbuch einen neuen Eintrag hinzu
};
// SetDefault aufrufen oben als Generikum definiert
Console.writeLine (setDefault <String, String> (Telefonbuch, "Shaun", "kein Telefon");
// Sie müssen weder TKY noch TVAlue angeben, da sie implizit abgeleitet werden
Console.writeLine (setDefault (Telefonbuch, "Sarah", "kein Telefon");
// Lambda -Ausdruck - Ermöglicht Ihnen Funktionen mit einer Codezeile zu lösen
Func <int, int> square = (x) => x * x;
Console.writeLine (Square (3));
// Defababable Resource Management - Ermöglicht Ihnen, einfach mit nicht verwalteten Ressourcen umzugehen. Die meisten Objekte, die auf nicht verwaltete Ressourcen (Dateioperatoren, Gerätekontext usw.) zugreifen, implementieren die idisposable Schnittstelle.
// Die Verwendung der Verwendung von Anweisung wird das idisposable Objekt für Sie bereinigt.
using (streamwriter writer = new streamwriter ("log.txt"))
{
Writer.WriteLine ("Nichts Verdächtiges hier");
// Am Ende des Umfangs wird die Ressource recycelt
// (selbst wenn eine Ausnahme ausgelöst wird, wird sie immer noch recycelt)
}
// Parallele Framework
// http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-inet-framework-4-getting-started.aspx
var websites = new String [] {
"http://www.google.com", "http://www.reddit.com",
"http://www.shaunmccarthy.com"
};
var antworten = new Dictionary <String, String> ();
// Öffnen Sie einen neuen Thread für jede Anforderung und fusionieren Sie die Ergebnisse, bevor Sie den nächsten Schritt ausführen
Parallel.foreach (Websites,
Neue Paralleloptionen () {MaxDegreeofparallelism = 3}, maximal 3 Threads
Website =>
{
// Mach etwas, das in der Datei lange dauert
Verwenden Sie (var r = webrequest.create (neue URI (Website)). getResponse ())
{
Antworten [Website] = R.ContentType;
}
});
// Der folgende Code wird erst ausgeführt, wenn alle Anfragen abgeschlossen sind
foreach (var Schlüssel in Antworten.Keys)
Console.writeLine ("{0}: {1}", Schlüssel, Antworten [Schlüssel]);
// Dynamische Objekte (es ist sehr bequem, mit anderen Sprachen zu verwenden)
Dynamic Student = new ExpaceOObject ();
Student.Firstname = "Vorname";
// Sie können sogar Methoden hinzufügen (eine Zeichenfolge akzeptieren, eine Zeichenfolge ausgeben).
student.intercoduce = new Func <String, String> (
(introceto) => string.format ("Hey {0}, das ist {1}", student.firstname, introceto));
Console.writeLine (student.inutroduc ("Beth"));
// iQueryable <T> - Fast alle Sammlungen implementieren sie und bringen Ihnen einen Karten-/Filter-/Reduzierungsstil -Ansatz.
var bikes = new List <bicycle> ();
Bikes.Sort ();
Bikes.sort ((B1, B2) => B1.Wheels.comPareto (B2.Wheels));
var result = Bikes
.Wo (b => B.Wheels> 3) // Filter - kann in Ketten verwendet werden (zurück zu iQueryable)
.Wher
.Select (b => B.ToString ());
var sum = bikes.sum (b => B.Wheels);
// Erstellen Sie eine Liste implizite Objekte, die basierend auf einigen Parametern des Fahrrads erzeugt werden
var bikesummaries = bikes.select (b => new {name = b.Name, isawesome =! b.isbroken && b.hastassles});
// Es ist schwierig zu demonstrieren, aber der Compiler kann die oben genannten Objekttypen ableiten, bevor der Code zusammengestellt wird.
foreach (var bikesummary in bikesummaries.where (b => b.isawesome))
Console.writeLine (Bikesummary.name);
// Asparallel
// böse Eigenschaften - Kombinieren von Linq und parallelen Operationen
var Dreiwheeler = Bikes.asparallel (). WO (b => B.Wheels == 3) .Select (b => B.Name);
// Der obige Code wird gleichzeitig ausgeführt. Der Thread wird automatisch geöffnet und die Ergebnisse werden separat berechnet. Geeignet für Multi-Kern- und Großdatenszenarien.
// linq - map iQueryable <T> in Speichern, Verzögerungsausführung wie linqtoSQL Mapping -Datenbank, linqtoxML -Mapping -XML -Dokumente.
var db = new Bikerspository ();
// Die Ausführung ist verzögert, was gut für die Abfrage der Datenbank ist
var filter = db.bikes.where (b => b.hastassles);
Wenn (42> 6) // Sie die Filterung, einschließlich der bedingten Filterung, kontinuierlich erhöhen können, z. B. für die erweiterte Suchfunktion
filter = filter.where (b => b.isbroken);
var query = filter
.Ondby (b => B.Wheels)
.Thenby (b => B.Name)
.Select (b => B.Name);
// Führen Sie nun die Abfrage aus, und ein Leser wird beim Ausführen der Abfrage geöffnet, sodass Sie über eine Kopie iterieren
foreach (Stringbike in Abfrage)
Console.WriteLine (Ergebnis);
}
} // End LearnCsharp -Klasse
// Sie können andere Klassen in die gleiche .cs -Datei aufnehmen
Öffentliche statische Klassenerweiterungen
{
// erweiterte Funktion
öffentlicher statischer Leeredruck (dieses Objekt OBJ)
{
Console.writeLine (obj.tostring ());
}
}
// die Syntax der Klasse deklarieren:
// <public/privat/protected/interal> class <Klasse name> {
// // Datenfelder, Konstruktoren, interne Funktionen.
/// In Java werden Funktionen als Methoden bezeichnet.
//}
Fahrrad für öffentliche Klasse
{
// Fahrradfelder und Variablen
öffentliche Int Cadence // öffentlich: Überall zugänglich
{
GET // GET - Definieren Sie eine Methode, um Attribute zu erhalten
{
Return _Cadence;
}
SET // SET - Definieren Sie eine Methode zum Einstellen von Eigenschaften
{
_cadence = Wert; // Wert ist der Wert, der dem Setter übergeben wurde
}
}
private int _cadence;
Geschützte virtuelle Int -Ausrüstung // Klassen und Unterklassen können zugegriffen werden
{
Erstellen Sie eine automatische Eigenschaft ohne Mitgliedsfelder
Satz;
}
Interne Int -Räder // intern: Kann innerhalb derselben Baugruppe zugegriffen werden
{
erhalten;
Privates Set; // Sie können Modifikatoren zur GET/SET -Methode hinzufügen
}
int _speed; // Standard ist privat: Es kann nur in dieser Klasse zugegriffen werden.
öffentlicher String -Name {Get;
// Der Enum -Typ enthält eine Reihe von Konstanten, die den Namen dem Wert abbilden (sofern nicht anders angegeben, eine Ganzzahl).
// Die Arten des ENMU -Elements können Byte, SByte, Short, Ushort, Int, Uint, Long, Ulong sein. Enum kann nicht den gleichen Wert enthalten.
Public Enum Bikebrand
{
Aist,
BMC,
Electra = 42, // Sie können Werte explizit zuweisen
Gitane // 43
}
// Dieser Typ definieren wir in der Fahrradklasse, so dass es sich um einen Inline -Typ handelt. Der Code außerhalb dieser Klasse sollte mit dem Fahrrad.Brand verwiesen werden.
öffentliche Bikebrand -Marke;
// Statische Methode
// Die Art der statischen Methode ist selbst und gehört nicht zu einem bestimmten Objekt. Sie können auf sie zugreifen, ohne Objekte zu verweisen.
statische öffentliche int biclescireated = 0;
// schreibgeschützte Wert
// schreibgeschützte Werte werden zur Laufzeit ermittelt und können nur Werte innerhalb der Deklaration oder des Konstruktors zugewiesen werden.
Readonly bool _hascardsinspokes = false;
// Konstruktoren sind eine Möglichkeit, Klassen zu erstellen.
// unten finden Sie einen Standardkonstruktor.
öffentliches Fahrrad ()
{
this.gear = 1; // Sie können das Schlüsselwort verwenden, um auf die Mitglieder des Objekts zugreifen zu können
Trittfrequenz = 50; //, aber Sie brauchen es nicht immer
_speed = 5;
Name = "Bontrager";
Brand = bikebrand.aist;
Fahrräder geschaffen ++;
}
// Ein weiteres Beispiel für den Konstruktor (einschließlich Parameter)
öffentliches Fahrrad (int startcadence, int startspeed, int startgear,
String -Name, Bool Hascardsinspokes, Bikebrand Marke)
: Base () // Erste Anrufbasis
{
Gear = StartGear;
Trittfrequenz = StartCadenz;
_speed = startspeed;
Name = Name;
_hascardsinSpokes = Hascardsinspokes;
Marke = Marke;
}
// Der Konstruktor kann in Ketten verwendet werden
Öffentliches Fahrrad (int StartCadence, int Startspeed, Bikebrand -Marke):
Dies (StartCadence, Startspeed, 0, "Big Wheels", True, Brand)
{
}
// Funktionssyntax:
// <public/privat/protected> <return Wert> <Funktion Name> (<Parameter>)
// Klassen können Getter und Setzermethoden für ihre Felder für Felder implementieren oder Eigenschaften implementieren (C# empfohlen, dies zu verwenden).
// Die Parameter der Methode können Standardwerte haben. Bei Standardwerten können die entsprechenden Parameter beim Aufrufen der Methode weggelassen werden.
öffentliche Leere beschleunigt (int Increment = 1)
{
_speed += Inkrement;
}
Öffentliche Leerlaufverschwendung (int Decrement = 1)
{
_Speed -= Niedergang;
}
// Eigenschaften können auf Werte zugreifen und festlegen. Wenn nur auf Daten zugegriffen werden müssen, sollten Sie Eigenschaften verwenden. Attribute können Get und Set oder beides definieren.
private bool _hastassles; // private Variable
öffentlicher BOOL UNTERSCHALTE // Public Accessor
{
{return _hastassles;
Setzen Sie {_hastassles = value;
}
// Sie können automatische Eigenschaften in einer Zeile definieren, und diese Syntax erstellt automatisch Fallback -Felder. Sie können Zugriffsmodifikatoren für Getters oder Setter festlegen, um ihren Zugriff zu begrenzen.
public bool isbroken {Get;
// Die Implementierung von Attributen kann automatisch sein
public int rahmensizesize
{
erhalten;
// Sie können Zugriffsmodifikatoren für GET oder SET angeben
// Der folgende Code bedeutet, dass nur die Fahrradklasse den Framesize -Satz aufrufen kann
privates Set;
}
// Methode zur Anzeige von Objekteigenschaften
öffentliche virtuelle Zeichenfolge info ()
{
Rückkehr "Ausrüstung:" + Gear +
"Trittfrequenz:" + Cadence +
"Geschwindigkeit:" + _speed +
"Name:" + Name +
"Karten in Speichen:" + (_hascardsinspokes? "Ja": "Nein") +
"/n ----------------------------/n"
}
// Die Methode kann statisch sein. Normalerweise in Hilfsmethoden verwendet.
öffentliches statisches Bool didwecreateenoughbycles ()
{
// In statischen Methoden können Sie sich nur auf statische Mitglieder der Klasse beziehen
Return Bicycles geschaffen> 9000;
} // Wenn Ihre Klasse nur statische Mitglieder benötigt, sollten Sie die gesamte Klasse als statische Klasse einnehmen.
} // Fahrradklasse endet
// Pennyfetthing ist eine Fahrradunterklasse
Klasse Pennyfetthing: Fahrrad
{
// (Penny Fartthings ist ein Fahrrad mit einem großen Vorderrad. Keine Zahnräder.)
// Rufen Sie den übergeordneten Konstruktor an
Öffentliche Pennyfetthing (int StartCadence, int startspeed):
Basis (StartCadenz, Startspeed, 0, "Pennyfetthing", True, Bikebrand.electra)
{
}
geschützter Override -Int -Gang
{
erhalten
{
Rückkehr 0;
}
Satz
{
Werfen Sie neue ArgumentException ("Sie können keine Gänge auf Pennyfetthing schalten");
}
}
Public Override String Info ()
{
String result = "Pennyfarming Bicycle";
result += base.toString ();
Rückgabeergebnis;
}
}
// Die Schnittstelle enthält nur die Signatur des Mitglieds und wird nicht implementiert.
Schnittstelle Ijumtable
{
Hohlraumsprung (INT -Meter);
}
Schnittstelle Ibreakable
{
bool zerbrochen {get;} // Die Schnittstelle kann Eigenschaften, Methoden und Ereignisse enthalten
}
// Klassen können nur eine Klasse erben, aber sie können eine beliebige Anzahl von Schnittstellen implementieren
Klasse MountainBike: Fahrrad, iJumptable, ibreakable
{
int schaden = 0;
öffentlicher Leerlaufsprung (int Meter)
{
Schaden += Meter;
}
Öffentliche Bool gebrochen
{
erhalten
{
Schaden zurückgeben> 100;
}
}
}
/// <summary>
/// eine Verbindung zur Datenbank herstellen, ein Beispiel für Linqtosql. Der EntityFramework-Code ist zuerst großartig (ähnlich wie Rubys ActiveCord, aber es ist zweiwegs)
/// http://msdn.microsoft.com/en-us/data/jj193542.aspx
/// </summary>
öffentliche Klasse Bikerspository: DBSet
{
öffentliche bikerspository ()
: base ()
{
}
public DBSet <Bicycle> Bikes {Get;
}
} // Endnamespace
Beachten Sie, dass die nicht abgedeckten Themen:
1.Flags
2.Adtributes
3. statische Eigenschaften
4. Ausnahme, Zusammenfassung
6.asp.net (Webformulare/MVC/WebMatrix)
6. WinForms
7. Windows Presentation Foundation (WPF)