Const parametrelerine C # 'da neden izin verilmiyor?

Özellikle C ++ geliştiricileri için garip görünüyor. C ++ ' constda, durumunun yöntemde değişmeyeceğinden emin olmak için bir parametreyi işaretlerdik . const refRef ile geçmek ve durumun değişmeyeceğinden emin olmak gibi C ++ 'ya özgü başka nedenler de vardır . Ama neden C # 'da yöntem parametreleri sabiti olarak işaretleyemiyoruz?

Yöntemimi neden aşağıdaki gibi açıklayamıyorum?

    ....
    static void TestMethod1(const MyClass val)
    {}
    ....
    static void TestMethod2(const int val)
    {}
    ....

Diğer iyi cevaplara ek olarak, C-stili sabitliği C # 'a koymamak için başka bir neden daha ekleyeceğim. Dedin:

yöntemde durumunun değişmeyeceğinden emin olmak için parametreyi const olarak işaretleriz.

Const gerçekten bunu yapsaydı, bu harika olurdu. Const bunu yapmaz. Sabit bir yalan!

Const gerçekten kullanabileceğime dair hiçbir garanti vermiyor. Sabit bir şey alan bir yönteminiz olduğunu varsayalım. İki kod yazarı vardır: arayanı yazan kişi ve arayan ucu yazan kişi . Aranan ucun yazarı, yöntemin bir sabit almasını sağlamıştır. İki yazar neyin nesne hakkında değişmez olduğunu varsayabilir?

Hiçbir şey değil. Aranan uç, const'ı atmak ve nesneyi değiştirmek için serbesttir, bu nedenle arayan, bir const alan bir yöntemi çağırmanın onu değiştirmeyeceğinin garantisine sahip değildir. Benzer şekilde, aranan uç, nesnenin içeriklerinin aranan ucun eylemi boyunca değişmeyeceğini varsayamaz; aranan uç , const nesnesinin const olmayan bir diğer adı üzerinde bazı mutasyon yöntemlerini çağırabilirdi ve şimdi sözde const nesnesi değişti .

C-style const, nesnenin değişmeyeceğine ve dolayısıyla bozulacağına dair hiçbir garanti vermez. Şimdi, C zaten zayıf bir tür sisteme sahip, burada gerçekten istiyorsanız double türünün int'e yeniden yorumlanmasını sağlayabilirsiniz, bu nedenle const'a göre zayıf bir tür sisteme sahip olması şaşırtıcı olmamalıdır. Ancak C # iyi bir tür sistemine sahip olacak şekilde tasarlanmıştır , "bu değişken bir dize içerir" dediğinizde değişkenin aslında bir dizeye (veya boş) bir başvuru içerdiği bir tür sistemi . Yazım sistemine kesinlikle bir C-stili "const" değiştiricisi koymak istemiyoruz çünkü yazı sisteminin yalan olmasını istemiyoruz . Kodunuz hakkında doğru şekilde düşünebilmeniz için tür sisteminin güçlü olmasını istiyoruz .

Const in C bir kılavuzdur ; temelde "bu şeyi değiştirmeye çalışmama konusunda bana güvenebilirsin" anlamına gelir. Bu tür sisteminde olmamalıdır ; tip sistemindeki şeyler , kullanımıyla ilgili bir kılavuz değil, akıl yürütebileceğiniz nesne hakkında bir gerçek olmalıdır .

Şimdi, beni yanlış anlamayın; C'deki const'in derinden kırılmış olması, tüm kavramın işe yaramaz olduğu anlamına gelmez. Görmek istediğim şey , C # 'da "const" ek açıklamasının gerçekten doğru ve yararlı bir biçimidir; bu, hem insanların hem de derleyicilerin kodu anlamalarına yardımcı olmak için kullanabilecekleri ve çalışma zamanının otomatik paralelleştirme gibi şeyler yapmak için kullanabileceği bir ek açıklama ve diğer gelişmiş optimizasyonlar.

Örneğin, bir kod parçasının etrafına "bir kutu çizebildiğinizi" ve derleyici tarafından kontrol edilebilecek bir şekilde "Bu kod parçasının bu sınıfın hiçbir alanında mutasyon yapmayacağını garanti ediyorum" diyebildiğinizi hayal edin . Veya "bu saf yöntem nesnenin iç durumunu değiştirir, ancak kutunun dışında hiçbir şekilde gözlemlenemez " yazan bir kutu çizin . Böyle bir nesne otomatik olarak güvenli bir şekilde çoklu iş parçacıklı olamaz, ancak otomatik olarak hafızaya alınabilir . Zengin optimizasyonları ve daha derin anlayışı mümkün kılacak koda koyabileceğimiz her türlü ilginç ek açıklama vardır. Zayıf C-stili sabit açıklamasından çok daha iyisini yapabiliriz.

Ancak bunun sadece spekülasyon olduğunu vurguluyorum . Bu tür bir özelliği herhangi bir varsayımsal gelecek C # sürümüne koymak için kesin bir planımız yok, eğer varsa, öyle ya da böyle açıklamadık. Bu, görmeyi çok istediğim bir şey ve çok çekirdekli bilgi işlem üzerine gelecek vurgunun gerektirebileceği bir şey, ancak bunların hiçbiri, herhangi bir özelliğin veya C # için gelecek yönün bir tahmini veya garantisi olarak yorumlanmamalıdır.

Şimdi, eğer istediğiniz şey yerel değişken üzerinde "bu parametrenin değeri yöntem boyunca değişmez" diyen bir parametre olan bir açıklama ise, o zaman bu kolayca yapılabilir. Bir kez başlatılacak "salt okunur" yerelleri ve parametreleri ve yöntemde değişiklik yapmak için bir derleme zamanı hatasını destekleyebiliriz. "Using" ifadesiyle bildirilen değişken zaten yereldir; değişkenleri "kullanıyor" gibi davranmalarını sağlamak için tüm yerellere ve parametrelere isteğe bağlı bir açıklama ekleyebiliriz. Asla çok yüksek öncelikli bir özellik olmadı, bu yüzden hiç uygulanmadı.

C # 'da const doğruluğu olmamasının nedenlerinden biri , çalışma zamanı düzeyinde mevcut olmamasıdır. C # 1.0'ın, çalışma zamanının bir parçası olmadığı sürece herhangi bir özelliğe sahip olmadığını unutmayın.

Ve CLR'nin sabit doğruluk kavramına sahip olmamasının birkaç nedeni örneğin:

1. Çalışma zamanını karmaşıklaştırır; ayrıca, JVM'de de yoktu ve CLR temelde C ++ benzeri bir çalışma zamanı değil, JVM benzeri bir çalışma zamanı oluşturmak için bir proje olarak başladı.
2. Çalışma zamanı düzeyinde const doğruluğu varsa, BCL'de const doğruluğu olmalıdır, aksi takdirde özellik .NET Framework söz konusu olduğunda hemen hemen anlamsızdır.
3. BCL const doğruluğunu gerektiriyorsa Ama CLR üstündeki her dil const doğruluğunu desteklemelidir (VB, JavaScript, Python, Ruby, F #, vs.) en That değil ne olacak.

Sabit doğruluk, hemen hemen yalnızca C ++ 'da bulunan bir dil özelliğidir. Bu nedenle, CLR'nin neden kontrol edilmiş istisnalar gerektirmediğine (yalnızca Java diline özgü bir özellik olan) ilişkin aynı argümantasyona dayanır.

Ayrıca, geriye dönük uyumluluğu bozmadan yönetilen bir ortamda bu kadar temel bir sistem özelliği sunabileceğinizi sanmıyorum. Bu yüzden C # dünyasına girerken sabit doğruluğa güvenmeyin.

C # 'nin sabit doğru olmamasının iki nedeni olduğuna inanıyorum.

Birincisi anlaşılabilirliktir . Çok az C ++ programcısı const-doğruluğunu anlar. Bunun basit örneği const int argsevimli, ama ben de gördüm char * const * const arg- sabit olmayan karakterlere sabit işaretçiler için sabit bir işaretçi. İşlevlere işaretçilerdeki sabit doğruluk tamamen yeni bir gizleme düzeyidir.

İkincisi, sınıf bağımsız değişkenlerinin değer tarafından iletilen başvurular olmasıdır. Bu, açıkça anlaşılır bir sözdizimi olmadan başa çıkılması gereken iki sabitlik düzeyi olduğu anlamına gelir . Benzer bir tökezleme noktası da koleksiyonlardır (ve koleksiyon koleksiyonları vb.).

Sabit-doğruluk, C ++ tipi sistemin önemli bir parçasıdır. Teoride C # 'a yalnızca derleme zamanında kontrol edilen bir şey olarak eklenebilir (CLR'ye eklenmesi gerekmez ve const üye yöntemleri kavramı dahil edilmedikçe BCL'yi etkilemez) .

Bununla birlikte, bunun olası olmadığına inanıyorum: ikinci nedeni (sözdizimi) çözmek oldukça zor olacaktır, bu da ilk nedeni (anlaşılabilirliği) daha da bir problem haline getirecektir.

constC # 'da "derleme zamanı sabiti" anlamına gelir, C ++' da olduğu gibi "salt okunur, ancak muhtemelen başka kodla değiştirilebilir" anlamına gelir. constC # 'da kabaca bir C ++ benzeri readonly, ancak bu yalnızca alanlar için geçerlidir. Bunun dışında, C # 'ta C ++ benzeri const doğruluğu kavramı yoktur.

Mantığın kesin olarak söylenmesi zor, çünkü birçok potansiyel neden var, ancak benim tahminim, dili her şeyden önce basit tutma arzusu ve bu ikinciyi uygulamanın belirsiz avantajları olacaktır.

Bu, C # 7.2'den (Visual Studio 2017 15.5 ile Aralık 2017) itibaren mümkündür.

Yalnızca Yapılar ve temel türler için! , sınıf üyeleri için değil.

inBağımsız değişkeni başvuruya göre girdi olarak göndermek için kullanmalısınız . Görmek:

Bakınız: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/in-parameter-modifier

Örneğiniz için:

....
static void TestMethod1(in MyStruct val)
{
    val = new MyStruct;  // Error CS8331 Cannot assign to variable 'in MyStruct' because it is a readonly variable
    val.member = 0;  // Error CS8332 Cannot assign to a member of variable 'MyStruct' because it is a readonly variable
}
....
static void TestMethod2(in int val)
{
    val = 0;  // Error CS8331 Cannot assign to variable 'in int' because it is a readonly variable
}
....