Udostępnij przez

Typy wartości (odwołanie w C#)

Typy wartości i typy referencyjne to dwie główne kategorie typów języka C#. Zmienna typu wartości zawiera wystąpienie typu. To zachowanie różni się od zmiennej typu odwołania, która zawiera odwołanie do wystąpienia typu. Domyślnie przy przypisaniu są kopiowane wartości zmiennych, przekazując argument do metody i zwracając wynik metody. W przypadku zmiennych typu wartości odpowiednie wystąpienia typu są kopiowane. W poniższym przykładzie pokazano, że zachowanie:

using System;

public struct MutablePoint
{
    public int X;
    public int Y;

    public MutablePoint(int x, int y) => (X, Y) = (x, y);

    public override string ToString() => $"({X}, {Y})";
}

public class Program
{
    public static void Main()
    {
        var p1 = new MutablePoint(1, 2);
        var p2 = p1;
        p2.Y = 200;
        Console.WriteLine($"{nameof(p1)} after {nameof(p2)} is modified: {p1}");
        Console.WriteLine($"{nameof(p2)}: {p2}");

        MutateAndDisplay(p2);
        Console.WriteLine($"{nameof(p2)} after passing to a method: {p2}");
    }

    private static void MutateAndDisplay(MutablePoint p)
    {
        p.X = 100;
        Console.WriteLine($"Point mutated in a method: {p}");
    }
}
// Expected output:
// p1 after p2 is modified: (1, 2)
// p2: (1, 200)
// Point mutated in a method: (100, 200)
// p2 after passing to a method: (1, 200)

Jak pokazano w poprzednim przykładzie, operacje na zmiennej typu wartości mają wpływ tylko na to wystąpienie typu wartości przechowywane w zmiennej.

Jeśli typ wartości zawiera element członkowski danych typu odwołania, tylko odwołanie do wystąpienia typu odwołania jest kopiowane po skopiowaniu wystąpienia typu wartości. Zarówno wystąpienie kopiowania, jak i oryginalnego typu wartości ma dostęp do tego samego wystąpienia typu odwołania. W poniższym przykładzie pokazano, że zachowanie:

using System;
using System.Collections.Generic;

public struct TaggedInteger
{
    public int Number;
    private List<string> tags;

    public TaggedInteger(int n)
    {
        Number = n;
        tags = new List<string>();
    }

    public void AddTag(string tag) => tags.Add(tag);

    public override string ToString() => $"{Number} [{string.Join(", ", tags)}]";
}

public class Program
{
    public static void Main()
    {
        var n1 = new TaggedInteger(0);
        n1.AddTag("A");
        Console.WriteLine(n1);  // output: 0 [A]

        var n2 = n1;
        n2.Number = 7;
        n2.AddTag("B");

        Console.WriteLine(n1);  // output: 0 [A, B]
        Console.WriteLine(n2);  // output: 7 [A, B]
    }
}

Uwaga

Aby kod był mniej podatny na błędy i bardziej niezawodny, zdefiniuj i użyj niezmiennych typów wartości. W tym artykule używane są tylko typy wartości modyfikowalne tylko w celach demonstracyjnych.

Rodzaje typów wartości i ograniczeń typu

Typ wartości może być jednym z dwóch następujących rodzajów:

  • typ struktury, który hermetyzuje dane i powiązane funkcje
  • typ wyliczenia, który jest definiowany przez zestaw nazwanych stałych i reprezentuje wybór lub kombinację wyborów

TypT? wartości dopuszczanej do wartości null reprezentuje wszystkie wartości bazowego typu T wartości i dodatkową wartość null. Nie można przypisać null do zmiennej typu wartości, chyba że jest to typ wartości dopuszczalnej wartości null.

Możesz użyć struct ograniczenia , aby określić, że parametr typu jest typem wartości innej niż null. Oba typy struktury i wyliczenia spełniają struct ograniczenie. Możesz użyć System.Enum w ograniczeniu klasy bazowej (nazywanej ograniczeniem wyliczenia), aby określić, że parametr typu jest typem wyliczenia.

Wbudowane typy wartości

Język C# udostępnia następujące wbudowane typy wartości, znane również jako proste typy:

Wszystkie proste typy to typy struktury. Różnią się one od innych typów struktur, które zezwalają na pewne dodatkowe operacje:

  • Aby podać wartość prostego typu, można użyć literałów.
    Na przykład 'A' jest literałem typu char, 2001 jest literałem typu , i 12.34m jest literałem typu intdecimal.

  • Stałe prostych typów można zadeklarować przy użyciu słowa kluczowego const .
    Można na przykład zdefiniować const decimal = 12.34mwartość .
    Nie można zadeklarować stałych innych typów struktur.

  • Wyrażenia stałe, których operandy są stałymi prostych typów, są obliczane w czasie kompilacji.

Krotka wartości jest typem wartości, ale nie prostym typem.

specyfikacja języka C#

Aby uzyskać więcej informacji, zobacz następujące sekcje specyfikacji języka C#:

Zobacz też

  • Last updated on