รูปแบบโรงงานใน C #: จะแน่ใจได้อย่างไรว่าอินสแตนซ์ออบเจ็กต์สามารถสร้างได้โดยคลาสโรงงานเท่านั้น

เมื่อเร็ว ๆ นี้ฉันคิดเกี่ยวกับการรักษาความปลอดภัยของรหัสของฉัน ฉันอยากรู้ว่าเราจะแน่ใจได้อย่างไรว่าจะไม่สามารถสร้างวัตถุได้โดยตรง แต่ด้วยวิธีการบางอย่างของคลาสโรงงานเท่านั้น สมมติว่าฉันมีคลาส "วัตถุทางธุรกิจ" และฉันต้องการตรวจสอบให้แน่ใจว่าอินสแตนซ์ใด ๆ ของคลาสนี้จะมีสถานะภายในที่ถูกต้อง เพื่อให้บรรลุสิ่งนี้ฉันจะต้องทำการตรวจสอบบางอย่างก่อนที่จะสร้างวัตถุอาจอยู่ในตัวสร้าง ทั้งหมดนี้ไม่เป็นไรจนกว่าฉันจะตัดสินใจว่าต้องการให้การตรวจสอบนี้เป็นส่วนหนึ่งของตรรกะทางธุรกิจ ดังนั้นฉันจะจัดให้ออบเจ็กต์ทางธุรกิจสามารถสร้างได้โดยใช้วิธีการบางอย่างในคลาสตรรกะทางธุรกิจของฉัน แต่ไม่สามารถสร้างได้โดยตรงได้อย่างไร ความปรารถนาแรกตามธรรมชาติที่จะใช้คีย์เวิร์ด "เพื่อน" เก่าที่ดีของ C ++ จะขาดหายไปกับ C # ดังนั้นเราจึงต้องการทางเลือกอื่น ...

ลองดูตัวอย่าง:

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;
    }
}

ไม่เป็นไรจนกว่าคุณจะจำได้ว่าคุณยังสามารถสร้างอินสแตนซ์ MyBusinessObjectClass ได้โดยตรงโดยไม่ต้องตรวจสอบอินพุต ฉันต้องการยกเว้นความเป็นไปได้ทางเทคนิคนั้นทั้งหมด

แล้วชุมชนคิดอย่างไรเกี่ยวกับเรื่องนี้?

ดูเหมือนว่าคุณต้องการเรียกใช้ตรรกะทางธุรกิจบางอย่างก่อนที่จะสร้างวัตถุดังนั้นทำไมคุณไม่เพียงสร้างวิธีการแบบคงที่ใน "BusinessClass" ซึ่งจะทำการตรวจสอบ "myProperty" ที่สกปรกทั้งหมดและทำให้ตัวสร้างเป็นแบบส่วนตัว

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;
    }
}

เรียกได้ว่าค่อนข้างตรงไปตรงมา:

BusinessClass objBusiness = BusinessClass.CreateObject(someProperty);

คุณสามารถทำให้ตัวสร้างเป็นแบบส่วนตัวและโรงงานเป็นประเภทที่ซ้อนกัน:

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

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

สิ่งนี้ใช้ได้เนื่องจากชนิดที่ซ้อนกันมีสิทธิ์เข้าถึงสมาชิกส่วนตัวของประเภทการปิดล้อม ฉันรู้ว่ามันค่อนข้าง จำกัด แต่หวังว่ามันจะช่วยได้ ...

หรือถ้าคุณต้องการที่จะจินตนาการจริงๆให้กลับการควบคุม: ให้ชั้นเรียนส่งคืนโรงงานและใช้โรงงานกับตัวแทนที่สามารถสร้างคลาสได้

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 ของคุณภายในและย้ายมันและโรงงานไปยังแอสเซมบลีของตนเอง ตอนนี้มีเพียงโรงงานเท่านั้นที่สามารถสร้างอินสแตนซ์ของคลาสได้

นอกเหนือจากสิ่งที่จอนแนะนำแล้วคุณยังสามารถกำหนดให้วิธีการของโรงงาน (รวมถึงการตรวจสอบ) เป็นวิธีการแบบคงที่ของ BusinessObject ได้ในตอนแรก จากนั้นให้ตัวสร้างเป็นแบบส่วนตัวและทุกคนจะถูกบังคับให้ใช้วิธีการแบบคงที่

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

แต่คำถามที่แท้จริงคือ - ทำไมคุณถึงมีข้อกำหนดนี้? เป็นที่ยอมรับในการย้ายโรงงานหรือวิธีการโรงงานไปในชั้นเรียนหรือไม่?

หลายปีผ่านไปสิ่งนี้ถูกถามและคำตอบทั้งหมดที่ฉันเห็นนั้นน่าเสียดายที่บอกคุณว่าคุณควรทำโค้ดของคุณอย่างไรแทนที่จะให้คำตอบที่ตรงไปตรงมา คำตอบที่แท้จริงที่คุณกำลังมองหาคือการมีคลาสของคุณที่มีคอนสตรัคเตอร์ส่วนตัว แต่เป็นอินสแตนซ์สาธารณะซึ่งหมายความว่าคุณสามารถสร้างอินสแตนซ์ใหม่จากอินสแตนซ์อื่น ๆ ที่มีอยู่เท่านั้น ... ที่มีให้ในโรงงานเท่านั้น:

อินเทอร์เฟซสำหรับชั้นเรียนของคุณ:

public interface FactoryObject
{
    FactoryObject Instantiate();
}

ชั้นเรียนของคุณ:

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

    private YourClass() {}

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

และในที่สุดโรงงาน:

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();
    }
}

จากนั้นคุณสามารถแก้ไขโค้ดนี้ได้อย่างง่ายดายหากคุณต้องการพารามิเตอร์เพิ่มเติมสำหรับอินสแตนซ์หรือเพื่อประมวลผลอินสแตนซ์ที่คุณสร้างไว้ล่วงหน้า และรหัสนี้จะช่วยให้คุณบังคับใช้อินสแตนซ์ผ่านโรงงานเนื่องจากตัวสร้างคลาสเป็นแบบส่วนตัว

อีกทางเลือกหนึ่ง (น้ำหนักเบา) คือการสร้างวิธีโรงงานแบบคงที่ในคลาส BusinessObject และทำให้ตัวสร้างเป็นแบบส่วนตัว

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

    private BusinessObject()
    {
    }
}

ดังนั้นดูเหมือนว่าสิ่งที่ฉันต้องการไม่สามารถทำได้ด้วยวิธีที่ "บริสุทธิ์" มันมักจะ "เรียกกลับ" ไปที่คลาสตรรกะ

บางทีฉันอาจทำได้ด้วยวิธีง่ายๆเพียงแค่สร้างเมธอด contructor ในคลาสอ็อบเจ็กต์ก่อนเรียกคลาสลอจิกเพื่อตรวจสอบอินพุต?

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;
    }
}

ด้วยวิธีนี้วัตถุทางธุรกิจไม่สามารถสร้างได้โดยตรงและวิธีการตรวจสอบสาธารณะในตรรกะทางธุรกิจจะไม่เป็นอันตรายเช่นกัน

ในกรณีของการแยกที่ดีระหว่างอินเทอร์เฟซและการใช้งาน
Protected-constructor-public-initializer ช่วยให้สามารถแก้ปัญหาได้อย่างเรียบร้อย

ให้วัตถุทางธุรกิจ:

public interface IBusinessObject { }

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

    protected BusinessObject() 
    { ... }
}

และโรงงานธุรกิจ:

public interface IBusinessFactory { }

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

    protected BusinessFactory() 
    { ... }
}

การเปลี่ยนแปลงBusinessObject.New()initializer ต่อไปนี้ช่วยแก้ปัญหา:

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

    ...
}

ที่นี่จำเป็นต้องมีการอ้างอิงถึงโรงงานธุรกิจคอนกรีตเพื่อเรียกตัวBusinessObject.New()เริ่มต้น แต่ผู้เดียวที่มีข้อมูลอ้างอิงที่จำเป็นคือโรงงานของธุรกิจเอง

เรามีสิ่งที่เราต้องการ: เพียงคนเดียวที่สามารถสร้างเป็นBusinessObjectBusinessFactory

    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!
    }

ฉันจะใส่โรงงานไว้ในแอสเซมบลีเดียวกันกับคลาสโดเมนและทำเครื่องหมายตัวสร้างคลาสโดเมนภายใน ด้วยวิธีนี้คลาสใดก็ได้ในโดเมนของคุณอาจสร้างอินสแตนซ์ได้ แต่คุณเชื่อว่าตัวเองจะไม่ทำใช่ไหม ใครก็ตามที่เขียนโค้ดนอกเลเยอร์โดเมนจะต้องใช้โรงงานของคุณ

public class Person
{
  internal Person()
  {
  }
}

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

อย่างไรก็ตามฉันต้องตั้งคำถามกับแนวทางของคุณ :-)

ฉันคิดว่าถ้าคุณต้องการให้คลาส Person ของคุณถูกต้องเมื่อสร้างคุณต้องใส่รหัสในตัวสร้าง

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

การแก้ปัญหานี้จะตามออกmunificentsคิดของการใช้สัญลักษณ์ในการสร้าง ทำในคำตอบนี้ให้แน่ใจว่าวัตถุที่สร้างโดยโรงงานเท่านั้น (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);
        }
    }

มีการกล่าวถึงหลายวิธีที่มีการแลกเปลี่ยนที่แตกต่างกัน

• การซ้อนคลาสโรงงานในคลาสที่สร้างแบบส่วนตัวจะอนุญาตให้โรงงานสร้างคลาสได้ 1 คลาสเท่านั้น ณ จุดนั้นคุณควรใช้Createวิธีการและ ctor ส่วนตัวดีกว่า
• การใช้มรดกและ ctor ที่ได้รับการป้องกันมีปัญหาเดียวกัน

ฉันต้องการเสนอโรงงานเป็นชั้นเรียนบางส่วนที่มีชั้นเรียนที่ซ้อนกันส่วนตัวพร้อมตัวสร้างสาธารณะ คุณกำลังซ่อนวัตถุที่โรงงานของคุณกำลังสร้าง 100% และเปิดเผยเฉพาะสิ่งที่คุณเลือกผ่านอินเทอร์เฟซเดียวหรือหลายอินเทอร์เฟซ

กรณีการใช้งานที่ฉันได้ยินมาคือเมื่อคุณต้องการติดตามอินสแตนซ์ 100% ในโรงงาน การออกแบบนี้รับประกันว่าไม่มีใครนอกจากโรงงานสามารถเข้าถึงการสร้างอินสแตนซ์ของ "สารเคมี" ที่กำหนดไว้ใน "โรงงาน" และไม่จำเป็นต้องมีการประกอบแยกต่างหากเพื่อให้บรรลุเป้าหมายนั้น

== 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);
    }
}

ฉันไม่เข้าใจว่าทำไมคุณถึงต้องการแยก "ตรรกะทางธุรกิจ" ออกจาก "วัตถุทางธุรกิจ" ฟังดูเหมือนเป็นการบิดเบือนการวางแนวของวัตถุและคุณจะผูกปมด้วยตัวเองโดยใช้แนวทางนั้น

ฉันไม่คิดว่าจะมีวิธีแก้ปัญหาที่ไม่เลวร้ายไปกว่าปัญหาทั้งหมดที่กล่าวมาข้างต้นต้องการโรงงานไฟฟ้าสถิตสาธารณะซึ่ง IMHO เป็นปัญหาที่แย่กว่าและจะไม่หยุดคนเพียงแค่เรียกโรงงานให้ใช้วัตถุของคุณ - มันไม่ได้ซ่อนอะไรเลย ดีที่สุดที่จะเปิดเผยอินเทอร์เฟซและ / หรือให้คอนสตรัคเตอร์เป็นแบบภายในถ้าคุณทำได้นั่นเป็นการป้องกันที่ดีที่สุดเนื่องจากแอสเซมบลีเป็นรหัสที่เชื่อถือได้

ทางเลือกหนึ่งคือการมีตัวสร้างแบบคงที่ซึ่งจะลงทะเบียนโรงงานที่ไหนสักแห่งที่มีบางอย่างเช่นคอนเทนเนอร์ IOC

นี่คืออีกทางเลือกหนึ่งของ "เพียงเพราะคุณไม่ได้หมายความว่าคุณควร" ...

เป็นไปตามข้อกำหนดในการรักษาตัวสร้างวัตถุทางธุรกิจให้เป็นส่วนตัวและวางตรรกะของโรงงานไว้ในคลาสอื่น หลังจากนั้นก็จะร่างเล็กน้อย

คลาสโรงงานมีวิธีการแบบคงที่สำหรับการสร้างวัตถุทางธุรกิจ มาจากคลาสอ็อบเจ็กต์ทางธุรกิจเพื่อเข้าถึงวิธีการก่อสร้างที่มีการป้องกันแบบคงที่ซึ่งเรียกใช้ตัวสร้างไพรเวต

โรงงานเป็นนามธรรมดังนั้นคุณจึงไม่สามารถสร้างอินสแตนซ์ของมันได้ (เพราะมันจะเป็นวัตถุทางธุรกิจด้วยดังนั้นมันก็แปลก) และมันมีตัวสร้างส่วนตัวดังนั้นรหัสไคลเอนต์จึงไม่สามารถรับมาจากมันได้

สิ่งที่ไม่ป้องกันคือรหัสไคลเอ็นต์ด้วยมาจากวัตถุชั้นธุรกิจและเรียกการป้องกัน ( แต่ unvalidated) วิธีการคงการก่อสร้าง หรือแย่กว่านั้นคือการเรียกตัวสร้างเริ่มต้นที่ได้รับการป้องกันที่เราต้องเพิ่มเพื่อให้ได้คลาสโรงงานในการคอมไพล์ตั้งแต่แรก (ซึ่งบังเอิญน่าจะเป็นปัญหากับรูปแบบใด ๆ ที่แยกคลาสโรงงานออกจากคลาสอ็อบเจ็กต์ทางธุรกิจ)

ฉันไม่ได้พยายามแนะนำใครในความคิดที่ถูกต้องว่าควรทำอะไรแบบนี้ แต่มันเป็นแบบฝึกหัดที่น่าสนใจ FWIW ทางออกที่ฉันชอบคือใช้ตัวสร้างภายในและขอบเขตการชุมนุมเป็นตัวป้องกัน

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()
    {
    }
}

ขอขอบคุณที่ได้ยินความคิดบางอย่างเกี่ยวกับการแก้ปัญหานี้ ผู้เดียวที่สามารถสร้าง 'MyClassPrivilegeKey' ได้คือโรงงาน และ 'MyClass' ต้องใช้ในตัวสร้าง จึงหลีกเลี่ยงการสะท้อนเรื่องผู้รับเหมาเอกชน / "จดทะเบียน" โรงงาน.

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);
            }
        }
    }
}