Come si fa a gestire le preferenze degli utenti?

Question

Come la maggior parte del software, gli utenti sono in grado di specificare in che modo vorrebbero gestire certe cose. Nel mio caso, gli utenti possono specificare che tipo di formattazione che preferirebbe. Ci sono 3 opzioni, lasciare non formattato, caso cammello o caso corretto. Al momento ho farlo funzionare ma si sente molto goffo e ripetitivo. Ecco una jist della 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;
    }
}

Il metodo in sé non si sente davvero goffo. E 'il modo in cui è stato chiamato. dover sempre passare le preferenze dell'utente ogni volta che voglio ottenere il testo formattato non sembra il modo migliore per andare. Sarei meglio fare una classe normale e passare l'applicazione delle preferenze oggetto attraverso il costruttore?

Grazie.

Answer 1

Una possibilità potrebbe essere quella di creare una sorta di classe factory, è quindi possibile creare un'istanza della classe in fabbrica con o dal istanza della classe che contiene le preferenze.

Uso della classe fabbrica è possibile ottenere un TextFormatter, l'istanza del formattatore restituita dipenderà dalle preferenze.

Ecco un esempio molto semplice solo per chiarire la mia risposta con un codice. Questo non è super elegante e può potenzialmente utilizzare i modelli più sofisticati, ma si spera il giusto punto di partenza.

Definisci un'interfaccia e alcuni formattatori

  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;
    }
  }

Ora una classe preferenze campione

  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.");
      }      
    }
  }

Utilizzando il codice

// 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");