La copia del código es la siguiente:
// El comentario de una sola línea comienza con //
/*
Así son los comentarios de varias líneas
*/
/// <summary>
/// Comentarios de documentos XML
/// </summary>
// Declarar el espacio de nombres utilizado por la aplicación
usando el sistema;
usando System.Collections.Generic;
usando System.Data.Entity;
usando System.Dynamic;
usando System.Linq;
usando System.Linq.Expressions;
usando System.net;
usando System.Threading.Tasks;
usando System.io;
// Definir el alcance y organizar el código en paquetes
aprendizaje del espacio de nombres
{
// Cada archivo .cs debe contener al menos una clase con el mismo nombre de archivo que
// Puede que no haga esto, pero esto no es bueno.
clase pública Learncsharp
{
// Si ha usado Java o C ++ antes, puede saltar directamente al siguiente texto "Características interesantes"
Sintaxis del vacío estático público ()
{
// usa console.writeLine para imprimir información
Console.WriteLine ("Hola mundo");
Console.WriteLine (
"Integer:" + 10 +
"Doble:" + 3.14 +
"Booleano:" + verdadero);
// Imprimir con console.write sin símbolo de ruptura de línea
Console.write ("hola");
Console.write ("mundo");
/////////////////////////////////////////////// /
// tipos y variables
//
// usar <proy> <name> para definir variables
/////////////////////////////////////////////// /
// sbyte - entero de 8 bits firmado
// (-128 <= sbyte <= 127)
sbyte foosbyte = 100;
// byte - entero de 8 bits sin firmar
// (0 <= byte <= 255)
byte foobyte = 100;
// breve - entero de 16 bits
// firmado - (-32,768 <= corto <= 32,767)
// Unsigned - (0 <= Ushort <= 65,535)
corto fooshort = 10000;
USHORT FOOUSHORT = 10000;
// entero - entero de 32 bits
int fooint = 1;
uint foouint = 1; // (0 <= uint <= 4,294,967,295)
// largo - entero de 64 bits
Long Foolong = 100000L;
ulong fooulong = 10000l;
// El número predeterminado es int o uint (dependiendo del tamaño)
// usa L para indicar el tipo de valor variable como Long o Ulong
// Doble - Número de punto flotante de 64 bits IEEE 754
Double FoodOuble = 123.4;
// Flotación - Número de punto flotante de 32 bits de 32 bits de 32 bits 754
FLOAT FOOFLAAT = 234.5F;
// use F para indicar que el tipo de valor variable es flotante
// Decimal - Tipo de datos de 128 bits, con mayor precisión que otros tipos de puntos flotantes, adecuado para finanzas y finanzas
Decimal Foodecimal = 150.3m;
// valor booleano - Verdadero y falso
bool fooBoolean = verdadero;
// char - personaje unicode único de 16 bits
char foochar = 'a';
// cadenas: a diferencia del tipo básico anterior, una cadena no es un valor, sino una referencia. Esto significa que puede configurar la cadena en NULL.
cadena Foostring = " /" Escape /"Cotizaciones y agregar /n (nuevas líneas) y /t (pestañas)";
Console.WriteLine (Foostring);
// Puede acceder a cada carácter de una cadena a través del índice:
Char CharFromString = Foostring [1];
// La cadena no se puede modificar: Foostring [1] = 'x' no funciona.
// Compare cadenas de acuerdo con la configuración de la regal de la ubicación actual, insensible a los casos
String.Compare (FooString, "X", StringComparison.CurrentCultureInignReCase);
// formato de cadena basado en sprintf
string foofs = string.format ("check check, {0} {1}, {0} {1: 0.0}", 1, 2);
// Fecha y formato
DateTime Foodate = DateTime.NOW;
Console.WriteLine (Foodate.ToString ("HH: MM, DD MMM yyyy"));
// Use el símbolo @ para crear cadenas a través de las líneas. Use "" para representar "
string bazstring = @"aquí hay algunas cosas
En una nueva línea!
// Use const o solo lectura para definir constantes, y las constantes se calculan durante la compilación
const int Sours_i_work_per_week = 9001;
/////////////////////////////////////////////// /
// Estructura de datos
/////////////////////////////////////////////// /
// matriz: el recuento comienza desde 0. Al declarar una matriz, debe determinar la longitud de la matriz.
// El formato de declarar una matriz es el siguiente:
// <satatype> [] <var name> = new <Statatype> [<Array size>];
int [] intArray = new int [10];
// Otras formas de declarar e inicializar matrices:
int [] y = {9000, 1000, 1337};
// Acceda a los elementos de la matriz
Console.WriteLine ("Intarray @ 0:" + Intarray [0]);
// La matriz se puede modificar
Intarray [1] = 1;
// Lista
// Las listas se usan más comúnmente que las matrices porque las listas son más flexibles.
// El formato de la lista de declaraciones es el siguiente:
// lista <satatype> <var name> = nueva lista <satatype> ();
List <int> intlist = new List <Sint> ();
List <String> StringList = New List <String> ();
Lista <int> z = nueva lista <int> {9000, 1000, 1337};
// <> para genéricos: consulte lo siguiente
// No hay un valor predeterminado para la lista.
intlist.add (1);
Console.WriteLine ("intlist @ 0:" + intlist [0]);
// Otras estructuras de datos:
// pila/cola
// diccionario (implementación de la tabla hash)
// colección hash
// colección de solo lectura
// tuple (.net 4+)
////////////////////////////////////
// operador
////////////////////////////////////
Console.WriteLine ("/n-> operadores");
int i1 = 1, i2 = 2;
// aritmética directa
Console.WriteLine (I1 + I2 - I1 * 3/7);
// tomar el resto
Console.WriteLine ("11%3 =" + (11%3));
// Comparar operadores
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));
// operador de bits
/*
~ Reverso
<< Mover a la izquierda (firmado)
>> Mover a la derecha (firmado)
& y
^ xor bit a bit
|
*/
// autoincrita, autodecrurar
int i = 0;
Console.WriteLine ("/n-> inc/dec-lementation");
Console.WriteLine (i ++);
Console.writeLine (++ i);
Console.WriteLine (i--);
Console.WriteLine (-i);
////////////////////////////////////
// Estructura de control
////////////////////////////////////
Console.WriteLine ("/n-> estructuras de control");
// Si la declaración similar a C
int j = 10;
if (j == 10)
{
Console.WriteLine ("Me imprimo");
}
más si (j> 10)
{
Console.WriteLine ("Yo no");
}
demás
{
Console.WriteLine ("Yo también no");
}
// expresión tripartita
// Una instrucción Simple IF/Else se puede escribir como:
// <condición>?
cadena istrue = (verdadero)?
// mientras bucle
int foowhile = 0;
Mientras (foowhile <100)
{
// iteraciones 100 veces, foowhile 0-> 99
foowhile ++;
}
// hacer mientras bucle
int foodowhile = 0;
hacer
{
// iteraciones 100 veces, Foodowhile 0-> 99
Foodowhile ++;
} while (foodowhile <100);
// para bucle
// para estructura de bucle => para (<condición inicial>; <dition>; <stone>)
para (int foofor = 0; foofor <10; foofor ++)
{
// iteraciones 10 veces, Foofor 0-> 9
}
// bucle foreach
// foreach loop structure => foreach (<iter type> <iter> en <enumerable estructura>)
// El bucle foreach es adecuado para cualquier objeto que implementa IEnumerable o ienumerable.
// tipos de colección (matrices, listas, diccionarios ...) En el marco .NET, todos implementan estas interfaces.
// En el siguiente código, ToCarArray () se puede eliminar porque la cadena también implementa IEnumerable.
foreach (personaje de char en "Hello World" .toCarArray ())
{
// iterar a través de todos los caracteres de la cadena
}
// Declaración de cambio
// El interruptor es adecuado para los tipos de datos Byte, Short, Char e Int.
// también aplicable a tipos enumerables, incluidas las clases de cadena,
// y algunas clases que encapsulan los valores originales: carácter, byte, corto e entero.
int mes = 3;
Meses de cadena de tracción;
interruptor (mes)
{
Caso 1:
Mesesstring = "enero";
romper;
Caso 2:
Mesesstring = "febrero";
romper;
Caso 3:
messtring = "marzo";
romper;
// puede hacer coincidir múltiples declaraciones de casos a la vez
// pero debe usar el descanso después de agregar la declaración del caso
// (de lo contrario, debe usar explícitamente la instrucción GOTO Case X)
Caso 6:
Caso 7:
Caso 8:
messtring = "¡Tiempo de verano!";
romper;
por defecto:
messtring = "algún otro mes";
romper;
}
////////////////////////////////////
// Convierta la cadena en un entero, y se lanzará una excepción si la conversión falla:
////////////////////////////////////
// Convertir datos
// Convierta la cadena en un entero, y se lanzará una excepción si la conversión falla:
int.parse ("123"); // return "123" de tipo entero
// TryParse intentará convertir el tipo, y si falla, devolverá el tipo predeterminado, como 0
int tyint;
if (int.tryparse ("123", out intyint)) // el funcido es booleano
Console.WriteLine (Tryint);
// Convertir enteros en cadenas
// Convertir la clase proporciona una serie de métodos de conversión convenientes
Convert.ToString (123);
// o
Tryint.ToString ();
}
////////////////////////////////////
// amable
////////////////////////////////////
Clases de vacío estático público ()
{
// Consulte la declaración de objeto al final del archivo
// Inicializar el objeto con nuevo
Bicicleta Trek = nueva bicicleta ();
// llamar al método de objeto
trek.speedup (3);
trek.cadence = 100;
// Ver la información del objeto.
Console.WriteLine ("Trek Info:" + trek.info ());
// instanciar un nuevo Penny Farthing
Pennyfarthing Funbike = New Pennyfarthing (1, 10);
Console.WriteLine ("Funbike Info:" + funbike.info ());
Console.read ();
} // finalizar el método principal
// Programa terminal El programa terminal debe tener un método principal como entrada
Public static void main (String [] args)
{
OtrointerestingFeatures ();
}
//
// características interesantes
//
// firma de método predeterminado
público // visibilidad
static // permite llamadas directas a clases sin crear instancias primero
int // Valor de retorno
Métodos de diseño (
int maxcount, // La primera variable, el tipo es un entero
int count = 0, // Si no se pasa ningún valor entrante, el valor predeterminado es 0
int otro = 3,
parámetros cadena [] OtherParams // Capture otros parámetros
)
{
regreso -1;
}
// El método puede cambiar el nombre siempre que la firma sea diferente
Methodessignature de vacío estático público (String MaxCount)
{
}
// Genéricos
// Las clases TKEY y TVALUE se especifican al llamar a la función con el usuario.
// La siguiente función simula el setdefault de Python
Public Static Tvalue setDefault <tkey, tvalue> (
Idictionary <tkey, tvalue> diccionario,
Tecla de Tkey,
Tvalue defaultItem)
{
Resultado de TVALUE;
if (! Dictionary.trygetValue (clave, resultado fuera))
return Dictionary [Key] = DefaultIm;
resultado de retorno;
}
// Puede limitar el rango de valores entrantes
Public static void iterate yprint <t> (t toprint) donde t: ienumerable <int>
{
// Podemos iterar porque es enumerable
foreach (elemento var en toprint)
// ittm es un entero
Console.WriteLine (item.ToString ());
}
Public static void othreinterestingFeatures ()
{
// Parámetros opcionales
Methodsignatures (3, 1, 3, "algunos", "extra", "cadenas");
Methodsignure (3, otro: 3);
// extender el método
int i = 3;
i.print ();
// puede ser de tipo nulo es muy útil para la interacción de la base de datos y los valores de retorno.
// ¿Se agregará cualquier tipo de valor (es decir, una clase) a un tipo anulable después de agregar un sufijo?
// <proye>? <Nombre variable> = <valor>
int? Nullable = NULL;
Console.WriteLine ("Variable anulable:" + Nullable);
bool hasvalue = nullable.hasvalue;
//?
// en caso de que la variable sea nula
int nonullable = Nullable?
// Inferencia de tipo variable
// Puede dejar que el compilador infiera tipos de variables:
var magic = "La magia es una cadena, en el momento de la compilación, por lo que todavía obtienes el tipo de seguridad";
// Magic = 9;
// Genéricos
//
VAR PhoneBook = New Dictionary <String, String> () {
{"Sarah", "212 555 5555"} // Agregar nueva entrada a la guía telefónica
};
// Llamar setDefault definido anteriormente como genérico
Console.WriteLine (setDefault <String, String> (Libera telefónica, "Shaun", "Sin teléfono"));
// No necesita especificar TKEY o TVALUE, porque se derivan implícitamente
Console.WriteLine (SetDefault (Libera telefónica, "Sarah", "Sin teléfono"));
// Expresión de lambda: le permite resolver funciones con una línea de código
Func <int, int> square = (x) => x * x;
Console.WriteLine (cuadrado (3));
// Gestión de recursos abandonables: le permite tratar fácilmente con recursos no administrados. La mayoría de los objetos que acceden a los recursos no administrados (operadores de archivos, contexto del dispositivo, etc.) implementan la interfaz IDISPosible.
// La declaración de uso de Using limpiará el objeto idisible para usted.
Usando (streamwriter escritor = nuevo streamwriter ("log.txt"))
{
Writer.Writeline ("Nada sospechoso aquí");
// Al final del alcance, el recurso se reciclará
// (incluso si se lanza una excepción, aún se reciclará)
}
// marco paralelo
// http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-netframework-4-getting-started.aspx
sitios web var = new String [] {
"http://www.google.com", "http://www.reddit.com",
"http://www.shaunmccarthy.com"
};
respuestas var = new Dictionary <String, String> ();
// Abra un nuevo hilo para cada solicitud y fusione los resultados antes de ejecutar el siguiente paso
Paralelo.Foreach (sitios web,
New ParallElOptions () {maxDegeeOfParallelism = 3}, // max de 3 hilos
sitio web =>
{
// Haz algo que lleva mucho tiempo en el archivo
usando (var r = webRequest.create (nuevo URI (sitio web)). GetResponse ())
{
Respuestas [Sitio web] = R.ContentType;
}
});
// El siguiente código no se ejecutará hasta que se completen todas las solicitudes
foreach (clave var en respuestas. keeys)
Console.WriteLine ("{0}: {1}", clave, respuestas [clave]);
// Objetos dinámicos (es muy conveniente de usar con otros idiomas)
Estudiante dinámico = new ExpandoObject ();
Student.FirstName = "Nombre";
// incluso puede agregar métodos (aceptar una cadena, emitir una cadena)
student.InTroDuce = new Func <String, String> (
(introductO) => String.Format ("Hey {0}, esto es {1}", student.firstname, introductOTo));
Console.WriteLine (Student.IntroDuce ("Beth"));
// iqueryable <t> - casi todas las colecciones lo implementan, brindándole un enfoque de estilo de mapa/filtro/reducción
var bicicleta = nueva lista <Bicycle> ();
bicicleta.sort ();
bikes.sort ((b1, b2) => b1.wheels.compareto (b2.wheels));
resultado var = bicicletas
Donde (b => b .wheels> 3) // filtro - se puede usar en cadenas (regresar a iqueryable)
Donde (b => b.isbreaking && b.hastassles)
.Select (b => B.ToString ());
var sum = bikes.sum (b => b.wheels);
// Cree una lista de objetos implícitos generados en función de algunos parámetros de la bicicleta
var bikesummies = bikes.select (b => new {name = b.name, isawesome =! b.isbreaken && b.hastassles});
// es difícil de demostrar, pero el compilador puede deducir los tipos de objetos anteriores antes de compilarse el código.
foreach (var bikesummary en bikesummars.where (b => b. isavome))
Console.WriteLine (bikesummary.name);
// asparalelo
// Características malvadas: combinando las operaciones LINQ y paralelas
var treswheelers = Bikes.AsParallel (). Donde (b => b.wheels == 3) .select (b => b.name);
// El código anterior se ejecutará simultáneamente. El hilo se abrirá automáticamente y los resultados se calcularán por separado. Adecuado para escenarios de datos múltiples y grandes.
// Linq: mapee iqueryable <t> para almacenamiento, ejecución de retraso, como la base de datos de mapeo de Linqtosql, los documentos XML de asignación de Linqtoxml.
var db = new BikereSpository ();
// La ejecución se retrasa, lo cual es bueno para consultar la base de datos
filtro var = db.bikes. Donde (b => b.hastassles);
Si (42> 6) // puede aumentar continuamente el filtrado, incluido el filtrado condicional, por ejemplo para la función de búsqueda avanzada
filtro = filtro. Where (b => B.isbreak
consulta var = filtro
.Orderby (b => b.wheels)
.Thenby (b => b.name)
.Select (b => b.name);
// ahora ejecuta la consulta, y se abrirá un lector cuando ejecute la consulta, por lo que itera sobre una copia
foreach (bicicleta de cuerda en la consulta)
Console.writeLine (resultado);
}
} // finalizar la clase Learncsharp
// Puede incluir otras clases en el mismo archivo .cs
Extensiones de clase estática pública
{
// función extendida
Impresión vacía estática pública (este objeto obj)
{
Console.WriteLine (obj.ToString ());
}
}
// Declarar la sintaxis de la clase:
// <público/privado/protegido/interno> class <class name> {
// // campos de datos, constructores, funciones internas.
/// En Java, las funciones se denominan métodos.
//}
bicicleta de clase pública
{
// campos y variables de bicicletas
Public int Cadence // Public: Accessible en cualquier lugar
{
Get // Get - Define un método para obtener atributos
{
return _cadence;
}
set // set: defina un método para establecer propiedades
{
_cadence = valor;
}
}
private int _cadence;
Se puede acceder a las clases y subclases de INT virtual protegidos
{
obtener; / crear una propiedad automática sin campos
colocar;
}
ruedas int internas // interno: se puede acceder dentro del mismo ensamblaje
{
conseguir;
Conjunto privado;/puede agregar modificadores al método get/set
}
int _speed ;// El valor predeterminado es privado: solo se puede acceder dentro de esta clase, también puede usar la palabra clave 'privada'
Nombre de cadena pública {Get;
// El tipo de enumación contiene un conjunto de constantes que asignan el nombre al valor (a menos que se especifique lo contrario, un entero).
// Los tipos del elemento Enmu pueden ser byte, sbyte, short, ushort, int, uint, long, ulong. Enum no puede contener el mismo valor.
Public enum bicicleta
{
Aist,
BMC,
Electra = 42, // Puede asignar valores explícitamente
Gitane // 43
}
// Este tipo que definimos en la clase de bicicleta, por lo que es un tipo en línea. El código fuera de esta clase debe ser referenciado utilizando Bicycle.BRAND.
marca de bicicleta pública;
// método estático
// El tipo de método estático es en sí mismo y no pertenece a un objeto específico. Puede acceder a ellos sin hacer referencia a objetos.
static public int BicyclesCreated = 0;
// valor de solo lectura
// Los valores de solo lectura se determinan en tiempo de ejecución y solo se les puede asignar valores dentro de la declaración o constructor.
Readonly bool _hascardsinspokes = falso;
// Los constructores son una forma de crear clases.
// A continuación se muestra un constructor predeterminado.
Public Bicycle ()
{
this.gear = 1;
Cadencia = 50;
_speed = 5;
Nombre = "Bontrager";
Brand = BikeBrand.aist;
Bicicletas creadas ++;
}
// Otro ejemplo de constructor (incluidos los parámetros)
Public Bicycle (Int StartCadence, Int StartSpeed, int Startgear,
Nombre de la cadena, Bool HaCardsinSpokes, marca de bicicletas)
: base () // primera base de llamadas
{
Gear = startgear;
Cadencia = startCadence;
_speed = startspeed;
Nombre = nombre;
_HascardsinSpokes = HASCARDSINSPOKES;
Marca = marca;
}
// El constructor se puede usar en cadenas
Public Bicycle (Int StartCadence, Int StartSpeed, BikeBebrand Brand):
Esto (StartCadence, StartSpeed, 0, "Big Wheels", True, Brand)
{
}
// Sintaxis de funciones:
// <público/privado/protegido> <valor de retorno> <nombre de la función> (<Parameter>)
// Las clases pueden implementar métodos de Getters y Setters para sus campos para campos, o pueden implementar propiedades (C# recomendado para usar esto).
// Los parámetros del método pueden tener valores predeterminados. En el caso de los valores predeterminados, los parámetros correspondientes se pueden omitir al llamar al método.
Speedup del vacío público (int increment = 1)
{
_speed += increment;
}
La desaceleración del vacío público (int disminución = 1)
{
_speed -= decline;
}
// Las propiedades pueden acceder y establecer valores. Cuando solo se necesitan datos, considere usar propiedades. Los atributos pueden definir Get and Set, o ambos.
bool privado _hastassles;
Public Bool Hastassles // Accesor público
{
Obtener {return _hastassles;
establecer {_hastassles = valor;
}
// Puede definir propiedades automáticas dentro de una línea, y esta sintaxis creará automáticamente campos de retroceso. Puede establecer modificadores de acceso para obtener Getters o Setters para limitar su acceso.
Public Bool Isbreak {Get;
// La implementación de atributos puede ser automática
Public int Framesize
{
conseguir;
// puede especificar modificadores de acceso para obtener o establecer
// El siguiente código significa que solo la clase de bicicleta puede llamar al conjunto de Framesize
conjunto privado;
}
// método para mostrar las propiedades del objeto
Información pública de cadena virtual ()
{
regresar "Gear:" + Gear +
"Cadence:" + cadencia +
"Velocidad:" + _speed +
"Nombre:" + Nombre +
"Tarjetas en Spokes:" + (_hascardsinspokes? "Sí": "No") +
"/N ------------------------------/N"
}
// El método puede ser estático. Generalmente se usa en métodos auxiliares.
Bool estática pública didwecreateenughbycles ()
{
// En métodos estáticos, solo puede consultar miembros estáticos de la clase
devolver bicicletas creadas> 9000;
} // Si su clase solo necesita miembros estáticos, considere tomar toda la clase como una clase estática.
} // termina la clase de bicicleta
// Pennyfarthing es una subclase de bicicleta
clase Pennyfarthing: bicicleta
{
// (Penny Farthings es una bicicleta con una gran rueda delantera. Sin engranajes).
// llamar al constructor matriz
Public Pennyfarthing (int StartCadence, int StartSpeed):
Base (StartCadence, StartSpeed, 0, "Pennyfarthing", True, BikeBrand.Electra)
{
}
anulación protegida int el equipo
{
conseguir
{
regresar 0;
}
colocar
{
arrojar una nueva ArgumentException ("No se puede cambiar de marcha en Pennyfarthing");
}
}
Información de cadena de anulación pública ()
{
Resultado de cadena = "Pennyfarthing Bicycle";
resultado += base.ToString ();
resultado de retorno;
}
}
// La interfaz solo contiene la firma del miembro y no se implementa.
interfaz iJumpable
{
salto vacío (int medidores);
}
interfaz ibreakable
{
bool roto {get;
}
// Las clases solo pueden heredar una clase, pero pueden implementar cualquier cantidad de interfaces
Class Mountainbike: Bicicleta, Ijumpable, Ibreakable
{
int daño = 0;
Public Void Jump (int medidores)
{
daño += metros;
}
Público bool roto
{
conseguir
{
Daño de retorno> 100;
}
}
}
/// <summary>
/// Conéctese a la base de datos, un ejemplo de Linqtosql. EntityFramework Code First es genial (similar al Activerecord de Ruby, pero es de dos vías)
/// http://msdn.microsoft.com/en-us/data/jj193542.aspx
/// </summary>
Bikerespository de clase pública: DBSET
{
Public Bikerespository ()
: base()
{
}
Public dbset <Bicicleta> Bikes {Get;
}
} // final del espacio de nombres
Tenga en cuenta que los temas no cubiertos son:
1.Flags
2.Tributas
3. Propiedades estáticas
4. Excepciones, abstracto
6.asp.net (formularios web/MVC/Webmatrix)
6. Winforms
7. Windows Presentation Foundation (WPF)