C # neden referansların geri dönüşünü desteklemiyor?

.NET'in başvuruların geri dönüşünü desteklediğini okudum, ancak C # desteklemiyor. Özel bir nedeni var mı? Neden böyle bir şey yapamam:

static ref int Max(ref int x, ref int y) 
{ 
  if (x > y) 
    return ref x; 
  else 
    return ref y; 
} 

Bu soru 23 Haziran 2011 tarihinde blogumun konusuydu . Bu mükemmel soru için teşekkürler!

C # ekibi C # 7 için bunu düşünüyor. Ayrıntılar için bkz. Https://github.com/dotnet/roslyn/issues/5233 .

GÜNCELLEME: Bu özellik onu C # 7'ye getirdi!

Haklısın; .NET, yönetilen başvuruları değişkenlere döndüren yöntemleri destekler . .NET , diğer değişkenlere yönetilen başvurular içeren yerel değişkenleri de destekler . (Ancak , çöp toplama öyküsünü aşırı derecede karmaşıklaştırdığından, .NET'in diğer değişkenlere yönetilen başvurular içeren alanları veya dizileri desteklemediğini unutmayın . Ayrıca "değişkene yönetilen başvuru" türleri nesneye dönüştürülemez ve bu nedenle genel türlere veya yöntemlere argümanlar yazın.)

Bazı nedenlerden dolayı yorumcu "RPM1984" bu konuda bir alıntı istedi. RPM1984 .NET'in bu özelliği hakkında bilgi için CLI belirtimi Bölüm I Kısım 8.2.1.1, "Yönetilen işaretçiler ve ilgili türler" i okumanızı öneririz.

Her iki özelliği de destekleyen bir C # sürümü oluşturmak tamamen mümkündür. O zaman böyle şeyler yapabilirsin

static ref int Max(ref int x, ref int y) 
{ 
  if (x > y) 
    return ref x; 
  else 
    return ref y; 
} 

ve sonra

int a = 123;
int b = 456; 
ref int c = ref Max(ref a, ref b); 
c += 100;
Console.WriteLine(b); // 556!

Ben bu özellikleri destekleyen C # bir sürümünü inşa etmenin mümkün olduğunu ampirik olarak biliyoruz ben çok yapmış çünkü . Gelişmiş programcılar, özellikle yönetilmeyen C ++ kodunu taşıyan kişiler, genellikle bize daha fazla C ++ benzeri şeyler ister, aslında işaretçileri kullanmanın ve hafızayı her yere sabitlemenin büyük çekiçinden kurtulmak zorunda kalmadan referanslarla bir şeyler yapma yeteneği ister. Yönetilen referansları kullanarak, çöp toplama performansınızı azaltmanın maliyetini ödemeden bu avantajları elde edersiniz.

Bu özelliği dikkate aldık ve aslında geri bildirimlerini almak için diğer dahili ekiplere gösterilecek kadar uyguladık. Ancak şu anda araştırmamıza dayanarak , özelliğin gerçek bir desteklenen dil özelliğine dönüştürmek için yeterince geniş bir cazibe veya zorlayıcı kullanım örneği olmadığına inanıyoruz . Daha yüksek önceliklerimiz ve sınırlı miktarda zaman ve çaba harcıyoruz, bu nedenle bu özelliği yakın zamanda yapmayacağız.

Ayrıca, düzgün bir şekilde yapılması için CLR'de bazı değişiklikler yapılması gerekir. Şu anda CLR, geri dönüş yöntemlerini yasal ancak doğrulanamaz olarak değerlendiriyor çünkü bu durumu tespit eden bir dedektörümüz yok:

ref int M1(ref int x)
{
    return ref x;
}

ref int M2()
{
    int y = 123;
    return ref M1(ref y); // Trouble!
}

int M3()
{
    ref int z = ref M2();
    return z;
}

M3, M2'nin yerel değişkeninin içeriğini döndürür, ancak bu değişkenin ömrü sona erdi! Açık bir şekilde yok ref-döner kullanımlarını saptayan bir dedektör yazmak mümkündür olmayan yığın güvenlik ihlal eder. Yapacağımız şey böyle bir dedektör yazmak ve eğer dedektör yığın güvenliğini kanıtlayamazsa, programın o bölümünde ref iadelerinin kullanılmasına izin vermezdik. Bunu yapmak çok büyük bir geliştirme işi değil, ancak tüm vakaları gerçekten aldığımızdan emin olmak için test ekipleri üzerinde çok fazla yük var. Bu, özelliğin maliyetini şu anda faydaların maliyetlerden ağır basmadığı noktaya kadar artıran başka bir şey.

Bana bu özelliği neden istediğini açıklayabilirsen, bunu gerçekten takdir ediyorum . Gerçek müşterilerden neden istedikleri hakkında ne kadar fazla bilgiye sahipsek, bir gün ürüne girme olasılığı o kadar yüksek olur. Bu sevimli küçük bir özellik ve yeterli ilgi varsa bir şekilde müşterilere almak istiyorum.

(Ayrıca ilgili sorulara bakın o C # Değişken bir başvuru Dönüş Mümkün mü? Ve ++ ben C gibi bir C # işlevi içinde bir başvuru kullanabilir miyim? )

Bir değer türüne başvuru döndüren yöntemlerden bahsediyorsunuz. Bildiğim tek yerleşik C # örneği, bir değer türünün dizi erişimcisi:

public struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}

ve şimdi bu yapıdan bir dizi oluşturun:

var points = new Point[10];
points[0].X = 1;
points[0].Y = 2;

Bu durumda points[0], dizi indeksleyici yapıya bir başvuru döndürür. Aynı "başvuru döndürme" davranışına sahip olan kendi dizinleyicinizi (örneğin, özel bir koleksiyon için) yazmak imkansızdır .

C # dilini tasarlamadım, bu yüzden onu desteklememenin arkasındaki tüm mantığı bilmiyorum, ama kısa cevabın olabileceğini düşünüyorum: onsuz iyi geçinebiliriz.

Her zaman böyle bir şey yapabilirsiniz:

public delegate void MyByRefConsumer<T>(ref T val);

public void DoSomethingWithValueType(MyByRefConsumer<int> c)
{
        int x = 2;
        c(ref x);
        //Handle potentially changed x...
}

C # 7.0 referansları döndürme desteğine sahiptir. Cevabımı burada görün .