Méthode unique pour plusieurs types?

Question

Dans le cas où vous avez une fonction qui fonctionne pour beaucoup de différents types personnalisés avec la même mise en œuvre, est-il correct d'utiliser un modèle de conception comme celui-ci ?:

type1 implicitly casts to type0 
type2 implicitly casts to type0 
type3 implicitly casts to type0 

Operate (type0) 

et appelez:

type1 a 
type2 b 
type3 c 

Operate (a) 
Operate (b) 
Operate (c) 

Y a-t-il des problèmes avec cette technique? Performance sage, clarté, etc?

EDIT: Également par moulage implicite, je voulais dire moulages personnalisés pour le type sans perte de données, juste commodité. Supposons que vous ayez une classe Pixel, puis en envoyant une instance de cette méthode à une méthode qui prend un point2, le pixel est automatiquement envoyé à un point2.

Answer 1

Ceci est une pratique parfaitement normale.

Performance sage, je ne crois pas qu'il y ait des problèmes.

Clarté sage, à cause d'Intellisense, vous avez peu de chances d'avoir des problèmes avec ça non plus.

Answer 2

coulée crée généralement un nouvel objet, qui est inutile dans ce cas

Plus façon POO de le faire serait par une classe de base ou d'une interface.

class Type1 : IOperatableType {} 
class Type2 : IOperatableType {} 
class Type3 : IOperatableType {} 

void Operate (IOperatableType a) 

ou

class Type1 : Type0 {} 
class Type2 : Type0 {} 
class Type3 : Type0 {} 

void Operate (Type0 a) 

La méthode appelante (fonctionner dans ce cas) dépend de l'utilisation des méthodes ou des propriétés de ses paramètres. Si ces propriétés/méthodes sont définies sur tous les types (type1, type2, type3), pensez à utiliser une interface qui définit une fonctionnalité commune. Si l'implémentation des propriétés et méthodes est la même, sauvegardez-vous du code répété et pensez à hériter d'une classe de base. En outre, lorsque vous essayez de comprendre votre code, les développeurs sont plus susceptibles de regarder d'abord un diagramme de classes, ce qui leur permet de voir la relation entre les classes, ou au moins la définition de classe (qui montrera les types de base et interfaces) plutôt que d'examiner les opérateurs (implicites/explicites) pour voir quelle classe est transposable à quelle autre classe.

Answer 3

C'est la base du fonctionnement des interfaces.

public interface IBlah { 
    void DoSomething(); 
} 
public class Type1 : IBlah { 
    void DoSomething() { /* implementation */ } 
} 
public class Type2 : IBlah { 
    void DoSomething() { /* implementation */ } 
} 
public class Type3 : IBlah { 
    void DoSomething() { /* implementation */ } 
} 

public class Foo { 
    void Operate(IBlah blah) { 
     blah.DoSomething(); 
    } 
}