Sintaxis de C#

Una palabra clave contextual se utiliza para proporcionar un significado específico en el código, pero no es una palabra reservada en C#. Algunas palabras clave contextuales, como partialy where, tienen significados en múltiples contextos. Las siguientes 42 palabras clave de C# son contextuales. ^{[ 5 ]}

Although C# does not have a separate preprocessor, unlike C and C++ which use the C preprocessor, these 13 directives are processed as if there were one.

Starting in C# 7.0, the underscore symbol can be used to separate digits in number values for readability purposes. The compiler ignores these underscores.^[6]

intbin=0b1101_0010_1011_0100;inthex=0x2F_BB_4A_F1;intdec=1_000_500_954;doublereal=1_500.200_2e-1_000;

Generally, separators may be put only between digit characters. It cannot be put at the beginning (_121) or the end of the value (121_ or 121.05_), next to the decimal in floating point values (10_.0), next to the exponent character (1.1e_1), or next to the type specifier (10_f).

Esta es una característica de C# 3.0 .

C# 3.0 introdujo la inferencia de tipos , lo que permite reemplazar el especificador de tipo de una declaración de variable por la palabra clave `type` var, si su tipo real se puede determinar estáticamente a partir del inicializador. Esto reduce la repetición, especialmente para tipos con múltiples parámetros de tipo genéricos , y se ajusta más al principio DRY ( Don't Repeat Yourself).

var myChars = new char [] { 'A' , 'Ö' }; // equivalente a: char [] myChars = new char [] { 'A' , 'Ö' };var myNums = new List < int > (); // equivalente a: List < int > myNums = new List < int > ();

Al declarar una variable local o un campo con la constpalabra clave como prefijo, el valor debe especificarse al declararlo. Posteriormente, el valor no puede cambiar. Pueden declararse en el contexto como un campo o una variable local. ^{[ 10 ]} Las constantes son implícitamente estáticas.

const double PI = 3.14 ;

Esto muestra ambos usos de la palabra clave.

clase pública Foo { const doble privado X = 3 ;public Foo () { const int y = 2 ; } }

La readonlypalabra clave hace algo similar a los campos. Al igual que los campos marcados como tales, constsu valor no puede cambiar una vez inicializado. La diferencia es que se puede optar por inicializarlos en un constructor o con un valor que no se conoce hasta el tiempo de ejecución. ^{[ 12 ]} Esto funciona solo con campos. readonlyLos campos pueden ser miembros de una instancia o miembros estáticos de una clase.

Esta es una característica de C# 7.1.

Las tareas asíncronas se pueden esperar en el Mainmétodo declarando el tipo de retorno del método como Task.

static async Task Main ( string [] args ) { await DoWorkAsync ( 42 ); }

Se admiten todas las combinaciones de Task, o Task<int>,y con o sin el parámetro.string[] args

Esta directiva carga los miembros estáticos de un tipo específico en el ámbito actual, haciéndolos accesibles directamente por el nombre del miembro.usingstatic

usando el sistema estático.Console ;​WriteLine ( "Hola, mundo!" );

Desde C# 10, es legal escribir directivas para indicar una directiva una sola vez y aplicarla a todos los archivos fuente.globalusingusing

global usando System ; global usando Microsoft.Extensions.FileSystemGlobbing ;

El asoperador intentará realizar una conversión implícita a un tipo determinado. Si es posible, devolverá el objeto con el nuevo tipo; de lo contrario, devolverá null.

Stream stream = File . Open ( @"C:\Temp\data.dat" ); FileStream fstream = stream as FileStream ; // Devolverá un objeto.String str = stream as String ; // Devolverá null.

La ifinstrucción se ejecuta cuando se cumple la condición dada. Las instrucciones case de una sola línea no requieren llaves de bloque, aunque por convención suelen ser las preferidas.

Una simple declaración de una sola línea:

si ( i == 3 ) ... ;

Varias líneas con bloque else (sin llaves):

si ( i == 2 ) ... si no ...

Convenciones de codificación recomendadas para una sentencia if.

si ( i == 3 ) { ... } si no si ( i == 2 ) { ... } si no { ... }

La switchestructura sirve como filtro para diferentes valores. Cada valor conduce a un "caso". No se permite pasar de una sección de caso a otra, por lo que la palabra clave breakse usa normalmente para finalizar un caso. Una condición incondicional returndentro de una sección de caso también puede usarse para finalizar un caso. gotoLas sentencias pueden usarse para pasar de un caso al siguiente. El caso predeterminado maneja todos los casos que no son manejados explícitamente por la estructura.

switch ( ch ) { case 'A' : instrucción ; ... break ; case 'B' : instrucción ; break ; case 'C' : // Una sección switch puede tener múltiples etiquetas case. case 'D' : ... break ; default : ... break ; }

El forbucle consta de tres partes: declaración , condición y expresión de contador . Todas son opcionales.

para ( int i = 0 ; i < 10 ; i ++ ) { ... }

Es equivalente a este código representado con una whileinstrucción, excepto que aquí la ivariable no es local al bucle.

int i = 0 ; mientras ( i < 10 ) { //... i ++ ; }

La foreachinstrucción se deriva de la forinstrucción y utiliza un patrón determinado descrito en la especificación del lenguaje C# para obtener y utilizar un enumerador de elementos sobre los que iterar.

Cada elemento de la colección dada se devuelve en el contexto del bloque de código. Cuando se ejecuta el bloque, se devuelve el siguiente elemento hasta que no queden más.

para cada ( int i en intList ) { ... }

Las etiquetas son puntos en el código a los que se puede saltar mediante la gotoinstrucción.

inicio : ....... ir a inicio ;

Tenga en cuenta que la etiqueta no tiene por qué estar colocada después de la gotoinstrucción; puede estar antes de ella en el archivo fuente.

Esta gotoinstrucción se puede utilizar en switchsentencias para pasar de un caso a otro o para continuar de un caso al siguiente.

switch ( n ) { case 1 : Console . WriteLine ( "Caso 1" ); break ; case 2 : Console . WriteLine ( "Caso 2" ); goto case 1 ; case 3 : Console . WriteLine ( "Caso 3" ); case 4 : // La compilación fallará aquí ya que los casos no pueden continuar en C#. Console . WriteLine ( "Caso 4" ); goto default ; // Esta es la forma correcta de continuar al siguiente caso. case 5 : // Se permiten múltiples etiquetas para el mismo código case 6 : default : Console . WriteLine ( "Predeterminado" ); break ; // Incluso el valor predeterminado no debe llegar al punto final }

La breakinstrucción sale del bucle o switchinstrucción más cercana. La ejecución continúa en la instrucción posterior a la instrucción que finalizó, si la hay.

int e = 10 ; for ( int i = 0 ; i < e ; i ++ ) { while ( true ) { break ; } // Se detendrá en este punto. }

Esta continueinstrucción interrumpe la iteración actual de la instrucción de control actual y comienza la siguiente iteración.

int ch ; while (( ch = Console.Read ( )) != -1 ) { if ( ch == '' ) { continue ; // Salta el resto del bucle while }// Resto del bucle while ... }

El whilebucle en el código anterior lee caracteres llamando a , omitiendo las instrucciones en el cuerpo del bucle si los caracteres son espacios.GetChar()

Las excepciones se gestionan dentro de bloques.try...catch

try { // Instrucciones que pueden generar excepciones ... } catch ( Exception ex ) { // Excepción capturada y manejada aquí ... } finally { // Instrucciones que siempre se ejecutan después de los bloques try/catch ... }

Las instrucciones dentro del trybloque se ejecutan y, si alguna de ellas genera una excepción, la ejecución del bloque se interrumpe y la excepción se gestiona catch. Puede haber varios catchbloques; en ese caso, se ejecuta el primer bloque que contenga una variable de excepción cuyo tipo coincida con el tipo de la excepción generada.

Si ningún bloque coincide con el tipo de la excepción lanzada, se interrumpe catchla ejecución del bloque (o método) externo que contiene la instrucción, y la excepción se propaga hacia arriba, fuera del bloque o método contenedor. La excepción se propaga hacia arriba a través de la pila de llamadas hasta que se encuentra un bloque coincidente dentro de uno de los métodos activos. Si la excepción se propaga hasta el método superior sin encontrar un bloque coincidente , se termina el programa completo y se escribe una descripción textual de la excepción en la salida estándar.try ... catchcatchMain()catch

Las instrucciones dentro del finallybloque siempre se ejecutan después de los bloques tryy catch, independientemente de si se produjo una excepción o no.

Después del bloque debe ir un catchbloque, otro finallybloque o ambos .try

Las estructuras se conocen comúnmente como structs . Las estructuras son tipos de valor definidos por el usuario que se declaran mediante la structpalabra clave `struct`. Son similares a las clases, pero más adecuadas para tipos ligeros. Algunas diferencias sintácticas importantes entre una clase y una estructura se presentan más adelante en este artículo .

struct Foo { ... }

Los tipos de datos primitivos son todos estructuras.

Los tipos enumerados (declarados con enum) son valores con nombre que representan valores enteros.

enum Season { Winter = 0 , Spring = 1 , Summer = 2 , Autumn = 3 , Fall = Autumn // Autumn se llama Fall en inglés americano. }

Las variables de enumeración se inicializan por defecto a cero. Se les pueden asignar o inicializar con los valores con nombre definidos por el tipo de enumeración.

Temporada temporada ; temporada = Temporada . Primavera ;

Las variables de tipo enumeración son valores enteros. Se permite la suma y la resta entre variables del mismo tipo sin necesidad de una conversión explícita, pero la multiplicación y la división son más arriesgadas y requieren dicha conversión. También se requieren conversiones para convertir variables enumeraciones a y desde tipos enteros. Sin embargo, la conversión no genera una excepción si el valor no está especificado en la definición del tipo.

temporada = ( Temporada ) 2 ; // convierte 2 a un valor enum de tipo Temporada. temporada = temporada + 1 ; // Agrega 1 al valor. temporada = temporada + temporada2 ; // Agrega los valores de dos variables enum. int valor = ( int ) temporada ; // Convierte el valor enum a un valor entero.temporada ++ ; // Temporada.Primavera (1) se convierte en Temporada.Verano (2). temporada -- ; // Temporada.Verano (2) se convierte en Temporada.Primavera (1).

Los valores se pueden combinar utilizando el operador OR bit a bit |.

Color myColors = Color . Verde | Color . Amarillo | Color . Azul ;

Un tipo de array es un tipo de referencia que alude a un espacio que contiene uno o más elementos de un tipo determinado. Todos los tipos de array derivan de una clase base común . Cada elemento se referencia mediante su índice, como en C++ y Java.System.Array

Un array en C# es lo que en C++ se denomina un array dinámico .

int [] números = nuevo int [ 2 ]; números [ 0 ] = 2 ; números [ 1 ] = 5 ; int x = números [ 0 ];

// Sintaxis larga int [] numbers = new int [ 5 ]{ 20 , 1 , 42 , 15 , 34 }; // Sintaxis corta int [] numbers2 = { 20 , 1 , 42 , 15 , 34 }; // Sintaxis inferida var numbers3 = new [] { 20 , 1 , 42 , 15 , 34 };

int [,] números = nuevo int [ 3 , 3 ]; números [ 1 , 2 ] = 2 ;int [,] numbers2 = new int [ 3 , 3 ] { { 2 , 3 , 2 }, { 1 , 2 , 6 }, { 2 , 4 , 5 } };

Las clases son tipos de referencia autodescriptivos definidos por el usuario. Básicamente, todos los tipos en .NET Framework son clases, incluyendo estructuras y enumeraciones, que son clases generadas por el compilador. Los miembros de una clase son privatepúblicos por defecto, pero se pueden declarar para publicque sean visibles fuera de la clase o protectedpara que sean visibles para cualquier descendiente de la misma.

string text = " ¡ Hola Mundo!" ; string substr = text.Substring ( 0 , 5 ) ; string [] parts = text.Split ( new char []{ ' ' } );

StringBuilder sb = new StringBuilder (); sb . Append ( 'H' ); sb . Append ( "el" ); sb . AppendLine ( "lo!" );

Las interfaces son estructuras de datos que contienen definiciones de miembros sin implementaciones. Una variable de un tipo de interfaz es una referencia a una instancia de una clase que implementa esta interfaz. Véase #Interfaces .

C# proporciona punteros a funciones orientadas a objetos con seguridad de tipos en forma de delegados .

clase Programa { // Tipo de delegado: delegate int Operación ( int a , int b );static int Add ( int i1 , int i2 ) { return i1 + i2 ; }static int Sub ( int i1 , int i2 ) { return i1 - i2 ; }static void Main () { // Instanciar el delegado y asignarle el método. Operación op = Agregar ;// Llama al método al que apunta el delegado. int result1 = op ( 2 , 3 ); // 5op = Sub ; int result2 = op ( 10 , 2 ); // 8 } }

Inicializando el delegado con un método anónimo.

adición = delegado ( int a , int b ) { return a + b ; };

Inicializando el delegado con una expresión lambda.

suma = ( a , b ) => a + b ;

Los eventos son punteros que pueden apuntar a múltiples métodos. Más precisamente, vinculan punteros de métodos a un identificador. Por lo tanto, esto puede considerarse una extensión de los delegados . Se utilizan habitualmente como disparadores en el desarrollo de interfaces de usuario. El formato utilizado en C# y el resto de la Infraestructura de Lenguaje Común se basa en el Visual Basic clásico .

usando System.Windows.Controls ;delegate void MouseEventHandler ( object sender , MouseEventArgs e );clase pública Botón : Control { evento privado MouseEventHandler _onClick ;/* Función de activación imaginaria */ void Click () { _onClick ( this , new MouseEventArgs ( data )); } }

Un evento requiere un controlador de eventos asociado , el cual se crea a partir de un delegado especial que, en una biblioteca específica de la plataforma, como Windows Presentation Foundation y Windows Forms, suele aceptar dos parámetros: el remitente y los argumentos del evento . El tipo del objeto de argumentos del evento deriva de la clase EventArgs, que forma parte de la biblioteca base de la CLI.

Una vez declarado en su clase, la única forma de invocar el evento es desde dentro del propietario. Se puede implementar un método de escucha externo que se activará cuando se dispare el evento.

public class MainWindow : System . Windows . Controls . Window { private Button _button1 ;public MainWindow () { _button1 = new Button (); _button1 . Text = "¡Haz clic aquí!" ;/* Suscribirse al evento */ _button1 . ClickEvent += Button1_OnClick ;/* Sintaxis alternativa que se considera antigua:  _button1.MouseClick += new MouseEventHandler(Button1_OnClick); */ }protected void Button1_OnClick ( object sender , MouseEventArgs e ) { MessageBox.Show ( " ¡ Clic!" ); } }

También es posible la implementación de eventos personalizados:

private EventHandler _clickHandles = ( s , e ) => { };evento público EventHandler Click { agregar { // Código que se ejecutará cuando se agregue el controlador... ..._clickHandles += valor ; } remove { // Código que se ejecutará cuando se elimine el controlador... ..._clickHandles -= valor ; } }

Véase también

• Programación basada en eventos

Esta es una característica de C# 2.0 .

Los tipos anulables se introdujeron en C# 2.0, en primer lugar, para permitir que los tipos de valor fueran nulos (algo útil al trabajar con una base de datos).

int? n = 2 ; n = null ;Console.WriteLine ( n.HasValue ) ;​​​

Esto es lo mismo que usar la estructura.Nullable<T>

Nullable < int > n = 2 ; n = null ;Console.WriteLine ( n.HasValue ) ;​​​

C# tiene y permite punteros a tipos seleccionados (algunos tipos primitivos, enumeraciones, cadenas, punteros e incluso matrices y estructuras si contienen solo tipos a los que se puede apuntar ^{[ 14 ]} ) en contextos no seguros: métodos y bloques de código marcados unsafe. Estos son sintácticamente iguales a los punteros en C y C++. Sin embargo, la comprobación en tiempo de ejecución está deshabilitada dentro de unsafelos bloques.

static void Main ( string [] args ) { unsafe { int a = 2 ; int * b = &a a ;Console.WriteLine ( " Dirección de a: {0}. Valor: {1}" , ( int ) & a a , a ); Console . WriteLine ( "Dirección de b: {0}. Valor: {1}. Valor de *b: {2}" , ( int ) & b , ( int ) b , * b );// Generará una salida similar a esta: // Dirección de a: 71953600. Valor: 2 // Dirección de b: 71953596. Valor: 71953600. Valor de *b: 2 } }

Las estructuras solo deben ser estructuras puras, sin miembros de un tipo de referencia administrado, por ejemplo, una cadena o cualquier otra clase.

public struct MyStruct { public char Character ; public int Integer ; }public struct MyContainerStruct { public byte Byte ; public MyStruct MyStruct ; }

En uso:

MyContainerStruct x ; MyContainerStruct * ptr = & x ;valor de byte = puntero -> Byte ;

Esta es una característica de C# 4.0 y .NET Framework 4.0 .

El tipo dynamicpermite la búsqueda dinámica en tiempo de ejecución en C# de forma estática. Dinámico indica una variable con un objeto cuyo tipo se resuelve en tiempo de ejecución, en lugar de en tiempo de compilación.

Esta función aprovecha el Dynamic Language Runtime (DLR) y está diseñada con el objetivo de interoperar con lenguajes de tipado dinámico como IronPython e IronRuby (implementaciones de Python y Ruby para .NET).

La compatibilidad dinámica también facilita la interoperabilidad con objetos COM .

dynamic x = new Foo (); x . DoSomething (); // Se compilará y se resolverá en tiempo de ejecución. Se lanzará una excepción si no es válido.

Esta es una característica de C# 3.0 .

Los tipos anónimos son clases sin nombre generadas por el compilador. Son útiles, aunque no imprescindibles, en situaciones como consultas LINQ que devuelven un objeto selectpara obtener valores específicos. Para ello, se define un tipo anónimo que contiene campos de solo lectura generados automáticamente para dichos valores.

Al instanciar otra declaración de tipo anónimo con la misma firma, el compilador infiere automáticamente el tipo.

var carl = new { Name = "Carl" , Age = 35 }; // El nombre del tipo solo lo conoce el compilador. var mary = new { Name = "Mary" , Age = 22 }; // Mismo tipo que la expresión anterior

Todos los tipos, incluso los tipos de valor en su forma encapsulada, heredan implícitamente de la clase base. Esta clase contiene los métodos más comunes compartidos por todos los objetos. Algunos de estos métodos son y pueden ser sobrescritos.System.Objectvirtual

Las clases heredan de forma directa o indirecta a través de otra clase base.System.Object

Miembros Algunos miembros de la clase Object:

• Equals- Admite comparaciones entre objetos.
• Finalize- Realiza operaciones de limpieza antes de que un objeto sea recuperado automáticamente. (Destructor predeterminado)
• GetHashCode- Obtiene el número correspondiente al valor del objeto para admitir el uso de una tabla hash .
• GetType- Obtiene el tipo de la instancia actual.
• ToString- Crea una cadena de texto legible para humanos que describe una instancia de la clase. Normalmente devuelve el nombre del tipo.

Aunque las clases y las estructuras son similares tanto en su declaración como en su uso, presentan diferencias significativas. Las clases son tipos de referencia y las estructuras son tipos de valor. Una estructura se asigna en la pila al declararse y la variable se vincula a su dirección. Contiene directamente el valor. Las clases son diferentes porque la memoria se asigna en el montón. Las variables son referencias, punteros administrados en la pila que apuntan a los objetos.

Las estructuras se diferencian de las clases en otros aspectos. Por ejemplo, si bien ambas ofrecen un constructor predeterminado implícito que no recibe argumentos, este no puede redefinirse para las estructuras. Definir explícitamente un constructor con parámetros diferentes anula el constructor predeterminado implícito en las clases, pero no en las estructuras. Todos los campos de una estructura deben inicializarse en dichos constructores. Las estructuras no tienen finalizadores y no pueden heredar de otra clase como lo hacen las clases. Implícitamente, son selladas y heredan de (que a su vez hereda de ). Las estructuras son más adecuadas para pequeñas cantidades de datos.System.ValueTypeSystem.Object

Declaración de clase:

clase Foo { // Declaraciones de miembros }

// File1.cs partial class Foo { ... }// File2.cs clase parcial Foo { ... }

Antes de poder usar los miembros de la clase, inicialice la variable con una referencia a un objeto. Para crearlo, llame al constructor correspondiente usando la newpalabra clave. Tiene el mismo nombre que la clase.

Foo foo = new Foo (); StreamReader sr = new StreamReader ( "MyFile.txt" );

Para las estructuras, es opcional llamar explícitamente a un constructor, ya que el predeterminado se llama automáticamente. Debe declararse y se inicializa con valores estándar.

Para reducir el código repetitivo, si el tipo se especifica en una declaración (es decir, sin usar var), el constructor se puede invocar simplemente con new().

Foo foo = nuevo (); StreamReader sr = nuevo ( "MyFile.txt" );

Persona persona = nueva Persona { Nombre = "John Doe" , Edad = 39 };// Igual a Persona persona = nueva Persona (); persona . Nombre = "John Doe" ; persona . Edad = 39 ;

Lista < int > lista = nueva Lista < int > { 2 , 5 , 6 , 6 };// Igual a List < int > list = new List < int > (); list . Add ( 2 ); list . Add ( 5 ); list . Add ( 6 ); list . Add ( 6 );

Se accede a los miembros de una instancia y a los miembros estáticos de una clase mediante el .operador.

Acceso a un miembro de instancia Se puede acceder a los miembros de instancia a través del nombre de una variable.

cadena foo = "Hola" ; cadena fooUpper = foo . ToUpper ();

Acceso a un miembro estático de una clase Los miembros estáticos se acceden utilizando el nombre de la clase u otro tipo.

int r = String.Compare ( foo , fooUpper ) ;​

Acceso a un miembro a través de un puntero En código no seguro , se accede a los miembros de un valor (tipo struct) referenciado por un puntero con el ->operador como en C y C++.

PUNTO p ; p . X = 2 ; p . Y = 6 ; PUNTO * ptr = & p ; ptr -> Y = 4 ;

Los modificadores son palabras clave que se utilizan para modificar las declaraciones de tipos y miembros de tipo. Cabe destacar un subgrupo que contiene los modificadores de acceso.

public class Foo { public static void Something () { ... } } // Llamando al método de la clase. Foo . Something ();

clase pública Foo { entero público Do () { return 0 ; }clase pública Bar {} }

Un constructor es un método especial que se llama al crear un objeto. Su propósito es inicializar los miembros del objeto. Los constructores tienen el mismo nombre que la clase y no devuelven ningún valor. Implícitamente, devuelven el objeto recién creado cuando se llaman mediante el newoperador `new`. Pueden recibir parámetros, como cualquier otro método. El constructor sin parámetros es especial porque puede especificarse como una restricción necesaria para un parámetro de tipo genérico.

clase Foo { Foo () { ... } }

Los constructores pueden ser public, private, protectedo internal.

El destructor se llama cuando el recolector de basura recoge el objeto para realizar una limpieza manual. El método destructor predeterminado finalizepuede ser sobrescrito.

La sintaxis es similar a la de los constructores. La diferencia radica en que el nombre va precedido de un ~ y no puede incluir parámetros. Solo se puede declarar un destructor.

clase Foo { ...~ Foo () { ... } }

Los finalizadores siempre son private.

Al igual que en C y C++, las funciones agrupan código reutilizable. La principal diferencia radica en que, como en Java, deben residir dentro de una clase. Por lo tanto, una función se denomina método . Un método tiene un valor de retorno, un nombre y, generalmente, parámetros que se inicializan al ser llamado con argumentos. Puede pertenecer a una instancia de una clase o ser estático.

clase Foo { int Bar ( int a , int b ) { return a % b ; } }

Se llama a un método. utilizando una notación sobre una variable específica o, como en el caso de los métodos estáticos, el nombre de un tipo.

Foo foo = nuevo Foo (); int r = foo . Bar ( 7 , 2 );Consola.WriteLine ( r ) ;​

void PassRef ( ref int x ) { if ( x == 2 ) { x = 10 ; } } int Z = 7 ; PassRef ( ref Z );void PassOut ( out int x ) { x = 2 ; } int Q ; PassOut ( out Q );

void Incremento ( ref int x , int dx = 1 ) { x += dx ; }int x = 0 ; Incremento ( ref x ); // dx toma el valor predeterminado de 1 Incremento ( ref x , 2 ); // dx toma el valor 2

Stream OpenFile ( string name , FileMode mode = FileMode . Open , FileAccess access = FileAccess . Read ) { ... }OpenFile ( "file.txt" ); // usar valores predeterminados para "mode" y "access" OpenFile ( " file.txt" , mode : FileMode.Create ) ; // usar valor predeterminado para "access" OpenFile ( "file.txt" , access : FileAccess.Read ) ; // usar valor predeterminado para "mode" OpenFile ( name : "file.txt" , access : FileAccess.Read , mode : FileMode.Create ) ; // nombrar todos los parámetros para mayor legibilidad, // y usar un orden diferente al de la declaración del método

objeto fileName = "Test.docx" ; objeto missing = System . Reflection . Missing . Value ;doc.SaveAs ( ref fileName , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing , ref missing ) ; console.writeline ( " Archivo guardado correctamente" );

doc.SaveAs ( ref fileName ) ;​

[DllImport("win32.dll")] static extern double Pow ( double a , double b );

Los campos, o variables de instancia , pueden declararse dentro del cuerpo de la clase para almacenar datos.

clase Foo { doble foo ; }

Los campos se pueden inicializar directamente al declararlos (a menos que se declaren en una estructura).

clase Foo { doble foo = 2.3 ; }

Modificadores para campos:

• const- Convierte el campo en una constante.
• private- Hace que el campo sea privado (por defecto).
• protected- Hace que el campo esté protegido.
• public- Hace público el campo.
• readonly- Permite que el campo se inicialice solo una vez en un constructor.
• static- Convierte el campo en un miembro estático, es decir, una variable de clase .

Las propiedades aportan una sintaxis similar a la de los campos y las combinan con métodos. Una propiedad puede tener dos accesores: gety set.

clase pública Persona { cadena privada _nombre ;cadena Nombre { obtener { devolver _nombre ; } establecer { _nombre = valor ; } } }// Usando una propiedad var person = new Person (); person . Name = "Robert" ;

Modificadores para propiedades:

• private- Hace que la propiedad sea privada (por defecto).
• protected- Protege la propiedad.
• public- Hace pública la propiedad.
• static- Convierte la propiedad en un miembro estático.

Modificadores para accesores de propiedades:

• private- Hace que el accesor sea privado.
• protected- Protege el dispositivo de acceso.
• public- Hace público el accesor.

Los modificadores predeterminados para los accesores se heredan de la propiedad. Tenga en cuenta que los modificadores del accesor solo pueden ser iguales o más restrictivos que el modificador de la propiedad.

public double Width { obtener ; privado establecer ; }

Los indexadores añaden a los objetos capacidades de indexación similares a las de los arrays. Se implementan de forma similar a las propiedades.

clase interna IntList { privado int [] _items ;int this [ int index ] { obtener { devolver _items [ index ]; } establecer { _items [ index ] = valor ; } } }// Usando un indexador IntList lista = nueva IntList (); lista [ 2 ] = 2 ;

Las clases en C# solo pueden heredar de una clase. Una clase puede derivar de cualquier clase que no esté marcada como sealed.

clase A { }clase B : A {}

clase Operación { público virtual int Hacer () { return 0 ; } }clase NuevaOperación : Operación { public override int Hacer () { return 1 ; } }

clase Operación { public int Hacer () { return 0 ; } }clase NuevaOperación : Operación { public new double Do () { return 4.0 ; } }

NuevaOperación op = nueva NuevaOperación ();// Llamará a "double Do()" en NewOperation double d = op . Do ();Operación op_ = op ;// Llamará a "int Do()" en Operation int i = op_ . Do ();

clase abstracta Mamífero { público abstracto void Caminar (); }clase Humano : Mamífero { public override void Walk () {}... }

clase interna sellada Foo { //... }public class Bar { public virtual void Action () { //... } }public class Baz : Bar { public sealed override void Action () { //... } }

Una interfaz es implementada por una clase o extendida por otra interfaz de la misma manera que una clase se deriva de otra clase utilizando la :notación.

Implementación implícita

Cuando se implementa implícitamente una interfaz, los miembros de la interfaz deben ser public.

public class Adder : IBinaryOperation { public double A { get ; set ; } public double B { get ; set ; }public double GetResult () { return A + B ; } }public class Multiplier : IBinaryOperation { public double A { get ; set ; } public double B { get ; set ; }public double GetResult () { return A * B ; } }

En uso:

IBinaryOperation op = null ; double result ;// El sumador implementa la interfaz IBinaryOperation.op = nuevo sumador (); op . Un = 2 ; op . B = 3 ;resultado = op . ObtenerResultado (); // 5// Multiplier también implementa la interfaz.op = nuevo multiplicador (); op . Una = 5 ; op . B = 4 ;resultado = op . ObtenerResultado (); // 20

Implementación explícita

Los miembros implementados explícitamente solo son accesibles cuando el objeto se trata como un tipo de interfaz.

public class Adder : IBinaryOperation { double IBinaryOperation . A { get ; set ; } double IBinaryOperation . B { get ; set ; }double IBinaryOperation.GetResult ( ) { return (( IBinaryOperation ) this ) .A + ( ( IBinaryOperation ) this ) .B ; } }

En uso:

Adder add = nuevo Adder ();// Estos miembros no son accesibles: // add.A = 2; // add.B = 3; // double result = add.GetResult();// Convierta al tipo de interfaz para acceder a ellos: IBinaryOperation add2 = add ; add2 . A = 2 ; add2 . B = 3 ;double resultado = add2.GetResult ( ) ;

Las propiedades de la clase que extiende IBinaryOperationson implementadas automáticamente por el compilador y se agrega automáticamente un campo de respaldo (ver #Propiedades automáticas ).

Ampliación de múltiples interfaces

Se permite que las interfaces y las clases extiendan múltiples interfaces.

clase MyClass : IInterfaceA , IInterfaceB { ... }

Una interfaz que extiende dos interfaces.

interfaz IInterfaceC : IInterfaceA , IInterfaceB { ... }

Las interfaces y las clases abstractas son similares. A continuación se describen algunas diferencias importantes:

• Una clase abstracta puede tener variables miembro, así como métodos o propiedades no abstractos. Una interfaz no puede.
• Una clase o clase abstracta solo puede heredar de una única clase o clase abstracta.
• Una clase o clase abstracta puede implementar una o más interfaces.
• Una interfaz solo puede extender otras interfaces.
• Una clase abstracta puede tener métodos y propiedades no públicos (también abstractos). Una interfaz solo puede tener miembros públicos.
• Una clase abstracta puede tener constantes, métodos estáticos y miembros estáticos. Una interfaz no puede.
• Una clase abstracta puede tener constructores. Una interfaz no.