C # 'da const ve readonly arasındaki fark nedir?


1362

Arasındaki fark nedir constve readonlyC #?

Birini ne zaman diğerinin üzerinde kullanırsınız?


Bu bağlantıyı bulmak için birkaç cevaba bakmalıydım, ama bu iyi bir bağlantı. Eric Lippert'in C #'daki değişmezliği ele geçirmesi
Frank Bryce

2
@donstack, aslında C # referansına göre , salt okunur bir alan, alan bildirimi ve yapıcı içinde birden çok kez atanabilir ve yeniden atanabilir.
Marques

Yanıtlar:


1289

Görünen fark dışında

  • constVS readonlydeğerleri için bir tanım sırasındaki değeri beyan etmek dinamik olarak hesaplanabilir, ancak yapıcıdan çıkmadan önce atanmaları gerekir.
  • 'const dolaylı olarak static. ClassName.ConstantNameBunlara erişmek için bir gösterim kullanırsınız.

İnce bir fark var. 'De tanımlanan bir sınıfı düşünün AssemblyA.

public class Const_V_Readonly
{
  public const int I_CONST_VALUE = 2;
  public readonly int I_RO_VALUE;
  public Const_V_Readonly()
  {
     I_RO_VALUE = 3;
  }
}

AssemblyBreferans verir AssemblyAve bu değerleri kodda kullanır. Bu derlendiğinde,

  • constdeğer durumunda, bul-değiştir gibi, 2 değeri IL'nin 'içine' pişirilir ' AssemblyB. Bu, yarın I_CONST_VALUEgelecekte 20'ye güncelleyeceğim anlamına gelir . AssemblyByeniden derleyene kadar hala 2 olurdu .
  • readonlydeğer olması durumunda, refbir bellek konumuna a gibidir. Değer, AssemblyBIL'ye dönüştürülmez . Bu, bellek konumu güncellenirse, AssemblyByeni değeri yeniden derlemeden alır demektir. Yani I_RO_VALUE30 olarak güncellenirse, sadece inşa etmeniz gerekir AssemblyA. Tüm istemcilerin yeniden derlenmesi gerekmez.

Yani sabitin değerinin değişmeyeceğinden eminseniz a kullanın const.

public const int CM_IN_A_METER = 100;

Ancak değişebilecek bir sabitiniz varsa (örn. Hassas) .. veya şüpheniz varsa, a kullanın readonly.

public readonly float PI = 3.14;

Güncelleme: Aku, önce dikkat çektiğinden bahsetmek gerekiyor. Ayrıca ben bu yerde öğrendim takmak gerekir .. Etkili C # - Bill Wagner


77
staticNokta en önemli ve yararlı nokta olarak görülmektedir -consts are implicitly static
LCJ

28
Referans değerlerle ilgili kısım en önemlisidir. Sabit değerler optimize edilebilir.
CodingBarfield

22
readonlydeğişkenler yapıcı (yansıma) dışında değiştirilebilir. Sadece kurucu dışında var değiştirmek için engel olmaya çalışır derleyici.
Bitterblue

12
@ mini-me readonlydeğişkenlerinin kurucu bittikten sonra, yansıma yoluyla bile değiştirilmesine izin verilmez. Çalışma zamanı bunu zorlamıyor. Çalışma zamanı da değişmez zorunlu kılmak amacıyla değil olur string.Emptyüzere "Hello, world!", ama yine de bu hale getirdiğini iddia olmaz string.Emptydeğiştirilemez veya bu kod farz edilmemelidir string.Emptyher zaman sıfır uzunluklu dize olacaktır.

7
blogs.msmvps.com/jonskeet/2014/07/16/… sadece salt okunur genel masraf maliyetini okuyor
CAD bloke

275

Consts ile bir gotcha var! Başka bir derlemeden bir sabite başvurursanız, değeri doğrudan çağrı derlemesine derlenir. Bu şekilde başvurulan derlemedeki sabiti güncellediğinizde, çağrı derlemesinde değişmez!


8
Ayrıştırmada (Reflektör, ILSpy, ..) aynı montaj veya başka bir montajdan bağımsız olarak ASLA herhangi bir kişi tarafından referans gösterilmez, bu nedenle derlenmiş kodda bir sabitin kullanımını hiç analiz edemezsiniz.
springy76

159

Sabitler

  • Sabitler varsayılan olarak statiktir
  • Derleme zamanında bir değere sahip olmalıdırlar (örneğin 3.14 * 2 olabilir, ancak yöntemleri çağıramazsınız)
  • Fonksiyonlar içinde beyan edilebilir
  • Bunları kullanan her bir derlemeye kopyalanır (her derleme değerlerin yerel bir kopyasını alır)
  • Niteliklerde kullanılabilir

Salt okunur örnek alanları

  • Yapıcı çıkış zamanına kadar ayarlanmış bir değer olmalıdır
  • Örnek oluşturulduğunda değerlendirilir

Statik salt okunur alanlar

  • Kod yürütme sınıf başvurusuna çarptığında değerlendirilir (yeni örnek oluşturulduğunda veya statik bir yöntem yürütüldüğünde)
  • Statik kurucu yapıldığında değerlendirilmiş bir değer olmalıdır
  • ThreadStaticAttribute öğesinin bu öğelere yerleştirilmesi önerilmez (statik yapıcılar yalnızca bir iş parçacığında yürütülür ve iş parçacığının değerini ayarlar; diğer tüm iş parçacıklarında bu değer başlatılmaz)

58

Sadece eklemek için, ReadOnly referans türleri için sadece referansları değil değerleri salt okunur yapar. Örneğin:

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
  }
}

stringSabit olarak kullanabileceğiniz başka bir referans türü var mı ?
springy76

constDize dışındaki referans türlerine sahip olabilirsiniz , ancak sabit yalnızca değere sahip olabilir null.
Mike Rosoft

40

Bu açıklıyor . Özet: const bildirim zamanında başlatılmalı, salt yapıcı üzerinde başlatılabilir (ve dolayısıyla kullanılan yapıcıya bağlı olarak farklı bir değere sahip olabilir).

EDIT: ince fark için yukarıdaki Gishu gotcha bakın


32

const: Hiçbir yerde değiştirilemez.

readonly: Bu değer yalnızca yapıcıdan değiştirilebilir. Normal işlevlerde değiştirilemez.


26

Küçük bir gotcha ile salt okunur. Bir salt okunur alan, yapıcı (lar) içinde birden çok kez ayarlanabilir. Değer, iki farklı zincir oluşturucuda ayarlanmış olsa bile, buna izin verilir.


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
    }
}

26

Derleme zamanında sabit bir üye tanımlanır ve çalışma zamanında değiştirilemez. Sabitler constanahtar kelime kullanılarak bir alan olarak bildirilir ve bildirildikçe başlatılmaları gerekir.

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

Bir readonlyüye değişmeyen bir değeri temsil ettiği için sabit gibidir. Fark, bir readonlyüyenin çalışma zamanında, bir kurucuda başlatılabilmesinin yanı sıra bildirildikçe başlatılabilmesidir.

public class MyClass1
{
     public readonly double PI2 = 3.14159;

     //or

     public readonly double PI3;

     public MyClass2()
     {
         PI3 = 3.14159;
     }
}

const

  • Olarak beyan edilemezler static(dolaylı olarak statiktirler)
  • Sabit değeri derleme zamanında değerlendirilir
  • sabitler yalnızca bildirimde başlatılır

Sadece oku

  • Örnek düzeyinde veya statik olabilirler
  • Değer, çalışma zamanında değerlendirilir
  • readonly, bildirimde veya yapıcıdaki kod ile başlatılabilir

6
Statik olamazlar, statiktirler. Eğer demek eğer o temizlemek yapmalıdır biri ilan edemezstatic const int i = 0;
Nawfal

constBeyanların neden yöntemlerle yapılamadığını açıklayabilir misiniz ?
Minh Tran

21

Const bir derleme zamanı sabitidir, oysa salt değer bir değerin çalışma zamanında hesaplanmasına ve yapıcı veya alan başlatıcıda ayarlanmasına izin verir. Dolayısıyla, bir 'sabit' her zaman sabittir, ancak 'salt okunur' atandığında salt okunurdur.

C # ekibinden Eric Lippert'in farklı değişmezlik türleri hakkında daha fazla bilgi var


15

Const'un sürüm güvenliğini veya referans türleri için ne kadar alakalı olmadığını gösteren başka bir bağlantı .

Özet :

  • Const mülkünüzün değeri derleme zamanında ayarlanır ve çalışma zamanında değiştirilemez
  • Sabit statik olarak işaretlenemez - anahtar kelime, salt okunur alanlardan farklı olarak statik olduklarını gösterir.
  • Sabit değer (ilkel) türler dışında bir şey olamaz
  • Salt okunur anahtar kelime alanı değiştirilemez olarak işaretler. Ancak özellik sınıfın yapıcısının içinde değiştirilebilir
  • Salt okunur anahtar kelime, bir sabitle (yüzeyde en az) aynı şekilde davranmasını sağlamak için statikle de birleştirilebilir. İkisi arasındaki IL'ye baktığınızda belirgin bir fark var
  • const alanları IL'de "değişmez" olarak işaretlenirken, salt okunur "initonly"

11

Salt Okunur : Değer çalışma zamanında Ctor aracılığıyla değiştirilebilir. Ancak üye İşlev aracılığıyla değil

Sabit : Statik statik ile. Değer herhangi bir yerden değiştirilemez (Ctor, İşlev, çalışma zamanı vb.


Beni sadece bu iki paket için 4 paragraf okumadığınız için teşekkürler ...
Don Cheadle


6

Bir constdeğerin tüm nesneler için aynı olduğuna (ve gerçek ifadeyle başlatılması gerektiğine) inanıyorum, oysa readonlyher örnekleme için farklı olabilir ...


5

Ofisimizdeki ekip üyelerinden biri, const, static ve readonly'nin ne zaman kullanılacağı konusunda aşağıdaki rehberliği sağlamıştır:

  • Çalışma zamanında bildiğiniz türde bir değişkeniniz varsa (dize değişmez, int, çift, numaralandırmalar, ...) bir sınıfın tüm örneklerinin veya tüketicilerinin değerin değişmemesi gereken yere erişmesini istediğinizde const kullanın .
  • Bir sınıfın tüm örneklerinin veya tüketicilerinin değerin değişebileceği yerlere erişmesini istediğiniz verilere sahipseniz statik kullanın .
  • Çalışma zamanında (nesneler), sınıfın tüm örneklerinin veya tüketicilerinin değerin değişmemesi gereken yerlere erişmesini istediğiniz bir tür değişkeniniz olduğunda statik salt okunur kullanın .
  • Nesne oluşturma sırasında değişmemesi gereken bildiğiniz bir örnek seviyesi değişkeniniz olduğunda salt okunur kullanın .

Son bir not: sabit alan statiktir, ancak tersi doğru değildir.


1
Bence "sohbet" demek istedin. Tersi "sabit olmayan bir alan statik değildir" olacaktır. Hangisi doğru olabilir de olmayabilir de. "Statik alan (her zaman) sabittir" tersi doğru değildir.
Michael Blackburn

5

Her ikisi de sabittir, ancak derleme zamanında da bir sabit mevcuttur. Bu, farkın bir yönünün, const değişkenlerini öznitelik yapıcılarına girdi olarak kullanabileceğiniz, ancak salt okunur değişkenleri kullanabileceğiniz anlamına gelir.

Misal:

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; }
  }
}

5
  • ne zaman kullanılır constveyareadonly

    • const

      • derleme zamanı sabiti: mutlak sabit, değer bildirim sırasında ayarlanır, IL kodunun kendisindedir
    • readonly

      • çalışma zamanı sabiti: yapıcı / init içinde config dosyası ile ayarlanabilir App.config, ancak başlatıldıktan sonra değiştirilemez

4

Const olarak işaretlenen değişkenler, güçlü bir şekilde yazılan #define makrolarından biraz daha fazladır, derleme zamanında const değişken referansları satır içi değişmez değerlerle değiştirilir. Sonuç olarak bu şekilde sadece belirli yerleşik ilkel değer türleri kullanılabilir. Salt okunur olarak işaretlenen değişkenler, bir kurucuda çalışma zamanında ayarlanabilir ve salt okunur olmaları çalışma zamanı sırasında da uygulanır. Bununla ilişkili bazı küçük performans maliyetleri vardır, ancak herhangi bir türle (hatta referans türleri) salt okunur olarak kullanabileceğiniz anlamına gelir.

Ayrıca, const değişkenleri doğal olarak statikken, salt okunur değişkenler istenirse örneğe özgü olabilir.


Sabitlerin #define makrolarının güçlü bir şekilde yazıldığını ekledi . Aksi takdirde, tüm C veya C ++ kişilerini korkutabiliriz. :-)
Jason Baker

4

SABİT

  1. const anahtar sözcüğü alanlara veya yerel değişkenlere uygulanabilir
  2. Beyan sırasında const alanı atamalıyız
  3. Bellek Tahsis Edilmedi Çünkü const değeri derlemeden sonra IL kodunun içine gömülü. Const değişkeninin tüm oluşumlarını bulmak ve değerini değiştirmek gibi. Bu nedenle derlemeden sonra IL kodu sabit değişkenler yerine sabit kodlanmış değerlere sahip olacaktır
  4. C # içindeki sabit varsayılan olarak statiktir.
  5. Değer tüm nesneler için sabittir
  6. Dll sürüm oluşturma sorunu var - Bu, her ne zaman bir kamu const değişkeni veya özelliği değiştirmek, (Aslında, teorik olarak değiştirilmesi gerekiyordu), bu değişkeni kullanan herhangi bir diğer dll veya derleme yeniden inşa edilmesi gerektiği anlamına gelir
  7. Yalnızca C # yerleşik türleri sabit olarak bildirilebilir
  8. Sabit alan ref veya out parametresi olarak geçirilemez

Sadece oku

  1. salt okunur anahtar kelime yalnızca yerel değişkenlere sahip olmayan alanlar için geçerlidir
  2. Başka bir yöntemde değil, beyan anında veya yapıcıda salt okunur bir alan atayabiliriz.
  3. salt okunur alanlar için ayrılan dinamik bellek ve değeri çalışma zamanında alabiliriz.
  4. Salt okunur olarak, yalnızca sınıf örneği üzerinden erişilen bu nesneye aittir. Sınıf üyesi olabilmek için, salt okunur olarak statik anahtar kelime eklememiz gerekir.
  5. Değer, kullanılan yapıcıya bağlı olarak farklı olabilir (sınıfın nesnesine ait olduğu için)
  6. İlkel olmayan türleri (başvuru türü) salt okunur olarak bildirirseniz, içerdiği nesne değil yalnızca başvuru değişmez.
  7. Değer çalışma zamanında elde edildiğinden, salt okunur alanlar / özellikleri ile dll sürüm oluşturma sorunu yoktur.
  8. Salt okunur alanı yapıcı bağlamında ref veya out parametreleri olarak geçirebiliriz.

3

Başka bir yakaladım .

Const gerçekten sadece temel veri türleriyle çalıştığından, bir sınıfla çalışmak istiyorsanız ReadOnly'ı kullanmak için "zorlanmış" hissedebilirsiniz. Ancak, tuzağa dikkat! ReadOnly, nesneyi başka bir nesneyle değiştiremeyeceğiniz anlamına gelir (başka bir nesneye başvurmasını sağlayamazsınız). Ancak nesneye referansı olan herhangi bir işlem, nesnenin içindeki değerleri değiştirmekte özgürdür !

Bu nedenle, ReadOnly'nin bir kullanıcının bazı şeyleri değiştiremeyeceğini ima ettiğini düşünmeyin. Bir sınıf örneğinin dahili değerlerinin değişmesini (bildiğim kadarıyla) değiştirmesini önlemek için C # 'da basit bir sözdizimi yoktur.


Evet bu daha genel bir temadır. Bir arraylisti açıklayan bir get özelliğiniz varsa, yine de arraylist'i değiştirebilirsiniz. Bu özelliğe farklı bir dizici ayarlayamazsınız, ancak kullanıcının diziliciyi değiştirmesini durduramazsınız.
Gishu

3

Bir constolmak zorunda kodlanmış burada olarak readonlyedilebilir kurucu belirlenen sınıfın.


3

C # .Net'te const ve salt okunur alanlar arasında dikkate değer bir fark vardır.

const varsayılan olarak statiktir ve daha sonra değiştirilemeyen sabit değerle başlatılması gerekir. Yapıcılarda da değer değişikliğine izin verilmez. Tüm veri tipleriyle kullanılamaz. Ex DateTime için. DateTime veri tipiyle kullanılamaz.

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

salt okunur olarak statik olarak bildirilebilir, ancak gerekli değildir. Beyan sırasında başlatmaya gerek yoktur. Değeri kurucu kullanılarak atanabilir veya değiştirilebilir. Bu nedenle, örnek sınıf üyesi olarak kullanıldığında avantaj sağlar. İki farklı örneklemenin salt okunur alanın değeri farklı olabilir. Eski için -

class A
{
    public readonly int Id;

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

Daha sonra salt okunur alan aşağıdaki gibi anlık spesifik değerlerle başlatılabilir:

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

Burada, objOne örneği 5 olarak salt okunur alan değerine sahip olacak ve objTwo'nun 10 değeri vardır. Bu, const kullanılarak mümkün değildir.


2

Bir sabit, değişmez değer olarak tüketiciye derlenirken, statik dize tanımlanan değere bir başvuru işlevi görür.

Bir alıştırma olarak, harici bir kütüphane oluşturmayı deneyin ve bir konsol uygulamasında tüketin, ardından kütüphanedeki değerleri değiştirin ve yeniden derleyin (tüketici programını yeniden derlemeden), DLL'i dizine bırakın ve EXE'yi manuel olarak çalıştırın, bulmalısınız. sabit dize değişmez.


İçtenlikle bunun doğru olduğundan şüphe ediyorum ... kontrol edeceğim.
ljs

Bu C # geliştirmek için 50 belirli yollarından biri - amazon.co.uk/Effective-Specific-Ways-Improve-Your/dp/0321245660/…
Russ Cam


@Andrew Hare - evet, yeni kontrol ettim. Çok şaşırdım, bu gerçek bir yakaladım, gerçekten çok şaşırdım, durumun hayrete düştüğü ...!
ljs

Ancak, burada kelime işaretçisinin kullanımına itiraz ediyorum. Bu bir işaretçi değil, bir referanstır ve güvenli olmayan modda yönetilmeyen işaretçileri değiştirebileceğiniz için C # 'da bir fark vardır , bu yüzden ikisi arasında ayrım yapmak önemlidir.
ljs

2

Sabit

Değer tanımlandığında const alanına değer sağlamalıyız. Derleyici daha sonra sabitin değerini derlemenin meta verilerine kaydeder. Bu, bir sabitin yalnızca boolean, char, byte vb. Gibi ilkel tipler için tanımlanabileceği anlamına gelir. Sabitler örnek üyeler değil, her zaman statik üyeler olarak kabul edilir.

Sadece oku

Salt okunur alanlar yalnızca çalışma zamanında çözülebilir. Bu, alanın bildirildiği tür için yapıcıyı kullanarak bir değer için bir değer tanımlayabileceğimiz anlamına gelir. Doğrulama, derleyici tarafından salt okunur alanların kurucu dışında herhangi bir yöntemle yazılmadığı şeklinde yapılır.

Her ikisi de bu makalede açıklanan hakkında daha fazla bilgi


1

Prensip olarak; çalışma zamanında sabit olmayan bir değere statik salt okunur bir alana bir değer atayabilirsiniz, oysa bir sabitin sabit bir değer atanması gerekir.


1

Const ve salt okunur benzerdir, ancak tam olarak aynı değildirler. Bir const alanı derleme zamanı sabitidir, yani bu değer derleme zamanında hesaplanabilir. Salt okunur bir alan, türün oluşturulması sırasında bazı kodların çalıştırılması gereken ek senaryolar sağlar. İnşaattan sonra, salt okunur bir alan değiştirilemez.

Örneğin, const üyeleri aşağıdaki gibi üyeleri tanımlamak için kullanılabilir:

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

3.14 ve 0 gibi değerler derleme zamanı sabitleridir. Ancak, bir tür tanımladığınız ve bu türün bazı fab öncesi örneklerini sağlamak istediğiniz durumu göz önünde bulundurun. Örneğin, bir Color sınıfı tanımlamak ve Siyah, Beyaz vb. Ortak renkler için "sabitler" sağlamak isteyebilirsiniz. Sağ taraflar derleme zamanı sabitleri olmadığından bunu const üyeleriyle yapmak mümkün değildir. Bunu düzenli statik üyelerle yapabiliriz:

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;
    }
}

ancak o zaman Renk müşterisinin belki de Siyah Beyaz değerlerini değiştirerek onunla uğraşmasını engelleyecek hiçbir şey yoktur. Söylemeye gerek yok, bu, Color sınıfının diğer istemcileri için şaşkınlığa neden olur. "Salt okunur" özellik bu senaryoyu ele alır. Yalnızca bildirimlere salt okunur anahtar sözcüğü ekleyerek, esnek kod başlatmayı korurken istemci kodunun karışmasını önleriz.

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;
    }
}

Const üyelerinin her zaman statik olduğunu, ancak salt okunur bir üyenin normal bir alan gibi statik olabileceğini veya olmayabileceğini belirtmek ilginçtir.

Bu iki amaç için tek bir anahtar kelime kullanmak mümkündür, ancak bu sürüm oluşturma sorunlarına veya performans sorunlarına yol açar. Bir an için bunun için (const) tek bir anahtar kelime kullandığımızı ve bir geliştiricinin şunu yazdığını varsayın:

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

ve farklı bir geliştirici A'ya dayanan bir kod yazdı:

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

Şimdi, oluşturulan kod AC'nin derleme zamanı sabiti olmasına güvenebilir mi? Yani, AC kullanımı sadece 0 değeri ile değiştirilebilir mi? Buna "evet" derseniz, A geliştiricisinin AC'nin başlatılma şeklini değiştiremeyeceği anlamına gelir - bu, A geliştiricisinin ellerini izinsiz bağlar. Bu soruya "hayır" derseniz, önemli bir optimizasyon kaçırılır. Belki de A'nın yazarı AC'nin her zaman sıfır olacağı konusunda olumludur. Hem const hem de salt okunur kullanımı, A geliştiricisinin amacı belirtmesine izin verir. Bu, daha iyi sürüm oluşturma davranışı ve daha iyi performans sağlar.


1

ReadOnly: Değer, sınıfın yapıcısından yalnızca bir kez başlatılır.
const: herhangi bir işlevde ancak bir kez başlatılabilir


1

Fark, statik bir salt okunur alanın değerinin çalışma zamanında ayarlanmasıdır, bu nedenle programın farklı yürütmeleri için farklı bir değere sahip olabilir. Ancak, bir const alanının değeri bir derleme zaman sabitine ayarlanır.

Unutmayın: Referans türlerinde, her iki durumda da (statik ve örnek) salt okunur değiştirici yalnızca alana yeni bir başvuru atamanızı önler. Özellikle referans ile gösterilen nesneyi değiştirilemez yapmaz.

Ayrıntılar için lütfen bu konuyla ilgili C # Sık Sorulan Sorular'a bakın: http://blogs.msdn.com/csharpfaq/archive/2004/12/03/274791.aspx


1

Sabit değişkenler derleme zamanında bildirilir ve başlatılır. Değer, servislerden sonra değiştirilemez. Salt okunur değişkenler yalnızca sınıfın Statik yapıcısından başlatılır. Salt okunur yalnızca değeri çalışma zamanında atamak istediğimizde kullanılır.


1

Sabit : Uygulama ömrü boyunca mutlak sabit değer.

Readonly : Çalışma süresinde değiştirilebilir.


1
Değiştirebileceği 'salt okunur' tanımınız kusurludur. Sanırım 'değiştir' ile 'set' demek istediniz, 'çalışma zamanında ayarlanabilir' gibi.
Ahmed

0

İnsanların yukarıda söylediklerine eklemek için bir şey. Salt okunur bir değer içeren bir montajınız varsa (ör. Salt okunur MaxFooCount = 4;), bu montajın yeni bir sürümünü farklı bir değerle göndererek (örneğin salt okunur MaxFooCount = 5;) çağrı derlemelerinin gördüğü değeri değiştirebilirsiniz.

Ancak bir sabitle, arayan derlendiğinde arayanın koduna katlanır.

Bu C # yeterlilik seviyesine ulaştıysanız, bu soruyu ayrıntılı olarak yanıtlayan Bill Wagner'in Etkili C #: 50 Özel Yolları # ve diğer soruları cevaplamaya hazırsınız.

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.