嵌套泛型的继承/抽象中的嵌套泛型class C#

Question

我有两个抽象类可以继承以供显式使用：A_GUI_Info 和 A_Info_Data。 GUI_Infos 是显示数据的 GUI 元素。 Info_Datas是数据类，将特定数据传输到相应的GUI_Info。

我想通过泛型表达一个显式 GUI_Info 具有一个显式 Info_Data 并且仍然允许继承的依赖关系。换句话说，我想避免将错误的显式 Info_Data 馈送到显式 GUI_Info。例如，我将 HUD_Info_Data 提供给无法表示它的 Wrist_GUI_Element。 > 一种继承泛型的类型安全

示例：

class HUDInfoData : A_Info_Data
class HUDInfo<HUDInfoData > : A_GUI_Info<A_Info_Data> 
// but the generic cant be inherited like that

class HUDInfo : A_GUI_Info<A_Info_Data>
// doesnt define dependency

class HUDInfo : A_GUI_Info<HUDInfoData >
// also not working

另一种方法是通过 where T : A_GUI_Info<D> where D : A_Info_Data 进行限制，但它并没有那样工作。

我无法开始工作的最后一个要求是：我有一个显式信息的实例并想在一个函数中处理它，该函数还可以处理所有其他继承的信息及其相应的数据。

public HUD_Info<HUD_Info_Data> obj;

public List<A_GUI_Info<A_Info_Data>> infos;

public void SetConnection(string ID, A_GUI_Info<A_Info_Data> p)
{
    infos.Add(p);
}

Answer 1

你试过了吗：

abstract class A_Info_Data { ... }
abstract class A_GUI_Info<T> where T: A_Info_Data { ... }

现在：

class CriticalData: A_Info_Data { ... }
class CriticalGui: A_GUI_Info<CriticalData> { ... }

Answer 2

基 class 上的类型参数只存在于基 class 上。更派生的 class 必须定义一个新的类型参数，并通过管道将类型传递给基础 class 的类型参数。这为您提供了一个设置更通用约束的地方。

例如：

class HUDInfo<THudInfoData> : A_GUI_Info<THudInfoData> where THudInfoData : A_Info_Data

现在，HUDInfo<> 可以接受任何 HudInfoData，只要它派生自 A_Info_Data（或者如果它是 A_Info_Data).如果你想让 HUDExtremelySpecificInfo 只能使用 HUDExtremelySpecificInfoData，那看起来像：

class HUDExtremelySpecificInfo<THudInfoData> : A_GUI_Info<THudInfoData>
    where THudInfoData : HUDExtremelySpecificInfoData

如果您不想指定类型，因为您知道它永远是 HUDExtremelySpecificInfoData，您也可以同时声明两者：

class HUDExtremelySpecificInfo<THudInfoData> : A_GUI_Info<THudInfoData>
    where THudInfoData : HUDExtremelySpecificInfoData { .. }

class HUDExtremelySpecificInfo : HUDExtremelySpecificInfo<HUDExtremelySpecificInfoData> { .. }

（根据通用 HUDExtremelySpecificInfo<> 实现非通用 HUDExtremelySpecificInfo，如果有更具体的信息数据子 class 您要指定的）

或只有一个：

class HUDExtremelySpecificInfo : A_GUI_Info<HUDExtremelySpecificInfoData> { .. }

Answer 3

最后可能需要用到这种数据结构：

public abstract class A_GUI_Info<G, D>
    where G : A_Info_Data<G, D>
    where D : A_GUI_Info<G, D>
{
    public G Gui { get; set; }
}

public abstract class A_Info_Data<G, D>
    where G : A_Info_Data<G, D>
    where D : A_GUI_Info<G, D>
{
    public D Data { get; set; }
}

它不是很好，但它确实将两个派生类型相互联系起来。

您可以这样定义它们：

public class HUDInfoData : A_Info_Data<HUDInfoData, HUDInfo>
{
}

public class HUDInfo : A_GUI_Info<HUDInfoData, HUDInfo>
{
}

Answer 4

感谢大家的建设性回答。我在这里尝试的方法并没有像首选那样工作（根本不可能）。这是我想出的：

// abstract definitions
public abstract class AInfo
{
    public abstract void SetData(AInfoData data);
}
public abstract class AInfoData

// explicit definitions
public class WristInfo : AInfo
{
    public override void SetData(AInfoData data)
    {
        Data_Info_Wrist d = (Data_Info_Wrist)data; // cast to use
    }
}
public class Data_Info_Wrist : AInfoData

// runtime usage
public AInfo instance; (WristInfo)

public void Setup(AInfo info) { }

对于 Unity 工作流，我要求显式 class 是非通用的。因此，此解决方法可能是最佳解决方案。缺点：这里没有给出所需的类型安全。

嵌套泛型的继承/抽象中的嵌套泛型class C#

Inheritance of nested generics / nested generics in abstract class C#

c#

generics

abstract