Question

我有一个主要对象，它有一些属性和方法。该对象可以有多个部分。这些部件是必需的。这些部分的数量是可变的。

每个部分都有不同的属性，并以主对象为基础。

要在我的GUI中完成此操作，我有一个tabcontrol。第一个选项卡是主要对象。其他选项卡进一步描述了主要对象。这些“其他”标签是我上面提到的部分。

我正在尝试设计一个架构，但我无法想象，我希望你能帮助我。

根据答案的建议，part-tabs从接口继承。但主要人员如何知道它的部分？部件不能硬编码，因为它是可变的。对部件进行硬编码违反了OCP原则。

此外，当再次加载主对象时，它如何知道它的部分？我必须在某处“注册”它们，但在哪里？

Answer 1

在List类中有Dictionary或Main，并存储对不同对象的引用。

例如：

所有标签都实现了一个名为IScreenTab的界面。

class MainTab : IScreenTab
{

    // Store a map of scree name to screen object
    // You can also just use a List<IScreenTab> 
    private Dictionary<string, IScreenTab> m_OtherScreens;

    // Your implementation goes here
    public MainTab(){ }
    public MainTab(List<IScreenTab> screenTabList){ }
    public AddTab(string screenName, IScreenTab screenTabObj){ }

}

Answer 2

为您的零件创建界面，可以引用主对象。主对象将包含Collection<IPart>

部分的集合

class MainObject
{
    Collection<IPart> Parts {get;set;}
}

interface IPart
{
    MainObject MainObject {get;set;}
}

class SomePartImpl : IPart
{
    //properties of this IPart implementation
}

这个类是实体。您的数据服务必须实现用于保存和级联操作的逻辑。示例wcf服务（来自我的项目）：

[EnableClientAccess]
public class ModelService : LinqToEntitiesDomainService<dpirtEntities>
{
    public void InsertZone(Zone zone)
        {
            if ((zone.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(zone, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Zones.AddObject(zone);
            }
        }

        public void UpdateZone(Zone currentZone)
        {
            Zone originalZone = this.ChangeSet.GetOriginal(currentZone);
            if ((currentZone.EntityState == EntityState.Detached))
            {
                if (originalZone != null)
                {
                    this.ObjectContext.Zones.AttachAsModified(currentZone, originalZone);
                }
                else
                {
                    this.ObjectContext.Zones.Attach(currentZone);
                }
            }

            foreach (Document doc in this.ChangeSet.GetAssociatedChanges(currentZone, o => o.Documents))
            {
                ChangeOperation op = this.ChangeSet.GetChangeOperation(doc);
                switch (op)
                {
                    case ChangeOperation.Insert:
                        if ((doc.EntityState != EntityState.Added))
                        {
                            if ((doc.EntityState != EntityState.Detached))
                            {
                                this.ObjectContext.ObjectStateManager.ChangeObjectState(doc, EntityState.Added);
                            }
                            else
                            {
                                this.ObjectContext.AddToDocuments(doc);
                            }
                        }
                        break;
                    case ChangeOperation.Update:
                        this.ObjectContext.Documents.AttachAsModified(doc, this.ChangeSet.GetOriginal(doc));
                        break;
                    case ChangeOperation.Delete:
                        if (doc.EntityState == EntityState.Detached)
                        {
                            this.ObjectContext.Attach(doc);
                        }
                        this.ObjectContext.DeleteObject(doc);
                        break;
                    case ChangeOperation.None:
                        break;
                    default:
                        break;
                }
            }
        }

        public void DeleteZone(Zone zone)
        {
            if ((zone.EntityState == EntityState.Detached))
            {
                this.ObjectContext.Zones.Attach(zone);
            }
            this.ObjectContext.Zones.DeleteObject(zone);
        }
}

Answer 3

我过去做过类似的事情，我通过使用IoC容器将GUI与我的域设计分离。在我的代码中，我使用了StructureMap，这很容易采用。

我有完全相同的设置，其中有一个'编辑器'，其中包含许多'标签'。每个选项卡可以包含我的“对象”的一些不同视图，也可以显示存储在“对象”中的集合中的项目。因此，有许多静态和变量标签。

所以，我需要两件事。 1.一种使用正确数量的选项卡创建编辑器的方法。 2.一种创建选项卡的方法，以及它的所有控件。

所以，我为每个人创建了一个界面，看起来很像这样。

public interface IEditorFactory<TObject>
{
    Editor CreateEditor(TObject instance);
}

public interface ITabEditorFactory<TObject>
{
    void CreateTab(TObject instance, Editor parent);
}

我会把编辑放在想象中。在我的应用程序中，它是一个自定义UserControl，具有各种功能和行为。

接下来，假设我们有一个人，他有个人信息，地址是多个合同。

public class Person
{
    public string Title { get; set; }
    public string Forename { get; set; }
    public string Surname { get; set; }
    public string EmployeeNumber { get; set; }
    public string NationalInsuranceNumber { get; set; }
    public Address Address { get; set; }
    public IEnumerable<Contract> Contracts { get; }
}

我的应用想要显示一个“个人详细信息”标签，一个“就业”标签，一个“地址”标签和多个“合同”标签。

我实施了以下内容。公共类PersonalTab：ITabEditorFactory {...} 公共类EmployeeTab：ITabEditorFactory {...} 公共类AddressTab：ITabEditorFactory {...} 公共类ContractTab：ITabEditorFactory {...}

注意＃1和＃2如何实现相同的ITabEditorFactory。那是因为他们都显示了人的不同方面。

但在我实施之前，我实施了PersonEditor public class PersonEditor：IEditorFactory {...} 我首先实现这一点很好，因为它强制将编辑器工厂从所有制表工厂中解耦。我不会不小心搞任何具体课程。我的编辑工厂刚知道如何要求ITabEditorFactory＆lt;＆gt;适用于人员，地址和合同类。

我的最终解决方案比上面概述的要复杂一点，因为它还包括编辑器重用不同实例，如何为任何单个类处理多个（或没有）选项卡编辑器，以及能够定义安全性在逐个标签的基础上。

最终结果是我有一个与我的域分离的GUI模型，并且可以扩展而不需要我更改现有代码的单行。

可爱的生气。

C＃如何使用其他对象实现主对象？

3 个答案: