Loading AI tools
多範式(面向對象)編程語言 来自维基百科,自由的百科全书
C#是微軟推出的一種基於.NET框架和後來的.NET的、物件導向的進階程式語言。C#是一種由C和C++衍生出來的物件導向的程式語言。它在繼承C和C++強大功能的同時去掉了一些它們的複雜特性,使其成為C語言家族中的一種高效強大的程式語言。C#以.NET框架類別程式庫作為基礎,擁有類似Visual Basic的快速開發能力。C#由安德斯·海爾斯伯格主持開發,微軟在2000年發布了這種語言,希望藉助這種語言來取代Java。C#已經成為Ecma國際和國際標準組織的標準規範。
![]() | |
編程範型 | 結構化、物件導向、泛型 |
---|---|
語言家族 | C |
設計者 | 微軟 |
實作者 | 微軟 |
面市時間 | 2000年 |
目前版本 |
|
作業系統 | Windows、Linux、Mac OS X 、 Android |
許可證 |
|
副檔名 | .cs , .csx |
網站 | docs |
主要實作產品 | |
.NET、.NET框架、Mono、DotGNU | |
衍生副語言 | |
Cω、Spec#、Polyphonic C# | |
啟發語言 | |
C++、Java、Eiffel、Modula-3、Object Pascal | |
影響語言 | |
Clojure[4]、D語言、F#、Java 5、Nemerle、Vala |
C#的發音為「C sharp」,「#」讀作「sharp」(/ʃɑːp/),命名啟發於音樂上的音名「C♯」,在音樂中「C♯」表示C升半音,為比C高一點的音節,且「#」形似4個加號,微軟藉助這樣的命名,以表示C#在一些語言特性方面對C++的提升的意思。
由於顯示器(標準字體、瀏覽器等)的技術限制,且大部分的鍵盤配置上不存在升記號(♯),所以井號(#)被用於此程式語言的名稱中,約定在ECMA-334 C#語言規範中[5]。
ECMA標準列出的C#設計目標:
原Borland公司的首席研發設計師安德斯·海爾斯伯格(Anders Hejlsberg)在微軟開發了Visual J++ 1.0,很快的Visual J++由1.1版本升級到6.0版。SUN公司認為Visual J++ 違反了Java開發平台的中立性,對微軟提出了訴訟。2000年6月26日微軟在奧蘭多舉行的「職業開發人員技術大會」(PDC 2000)上,發表新的語言C#。C#語言取代了Visual J++,語言本身深受Visual Basic、Java、C和C++ 的影響。
版本 | 語言規格 | 日期 | .NET框架版本 | Visual Studio的版本 | ||
---|---|---|---|---|---|---|
ECMA | ISO/IEC | Microsoft | ||||
C# 1.0 | 2002年12月(頁面存檔備份,存於網際網路檔案館) | 2003年4月(頁面存檔備份,存於網際網路檔案館) | 2002年1月(頁面存檔備份,存於網際網路檔案館) | 2002年1月 | .NET Framework 1.0 | Visual Studio .NET 2002 |
C# 1.1 C# 1.2 |
2003年10月(頁面存檔備份,存於網際網路檔案館) | 2003年4月 | .NET Framework 1.1 | Visual Studio .NET 2003 | ||
C# 2.0 | 2006年6月 | 2006年9月(頁面存檔備份,存於網際網路檔案館) | 2005年9月(頁面存檔備份,存於網際網路檔案館) | 2005年11月 | .NET Framework 2.0 | Visual Studio 2005 |
C# 3.0 | 否 | 2007年8月(頁面存檔備份,存於網際網路檔案館) | 2007年11月 |
.NET Framework 2.0 (Except LINQ)[6] |
Visual Studio 2008 Visual Studio 2010 | |
C# 4.0 | 2010年4月 | 2010年4月 | .NET Framework 4 | Visual Studio 2010 | ||
C# 5.0 | 2017年12月(頁面存檔備份,存於網際網路檔案館) | 2018年12月(頁面存檔備份,存於網際網路檔案館) | 2013年6月(頁面存檔備份,存於網際網路檔案館) | 2012年8月 | .NET Framework 4.5 | Visual Studio 2012 Visual Studio 2013 |
C# 6.0 | 否 | 草案(頁面存檔備份,存於網際網路檔案館) | 2015年7月/2016-06-27 | .NET Framework 4.6/.NET Core 1.0 | Visual Studio 2015 | |
C# 7.0 | 建議草案 (頁面存檔備份,存於網際網路檔案館) | 2017年3月 | .NET Framework 4.6.2 | Visual Studio 2017 | ||
C# 7.1 | 否 | 否 | 建議草案 (頁面存檔備份,存於網際網路檔案館) | 2017年8月/2016-08-14 | .NET Framework 4.7/.NET Core 2.0 | Visual Studio 2017 version 15.3[7] |
C# 7.2 | 否 | 否 | 建議草案 | 2017年11月 | .NET Framework 4.7.1 | Visual Studio 2017 version 15.5[8] |
C# 7.3 | 否 | 否 | 建議草案 (頁面存檔備份,存於網際網路檔案館) | 2018年5月/2018-05-30/2018-12-04 | .NET Framework 4.7.2/.NET Core 2.1/.NET Core 2.2 | Visual Studio 2017 version 15.7[8] |
C# 8 | 否 | 否 | 建議草案 (頁面存檔備份,存於網際網路檔案館) | 2019年9月/2019-09-23/2019-12-03 | .NET Framework 4.8/.NET Core 3.0/.NET Core 3.1 | Visual Studio 2019 version 16.3[8] |
C# 9 | 否 | 否 | 建議草案 (頁面存檔備份,存於網際網路檔案館) | 2020年11月 | .NET 5 | Visual Studio 2019 version 16.8[8] |
C# 10[9] | 否 | 否 | 建議草案 (頁面存檔備份,存於網際網路檔案館) | 2021年11月 | .NET 6 | Visual Studio 2022 version 17.0[10] |
C# 11[9] | 否 | 否 | 建議草案 (頁面存檔備份,存於網際網路檔案館) | 2022年11月 | .NET 7 | Visual Studio 2022 version 17.4[11] |
C# 12[12] | 否 | 否 | 建議草案 | 2023年11月 | .NET 8 | Visual Studio 2022 version 17.8[13] |
針對於.NET SDK 2.0(相對應於ECMA-334標準第三版),C# 的新特性有:
分部類別將類別的實現分在多個檔案中。該概念於C# 中首次出現,除了能將一個類別的成員分開存放,還使ASP.NET中的代碼後置得以實現。代碼後置實現了HTML代碼和後台互動代碼的分離。
file1.cs:
public partial class MyClass1
{
public void MyMethod1()
{
// implementation
}
}
file2.cs:
public partial class MyClass1
{
public void MyMethod2()
{
// implementation
}
}
分部類別這個特性允許將一個類別的編寫工作分配給多個人,一人寫一個檔案,便於版本控制。它又可以隔離自動生成的代碼和人工書寫的代碼,例如設計表單應用程式時。
泛型,或參數化類型,是被C#支援的.NET 2.0特性。不同於C++模版,.NET參數化類型是在執行時被實例化,而不是編譯時,因此它可以跨語言,而C++模版卻不行。C#泛型類在編譯時,先生成中間代碼IL,通用類型符號T只是一個預留位置;在實例化類時,根據實際資料類型代替T並由即時編譯器(JIT)生成本地代碼,其中使用了實際的資料類型,等同於用實際類型寫的普通的類。
它支援的一些特性並不被C++模版直接支援,比如約束泛型參數實現一個介面。另一方面,C# 不支援無類型的泛型參數。不像Java中的泛型,在CLI虛擬機器中,.NET generics使用具化生成泛型參數,它允許最佳化和儲存類型資訊。[14]
泛型類中,可以用where關鍵字對參數類型實現約束。例如:
class Node<T, V>
where T : Stack, IComparable, new(), class
where V : Stack, struct
{...}
上述表示T和V必須是Stack類或其衍生類別,T必須繼承了IComparable介面、有無參建構函式、是參照類型;V必須是值類型。
泛型不僅能作用在類上,也可單獨用在類的方法上,稱為「泛型方法」。
泛型類的靜態成員變數在相同封閉類間共享,不同的封閉類間不共享。
泛型類中的方法多載,參數類型T和V在執行時確定,不影響這個類通過編譯。C#的泛型是在實例的方法被呼叫時檢查多載是否產生混淆,而不是在泛型類本身編譯時檢查。特別地,當一般方法與泛型方法具有相同的簽章時,會覆蓋泛型方法。
靜態類別它不能被實例化,並且只能有靜態成員。這同很多過程語言中的模組概念相類似。
一種新形式的迭代器它提供了函數式程式設計中的generator,使用yield return
類似於Python中使用的yield
// Method that takes an iterable input (possibly an array)
// and returns all even numbers.
public static IEnumerable<int> GetEven(IEnumerable<int> numbers)
{
foreach (int i in numbers)
{
if (i % 2 == 0) yield return i;
}
}
注意事項:
匿名方法類似於函數式程式設計中的閉包。[15]匿名方法是通過使用 delegate 關鍵字建立委託實例來聲明的。例如:
delegate void NumberChanger(int n);
NumberChanger nc = delegate(int x)
{
Console.WriteLine("Anonymous Method: {0}", x);
};
public void Foo(object parameter)
{
// ...
ThreadPool.QueueUserWorkItem(delegate
{
// anonymous delegates have full access to local variables of the enclosing method
if(parameter == ...)
{
// ...
}
// ...
});
}
例子:
string status = string.Empty;
public string Status
{
get { return status; } // anyone can get value of this property,
protected set { status = value; } // but only derived classes can change it
}
可空類型(跟個問號,如int? i = null;
)允許設定null
給任何類類型。
int? i = null;
object o = i;
if(o == null)
Console.WriteLine("Correct behaviour - runtime version from September 2005 or later");
else
Console.WriteLine("Incorrect behaviour - pre-release runtime (from before September 2005)");
(??
):如果左運算數表達式的值不為空值時回傳該值,如果為空值則返回右運算數表達式的值。
object nullObj = null;
object obj = new Object();
return nullObj ?? obj; // returns obj
主要用作將一個可空類型賦值給不可空類型的簡便語法
int? i = null;
int j = i ?? 0; // Unless i is null, initialize j to i. Else (if i is null), initialize j to 0.
C# 3.0發布於2007年10月17日,是.NET Framework 3.5的一部分,它的新特性靈感來自於函數式程式設計語言,如:Haskell和ML,並廣泛地引入了Language Integrated Query(LINQ)模式到通用語言運行庫中e.[17]
語言整合查詢(英語:Language Integrated Query,縮寫:LINQ):[18] 上下文相關關鍵字"from
, where
, select
"可用於查詢SQL、XML、集合等。這些識別碼在LINQ上下文中被作為關鍵字,但是它們的增加不會破壞原有的名為from
、where
或select
的變數。
Customer c = new Customer();
c.Name = "James";
可寫作:
Customer c = new Customer() { Name = "James" };
MyList list = new MyList();
list.Add(1);
list.Add(2);
可寫作
MyList list = new MyList { 1, 2 };
假設MyList
實現了System.Collections.IEnumerable
且有一個Add
方法method[19]
var x = new { Name = "James" };
局部變數類型推斷:
var x = new Dictionary<string, List<float>>();
等同於
Dictionary<string, List<float>> x = new Dictionary<string, List<float>>();
它只是一個語法糖,這個特性被匿名類型聲明時所需要
Lambda表達式(無函式名稱的物件方法在程式語言中的表達語法):
listOfFoo.Where(
delegate(Foo x)
{
return x.Size > 10;
}
)
listOfFoo.Where(x => x.Size > 10);
編譯器翻譯Lambda表達式為強型別委託或強型別表達式樹。
注意事項:
編譯器將自動生成私有變數和適當的getter(get訪問器)和setter(set訪問器),如:
public string Name
{
get;
set;
}
擴充方法能夠使現有的類型添加方法,而無需新增的衍生類型、重新編譯或以其它方式修改原始類型。
使用拓展方法,必須在一個非巢狀、非泛型的靜態類中定義一個靜態方法,方法第一個參數必須附加this關鍵字作為字首,第一個參數不能有其它修飾詞(如ref或者out),這個方法將被編譯器添加到該this的類型中。
public static class IntExtensions
{
public static void PrintPlusOne(this int x)
{
Console.WriteLine(x + 1);
}
}
int foo = 0;
foo.PrintPlusOne();
注意事項:
允許碼產生器生成方法聲明作為擴充點,如果有人在另一個部分類實現了它才會被包含於原代碼編譯。[20]
例子:
partial class C
{
static partial void M(int i); // defining declaration
}
partial class C
{
static partial void M(int i)
{
dosomething();
}
}
C# 4.0新增dynamic關鍵字,提供動態編程(dynamic programming),把既有的靜態物件標記為動態物件,類似javascript, Python或Ruby。
dynamic關鍵字標記的實例被處理成一個特殊包裝的object對象,取消了CLI的編譯時型別檢查,編譯時被假定支援任何操作,但如果並不實際支援則執行時報錯。
dynamic calc = GetCalculator();
int sum = calc.Add(10, 20);
public StreamReader OpenFile(string path, int bufferSize = 1024)
{ ... }
呼叫OpenFile時,順序可以完全顛倒:
OpenFile(bufferSize: 4096, path: "foo.txt");
在C#中打開一個Word檔案:
static void Main(string[] args)
{
Word.Application wordApplication = new Word.Application() { Visible = true };
wordApplication.Documents.Open(@"C:\plant.docx", ReadOnly: true);
}
在C#中指定Excel的某一格文字:
excelObj.Cells[5, 5].Value = "This is sample text";
C# 4.0支援協變和逆變,例如在泛型介面可以加上in、out修饰字。
public interface IComparer<in T>
{
int Compare(T left, T right);
}
public interface IEnumerable<out T> : IEnumerable
{
IEnumerator<T> GetEnumerator();
}
using System;
public class Person
{
public Person(string firstName, string lastName)
{
fname = firstName;
lname = lastName;
}
private string fname;
private string lname;
public override string ToString() => $"{fname} {lname}".Trim(); //返回值类型string
public void DisplayName() => Console.WriteLine(ToString()); //返回值类型void
public string Name => $"{fname} {lname}".Trim();//只读属性
}
能夠直接宣告一個變數在它要傳入的地方,當成一個 out 的引數[21]
元組/對象的解構:
var tuple = (1, 2, 3, 4, 5);
(_, _, _, _, var fifth) = tuple;
使用 is/switch 的模式匹配:
var obj = CultureInfo.CurrentCulture.DateTimeFormat;
switch (obj)
{
case IFormatProvider fmt:
Console.WriteLine($"{fmt} object");
break;
case null:
Console.Write("A null object reference");
break;
case object _:
Console.WriteLine("Some object type without format information");
break;
}
if (obj is object _) { ... }
對具有 out 參數的方法的呼叫:
var point = new Point(10, 10);
// 只要 x, 不关心 y
point.GetCoordinates(out int x, out _);
作用域內獨立使用場景:
void Test(Dto dto)
{
_ = dto ?? throw new ArgumentNullException(nameof(dto));
}
using System;
public class Location
{
private string locationName;
public Location(string name) => Name = name; //构造函数
public string Name
{
get => locationName; //get属性
set => locationName = value; //set属性
}
public override string ToString() => GetType().Name;
~Location() => Console.WriteLine($"The {ToString()} finalizer is executing."); //析构函数
private string[] types = { "Baseball", "Basketball", "Football",
"Hockey", "Soccer", "Tennis",
"Volleyball" };
public string this[int i]
{
get => types[i]; //索引器
set => types[i] = value;
}
}
記錄類型, 是一種參照類型, 預設是不可變的。 記錄類型的相等判斷可以通過參照或者結構進行判斷的。
// 默认不可变的记录类型
public record Person(string Name, int Age);
// 可变记录类型
public record MutablePerson(string Name, int Age)
{
public string Name { get; set; } = Name;
public int Age { get; set; } = Age;
}
var person1 = new Person("Alice", 40);
var person2 = new Person("Alice", 40);
Console.WriteLine(person1 == person2); // True 结构相同
Console.WriteLine(person1.Equals(person2)); // True 结构相同
Console.WriteLine(ReferenceEquals(person1, person2)); // False, 引用不同
// 改变默认的记录! --> 创建一个新的记录。
var person3 = person1 with { Age = 43 };
Console.WriteLine(person3 == person1); // False 结构不同
// 解构 (Destruct) 一个记录, 将记录的属性提取为本地变量
var (name, age) = person3;
var person4 = new MutablePerson("Alice", 40);
person4.Age = 43;
// 记录类型也可以被继承
public record Citizen(string Name, int Age, string Country) : Person(Name, Age);
var citizen = new Citizen("Alice", 40, "China");
Console.WriteLine(person1 == citizen); // False 类型不同;
init存取子表示該屬性所屬類型僅能在建構函式(Constructor)中或是屬性初始化式子中賦予其值,如果嘗試在其他地方設定該屬性的值,在編譯時便會遭編譯器阻止。
範例如下:在這個範例中,建立了一個Student
類型,並且屬性StudentName
與StudentID
只能在初始化時賦予其值。
public class Student
{
public Student()
{
}
public Student(string studentName,string studentID)
{
StudentName = studentName;
StudentID = studentID;
}
public string StudentName { get; init; } = "Default Name";
public string StudentID { get; init; } = "00000000";
}
如果在此時撰寫以下程式碼:
Student DemoStudent = new Student();
DemoStudent.StudentName = "Test Name";
編譯器便會無法編譯並且擲回錯誤。
而如果要建立學生名稱為「Test Name」,學生ID為「0001」的學生,則需要寫成:
Student DemoStudent = new Student() //物件初始化運算式
{
StudentName = "Test Name";
StudentID = "0001"
};
或是
Student DemoStudent = new Student("Test Name","0001"); //藉由類型的建構式初始化StudentName以及StudentID。
在以前的版本,開發者在撰寫最上層語句(如Program.cs)程式碼時,需要包含完整的namespace與class架構,因此如果要撰寫Hello World程式時,程式碼就會是:
using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
}
}
但是在C# 9之後,最上層語句的程式碼不需要包含namespace以及class,可將其簡化為:
using System;
Console.WriteLine("Hello World!");
//或者简化为一行语句:
System.Console.WriteLine("Hello World!");
注意, 一個程式中, 只能有一個檔案使用頂級語句, 並且頂級語句必須位於命名空間或類型定義之前。
Func<int, int, int> zero = (_, _) => 0;
Func<int, int, int> func = delegate (int _, int _) { return 0; };
在 C# 9 之前,即便不使用的 Lambda 參數也需要給它命名。C# 9 支援棄元參數一方面簡化了命名,另一方面也節省了主記憶體分配。更重要的是它使得編程的意圖更明確,讓人一看就知道這個參數是不用的,增強了代碼的可讀性和可維護性。
Init only setters,只能通過對象初始化進行賦值的屬性。
public class InitDemo
{
public string Start { get; init; }
public string Stop { get; init; }
}
// initDemo.Start = "Now"; // Error
// initDemo.End = "Tomorrow"; // Error
var initDemo = new InitDemo
{
Start = "Now",
Stop = "Tomorrow"
};
使用 delegate* 可以聲明函式指標。
unsafe class FunctionPointer {
static int GetLength(string s) => s.Length;
delegate*<string, int> functionPointer = &GetLength;
}
public void Test() {
Console.WriteLine(functionPointer("test")); // 4;
}
[System.Runtime.CompilerServices.SkipLocalsInit]
static unsafe void DemoLocalsInit() {
int x;
// 注意, x 没有初始化, 输出结果不确定;
Console.WriteLine(*&x);
}
兩個新的整數類型 nint 和 nunit , 依賴宿主機以及編譯設定。
協變返回類型為重寫方法的返回類型提供了靈活性。覆蓋方法可以返回從被覆蓋的基礎方法的返回類型衍生的類型。
class Person
{
public virtual Person GetPerson() { return new Person(); }
}
class Student : Person
{
public override Student GetPerson() { return new Student(); }
}
ModuleInitializerAttribute 為組件 (assembly) 定義初始化代碼, 當初始化/載入時執行, 可以類比類的靜態建構函式, 但是是組件級別的。
static 修飾詞添加到 lambda 表達式或匿名方法 。這將無法擷取局部變數或實例狀態,從而防止意外擷取其他變數。
移除了分部方法的下述限制:
如果建立對象的類型已知時,可以在new表達式中省略該類型。
Point p = new(1, 1);
Dictionary<string, int> dict = new();
Point[] points = { new(1, 1), new (2, 2), new (3, 3) };
var list = new List<Point> { new(1, 1), new(2, 2), new(3, 3)};
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
namespace CoreApp2
{
class Program
{
static void Main(string[] args)
{
[Conditional("DEBUG")]
static void DoSomething([NotNull] string test)
{
System.Console.WriteLine("Do it!");
}
DoSomething("Doing!");
}
}
}
可以為任意類型添加一個 GetEnumerator 擴充方法, 返回一個 IEnumerator 或者 IAsyncEnumerator 實例, 從而在 foreach 迴圈中使用。
using System.Collections.Generic;
using System.Collections.ObjectModel;
namespace CoreApp2
{
public static class Extensions
{
public static IEnumerator<T> GetEnumerator<T>(this IEnumerator<T> enumerator) => enumerator;
}
class Program
{
static void Main(string[] args)
{
IEnumerator<string> enumerator = new Collection<string> {"A", "B", "C"}.GetEnumerator();
foreach (var item in enumerator)
{
Console.WriteLine(item);
}
}
}
}
Type patterns 類型匹配,判斷一個變數的類型
object obj = new int();
var type = obj switch
{
string => "string",
int => "int",
_ => "obj"
};
Console.WriteLine(type); // int
Relational patterns 關係匹配:
class Person
{
public string name;
public int age;
public Person(string a, int b) { name = a;age = b; }
public void Deconstruct(out string a,out int b){a = name;b = age; }
}
class Program
{
static void Main(string[] args)
{
var person1 = new Person("Alice", 40);
var inRange = person1 switch
{
(_, < 18) => "less than 18",
(_, > 18) => "greater than 18",
(_, 18) => "18 years old!"
};
Console.WriteLine(inRange); // greater than 18
}
}
Conjunctive and patterns 邏輯合取匹配:
// And pattern
var person1 = new Person("Alice", 40);
var ageInRange = person1 switch
{
(_, < 18) => "less than 18",
("Zhang Zhimin", _) and (_, >= 18) => "Alice is greater than 18"
};
Console.WriteLine(ageInRange); // Alice is greater than 18
Disjunctive or patterns 邏輯析取匹配:
// Or pattern
var person1 = new Person("Alice", 40);
var ageInRange = person1 switch
{
(_, < 18) => "less than 18",
(_, 18) or (_, > 18) => "18 or greater"
};
Console.WriteLine(ageInRange); // 18 or greater
Negated not patterns 邏輯非匹配
// Not pattern
var person1 = new Person("Alice", 40);
var meOrNot = person1 switch
{
not ("Alice", 40) => "Not me!",
_ => "Me :-)"
};
Console.WriteLine(meOrNot); // Me :-)
Parenthesized patterns 帶括號的優先級匹配:
// Parenthesized patterns
var is10 = new IsNumber(true, 10);
var n10 = is10 switch
{
((_, > 1 and < 5) and (_, > 5 and < 9)) or (_, 10) => "10",
_ => "not 10"
};
Console.WriteLine(n10); // 10
解決了 record 只能給 class 而不能給 struct 用的問題:
record struct Point(int X, int Y);
可以把 record 里的 ToString 方法標記成 sealed
無參建構函式使得new struct() 和 default(struct) 的語意不一樣
var x = new { A = 1, B = 2 };
var y = x with { A = 3 };
這裡 y.A 將會是 3 。
可以給整個專案啟用 using,不需要每個檔案都寫一份。
以前寫 namespace 還得帶一層大括號。現在如果一個檔案里只有一個 namespace 的話,直接在檔案開頭寫:namespace MyNamespace;
const string x = "hello";
const string y = $"{x}, world!";
f = [Foo] (x) => x; // 给 lambda 设置
f = [return: Foo] (x) => x; // 给 lambda 返回值设置
f = ([Foo] x) => x; // 给 lambda 参数设置
此前 C# 的 lambda 返回值類型靠推導,C# 10允許在參數列之前顯式指定 lambda 返回值類型:
f = int () => 4;
f = ref int (ref int x) => ref x; // 返回一个参数的引用
函式可以隱式轉換到 delegate,於是函式上升為頭等函式(first function):
void Foo() { Console.WriteLine("hello"); }
var x = Foo;
x(); // hello
lambda 可自動建立自然委託類型,於是不再需要寫出類型:
var f = () => 1; // Func<int>
var g = string (int x, string y) => $"{y}{x}"; // Func<int, string, string>
var h = "test".GetHashCode; // Func<int>
使用CallerArgumentExpression這個attribute,編譯器會自動填充呼叫參數的表達式字串,例如:
void Foo(int value, [CallerArgumentExpression("value")] string? expression = null)
{
Console.WriteLine(expression + " = " + value);
}
當你呼叫 Foo(4 + 5) 時,會輸出 4 + 5 = 9。這對測試框架極其有用
int y = 0;
(var x, y, var z) = (1, 2, 3);
於是 y 就變成 2 了,同時還建立了兩個變數 x 和 z,分別是 1 和 3 。
.NET 6中這個特性為preview特性。
在方法上用 [AsyncMethodBuilder(...)],來使用自己實現的 async method builder,代替內建的 Task 或者 ValueTask 的非同步方法構造器。有助於實現零開銷的非同步方法。
以前 #line 只能用來指定一個檔案中的某一行,現在可以指定行列和範圍:
#line (startLine, startChar) - (endLine, endChar) charOffset "fileName"
// 比如 #line (1, 1) - (2, 2) 3 "test.cs"
以前在匹配巢狀屬性的時候需要這麼寫:
if (a is { X: { Y: { Z: 4 } } }) { ... }
現在只需要簡單的:
if (a is { X.Y.Z: 4 }) { ... }
實現接近零開銷的字串插值。
包括強型別的代碼構建器,以及增量編譯的支援等
C# 11 開始支援屬性(attribute)為泛型類,即允許聲明基礎類別為System.Attribute
的泛型類:
public class GenericAttribute<T> : Attribute { }
C# 11 開始允許介面中定義靜態方法(包括運算子多載方法),實現該介面的類必須包含該靜態方法[23]:
public interface IGetNext<T> where T : IGetNext<T>
{
static abstract T operator ++(T other);
}
對泛型及其對象進行數學操作的支援。基於靜態介面方法特性,自 .NET 8.0 起,在System
命名空間中提供數學運算相關泛型介面,以支援泛型的運算操作[25]:
public static TResult Sum<T, TResult>(IEnumerable<T> values)
where T : INumber<T>
where TResult : INumber<TResult>
{
TResult result = TResult.Zero;
foreach (var value in values)
{
result += TResult.Create(value);
}
return result;
}
允許內插字串中{
與}
內的文字跨多個行
原始字串文字以 """
開始並以 """
結束,允許多行字串,若為多行字串則以單獨的一行 """
結束,且字串的縮排以末尾的 """
的起始位置為基準。原始字串文字不進行任何跳脫操作,但允許字串內插(開頭的 $ 數量代表內插所需要的花括號數)[26]:
var x = 1;
var y = 2;
var code1 = """int i = 0;""";
var code2 = $"""int x = {x};""";
var code3 = $$"""
#include <stdio.h>
int main(void) {
const char *s = "{y} = {{y}}"; // {y} = 2
return 0;
}
""";
Console.WriteLine($"code1:\n{code1}\n");
Console.WriteLine($"code2:\n{code2}\n");
Console.WriteLine($"code3:\n{code3}\n");
可以對字串字面量指定 u8
字尾來指定 UTF-8 字元編碼的字串字面量,其類型為ReadOnlySpan<byte>
[27]:
使用[
和]
可以定義列表模式,用於模式匹配:
int[] numbers = { 1, 2, 3 };
Console.WriteLine(numbers is [1, 2, 3]); // True
Console.WriteLine(numbers is [1, 2, 4]); // False
Console.WriteLine(numbers is [1, 2, 3, 4]); // False
Console.WriteLine(numbers is [0 or 1, <= 2, >= 3]); // True
C# 11 起 nint
和 nuint
類型的別名分別為 IntPtr
和 UIntPtr
(C# 9 中它們僅被認為是「相似」的[28])。
最佳化了方法組向委託轉換的效能。例如下述代碼中,在 C# 11 前,Sum
比 SumMethodGroup
效能更高[29]:
static readonly List<int> Numbers = Enumberable.Range(0, 100).ToList();
public int Sum()
{
return Numbers.Where(x => Filter(x)).Sum(); // <- faster
}
public int SumMethodGroup()
{
return Numbers.Where(Filter).Sum(); // <- slower
}
static bool Filter(int number)
{
return number > 50;
}
C#通常不被編譯成為能夠直接在電腦上執行的二進制本地代碼。與Java類似,它被編譯成為中間代碼(Microsoft Intermediate Language),然後通過.NET Framework的虛擬機器——被稱為通用語言執行層——執行。
所有的.Net程式語言都被編譯成這種被稱為通用中間語言的中間代碼。因此雖然最終的程式在表面上仍然與傳統意義上的可執行檔都具有「.exe」的字尾名。如果電腦上沒有安裝.Net Framework,那麼這些程式會彈出對話方塊,要求使用者下載.net framework。
在程式執行時,.Net Framework將中間代碼翻譯成為二進制機器碼,從而使它得到正確的執行。最終的二進制代碼被儲存在一個緩衝區(Buffer)中。所以一旦程式使用了相同的代碼,那麼將會呼叫緩衝區中的版本。這樣如果一個.Net程式第二次被執行,那麼這種翻譯不需要進行第二次,速度明顯加快。
微軟公司已經向ECMA申請將C#作為一種標準。在2001年12月,ECMA發布了ECMA-334 C#語言規範。C#在2003年成為一個ISO標準(ISO/IEC 23270)。現在有一些獨立的實現正在進行,包括:
下面是一個在命令提示字元上輸出Hello World的小程式,這種程式通常作為開始學習程式語言的第一個步驟:
using System;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
}
}
微軟正在引領開源參考 C# 編譯器和工具集的開發。 第一個編譯器 Roslyn編譯成中間語言(IL),第二個編譯器 RyuJIT,[30] 是一個 JIT(即時)編譯器,它是動態的,進行動態最佳化並編譯將 IL 轉換為 CPU 前端的本機代碼。[31] RyuJIT 是開源的,用 C++ 編寫。[32] Roslyn 完全是用 受控代碼 (C#)編寫的,已經開放並且功能以 API 的形式出現。因此,它使開發人員能夠建立重構和診斷工具。[2][33] 官方實現的兩個分支是 .NET Framework(閉源,僅限 Windows)和 .NET Core(開源,跨平台);它們最終融合為一個開源實現:.NET 5.0。[34] 在 .NET Framework 4.6 中,新的 JIT 編譯器取代了前者。[30][35]
其他 C# 編譯器(其中一些包括公共語言基礎結構和 .NET 類別程式庫的實現):
遊戲引擎 Unity 使用C# 作為其主要手稿語言。由於Microsoft 捐贈了 24,000 美元, Godot 遊戲引擎實現了一個可選的 C# 模組。