Comment gérez-vous les préférences de l'utilisateur?

Question

Comme la plupart des logiciels, les utilisateurs sont en mesure de préciser comment ils aimeraient gérer certaines choses. Dans mon cas, les utilisateurs peuvent spécifier quel type de formatage qu'ils préféreraient. Il y a 3 options, congé non formaté, cas de chameau ou cas approprié. J'ai actuellement fonctionner, mais il se sent très maladroit et répétitif. Voici un jist de la classe.

public static class Extensions
{
    public static string GetPreferenceFormattedText(this string text, ApplicationPreferences applicationPreferences, bool pluralize)
    {
        if (applicationPreferences.FieldNamingConvention.Equals(FieldNamingConvention.SameAsDatabase))
            return text;
        string formattedText = text.Replace('_', ' ');
        formattedText = formattedText.MakeTitleCase();
        formattedText = formattedText.Replace(" ", "");

        if (applicationPreferences.FieldNamingConvention.Equals(FieldNamingConvention.Prefixed))
            return applicationPreferences.Prefix + formattedText;

        return applicationPreferences.FieldNamingConvention.Equals(FieldNamingConvention.CamelCase)
                   ? formattedText.MakeFirstCharLowerCase()
                   : formattedText;
    }
}

La méthode elle-même ne se sent pas vraiment maladroit. C'est la façon dont il est appelé. Toujours avoir à passer chaque fois que je veux obtenir le texte formaté ne semble pas la meilleure façon d'aller les préférences de l'utilisateur. Serais-je mieux de faire une classe régulière et passer les préférences objet d'application par le constructeur?

Merci.

Answer 1

Une option serait de créer une sorte de classe d'usine, vous pouvez instancier la classe d'usine ou de l'instance de la classe contenant les préférences.

Utilisation de la classe d'usine, vous pouvez obtenir un TextFormatter, l'instance du formatter retourné dépendra des préférences.

Voici un exemple très simple juste pour clarifier ma réponse avec un code. Ce n'est pas super chic et peut potentiellement utiliser des modèles plus Sophistiqué, mais il est, espérons-le bon point de départ.

Définir une interface et certains traducteurs

  public interface IIdentifierFormatter
  {
    string FormatText(string text);
  }

  public class UnformattedIdenifierFormatter : IIdentifierFormatter
  {
    public string FormatText(string text)
    {
      return text;
    }
  }

  public class CamelCaseIdenifierFormatter : IIdentifierFormatter
  {
    public string FormatText(string text)
    {
      // Camel case formatting here
      return text;
    }
  }

  public class ProperCaseIdenifierFormatter : IIdentifierFormatter
  {
    public string FormatText(string text)
    {
      // Proper case formatting here
      return text;
    }
  }

Maintenant, un échantillon classe préférences

  enum NamingConvention 
  {
    Unformatted,
    CamelCase,
    ProperCase
  }

  public class Preferences
  {
    public NamingConvention FieldNamingConvention { get; set; }
    // .. Other settings


    // Function to get the formatter depending on the FieldNamingConvention
    public IIdentifierFormatter GetFieldNameFormatter()
    {
      switch (FieldNamingConvention)
      {
        case NamingConvention.Unformatted:
          return new ProperCaseIdenifierFormatter();
        case NamingConvention.CamelCase:
          return new ProperCaseIdenifierFormatter();
        case NamingConvention.ProperCase:
          return new ProperCaseIdenifierFormatter();          
        default:
          throw new Exception("Invalid or unsupported field naming convention.");
      }      
    }
  }

En utilisant le code

// Preferences loaded from some source,
// for the example I just initialized it here.      
  Preferences pref = new Preferences();
  pref.FieldNamingConvention = NamingConvention.CamelCase;

  // Get the formatter
  IIdentifierFormatter formatter = pref.GetFieldNameFormatter();

  string formatted = formatter.FormatText("the_name_to_format");