Classe enfant C # renvoyant un type inconnu (plus: du parent)

Question

j'ai une interface:

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

classe simple avec ce metod

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

et classe parent comme ça:

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

je veux retourner le type de parent à partir de Set metod dans la classe enfant C'est possible ? J'ai besoin de faire quelque chose comme ça:

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

Maintenant, je dois le faire:

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

Et son petit ennuyeux, je dois l'utiliser plusieurs fois

Désolé pour le spammeur bien hmm je peux utiliser quelque chose comme ça:

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

alors peut-être que la bonne solution est de retourner un objet de cette méthode; \?

bien classe générique avec interface générique semble être une grosse perte de mémoire ... fonction beacose de cette classe sont les mêmes que le type de retour est différent

Answer 1

Est-ce ce que vous voulez?

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: Il est préférable de déplacer l'implémentation d'interface vers la classe de base, comme l'a dit 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

La seule façon de le faire serait de rendre le Base générique (Base<T>) et de Set renvoyer T - puis de Parent : Base<Parent>. Le problème est ... comment where T : new() saurait-il créer le <=>? Vous pourriez avoir la <=> clause ...

Un aspect intéressant ici est que vous pouvez déplacer l'implémentation d'interface dans <=>:

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

Eh bien, si j'utilise la classe de base générique, je ne peux pas convertir la classe parente en un type, Je ne sais pas pourquoi j'ai essayé d'utiliser générique là-bas ... j'ai trouvé la solution maintenant:)

merci de l'aide

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));
   // ...
}