Création et initialisation de différents sous-types sans beaucoup de coulée

Question

Je suis sûr que je suis en train de déconner avec beaucoup de casting et tel dans ce code ci-dessous. Il semble qu'il devrait y avoir une façon plus douce. Essentiellement, j'essaie d'utiliser une méthode de construction (CreateNewPattern) pour gérer la création de nouveaux objets du type de sous-classe transmis (par les méthodes CreateNewCircularPattern et CreateNewLinePattern). Je n'ai actuellement que deux types sous-classifiés CircularHolePattern et SingleLineHolePattern qui héritent de HolePattern, mais je m'attends à en avoir plus au fur et à mesure que mon application se développe.

Est-ce un endroit pour utiliser un délégué ou un lambda? Il n'en sait rien, alors soyez aussi précis que possible avec des suggestions de code.

private CircularHolePattern CreateNewCircularPattern() 
{ 
    var CreatedPattern = CreateNewPattern(typeof(CircularHolePattern)); 
    return (CircularHolePattern)CreatedPattern; 
} 


private SingleLineHolePattern CreateNewLinePattern() 
{ 
    var CreatedPattern=CreateNewPattern(typeof(SingleLineHolePattern)); 
    return (SingleLineHolePattern)CreatedPattern; 
} 

private HolePattern CreateNewPattern(Type PatternTypeToCreate) 
{ 
    var NewHolePattern = (HolePattern)Activator.CreateInstance(PatternTypeToCreate); 
    NewHolePattern.PatternName = "Pattern #" + (HolePatterns.Count + 1).ToString(); 
    this.AddPattern(NewHolePattern); 
    this.SetActivePattern(NewHolePattern); 
    return NewHolePattern; 
} 

Answer 1

Je suppose que vous voulez génériques:

private T CreateNewPattern<T>() where T : HolePattern, new() 
{ 
    var newHolePattern = new T(); 
    newHolePattern.PatternName = "Pattern #" + 
     (HolePatterns.Count + 1).ToString(); 
    this.AddPattern(newHolePattern); 
    this.SetActivePattern(newHolePattern); 
    return newHolePattern;   
} 

private SingleLineHolePattern CreateNewLinePattern() { 
    return CreateNewPattern<SingleLineHolePattern>(); 
} 

private CircularHolePattern CreateNewCircularPattern() { 
    return CreateNewPattern<CircularHolePattern>(); 
} 

Le T est le type argument générique; le type que nous voulons créer. Le where indique "il doit être HolePattern ou un sous-type, et il doit avoir un constructeur public sans paramètre" - ceci nous permet d'utiliser new T() pour en créer une nouvelle instance, et accéder à tous les membres de HolePattern par rapport à de telles instances (PatternName). Cela nous permet également d'appeler les méthodes qui acceptent un HolePattern en tant qu'argument.

Answer 2

Pour un, vous pouvez réduire les ... Créer des méthodes de modèle pour

private CircularHolePattern CreateNewCircularPattern() 
{ 
    return CreateNewPattern(typeof(CircularHolePattern)); 
} 

Une autre suggestion pourrait être seulement le travail dans les abstractions. Par exemple, renvoyez uniquement les types HolePattern à partir des méthodes Create ... Pattern au lieu de leurs types concrets tels que CircularHolePattern. Vous les rejetez dans HolePattern dans tous les cas.

Ainsi, CreateNewCircularPattern devient

private HolePattern CreateNewCircularPattern() 
{ 
    return CreateNewPattern(typeof(CircularHolePattern)); 
}