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
- Jak wysyłać wiadomości e-mail w ASP.NET C #
- Jakie są prawidłowe numery wersji dla języka C #?
- Jaka jest różnica między ciągiem a ciągiem w C #?
- Dlaczego
Randomza każdym razem daje te same wyniki? - Przechwycone zmienne w pętlach
- Czy w C # można rzutować
List<Child>naList<Parent>? - Czy C # przekazuje obiekty przez odwołanie?
- Dlaczego kompilator narzeka na moje wyrażenie warunkowe (
a == b ? x : y)? - Dlaczego otrzymuję
NullReferenceException? (Odniesienie do obiektu nie jest ustawione na wystąpienie obiektu) - Co to jest wyjątek „indeks poza zakresem” i jak go naprawić?
- Co nowego w C # 4.0?
- Co nowego w programie .NET Framework?
- Co nowego w C #?
- Nowe funkcje w C # 6
- Nowe funkcje w C # 7
- Nowe funkcje w C # 8
- Ukryte funkcje C #?
- Nowe funkcje w C # 9
Zasoby
- Historia języka C #
- Specyfikacja języka C # 5.0
- C # 6.0 wersja robocza specyfikacji języka
- Artykuł w Wikipedii
- Projekty .NET w serwisie GitHub
- Stary blog Erica Lipperta || Nowy blog Erica Lipperta
- Blog Jona Skeeta
- James Michael Hare's C # / .NET Little Wonders & amp; Seria Little Pitfalls
- Przewodnik programowania
- Wprowadzenie do języka Visual C #
- Podstawy języka C #: programowanie dla absolutnie początkujących
- Visual C # .NET dla początkujących
- csharp.2000things
- Dot Net Perls
Książki
- CLR przez C #
- C # 7.0 w pigułce: The Definitive Reference
- C # w głębi
- Head First C #
- Język programowania C # (wydanie trzecie, 4. wydanie)
- Wytyczne dotyczące projektowania ram
- Essential C # (6.0 (piąte wydanie), 7.0 (szósta edycja))
- Visual C # Jak programować
- Visual C # .NET krok po kroku
- C # 5.0 uwolniony
- Pro C # 7.0: z .NET i .NET Core
- Nauka języka C # 3.0
- Zaczynamy od Visual C # (4. wydanie)
- Programowanie C # 5.0 - tworzenie aplikacji dla systemu Windows 8, sieci Web i aplikacji komputerowych dla platformy .NET 4.5 Framework
- C # 4.0 kompletne odniesienie
- [C # Design Pattern Essentials] 47
- C # 6.0 i .NET 4.6 Framework
- C # 7 i .NET Core
- Efektywny C # (obejmuje C # 6.0), 50 konkretnych sposobów na poprawę języka C # (3. wydanie)
- Skrócona instrukcja składni języka C # 7: kieszonkowy przewodnik po języku, interfejsach API i bibliotece (wydanie drugie)
Poradniki
- MSDN
- Wirtualna Akademia Microsoft
- docs.microsoft.com
- microsoft.com/dotnet
- Kanał 9: C #
- Ścieżka Pluralsight C #
Przyszłość języka C #
Przekaż i zaproponuj nowe funkcje tutaj.
Projekty demonstracyjne
C # Online IDE
C # Offline IDE