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，而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进行限制，但这种方法并非如此。

我不能上班的最后一个要求是：我有一个显式Info的实例，并想在一个函数中处理它，该函数还可以使用其对应的Datas处理所有其他继承的Infos。

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

最终可能需要使用这种数据结构：

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 2

您尝试过吗：

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 3

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

例如：

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 HUDExtremelySpecificInfo : A_GUI_Info<HUDExtremelySpecificInfoData> { .. }）

或仅一个：

Event updateEvent = service.events().move(yourCalendarId, event_.getId(), "xyz@gmail.com").execute();

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工作流，我要求显式类是非泛型的。因此，此解决方法可能是最好的解决方案。缺点：此处未提供所需的类型安全性。

嵌套泛型/抽象类C＃中的嵌套泛型的继承

4 个答案: