Generify classes that reference themselves.

Question

Is there any way to generify this two classes?

class Tag1{
  public Tag1 Parent{get;set;}
}

class Tag2{
  public Tag2 Parent{get;set;}
}

So I will have:

class Tag1 : Tag{}

class Tag2 : Tag{}

Seems no, but possible that I missed something global.

Thanks to Jon, I ended with the following solution:

class Tag1 : Tag<T> {
   public T Parent {get;set;}

  public T AddNew(){
      return new T(){Parent = (T)this;} // This works
  }
}

Answer 1

Heh... my first thought was this:

public class ParentizedClass<T>
{
   public T Parent {get; set;}
}

But then I thought... "no, that can't work."

I don't believe it's possible.

Hmm... working on it some more, you could use an interface:

public interface ParentizedClass<T>
{
   public T Parent {get; set;}
}

And then have the class implement the interface using itself as the base class:

public class MyClass : ParentizedClass<MyClass>
{
    public MyClass Parent {get; set;}
}

But I can't check that for validity at the moment.

Answer 2

How about:

class Tag<T>
{
    public Tag<T> Parent{get; set;}
}

?

Answer 3

Okay, slightly messier than before, and the subclass needs to do a bit more work, but...

public abstract class SelfRef<T> where T : SelfRef<T>
{
    private readonly Func<T> childFactory;

    public T Parent { get; set; }

    protected SelfRef(Func<T> childFactory)
    {
        this.childFactory = childFactory;
    }

    public T AddNew()
    {
       return childFactory();
    }
}

public sealed class Ref1 : SelfRef<Ref1>
{
    public Ref1()
        : base(() => new Ref1 { Parent = this })
    {            
    }
}

I think that meets the requirements. Note that you'll always have trouble implementing a hierarchy more than one level deep under SelfRef however you do it, so don't bother :)

You could potentially make the child factory take the new parent. Basically the type relationship you really want - that T = (the same type deriving from SelfRef<T>) - can't be expressed in .NET generics, which is why you have a slight mess.

Answer 4

Here is nice hairy example:

  class Pair<TCar, TCdr>
  {
    public TCar Car { get; set; }
    public TCdr Cdr { get; set; }
  }

  class List<T> : Pair<T, List<T>>, IEnumerable<T>
  {
    public List(T car, List<T> cdr)
    {
      Car = car;
      Cdr = cdr;
    }

    IEnumerator<T> IEnumerable<T>.GetEnumerator()
    {
      yield return Car;
      var cdr = Cdr;
      while (cdr != null)
      {
        yield return cdr.Car;
        cdr = cdr.Cdr;
      }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
      return ((IEnumerable<T>)this).GetEnumerator();
    }
  }