C# (lenguaje de programación)

Microsoft utilizó por primera vez el nombre C# en 1988 para una variante del lenguaje C diseñada para la compilación incremental. ^{[ 38 ]} Ese proyecto no se completó y el nombre se reutilizó posteriormente.

El nombre "C sharp" se inspiró en la notación musical donde el símbolo "shape" indica que la nota escrita debe elevarse un semitono . ^{[ 39 ]} Esto es similar al nombre del lenguaje C++ , donde "++" indica que una variable debe incrementarse en 1 después de ser evaluada. El símbolo "shape" también se asemeja a una ligadura de cuatro símbolos "+" (en una cuadrícula de dos por dos), lo que implica aún más que el lenguaje es una evolución de C++. ^{[ 40 ]}

Debido a las limitaciones técnicas de visualización (fuentes estándar, navegadores, etc.) y a que la mayoría de las distribuciones de teclado carecen de un símbolo de sostenido ( U+266F ♯ MUSIC SHARP SIGN ( & sharp; ) ), se eligió el signo de número ( U+0023 # NUMBER SIGN ( & num; ) ) para aproximar el símbolo de sostenido en el nombre escrito del lenguaje de programación. ^{[ 41 ]} Esta convención se refleja en la especificación del lenguaje C# ECMA-334. ^{[ 1 ]}

El sufijo "sharp" ha sido utilizado por varios otros lenguajes compatibles/que cumplen con Microsoft .NET que son variantes de lenguajes existentes, incluidos J# (un lenguaje .NET también diseñado por Microsoft que se deriva de Java 1.1), A# (de Ada ) y el lenguaje de programación funcional F# . ^{[ 42 ]} La implementación original de Eiffel para .NET se llamaba Eiffel# , ^{[ 43 ]} un nombre retirado ya que ahora se admite el lenguaje Eiffel completo . El sufijo también se ha utilizado para bibliotecas , como Gtk# (un envoltorio .NET para GTK y otras bibliotecas GNOME ) y Cocoa# (un envoltorio para Cocoa ).

El desarrollo del texto para los estándares (a partir de C#  6) se realiza en GitHub . C#  7 se presentó a Ecma y se aprobó en diciembre de 2023. A partir de enero de 2024, el estándar para C#  8 se encuentra actualmente en desarrollo, tomando como referencia las propuestas de lenguaje aprobadas .

Por diseño, C# es el lenguaje de programación que refleja más directamente la Infraestructura de Lenguaje Común  (CLI) subyacente. ^{[ 73 ]} La mayoría de sus tipos intrínsecos corresponden a tipos de valor implementados por el marco de trabajo CLI. Sin embargo, la especificación del lenguaje no establece los requisitos de generación de código del compilador: es decir, no indica que un compilador de C# deba apuntar a un Entorno de Ejecución de Lenguaje Común (CLR), ni generar Lenguaje Intermedio Común (CIL), ni generar ningún otro formato específico. Algunos compiladores de C# también pueden generar código máquina como los compiladores tradicionales de Objective-C, C, C++, Ensamblador y Fortran . ^{[ 74 ] [ 75 ]}

C# admite declaraciones de variables fuertemente tipadas implícitamente con la palabra clave var, ^{[ 17 ] : 470} y matrices tipadas implícitamente con la palabra clave new[]seguida de un inicializador de colección. ^{[ 17 ] : 80 [ 21 ] : 58}

Su sistema de tipos se divide en dos familias: tipos de valor, como los tipos numéricos integrados y las estructuras definidas por el usuario, que se pasan automáticamente como copias cuando se usan como parámetros, y tipos de referencia, que incluyen arreglos, instancias de clases y cadenas, que solo pasan un puntero al objeto correspondiente. Debido a su manejo especial del operador de igualdad y su inmutabilidad , las cadenas se comportarán, a efectos prácticos, como si fueran valores. El programador incluso puede usarlas como etiquetas de caso . Cuando sea necesario, los tipos de valor se empaquetarán automáticamente. ^{[ 76 ]}

C# admite un tipo de datos booleano estricto , bool. Las sentencias que toman condiciones, como whiley if, requieren una expresión de un tipo que se evalúe al truevalor booleano. Si bien C++ también tiene un tipo booleano, se puede convertir libremente a y desde enteros, y expresiones como if (a)solo requieren que asea convertible a bool, lo que permite aque sea un int o un puntero. C# no permite este enfoque de "entero que significa verdadero o falso", con el argumento de que obligar a los programadores a usar expresiones que devuelvan exactamente boolpuede prevenir ciertos tipos de errores de programación como if (a = b)(uso de asignación =en lugar de igualdad ==).

C# es más seguro en cuanto a tipos que C++. Las únicas conversiones implícitas por defecto son aquellas que se consideran seguras, como la ampliación de enteros. Esto se aplica en tiempo de compilación, durante la compilación Just-in-Time y, en algunos casos, en tiempo de ejecución. No se producen conversiones implícitas entre booleanos y enteros, ni entre miembros de enumeración y enteros (excepto el literal 0, que puede convertirse implícitamente a cualquier tipo enumerado). Cualquier conversión definida por el usuario debe marcarse explícitamente como explícita o implícita, a diferencia de los constructores de copia y los operadores de conversión de C++, que son implícitos por defecto.

C# tiene soporte explícito para covarianza y contravarianza en tipos genéricos, ^{[ 17 ] : 144 [ 21 ] : 23} a diferencia de C++ que tiene cierto grado de soporte para contravarianza simplemente a través de la semántica de los tipos de retorno en métodos virtuales.

Los miembros de la enumeración se colocan en su propio ámbito .

El lenguaje C# no permite variables ni funciones globales. Todos los métodos y miembros deben declararse dentro de las clases. Los miembros estáticos de las clases públicas pueden sustituir a las variables y funciones globales.

A diferencia de C y C++, las variables locales no pueden ocultar variables del bloque que las contiene, pero sí pueden ocultar nombres a nivel de tipo.

La metaprogramación se puede lograr de varias maneras:

• La reflexión es compatible a través de las API de .NET, que permiten escenarios como la inspección de metadatos de tipo y la invocación dinámica de métodos.
• Los árboles de expresiones ^{[ 77 ]} representan el código como un árbol de sintaxis abstracta , donde cada nodo es una expresión que puede ser inspeccionada o ejecutada. Esto permite la modificación dinámica del código ejecutable en tiempo de ejecución. Los árboles de expresiones introducen cierta homoiconicidad en el lenguaje.
• En la jerga de C#, los atributos son metadatos que se pueden adjuntar a tipos, miembros o ensamblados completos , equivalentes a las anotaciones en Java . Los atributos son accesibles tanto para el compilador como para el código mediante reflexión, lo que les permite ajustar su comportamiento. ^{[ 78 ]} Muchos de los atributos nativos duplican la funcionalidad de las directivas de preprocesador dependientes de la plataforma de GCC y VisualC++.
• System.Reflection.Emitespacio de nombres, ^{[ 79 ]} que contiene clases que emiten metadatos y CIL (tipos, ensamblados, etc.) en tiempo de ejecución .
• La plataforma de compilación .NET (Roslyn) proporciona acceso API a los servicios de compilación de lenguajes, lo que permite compilar código C# desde dentro de las aplicaciones .NET. Expone API para el análisis sintáctico ( léxico ) del código, el análisis semántico , la compilación dinámica a CIL y la emisión de código. ^{[ 80 ]}
• Los generadores de código fuente, ^{[ 81 ]} una característica del compilador Roslyn C#, permiten la metaprogramación en tiempo de compilación. Durante el proceso de compilación, los desarrolladores pueden inspeccionar el código que se está compilando con la API del compilador y pasar código fuente C# generado adicional para su compilación.

Un método en C# es un miembro de una clase que puede ser invocado como una función , en lugar de la mera capacidad de almacenar valores de un campo , es decir, una variable de clase o de instancia . ^{[ 82 ]} Como en otros lenguajes sintácticamente similares, como C++ y ANSI C , la firma de un método es una declaración que comprende en orden: cualquier palabra clave de accesibilidad opcional (como ), la especificación explícita de su tipo de retorno (como , o la palabra clave si no se devuelve ningún valor), el nombre del método y, finalmente, una secuencia entre paréntesis de especificaciones de parámetros separadas por comas, cada una de las cuales consiste en el tipo de un parámetro, su nombre formal y, opcionalmente, un valor predeterminado que se utilizará cuando no se proporcione ninguno. A diferencia de la mayoría de los demás lenguajes, los parámetros de paso por referencia deben marcarse tanto en la definición de la función como en el sitio de llamada, y el programador puede elegir entre y , este último permite pasar una variable no inicializada que tendrá un valor definido al regresar. ^{[ 83 ]} Además, el programador puede especificar una lista de argumentos de tamaño variable aplicando la palabra clave al último parámetro. ^{[ 84 ]} Ciertos tipos específicos de métodos, como aquellos que simplemente obtienen o establecen el valor de un campo devolviéndolo o asignándolo, no requieren una firma completa explícitamente indicada, pero en el caso general, la definición de una clase incluye la declaración de firma completa de sus métodos. ^{[ 85 ]}privateintvoidrefoutparams

Al igual que en C++, y a diferencia de Java, los programadores de C# deben usar la palabra clave `scope` para permitir que las subclases sobrescribanvirtual métodos . A diferencia de C++, el programador debe especificar explícitamente la palabra clave al hacerlo. ^{[ 86 ]} Esto tiene como objetivo evitar confusiones entre sobrescribir y sobrecargar una función, es decir, ocultar la primera implementación. Para hacer lo segundo, el programador debe especificar la palabra clave. ^{[ 87 ]} La palabra clave se puede usar para impedir más sobrescrituras para métodos individuales o clases completas. ^{[ 88 ]}overridenewsealed

Los métodos de extensión en C# permiten a los programadores usar métodos estáticos como si fueran métodos de la tabla de métodos de una clase, lo que les permite agregar virtualmente métodos de instancia a una clase que, a su juicio, deberían existir en ese tipo de objetos (y en las instancias de las clases derivadas correspondientes). ^{[ 17 ] : 103–105 [ 21 ] : 202–203}

Este tipo dynamicpermite la vinculación de métodos en tiempo de ejecución, lo que posibilita llamadas a métodos similares a las de JavaScript y la composición de objetos en tiempo de ejecución . ^{[ 17 ] : 114–118}

C# admite punteros a funciones fuertemente tipados mediante la palabra clave ` delegate.`. Al igual que la señal y la ranura pseudo -C++ del framework Qt , C# tiene una semántica específica para eventos de estilo publicación-suscripción, aunque C# utiliza delegados para ello. A diferencia de los campos, las variables pueden formar parte de una interfaz, ya que técnicamente constan de dos funciones predeterminadas para agregar y eliminar delegados que se van a llamar.event

C# ofrece llamadas a métodos similares a las de Java synchronized, a través del atributo [MethodImpl(MethodImplOptions.Synchronized)], y admite bloqueos mutuamente excluyentes a través de la palabra clave lock.

C# admite clases con propiedades . Las propiedades pueden ser funciones de acceso simples con un campo de respaldo, o implementar funciones de obtención y establecimiento arbitrarias. Una propiedad es de solo lectura si no tiene un método de establecimiento. Al igual que con los campos, puede haber propiedades de clase e instancia. Los métodos subyacentes pueden ser de solo lectura virtualo abstractcomo cualquier otro método. ^{[ 85 ]}

Desde C# 3.0 está disponible el azúcar sintáctico de las propiedades autoimplementadas, ^{[ 89 ]} donde el accesor (getter) y el mutador (setter) encapsulan operaciones en un solo campo de una clase.

AC# namespaceproporciona el mismo nivel de aislamiento de código que Java packageo C++ namespace, con reglas y características muy similares a las de un package. Los espacios de nombres se pueden importar con la sintaxis "using". ^{[ 90 ]}

En C#, los punteros a direcciones de memoria solo se pueden usar dentro de bloques específicamente marcados como inseguros , ^{[ 91 ]} y los programas con código inseguro necesitan los permisos adecuados para ejecutarse. La mayoría del acceso a objetos se realiza a través de referencias de objetos seguras, que siempre apuntan a un objeto "vivo" o tienen el valor nulo bien definido ; es imposible obtener una referencia a un objeto "muerto" (uno que ha sido recolectado por el recolector de basura) o a un bloque de memoria arbitrario. Un puntero inseguro puede apuntar a una instancia de un tipo de valor no administrado que no contiene ninguna referencia a objetos sujetos a recolección de basura, como instancias de clases, matrices o cadenas. El código que no está marcado como inseguro aún puede almacenar y manipular punteros a través del System.IntPtrtipo, pero no puede desreferenciarlos.

La memoria administrada no se puede liberar explícitamente; en su lugar, se elimina automáticamente mediante la recolección de basura . La recolección de basura resuelve el problema de las fugas de memoria al liberar al programador de la responsabilidad de liberar la memoria que ya no se necesita en la mayoría de los casos. El código que mantiene referencias a objetos durante más tiempo del necesario aún puede experimentar un mayor consumo de memoria del necesario; sin embargo, una vez que se libera la última referencia a un objeto, la memoria queda disponible para la recolección de basura.

Los programadores disponen de una variedad de excepciones estándar . Los métodos de las bibliotecas estándar suelen generar excepciones del sistema en determinadas circunstancias, y el tipo de excepciones que se generan normalmente está documentado. Se pueden definir clases de excepción personalizadas para las clases, lo que permite implementar el manejo necesario para cada circunstancia. ^{[ 92 ]}

La sintaxis para el manejo de excepciones es la siguiente:

try { // algo } catch ( Exception ex ) { // si hay error, hacer esto } finally { // siempre se ejecuta, independientemente de si ocurre un error }

Esto se suele denominar bloque de código "try-catch", debido a que las funciones "try" y "catch" se utilizan y están disponibles en todas las versiones de C#. La parte "finally" puede omitirse. Si no es necesario inspeccionar los detalles del error, el (Exception ex)parámetro también puede omitirse. Además, puede haber varias partes "catch" que gestionen diferentes tipos de excepciones. ^{[ 93 ]}

En C# no existen excepciones verificadas (a diferencia de Java). Esta ha sido una decisión deliberada basada en cuestiones de escalabilidad y gestión de versiones. ^{[ 94 ]}

A diferencia de C++ , C# no admite la herencia múltiple , aunque una clase puede implementar cualquier número de " interfaces " (clases totalmente abstractas). Esta fue una decisión de diseño del arquitecto principal del lenguaje para evitar complicaciones y simplificar los requisitos arquitectónicos en toda la CLI .

Al implementar múltiples interfaces que contienen un método con el mismo nombre y que aceptan parámetros del mismo tipo en el mismo orden, es decir, con la misma firma , de forma similar a Java , C# permite tanto un único método para cubrir todas las interfaces como, si es necesario, métodos específicos para cada interfaz.

C# también ofrece sobrecarga de funciones (también conocida como polimorfismo ad hoc ), es decir, métodos con el mismo nombre, pero firmas distinguibles. ^{[ 95 ]} A diferencia de Java, C# admite además sobrecarga de operadores . ^{[ 96 ]}

Desde la versión 2.0, C# ofrece polimorfismo paramétrico , es decir, clases con parámetros de tipo arbitrarios o restringidos, por ejemplo , un array de tamaño variable que solo puede contener elementos de tipo . Existen ciertos tipos de restricciones que el programador puede especificar para los parámetros de tipo: debe ser de tipo X ( o uno derivado de él ), debe implementar una interfaz determinada, debe ser un tipo de referencia, debe ser un tipo de valor, debe implementar un constructor público sin parámetros . La mayoría de ellas se pueden combinar y se puede especificar cualquier número de interfaces. ^{[ 97 ] [ 98 ]}List<T>T

C# tiene la capacidad de utilizar LINQ a través del .NET Framework. Un desarrollador puede consultar diversas fuentes de datos, siempre que la interfaz esté implementada en el objeto. Esto incluye documentos XML , un conjunto de datos ADO.NET y bases de datos SQL . ^{[ 99 ]}IEnumerable<T>

El uso de LINQ en C# ofrece ventajas como compatibilidad con IntelliSense , sólidas capacidades de filtrado, seguridad de tipos con comprobación de errores de compilación y consistencia para consultar datos de diversas fuentes. ^{[ 100 ]} Existen varias estructuras de lenguaje que se pueden utilizar con C# y LINQ, como expresiones de consulta, expresiones lambda, tipos anónimos, variables con tipado implícito, métodos de extensión e inicializadores de objetos. ^{[ 101 ]}

LINQ tiene dos sintaxis: sintaxis de consulta y sintaxis de método. Sin embargo, el compilador siempre convierte la sintaxis de consulta a sintaxis de método en tiempo de compilación. ^{[ 102 ]}

usando System.Linq ;var numbers = new int [] { 5 , 10 , 8 , 3 , 6 , 12 };// Sintaxis de consulta (SELECT num FROM numbers WHERE num % 2 = 0 ORDER BY num) var numQuery1 = from num in numbers where num % 2 == 0 orderby num select num ;// Sintaxis del método var numQuery2 = números . Donde ( núm => núm % 2 == 0 ) . Ordenar por ( n => n );

Aunque principalmente es un lenguaje imperativo, C# siempre añade características funcionales con el tiempo, ^{[ 103 ] [ 104 ]} por ejemplo:

• Funciona como ciudadano de primera clase : delegados de C# 1.0 ^{[ 105 ]}
• Funciones de orden superior – C# 1.0 junto con delegados
• Funciones anónimas : delegados anónimos de C# 2 y expresiones lambda de C# 3 ^{[ 106 ]}
• Cierres – C# 2 junto con delegados anónimos y C# 3 junto con expresiones lambda ^{[ 106 ]}
• Inferencia de tipos : C# 3 con variables locales de tipo implícito vary C# 9 con expresiones new de tipo de destino.new()
• Comprensión de listas – C# 3 LINQ
• Tuplas – .NET Framework 4.0 pero se popularizó cuando C# 7.0 introdujo un nuevo tipo de tupla con soporte de lenguaje ^{[ 107 ]}
• Funciones anidadas – C# 7.0 ^{[ 107 ]}
• Coincidencia de patrones – C# 7.0 ^{[ 107 ]}
• Inmutabilidad : Estructura de solo lectura de C# 7.2, tipos de registro de C# 9 ^{[ 108 ]} y setters de solo inicialización ^{[ 109 ]}
• Clases de tipos – Roles/extensiones de C# 12 (en desarrollo ^{[ 110 ]} )

CTS separa los tipos de datos en dos categorías: ^{[ 111 ]}

1. Tipos de referencia
2. Tipos de valor

Las instancias de tipos de valor no tienen identidad referencial ni semántica de comparación referencial. Las comparaciones de igualdad y desigualdad para tipos de valor comparan los valores de datos reales dentro de las instancias, a menos que los operadores correspondientes estén sobrecargados. Los tipos de valor se derivan de , siempre tienen un valor predeterminado y siempre se pueden crear y copiar. Algunas otras limitaciones de los tipos de valor son que no pueden derivar unos de otros (pero pueden implementar interfaces) y no pueden tener un constructor predeterminado explícito (sin parámetros) porque ya tienen uno implícito que inicializa todos los datos contenidos al valor predeterminado dependiente del tipo (0, null o similar). Ejemplos de tipos de valor son todos los tipos primitivos, como (un entero con signo de 32 bits), (un número de punto flotante IEEE de 32 bits), (una unidad de código Unicode de 16 bits), (números de punto fijo útiles para manejar cantidades de moneda) y (identifica un punto específico en el tiempo con precisión de nanosegundos). Otros ejemplos son (enumeraciones) y (estructuras definidas por el usuario).System.ValueTypeintfloatchardecimalSystem.DateTimeenumstruct

En contraste, los tipos de referencia tienen la noción de identidad referencial, lo que significa que cada instancia de un tipo de referencia es inherentemente distinta de cualquier otra instancia, incluso si los datos dentro de ambas instancias son los mismos. Esto se refleja en las comparaciones de igualdad y desigualdad predeterminadas para los tipos de referencia, que prueban la igualdad referencial en lugar de la estructural, a menos que los operadores correspondientes estén sobrecargados (como el caso de ). Algunas operaciones no siempre son posibles, como crear una instancia de un tipo de referencia, copiar una instancia existente o realizar una comparación de valores en dos instancias existentes. Sin embargo, tipos de referencia específicos pueden proporcionar tales servicios al exponer un constructor público o implementar una interfaz correspondiente (como o ). Ejemplos de tipos de referencia son (la clase base definitiva para todas las demás clases de C#), (una cadena de caracteres Unicode) y (una clase base para todos los arreglos de C#).System.StringICloneableIComparableobjectSystem.StringSystem.Array

Ambas categorías de tipos son extensibles mediante tipos definidos por el usuario.

El boxing es la operación de convertir un objeto de tipo valor en un valor de un tipo de referencia correspondiente. ^{[ 111 ]} El boxing en C# es implícito.

El desempaquetado es la operación de convertir un valor de un tipo de referencia (previamente empaquetado) en un valor de un tipo de valor. ^{[ 111 ]} El desempaquetado en C# requiere una conversión de tipo explícita . Un objeto empaquetado de tipo T solo puede desempaquetarse a un T (o un T anulable). ^{[ 112 ]}

Ejemplo:

int foo = 42 ; // Tipo de valor. object bar = foo ; // foo se convierte en bar. int foo2 = ( int ) bar ; // Se vuelve a convertir en tipo de valor.

El siguiente es un programa C# muy simple, una versión del clásico ejemplo " Hola Mundo " que utiliza la característica de sentencias de nivel superior introducida en C# 9: ^{[ 114 ]}

Consola.WriteLine ( " ¡ Hola, mundo!" ) ;

Para el código escrito en C# 8 o inferior, la lógica del punto de entrada de un programa debe estar escrita en un método Main dentro de un tipo:

usando el sistema ;clase Programa { static void Main () { Console . WriteLine ( "Hola, Mundo!" ); } }

Este código mostrará este texto en la ventana de la consola:

¡Hola Mundo!

Cada línea tiene un propósito:

usando el sistema ;

La línea anterior importa todos los tipos del Systemespacio de nombres. Por ejemplo, la Consoleclase que se usa más adelante en el código fuente está definida en dicho Systemespacio de nombres, lo que significa que se puede usar sin especificar el nombre completo del tipo (que incluye el espacio de nombres).

// Una versión del clásico programa "Hola Mundo"

Esta línea es un comentario; describe y documenta el código para el/los programador/es.

Programa de clases

Arriba se muestra la definición de la claseProgram . Todo lo que aparece entre las llaves describe dicha clase.

{ ... }

Las llaves delimitan los límites de un bloque de código. En este primer caso, marcan el inicio y el final de la Programclase.

estático void Main ()

Esto declara el método miembro de la clase donde comienza la ejecución del programa. El entorno de ejecución de .NET llama al Mainmétodo. A diferencia de Java , el Mainmétodo no necesita la publicpalabra clave, que le indica al compilador que el método puede ser llamado desde cualquier lugar por cualquier clase. ^{[ 115 ]} Escribir es equivalente a escribir . La palabra clave static hace que el método sea accesible sin una instancia de . El punto de entrada de cada aplicación de consola debe declararse; de ​​lo contrario, el programa requeriría una instancia de , pero cualquier instancia requeriría un programa. Para evitar esa dependencia circular irresoluble , los compiladores de C# que procesan aplicaciones de consola (como la anterior) informan un error si no hay ningún método. La palabra clave declara que no tiene valor de retorno . (Tenga en cuenta, sin embargo, que se pueden escribir programas cortos utilizando las instrucciones de nivel superior introducidas en C# 9, como se mencionó anteriormente).staticvoidMain(string[]args)privatestaticvoidMain(string[]args)ProgramMainstaticProgramstaticMainvoidMain

Consola.WriteLine ( " ¡ Hola, mundo!" ) ;

Esta línea escribe la salida. Consolees una clase estática en el Systemespacio de nombres. Proporciona una interfaz para la entrada/salida estándar y los flujos de error para aplicaciones de consola. El programa llama al Consolemétodo WriteLine, que muestra en la consola una línea con el argumento, la cadena "Hello, World!".

Con .NET 2.0 y C# 2.0, la comunidad obtuvo colecciones más flexibles que las de .NET 1.x. En ausencia de genéricos, los desarrolladores tenían que usar colecciones como ArrayList para almacenar elementos como objetos de tipo no especificado, lo que generaba una sobrecarga de rendimiento al convertir/desconvertir/verificar el tipo de los elementos contenidos.

Los genéricos introdujeron una nueva característica fundamental en .NET que permitió a los desarrolladores crear estructuras de datos con tipado seguro. Este cambio es particularmente importante en el contexto de la conversión de sistemas heredados, donde la actualización a genéricos puede mejorar significativamente el rendimiento y la mantenibilidad al reemplazar las estructuras de datos obsoletas con alternativas más eficientes y con tipado seguro. ^{[ 116 ]}

Ejemplo

public class DataStore < T > { private T [] items = new T [ 10 ]; private int count = 0 ;public void Agregar ( T item ) { items [ count ++ ] = item ; }public T Get ( int index ) { return items [ index ]; } }

• Albahari, Joseph (2022). C# 10 en pocas palabras (Primera  ed.). O'Reilly. ISBN 978-1-098-12195-2.
• Archer, Tom (2001). «Parte 2, Capítulo 4: El sistema de tipos». Inside C# . Redmond, Washington: Microsoft Press. ISBN 0-7356-1288-9.
• Novák, István; Velvart, András; Granicz, Adam; Balássy, György; Hajdrik, Atila; Vendedores, Mitchel; Hillar, Gastón C.; Molnár, Ágnes; Kanjilal, Joydip (2010). Visual Studio 2010 y .NET 4 seis en uno . Prensa Wrox. ISBN 978-0470499481.
• Skeet, Jon (2019). C# en profundidad (Cuarta  ed.). Manning. ISBN 978-1617294532.