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

  • Artykuł
  • Czas czytania: 3 min

Typy wartości i typy referencyjne to dwie główne kategorie typów języka C#. Zmienna typu wartości zawiera wystąpienie typu . Różni się to 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 to 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 wpływają tylko na to wystąpienie typu wartości przechowywane w zmiennej.

Jeśli typ wartości zawiera element członkowski danych typu odwołania, podczas kopiowania wystąpienia typu odwołania jest kopiowane tylko odwołanie do wystąpienia typu odwołania. Zarówno wystąpienie typu kopii, jak i oryginalnego typu wartości ma dostęp do tego samego wystąpienia typu odwołania. W poniższym przykładzie pokazano to 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 do celów 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

Typ T?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 do wartości null.

Możesz użyć struct ograniczenia , aby określić, że parametr typu jest typem wartości innej niż null. Zarówno typy struktury, jak i wyliczenia spełniają struct ograniczenie. Począwszy od języka C# 7.3, można użyć System.Enum w ograniczeniu klasy bazowej (znanym jako ograniczenie 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 są typami struktury i różnią się od innych typów struktur, ponieważ zezwalają na pewne dodatkowe operacje:

  • Możesz użyć literałów, aby podać wartość prostego typu. Na przykład 'A' jest literałem typu char i 2001 jest literałem typu int.

  • Stałe prostych typów można zadeklarować za pomocą słowa kluczowego const . Nie można mieć stałych innych typów struktur.

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

Począwszy od języka C# 7.0, język C# obsługuje krotki wartości. 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ż