Sınıf yerine bir yapı ne zaman kullanmalıyım?

MSDN, hafif nesnelere ihtiyacınız olduğunda yapıları kullanmanız gerektiğini söylüyor. Bir yapı bir sınıfa tercih edildiğinde başka senaryolar var mı?

Bazı insanlar bunu unutmuş olabilir:

1. yapıların yöntemleri olabilir.
2. yapılar miras alınamaz.

Yapılar ve sınıflar arasındaki teknik farklılıkları anlıyorum, bir yapının ne zaman kullanılacağı konusunda iyi bir fikrim yok .

MSDN şu cevaba sahiptir: Sınıflar ve Yapılar Arasında Seçim Yapma .

Temel olarak, bu sayfa size 4 öğeli bir kontrol listesi verir ve türünüz tüm ölçütleri karşılamadığı sürece bir sınıf kullandığını söyler.

Tür aşağıdaki özelliklerin hepsine sahip olmadığı sürece bir yapı tanımlamayın:

• Mantıksal olarak ilkel tiplere (tamsayı, çift vb.) Benzer tek bir değeri temsil eder.
• 16 bayttan küçük bir örnek boyutuna sahiptir.
• Değişmez.
• Sık sık kutsanması gerekmeyecek.

En önemli yönü düşündüğüm önceki cevabın hiçbirini okumadığım için şaşırdım:

Kimliği olmayan bir tür istediğimde yapıları kullanıyorum. Örneğin bir 3B nokta:

public struct ThreeDimensionalPoint
{
    public readonly int X, Y, Z;
    public ThreeDimensionalPoint(int x, int y, int z)
    {
        this.X = x;
        this.Y = y;
        this.Z = z;
    }

    public override string ToString()
    {
        return "(X=" + this.X + ", Y=" + this.Y + ", Z=" + this.Z + ")";
    }

    public override int GetHashCode()
    {
        return (this.X + 2) ^ (this.Y + 2) ^ (this.Z + 2);
    }

    public override bool Equals(object obj)
    {
        if (!(obj is ThreeDimensionalPoint))
            return false;
        ThreeDimensionalPoint other = (ThreeDimensionalPoint)obj;
        return this == other;
    }

    public static bool operator ==(ThreeDimensionalPoint p1, ThreeDimensionalPoint p2)
    {
        return p1.X == p2.X && p1.Y == p2.Y && p1.Z == p2.Z;
    }

    public static bool operator !=(ThreeDimensionalPoint p1, ThreeDimensionalPoint p2)
    {
        return !(p1 == p2);
    }
}

Bu yapının iki örneği varsa, bunların bellekte tek bir veri parçası mı yoksa iki tane mi olduğunu umursamazsınız. Sadece sahip oldukları değerlere önem veriyorsunuz.

Bill Wagner'in "etkili c #" kitabında bununla ilgili bir bölüm var ( http://www.amazon.com/Effective-Specific-Ways-Improve-Your/dp/0321245660 ). Aşağıdaki prensibi kullanarak sonuçlandırır:

1. Veri depolama türünün ana sorumluluğu var mı?
2. Genel arayüzü tamamen veri üyelerine erişen veya bunları değiştiren özellikler tarafından tanımlanıyor mu?
3. Türünüzün asla alt sınıfları olmayacağından emin misiniz?
4. Tipinizin asla polimorfik olarak muamele görmeyeceğinden emin misiniz?

4 sorunun hepsine 'evet' cevabını verirseniz: bir yapı kullanın. Aksi takdirde bir sınıf kullanın.

Başvuru türü yerine değer türü anlambilimi istediğinizde bir yapı kullanın. Yapılar kopya değerlidir, bu yüzden dikkatli olun!

Ayrıca önceki sorulara bakın, ör.

.NET'te struct ve class arasındaki fark nedir?

Ben ne zaman yapılar kullanırsınız:

1. bir nesnenin salt okunur olması gerekir (bir yapıyı her geçtiğinizde / atadığınızda kopyalanır). Çoğu durumda kilitleme gerektirmediğinden, çok iş parçacıklı işleme söz konusu olduğunda salt okunur nesneler harikadır.

2. bir nesne küçük ve kısa ömürlüdür. Böyle bir durumda, nesnenin yığına tahsis edilmesi şansı yüksektir, bu da yönetilen yığın üzerine koymaktan çok daha verimlidir. Dahası, nesne tarafından ayrılan bellek, kapsamının dışına çıkar çıkmaz boşaltılır. Başka bir deyişle, Çöp Toplayıcı için daha az iştir ve bellek daha verimli kullanılır.

Aşağıdaki durumlarda bir sınıf kullanın:

• Kimliği önemlidir. Yapılar, değere göre bir yönteme geçirildiğinde örtük olarak kopyalanır.
• Geniş bir bellek alanına sahip olacak.
• Alanları başlangıç ​​değerlerine ihtiyaç duyar.
• Bir temel sınıftan miras almanız gerekir.
• Polimorfik davranışa ihtiyacınız var;

Aşağıdaki durumlarda bir yapı kullanın:

• İlkel bir tip gibi davranacaktır (int, uzun, bayt, vb.).
• Küçük bir bellek alanına sahip olması gerekir.
• Bir yapının değere göre aktarılmasını gerektiren bir P / Invoke yöntemini çağırıyorsunuz.
• Çöp toplamanın uygulama performansı üzerindeki etkisini azaltmanız gerekir.
• Alanlarının yalnızca varsayılan değerlerine sıfırlanması gerekir. Bu değer, sayısal türler için sıfır, Boolean türler için yanlış ve referans türleri için null olur.
  • C # 6.0 yapılarında, yapı alanlarının varsayılan olmayan değerlere başlatılmasında kullanılabilecek varsayılan bir yapıcı olabileceğini unutmayın.
• Bir temel sınıftan (tüm yapıların devraldığı ValueType dışında) miras almanıza gerek yoktur.
• Polimorfik davranışa ihtiyacınız yoktur.

Her zaman bir yöntem çağrısından bir şeyler geri aktarmak için birkaç değeri bir araya getirmek istediğimde bir yapı kullandım, ancak bu değerleri okuduktan sonra herhangi bir şey için kullanmam gerekmeyecek. Tıpkı işleri temiz tutmanın bir yolu gibi. Bir yapıdaki şeyleri "fırlatma" ve sınıftaki şeyleri daha kullanışlı ve "işlevsel" olarak görme eğilimindeyim

Eğer bir varlık değişmez olacaksa, bir yapı mı yoksa sınıf mı kullanılacağı sorusu anlambilimden ziyade genellikle performanstan biri olacaktır. 32/64-bit bir sistemde, sınıf referansları, sınıftaki bilgi miktarından bağımsız olarak depolanması için 4/8 bayt gerektirir; sınıf referansını kopyalamak 4/8 bayt kopyalamayı gerektirir. Öte yandan, her farklısınıf örneği, sahip olduğu bilgilere ve referanslara ilişkin bellek maliyetine ek olarak 8/16 bayt ek yüke sahip olacaktır. Her birinin dört adet 32 ​​bitlik tam sayıya sahip 500 varlıklık bir dizi istediğini varsayalım. Varlık bir yapı türüyse, dizi, 500 varlığın tümü aynı, hepsi farklı veya aralarında bir yer olup olmadığına bakılmaksızın 8.000 bayt gerektirir. Varlık bir sınıf türüyse, 500 başvuru dizisi 4.000 bayt alır. Bunların tümü farklı nesnelere işaret ediyorsa, nesnelerin her biri ek 24 bayt (500'ün tamamı için 12.000 bayt), toplam 16.000 bayt - bir yapı türünün depolama maliyetinin iki katı gerekir. Öte yandan, kod bir nesne örneği oluşturdu ve daha sonra 500 dizi yuvasına bir referans kopyaladı, toplam maliyet o örnek için 24 bayt ve 4, Dizi için 000 - toplam 4.024 bayt. Büyük bir tasarruf. Sonuncunun yanı sıra çok az sayıda durum işe yarayacaktır, ancak bazı durumlarda bu tür paylaşımları değerli kılmak için yeterli sayıda dizi yuvasına bazı referanslar kopyalamak mümkün olabilir.

Varlığın değişebilir olması gerekiyorsa, bir sınıf veya yapı kullanılıp kullanılmayacağı sorusu bazı açılardan daha kolaydır. "Şey" in, x adında bir tamsayı alanına sahip bir yapı veya sınıf olduğunu ve birinin aşağıdaki kodu yaptığını varsayalım:

  Şey tl, t2;
  ...
  t2 = tl;
  t2.x = 5;

İkinci ifade t1.x'i etkilemek ister mi?

Şey bir sınıf tipiyse, t1 ve t2 eşdeğer olacaktır, yani t1.x ve t2.x de eşdeğer olacaktır. Böylece, ikinci ifade t1.x'i etkileyecektir. Şey bir yapı tipiyse, t1 ve t2 farklı örnekler olacaktır, yani t1.x ve t2.x farklı tamsayıları ifade edecektir. Dolayısıyla, ikinci ifade t1.x'i etkilemeyecektir.

Değişken yapılar ve değişebilir sınıflar temelde farklı davranışlara sahiptir, ancak .net'in yapısal mutasyonları ele almasında bazı tuhaflıkları vardır. Kişi değer türü davranışlar istiyorsa ("t2 = t1" ifadesinin, t1 ve t2'yi ayrı örnek olarak bırakırken verileri t1'den t2'ye kopyalayacağı anlamına gelir) ve .net'in değer türlerini işleyişindeki tuhaflıklarla yaşayabiliyorsa, yapı. Birisi değer türü anlambilim istiyor, ancak .net'in tuhaflıkları kişinin uygulamasında değer türü anlambilimine yol açacaksa, bir sınıf ve mumble kullanın.

Buna ek olarak, yukarıdaki mükemmel cevaplar:

Yapılar değer tipleridir.

Hiçbir zaman Hiçbir şey olarak ayarlanamazlar .

Bir yapı ayarlama = Hiçbir şey, tüm değer türlerini varsayılan değerlerine ayarlayamaz.

gerçekten davranışa ihtiyacınız olmadığında, ancak basit bir dizi veya sözlükten daha fazla yapıya ihtiyacınız olduğunda.

Takip Genel olarak yapıları böyle düşünüyorum. Yöntemleri olabileceğini biliyorum, ama bu zihinsel ayrımı tutmayı seviyorum.

@Simon'un dediği gibi, yapılar "değer türü" anlambilim sağlar, bu nedenle yerleşik bir veri türüne benzer bir davranışa ihtiyacınız varsa bir yapı kullanın. Yapılar kopya ile geçtiğinden, küçük boyutlarda, yaklaşık 16 bayt olduğundan emin olmak istersiniz.

Bu eski bir konudur, ancak basit bir kıyaslama testi sağlamak istemiştir.

İki .cs dosyası oluşturdum:

public class TestClass
{
    public long ID { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

ve

public struct TestStruct
{
    public long ID { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

Kıyaslama testi:

• 1 TestClass oluştur
• 1 TestStruct oluştur
• 100 TestClass oluştur
• 100 TestStruct oluştur
• 10000 TestClass oluştur
• 10000 TestStruct oluştur

Sonuçlar:

BenchmarkDotNet=v0.12.0, OS=Windows 10.0.18362
Intel Core i5-8250U CPU 1.60GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
.NET Core SDK=3.1.101
[Host]     : .NET Core 3.1.1 (CoreCLR 4.700.19.60701, CoreFX 4.700.19.60801), X64 RyuJIT  [AttachedDebugger]
DefaultJob : .NET Core 3.1.1 (CoreCLR 4.700.19.60701, CoreFX 4.700.19.60801), X64 RyuJIT


|         Method |           Mean |         Error |        StdDev |     Ratio | RatioSD | Rank |    Gen 0 | Gen 1 | Gen 2 | Allocated |
|--------------- |---------------:|--------------:|--------------:|----------:|--------:|-----:|---------:|------:|------:|----------:|

|      UseStruct |      0.0000 ns |     0.0000 ns |     0.0000 ns |     0.000 |    0.00 |    1 |        - |     - |     - |         - |
|       UseClass |      8.1425 ns |     0.1873 ns |     0.1839 ns |     1.000 |    0.00 |    2 |   0.0127 |     - |     - |      40 B |
|   Use100Struct |     36.9359 ns |     0.4026 ns |     0.3569 ns |     4.548 |    0.12 |    3 |        - |     - |     - |         - |
|    Use100Class |    759.3495 ns |    14.8029 ns |    17.0471 ns |    93.144 |    3.24 |    4 |   1.2751 |     - |     - |    4000 B |
| Use10000Struct |  3,002.1976 ns |    25.4853 ns |    22.5920 ns |   369.664 |    8.91 |    5 |        - |     - |     - |         - |
|  Use10000Class | 76,529.2751 ns | 1,570.9425 ns | 2,667.5795 ns | 9,440.182 |  346.76 |    6 | 127.4414 |     - |     - |  400000 B |

Hmm ...

Çöp toplamayı, yapıların sınıflara karşı kullanımına karşı / argüman olarak kullanmam. Yönetilen yığın bir yığın gibi çalışır - bir nesne oluşturmak onu yığının en üstüne koyar, bu da yığın üzerine tahsis etmek kadar hızlıdır. Ek olarak, bir nesne kısa ömürlüdür ve bir GC döngüsünde hayatta kalmazsa, GC yalnızca hala erişilebilir olan bellekle çalıştığından, serbest bırakma serbesttir. (Arama MSDN, .NET bellek yönetimi hakkında bir dizi makale var, onlar için kazmak için çok tembelim).

Çoğu zaman bir yapı kullanıyorum, bunu yapmak için kendimi tekmeliyorum, çünkü daha sonra referans anlambilimine sahip olmanın işleri biraz daha basit hale getireceğini keşfediyorum.

Her neyse, yukarıda yayınlanan MSDN makalesindeki bu dört nokta iyi bir rehber gibi görünüyor.

Yapılar Yığın üzerinde değil, bu nedenle iş parçacığı açısından güvenlidir ve aktarım nesnesi desenini uygularken kullanılmalıdır, Yığın üzerinde uçucu oldukları nesneleri asla kullanmak istemezsiniz, bu durumda Çağrı Yığını'nı kullanmak istersiniz, buradaki cevapların çıkışından şaşırdığım bir yapı kullanmak için temel bir durum,

Bence en iyi cevap sadece özellikleri ve davranışları bir koleksiyon olduğunda özellikleri bir koleksiyon, sınıf bir yapı zaman yapılandırmak kullanmaktır.