Créer une nouvelle instance de type générique convertit en type racine?

Question

J'essaye actuellement de cloner un type personnalisé dans mon projet XNA que j'appelle "Component", en le faisant ressembler à ceci.

public static TComponent CloneComponent<TComponent>(this TComponent source) where TComponent : Component, new() 
{ 
    TComponent clone = new TComponent(); //Create the new instance 

    //Clone the source code here 

    return clone; 
} 

Dans mon projet, il est en fait le code du clonage dans ma méthode, mais comme il n'a rien à ma question de faire je l'ai enlevé.

Pour une explication sur ma classe de composant, j'ai la classe racine appelée Component mais ensuite je crée des classes qui dérivent de Component que j'essaye de cloner.

Ainsi, par exemple, je pourrais avoir un composant appelé "PlayerController":

class PlayerController: Component 

Donc, si je veux cloner une entrée PlayerController I que l'argument de type; TComponent doit être de type PlayerController.

Supposons que j'essaie de cloner un composant PlayerController.

Si je déboguer le nom du composant source, qui est GetType().ToString() dans le composant:

Debug.WriteLine(source.name); 

je reçois la sortie « PlayerController ».

Donc, cela signifie que TComponent est de type PlayerController, n'est-ce pas?

Cependant, si je débogue le nom du clone, une nouvelle instance de TComponent, j'obtiens la sortie "Component". Cela signifie que pour une raison quelconque, ma nouvelle instance de TComponent a été convertie en type racine?

Ce qui est intéressant est que quand je recrée cela dans une application console, je ne comprends pas cette erreur ...

Modifier:

Test à la source:

static class Program 
{ 
    static void Main(string[] args) 
    { 
     PlayerController e = new PlayerController(); 
     PlayerController eClone = Extensions.CloneComponent(e); 

     Console.WriteLine(e.name); 
     Console.WriteLine(eClone.name); 
    } 


} 

public class Component 
{ 

} 

public class PlayerController : Component 
{ 

} 

public static class Extensions 
{ 
    public static TComponent CloneComponent<TComponent>(this TComponent source) where TComponent : Component, new() 
    { 
     var clone = new TComponent(); 

     var srcProperties = System.ComponentModel.TypeDescriptor.GetProperties(typeof(TComponent)).Cast<System.ComponentModel.PropertyDescriptor>(); 

     foreach (var srcProperty in srcProperties) 
     { 
      srcProperty.SetValue(clone, srcProperty.GetValue(source)); 
     } 

     return clone; 
    } 
} 

Qu'est-ce que cette sorties dans la console est:

PlayerController
Jouer erController

Cela signifie que TComponent est en fait le type de la source. Comment ne pas obtenir les mêmes résultats dans mon projet quand je fais exactement la même chose?

Edit 2:
Le paramètre source est prise à partir d'une liste des composants, et donc apparemment il est converti en type de racine quand il est utilisé comme argument ... Quand je le débugger est bon type avant qu'il me donne la type correct. Je suppose que je vais devoir faire une autre question sur la façon de contourner cela.

Answer 1

Je ne sais pas vraiment quelle est votre véritable question. Votre code semble bien et semble vous donner le PlayerController comme vous le souhaitez.Si je lance le code ci-dessous, je reçois:

Source: Tester.PlayerComponent, clone: Tester.PlayerComponent 

Source:

namespace Tester 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      var item = new PlayerComponent() {Name = "PlayerOne"}; 
      var item2 = item.CloneComponent(); 

      Console.ReadLine(); 
     } 
    } 


    public static class Extensions 
    { 
     public static TComponent CloneComponent<TComponent>(this TComponent source) where TComponent : Component, new() 
     { 
      TComponent clone = new TComponent(); //Create the new instance 

      //Clone the source code here   
      Console.WriteLine($"Source: {source.GetType()}, clone: {clone.GetType()}"); 

      return clone; 
     } 
    } 

    public class Component 
    { 
    } 

    public class PlayerComponent : Component 
    { 
     public string Name { get; set; } = "Test"; 
    } 
} 

Answer 2

Je pense que ce qui vous manque est que les types génériques en C# sont instanciés au moment de la compilation. Cela signifie que le type de TComponent est défini en fonction du type (de compilation statique) du source que vous transmettez à CloneCompenent. Le fait que l'objet réel contenu dans ce source puisse être d'un autre type ne peut pas être vu par le compilateur.

Puisque vous ne pouvez pas connaître le type dynamique de votre objet, vous devez utiliser l'héritage et déléguer l'opération de clonage au type réel. Dans la classe de composants:

public static Component CloneComponent(this Component source) => return source.CloneMyself(); 

Dans la classe PlayerComponent:

public Component CloneMyself() { 
    var clone = new PlayerComponent(this); // special constructor takes self type 
    return (Component) clone; 
}