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

Question

i am trying to create a general class which will have a nested member class which will be somewhat template. I am using generics on the derived member but not sure how to ensure the main class should be defined properly to allow generics to be used through out.

My first implementation was object type which works but I was wanting to use generics through out the definition.

provided is the current 3 class

structure hierarchy is, similar to a look aside record.

{ event template } ---> {event context } --> {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; }
    }

}

record details (with object)

public class writeClass 
{

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

}

// calling code with object

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

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

changing to support generics in writeClass

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

}

When I try to call this it doesn't quite work as expected so I am missing some important here.

Answer 1

Problem

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

resolves to

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

Solution

Make a BaseClass for your EventData

 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; }
}

}

Change the constraint in your writeClass like the following

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

}

calling the object

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

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

Solution2

Make a specific implementation of writeClass for every derived type, by creating an interface of writeClass

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

public class WriteTemplate1 : IWriteClass<EventData<Template1>

public class WriteTemplate2 : IWriteClass<EventData<Template2>

Solution2 is more or less an addition to Solution1. But if you don't use an interface you'd have to check the type of your parameter in your writeClass class and cast it into the specific type.