Design patterns 工厂模式，需要向下转换参数

在重构我的应用程序并尝试为其添加一些抽象时，我发现了一个我自己无法解决的问题

这是我真实问题的抽象，希望这更容易想象和理解

有一个带有

列表的
容器
类

在我的应用程序中，有两种类型的
IContainerItem
：


ContainerItemA
ContainerItemB

还有
IContainerItemFactory
，有一种方法：

IContainerItem Create();

对于这两种类型的
IContainerItem
还有
IContainerItemFactory
实现：

class ContainerItemAPart : IContainerItemPart
{

       ...
       public IContainerItemFactory getItemFactory(){

               return new ContainerItemAFactory (this );
       }
}


ContainerItemAFactory
ContainerItemBFactory

现在，在IoC构建
容器时，注入了特定类型的
IContainerItemFactory
，列表可以由特定工厂填充，一切正常

当我添加到我的应用程序
IContainerItemPart
及其两个实现时，问题开始了：


containerItemPart
ContainerItemBPart

现在要创建
ContainerItem（A | B）
您必须经过构造函数
ContainerItem（A | B）部分
。无法传递
IContainerItemPart
，因为
IContainerItemPart
m的每个实现都使用特定
IContainerItemPart
实现中的属性（不同的名称，不同数量的属性）

现在如何处理这些工厂？
现在，界面中的Create方法如下所示：

IContainerItem Create(IContainerItemPart part);

我有两个选择：

在factory Create方法中将从IContainerItemPart添加到specific的强制转换，并将实现传递给构造函数
将
IContainerItemPart
传递到
IContainerItem
实现并在内部强制转换（构造函数内部）
您认为哪种解决方案更好？也许没有？为什么？
也许问题出在我的架构上？那怎么解决呢

更新：

我提供了一些代码来澄清。代码是有效的C#代码，但工厂中的Create（）方法除外

    interface IContainerItem { }

    class ContainerItemA : IContainerItem
    {
        public ContainerItemA(ContainerItemAPart part)
        {
            Console.WriteLine(part.SpecificForA);
        }
    }

    class ContainerItemB : IContainerItem
    {
        public ContainerItemB(ContainerItemBPart part)
        {
            Console.WriteLine(part.SpecificForB);
        }
    }

    interface IContainerItemPart
    {
        int Id { get; }
    }

    class ContainerItemAPart : IContainerItemPart
    {
        public int Id { get; set; }
        public int SpecificForA { get; set; }
    }

    class ContainerItemBPart : IContainerItemPart
    {
        public int Id { get; set; }
        public int SpecificForB { get; set; }
    }

    interface IContainerItemFactory
    {
        IContainerItem Create(IContainerItemPart part);
    }

    class ContainerItemAFactory : IContainerItemFactory
    {
        public IContainerItem Create(IContainerItemPart part)
        {
            //dont work here, downcasting needed
            return new ContainerItemA(part);
        }
    }
    class ContainerItemBFactory : IContainerItemFactory
    {
        public IContainerItem Create(IContainerItemPart part)
        {
            //dont work here, downcasting needed
            return new ContainerItemB(part);
        }
    }

    class Container
    {
        private IList<IContainerItem> _items;
        public Container(IList<IContainerItemPart> parts, IContainerItemFactory factory)
        {
            _items = new List<IContainerItem>();
            foreach (var part in parts)
                _items.Add(factory.Create(part));
        }
    }

接口IContainerItem{}
类别ContainerItemA:IContainerItem
{
公共集装箱码头（集装箱码头部分）
{
控制台写入线（部分规格）；
}
}
类别ContainerItem:IContainerItem
{
公共容器emb（容器emb部分）
{
控制台写入线（部分规范B）；
}
}
接口IContainerItemPart
{
int Id{get；}
}
类ContainerItemPart:IContainerItemPart
{
公共int Id{get；set；}
公共int specififora{get；set；}
}
类ContainerItemBPart:IContainerItemPart
{
公共int Id{get；set；}
公共int SpecificForB{get；set；}
}
接口IContainerItemFactory
{
IContainerItem创建（IContainerItemPart部件）；
}
类别ContainerItemFactory:IContainerItemFactory
{
公共IContainerItem创建（IContainerItemPart）
{
//不要在这里工作，需要降级
退回新的集装箱（零件）；
}
}
类别ContainerItemBFactory:IContainerItemFactory
{
公共IContainerItem创建（IContainerItemPart）
{
//不要在这里工作，需要降级
退回新集装箱EMB（部分）；
}
}
类容器
{
私人IList_项目；
公共容器（IList零件、IContainerItemFactory）
{
_项目=新列表（）；
foreach（var零件中的零件）
_添加（工厂创建（零件））；
}
}
使
IContainerItemPart
对象具有容器工厂使用

interface IContainerItemPart{

    IContainerItemFactory getItemFactory();

}

这样，每个ItemPart将始终创建正确的itemFactory实现（并可能将自身作为参数传递给itemFactory的构造函数）

编辑
下面是代码示例：

下面是
containerFactory
的一个实现：

class ContainerItemAFactory : IContainerItemFactory
{

    private IContainerItemAPart _part;

    public ContainerItemAFactory ( IContainerItemPart part){
         _part = part;
    }

    //now we don't have to pass the part subtype around as a parameter
    public IContainerItem Create()
    {
        //look no downcasting needed
        return new ContainerItemA(part);
    }
}

现在是
IContainerItemPart
实现：

class ContainerItemAPart : IContainerItemPart
{

       ...
       public IContainerItemFactory getItemFactory(){

               return new ContainerItemAFactory (this );
       }
}

因此，在代码中，您不需要知道它是A项还是B项：

ContainerItem item = myItemPartFactory.getItemFactory().create(); 

问题在于

interface IContainerItemPart{

    IContainerItemFactory getItemFactory();

}

一个项可能有一个带参数的构造函数

我想知道一些要点


项目是否有参数参数
你能发一些代码吗
你不投是对的
您是否使用泛型（我认为这是一个关键因素，我将在您回答时解释）
你今天过得好吗

期待您的回复

你的

Abdulmajid Alnouri
对不起，我真的不明白这将如何解决我的问题？你能给我解释一下吗？也许我提供的代码可以成为它的良好基础？现在我看到了，它可以为我工作。然而，我宁愿让ItemPart对这个项目一无所知。在我的实际问题中，ItemPart来自较低的层，然后是Item。我提供了示例代码。谢谢你，我今天过得很好；）