Comment rendre cette classe plus réutilisable? (Exemple spécifique à l'intérieur)

Question

J'ai une méthode qui prend actuellement un IList comme paramètre, où UserBO est similaire à ce qui suit:

public class UserBO { 
    public string Username { get; set; } 
    public string Password { get; set; } 
    public string Pin { get; set; } 
} 

public class SomeClass { 
    // An example method giving the basic idea of what I need to do 
    public void WriteUsers(IList<UserBO> users) { 
     // Do stuff with users 
     for (var user in users) { 
      Console.WriteLine(String.Format(User: {0}: {1}, users.Username, Hash(users.Pin)); // Now needs to optionally be users.Password 
     } 
    } 

    private string Hash(string pin) { 
     return // Hashed Pin 
    } 
} 

Cette méthode utilise ensuite les paires Nom d'utilisateur/Pin pour créer une XML utilisé par un autre programme (nous utiliserons la méthode ci-dessus comme exemple). La chose est, maintenant je dois être capable de produire le même code, sauf en utilisant le champ Mot de passe au lieu du champ Pin (il y a une bonne raison pour avoir les deux champs). Au lieu de simplement créer une autre méthode avec un nom similaire, je préfèrerais refactoriser le code de manière à supprimer complètement le code spécifique à BO de cette classe, et faire en sorte que la décision concernant la classe/les membres à utiliser sont faites non pas dans la méthode elle-même mais dans le code qui l'appelle.

Une option serait de passer un IDictionary et d'utiliser la méthode Linq ToDictionary pour créer un dictionnaire à la volée dans le code appelant. Cela perdrait cependant la commande des articles (ce qui serait bien mais pas indispensable à conserver). Je pourrais utiliser un IList ou quelque chose, mais ce serait plus difficile de convertir le IList en.

Est-ce que quelqu'un a de bonnes suggestions sur la façon de procéder?

P.S. Si quelqu'un a une meilleure idée de comment intituler ce post, n'hésitez pas à y aller.

Answer 1

Vous pouvez également utiliser des expressions:

WriteUsers(IList<T> users, u => u.Username, u => u.Password); 

si vous utilisez Net 3.5.

Answer 2

Ce n'est pas clair exactement ce que vous devez faire avec les chaînes après le formatage. Vous pourriez faire la méthode prendre un IEnumerable<string>, puis faire le code d'appel:

WriteUsers(users.Select(user => string.Format("{0}: {1}", 
               users.Username, users.Pin))); 

Que qui fonctionne pour vous ou non dépendra des détails.

Answer 3

Tout d'abord, pour des raisons de convivialité, je vous recommande de basculer votre IList sur un IEnumerable. Pourvu que vous ne fassiez aucune autre logique qui nécessite la liste, il ouvre votre classe à être utilisable par plus d'utilisateurs, et n'a aucun inconvénient.

Si vous voulez éliminer complètement la sélection de ce qui est imprimé à partir de votre classe, je peux penser à quelques options.

Un (bien que potentiellement moins utilisable) serait d'utiliser la réflexion. Si perf. n'est pas un énorme problème, vous pouvez refactoriser avoir quelque chose comme:

WriteElements (éléments IEnumerable, params string [] propertiesToWrite)

vous pourriez juste factoriser la méthode pour qu'il utilise la réflexion pour obtenir le propriétés du spécificateur de type pour T, et d'écrire un certain nombre d'entre eux.L'appelant aurait alors faire:

WriteElements(listOfUsers, "Username", "Password"); 

Un second, probablement plus propre, l'option serait de factoriser à prendre:

WriteElements(IEnumerable<UserBO>, Func<UserBO,string>); 

Vous pouvez ensuite appeler avec:

// Call using password 
WriteElements(listOfUsers, user => user.Password); 

// or call using pin 
WriteElements(listOfUsers, user => user.Pin);