C # 'da fabrika deseni: Bir nesne örneğinin yalnızca bir fabrika sınıfı tarafından oluşturulabileceğinden nasıl emin olunur?

Son zamanlarda kodumun bir kısmını güvenli hale getirmeyi düşünüyordum. Bir nesnenin hiçbir zaman doğrudan yaratılamayacağından, ancak sadece fabrika sınıfının bir yöntemi aracılığıyla nasıl emin olunabileceğini merak ediyorum. Diyelim ki bir "iş nesnesi" sınıfım var ve bu sınıfın herhangi bir örneğinin geçerli bir dahili duruma sahip olduğundan emin olmak istiyorum. Bunu başarmak için, bir nesne oluşturmadan önce, muhtemelen yapıcısında bazı kontroller yapmam gerekecek. Bu kontrolün iş mantığının bir parçası olmasını istediğime karar verene kadar sorun değil. Öyleyse, bir iş nesnesinin yalnızca iş mantığı sınıfımdaki bazı yöntemlerle, ancak asla doğrudan yaratılamaz olmasını nasıl ayarlayabilirim? C ++ 'nın eski güzel bir "arkadaş" anahtar kelimesini kullanmak için ilk doğal arzu C # ile yetersiz kalacaktır. Bu yüzden başka seçeneklere ihtiyacımız var ...

Bir örnek deneyelim:

public MyBusinessObjectClass
{
    public string MyProperty { get; private set; }

    public MyBusinessObjectClass (string myProperty)
    {
        MyProperty = myProperty;
    }
}

public MyBusinessLogicClass
{
    public MyBusinessObjectClass CreateBusinessObject (string myProperty)
    {
        // Perform some check on myProperty

        if (true /* check is okay */)
            return new MyBusinessObjectClass (myProperty);

        return null;
    }
}

Girdiyi kontrol etmeden MyBusinessObjectClass örneğini doğrudan oluşturabileceğinizi hatırlayana kadar her şey yolunda. Bu teknik olasılığı tamamen dışlamak istiyorum.

Peki, toplum bu konuda ne düşünüyor?

Görünüşe göre, nesneyi oluşturmadan önce biraz iş mantığı çalıştırmak istiyorsunuz - öyleyse neden "BusinessClass" içinde tüm kirli "myProperty" denetimini yapan ve kurucuyu özel yapan statik bir yöntem oluşturmuyorsunuz?

public BusinessClass
{
    public string MyProperty { get; private set; }

    private BusinessClass()
    {
    }

    private BusinessClass(string myProperty)
    {
        MyProperty = myProperty;
    }

    public static BusinessClass CreateObject(string myProperty)
    {
        // Perform some check on myProperty

        if (/* all ok */)
            return new BusinessClass(myProperty);

        return null;
    }
}

Bunu aramak oldukça basit olurdu:

BusinessClass objBusiness = BusinessClass.CreateObject(someProperty);

Yapıcıyı özel ve fabrikayı iç içe bir tür yapabilirsiniz:

public class BusinessObject
{
    private BusinessObject(string property)
    {
    }

    public class Factory
    {
        public static BusinessObject CreateBusinessObject(string property)
        {
            return new BusinessObject(property);
        }
    }
}

Bu işe yarar çünkü yuvalanmış türlerin, kendi çevreleyen türlerinin özel üyelerine erişimi vardır. Biraz kısıtlayıcı olduğunu biliyorum ama umarım yardımcı olur ...

Ya da, gerçekten süslü olmak istiyorsanız, kontrolü tersine çevirin: Sınıfın fabrikayı geri göndermesini ve fabrikayı, sınıfı yaratabilecek bir temsilciyle donatmasını sağlayın.

public class BusinessObject
{
  public static BusinessObjectFactory GetFactory()
  {
    return new BusinessObjectFactory (p => new BusinessObject (p));
  }

  private BusinessObject(string property)
  {
  }
}

public class BusinessObjectFactory
{
  private Func<string, BusinessObject> _ctorCaller;

  public BusinessObjectFactory (Func<string, BusinessObject> ctorCaller)
  {
    _ctorCaller = ctorCaller;
  }

  public BusinessObject CreateBusinessObject(string myProperty)
  {
    if (...)
      return _ctorCaller (myProperty);
    else
      return null;
  }
}

:)

MyBusinessObjectClass sınıfınızdaki kurucuyu dahili yapabilir ve onu ve fabrikayı kendi derlemelerine taşıyabilirsiniz. Artık sınıfın bir örneğini yalnızca fabrika oluşturabilmelidir.

Jon'un önerdiğinin yanı sıra, fabrika yöntemini (kontrol dahil) ilk etapta BusinessObject'in statik bir yöntemi olabilir. Ardından, kurucuyu özel yapın ve diğer herkes statik yöntemi kullanmaya zorlanacaktır.

public class BusinessObject
{
  public static Create (string myProperty)
  {
    if (...)
      return new BusinessObject (myProperty);
    else
      return null;
  }
}

Ama asıl soru şu - neden bu şarta sahipsiniz? Fabrika veya fabrika yöntemini sınıfa taşımak kabul edilebilir mi?

Yıllar sonra bu soruldu ve gördüğüm tüm cevaplar maalesef size doğrudan bir cevap vermek yerine kodunuzu nasıl yapmanız gerektiğini söylüyor. Aradığınız asıl cevap, sınıflarınızın özel bir kurucu, ancak genel bir anlık oluşturucuya sahip olmasıdır; bu, yalnızca diğer mevcut örneklerden yeni örnekler oluşturabileceğiniz anlamına gelir ... yalnızca fabrikada mevcuttur:

Sınıflarınız için arayüz:

public interface FactoryObject
{
    FactoryObject Instantiate();
}

Senin sınıfın:

public class YourClass : FactoryObject
{
    static YourClass()
    {
        Factory.RegisterType(new YourClass());
    }

    private YourClass() {}

    FactoryObject FactoryObject.Instantiate()
    {
        return new YourClass();
    }
}

Ve nihayet fabrika:

public static class Factory
{
    private static List<FactoryObject> knownObjects = new List<FactoryObject>();

    public static void RegisterType(FactoryObject obj)
    {
        knownObjects.Add(obj);
    }

    public static T Instantiate<T>() where T : FactoryObject
    {
        var knownObject = knownObjects.Where(x => x.GetType() == typeof(T));
        return (T)knownObject.Instantiate();
    }
}

Ardından, örnekleme için ekstra parametrelere ihtiyacınız varsa veya oluşturduğunuz örnekleri önceden işlemek için bu kodu kolayca değiştirebilirsiniz. Ve bu kod, sınıf oluşturucu özel olduğu için fabrika üzerinden başlatmayı zorlamanıza izin verecektir.

Diğer bir (hafif) seçenek ise BusinessObject sınıfında statik bir fabrika yöntemi yapmak ve yapıcıyı özel tutmaktır.

public class BusinessObject
{
    public static BusinessObject NewBusinessObject(string property)
    {
        return new BusinessObject();
    }

    private BusinessObject()
    {
    }
}

Yani, istediğim şey "saf" bir şekilde yapılamaz gibi görünüyor. Mantık sınıfına her zaman bir tür "geri arama" dır.

Belki bunu basit bir şekilde yapabilirim, sadece nesne sınıfında bir yapıcı yöntemi yapın, önce girişi kontrol etmek için mantık sınıfını çağırın?

public MyBusinessObjectClass
{
    public string MyProperty { get; private set; }

    private MyBusinessObjectClass (string myProperty)
    {
        MyProperty  = myProperty;
    }

    pubilc static MyBusinessObjectClass CreateInstance (string myProperty)
    {
        if (MyBusinessLogicClass.ValidateBusinessObject (myProperty)) return new MyBusinessObjectClass (myProperty);

        return null;
    }
}

public MyBusinessLogicClass
{
    public static bool ValidateBusinessObject (string myProperty)
    {
        // Perform some check on myProperty

        return CheckResult;
    }
}

Bu şekilde, iş nesnesi doğrudan oluşturulamaz ve iş mantığındaki genel kontrol yöntemi de zarar vermez.

Arayüzler ve uygulamalar arasında iyi bir ayrım olması durumunda,
korumalı-yapıcı-genel-başlatıcı modeli çok düzgün bir çözüme izin verir.

Bir iş nesnesi verildiğinde:

public interface IBusinessObject { }

class BusinessObject : IBusinessObject
{
    public static IBusinessObject New() 
    {
        return new BusinessObject();
    }

    protected BusinessObject() 
    { ... }
}

ve bir iş fabrikası:

public interface IBusinessFactory { }

class BusinessFactory : IBusinessFactory
{
    public static IBusinessFactory New() 
    {
        return new BusinessFactory();
    }

    protected BusinessFactory() 
    { ... }
}

BusinessObject.New()Başlatıcıda yapılan aşağıdaki değişiklik çözümü verir:

class BusinessObject : IBusinessObject
{
    public static IBusinessObject New(BusinessFactory factory) 
    { ... }

    ...
}

Burada, BusinessObject.New()başlatıcıyı aramak için somut iş fabrikasına bir referans gereklidir . Ancak gerekli referansa sahip olan tek kişi iş fabrikasının kendisidir.

Oluşturabilir tek: Biz istediğini aldı BusinessObjectolduğunu BusinessFactory.

    public class HandlerFactory: Handler
    {
        public IHandler GetHandler()
        {
            return base.CreateMe();
        }
    }

    public interface IHandler
    {
        void DoWork();
    }

    public class Handler : IHandler
    {
        public void DoWork()
        {
            Console.WriteLine("hander doing work");
        }

        protected IHandler CreateMe()
        {
            return new Handler();
        }

        protected Handler(){}
    }

    public static void Main(string[] args)
    {
        // Handler handler = new Handler();         - this will error out!
        var factory = new HandlerFactory();
        var handler = factory.GetHandler();

        handler.DoWork();           // this works!
    }

Fabrikayı etki alanı sınıfıyla aynı derlemeye koyar ve etki alanı sınıfının yapıcısını dahili olarak işaretlerdim. Bu şekilde, alanınızdaki herhangi bir sınıf bir örnek oluşturabilir, ancak kendinize güvenmiyorsunuz, değil mi? Etki alanı katmanı dışında kod yazan herkes fabrikanızı kullanmak zorunda kalacaktır.

public class Person
{
  internal Person()
  {
  }
}

public class PersonFactory
{
  public Person Create()
  {
    return new Person();
  }  
}

Ancak, yaklaşımınızı sorgulamalıyım :-)

Person sınıfınızın yaratılırken geçerli olmasını istiyorsanız, kodu kurucuya koymanız gerektiğini düşünüyorum.

public class Person
{
  public Person(string firstName, string lastName)
  {
    FirstName = firstName;
    LastName = lastName;
    Validate();
  }
}

Bu çözüm off dayanır munificents yapıcı bir belirteç kullanma fikri. Bu cevapta tamamlanan nesnenin yalnızca fabrika tarafından oluşturulduğundan emin olun (C #)

  public class BusinessObject
    {
        public BusinessObject(object instantiator)
        {
            if (instantiator.GetType() != typeof(Factory))
                throw new ArgumentException("Instantiator class must be Factory");
        }

    }

    public class Factory
    {
        public BusinessObject CreateBusinessObject()
        {
            return new BusinessObject(this);
        }
    }

Farklı ödünleşimlere sahip çoklu yaklaşımlardan bahsedilmiştir.

• Fabrika sınıfını özel olarak inşa edilen sınıfa yerleştirmek, fabrikanın yalnızca 1 sınıf oluşturmasına izin verir. Bu noktada bir Createyöntem ve özel bir hocayla daha iyi durumda olursunuz .
• Miras ve korumalı bir ctor kullanmak da aynı soruna sahiptir.

Fabrikayı, genel oluşturuculara sahip özel yuvalanmış sınıfları içeren kısmi bir sınıf olarak önermek istiyorum. Fabrikanızın inşa ettiği nesneyi% 100 gizliyorsunuz ve yalnızca bir veya daha fazla arayüz aracılığıyla seçtiğiniz şeyi açığa çıkarıyorsunuz.

Bunun için duyduğum kullanım örneği, fabrikadaki örneklerin% 100'ünü izlemek istediğinizde olacaktır. Bu tasarım, fabrikanın "fabrikada" tanımlanan "kimyasallar" örneklerini oluşturmaya erişimi dışında kimseyi garanti etmez ve bunu başarmak için ayrı bir montaj ihtiyacını ortadan kaldırır.

== ChemicalFactory.cs ==
partial class ChemicalFactory {
    private  ChemicalFactory() {}

    public interface IChemical {
        int AtomicNumber { get; }
    }

    public static IChemical CreateOxygen() {
        return new Oxygen();
    }
}


== Oxygen.cs ==
partial class ChemicalFactory {
    private class Oxygen : IChemical {
        public Oxygen() {
            AtomicNumber = 8;
        }
        public int AtomicNumber { get; }
    }
}



== Program.cs ==
class Program {
    static void Main(string[] args) {
        var ox = ChemicalFactory.CreateOxygen();
        Console.WriteLine(ox.AtomicNumber);
    }
}

Neden "iş mantığını" "iş nesnesi" nden ayırmak istediğinizi anlamıyorum. Bu, nesne yöneliminde bir bozulma gibi geliyor ve bu yaklaşımı benimseyerek kendinizi düğümlere bağlamış olacaksınız.

Sorundan daha kötü olmayan bir çözüm olduğunu sanmıyorum, yukarıda belirtilenlerin tümü, IMHO'nun daha kötü bir sorun olduğu ve insanların sadece fabrikayı nesnenizi kullanmaları için çağırmasını engellemeyecek bir kamu statik fabrikasına ihtiyaç duyuyor - hiçbir şeyi gizlemiyor. Bir arabirimi ortaya çıkarmak ve / veya yapıcıyı yapabiliyorsanız dahili olarak tutmak en iyisidir, bu, derleme güvenilir kod olduğundan en iyi korumadır.

Bir seçenek, bir fabrikayı IOC konteyneri gibi bir yere kaydeden statik bir kurucuya sahip olmaktır.

İşte "sırf yapabilmen, yapman gerektiği anlamına gelmez" damarındaki başka bir çözüm ...

İş nesnesi kurucusunu özel tutma ve fabrika mantığını başka bir sınıfa koyma gereksinimlerini karşılar. Bundan sonra biraz kabataslak oluyor.

Factory sınıfı, iş nesneleri oluşturmak için statik bir yönteme sahiptir. Özel oluşturucuyu çağıran statik korumalı bir yapı yöntemine erişmek için iş nesnesi sınıfından türetilir.

Fabrika soyut olduğundan bir örneğini gerçekten oluşturamazsınız (çünkü aynı zamanda bir iş nesnesi olurdu, bu yüzden tuhaf olurdu) ve özel bir kurucuya sahiptir, böylece müşteri kodu ondan türetilemez.

Engellenmeyen şey, istemci kodunun da iş nesnesi sınıfından türetilmesi ve korumalı (ancak doğrulanmamış) statik yapı yöntemini çağırmasıdır. Daha da kötüsü, fabrika sınıfının ilk etapta derlenmesini sağlamak için eklememiz gereken korumalı varsayılan kurucuyu çağırmak. (Tesadüfen, fabrika sınıfını iş nesnesi sınıfından ayıran herhangi bir modelde bir sorun olması muhtemeldir.)

Aklı başında kimseye böyle bir şey yapmasını önermeye çalışmıyorum, ama bu ilginç bir egzersizdi. FWIW, benim tercih ettiğim çözüm, dahili bir kurucu ve koruma olarak montaj sınırını kullanmak olacaktır.

using System;

public class MyBusinessObjectClass
{
    public string MyProperty { get; private set; }

    private MyBusinessObjectClass(string myProperty)
    {
        MyProperty = myProperty;
    }

    // Need accesible default constructor, or else MyBusinessObjectFactory declaration will generate:
    // error CS0122: 'MyBusinessObjectClass.MyBusinessObjectClass(string)' is inaccessible due to its protection level
    protected MyBusinessObjectClass()
    {
    }

    protected static MyBusinessObjectClass Construct(string myProperty)
    {
        return new MyBusinessObjectClass(myProperty);
    }
}

public abstract class MyBusinessObjectFactory : MyBusinessObjectClass
{
    public static MyBusinessObjectClass CreateBusinessObject(string myProperty)
    {
        // Perform some check on myProperty

        if (true /* check is okay */)
            return Construct(myProperty);

        return null;
    }

    private MyBusinessObjectFactory()
    {
    }
}

Bu çözüm hakkında bazı düşünceler duymak isterim. 'MyClassPrivilegeKey' yaratabilen tek şey fabrikadır. ve 'MyClass' yapıcıda gerektirir. Böylelikle özel yükleniciler / fabrikaya "kayıt" üzerine yansımadan kaçınılmış olur.

public static class Runnable
{
    public static void Run()
    {
        MyClass myClass = MyClassPrivilegeKey.MyClassFactory.GetInstance();
    }
}

public abstract class MyClass
{
    public MyClass(MyClassPrivilegeKey key) { }
}

public class MyClassA : MyClass
{
    public MyClassA(MyClassPrivilegeKey key) : base(key) { }
}

public class MyClassB : MyClass
{
    public MyClassB(MyClassPrivilegeKey key) : base(key) { }
}


public class MyClassPrivilegeKey
{
    private MyClassPrivilegeKey()
    {
    }

    public static class MyClassFactory
    {
        private static MyClassPrivilegeKey key = new MyClassPrivilegeKey();

        public static MyClass GetInstance()
        {
            if (/* some things == */true)
            {
                return new MyClassA(key);
            }
            else
            {
                return new MyClassB(key);
            }
        }
    }
}