Ordre de paramètre recommandé

Question

Je travaille sur un système logiciel hérité et j'ai été chargé de migrer certains anciens composants COM vers .NET 3.5. Les composants COM étaient initialement hébergés dans MTS, puis dans les services de composants. Dans le port .NET, nous gérons des transactions avec des transactions ADO.NET, de sorte que les signatures de méthodes changent quelque peu.

Le dilemme auquel je fais face est l'ordre des paramètres. Chaque méthode nécessite que vous lui transmettiez SqlConnection ou SqlTransaction (selon que la méthode met à jour ou non la base de données). Certaines méthodes peuvent, naturellement, être invoquées avec des arguments différents. Par exemple:

Keyword.Load(string description, SqlTransaction transaction) 

--OU--

Keyword.Load(string description, string tag, SqlTransaction transaction) 

Maintenant, la plupart des méthodes dans le cadre qui fournissent le font plusieurs surcharges comme suit:

A(int arg1) 
A(int arg1, string arg2) 
A(int arg1, string arg2, DateTime arg3) 

Notamment, l'ordre des paramètres est cohérent malgré les surcharges. Cependant, je voudrais vraiment souligner l'exigence pour l'utilisateur de transmettre une connexion ou une transaction. Généralement, ce sont les derniers arguments spécifiés. Mais il me semble que le meilleur endroit pour les mettre est le paramètre 0:

A(SqlTransaction transaction) 
A(SqlTransaction transaction, int arg1) 

Malheureusement, lorsque cela tombe en panne est dans la déclaration de la surcharge qui prend ni connexion ni une transaction et un crée pour vous:

// These overloads create a connection, open it, and start a new transaction. 
A() 
A(int arg1) 
A(int arg1, string arg2) 
A(int arg1, string arg2) 
A(int arg1, string arg2, DateTime arg3) 

// These overloads require that the transaction be passed in, so that the method 
// can take part in it. 
A(SqlTransaction transaction) 
A(SqlTransaction transaction, int arg1) 
A(SqlTransaction transaction, int arg1, string arg2) 
A(SqlTransaction transaction, int arg1, string arg2, DateTime arg3) 

Comme vous pouvez le voir, il faut plus pour obtenir les surcharges droite, mais l'accent mis sur la transaction ou la connexion semble un peu plus clair pour moi.

Si vous étiez moi, quel chemin choisiriez-vous? Existe-t-il une directive de conception qui stipule comment les scénarios de ce type doivent être traités? Est-ce trop de surcharges à gérer?

Answer 1

Droit des lignes directrices de conception Cadre:

ne soyez cohérent dans l'ordre et la désignation des paramètres de la méthode.

Edit:

Si vous ne voulez pas suivre la ligne directrice, je casserais les méthodes distinctes en surcharge comme ceci:

A() 
A(int arg1) 
A(int arg1, string arg2) 
A(int arg1, string arg2) 

et

AWithTransaction(SqlTransaction transaction) 
AWithTransaction(SqlTransaction transaction, int arg1) 
AWithTransaction(SqlTransaction transaction, int arg1, string arg2) 
AWithTransaction(
    SqlTransaction transaction, 
    int arg1, 
    string arg2, 
    DateTime arg3 
) 

En en particulier, je dirais

Keyword.Load(string description) 
Keyword.Load(string description, string tag) 

et

Keyword.LoadWithTransaction(SqlTransaction transaction, string description) 
Keyword.LoadWithTransaction(
    SqlTransaction transaction, 
    string description, 
    string tag 
)