La copie de code est la suivante:
// Le commentaire à ligne unique commence par //
/ *
C'est ainsi que sont les commentaires multi-lignes
* /
/// <résumé>
/// Commentaires du document XML
/// </summary>
// Déclarer l'espace de noms utilisé par l'application
Utilisation du système;
Utilisation de System.Collections. GENENERIER;
Utilisation de System.Data.entity;
Utilisation de System.dynamic;
Utilisation de System.Linq;
Utilisation de System.Linq.Expressions;
Utilisation de System.net;
Utilisation de System.Threading.Tasks;
Utilisation de System.io;
// Définissez la portée et organisez le code en packages
Apprentissage de l'espace de noms
{
// chaque fichier .cs doit contenir au moins une classe avec le même nom de fichier que
// Vous ne le faites peut-être pas, mais ce n'est pas bon.
classe publique LearncSharp
{
// Si vous avez déjà utilisé Java ou C ++, vous pouvez sauter directement au texte suivant "Fonctions intéressantes"
Syntaxe public statique VOID ()
{
// Utiliser Console.WriteLine pour imprimer des informations
Console.WriteLine ("Hello World");
Console.writeline (
"Entier:" + 10 +
"Double:" + 3.14 +
"Boolean:" + True);
// imprime avec console.write sans symbole de pause de ligne
Console.write ("bonjour");
Console.write ("monde");
////////////////////////////////////////////////////////////////////////// / / /
// Types et variables
//
// Utiliser <Type> <nom> pour définir les variables
////////////////////////////////////////////////////////////////////////// / / /
// sbyte - entier 8 bits signé
// (-128 <= sbyte <= 127)
Sbyte Foosbyte = 100;
// octet - entier 8 bits non signé
// (0 <= octet <= 255)
octet foobyte = 100;
// court - entier 16 bits
// Signé - (-32 768 <= court <= 32 767)
// Unsigned - (0 <= ushort <= 65 535)
Fooshort court = 10000;
Ushort Fooushort = 10000;
// entier - entier 32 bits
int fooint = 1;
uint foouint = 1;
// Long - entier 64 bits
Long Foolong = 100000L;
Ulong Fooulong = 10000L;
// le nombre par défaut est int ou uint (selon la taille)
// Utiliser L pour indiquer le type de valeur variable comme long ou ulong
// Double - Double numéro de point flottant IEEE 754 64 bits
Double Foodouble = 123,4;
// Float - Numéro de point flottant IEEE 754 Single Precision 32 bits 754
float foofloat = 234,5f;
// Utiliser f pour indiquer le type de valeur variable est flottant
// décimal - type de données 128 bits, avec une précision plus élevée que les autres types de points flottants, adaptés à la finance et au financement
Decimal FoodEamal = 150,3 m;
// Valeur booléenne - Vrai et faux
bool fooboolean = true;
// char - caractère unicode 16 bits unique
char foochar = 'a';
// Strings - Contrairement au type de base précédent, une chaîne n'est pas une valeur, mais une référence. Cela signifie que vous pouvez définir la chaîne sur NULL.
String Foostring = "/" Escape / "Quotes and Add / n (nouvelles lignes) et / t (onglets)";
Console.WriteLine (Foostring);
// Vous pouvez accéder à chaque caractère d'une chaîne via l'index:
char CharFromString = Foostring [1];
// La chaîne ne peut pas être modifiée: Foostring [1] = 'x' ne fonctionne pas.
// Comparez les chaînes en fonction des paramètres des paramètres régionaux actuels, insensible au cas
String.Compare (Foostring, "X", StringComparison.CurrentCultureIgnoreCase);
// Formatage de chaîne basé sur sprintf
String FOOFS = String.Format ("Check Check, {0} {1}, {0} {1: 0.0}", 1, 2);
// Date et format
DateTime Foodate = DateTime.now;
Console.WriteLine (Foodate.Tostring ("HH: MM, DD MMM YYYY"));
// Utilisez le symbole @ pour créer des chaînes entre les lignes. Utilisez "" pour représenter "
String bazstring = @ "Voici quelques trucs
Sur une nouvelle ligne! "" Wow! "", les masses ont pleuré ";
// Utilisez const ou en lecture seule pour définir les constantes, et les constantes sont calculées pendant la compilation
const int hours_i_work_per_week = 9001;
////////////////////////////////////////////////////////////////////////// / / /
// Structure de données
////////////////////////////////////////////////////////////////////////// / / /
// Array - Le comptage commence à partir de 0. Lors de la déclaration d'un tableau, vous devez déterminer la longueur du tableau.
// Le format de déclaration d'un tableau est le suivant:
// <dataType> [] <var name> = new <dataType> [<Taille du tableau>];
int [] intArray = new int [10];
// d'autres façons de déclarer et d'initialiser les tableaux:
int [] y = {9000, 1000, 1337};
// accéder aux éléments du tableau
Console.WriteLine ("IntArray @ 0:" + IntArray [0]);
// Le tableau peut être modifié
intarray [1] = 1;
// Liste
// Les listes sont plus couramment utilisées que les tableaux car les listes sont plus flexibles.
// Le format de la liste de déclaration est le suivant:
// list <dataType> <var name> = new list <dataType> ();
List <int> intList = new list <nt> ();
List <string> stringList = new list <string> ();
Liste <nt> z = nouvelle liste <nt> {9000, 1000, 1337};
// <> pour les génériques - reportez-vous à ce qui suit
// Il n'y a pas de valeur par défaut pour la liste.
intList.add (1);
Console.writeLine ("intlist @ 0:" + intList [0]);
// Autres structures de données:
// pile / file d'attente
// Dictionnaire (implémentation de la table de hachage)
// Collection de hachage
// Collection en lecture seule
// Tuple (.net 4+)
/////////////////////////////////////////////
// opérateur
/////////////////////////////////////////////
Console.writeLine ("/ n-> opérateurs");
int i1 = 1, i2 = 2; // abréviation de plusieurs déclarations
// arithmétique direct
Console.writeline (i1 + i2 - i1 * 3/7);
// Prenez le reste
Console.WriteLine ("11% 3 =" + (11% 3));
// Comparez les opérateurs
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));
// Opérateur de bits
/ *
~ Inverser
<< Déplacer à gauche (signé)
>> se déplacer à droite (signé)
& et
^ bitwise xor
| ou
* /
// auto-augmentation, auto-décorer
int i = 0;
Console.WriteLine ("/ n-> inc / dec-rement");
Console.writeLine (i ++);
Console.WriteLine (++ I);
Console.writeline (i--); // i = 1.
Console.writeline (- i);
/////////////////////////////////////////////
// Structure de contrôle
/////////////////////////////////////////////
Console.WriteLine ("/ n-> Structures de contrôle");
// Si une déclaration similaire à C
int j = 10;
if (j == 10)
{
Console.WriteLine ("I Get Imprimé");
}
sinon si (j> 10)
{
Console.WriteLine ("Je ne le fais pas");
}
autre
{
Console.WriteLine ("Je ne le fais pas aussi");
}
// Expression tripartite
// Une instruction si / else simple peut être écrite comme:
// <ord>?
String isTrue = (true)? "true": "false";
// pendant la boucle
int FoowHile = 0;
Tandis que (foowhile <100)
{
// itérations 100 fois, foowhile 0-> 99
foowHile ++;
}
// faire en boucle
int FoodowHile = 0;
faire
{
// itérations 100 fois, Foodowhile 0-> 99
FoodowHile ++;
} tandis que (foodowhile <100);
// pour Loop
// pour la structure de la boucle => pour (<condition initiale>; <Dontion>; <Stepl>)
pour (int foofor = 0; foofor <10; foofor ++)
{
// itérations 10 fois, foofor 0-> 9
}
// Boucle ForEach
// Structure de boucle foreach => foreach (<iter type> <iteter> dans <structure énumérable>)
// La boucle foreach convient à tout objet qui met en œuvre iennumable ou ienunuable.
// Types de collecte (tableaux, listes, dictionnaires ...) Dans le cadre .NET Implémentez tous ces interfaces.
// Dans le code suivant, toCharArray () peut être supprimé car la chaîne implémente également ienumable.
ForEach (personnage char dans "Hello World" .toCharArray ())
{
// itérate à travers tous les caractères de la chaîne
}
// Instruction de commutation
// Le commutateur convient aux types de données d'octets, courts, char et int.
// également applicable aux types énumérés, y compris les classes de chaînes,
// et certaines classes qui résument les valeurs originales: caractère, octet, court et entier.
int mois = 3;
String MontsTring;
Switch (mois)
{
Cas 1:
MontsTring = "janvier";
casser;
Cas 2:
MontsTring = "Février";
casser;
Cas 3:
MontsTring = "March";
casser;
// Vous pouvez faire correspondre plusieurs instructions de cas à la fois
// mais vous devez utiliser Break après avoir ajouté la déclaration de cas
// (sinon vous devez utiliser explicitement l'instruction GOTO CASE X)
Cas 6:
Cas 7:
Cas 8:
MontsTring = "Time d'été !!";
casser;
défaut:
mois à mois = "un autre mois";
casser;
}
/////////////////////////////////////////////
// Convertir la chaîne en un entier, et une exception sera lancée si la conversion échoue:
/////////////////////////////////////////////
// Conversion des données
// Convertir la chaîne en un entier, et une exception sera lancée si la conversion échoue:
int.parse ("123"); // retourne "123" de type entier
// TryParse essaiera de convertir le type, et s'il échoue, il renverra le type par défaut, tel que 0
int tryint;
if (int.tryParse ("123", out tryint)) // Funciton est booléen
Console.WriteLine (TryInt);
// convertir les entiers en chaînes
// convertissant la classe fournit une série de méthodes de conversion pratiques
Convert.tostring (123);
// ou
tryInt.toString ();
}
/////////////////////////////////////////////
// gentil
/////////////////////////////////////////////
Classes de void statique publique ()
{
// Voir la déclaration d'objet à la fin du fichier
// initialise l'objet avec nouveau
Bicycle Trek = new Bicycle ();
// appelle la méthode de l'objet
Trek.Speed (3);
trek.cadence = 100;
// Affichez les informations de l'objet.
Console.WriteLine ("Trek Info:" + trek.info ());
// instancier une nouvelle farthing
Pennyfarthing funbike = new Pennyfarthing (1, 10);
Console.WriteLine ("Funbike Info:" + funbike.info ());
Console.read ();
} // Fin de la méthode principale
// Programme terminal Le programme de terminal doit avoir une méthode principale comme entrée
public static void main (String [] args)
{
Autre InterestingFeatures ();
}
//
// fonctionnalités intéressantes
//
// Signature de la méthode par défaut
Public // Visibilité
statique // permet d'appels directs vers les classes sans créer d'abord des instances
Int // Valeur de retour
Insignations de méthodes (
int maxcount, // la première variable, le type est un entier
int count = 0, // Si aucune valeur entrante n'est passée, la valeur par défaut est 0
dans un autre = 3,
Params String [] AutreParams // Capture d'autres paramètres
)
{
retour -1;
}
// La méthode peut être renommée tant que la signature est différente
Public statique void Methodsignature (String MaxCount)
{
}
// génériques
// Les classes TKEY et TVALUE sont spécifiées lors de l'appel de la fonction avec l'utilisateur.
// La fonction suivante simule SetDefault de Python
public static tvalue setDefault <Tkey, tvalue> (
Idictionary <tkey, tvalue> dictionnaire,
Tkey Key,
Tvalue defaultItem)
{
Résultat de tvalue;
if (! Dictionary.TryGetValue (Key, Out Result))
return dictionary [key] = defaultItem;
Résultat de retour;
}
// Vous pouvez limiter la plage de valeurs entrantes
public statique void iterateAndprint <T> (t Toprint) où t: ienumerable <nt>
{
// nous pouvons itérer parce que t est énumérable
foreach (élément var en toprint)
// ittm est un entier
Console.WriteLine (item.toString ());
}
VOID STATIQUE PUBLIC AUTRES InterestingFeatures ()
{
// Paramètres facultatifs
Méthodesignatures (3, 1, 3, "Some", "Extra", "Strings");
Methodsignatures (3, un autre: 3);
// prolonger la méthode
int i = 3;
i.print (); // voir la définition ci-dessous
// peut être le type nul est très utile pour l'interaction de la base de données et les valeurs de retour.
// Tout type de valeur (c'est-à-dire n'est pas une classe) sera ajouté à un type nullable après avoir ajouté un suffixe?
// <type>?
int? nullable = null;
Console.WriteLine ("variable nullable:" + nullable);
bool hasvalue = nullable.hasvalue;
// ??
// dans le cas où la variable est nul
int notNullable = nullable ??
// Inférence de type variable
// Vous pouvez laisser le compilateur déduire des types de variables:
var magic = "Magic est une chaîne, au moment de la compilation, donc vous obtenez toujours la sécurité de type";
// Magic = 9; // ne fonctionne pas parce que la magie est une chaîne, pas un entier.
// génériques
//
Var Phonebook = new Dictionary <String, String> () {
{"Sarah", "212 555 5555"} // Ajouter une nouvelle entrée à l'annuaire téléphonique
};
// appelle setDefault défini ci-dessus comme générique
Console.WriteLine (setDefault <String, String> (répertoire téléphonique, "Shaun", "pas de téléphone"));
// Vous n'avez pas besoin de spécifier Tkey ou Tvalue, car ils seront implicitement dérivés
Console.WriteLine (SetDefault (répertoire téléphonique, "Sarah", "No Phone"));
// Lambda Expression - vous permet de résoudre des fonctions avec une ligne de code
Func <int, int> carré = (x) => x * x;
Console.writeline (carré (3));
// Gestion abandonable des ressources - vous permet de gérer facilement les ressources non gérées. La plupart des objets qui accèdent aux ressources non gérées (opérateurs de fichiers, contexte de périphérique, etc.) implémentent l'interface iDisposable.
// L'instruction Utilisation nettoiera l'objet iDisposable pour vous.
Utilisation (streamwriter writer = new StreamWriter ("Log.txt"))
{
écrivain.writeline ("Rien de suspect ici");
// À la fin de la portée, la ressource sera recyclée
// (même si une exception est lancée, elle sera toujours recyclée)
}
// Cadre parallèle
// http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
var sites Web = new String [] {
"http://www.google.com", "http://www.reddit.com",
"http://www.shaunmccarthy.com"
};
var réponses = new Dictionary <String, String> ();
// Ouvrez un nouveau thread pour chaque demande et fusionnez les résultats avant d'exécuter l'étape suivante
Parallel.ForEach (sites Web,
Nouvelles paralleloblis () {maxDegreeOfPaLailism = 3}, // max de 3 threads
Site Web =>
{
// faire quelque chose qui prend beaucoup de temps sur le fichier
Utilisation (var r = webRequest.create (New Uri (site Web)). GetResponse ())
{
Réponses [Site Web] = R.ContentType;
}
});
// Le code suivant ne sera pas exécuté tant que toutes les demandes ne seront pas remplies
foreach (clés var dans les réponses.
Console.writeLine ("{0}: {1}", key, réponses [key]);
// Objets dynamiques (il est très pratique à utiliser avec d'autres langues)
Dynamic Student = new ExpandoObject ();
Student.FirstName = "Prénom"; // Il n'est pas nécessaire de définir la classe d'abord!
// Vous pouvez même ajouter des méthodes (accepter une chaîne, sortir une chaîne)
Student.Introduce = new func <String, String> (
(introduceto) => string.format ("hey {0}, c'est {1}", student.firstName, introduceto));
Console.WriteLine (Student.Introduce ("Beth"));
// iQueryable <T> - Presque toutes les collections l'implémentent, vous apportant une approche de carte / filtre / réduction
var bikes = new List <Bicycle> ();
bikes.sort ();
bikes.sort ((b1, b2) => b1.wheels ..........
Résultat var = vélos
.Lore (b => b. roues> 3) // filtre - peut être utilisé dans les chaînes (retour à iQueryable)
.Where (b => b.Sbroken && b.hastassles)
.Select (b => b.toString ());
var sum = bikes.sum (b => b. roues);
// Créer une liste d'objets implicites générés en fonction de certains paramètres du vélo
var bikesummaries = bikes.select (b => new {name = b.name, iSawesome =! B.Sbroken && b.hastassles});
// Il est difficile à démontrer, mais le compilateur peut déduire les types d'objets ci-dessus avant la compilation du code.
foreach (var bikesummary in bikesummaries.where (b => b.isawome)))
Console.writeline (bikesummary.name);
// asparesal
// Caractéristiques maléfiques - combinant des opérations Linq et parallèles
var trois-roues = bikes.asparallel (). où (b => b. roues == 3) .Select (b => b.name);
// Le code ci-dessus s'exécutera simultanément. Le thread sera automatiquement ouvert et les résultats seront calculés séparément. Convient pour les scénarios multi-core et grandes données.
// linq - map iQueryable <T> to Storage, retarder l'exécution, telles que la base de données de mappage LinqTOSQL, les documents XML de mappage LinQTOXML.
var db = new bikeRespository ();
// L'exécution est retardée, ce qui est bon pour interroger la base de données
var filter = db.bikes.where (b => b.hastassles);
si (42> 6) // vous pouvez augmenter en continu le filtrage, y compris le filtrage conditionnel, par exemple pour la fonction de recherche avancée
filter = filter.where (b => b.sbroken);
Var Query = filtre
.Orderby (b => b. roues)
.Thenby (b => b.name)
.Select (b => b.name);
/-
foreach (vélo de ficelle en requête)
Console.WriteLine (résultat);
}
} // terminer la classe Learncsharp
// Vous pouvez inclure d'autres classes dans le même fichier .cs
Extensions publiques de classe statique
{
// Fonction étendue
Impression du public statique vide (cet objet obj)
{
Console.WriteLine (obj.toString ());
}
}
// Déclarer la syntaxe de la classe:
// <public / privé / protégé / interne> classe <nom de classe> {
// // champs de données, constructeurs, fonctions internes.
/// En Java, les fonctions sont appelées méthodes.
//}
vélo de classe publique
{
// champs de vélo et variables
public int cadence // public: accessible partout
{
get // get - définir une méthode pour obtenir des attributs
{
retour _Cadence;
}
SET // SET - Définissez une méthode pour définir les propriétés
{
_Cadence = valeur;
}
}
int _cadence privé;
Les classes et sous-classes Virtual Int Gear // protégées sont accessibles
{
obtenir;
ensemble;
}
roues int internes // interne: peut être accessible dans le même assemblage
{
obtenir;
Set privé;
}
int _speed;
Nom de la chaîne publique {get;}
// Le type d'énumération contient un ensemble de constantes qui mappent le nom sur la valeur (sauf indication contraire, un entier).
// Les types de l'élément ENMU peuvent être octets, sbyte, court, ushort, int, uint, long, ulong. Enum ne peut pas contenir la même valeur.
Brand en énumération publique
{
Aist,
BMC,
Electra = 42, // Vous pouvez affecter explicitement des valeurs
Gitane // 43
}
// Ce type que nous définissons dans la classe de vélo, il s'agit donc d'un type en ligne. Le code en dehors de cette classe doit être référencé à l'aide de Bicycle.Brand.
Marque publique de BikeBrand; // après avoir déclaré un type d'énumération, nous pouvons déclarer les champs de ce type
// Méthode statique
// Le type de la méthode statique est lui-même et n'appartient pas à un objet spécifique. Vous pouvez y accéder sans référencer des objets.
public statique int bicyclescreated = 0;
// Valeur en lecture seule
// Les valeurs en lecture seule sont déterminées à l'exécution et elles ne peuvent être attribuées que des valeurs dans la déclaration ou le constructeur.
readonly bool _hascardsInspokes = false;
// Les constructeurs sont un moyen de créer des classes.
// ci-dessous est un constructeur par défaut.
Bicycle public ()
{
this.gear = 1;
Cadence = 50; // mais vous n'en avez pas toujours
_Speed = 5;
Name = "bontrager";
Marque = bikebrand.aist;
Bicyclescreated ++;
}
// un autre exemple de constructeur (y compris les paramètres)
Public Bicycle (int startCadence, int startSpeed, int startgear,
Nom de la chaîne, Bool HascardsInspokes, BikeBrand Brand)
: base () // première base d'appel
{
Gear = startGear;
Cadence = startCadence;
_Speed = startSpeed;
Name = name;
_hascardsInspokes = HascardsInspokes;
Marque = marque;
}
// Le constructeur peut être utilisé dans les chaînes
Public Bicycle (int startCadence, int startpeed, marque de vélo):
Ceci (StartCadence, StartSpeed, 0, "Big Wheels", True, Brand)
{
}
// Syntaxe de fonction:
// <public / privé / protégé> <valeur de retour> <nom de fonction> (<paramètre>)
// Les classes peuvent implémenter des méthodes Getters et Setters pour leurs champs pour les champs, ou ils peuvent implémenter des propriétés (C # recommandé pour l'utiliser).
// Les paramètres de la méthode peuvent avoir des valeurs par défaut. Dans le cas des valeurs par défaut, les paramètres correspondants peuvent être omis lors de l'appel de la méthode.
Public vide accélération (INT incrément = 1)
{
_Speed + = incrément;
}
ralentissement public du vide (INT décrément = 1)
{
_Speed - = déclin;
}
// Les propriétés peuvent accéder et définir des valeurs. Lorsque seules les données doivent être accessibles, envisagez d'utiliser des propriétés. Les attributs peuvent définir Get and Set, ou les deux.
Bool privé _hastassles; // variable privée
Public Bool Hastassles // Accessor public
{
obtenir {return _hastassles;}
set {_hastassles = valeur;
}
// Vous pouvez définir les propriétés automatiques dans une seule ligne, et cette syntaxe créera automatiquement des champs de secours. Vous pouvez définir des modificateurs d'accès pour Getters ou Setters pour limiter leur accès.
Public Bool Isbroken {Get;
// L'implémentation des attributs peut être automatique
public int Framesize
{
obtenir;
// Vous pouvez spécifier les modificateurs d'accès pour obtenir ou définir
// Le code suivant signifie que seule la classe de vélo peut appeler l'ensemble FrameSize
ensemble privé;
}
// Méthode pour afficher les propriétés des objets
Info de chaîne virtuelle publique ()
{
Retour "Gear:" + Gear +
"Cadence:" + Cadence +
"Speed:" + _Speed +
"Nom:" + Name +
"Cartes dans les rayons:" + (_hascardsInspokes? "Oui": "non") +
"/ n ----------------------------- / n"
}
// La méthode peut être statique. Généralement utilisé dans les méthodes auxiliaires.
Bool statique publique DIDECREAEenoughbycles ()
{
// Dans les méthodes statiques, vous ne pouvez vous référer aux membres statiques de la classe
Retour BicyclesCreated> 9000;
} // Si votre classe n'a besoin que de membres statiques, envisagez de prendre toute la classe en tant que classe statique.
} // Le cours de vélo se termine
// Pennyfarthing est une sous-classe de vélo
Classe Pennyfarthing: Bicycle
{
// (Penny Farthings est un vélo avec une grande roue avant. Pas de vitesses.)
// appelle le constructeur parent
Public PennyFarthing (int startCadence, int startSpeed):
base (startCadence, startpeed, 0, "Pennyfarthing", True, bikebrand.electra)
{
}
PROTÉRÉ PROTÉRÉ INT PRIGURE
{
obtenir
{
retour 0;
}
ensemble
{
Jetez une nouvelle argumentaire ArgumentException ("Vous ne pouvez pas changer de vitesse sur Pennyfarthing");
}
}
Public Override String info ()
{
Résultat de la chaîne = "Bicycle de pennyfarthing";
Résultat + = base.toString ();
Résultat de retour;
}
}
// L'interface ne contient que la signature du membre et n'est pas implémentée.
interface ijumpable
{
vide saut (compteurs); tous les membres de l'interface sont implicitement exposés
}
interface ibreakable
{
Bool Broken {get;} // L'interface peut contenir des propriétés, des méthodes et des événements
}
// Les classes ne peuvent hériter qu'une seule classe, mais ils peuvent implémenter n'importe quel nombre d'interfaces
classe Mountainbike: vélo, ijumpable, ibreakable
{
int dommage = 0;
Saut de vide public (INT Metter)
{
dommages + = mètres;
}
Bool public cassé
{
obtenir
{
Dégâts de retour> 100;
}
}
}
/// <résumé>
/// Connectez-vous à la base de données, un exemple de linqtosql. EntityFramework Code First est génial (similaire à l'actif de Ruby, mais c'est à double sens)
/// http://msdn.microsoft.com/en-us/data/jj193542.aspx
/// </summary>
Classe publique BikeRespository: DBSET
{
public bikerePository ()
: base()
{
}
Public DBset <Bicycle> Bikes {get;};
}
} // Fin de l'espace de noms
Notez que les sujets non couverts sont:
1.Flags
2.Attributes
3. Propriétés statiques
4.Exceptions, abstrait
6.asp.net (Formulaires Web / MVC / WebMatrix)
6. Winforms
7. Windows Presentation Foundation (WPF)