不使用接口 C# 实现 FactoryPattern

Question

I have a requirement of refactoring the code where I have multiple classes and the object of the classes need to be created dynamically depending upon the user request. Now the classes are all there and have no common methods within them that match each other. So I cannot add an interface to it and create a factory class that will return the interface reference referencing the actual class. Is there a way with generics or any other way to refactor this to be able to create objects dynamically. The approach we have now is that there is a main class where the object of each class is instantiated and all methods are being called. Can we implement a factory pattern without an interface or any solution to my scenario ? Please.

Adding sample code to explain the scenario.

 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
}

So, as in above, I can't have the interface because no common methods are in it. So what other solutions I can have, if I have an empty interface or abstract method, how will that help. Even if I put one common method in the interface and all classes implement it, since I am passing the reference to the interface, I can only access the common method from the interface reference.

My idea is to use something like the below, but not sure what the return type would or should be defined as.

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

How do I define T here in the return is my concern and how can I invoke it, if anybody can help with that, then I think I am close to the solution.

Answer to my problem

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

Answer 1

I'm not saying totally understand the problem, but give it a shot...

Factory like class that you have:

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

Types that you have to create:

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

Usage of the code:

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

And the missing parts:

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

This is called the Visitor pattern. If you know what methods need to be called Visitor.Visit than that is what you want.

Answer 2

I don't entirely understand your question but a basic assertion is wrong. I am concerned with your design given the basis of your question.

Regardless, my proposed solution:

You are saying that you don't have a common object (indirect, directly you stated: "I can't have the interface because no common methods are in it."

object is the common element.

I don't condone this but you could create a factory object that just returned object as the data type. The problem with this is you then have to cast it after the object creation which you may not mind...

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

}