C classe # infantile retour d'un type inconnu (futher: de parent)

Question

i ont une interface:

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

classe simple avec ce metod

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

et classe mère comme ça:

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

Je veux retourner Type de parent de Set metod dans la classe enfant C'est possible? Je dois le faire à quelque chose comme ça:

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

Maintenant, je dois faire:

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

Et son peu ennuyeux, je dois utiliser beaucoup de temps

---

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

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

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

classe bien générique avec interface générique semble ce être grand gaspillage de mémoire ... beacose fonction de cette classe sont les mêmes que le type de retour est diffrent

Answer 1

Est-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 la mise en œuvre d'interface jusqu'à la classe de base comme Marc dit:

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 que vous pourriez le faire serait de rendre le (générique BaseBase<T>) et ont Set retourner T - puis avoir Parent : Base<Parent>. Le problème est ... comment Set savoir comment créer le T? Vous pourriez avoir la clause where T : new() ...

Un utile de côté ici est que vous pouvez déplacer la mise en œuvre d'interface dans Base<T>:

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

bien si j'utilise la classe de base générique je ne peux pas jeter classe parent à un type, Je ne sais pas pourquoi je l'ai essayé d'utiliser ... il générique que j'ai trouvé la solution maintenant :)

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