Jaka jest różnica między const a readonly w C#?

There is a gotcha with consts! Jeśli odwołujesz się do stałej z innego zestawu, jej wartość zostanie skompilowana bezpośrednio do zestawu wywołującego. W ten sposób, gdy zaktualizujesz stałą w przywołanym zestawie, nie zmieni się ona w zestawie wywołującym!

Stałe

• stałe są domyślnie statyczne
• muszą mieć wartość w czasie kompilacji (można mieć np. 3.14 * 2, ale nie można wywoływać metod)
• Można zadeklarować w ramach funkcji
• są kopiowane do każdego zestawu, który ich używa (każdy zestaw otrzymuje lokalną kopię wartości)
• może być używany w atrybutach

Pola instancji Readonly

• musi mieć ustawioną wartość, przez konstruktor czasu kończy
• są oceniane, gdy instancja jest tworzona

Statyczne pola readonly

• są oceniane, gdy wykonanie kodu trafi w referencję do klasy (gdy zostanie utworzona nowa instancja lub zostanie wykonana statyczna metoda)
• musi mieć obliczoną wartość do czasu wykonania statycznego konstruktora
• nie zaleca się umieszczania na nich threadstaticattribute (statyczne konstruktory będą wykonywane tylko w jednym wątku i ustawią wartość dla jego wątku; wszystkie inne wątki będą miały tę wartość uninitialized)

Tylko dodać, readonly dla typów referencyjnych sprawia, że Referencja tylko do odczytu nie wartości. Na przykład:

public class Const_V_Readonly
{
  public const int I_CONST_VALUE = 2;
  public readonly char[] I_RO_VALUE = new Char[]{'a', 'b', 'c'};

  public UpdateReadonly()
  {
     I_RO_VALUE[0] = 'V'; //perfectly legal and will update the value
     I_RO_VALUE = new char[]{'V'}; //will cause compiler error
  }
}

To wyjaśnia . Podsumowanie: const musi być zainicjalizowany w czasie deklaracji, readonly może być zainicjowany w konstruktorze (i tym samym mieć inną wartość w zależności od użytego konstruktora).

EDIT: Zobacz Gishu ' s gotcha powyżej dla subtelnej różnicy

const: nigdzie nie można go zmienić.

readonly: Wartość tę można zmienić tylko w konstruktorze. Nie można zmienić w normalnych funkcjach.

Stały element jest definiowany w czasie kompilacji i nie może być zmieniany w czasie wykonywania. Stałe są deklarowane jako pole przy użyciu słowa kluczowego const i muszą być inicjalizowane w momencie ich zadeklarowania.

public class MyClass
{
    public const double PI1 = 3.14159;
}

Członek readonly jest jak stała, ponieważ reprezentuje niezmienną wartość. Różnica polega na tym, że element readonly może być inicjowany w czasie wykonywania, w konstruktorze, a także może być inicjowany w momencie ich deklarowania.

public class MyClass1
{
     public readonly double PI2 = 3.14159;

     //or

     public readonly double PI3;

     public MyClass2()
     {
         PI3 = 3.14159;
     }
}

Const

• mogą nie mogą być zadeklarowane jako static (są niejawnie statyczne)
• wartość stałej jest obliczana w czasie kompilacji
• stałe są inicjalizowane tylko w deklaracji

Readonly

Mogą być zarówno poziomami instancji, jak i statycznymi.]}
• wartość jest obliczana w czasie wykonywania
• readonly może być zainicjowany w deklaracji lub kodem w konstruktorze

Jest mała gotcha z readonly. Pole readonly może być ustawione wiele razy w konstruktorze(konstruktorach). Nawet jeśli wartość jest ustawiona w dwóch różnych konstruktorach łańcuchowych, nadal jest to dozwolone.

public class Sample {
    private readonly string ro;

    public Sample() {
        ro = "set";
    }

    public Sample(string value) : this() {
        ro = value; // this works even though it was set in the no-arg ctor
    }
}

Const jest stałą w czasie kompilacji, podczas gdy readonly pozwala na obliczenie wartości w czasie wykonywania i ustawienie jej w konstruktorze lub inicjalizatorze pola. Tak więc 'const' jest zawsze stały, ale 'readonly' jest tylko do odczytu po jego przypisaniu.

Eric Lippert z zespołu C# ma więcej informacji na temat różnych typów niezmienności.

Oto kolejny link pokazujący, że const nie jest bezpieczny dla wersji lub odpowiedni dla typów referencyjnych.

Podsumowanie :

• wartość właściwości const jest ustawiana w czasie kompilacji i nie może się zmieniać w czasie wykonywania
• Const nie może być oznaczony jako static - słowo kluczowe oznacza, że są statyczne, w przeciwieństwie do pól readonly, które mogą.
• Const nie może być niczym poza typami wartości (prymitywnymi)
• słowo kluczowe readonly oznacza pole jako niezmienne. Jednak właściwość może być zmieniona wewnątrz konstruktora klasy
• słowo kluczowe tylko do odczytu może być również łączone ze static, aby działać w taki sam sposób jak const (przynajmniej na powierzchni). Istnieje znacząca różnica, gdy patrzysz na IL między tymi dwoma
• pola const są oznaczone jako" dosłowne "w IL, podczas gdy readonly to "initonly"

Tylko Do Odczytu : Wartość może być zmieniana przez Ctor w czasie wykonywania. Ale nie poprzez funkcję member

Stała : Domyślnie static. Wartość nie może być zmieniana z dowolnego miejsca (ctor, Function, runtime itd no-where)

Yet another gotcha: readonly wartości mogą być zmieniane przez" przebiegły " kod poprzez odbicie.

var fi = this.GetType()
             .BaseType
             .GetField("_someField", 
                       BindingFlags.Instance | BindingFlags.NonPublic);
fi.SetValue(this, 1);

Czy Mogę zmienić prywatne pole readonly odziedziczone w C# przy użyciu reflection?

Uważam, że wartość const jest taka sama dla wszystkich obiektów( i musi być zainicjalizowana dosłownym wyrażeniem), podczas gdy readonly może być inna dla każdej instancji...

Oba są stałe, ale const jest dostępny również w czasie kompilacji. Oznacza to, że jednym z aspektów różnicy jest to, że można używać zmiennych const jako danych wejściowych do konstruktorów atrybutów, ale nie tylko do odczytu zmiennych.

Przykład:

public static class Text {
  public const string ConstDescription = "This can be used.";
  public readonly static string ReadonlyDescription = "Cannot be used.";
}

public class Foo 
{
  [Description(Text.ConstDescription)]
  public int BarThatBuilds {
    { get; set; }
  }

  [Description(Text.ReadOnlyDescription)]
  public int BarThatDoesNotBuild {
    { get; set; }
  }
}

Jeden z członków zespołu w naszym biurze podał następujące wskazówki, kiedy używać const, static i readonly:

• Użyj const, Gdy masz zmienną typu, którą możesz znać w czasie wykonywania (string literal, int, double, enums,...), do których chcesz, aby wszystkie instancje lub konsumenci danej klasy mieli dostęp, do których wartość nie powinna się zmieniać.
• Użyj static , Gdy masz dane, do których chcesz mieć dostęp do wszystkich instancji lub konsumentów klasy, gdzie wartość może się zmienić.
• Użyj Tylko do odczytu statycznego , Gdy masz zmienną typu, którego nie możesz znać w czasie wykonywania (obiekty), do których chcesz mieć dostęp do wszystkich instancji lub konsumentów klasy, do których wartość nie powinna się zmieniać.
• Użyj Tylko do odczytu Gdy masz zmienną poziomu instancji, będziesz wiedział w momencie tworzenia obiektu, który nie powinien się zmieniać.

Ostatnia uwaga: pole const jest statyczne, ale odwrotność nie jest prawdziwa.

• Kiedy stosować const LUB readonly

  • const

    • compile-time stała: absolutna stała, wartość jest ustawiana podczas deklaracji, jest w samym kodzie IL

  • readonly

    • run-time stała: może być ustawiona w konstruktorze / init za pomocą pliku konfiguracyjnego tj. App.config, ale po inicjalizacji nie można jej zmienić

CONST

1. słowo kluczowe const może być stosowane do pól lub zmiennych lokalnych
2. musimy przypisać pole const w momencie deklaracji
3. Brak przydzielonej pamięci, ponieważ wartość const jest osadzona w kodzie IL po kompilacji. To tak, jakby znaleźć wszystkie wystąpienia zmiennej const i zastąpić jej wartością. Tak więc kod IL po kompilacji będzie miał zakodowane na twardo wartości zamiast zmiennych const
4. Const w C# są domyślnie statyczne.
5. wartość jest stała dla wszystkich obiekty
6. występuje problem z wersjonowaniem dll - oznacza to, że za każdym razem, gdy zmieniamy publiczną zmienną lub właściwość const (w rzeczywistości nie powinna być zmieniana teoretycznie), każde inne DLL lub zgromadzenie, które używa tej zmiennej musi zostać ponownie zbudowane
7. tylko typy wbudowane w C# mogą być zadeklarowane jako stałe
8. pole Const nie może być przekazywane jako parametr ref lub out

ReadOnly

1. słowo kluczowe readonly dotyczy tylko pól nie zmiennych lokalnych
2. możemy Przypisz pole readonly w momencie deklaracji lub w konstruktorze,a nie w żadnych innych metodach.
3. pamięć dynamiczna przydzielona do pól readonly i możemy uzyskać wartość w czasie wykonywania.
4. Readonly należy tylko do obiektu utworzonego w ten sposób, do którego dostęp ma tylko instancja klasy. Aby uczynić go członkiem klasy musimy dodać statyczne słowo kluczowe przed readonly.
5. wartość może być różna w zależności od użytego konstruktora (ponieważ należy do obiektu klasy)
6. Jeśli zadeklarujesz nie-prymitywne typy (typ referencji) jako Tylko do odczytu odniesienie jest niezmienne, a nie obiekt, który zawiera.
7. ponieważ wartość jest pobierana w czasie wykonywania, nie ma problemu z wersjonowaniem dll z polami/ właściwościami readonly.
8. możemy przekazać pole readonly jako parametry ref lub out w kontekście konstruktora.

Zmienne oznaczone const są niewiele więcej niż mocno wpisane makra # define, w czasie kompilacji odwołania do zmiennych const są zastępowane literałowymi wartościami w wierszu. W konsekwencji tylko niektóre wbudowane prymitywne typy wartości mogą być używane w ten sposób. Zmienne oznaczone tylko do odczytu mogą być ustawiane w konstruktorze w czasie wykonywania, a ich wartość tylko do odczytu jest wymuszana również w czasie wykonywania. Wiąże się to z niewielkimi kosztami wydajności, ale oznacza to, że możesz używać readonly z dowolnym typem (nawet typy referencyjne).

Również zmienne const są z natury statyczne, podczas gdy zmienne readonly mogą być specyficzne dla instancji w razie potrzeby.

Istnieje znacząca różnica między polami const i readonly w C#.Net

Const jest domyślnie statyczny i musi zostać zainicjowany stałą wartością, której nie można później modyfikować. Zmiana wartości nie jest dozwolona również w konstruktorach. Nie można go używać ze wszystkimi typami danych. Dla ex-DateTime. Nie może być używany z DateTime datatype.

public const DateTime dt = DateTime.Today;  //throws compilation error
public const string Name = string.Empty;    //throws compilation error
public readonly string Name = string.Empty; //No error, legal

Readonly może być zadeklarowane jako statyczne, ale nie jest to konieczne. Nie ma potrzeby inicjalizacji w momencie deklaracji. Jego wartość może być przypisane lub zmienione za pomocą konstruktora. Daje to więc przewagę, gdy jest używany jako członek klasy instancji. Dwie różne instancje mogą mieć różną wartość pola readonly. Dla ex -

class A
{
    public readonly int Id;

    public A(int i)
    {
        Id = i;
    }
}

Następnie pole readonly może być zainicjalizowane wartościami natychmiastowymi, w następujący sposób:

A objOne = new A(5);
A objTwo = new A(10);

Tutaj instancja objOne będzie miała wartość pola readonly jako 5, a objTwo jako 10. Co nie jest możliwe przy użyciu const.

Another gotcha .

Ponieważ const naprawdę działa tylko z podstawowymi typami danych, jeśli chcesz pracować z klasą, możesz czuć się "zmuszony" do używania ReadOnly. Uważaj jednak na pułapkę! ReadOnly oznacza, że nie można zastąpić obiektu innym obiektem(nie można sprawić, by odnosił się do innego obiektu). Ale każdy proces, który ma odniesienie do obiektu, może dowolnie modyfikować wartości wewnątrz obiekt!

Więc nie myl się myśląc, że ReadOnly oznacza, że użytkownik nie może niczego zmienić. Nie ma prostej składni w C#, aby zapobiec zmianie wewnętrznych wartości instancji klasy (o ile mi wiadomo).

A constmusi być zakodowane na twardo, gdzie jako readonlymoże być ustawione w konstruktorze klasy.

Stała zostanie skompilowana do konsumenta jako literalna wartość, podczas gdy statyczny łańcuch będzie służył jako odniesienie do zdefiniowanej wartości.

Jako ćwiczenie spróbuj utworzyć bibliotekę zewnętrzną i skonsumuj ją w aplikacji konsolowej, następnie zmień wartości w bibliotece i przekompiluj ją (bez rekompilowania programu konsumenckiego), upuść DLL do katalogu i uruchom EXE ręcznie, powinieneś zauważyć, że stały ciąg znaków się nie zmienia.

Const i readonly są podobne, ale nie są dokładnie takie same. Pole const jest stałą czasu kompilacji, co oznacza, że wartość ta może być obliczona w czasie kompilacji. Pole readonly umożliwia dodatkowe scenariusze, w których część kodu musi być uruchomiona podczas budowy typu. Po zbudowaniu pole readonly nie może zostać zmienione.

Na przykład, członkowie const mogą być używane do definiowania członków takich jak:

struct Test
{
    public const double Pi = 3.14;
    public const int Zero = 0;
}

Ponieważ wartości takie jak 3.14 i 0 są stałymi czasu kompilacji. Jednakże, rozważ przypadek, w którym zdefiniujesz typ i chcesz podać kilka jego początkowych wystąpień. Na przykład możesz zdefiniować klasę kolorów i podać "stałe" dla popularnych kolorów, takich jak czarny, biały itp. Nie można tego zrobić z elementami const, ponieważ prawa strona nie jest stała czasu kompilacji. Można to zrobić ze zwykłymi statycznymi członkami:

public class Color
{
    public static Color Black = new Color(0, 0, 0);
    public static Color White = new Color(255, 255, 255);
    public static Color Red = new Color(255, 0, 0);
    public static Color Green = new Color(0, 255, 0);
    public static Color Blue = new Color(0, 0, 255);
    private byte red, green, blue;

    public Color(byte r, byte g, byte b) {
        red = r;
        green = g;
        blue = b;
    }
}

Ale wtedy nie ma nic, aby powstrzymać klienta koloru od mucking z nim, być może przez zamianę wartości czerni i bieli. Nie trzeba dodawać, że spowodowałoby to konsternację dla innych klientów klasy kolorów. Funkcja "readonly" odnosi się do tego scenariusza. Wprowadzając po prostu słowo kluczowe readonly w deklaracjach, zachowujemy elastyczną inicjalizację, jednocześnie zapobiegając blokowaniu kodu klienta.

public class Color
{
    public static readonly Color Black = new Color(0, 0, 0);
    public static readonly Color White = new Color(255, 255, 255);
    public static readonly Color Red = new Color(255, 0, 0);
    public static readonly Color Green = new Color(0, 255, 0);
    public static readonly Color Blue = new Color(0, 0, 255);
    private byte red, green, blue;

    public Color(byte r, byte g, byte b) {
        red = r;
        green = g;
        blue = b;
    }
}

Warto zauważyć, że członkowie const są zawsze statyczne, podczas gdy członkowie readonly mogą być statyczne lub nie, tak jak zwykłe pole.

Możliwe jest użycie pojedynczego słowo kluczowe dla tych dwóch celów, ale prowadzi to do problemów z wersjonowaniem lub problemów z wydajnością. Załóżmy przez chwilę, że użyliśmy jednego słowa kluczowego dla tego (const) i programista napisał:

public class A
{
    public static const C = 0;
}

I inny programista napisał kod, który opierał się na:

public class B
{
    static void Main() {
        Console.WriteLine(A.C);
    }
}

ReadOnly: wartość zostanie zainicjalizowana tylko raz z konstruktora klasy.
const: może być zainicjalizowany w dowolnej funkcji, ale tylko raz

Różnica polega na tym, że wartość statycznego pola readonly jest ustawiana w czasie wykonywania, Więc może mieć inną wartość dla różnych egzekucji programu. Jednak wartość pola const jest ustawiana na stałą czasu kompilacji.

Remember: W przypadku typów referencji, w obu przypadkach (statyczny i instancyjny), modyfikator readonly uniemożliwia przypisanie nowego odniesienia do pola. W szczególności nie czyni niezmiennego obiektu wskazywanego przez odniesienie.

Dla szczegóły, zapoznaj się z często zadawanymi pytaniami na ten temat w języku C# : http://blogs.msdn.com/csharpfaq/archive/2004/12/03/274791.aspx

Stałe zmienne są deklarowane i inicjalizowane podczas kompilacji. Wartość nie może być zmieniona po oddziałach. Zmienne tylko do odczytu będą inicjowane tylko ze statycznego konstruktora klasy. Tylko do odczytu jest używane tylko wtedy,gdy chcemy przypisać wartość w czasie wykonywania.

Zasadniczo; można przypisać wartość do statycznego pola readonly do niestałej wartości w czasie wykonywania, podczas gdy const musi być przypisana stała wartość.

Jedna rzecz dodać do tego, co ludzie powiedzieli powyżej. Jeśli masz assembly zawierające wartość readonly (np. readonly MaxFooCount = 4;), możesz zmienić wartość wyświetlaną przez wywołanie Assembly wysyłając nową wersję tego assembly o innej wartości (np. readonly MaxFooCount = 5;)

Ale z const, to byłoby złożone w kod dzwoniącego, gdy dzwoniący został skompilowany.

Jeśli osiągnąłeś ten poziom biegłości w C#, jesteś gotowy na książkę Billa Wagnera, Skuteczne C#: 50 konkretnych sposobów na poprawę swojego C# Który szczegółowo odpowiada na to pytanie (i 49 innych rzeczy).

Zasadnicza różnica polega na tym, że Const jest odpowiednikiem C #DEFINE. Liczba ta jest dosłownie zastępowana a-la precompilatorem. Readonly jest w rzeczywistości traktowana jako zmienna.

To rozróżnienie jest szczególnie istotne, gdy projekt a jest zależny od stałej publicznej od projektu B. Załóżmy, że stała publiczna się zmienia. Teraz wybór const / readonly wpłynie na zachowanie projektu A:

Const: projekt A nie wychwytuje nowej wartości (chyba że jest rekompilowany z nowy const, oczywiście), ponieważ został skompilowany z podstawionymi stałymi.

ReadOnly: projekt a zawsze zapyta projekt B o wartość zmiennej, więc pobiera nową wartość publicznej stałej w B.

Szczerze mówiąc, polecam używać readonly dla prawie wszystkiego, z wyjątkiem prawdziwie uniwersalnych stałych ( np. Pi, Inches_To_Centimeters). Na wszystko, co może się zmienić, mówię, użyj readonly.

Mam nadzieję, że to pomoże, Alan.

Const : bezwzględna stała wartość w czasie życia aplikacji.

Readonly : można go zmienić w czasie pracy.