C# 工厂或建筑商模式使用非通用产品类？

你好

我正试图找出什么样的模式可以用于一些新的开发，但我陷入了困境。我起初以为是工厂模式，但后来可能是建筑商模式，但两者似乎都不完美

我的问题是模式中的基本产品类不是泛型的。工厂中的一切和构建器模式似乎都要求基础产品完全相同

例如（一个非常简单的例子）：

我想我可以使用factory方法构建产品并将其返回给调用者，然后让调用者在我获得产品后设置产品上的唯一数据，但这需要将产品类强制转换为特定类型，以便设置特定类型的数据。然而，这一切对我来说都是可疑的，因为如果我已经知道我需要什么类型，我真的只是用一种模式使事情复杂化了吗

无论如何，任何关于在这里可以采取什么方法的指导都是受欢迎的。最终，我希望对这些模式进行一些修改（或者完全不同），以允许非通用产品。或者，在创建后通过模式在产品上设置特定于类型的数据也不是那么糟糕

---

更新：我应该提到我需要在运行时设置特定于类型的数据（z或a），因为它是通过webform传入的。因此，我不能将创建完整实例的任务留给工厂或构建者，我仍然需要在事后（或在实例化期间，但这似乎没有一个好的通用解决方案）设置数据的方法。

每个产品都有一个抽象工厂方法类和一个conrete工厂方法类有什么不对

public class ProductBase
{
    public int x;
    public int y;
}

public class ProductA : ProductBase
{
    public int z;
}

public class ProductB : ProductBase
{
    public int a;
}
public class Factory
{
    abstract Product Create();
}
public class FactoryA:Factory
{
    override Product Create()
    {
         return new ProductA();
    }
}
public class FactoryB:Factory
{
    override Product Create()
    {
       return new ProductB();
    }
}

这适用于一般情况和外部参数

 internal static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        private static void Main()
        {
            var fact = new FactoryA();
            int passParam = 5;//fromGUI
            ProductA f = fact.Create(passParam);
        }
    }

    public class ProductBase
    {
        public int x;
        public int y;
    }

    public class ProductA : ProductBase
    {
        public int z;
    }

    public class ProductB : ProductBase
    {
        public int a;
    }

    public abstract class Factory<T> where T : ProductBase
    {
        public abstract T Create(int passedParam);
    }

    public class FactoryA : Factory<ProductA>
    {
        public override ProductA Create(int passedParam)
        {
            return new ProductA() { x = 1, y = 1, z = passedParam };
        }
    }

    public class FactoryB : Factory<ProductB>
    {
        public override ProductB Create(int passedParam)
        {
            return new ProductB() { x = 1, y = 1, a = passedParam };
        }
    }

内部静态类程序
{
/// 
///应用程序的主要入口点。
/// 
[状态线程]
私有静态void Main（）
{
var fact=新工厂a（）；
int passParam=5；//fromGUI
ProductA f=fact.Create（passParam）；
}
}
公共类产品库
{
公共int x；
公共智力；
}
公共类ProductA:ProductBase
{
公共INTZ；
}
公共类ProductB:ProductBase
{
公共INTA；
}
公共抽象类工厂，其中T:ProductBase
{
公共摘要T Create（int passedParam）；
}
公共类工厂A:工厂
{
公共覆盖产品A创建（int passedParam）
{
返回新的ProductA（）{x=1，y=1，z=passedParam}；
}
}
公共类工厂B：工厂
{
公共覆盖产品B创建（int passedParam）
{
返回新的ProductB（）{x=1，y=1，a=passedParam}；
}
}

每个产品有一个抽象工厂方法类和一个conrete工厂方法类有什么不对

public class ProductBase
{
    public int x;
    public int y;
}

public class ProductA : ProductBase
{
    public int z;
}

public class ProductB : ProductBase
{
    public int a;
}
public class Factory
{
    abstract Product Create();
}
public class FactoryA:Factory
{
    override Product Create()
    {
         return new ProductA();
    }
}
public class FactoryB:Factory
{
    override Product Create()
    {
       return new ProductB();
    }
}

这适用于一般情况和外部参数

 internal static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        private static void Main()
        {
            var fact = new FactoryA();
            int passParam = 5;//fromGUI
            ProductA f = fact.Create(passParam);
        }
    }

    public class ProductBase
    {
        public int x;
        public int y;
    }

    public class ProductA : ProductBase
    {
        public int z;
    }

    public class ProductB : ProductBase
    {
        public int a;
    }

    public abstract class Factory<T> where T : ProductBase
    {
        public abstract T Create(int passedParam);
    }

    public class FactoryA : Factory<ProductA>
    {
        public override ProductA Create(int passedParam)
        {
            return new ProductA() { x = 1, y = 1, z = passedParam };
        }
    }

    public class FactoryB : Factory<ProductB>
    {
        public override ProductB Create(int passedParam)
        {
            return new ProductB() { x = 1, y = 1, a = passedParam };
        }
    }

内部静态类程序
{
/// 
///应用程序的主要入口点。
/// 
[状态线程]
私有静态void Main（）
{
var fact=新工厂a（）；
int passParam=5；//fromGUI
ProductA f=fact.Create（passParam）；
}
}
公共类产品库
{
公共int x；
公共智力；
}
公共类ProductA:ProductBase
{
公共INTZ；
}
公共类ProductB:ProductBase
{
公共INTA；
}
公共抽象类工厂，其中T:ProductBase
{
公共摘要T Create（int passedParam）；
}
公共类工厂A:工厂
{
公共覆盖产品A创建（int passedParam）
{
返回新的ProductA（）{x=1，y=1，z=passedParam}；
}
}
公共类工厂B：工厂
{
公共覆盖产品B创建（int passedParam）
{
返回新的ProductB（）{x=1，y=1，a=passedParam}；
}
}

如果您有一个上下文，您需要使用

ProductA

和

ProductB

的实例，就好像它们是同一类型的一样，那么从一个函数中提供这些实例是有意义的，该函数将决定实例化哪个具体类所需的参数作为参数，并具有检索需要实例化的任何对象的方法正确地创建这样的实例。在这种情况下，所有属性都应从该函数中设置，以避免打开混凝土类型来完成构造

如果您觉得施工过程过于复杂，请将其模块化：

class ProductFactoryBase {
  protected void Populate(ProductBase p) {
    p.x = some_x;
    p.y = some_y;
  }
}

class ProductAFactory : ProductFactoryBase {
  public ProductBase Create() {
    ProductA p = new ProductA();
    populate(p);
    p.z = some_z;
    return p;
  }
}

class ProductBFactory : ProductFactoryBase {
  public ProductBase Create() {
    ProductB p = new ProductB();
    populate(p);
    p.a = some_a;
    return p;
  }
}

class ProductFactory {
  private ProductAFactory paf = new ProductAFactory();
  private ProductBFactory pbf = new ProductBFactory();

  ProductBase Create(bool create_A) {
    if ( create_A )
      return paf.Create();
    else
      return pbf.Create();
  }
}

然而，如果你真的不需要使用

ProductA

s和

ProductB

s，就好像它们是同一件事一样，不要仅仅为了它而泛化；只要在需要时创建并使用每种类型的实例即可

在这两个极端之间，你可以考虑让通用性在构建过程中共同考虑因素，即使你的类不需要一个共同的基础。在这种情况下，您不会有像上面的

ProductFactory

那样的通用工厂

---

希望这能回答您的问题。

如果您有一个上下文，您需要使用

ProductA

和

ProductB

的实例，就好像它们是同一类型的一样，那么从一个函数中提供这些实例是有意义的，该函数以决定实例化哪个具体类所需的参数为参数，并具有相应的方法检索正确创建此类实例所需的任何对象。在这种情况下，所有属性都应从该函数中设置，以避免打开混凝土类型来完成构造

如果您觉得施工过程过于复杂，请将其模块化：

class ProductFactoryBase {
  protected void Populate(ProductBase p) {
    p.x = some_x;
    p.y = some_y;
  }
}

class ProductAFactory : ProductFactoryBase {
  public ProductBase Create() {
    ProductA p = new ProductA();
    populate(p);
    p.z = some_z;
    return p;
  }
}

class ProductBFactory : ProductFactoryBase {
  public ProductBase Create() {
    ProductB p = new ProductB();
    populate(p);
    p.a = some_a;
    return p;
  }
}

class ProductFactory {
  private ProductAFactory paf = new ProductAFactory();
  private ProductBFactory pbf = new ProductBFactory();

  ProductBase Create(bool create_A) {
    if ( create_A )
      return paf.Create();
    else
      return pbf.Create();
  }
}

但是，如果您真的不需要使用

ProductA