Udostępnij za pośrednictwem

nowy operator — new operator tworzy nowe wystąpienie typu

Operator new tworzy nowe wystąpienie typu. Możesz również użyć słowa kluczowego new jako modyfikatora deklaracji składowej lub ograniczenia typu ogólnego.

Wywołanie konstruktora

Aby utworzyć nowe wystąpienie typu, zazwyczaj wywołujesz jeden z konstruktorów tego typu przy użyciu new operatora :

var dict = new Dictionary<string, int>();
dict["first"] = 10;
dict["second"] = 20;
dict["third"] = 30;

Console.WriteLine(string.Join("; ", dict.Select(entry => $"{entry.Key}: {entry.Value}")));
// Output:
// first: 10; second: 20; third: 30

Możesz użyć inicjatora obiektu lub kolekcji z operatoremnew, aby utworzyć wystąpienie i zainicjować obiekt w jednej instrukcji, jak pokazano w poniższym przykładzie:

var dict = new Dictionary<string, int>
{
    ["first"] = 10,
    ["second"] = 20,
    ["third"] = 30
};

Console.WriteLine(string.Join("; ", dict.Select(entry => $"{entry.Key}: {entry.Value}")));
// Output:
// first: 10; second: 20; third: 30

Typ docelowy new

Wyrażenia wywołania konstruktora są typizowane przez obiekt docelowy. Oznacza to, że jeśli znany jest typ docelowy wyrażenia, można pominąć nazwę typu, jak pokazano w poniższym przykładzie:

List<int> xs = new();
List<int> ys = new(capacity: 10_000);
List<int> zs = new() { Capacity = 20_000 };

Dictionary<int, List<int>> lookup = new()
{
    [1] = new() { 1, 2, 3 },
    [2] = new() { 5, 8, 3 },
    [5] = new() { 1, 0, 4 }
};

Jak pokazano w poprzednim przykładzie, zawsze należy używać nawiasów w wyrażeniu typu new docelowego.

Jeśli typ docelowy new wyrażenia jest nieznany (na przykład w przypadku używania var słowa kluczowego), musisz określić nazwę typu.

Tworzenie tablicy

Operator służy new również do tworzenia wystąpienia tablicy, jak pokazano w poniższym przykładzie:

var numbers = new int[3];
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
Console.WriteLine(string.Join(", ", numbers));
// Output:
// 10, 20, 30

Użyj składni inicjowania tablicy, aby utworzyć wystąpienie tablicy i wypełnić je elementami w jednej instrukcji. W poniższym przykładzie przedstawiono różne sposoby, w jaki można to zrobić:

var a = new int[3] { 10, 20, 30 };
var b = new int[] { 10, 20, 30 };
var c = new[] { 10, 20, 30 };
Console.WriteLine(c.GetType());  // output: System.Int32[]

Aby uzyskać więcej informacji na temat tablic, zobacz Tablice.

Tworzenie wystąpień typów anonimowych

Aby utworzyć wystąpienie typu anonimowego, użyj new operatora i składni inicjatora obiektów:

var example = new { Greeting = "Hello", Name = "World" };
Console.WriteLine($"{example.Greeting}, {example.Name}!");
// Output:
// Hello, World!

Niszczenie wystąpień typu

Nie trzeba niszczyć wcześniej utworzonych wystąpień typu. Wystąpienia typów odwołań i wartości są niszczone automatycznie. Wystąpienia typów wartości są niszczone natychmiast po zniszczeniu kontekstu zawierającego je. Wystąpienia typów odwołań są niszczone przez moduł odśmiecający śmieci w nieokreślonym czasie po usunięciu ostatniego odwołania do nich.

W przypadku wystąpień typów, które zawierają zasoby niezarządzane, na przykład dojście do plików, zaleca się zastosowanie deterministycznego czyszczenia w celu zapewnienia, że zasoby, które zawierają, są zwalniane tak szybko, jak to możliwe. Aby uzyskać więcej informacji, zobacz dokumentację interfejsu System.IDisposable API i artykuł z instrukcjąusing.

Przeciążenie operatora

Typ zdefiniowany przez użytkownika nie może przeciążyć new operatora.

specyfikacja języka C#

Aby uzyskać więcej informacji, zobacz sekcję nowy operator specyfikacji języka C#.

Aby uzyskać więcej informacji na temat wyrażenia typu new docelowego, zobacz notatkę dotyczącą propozycji funkcji.

Zobacz też