C# 不使用接口C实现FactoryPattern#

我需要重构代码，因为我有多个类，并且需要根据用户请求动态创建类的对象。现在这些类都在那里，并且它们内部没有相互匹配的公共方法。因此，我无法向其添加接口并创建一个工厂类，该工厂类将返回引用实际类的接口引用。有没有办法使用泛型或任何其他方法来重构它，以便能够动态创建对象。我们现在的方法是有一个主类，其中每个类的对象都被实例化，所有方法都被调用。我们是否可以在没有接口或解决方案的情况下实现工厂模式？求你了

添加示例代码以解释该场景

 public interface ITest
{
    string TestMethod1(string st, int ab);
    int TestMethod2(string st);
    void TestMethod4(int ab);
    float ITest.TestMethod3(string st);
}
public class Class1 : ITest
{
    public string TestMethod1(string st, int ab)
    {
        return string.Empty;
    }
    public void TestMethod4(int ab)
    {
        throw new NotImplementedException();
    }

    public int TestMethod2(string st)
    {
        throw new NotImplementedException();
    }

    public float TestMethod3(string st)
    {
        throw new NotImplementedException();
    }
}
 public class Class2 : ITest
{

    float ITest.TestMethod3(string st)
    {
        return float.Parse("12.4");
    }

    void ITest.TestMethod4(int ab)
    {
        throw new NotImplementedException();
    }
    public string TestMethod1(string st, int ab)
    {
        throw new NotImplementedException();
    }

    public int TestMethod2(string st)
    {
        throw new NotImplementedException();
    }
}
 public class Main
{
    ITest test = null;

    public ITest CreateFactory(TestType testType)
    {
        switch(testType)
        {
            case TestType.Class1:
               test = new Class1();
                break;
            case TestType.Class2:
                test = new Class2();
                break;
        }
        return test;
    }
}

enum TestType
{
    Class1,
    Class2
}

因此，如上所述，我不能拥有该接口，因为其中没有通用方法。那么，如果我有一个空的接口或抽象方法，我还能有什么其他的解决方案呢。即使我在接口中放置了一个公共方法，并且所有类都实现了它，因为我将引用传递给接口，所以我只能从接口引用访问公共方法

我的想法是使用下面这样的东西，但不确定返回类型会或应该定义为什么

 public T CreateFactory(TestType testType)
    {
        switch(testType)
        {
            case TestType.Class1:
               return GetInstance<Class1>("Class1");

            case TestType.Class2:
                return GetInstance<Class1>("Class2");

        }
        return null;
    }
    public T GetInstance<T>(string type)
    {
        return (T)Activator.CreateInstance(Type.GetType(type));
    }

公共T CreateFactory（TestType TestType） { 开关（测试类型） { 案例TestType.Class1： 返回GetInstance（“Class1”）； 案例TestType.Class2： 返回GetInstance（“Class2”）； } 返回null； } 公共GetInstance（字符串类型） { return（T）Activator.CreateInstance（Type.GetType（Type））； } 我在这里如何定义T是我关心的问题，我如何调用它，如果有人能提供帮助，那么我想我已经接近解决方案了

我的问题的答案

public static T CreateFactory<T>()
    where T: IFactory, new()
{
    return new T();
}

publicstatict CreateFactory（）
其中T:IFactory，new（）
{
返回新的T（）；
}

我不是说完全理解这个问题，而是尝试一下

您拥有的类似工厂的类：

class Factory
{
    public static Visitable Create(string userInput)
    {
        switch (userInput)
        {
            case nameof(ClassA):
                return new ClassA();
            case nameof(ClassB):
                return new ClassB();
            default:
                return null;
        }
    }
}

必须创建的类型：

class ClassA : Visitable
{
    public void M1(){}
    public override void Accept(Visitor visitor){visitor.Visit(this)}
}

class ClassB : Visitable
{
    public void M2(){}
    public override void Accept(Visitor visitor){visitor.Visit(this)}
}

守则的用途：

var visitor = new Visitor();
var obj = Factory.Create("ClassA");
obj.Accept(visitor);

以及缺失的部分：

class Visitor
{
    public void Visit(ClassA obj){ obj.M1(); } // Here you have to know what method will be called!
    public void Visit(ClassB obj){ obj.M2(); } // Here you have to know what method will be called!
}

abstract class Visitable
{
    public abstract void Accept(Visitor visitor);
}

这称为访问者模式。如果你知道什么方法需要被称为Visitor.Visit，那就是你想要的。

我不完全理解你的问题，但是一个基本的断言是错误的。考虑到你的问题，我对你的设计很关心

无论如何，我提出的解决方案：

你说你没有一个公共对象（间接的，直接的），你说：“我不能有接口，因为它没有公共方法。”

对象

是公共元素

我不允许这样做，但您可以创建一个工厂对象，它只返回

对象

作为数据类型。问题是您必须在对象创建后强制转换它，您可能不介意

internal class MyFactory
{
    internal object CreateItem1() { return ...; }
    internal object CreateItem2() { return ...; }
    internal object CreateItem2(ExampleEnum e) 
    {
        switch(e) 
        {
            case e.Something:
               return new blah();
            default:
               return new List<string>();
        }
    }

}

内部类MyFactory
{
内部对象CreateItem1（）{return…；}
内部对象CreateItem2（）{return…；}
内部对象CreateItem2（示例Enum e）
{
开关（e）
{
案例e.某事：
返回新的blah（）；
违约：
返回新列表（）；
}
}
}

在此处创建帖子或粘贴您的代码，否则这只是理论上的讨论（创建对象后）您怎么知道如何处理或需要调用哪些方法？该逻辑可以帮助解决您的问题。简而言之，我的问题是。我有一个类，它创建指定类型的对象并返回创建的对象，但是为了返回它，我需要强制转换或转换它，或者有一个接口，该接口由我的所有类实现，然后返回that interface ref，但是我不能在这里有一个接口，因为这里没有公共方法，所以在这种情况下我能做什么？你有一个类

FactoryLikeClass

，它根据一些输入

userInput

返回对象。这些对象没有公共方法。在

FactoryLikeClass

中的对象创建点，你知道将对新创建的对象调用哪些方法？它们是动态调用的，每个类中可能有4-5个方法，并且根据需要将调用其中一个方法。我不理解您所说的“我知道将调用哪些方法”是什么意思这对我来说是新的，但我认为它对我不起作用。有很多类，它们不断被添加，所以我必须在这里不断进行更改，如果我去工厂，我所需要的只是在接口中添加一个开关和方法。但感谢你花时间解释得这么好。至少现在你知道什么是正确的方法：）我不知道任何其他模式/技术可以帮助你。也许是一些黑魔法。。。这是一个关于模式的好网站：值得一看！模式匹配但这是一个C#7功能，你必须等待它。我有一个简单的工厂模式，不知道为什么任何人都不能理解它，我唯一需要做的更改是用其他东西替换接口，比如泛型，返回一个T类型的对象，但我不知道如何实施，这是我的建议。使用

object

，它是CLR（.NET）内部所有对象的基础，而不考虑声明（它是隐式的）。就我而言，我不明白目的。如果无法预测对象的类型，则可能无法正确设计对象。这是一个非常大的话题，但不管你的理由是什么，我的答案应该是充分的，基于你的评论。但在接收端，我如何知道从我发送的对象将其转换回哪种类型？这是我关心的问题（因此我的理解说明）。例如，在Python中，这是一个可能的问题。在CLR中，这不会是一个问题，因为您需要在编译时知道这一点。如果，作为程序员，你不知道