C#泛型/动力学继承

假设我有这些课程：

public class BaseMapClass<T1, T2>
{
   protected T1 Thing1;
   protected T2 Thing2;
}

public class InstanceMapClass1 : BaseMapClass<Type1, Type2>
{
      public InstanceMapClass(Type1 x, Type2 y)
      {
         Thing1 = x;
         Thing2 = y
      }
}

public class InstanceMapClass2 : BaseMapClass<Type3, Type4>
{
      public InstanceMapClass(Type3 x, Type4 y)
      {
         Thing1 = x;
         Thing2 = y
      }
}

公共类BaseMapClass
{
受保护的T1事物1；
受保护的T2物质2；
}
公共类InstanceMapClass1:BaseMapClass
{
公共实例类（类型1 x，类型2 y）
{
Thing1=x；
事物2=y
}
}
公共类InstanceMapClass2:BaseMapClass
{
公共实例类（类型3 x，类型4 y）
{
Thing1=x；
事物2=y
}
}

现在我有了第三个类，理想情况下，我希望有两个泛型IEnumerable，它们根据BaseMapClass中传递的类型的泛型获取其类型

public class Three<T> where T : BaseMapClass<dynamic, dynamic>
{
   IEnumerable<??> TypeXThings; // should be of the first dynamic type
   IEnumerable<??> TypeYThings; // should be of the second dynamic type
}

公共类三，其中T:BaseMapClass
{
IEnumerable TypeXThings；//应为第一个动态类型
IEnumerable TypeYThings；//应为第二个动态类型
}

如果我创建了一个新类

Three<InstanceMapClass1> three = new Three<InstanceMapClass1>();
Type1 t1 = three.TypeXThings.FirstOrDefault();

Three-Three=new-Three（）；
type1t1=3.TypeXThings.FirstOrDefault（）；

或

Three-other=new-Three（）；
Type3 t3=另一个.TypeXThings.FirstOrDefault（）；

使用动力学和泛型是否可以在运行时将这些IEnumerable的类型设置为BaseMapClass的泛型类型？我真正想要的是能够传入这个映射类，然后能够基于它们的泛型参数创建集合。我觉得我走错了方向，但我能想到的唯一其他方法是

public class Three<T1, T2, T3>
{
   IEnumerable<T2> Type1Things;
   IEnumerable<T3> Type2Things:
}

公共三级
{
i可数类型1事物；
i可数类型2：
}

谢谢！此外，我意识到这可能毫无意义，因此请让我知道需要澄清的地方。

根据您的问题：

public class Three<T> where T : BaseMapClass<dynamic, dynamic>

这不是一个灵丹妙药，在运行时仍然会抛出异常-

RuntimeBinderException

，因为Thing1/Thing2受

保护

这就是
动态
使用运行时编译的好处和坏处：）

解决方案（让您的代码编译）

你的第三个例子最有意义。在这里，它与您现有的代码相结合：

public class Three<T1, T2, T3> where T1 : BaseMapClass<T2, T3>
{
   IEnumerable<T2> Type1Things;
   IEnumerable<T3> Type2Things:
}

如果不需要这样做，请不要继承自
BaseMapClass
，也不要更改其定义方式

对最终设计的建议

如果这不能帮助您解决最初的问题，您可能希望在站点上发布代码，看看是否可以获得一些关于您的设计的反馈

我最初的想法是，您应该调查在设计中使用
接口
s是否有意义，而不是从具体类型继承

还可以查看.Net framework中是否存在适合您的目的的现有类型，而不是发明新类型（例如
Tuple
或
Dictionary
）。
您的问题：

public class Three<T> where T : BaseMapClass<dynamic, dynamic>

这不是一个灵丹妙药，在运行时仍然会抛出异常-
RuntimeBinderException
，因为Thing1/Thing2受
保护

这就是
动态
使用运行时编译的好处和坏处：）

解决方案（让您的代码编译）

你的第三个例子最有意义。在这里，它与您现有的代码相结合：

public class Three<T1, T2, T3> where T1 : BaseMapClass<T2, T3>
{
   IEnumerable<T2> Type1Things;
   IEnumerable<T3> Type2Things:
}

如果不需要这样做，请不要继承自
BaseMapClass
，也不要更改其定义方式

对最终设计的建议

如果这不能帮助您解决最初的问题，您可能希望在站点上发布代码，看看是否可以获得一些关于您的设计的反馈

我最初的想法是，您应该调查在设计中使用
接口
s是否有意义，而不是从具体类型继承

还要查看.Net framework中是否存在适合您的目的的现有类型，而不是发明新的类型（例如
Tuple
或
Dictionary
）。
动态和泛型不能互换。例如，BaseMap是一种开放的泛型类型。“打开”意味着您无法创建它的实例，因为类型占位符还没有值。当泛型类型获取其泛型类型参数（例如string、string）时，您已经创建了一个可实例化的封闭泛型类型。您可以在运行时填写泛型类型参数并实例化该类型，但泛型类型实例绑定到泛型类型参数Dynamic，并且泛型不能互换。例如，BaseMap是一种开放的泛型类型。“打开”意味着您无法创建它的实例，因为类型占位符还没有值。当泛型类型获取其泛型类型参数（例如string、string）时，您已经创建了一个可实例化的封闭泛型类型。您可以在运行时填写泛型类型参数并实例化该类型，但泛型类型实例绑定到泛型类型参数
，并使用反射来调出每个方法/属性/字段访问
，我认为这不准确。我很确定它更像是
它在运行时加载编译器的一个小版本来解析类型
谢谢，我认为元组是一个合理的建议。我想这样做的主要原因是，用户可以使用更易访问的类型传递到三个类中，但是，这三个类的内部逻辑将能够了解我更希望库用户不要乱搞的更受限制的类型。
并使用反射来调出每个方法/属性/字段访问
，我认为这不准确。我很确定它更像是
它在运行时加载编译器的一个小版本来解析类型
谢谢，我认为元组是一个合理的建议。我想这样做的主要原因是，用户可以使用更易访问的类型来传递到三个类中，但是三个类的内部逻辑将能够了解更受限制的类型，我希望库的用户不要乱来。
protected T2 Thing1; // Note: T1 of base type becomes T2 of the outer type
protected T3 Thing2; // Note: T2 of base type becomes T3 of the outer type