Wie gehen Sie mit Benutzereinstellungen?

Question

Wie die meisten Software, können Benutzer angeben, wie sie möchten, dass bestimmte Dinge zu handhaben. In meinem Fall kann der Anwender festlegen, welche Art von Formatierung sie würden es vorziehen. Es gibt 3 Möglichkeiten, lassen Sie unformatiert, Kamel Fall oder richtiger Fall. Im Moment habe ich es funktioniert, aber es fühlt sich sehr klobig und repetitiv. Hier ist ein jist der Klasse.

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

Das Verfahren selbst ist nicht wirklich klobig fühlen. Es ist so, wie es genannt wird. Immer mit den Benutzereinstellungen jedes Mal, wenn ich den formatierten Text zu erhalten, will passieren scheint nicht wie der beste Weg zu gehen. Würde ich besser dran, eine reguläre Klasse zu machen und die Anwendung übergeben Präferenzen durch den Konstruktor Objekt?

Danke.

Answer 1

Eine Möglichkeit wäre, eine Art von Factory-Klasse zu erstellen, können Sie dann die Factory-Klasse instanziiert mit oder von der Instanz der Klasse, die Präferenzen enthält.

Mit der Factory-Klasse können Sie einen TextFormatter bekommen, die Instanz des Formatierungsprogramm zurückgegeben wird von den Vorlieben ab.

Hier ist ein sehr einfaches Beispiel nur meine Antwort mit einigem Code zu klären. Dies ist nicht super schicke und kann möglicherweise auch kompliziertere Muster verwenden, aber es ist hoffentlich der richtige Ausgangspunkt.

Definieren Sie eine Schnittstelle und einige Formatierer

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

Jetzt eine Probe Vorlieben Klasse

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

Mit dem 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");