¿Cómo manejas las preferencias del usuario?

Question

Al igual que la mayoría del software, los usuarios pueden especificar cómo les gustaría manejar ciertas cosas. En mi caso, los usuarios pueden especificar qué tipo de formato preferirían. Hay 3 opciones, deje sin formato, estuche de camello o estuche adecuado. Actualmente lo tengo funcionando, pero se siente muy torpe y repetitivo. Aquí hay una frase de la clase.

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

El método en sí no se siente torpe. Es la forma en que se la llama. Siempre tener que pasar las preferencias del usuario cada vez que quiero obtener el texto formateado no parece ser la mejor manera de hacerlo. ¿Sería mejor hacer una clase normal y pasar el objeto de preferencias de la aplicación a través del constructor?

Gracias.

Answer 1

Una opción sería crear algún tipo de clase de fábrica, luego puede instanciar la clase de fábrica con o desde la instancia de la clase que contiene las preferencias.

Usando la clase de fábrica puede obtener un TextFormatter, la instancia del formateador devuelto dependerá de las preferencias.

Aquí hay un ejemplo muy simple solo para aclarar mi respuesta con algún código. Esto no es muy sofisticado y puede potencialmente utilizar patrones más sofisticados, pero es de esperar el punto de partida correcto.

Definir una interfaz y algunos formateadores

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

ahora una clase de preferencias de muestra

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

Utilizando el código

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