Delphi Sınıfı C#

Question

Bu sorunun daha önce sorulmuş olduğunu biliyorum, ancak henüz kısa ve net bir cevap görmedim, bu yüzden bu soruyu kaldırmayacaklarını umuyorum ve şimdi net bir cevap alacağım:

Şu anda C# 5.0; .NET 4.5; VS 2012. C# ile çok yapmam rağmen çoğunlukla bir Delphi adamım. Şimdi

unit uFactory; 

interface 


type 

    TClassofMyClass = class of TMyClass; 
    TFactoryDict = TDictionary<TMyEnum, TClassofMyClass>; 

var fDict:TFactoryDict; 

implementation 

procedure initDict; 
begin 

    fDict:=TFactoryDict.create; 
    fDict.add(myEnum1, TMyClass1); 
    fDict.add(myEnum2, TMyClass2); 
    fDict.add(myEnum3, TMyClass3); 

end; 


function Factory(const aEnum: TMyEnum): TMyClass; 

var 

    ClassofMyClass: TClassofMyClass; 

begin 

    if fDict.TryGetValue(aEnum, ClassofMyClass) then 

    result := ClassofMyClass.Create(aParam); 

end; 

end. 

:

Delphi ben tasarımın aşağıdaki tür (COK BURADA BASİTLEŞTİRİLMİŞ) kullanan sınıf fabrikaların yüzlerce yazdım NASIL C# böyle bir şey yapacağız ?! C# türünde NO 'sınıfı var gibi görünüyor. Bir şey mi eksik? Bu tip bir sınıf fabrikasını C# 'da basit ve zarif bir şekilde nasıl uygularım? Bu tasarım Python'da da uygulanabilir - neden C# daha kötü olmalı ?!

Answer 1

Sen Tip kullanabilirsiniz:

Dictionary<ClassEnum, Type> TypeDictionary = new Dictionary<ClassEnum, Type>(); 

public void InitDictionary() 
{ 
    TypeDictionary.Add(ClassEnum.FirstClass, typeof(FirstClass)); 
    //etc... 
} 

public object Factory(ClassEnum type) 
{ 
    if (!TypeDictionary.ContainsKey(type)) 
     return null; 

    var constructor = TypeDictionary[type].GetConstructor(....); 
    return constructor.Invoke(....); 
} 

Ama genel yöntemi kullanmak gerektiğini düşünüyorum:

public T Factory<T>(params object[] args): where T is MyBaseClass 
{ 
    var argList = new List<object>(args); 
    var type = typeof(T); 
    var argtypes = argList.Select(o => o.GetType()).ToArray(); 
    var constructor = type.GetConstructor(argtypes); 
    return constructor.Invoke(args) as T; 
} 

Ve: İşte

public T Factory<T>(): where T is MyBaseClass 
{ 
    var type = typeof(T); 
    var constructor = type.GetConstructor(....); 
    return constructor.Invoke(....) as T; 
} 

parametreli yapımı için bir çeşittir Tabii; bunun, eşleşen yapıcısı bulamazsa İlk örnekte olduğu gibi, bu ... TMyClass ait

Answer 2

Eğer doğru anladıysan, statik bir sınıfa başvurmak istiyorsan, düzeltin. Bu C# mümkün değildir. fabrika yöntemi uygulamasının

sadece bir örnek: http://www.codeproject.com/Tips/328826/implementing-Factory-Method-in-Csharp

Answer 3

C# dili meta sınıfları desteklemez.

Fabrikanızı başka bir şekilde uygulamak zorundasınız. Tek yönlü bir enum üzerinde bir switch deyimi kullanmaktır:

switch (aEnum) 
{ 
    case myEnum1: 
     return new MyClass1(); 
    case myEnum2: 
     return new MyClass2(); 
    ..... 
} 

başka sık kullanılan seçenek yapmaya alışık ne daha yakın kod yazmak sağlayacak yansıması ile yapmaktır.

Ayrıca, bir başka seçenek de sınıfınızın sözlüğünü, nesnenizin yeni bir örneğini döndüren delegelerin sözlüğü ile değiştirmektir. Bu seçenek lambda sözdizimi ile çok temiz kod verir.

Yansımanın dezavantajı, derleme zamanı tipi güvenliğinden vazgeçmenizdir. Bu yüzden, yansıma tabanlı yaklaşım, söz konusu sorudaki Delphi koduna muhtemelen en yakın olsa da, kişisel olarak tercih edeceğim yol değil.

Delphi çözümünüzü bu yaklaşımı istemeyen bir dile sokmaya çalışmak yerine, en idiomatik C# çözümünü aramanızı öneririm. Sınıf fabrikası için bir web araması ile başlayın.

Answer 4

class Potato 
    { 
    } 

    class Potato1 : Potato 
    { 
     public Potato1(object[] param) { } 
    } 

    class Potato2 : Potato 
    { 
     public Potato2(object[] param); 
    } 

    enum MyEnum 
    { 
     E1, E2 
    } 

    Dictionary<MyEnum, Func<object[], Potato>> dict = new Dictionary<MyEnum, Func<object[], Potato>>(){ 
      {MyEnum.E1,(d)=>new Potato1(d)}, 
      {MyEnum.E2,(d)=>new Potato2(d)} 
     }; 

    Potato Factory(MyEnum e, object[] param) 
    { 
     return dict[e](param); 
    }