Использование шаблона Factory или Builder с неуниверсальным классом продукта?

Что плохого в наличии одного класса абстрактных фабричных методов и одного конкретного класса фабричных методов для каждого продукта?

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

Если у вас есть контекст, в котором вам нужно использовать экземпляры 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();
  }
}

Однако, если вам действительно не нужно использовать ProductAs и ProductBs, как если бы они были одним и тем же, не обобщайте только ради этого; просто создавайте и используйте экземпляры каждого типа, когда они вам нужны.

Между этими двумя крайностями вы могли бы подумать о том, чтобы сделать ProductFactoryBase универсальным, чтобы учесть общность в процессе построения, даже если ваши классы на самом деле не нуждаются в общей базе. В этом случае у вас не будет общей фабрики, такой как ProductFactory выше.

Надеюсь, что это ответ на ваш вопрос.