Classe figlio C # che restituisce un tipo sconosciuto (altro: dal genitore)

Question

ho un'interfaccia:

public interface Inx<T>
{
   T Set(Data data);
}

classe semplice con questo metodo

public class Base
{
   ??? Set(Data data) { ... }
}

e classe genitore del genere:

public class Parent : Base, Inx<Parent>
{
   ...
}

Voglio restituire il tipo Parent da Set metod in child class È possibile ? Ho bisogno che faccia qualcosa del genere:

list.Add(new Parent().Set(data));

Ora devo farlo:

T t = new T();
t.Set(data);
list.Add(t);

Ed è un po 'fastidioso, devo usarlo molte volte

---

Mi dispiace per lo spaming bene hmm posso usare qualcosa del genere:

this.GetType().GetConstructor(new System.Type[] { typeof(Data) }).Invoke(new object[] { data })

quindi forse una buona soluzione è restituire un oggetto da questo metodo; \?

bene la classe generica con interfaccia generica sembra essere un grande spreco di memoria ... perché le funzioni di questa classe sono uguali, solo il tipo di ritorno è diverso

Answer 1

È questo quello che vuoi?

interface Inx<T> { 
    T Set(Data data);
}
public class Base
{
    public virtual T Set<T>(Data data)
    {
        T t = default(T);
        return t;
    }
}
public class Parent : Base, Inx<Parent>
{
    public Parent Set(Data data)
    {
        return base.Set<Parent>(data);
    }
}
class Program
{
    static void Main(string[] args)
    {
        var data = new Data();
        var list = new List<Parent>();
        list.Add(new Parent().Set<Parent>(data));
        // or 
        list.Add(new Parent().Set(data));
    }
}

EDIT: è meglio spostare l'implementazione dell'interfaccia nella classe Base come ha detto Marc:

interface Inx<T> { 
    T Set(Data data);
}
public class Base<T> : Inx<T>
{
    public virtual T Set(Data data)
    {
        T t = default(T);
        return t;
    }
}
public class Parent : Base<Parent>
{        
}
class Program
{
    static void Main(string[] args)
    {
        var data = new Data();
        var list = new List<Parent>();
        list.Add(new Parent().Set(data));            
    }
}

Answer 2

L'unico modo per farlo sarebbe quello di rendere Base generico (Base<T>) e avere Set ritorno T - quindi avere Parent : Base<Parent>. Il problema è ... come farebbe where T : new() a sapere come creare <=>? Potresti avere la <=> clausola ...

Un utile lato qui è che puoi spostare l'implementazione dell'interfaccia in <=>:

public class Base<T> : Inx<T> where T : new()
{
   public T Set(Data data) {
       T t = new T();
       ///
       return t;
   }
}
public class Parent : Base<Parent> { }

Answer 3

bene, se uso una classe di base generica, non riesco a trasmettere la classe genitore a un tipo, non so perché ho provato a usare il generico lì ... ho trovato la soluzione ora :)

grazie per l'aiuto

interface Inx
{
   object Set(Data data);
}
class Base
{
   object Set(Data data)
   {
      // ...
      return (object) this;
   }
}
class Parent: Base, Inx
{
   // i don't have too write here Set (im using from base one)
}
class ManageParent<T> where T: Inx, new()
{
   // ...
      list.Add((T) new T().Set(data));
   // ...
}