C # (wymawiane „patrz ostro”) jest językiem programowania wysokiego poziomu, statycznie typowanym, wieloparadygmatowym opracowanym przez firmę Microsoft. Kod C # zwykle jest przeznaczony dla rodziny narzędzi Microsoft .NET i czasów wykonywania, do których należą między innymi .NET Framework, .NET Core i Xamarin. Użyj tego tagu w przypadku pytań dotyczących kodu napisanego w C # lub C # formalnej specyfikacji.

c#to wielo-paradygmatyczny, zarządzany, obiektowy język programowania stworzony przez firmę Microsoft we współpracy z .NET. Języka C # można używać w dowolnej implementacji platformy .NET, takiej jak .NET Core, .NET Framework, Mono i Xamarin.

Wersje

+---------+---------------------------------------------------------+----------------+----------------------------------+---------------------------------+
| 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 |
+---------+--------------------------------+------------------------+----------------+----------------------------------+---------------------------------+

Nowe funkcje

Wersje 1.0 / 1.2 i 2.0 języka C # zostały przesłane i zatwierdzone jako ECMA(Wersja internetowa ) i ISO / IEC. Najnowsza wersja ECMA pasuje dospecyfikacji Microsoft C # 5.0. Microsoft udostępnia również specyfikacje językowe dla języka C # 3.0i C # 5.0, a także C # 6.0wersja robocza.

System typów języka był pierwotnie statyczny, z dozwolonymi tylko jawnymi deklaracjami zmiennych. Wprowadzenie var(C # 3.0) i dynamic(C # 4.0) umożliwiło mu korzystanie z wnioskowania o typie do niejawnego wpisywania zmiennych i używania dynamiczne systemy typu. Delegaci, zwłaszcza z obsługą zamykania leksykalnego dla metod anonimowych (C # 2,0) i wyrażeń lambda (C # 3,0), umożliwiają używanie języka do programowania funkcjonalnego.

C # 5.0 wprowadził asynci await, aby uprościć korzystanie z asynchronicznych wywołań funkcji.

C # 6.0 wprowadził operator propagacji wartości null?., wyjątek filtry, interpolacja ciągówi wiele innych funkcjiułatwiających pisanie prostego kodu.

C # 7.0 wprowadził wiele argumentów out, dopasowywanie wzorców, krotki dla wartości zwracanej, is - wyrażenia & amp; switch instrukcje z wzorami, dekonstrukcją, funkcjami lokalnymi i kilkoma innymi.

C # 7.1 wprowadził ogólne dopasowanie wzorców, wywnioskowane nazwy elementów krotki, default wyrażenia literalne, async main i kilka innych.

C # 7.2 wprowadził private protected, niekońcowe nazwane argumenty, separator cyfrowy po podstawowym specyfikatorze, wyrażenie warunkowe ref, semantykę odwołań dla typów wartości i kilka innych.

C # 7.3 wprowadził funkcje, które umożliwiają bezpieczny kod tak samo wydajny jak niebezpieczny kod, nowe opcje kompilatora, użycie out deklaracji zmiennych w inicjalizatorach pola, właściwości i konstruktora, wsparcie == i != na typach krotek i nie tylko.

C # 8.0 wprowadził typy odwołań do wartości null, które generują ostrzeżenia kompilatora o możliwym wyłuskiwaniu wartości null, chyba że kod wyraźnie wskazuje, że zmienną może być null (np. string? foo jest zmienną, która może być zerowa), strumienie asynchroniczne, które wzmacniają -w szczególności- integrację IoT i chmury i domyślne metody interfejsu, aby zapobiec poważnym zmianom w interfejsach, wraz z innymi ulepszenia.

C # 9.0 wprowadził wiele nowych koncepcji i funkcji, takich jak Records, Init only setters, Instrukcje najwyższego poziomu, Ulepszenia dopasowywania wzorcówi nie tylko.

Kompilacja jest zwykle wykonywana w języku Microsoft Intermediate Language (MSIL), który jest następnie kompilowany JIT do kodu natywnego (i buforowany) podczas wykonywania w środowisku uruchomieniowym języka wspólnego (CLR). Jednak opcje takie jak NGen(dla .NET Framework) i AOT (dla mono) oznacza, że kod C # można bezpośrednio skompilować do obrazu natywnego. Ponadto niektóre struktury (na przykład .NET Micro Framework) działają jako interpretery CIL, bez JIT.

W przeciwieństwie do szablonów C ++ (szablony są rozwiązywane w czasie kompilacji) lub typy generyczne Java (które używają wymazywania typów) w języku C # generyczne są dostarczane częściowo przez środowisko wykonawcze.

Dzięki połączeniu .NET Coredla systemów Windows, macOS i Linux, .NET Frameworkdla Windows (desktop / server / mobile), Mono, który obsługuje aplikacje Xamarin na Androida, Mac, iOS, tvOS i watchOS, Silverlight / Moonlight (przeglądarka / mobilna), Compact Framework (mobilny ) i Micro Framework (urządzenia wbudowane), jest dostępny dla szerokiej gamy platform.


Przykład Hello World:

using System;

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

Przykład Hello World przy użyciu klas:

using System;

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

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

Zasoby przepełnienia stosu


FAQs


Zasoby


Książki


Poradniki


Przyszłość języka C #

Przekaż i zaproponuj nowe funkcje tutaj.


Projekty demonstracyjne


C # Online IDE


C # Offline IDE

Powiązane tagi