C # (pronunciado "see sharp") es un lenguaje de programación multi-paradigma de alto nivel, estáticamente tipado desarrollado por Microsoft. El código C # generalmente se dirige a la familia de herramientas y tiempos de ejecución .NET de Microsoft, que incluyen .NET Framework, .NET Core y Xamarin, entre otros. Use esta etiqueta para preguntas sobre el código escrito en las especificaciones formales de C # o C #.

c#es un lenguaje de programación orientado a objetos, gestionado por varios paradigmas, creado por Microsoft junto con .NET. C # se puede usar con cualquier implementación de .NET como .NET Core, .NET Framework, Mono y Xamarin.

Versiones

+---------+---------------------------------------------------------+----------------+----------------------------------+---------------------------------+
| Version |                  Language specification                 |      Date      |           .NET Version           |          Visual Studio          |
|         +---------------+----------------+------------------------+                |                                  |                                 |
|         |      Ecma     |     ISO/IEC    |        Microsoft       |                |                                  |                                 |
+---------+---------------+----------------+------------------------+----------------+----------------------------------+---------------------------------+
| C# 1.0  | December 2002 | April 2003     | January 2002           | January 2002   | .NET Framework 1.0               | Visual Studio .NET 2002         |
+---------+               |                +------------------------+----------------+----------------------------------+---------------------------------+
| C# 1.1  |               |                | October 2003           | April 2003     | .NET Framework 1.1               | Visual Studio .NET 2003         |
| C# 1.2  |               |                |                        |                |                                  |                                 |
+---------+---------------+----------------+------------------------+----------------+----------------------------------+---------------------------------+
| C# 2.0  | June 2006     | September 2006 | September 2005         |                | .NET Framework 2.0               | Visual Studio .NET 2005         |
|         |               |                |                        |                | .NET Framework 3.0               | Visual Studio .NET 2008         |
+---------+---------------+----------------+------------------------+----------------+----------------------------------+---------------------------------+
| C# 3.0  |                -               | August 2007            |                | .NET Framework 2.0 (Except LINQ) | Visual Studio 2008              |
|         |                                |                        | November 2007  | .NET Framework 3.0 (Expect LINQ) |                                 |
|         |                                |                        |                | .NET Framework 3.5               |                                 |
+---------+                                +------------------------+----------------+----------------------------------+---------------------------------+
| C# 4.0  |                                | April 2010             | April 2010     | .NET Framework 4                 | Visual Studio 2010              |
+---------+---------------+----------------+------------------------+----------------+----------------------------------+---------------------------------+
| C# 5.0  | December 2017 | December 2018  | June 2013              | August 2012    | .NET Framework 4.5               | Visual Studio 2012              |
|         |               |                |                        |                |                                  | Visual Studio 2013              |
+---------+---------------+----------------+------------------------+----------------+----------------------------------+---------------------------------+
|         |                -               | Draft                  |                | .NET Framework 4.6               | Visual Studio 2015              |
| C# 6.0  |                                |                        | July 2015      | .NET Core 1.0                    |                                 |
|         |                                |                        |                | .NET Core 1.1                    |                                 |
+---------+                                +------------------------+----------------+----------------------------------+---------------------------------+
| C# 7.0  |                                | Specification proposal | March 2017     | .NET Framework 4.7               | Visual Studio 2017 version 15.0 |
+---------+                                +------------------------+----------------+----------------------------------+---------------------------------+
| C# 7.1  |                                | Specification proposal | August 2017    | .NET Core 2.0                    | Visual Studio 2017 version 15.3 |
+---------+                                +------------------------+----------------+----------------------------------+---------------------------------+
| C# 7.2  |                                | Specification proposal | November 2017  |                 -                | Visual Studio 2017 version 15.5 |
+---------+                                +------------------------+----------------+----------------------------------+---------------------------------+
|         |                                | Specification proposal |                | .NET Core 2.1                    | Visual Studio 2017 version 15.7 |
| C# 7.3  |                                |                        | May 2018       | .NET Core 2.2                    |                                 |
|         |                                |                        |                | .NET Framework 4.8               |                                 |
+---------+                                +------------------------+----------------+----------------------------------+---------------------------------+
| C# 8    |                                | Specification proposal | September 2019 | .NET Core 3.0                    | Visual Studio 2019 version 16.3 |
+---------+--------------------------------+------------------------+----------------+----------------------------------+---------------------------------+
| C# 9.0  |                                | Specification proposal | September 2020 | .NET 5.0                         | Visual Studio 2019 version 16.8 |
+---------+--------------------------------+------------------------+----------------+----------------------------------+---------------------------------+

Nuevas características

Las versiones 1.0 / 1.2 y 2.0 de C # se presentaron y aprobaron como ECMA(Versión web ) y normas ISO / IEC. La última versión de ECMA coincidecon la especificación Microsoft C # 5.0. Las especificaciones de idioma también están disponibles en Microsoft para C # 3.0y C # 5.0y C # 6.0borrador.

El sistema de tipos del lenguaje era originalmente estático, con solo declaraciones de variables explícitas permitidas. La introducción de var(C # 3.0) y dynamic(C # 4.0) le permitió usar la inferencia de tipos para escribir variables implícitamente y consumir sistemas de tipo dinámico, respectivamente. Los delegados, especialmente con soporte de cierre léxico para métodos anónimos (C # 2.0) y expresiones lambda (C # 3.0), permiten que el lenguaje se use para la programación funcional.

C # 5.0 introdujo el asyncy awaitpalabras clave para simplificar el uso de llamadas a funciones asíncronas.

C # 6.0 introdujo el operador de propagación nulo?., excepción filtros, interpolación de cadenas, y muchas otras característicasque ayudan a escribir código simple.

C # 7.0 introdujo múltiples argumentos out, coincidencia de patrones, tuplas para un valor de retorno, expresiones is y declaraciones switch con patrones, deconstrucción, funciones locales y algunas más.

C # 7.1 introdujo la coincidencia de patrones genéricos, nombres de elementos de tupla inferidos, expresiones literales default, asíncrono principal y algunos más.

C # 7.2 introdujo private protected, argumentos con nombre no final, separador digital después del especificador base, expresión condicional de referencia, semántica de referencia para tipos de valores y algunos más.

C # 7.3 introdujo características que permiten que el código seguro sea tan eficaz como el código inseguro, nuevas opciones de compilación, el uso de out declaraciones de variables en los inicializadores de campo, propiedad y constructor, soporte == y != sobre tipos de tuplas y algo más.

C # 8.0 introdujo tipos de referencia anulablesque genera advertencias del compilador sobre la posible desreferenciación de valores nulos a menos que el código exprese explícitamente que una variable puede ser null (por ejemplo, string? foo es una variable que puede ser nula), flujos asíncronos que potencian, especialmente, las integraciones de IoT y de la nube y métodos de interfaz predeterminados para evitar cambios importantes en las interfaces, junto con algún otro mejoras.

C # 9.0 introdujo muchos conceptos y características nuevos, como Registros a>, solo establecedores de inicio, < a href = "https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-9#top-level-statements"> Declaraciones de nivel superior, Mejoras de coincidencia de patronesy más.

La compilación generalmente se realiza en el lenguaje intermedio de Microsoft (MSIL), que luego se compila JIT en código nativo (y se almacena en caché) durante la ejecución en Common Language Runtime (CLR). Sin embargo, opciones como NGen(para el .NET Framework) y AOT (para Mono) significa que el código C # se puede compilar directamente en la imagen nativa. Además, algunos marcos (por ejemplo, .NET Micro Framework) actúan como intérpretes de CIL, sin JIT.

Los genéricos en C # son proporcionados en parte por el tiempo de ejecución, a diferencia de las plantillas de C ++ (las plantillas se resuelven en tiempo de compilación), o los genéricos de Java (que usan borrado de tipo).

Con la combinación de .NET Corepara Windows, macOS y Linux, .NET Frameworkpara Windows (escritorio / servidor / móvil), Mono que alimenta las aplicaciones de Xamarin en Android, Mac, iOS, tvOS y watchOS, Silverlight / Moonlight (navegador / móvil), Compact Framework (móvil ) y Micro Framework (dispositivos integrados), está disponible para una amplia gama de plataformas.


Hola Mundo Ejemplo:

using System;

class Hello
{
    static void Main()
    {
        Console.WriteLine("Hello, World!");
    }
}

Ejemplo de Hello World usando clases:

using System;

namespace HelloWorldUsingClasses
{
   class Greeting
   {
       public static void SayHello()
       {
           Console.WriteLine("Hello World!");
       }
   }

   class Program
   {
       static void Main(string[] args)
       {
           Greeting.SayHello();
       }
   }
}

Recursos de desbordamiento de pila


Preguntas frecuentes


Recursos


Libros


Tutoriales


Futuro del lenguaje C #

Contribuya y proponga nuevas funciones aquí.


Proyectos de demostración


C # IDE en línea


C # IDE sin conexión

Etiquetas relacionadas