C# 在这种情况下，有没有办法将派生类转换为基类工作？

我现在有个问题

我有一个接口，有两种类型的参数

ITestInterface<ArgumentA>
ITestInterface<ArgumentB>

public class MyClass
{
    public ITestInterface<object> MyInterface {get; set;}

    public MyClass(ITestInterface<ArgumentA> testInterfaceA){
    this.MyInterface = testInterfaceA as ITestInterface<object>;
    this.MyTestInterface.SomeEvent += this.OnSubcribe;
    }
    
    public MyClass(ITestInterface<ArgumentB> testInterfaceB){
    this.MyInterface = testInterfaceB as ITestInterface<object>;
    this.MyTestInterface.SomeEvent += this.OnSubcribe;
    }

public void OnSubcribe(){
//Work to do here, dont care about what argument the interface has.
}
}

ITestInterface
界面

此接口只有参数不同

我想把这个接口传递给一个类的构造函数。像这样的东西

ITestInterface<ArgumentA>
ITestInterface<ArgumentB>

public class MyClass
{
    public ITestInterface<object> MyInterface {get; set;}

    public MyClass(ITestInterface<ArgumentA> testInterfaceA){
    this.MyInterface = testInterfaceA as ITestInterface<object>;
    this.MyTestInterface.SomeEvent += this.OnSubcribe;
    }
    
    public MyClass(ITestInterface<ArgumentB> testInterfaceB){
    this.MyInterface = testInterfaceB as ITestInterface<object>;
    this.MyTestInterface.SomeEvent += this.OnSubcribe;
    }

public void OnSubcribe(){
//Work to do here, dont care about what argument the interface has.
}
}

公共类MyClass
{
公共ITestInterface MyInterface{get；set；}
公共MyClass（ITestInterface TestInterface A）{
this.MyInterface=testInterfaceA作为ITestInterface；
this.MyTestInterface.SomeEvent+=this.onsubscribe；
}
公共MyClass（ITestInterface TestInterface B）{
this.MyInterface=testInterfaceB作为ITestInterface；
this.MyTestInterface.SomeEvent+=this.onsubscribe；
}
subscribe（）上的公共无效{
//这里要做的工作，不关心接口有什么参数。
}
}

要调用MyClass构造函数，我有如下内容：

public List<MyClass> ClassList = new();
    
public void testMethod(){
var interA = getInterfaceWithArgumentA();
var myClassA = new MyClass(interA);

var interB = getInterfaceWithArgumentB();
var myClassB = new MyClass(interB);
}

public List ClassList=new（）；
公共void testMethod（）{
var interA=getInterfaceWithArgumentA（）；
var myClassA=新的myClassA（interA）；
var interB=getInterfaceWithArgumentB（）；
var myClassB=新的MyClass（interB）；
}

所以问题是我无法将接口参数转换为对象。我也不需要对这个论点提出异议。我只是想避免使用MyInterface的两个属性，比如（MyInterfaceA，MyInterfaceB）

我还需要考虑的是，也许将来我会有更多类型的参数，这样可能有多个属性，比如MyTeFiTeA、MyTrimeFeb、MyTimeFraceC以及每个接口类型的多个构造函数将是一个烂摊子。 我只是想有一个基类和ArgumentA和ArgumentB类从中派生出来，这样演员阵容就可以工作了，但不是这样

我该如何解决这个问题

---

非常感谢

我想您还没有提供getInterfaceWithArgumentB（）和getInterfaceWithArgumentA（）方法的功能。我很少做假设

要解决您的问题，通用将有所帮助

下面是一个例子

 public class MyClass<T>
{
    public ITestInterface<T> MyInterface { get; set; }

    public MyClass(ITestInterface<T> testInterfaceA)
    {
        this.MyInterface = testInterfaceA;
        this.MyInterface.SomeEvent += MyInterface_SomeEvent;
    }
    private void MyInterface_SomeEvent(object sender, EventArgs e)
    {
        Console.WriteLine(sender);
    }
    
}

public class ArgumentA
{
    public string Name { get; set; }
}

public class ArgumentB
{
    public int Id { get; set; }
}

public interface ITestInterface<T>
{
    T Data { get; set; }

    event EventHandler SomeEvent;
    void OnSomeEvent();
}

public class TestInterface<T> : ITestInterface<T>
{
    public T Data { get ; set; }

    public event EventHandler SomeEvent;

    public void OnSomeEvent()
    {
        if(SomeEvent != null)
        SomeEvent(Data, EventArgs.Empty);
    }
}

公共类MyClass
{
公共ITestInterface MyInterface{get；set；}
公共MyClass（ITestInterface TestInterface A）
{
this.MyInterface=testInterfaceA；
this.MyInterface.SomeEvent+=MyInterface\u SomeEvent；
}
私有void MyInterface_SomeEvent（对象发送方，事件参数e）
{
控制台写入线（发送方）；
}
}
公开课辩论
{
公共字符串名称{get；set；}
}
公开课B
{
公共int Id{get；set；}
}
公共接口ITestInterface
{
T数据{get；set；}
事件处理程序SomeEvent；
void OnSomeEvent（）；
}
公共类测试接口：ITestInterface
{
公共T数据{get；set；}
公共事件事件处理程序SomeEvent；
OnSomeEvent（）上的公共无效
{
if（SomeEvent！=null）
SomeEvent（数据，EventArgs.Empty）；
}
}

你可以像下面那样使用它

MyClass<ArgumentA> myClass = new MyClass<ArgumentA>(
                                             new TestInterface<ArgumentA>()
                                             {
                                                 Data = new ArgumentA() { Name = "test" }
                                             });
            MyClass<ArgumentB> myClas2 = new MyClass<ArgumentB>(
                                             new TestInterface<ArgumentB>() 
                                             { 
                                                 Data = new ArgumentB() { Id = 10 } 
                                             });

            myClas2.MyInterface.OnSomeEvent();
            myClass.MyInterface.OnSomeEvent();

MyClass MyClass=新的MyClass(
新TestInterface（）
{
Data=new ArgumentA（）{Name=“test”}
});
MyClass myClas2=新的MyClass(
新TestInterface（）
{ 
数据=新参数b（）{Id=10}
});
myClas2.MyInterface.OnSomeEvent（）；
myClass.MyInterface.OnSomeEvent（）；

使现代化

类程序
{
静态void Main（字符串[]参数）
{
ObservableCollection items=新的ObservableCollection（）；
MyClass MyClass=新的MyClass(
新TestInterface（）
{
Data=new ArgumentA（）{Name=“test”}
});
MyClass myClas2=新的MyClass(
新TestInterface（）
{ 
数据=新参数b（）{Id=10}
});
添加（myClass）；
添加项目（myClas2）；
myClas2.MyInterface.OnSomeEvent（）；
myClass.MyInterface.OnSomeEvent（）；
}
}
公共类MyClass
{
公共ITestInterface MyInterface{get；set；}
}
公共类MyClass:MyClass
{
公共MyClass（ITestInterface TestInterface A）
{
this.MyInterface=testInterfaceA；
this.MyInterface.SomeEvent+=MyInterface\u SomeEvent；
}
私有void MyInterface_SomeEvent（对象发送方，事件参数e）
{
控制台写入线（发送方）；
}
}
公开课辩论
{
公共字符串名称{get；set；}
}
公开课B
{
公共int Id{get；set；}
}
公共接口ITestInterface
{
事件处理程序SomeEvent；
void OnSomeEvent（）；
}
公共接口ITestInterface:ITestInterface
{
T数据{get；}
}
公共类测试接口：ITestInterface
{
公共T数据{get；set；}
公共事件事件处理程序SomeEvent；
OnSomeEvent（）上的公共无效
{
if（SomeEvent！=null）
SomeEvent（数据，EventArgs.Empty）；
}
}

我想您还没有提供getInterfaceWithArgumentB（）和getInterfaceWithArgumentA（）方法的作用。我很少做假设

要解决您的问题，通用将有所帮助

下面是一个例子

 public class MyClass<T>
{
    public ITestInterface<T> MyInterface { get; set; }

    public MyClass(ITestInterface<T> testInterfaceA)
    {
        this.MyInterface = testInterfaceA;
        this.MyInterface.SomeEvent += MyInterface_SomeEvent;
    }
    private void MyInterface_SomeEvent(object sender, EventArgs e)
    {
        Console.WriteLine(sender);
    }
    
}

public class ArgumentA
{
    public string Name { get; set; }
}

public class ArgumentB
{
    public int Id { get; set; }
}

public interface ITestInterface<T>
{
    T Data { get; set; }

    event EventHandler SomeEvent;
    void OnSomeEvent();
}

public class TestInterface<T> : ITestInterface<T>
{
    public T Data { get ; set; }

    public event EventHandler SomeEvent;

    public void OnSomeEvent()
    {
        if(SomeEvent != null)
        SomeEvent(Data, EventArgs.Empty);
    }
}

公共类MyClass
{
公共ITestInterface MyInterface{get；set；}
公共MyClass（ITestInterface TestInterface A）
{
this.MyInterface=testInterfaceA；
this.MyInterface.SomeEvent+=MyInterface\u SomeEvent；
}
私有void MyInterface_SomeEvent（对象发送方，