Question

我正在尝试创建一个通用类，它将具有嵌套的成员类，这将是一些模板。我在派生成员上使用泛型但不确定如何确保正确定义主类以允许通用的泛型。

我的第一个实现是对象类型，但是我想在定义中使用泛型。

提供的是当前的3级

结构层次结构，类似于旁观记录。

{event template} ---＆gt; {event context} - ＆gt; {event record}

// templates

public class EventTemplate1
{
    public string name { get; set; }

    // ..... other members 
    public string template1 { get; set; }
}

public class EventTemplate2
{
    public string name { get; set; }
    // ..... other members 
    public string template2 { get; set; }
}

// context

public class EventData<T>
{

    protected T _context;
    // ..... other  

    public EventData(T t)
    {
        this._context = t;
    }

    // ..... other members 

    public T Context
    {
        get { return _context; }
        set { _context = value; }
    }

}

记录详细信息（带对象）

public class writeClass 
{

    // ..... other members 
    public object data { get; set; }

}

//用对象调用代码

   Template1 temp1 = new Template1();
        temp1.name = "test 1";

        writeClass writeEvent = new writeClass();
        writeEvent.data = temp1;

更改为支持writeClass中的泛型

public class writeClass <T> where T : EventData<T>
{
    public writeClass(T t)
    {
        data = t;
    }
    // ..... other members 
    public EventData<T> data { get; set; }

}

当我试着打电话给它时，它并没有按预期工作，所以我在这里错过了一些重要的事情。

Answer 1

<强>问题

public class writeClass <T> where T : EventData<T>

解析为

   public class writeClass <EventData<EventData<EventData<EventData<EventData....>>>> where T : EventData<T>

<强>解决方案

为EventData创建一个BaseClass

 public class BaseEventTemplate {
        public string name { get; set; }
    }

public class EventTemplate1 : BaseEventTemplate {
    // ..... other members 
    public string template1 { get; set; }
}

public class EventTemplate2: BaseEventTemplate {
    // ..... other members 
    public string template2 { get; set; }
}

public class EventData<T> where T : BaseEventTemplate {
  protected T _context;
// ..... other  

public EventData(T t)
{
    this._context = t;
}

// ..... other members 

public T Context
{
    get { return _context; }
    set { _context = value; }
}

}

更改writeClass中的约束，如下所示

public class writeClass <T> where T : EventData<BaseEventTemplate>  {
    public writeClass(T t)
    {
        data = t;
    }
    // ..... other members 
    public EventData<BaseEventTemplate> data { get; set; }

}

调用对象

  Template1 temp1 = new Template1();
  temp1.name = "test 1";

  writeClass writeEvent = new writeClass(temp1);
  Foo foo = writeEvent.data;

<强>溶液2

通过创建writeClass

的接口，为每个派生类型创建writeClass的特定实现

public interface IWriteClass<T> : where T : EventData<BaseEventTemplate>

public class WriteTemplate1 : IWriteClass<EventData<Template1>

public class WriteTemplate2 : IWriteClass<EventData<Template2>

Solution2或多或少是Solution1的补充。但是，如果您不使用接口，则必须在writeClass类中检查参数的类型并将其转换为特定类型。

如何使用嵌套变量，该变量是基于通用类的成员

1 个答案: