Ref ne zaman kullanılır ve C # 'da gerekli olmadığında

Programın hafızadaki durumu olan bir nesnem var ve ayrıca durumu değiştirmek için nesneyi ilettiğim başka çalışan işlevlerim var. Bunu işçi işlevlerine göre aktarıyorum. Ancak şu fonksiyonla karşılaştım.

byte[] received_s = new byte[2048];
IPEndPoint tmpIpEndPoint = new IPEndPoint(IPAddress.Any, UdpPort_msg);
EndPoint remoteEP = (tmpIpEndPoint);

int sz = soUdp_msg.ReceiveFrom(received_s, ref remoteEP); 

Kafamı karıştırıyor çünkü ikisi de received_sve remoteEPişlevden bir şeyler döndürüyor. Neden a'ya remoteEPihtiyaç duyuyor refve received_sgerekmiyor?

Ben de ac programcısıyım, bu yüzden işaretçileri kafamdan atmakta sorun yaşıyorum.

Düzenleme: Görünüşe göre C # 'daki nesneler kaputun altındaki nesneye işaret ediyor. Böylece, bir nesneyi bir işleve ilettiğinizde, nesne içeriğini işaretçi aracılığıyla değiştirebilirsiniz ve işleve iletilen tek şey nesnenin işaretçisidir, böylece nesnenin kendisi kopyalanmaz. Çift işaretçi gibi işlevde geçiş yapabilmek veya yeni bir nesne oluşturmak istiyorsanız ref veya out kullanırsınız.

Kısa cevap: benim okuma argüman geçen makalesine .

Uzun cevap: bir referans türü parametresi değere göre iletildiğinde, nesnenin bir kopyası değil , yalnızca başvuru iletilir . Bu, C veya C ++ 'da bir işaretçi (değere göre) iletmek gibidir. Parametresi kendisinin değerine değişiklikler arayan tarafından görülen, ama referans noktaları nesne değişikliği olmaz olacak görülebilir.

Bir parametre (her türde) geçirildiğinde ile referans parametresi herhangi bir değişiklik arayan tarafından görülür o araçları - parametreye değişiklikler olan değişkene değişir.

Makale elbette tüm bunları daha ayrıntılı olarak açıklıyor :)

Faydalı cevap: neredeyse hiç ref / out kullanmanıza gerek kalmaz . Temelde başka bir dönüş değeri elde etmenin bir yoludur ve genellikle kesinlikle kaçınılmalıdır çünkü bu, yöntemin muhtemelen çok fazla şey yapmaya çalıştığı anlamına gelir. Durum her zaman böyle değildir ( TryParsevb. Makul kullanımın kanonik örnekleridir out) ancak ref / out kullanımı göreceli olarak nadir olmalıdır.

Ref olmayan bir parametreyi işaretçi ve ref parametresini çift işaretçi olarak düşünün. Bu bana en çok yardımcı oldu.

Değerleri neredeyse hiçbir zaman ref ile geçirmemelisiniz. Interop endişeleri olmasaydı, .Net ekibinin bunu asla orijinal spesifikasyona dahil etmeyeceğinden şüpheleniyorum. Ref parametrelerinin çözdüğü çoğu problemle başa çıkmanın OO yolu şudur:

Birden çok dönüş değeri için

• Birden çok dönüş değerini temsil eden yapılar oluşturun

Yöntem çağrısının sonucu olarak bir yöntemde değişen ilkel öğeler için (yöntemin ilkel parametreler üzerinde yan etkileri vardır)

• Yöntemi bir nesneye örnek yöntem olarak uygulayın ve yöntem çağrısının bir parçası olarak nesnenin durumunu (parametreleri değil) değiştirin
• Çoklu dönüş değeri çözümünü kullanın ve dönüş değerlerini durumunuzla birleştirin
• Bir yöntem tarafından işlenebilen durumu içeren bir nesne oluşturun ve bu nesneyi parametre olarak iletin, ilkellerin kendileri değil.

Muhtemelen bütün bir C # uygulaması yazabilir ve hiçbir nesneyi / yapıyı ref ile iletemezsiniz.

Bana şunu söyleyen bir profesörüm vardı:

Referansları kullanacağınız tek yer şunlardan birini yaptığınız yerdir:

1. Büyük bir nesneyi (yani nesnelerin / yapının içinde birden çok seviyeye nesneler / yapılar vardır) geçirmek istersiniz ve onu kopyalamak pahalı olur ve
2. Bir Framework, Windows API veya bunu gerektiren başka bir API çağırıyorsunuz.

Bunu sadece yapabildiğin için yapma. Bir parametrede değerleri değiştirmeye başlarsanız ve dikkatinizi vermezseniz, bazı kötü böcekler tarafından ısırılabilirsiniz.

Tavsiyesine katılıyorum ve okuldan bu yana geçen beş artı yılımda, Framework veya Windows API'yi çağırmanın dışında buna hiç ihtiyacım olmadı.

Alınan_s bir dizi olduğundan, o diziye bir gösterici geçiriyorsunuz. İşlev, temeldeki konumu veya işaretçiyi değiştirmeden, mevcut verileri yerinde işler. Ref anahtar sözcüğü, gerçek işaretçiyi konuma ilettiğinizi ve bu işaretçiyi dış işlevde güncellediğinizi belirtir, böylece dış işlevdeki değer değişir.

Örneğin bayt dizisi önceki ve sonraki aynı belleğe bir göstericidir, bellek henüz güncellenmiştir.

Uç nokta referansı aslında işaretleyiciyi dış işlevdeki Uç Noktaya, işlev içinde oluşturulan yeni bir örneğe güncelliyor.

Bir referansı, bir göstericiyi referans olarak geçirdiğiniz anlamına gelir. Bir ref kullanmamak, bir göstericiyi değere göre geçirdiğiniz anlamına gelir.

Daha da iyisi, az önce söylediklerimi görmezden gelin (muhtemelen yanıltıcıdır, özellikle değer türlerinde) ve Bu MSDN sayfasını okuyun .

Anladığım kadarıyla, Object sınıfından türetilen tüm nesneler işaretçi olarak aktarılırken sıradan türler (int, struct) işaretçi olarak aktarılmaz ve ref gerektirir. String hakkında emin değilim (sonuçta Object sınıfından mı türetildi?)

Jon Skeet'in genel olarak cevabına ve diğer bazı cevaplara katılıyorum, ancak kullanmak için bir kullanım durumu var ref ve bu, performans optimizasyonlarını sıkılaştırmak için. Performans profili oluşturma sırasında, bir yöntemin geri dönüş değerini belirlemenin performans açısından küçük etkileri olduğu gözlemlenmiştir, oysa refdönüş değerinin bu parametreye doldurulduğu bir argüman olarak kullanılması , bu küçük darboğazın ortadan kaldırılmasına neden olur.

Bu gerçekten yalnızca optimizasyon çabalarının aşırı seviyelere götürüldüğü, okunabilirlikten ve belki de milisaniyelerden veya belki de milisaniyelerden tasarruf etmek için test edilebilirlik ve sürdürülebilirlikten ödün verildiği durumlarda yararlıdır.

İlk olarak temel sıfır kuralı, ilgili TİPLER bağlamında, İlkel olmayanlar (Yığın) değeriyle (Yığın) ve İlkel Olmayan (Heap) ile aktarılır.

İlgili parametreler varsayılan olarak Değer tarafından aktarılır. Her şeyi ayrıntılı olarak açıklayan iyi bir gönderi. http://yoda.arachsys.com/csharp/parameters.html

Student myStudent = new Student {Name="A",RollNo=1};

ChangeName(myStudent);

static void ChangeName(Student s1)
{
  s1.Name = "Z"; // myStudent.Name will also change from A to Z
                // {AS s1 and myStudent both refers to same Heap(Memory)
                //Student being the non-Primitive type
}

ChangeNameVersion2(ref myStudent);
static void ChangeNameVersion2(ref Student s1)
{
  s1.Name = "Z"; // Not any difference {same as **ChangeName**}
}

static void ChangeNameVersion3(ref Student s1)
{
    s1 = new Student{Name="Champ"};

    // reference(myStudent) will also point toward this new Object having new memory
    // previous mystudent memory will be released as it is not pointed by any object
}

(Uyarı ile) diyebiliriz İlkel olmayan türler İşaretçilerden başka bir şey değildir Ve onları ref ile geçerken Double Pointer'ı geçiyoruz diyebiliriz