Genel türlerden miras almak iyi bir uygulama mıdır?

List<string>Tür ek açıklamalarında veya StringListyerde kullanmak daha mı iyiStringList

class StringList : List<String> { /* no further code!*/ }

Ben koştu birkaç ait bu yer Irony .

Genel bir türden miras almak isteyebileceğiniz başka bir neden var.

Microsoft , yöntem imzalarında genel türlerin yuvalanmasından kaçınılmasını önerir .

Öyleyse, jeneriklerinizden bazıları için işletme-etki alanı tipi oluşturmak iyi bir fikirdir. Bir sahip olmak yerine, IEnumerable<IDictionary<string, MyClass>>bir tür oluşturun MyDictionary : IDictionary<string, MyClass>ve IEnumerable<MyDictionary>üyeniz çok daha okunaklı olan bir olur . Ayrıca, MyDictionary'yi bir çok yerde kullanmanıza izin vererek kodunuzun açıklığını artırır.

Bu, çok büyük bir avantaj gibi görünmeyebilir, ancak gerçek dünyadaki iş kodunda saçınızı ayakta tutacak jenerik ilaçlar gördüm. Gibi şeyler List<Tuple<string, Dictionary<int, List<Dictionary<string, List<double>>>>>. Bu jenerikin anlamı hiçbir şekilde açık değildir. Yine de, bir dizi açıkça yaratılmış türden yapılmışsa, orijinal geliştiricinin niyeti daha açık olacaktır. Dahası, eğer bu genel türün bir sebepten dolayı değişmesi gerekiyorsa, bu genel türün tüm örneklerini bulmak ve değiştirmek, türetilmiş sınıfta değiştirmekle karşılaştırıldığında, gerçek bir acı olabilir.

Son olarak, birisinin jeneriklerden türetilmiş kendi türlerini oluşturmak istemesinin başka bir nedeni var. Aşağıdaki sınıfları göz önünde bulundurun:

public class MyClass
{
    public ICollection<MyItems> MyItems { get; private set; }
    // plumbing code here
}

public class MyOtherClass
{
    public ICollection<MyItems> MyItemCache { get; private set; }
    // plumbing code here
}

public class MyConsumerClass
{
    public MyConsumerClass(ICollection<MyItems> myItems)
    {
        // use the collection
    }
}

Şimdi ICollection<MyItems>, MyConsumerClass için hangi kurucuya geçileceğini nasıl bilebiliriz? Biz türetilmiş sınıfları oluşturursanız class MyItems : ICollection<MyItems>ve class MyItemCache : ICollection<MyItems>, MyConsumerClass sonra aslında istediği iki koleksiyonları hangi derece spesifik olabilir. Bu daha sonra, iki koleksiyonu çok kolay çözebilen bir IoC kabı ile çok iyi çalışır. Ayrıca programcının daha doğru olmasını sağlar - MyConsumerClassherhangi bir ICollection ile çalışmak mantıklıysa , genel yapıcıyı alabilirler. Bununla birlikte, türetilmiş iki türden birini kullanmak hiçbir zaman mantıklı olmazsa, geliştirici constructor parametresini belirli türle sınırlayabilir.

Özet olarak, türleri genel türlerden türetmek faydalı olacaktır - uygun olan yerlerde daha açık kod sağlar ve okunabilirlik ve bakım kolaylığı sağlar.

Prensip olarak, genel türlerden miras almak ile başka herhangi bir şeyden miras almak arasında bir fark yoktur.

Ancak, neden dünyadaki herhangi bir sınıftan türetiyor ve başka bir şey eklemiyorsunuz?

C # 'yi çok iyi tanımıyorum, ancak typedefC ++ programcılarının genellikle birkaç sebepten dolayı kullandıkları tek yolun bu olduğuna inanıyorum :

• Kodunuzun açılı ayraçlar gibi görünmesini önler.
• İhtiyaçlarınız sonradan değişirse farklı altta bulunan kapları değiştirmenize izin verir ve bunu yapma hakkını saklı tuttuğunuzu açıkça belirtir.
• Bağlamda daha alakalı bir ad girmenizi sağlar.

Temelde sıkıcı ve genel isimleri seçerek son avantajı attılar, ancak diğer iki neden hala geçerli.

En az bir pratik sebep düşünebiliyorum.

Genel türlerden miras kalan (başka bir şey eklemeden bile) genel olmayan türlerin bildirilmesi, bu türlerin, aksi durumda kullanılamayacakları veya olması gerektiğinden daha karmaşık bir şekilde kullanılabileceği yerlerden kaynak gösterilmesini sağlar.

Bu tür bir durum, yalnızca genel olmayan türlerin kullanılabildiği yerlerde Visual Studio'daki Ayarlar editörü ile ayarları eklerken olur. Oraya giderseniz, tüm System.Collectionssınıfların uygun olduğunu göreceksiniz ancak System.Collections.Genericgeçerli olduğu için hiçbir koleksiyon görünmüyor.

Diğer bir durum ise WPF'deki türlerin XAML aracılığıyla başlatılmasıdır. 2009 öncesi şema kullanıldığında XML sözdiziminde tür argümanlarının iletilmesi için destek yoktur. Bu, 2006 şemasının yeni WPF projeleri için varsayılan gibi görünmesi gerçeğiyle daha da kötüleşmiştir.

Bence bazı tarihlere bakmalısın .

• C #, genel türleri olduğundan daha uzun süredir kullanılıyor.
• Verilen yazılımın tarihin bir noktasında kendi StringList'ine sahip olmasını bekliyorum.
• Bu, bir ArrayList'i sararak da uygulanmış olabilir.
• Ardından kod tabanını ileri taşımak için refactoring yapan biri.
• Ancak 1001 farklı dosyaya dokunmak istemiyordu, bu yüzden işi bitirin.

Aksi takdirde, Theodoros Chatzigiannakis en iyi cevaplara sahipti; örneğin, genel türleri anlamayan pek çok araç var. Veya belki de cevabını ve tarihini bir karışımı.

Bazı durumlarda, genel türlerin kullanılması mümkün değildir; örneğin, XAML'deki genel bir türe başvuruda bulunamazsınız. Bu durumlarda, başlangıçta kullanmak istediğiniz genel türden miras alan genel olmayan bir tür oluşturabilirsiniz.

Mümkünse, bundan kaçınırdım.

Bir typedef'in aksine, yeni bir tip yaratırsınız. StringList'i bir yönteme giriş parametresi olarak kullanırsanız, arayanlarınız a geçemez List<string>.

Ayrıca, kullanmak istediğiniz tüm yapıcıları , böyle bir yapıcıyı tanımlamasına new StringList(new[]{"a", "b", "c"})rağmen , StringList örneğinde söyleyemediğiniz bir örneği açıkça kopyalamanız gerekir List<T>.

Düzenle:

Kabul edilen cevap etki alanı modelinizde türetilmiş türleri kullanırken profesyonellerin üzerinde durur. Bu durumda potansiyel olarak yararlı olabileceklerini kabul ediyorum, yine de bizzat orada bile onlardan kaçınırdım.

Ancak, (bence) bunları asla halka açık bir API'de kullanmamalısınız, çünkü ya arayanızın hayatını zorlaştırır ya da israf performansını (genel olarak örtük dönüşümleri de pek sevmem).

Buna değer, Microsoft’un Roslyn derleyicisinde ve sınıfın adını bile değiştirmeden, genel bir sınıftan miras almanın bir örneği. (Bundan gerçekten şaşırmıştım, bunun gerçekten mümkün olup olmadığını görmek için araştırmamda sona erdi.)

CodeAnalysis projesinde bu tanımı bulabilirsiniz:

/// <summary>
/// Common base class for C# and VB PE module builder.
/// </summary>
internal abstract class PEModuleBuilder<TCompilation, TSourceModuleSymbol, TAssemblySymbol, TTypeSymbol, TNamedTypeSymbol, TMethodSymbol, TSyntaxNode, TEmbeddedTypesManager, TModuleCompilationState> : CommonPEModuleBuilder, ITokenDeferral
    where TCompilation : Compilation
    where TSourceModuleSymbol : class, IModuleSymbol
    where TAssemblySymbol : class, IAssemblySymbol
    where TTypeSymbol : class
    where TNamedTypeSymbol : class, TTypeSymbol, Cci.INamespaceTypeDefinition
    where TMethodSymbol : class, Cci.IMethodDefinition
    where TSyntaxNode : SyntaxNode
    where TEmbeddedTypesManager : CommonEmbeddedTypesManager
    where TModuleCompilationState : ModuleCompilationState<TNamedTypeSymbol, TMethodSymbol>
{
  ...
}

Sonra CSharpCodeanalysis projesinde bu tanım var:

internal abstract class PEModuleBuilder : PEModuleBuilder<CSharpCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, NoPia.EmbeddedTypesManager, ModuleCompilationState>
{
  ...
}

Bu jenerik olmayan PEModuleBuilder sınıfı, CSharpCodeanalysis projesinde yaygın olarak kullanılır ve bu projedeki birkaç sınıf doğrudan veya dolaylı olarak ondan miras alır.

Ve sonra BasicCodeanalysis projesinde şu tanım var:

Partial Friend MustInherit Class PEModuleBuilder
    Inherits PEModuleBuilder(Of VisualBasicCompilation, SourceModuleSymbol, AssemblySymbol, TypeSymbol, NamedTypeSymbol, MethodSymbol, SyntaxNode, NoPia.EmbeddedTypesManager, ModuleCompilationState)

İnşallah (umarım) Roslyn'in geniş C # bilgisi olan insanlar tarafından yazıldığını ve nasıl kullanılması gerektiğini varsayalım. Bunun bir teknik öneri olduğunu düşünüyorum.

Birisinin bunu kafamın üstünden çıkarmaya çalışmasının üç olası nedeni var:

1) Bildirimleri basitleştirmek için:

Elbette StringListve ListStringyaklaşık aynı uzunluktadırlar, ancak bunun yerine UserCollection, aslında Dictionary<Tuple<string,Type>, IUserData<Dictionary,MySerializer>>ya da başka bir büyük genel örnekle çalıştığınızı hayal edin .

2) AOT'a yardım etmek için:

Bazen, Tam Zamanında derlemeyi değil, Zaman İçi derlemesini değil, örneğin iOS için geliştirmeyi kullanmanız gerekir. Bazen AOT derleyicisi önceden tüm jenerik türleri bulmakta zorlanıyor ve bu bir ipucu sağlama girişimi olabilir.

3) İşlevsellik eklemek veya bağımlılığı kaldırmak için:

Belki de uygulamak istedikleri StringList(uzatma yönteminde gizlenmiş, henüz eklenmemiş veya tarihi geçmiş olabilir) ya da List<string>miras almadan ekleyemeyecekleri ya da onunla kirletmek istemedikleri belirli bir işlevi List<string>vardır. .

Alternatif olarak StringList, pistin aşağı doğru uygulanmasını değiştirmek isteyebilirler , bu yüzden sınıfı sadece bir işaretleyici olarak kullandım (genellikle bunun için arayüzler yaparsınız / kullanırsınız IList).

Ayrıca, bu kodu bir dil çözümleyici olan Irony'de bulduğunuzu da unutmayın - oldukça sıradışı bir uygulama. Bunun kullanılmasının özel bir nedeni olabilir.

Bu örnekler, böyle bir bildiri yazmak için meşru sebepler olabileceğini göstermektedir - çok yaygın olmasa bile. Her şeyde olduğu gibi birkaç seçenek düşünün ve o sırada sizin için en uygun olanı seçin.

Kaynak koduna bir göz attıysanız, seçenek 3 görünür - nedeni budur; işlevsellik eklemek / koleksiyonları özelleştirmek için bu tekniği kullanırlar:

public class StringList : List<string> {
    public StringList() { }
    public StringList(params string[] args) {
      AddRange(args);
    }
    public override string ToString() {
      return ToString(" ");
    }
    public string ToString(string separator) {
      return Strings.JoinStrings(separator, this);
    }
    //Used in sorting suffixes and prefixes; longer strings must come first in sort order
    public static int LongerFirst(string x, string y) {
      try {//in case any of them is null
        if (x.Length > y.Length) return -1;
      } catch { }
      if (x == y) return 0;
      return 1; 
    }

Bunun iyi bir uygulama olmadığını söyleyebilirim.

List<string>"genel bir dizge listesi" iletişim kurar. Açıkça List<string> uzantı yöntemleri uygulanır. Anlamak için daha az karmaşıklık gerekir; sadece Liste gereklidir.

StringList"ayrı bir sınıfa ihtiyaç" olduğunu bildirir. Belki List<string> uzatma yöntemleri de geçerlidir (bunun için gerçek tip uygulamasını kontrol edin). Kodu anlamak için daha fazla karmaşıklık gerekir; Liste ve türetilmiş sınıf uygulama bilgisi gereklidir.