Пов’язування перерахунків із рядками в C #

Я знаю, що наступне неможливо, оскільки тип перерахування повинен бути цілим

enum GroupTypes
{
    TheGroup = "OEM",
    TheOtherGroup = "CMB"
}

З моєї бази даних я отримую поле з незрозумілими кодами ( OEMі CMBі). Я хотів би перетворити це поле на enumщось зрозуміле або щось інше. Тому що, якщо ціль - читабельність, рішення має бути стислим.

Які ще є варіанти?

Мені подобається використовувати властивості в класі замість методів, оскільки вони виглядають більш переглядно.

Ось приклад для Logger:

public class LogCategory
{
    private LogCategory(string value) { Value = value; }

    public string Value { get; set; }

    public static LogCategory Trace   { get { return new LogCategory("Trace"); } }
    public static LogCategory Debug   { get { return new LogCategory("Debug"); } }
    public static LogCategory Info    { get { return new LogCategory("Info"); } }
    public static LogCategory Warning { get { return new LogCategory("Warning"); } }
    public static LogCategory Error   { get { return new LogCategory("Error"); } }
}

Передати в якості параметра безпечні для рядка значення :

public static void Write(string message, LogCategory logCategory)
{
    var log = new LogEntry { Message = message };
    Logger.Write(log, logCategory.Value);
}

Використання:

Logger.Write("This is almost like an enum.", LogCategory.Info);

Ви також можете використовувати модель розширення:

public enum MyEnum
{
    [Description("String 1")]
    V1= 1,
    [Description("String 2")]
    V2= 2
} 

Ваш клас розширення

public static class MyEnumExtensions
{
    public static string ToDescriptionString(this MyEnum val)
    {
        DescriptionAttribute[] attributes = (DescriptionAttribute[])val
           .GetType()
           .GetField(val.ToString())
           .GetCustomAttributes(typeof(DescriptionAttribute), false);
        return attributes.Length > 0 ? attributes[0].Description : string.Empty;
    }
} 

використання:

MyEnum myLocal = MyEnum.V1;
print(myLocal.ToDescriptionString());

Як щодо використання статичного класу з константами?

static class GroupTypes
{
  public const string TheGroup = "OEM";
  public const string TheOtherGroup = "CMB";
}

void DoSomething(string groupType)
{
  if(groupType == GroupTypes.TheGroup)
  {
    // Be nice
  }  
  else if (groupType == GroupTypes.TheOtherGroup)
  {
    // Continue to be nice
  }
  else
  {
    // unexpected, throw exception?
  }
}

Ви можете додати атрибути до елементів перерахунку, а потім використовувати відображення для отримання значень з атрибутів.

Вам потрібно буде використовувати специфікатор "поля", щоб застосувати атрибути, наприклад:

enum GroupTypes
{
    [field:Description("OEM")]
    TheGroup,

    [field:Description("CMB")]
    TheOtherGroup
}

Потім ви б відобразили статичні поля типу enum (у цьому випадку GroupTypes) та отримали DescriptionAttributeзначення, яке шукали за допомогою відображення:

public static DescriptionAttribute GetEnumDescriptionAttribute<T>(
    this T value) where T : struct
{
    // The type of the enum, it will be reused.
    Type type = typeof(T);

    // If T is not an enum, get out.
    if (!type.IsEnum) 
        throw new InvalidOperationException(
            "The type parameter T must be an enum type.");

    // If the value isn't defined throw an exception.
    if (!Enum.IsDefined(type, value))
        throw new InvalidEnumArgumentException(
            "value", Convert.ToInt32(value), type);

    // Get the static field for the value.
    FieldInfo fi = type.GetField(value.ToString(), 
        BindingFlags.Static | BindingFlags.Public);

    // Get the description attribute, if there is one.
    return fi.GetCustomAttributes(typeof(DescriptionAttribute), true).
        Cast<DescriptionAttribute>().SingleOrDefault();
}

Я вирішив повернути DescriptionAttributeсебе вище, якщо ви хочете мати можливість визначити, чи застосовується атрибут навіть ні.

Насправді це можна зробити дуже легко. Використовуйте наступний код.

enum GroupTypes
{
   OEM,
   CMB
};

Тоді, коли ви хочете отримати значення рядка кожного елемента enum, просто використовуйте наступний рядок коду.

String oemString = Enum.GetName(typeof(GroupTypes), GroupTypes.OEM);

Раніше я успішно використовував цей метод, а також використовував клас констант, щоб утримувати строкові константи, обидва працюють досить добре, але я, як правило, віддаю перевагу цьому.

Спробуйте додати константи до статичного класу. Ви не закінчуєте типом, але у вас будуть читані, організовані константи:

public static class GroupTypes {

    public const string TheGroup = "OEM";
    public const string TheOtherGroup = "CMB";

}

Створіть другу перерахунок для вашої БД, що містить наступне:

enum DBGroupTypes
{
    OEM = 0,
    CMB = 1
}

Тепер ви можете використовувати Enum.Parse для отримання правильного значення DBGroupTypes з рядків "OEM" та "CMB". Потім ви можете перетворити їх в int та отримати правильні значення з правого перерахування, яке ви хочете використовувати далі у вашій моделі.

Використовуйте клас.

Правка: кращий приклад

class StarshipType
{
    private string _Name;
    private static List<StarshipType> _StarshipTypes = new List<StarshipType>();

    public static readonly StarshipType Ultralight = new StarshipType("Ultralight");
    public static readonly StarshipType Light = new StarshipType("Light");
    public static readonly StarshipType Mediumweight = new StarshipType("Mediumweight");
    public static readonly StarshipType Heavy = new StarshipType("Heavy");
    public static readonly StarshipType Superheavy = new StarshipType("Superheavy");

    public string Name
    {
        get { return _Name; }
        private set { _Name = value; }
    }

    public static IList<StarshipType> StarshipTypes
    {
        get { return _StarshipTypes; }
    }

    private StarshipType(string name, int systemRatio)
    {
        Name = name;
        _StarshipTypes.Add(this);
    }

    public static StarshipType Parse(string toParse)
    {
        foreach (StarshipType s in StarshipTypes)
        {
            if (toParse == s.Name)
                return s;
        }
        throw new FormatException("Could not parse string.");
    }
}

Інший спосіб вирішити проблему - це перерахунок і масив рядків, які будуть зіставляти значення enum зі списком рядків:

public enum GroupTypes
{
    TheGroup  = 0,
    TheOtherGroup 
}

string[] GroupTypesStr = {
    "OEM",
    "CMB"
};

ви можете використовувати це приблизно так:

Log.Write(GroupTypesStr[(int)GroupTypes.TheOtherGroup]);

Це підкаже CMB

ПРО:

1. Простий і чистий код.
2. Висока продуктивність (особливо порівняно з тими підходами, що використовують класи)

Мінуси:

1. Схильний зіпсувати список під час редагування, але це буде добре для короткого списку.

Ось метод розширення, який я використав для отримання значення enum у вигляді рядка. Спочатку тут - перелік.

public enum DatabaseEnvironment
{
    [Description("AzamSharpBlogDevDatabase")]
    Development = 1, 
    [Description("AzamSharpBlogQADatabase")]
    QualityAssurance = 2, 
    [Description("AzamSharpBlogTestDatabase")] 
    Test = 3
}

Атрибут Опис прийшов від System.ComponentModel.

І ось мій метод розширення:

public static string GetValueAsString(this DatabaseEnvironment environment) 
{
    // get the field 
    var field = environment.GetType().GetField(environment.ToString());
    var customAttributes = field.GetCustomAttributes(typeof (DescriptionAttribute), false);

    if(customAttributes.Length > 0)
    {
        return (customAttributes[0] as DescriptionAttribute).Description;  
    }
    else
    {
        return environment.ToString(); 
    }
}

Тепер ви можете отримати доступ до enum як значення рядка, використовуючи наступний код:

[TestFixture]
public class when_getting_value_of_enum
{
    [Test]
    public void should_get_the_value_as_string()
    {
        Assert.AreEqual("AzamSharpBlogTestDatabase",DatabaseEnvironment.Test.GetValueAsString());  
    }
}

Чи розглядали ви таблицю пошуку за допомогою словника?

enum GroupTypes
{
    TheGroup,
    TheOtherGroup
}

Dictionary<string, GroupTypes> GroupTypeLookup = new Dictionary<string, GroupTypes>();
// initialize lookup table:
GroupTypeLookup.Add("OEM", TheGroup);
GroupTypeLookup.Add("CMB", TheOtherGroup);

Потім ви можете використовувати GroupTypeLookup.TryGetValue () для пошуку рядка під час його читання.

public class DataType
{
    private readonly string value;
    private static readonly Dictionary<string, DataType> predefinedValues;

    public static readonly DataType Json = new DataType("json");
    public static readonly DataType Xml = new DataType("xml");
    public static readonly DataType Text = new DataType("text");
    public static readonly DataType Html = new DataType("html");
    public static readonly DataType Binary = new DataType("binary");

    static DataType()
    {
        predefinedValues = new Dictionary<string, DataType>();
        predefinedValues.Add(Json.Value, Json);
        predefinedValues.Add(Xml.Value, Xml);
        predefinedValues.Add(Text.Value, Text);
        predefinedValues.Add(Html.Value, Html);
        predefinedValues.Add(Binary.Value, Binary);
    }

    private DataType(string value)
    {
        this.value = value;
    }

    public static DataType Parse(string value)
    {
        var exception = new FormatException($"Invalid value for type {nameof(DataType)}");
        if (string.IsNullOrEmpty(value))
            throw exception;

        string key = value.ToLower();
        if (!predefinedValues.ContainsKey(key))
            throw exception;

        return predefinedValues[key];
    }

    public string Value
    {
        get { return value; }
    }
}

C # не підтримує перелічені рядки, але для більшості ситуацій ви можете використовувати Список або Словник, щоб отримати бажаний ефект.

Наприклад, для друку результатів пропуску / помилки:

List<string> PassFail = new List<string> { "FAIL", "PASS" };
bool result = true;
Console.WriteLine("Test1: " + PassFail[result.GetHashCode()]);

Я зробив би це у класі взагалі уникнути перерахунків. А потім за допомогою машинопису ви зможете створити об'єкт, коли захопите його з db.

IE:

public class Group
{
    public string Value{ get; set; }
    public Group( string value ){ Value = value; } 
    public static Group TheGroup() { return new Group("OEM"); }
    public static Group OtherGroup() { return new Group("CMB"); }

}

Я просто створив би словник і використав код як ключ.

Редагувати: Щоб звернутися до коментаря про пошук зворотного пошуку (пошук ключа), це не було б дуже ефективно. Якщо це необхідно, я б написав новий клас, щоб обробити це.

Перше моє запитання - чи маєте ви доступ до самої бази даних? Це слід нормалізувати в базі даних, в ідеалі, інакше будь-яке рішення буде схильне до помилок. З мого досвіду, поля даних, наповнені "OEM" та "CMB", як правило, закінчуються тим, що такі речі, як "oem" та інші "дані про лайно", змішуються з часом .... Якщо ви можете нормалізувати їх, ви можете використовувати ключ в таблиці, що містить елементи, як ваш Enum, і ви закінчили, зі значно більш чистою структурою.

Якщо цього немає в наявності, я б зробив ваш Enum і склав клас для розбору вашої струни в Enum для вас. Це, принаймні, надасть вам деяку гнучкість у застосуванні нестандартних записів та набагато більшу гнучкість для вилучення помилок або помилок обробки, ніж будь-яке обхідне рішення за допомогою Enum.Parse / Reflection / тощо. Словник працював би, але може вийти з ладу, якщо у вас виникнуть проблеми зі справами тощо.

Я рекомендую написати клас, щоб ви могли:

// I renamed this to GroupType, since it sounds like each element has a single type...
GroupType theType = GroupTypeParser.GetGroupType(theDBString);

Це зберігає більшу частину вашої читабельності, не змінюючи БД.

Якщо я правильно розумію, вам потрібно перетворення від рядка до перерахунку:

enum GroupTypes {
    Unknown = 0,
    OEM = 1,
    CMB = 2
}
static GroupTypes StrToEnum(string str){
    GroupTypes g = GroupTypes.Unknown;
    try {
        object o = Enum.Parse(typeof(GroupTypes), str, true);
        g = (GroupTypes)(o ?? 0);
    } catch {
    }
    return g;
}
// then use it like this
GroupTypes g1 = StrToEnum("OEM");
GroupTypes g2 = StrToEnum("bad value");

Якщо ви хочете, ви можете зробити його більш привабливим для загальних даних для типу enum.

У VS 2015 ви можете використовувати nameof

public class LogCategory
{
    public static string Trace;
    public static string Debug;
    public static string Info;
    public static string Warning;
    public static string Error;
}

Використання:

Logger.Write("This is almost like an enum.", nameof(LogCategory.Info));

Невеликий підхід до методу розширення Glennular, тому ви можете використовувати розширення для інших речей, ніж лише ENUM;

using System;
using System.ComponentModel;
namespace Extensions {
    public static class T_Extensions {
        /// <summary>
        /// Gets the Description Attribute Value
        /// </summary>
        /// <typeparam name="T">Entity Type</typeparam>
        /// <param name="val">Variable</param>
        /// <returns>The value of the Description Attribute or an Empty String</returns>
        public static string Description<T>(this T t) {
            DescriptionAttribute[] attributes = (DescriptionAttribute[])t.GetType().GetField(t.ToString()).GetCustomAttributes(typeof(DescriptionAttribute), false);
            return attributes.Length > 0 ? attributes[0].Description : string.Empty;
        }
    }
}

Або за допомогою Linq

using System;
using System.ComponentModel;
using System.Linq;

namespace Extensions {


public static class T_Extensions {
        public static string Description<T>(this T t) =>
            ((DescriptionAttribute[])t
            ?.GetType()
            ?.GetField(t?.ToString())
            ?.GetCustomAttributes(typeof(DescriptionAttribute), false))
            ?.Select(a => a?.Description)
            ?.FirstOrDefault() 
            ?? string.Empty;  
    }
}

Після відповіді @Even Mien я спробував піти трохи далі і зробити це загальним, я, здається, майже є, але один випадок все ще противиться, і я, мабуть, можу трохи спростити свій код.
Я розміщую його тут, якщо хтось бачить, як я міг би вдосконалитись і особливо змусити його працювати, оскільки я не можу призначити його з рядка

Поки що у мене є такі результати:

        Console.WriteLine(TestEnum.Test1);//displays "TEST1"

        bool test = "TEST1" == TestEnum.Test1; //true

        var test2 = TestEnum.Test1; //is TestEnum and has value

        string test3 = TestEnum.Test1; //test3 = "TEST1"

        var test4 = TestEnum.Test1 == TestEnum.Test2; //false
         EnumType<TestEnum> test5 = "TEST1"; //works fine

        //TestEnum test5 = "string"; DOESN'T compile .... :(:(

Де відбувається магія:

public abstract  class EnumType<T>  where T : EnumType<T>   
{

    public  string Value { get; set; }

    protected EnumType(string value)
    {
        Value = value;
    }


    public static implicit operator EnumType<T>(string s)
    {
        if (All.Any(dt => dt.Value == s))
        {
            Type t = typeof(T);

            ConstructorInfo ci = t.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic,null, new Type[] { typeof(string) }, null);

            return (T)ci.Invoke(new object[] {s});
        }
        else
        {
            return null;
        }
    }

    public static implicit operator string(EnumType<T> dt)
    {
        return dt?.Value;
    }


    public static bool operator ==(EnumType<T> ct1, EnumType<T> ct2)
    {
        return (string)ct1 == (string)ct2;
    }

    public static bool operator !=(EnumType<T> ct1, EnumType<T> ct2)
    {
        return !(ct1 == ct2);
    }


    public override bool Equals(object obj)
    {
        try
        {
            return (string)obj == Value;
        }
        catch
        {
            return false;
        }
    }

    public override int GetHashCode()
    {
        return Value.GetHashCode();
    }

    public static IEnumerable<T> All
     => typeof(T).GetProperties()
       .Where(p => p.PropertyType == typeof(T))
       .Select(x => (T)x.GetValue(null, null));



}

Я лише тоді мушу заявити про це для своїх перерахунків:

public class TestEnum : EnumType<TestEnum> 
{

    private TestEnum(string value) : base(value)
    {}

    public static TestEnum Test1 { get { return new TestEnum("TEST1"); } }
    public static TestEnum Test2 { get { return new TestEnum("TEST2"); } }
}

Нове в .Net Core 3.0 / C # 8.0 (якщо ваше робоче середовище дозволяє оновити проект) - це короткий вимикач, який виглядає дещо важко. Зрештою, це та ж стара нудна заява про перемикання, яку ми використовуємо роками.

Єдина відмінність тут полягає в тому, що заява перемикача отримала новий костюм.

public static RGBColor FromRainbow(Rainbow colorBand) =>
colorBand switch
{
    Rainbow.Red    => new RGBColor(0xFF, 0x00, 0x00),
    Rainbow.Orange => new RGBColor(0xFF, 0x7F, 0x00),
    Rainbow.Yellow => new RGBColor(0xFF, 0xFF, 0x00),
    Rainbow.Green  => new RGBColor(0x00, 0xFF, 0x00),
    Rainbow.Blue   => new RGBColor(0x00, 0x00, 0xFF),
    Rainbow.Indigo => new RGBColor(0x4B, 0x00, 0x82),
    Rainbow.Violet => new RGBColor(0x94, 0x00, 0xD3),
    _              => throw new ArgumentException(message: "invalid enum value", paramName: nameof(colorBand)),
};

Ви помітите, що код, над яким я скопіював звідси , насправді використовує enum як парам.

Це не зовсім те, що ви хочете (і повірте, я хотів щось подібне до того, що ОП просить давно), але я насправді відчуваю, що це дещо з оливкової гілки від MS. JMO.

Сподіваюся, це комусь допоможе!

Я використовував структуру, про яку згадували у попередній відповіді, але усунув будь-яку складність. Для мене це найбільше схоже на створення перерахування рядків. Він використовується таким же чином, як і перерахування.

    struct ViewTypes
    {
        public const string View1 = "Whatever string you like";
        public const string View2 = "another string";
    }

Приклад використання:

   switch( some_string_variable )
   {
      case ViewTypes.View1: /* do something */ break;
      case ViewTypes.View2: /* do something else */ break;
   }

Я навіть реалізував кілька переліків, як це запропонував @Even (через class Xта public static Xучасників), просто щоб потім дізнатися, що в ці дні, починаючи з .Net 4.5, є право ToString() метод.

Тепер я все перетворюю на переліки.

Це спосіб використовувати його як сильно набраний параметр або як рядок :

public class ClassLikeEnum
{
    public string Value
    {
        get;
        private set;
    }

    ClassLikeEnum(string value) 
    {
        Value = value;
    }

    public static implicit operator string(ClassLikeEnum c)
    {
        return c.Value;
    }

    public static readonly ClassLikeEnum C1 = new ClassLikeEnum("RandomString1");
    public static readonly ClassLikeEnum C2 = new ClassLikeEnum("RandomString2");
}

Можна використовувати два перерахунки. Один для бази даних, а другий для читабельності.

Вам просто потрібно переконатися, що вони синхронізуються, що здається невеликою вартістю. Не потрібно встановлювати значення, просто встановлюйте однакові позиції, але якщо встановити значення, то це дуже ясно, що два перерахунки пов'язані між собою та запобігає помилкам переставляти члени перерахунків. І коментар дозволяє екіпажу з технічного обслуговування знати, що вони пов'язані і повинні підтримуватися синхронно.

// keep in sync with GroupTypes
public enum GroupTypeCodes
{
    OEM,
    CMB
}

// keep in sync with GroupTypesCodes
public enum GroupTypes
{
    TheGroup = GroupTypeCodes.OEM,
    TheOtherGroup = GroupTypeCodes.CMB
}

Щоб скористатися нею, ви просто спочатку перетворите в код:

GroupTypes myGroupType = GroupTypes.TheGroup;
string valueToSaveIntoDatabase = ((GroupTypeCodes)myGroupType).ToString();

Тоді, якщо ви хочете зробити це ще зручніше, ви можете додати функцію розширення, яка працює лише для цього типу enum:

public static string ToString(this GroupTypes source)
{
    return ((GroupTypeCodes)source).ToString();
}

і ви можете просто зробити:

GroupTypes myGroupType = GroupTypes.TheGroup;
string valueToSaveIntoDatabase = myGroupType.ToString();

Я в основному шукав відповідь на роздуми від @ArthurC

Щоб трохи розширити його відповідь, ви можете зробити її ще кращою, маючи загальну функцію:

    // If you want for a specific Enum
    private static string EnumStringValue(GroupTypes e)
    {
        return EnumStringValue<GroupTypes>(e);
    }

    // Generic
    private static string EnumStringValue<T>(T enumInstance)
    {
        return Enum.GetName(typeof(T), enumInstance);
    } 

Тоді ви можете просто обернути все, що у вас є

EnumStringValue(GroupTypes.TheGroup) // if you incorporate the top part

або

EnumStringValue<GroupTypes>(GroupTypes.TheGroup) // if you just use the generic

Взято від @EvenMien та додано в деяких коментарях. (Також для мого власного випадку використання)

public struct AgentAction
{
    private AgentAction(string value) { Value = value; }

    public string Value { get; private set; }

    public override string ToString()
    {
        return this.Value;
    }

    public static AgentAction Login = new AgentAction("Logout");
    public static AgentAction Logout = new AgentAction("Logout");

    public static implicit operator string(AgentAction action) { return action.ToString(); }
}

Додавання цього класу

public class DatabasePreference {
    public DatabasePreference([CallerMemberName] string preferenceName = "") {
        PreferenceName = preferenceName;
    }
    public string PreferenceName;
}

Ця робота використовується CallerMemberName для мінімізації кодування

Використання:

//Declare names
public static DatabasePreference ScannerDefaultFlashLight = new DatabasePreference();
public static DatabasePreference ScannerQrCodes = new DatabasePreference();
public static DatabasePreference Scanner1dCodes = new DatabasePreference();

Перевірте:

Console.WriteLine(ScannerDefaultFlashLight.PreferenceName);
Console.WriteLine(ScannerDefaultFlashLight.Scanner1dCodes);

вихід:

ScannerDefaultFlashLight
Scanner1dCodes

Виходячи з інших думок, це те, що я придумав. Цей підхід дозволяє уникнути необхідності вводити .Value там, де ви хочете отримати постійне значення.

У мене базовий клас для всіх рядкових перерахунків на зразок цього:

using System;
using Newtonsoft.Json;

[JsonConverter(typeof(ConstantConverter))]
public class StringEnum: IConvertible
{
    public string Value { get; set; }

    protected StringEnum(string value)
    {
        Value = value;
    }

    public static implicit operator string(StringEnum c)
    {
        return c.Value;
    }
    public string ToString(IFormatProvider provider)
    {
        return Value;
    }

    public TypeCode GetTypeCode()
    {
        throw new NotImplementedException();
    }

    public bool ToBoolean(IFormatProvider provider)
    {
        throw new NotImplementedException();
    }
    //The same for all the rest of IConvertible methods
}

JsonConverter такий:

using System;
using Newtonsoft.Json;

class ConstantConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return true;
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        if (value == null)
        {
            serializer.Serialize(writer, null);
        }
        else
        {
            serializer.Serialize(writer, value.ToString());
        }
    }
}

І власне перерахунок рядків буде приблизно таким:

public sealed class Colors : StringEnum
{
    public static Colors Red { get { return new Catalog("Red"); } }
    public static Colors Yellow { get { return new Catalog("Yellow"); } }
    public static Colors White { get { return new Catalog("White"); } }

    private Colors(string value) : base(value) { }
}

І з цим ви можете просто використовувати Color.Red, щоб навіть серіалізувати до json, не використовуючи властивість Value

Мені не потрібно було нічого надійного, як зберігання рядка в атрибутах. Мені просто потрібно було перетворити щось на кшталт MyEnum.BillEveryWeek"законопроект щотижня" або MyEnum.UseLegacySystem"використовувати застарілу систему" - в основному розбити перелік за допомогою його верблюда на окремі малі слова.

public static string UnCamelCase(this Enum input, string delimiter = " ", bool preserveCasing = false)
{
    var characters = input.ToString().Select((x, i) =>
    {

       if (i > 0 && char.IsUpper(x))
       {
           return delimiter + x.ToString(CultureInfo.InvariantCulture);
       }
       return x.ToString(CultureInfo.InvariantCulture);

    });

    var result = preserveCasing
       ? string.Concat(characters)
       : string.Concat(characters).ToLower();

    var lastComma = result.LastIndexOf(", ", StringComparison.Ordinal);

    if (lastComma > -1)
    {
       result = result.Remove(lastComma, 2).Insert(lastComma, " and ");
    }

    return result;
}

MyEnum.UseLegacySystem.UnCamelCase() виводи "використовувати застарілу систему"

Якщо у вас встановлено кілька прапорів, це перетворить це на звичайну англійську (розміщено комами, крім "і" замість останньої коми).

var myCustomerBehaviour = MyEnum.BillEveryWeek | MyEnum.UseLegacySystem | MyEnum.ChargeTaxes;

Console.WriteLine(myCustomerBehaviour.UnCamelCase());
//outputs "bill every week, use legacy system and charge taxes"