Mapping Text to Enum entries

    private bool GetEnumValues(Type enumType, object value, out IEnumerable<object> enumValues)
    {
      bool enumCompletelyCovered = false;
      List<object> enumValueCollection = new List<object>();

      // perform a shortcut comparison for the common case
      if(Enum.IsDefined(enumType, value))
      {
        // the specified value completely matches an enumeration entry
        enumValueCollection.Add(value);
        enumCompletelyCovered = true;
      }
      else
      {
        // attempt to decompose the specified value into several enumeration entries
        // compare enumeration values as the largest comparable type (UInt64)
        ulong currentEnumValue = Convert.ToUInt64(value);

        // get an array of all the possible enumeration entries
        Array values = Enum.GetValues(enumType);

        // process the enumeration entries in reverse order to compare the largest values first
        int index = values.Length - 1;
        while(index >= 0)
        {
          // convert currently indexed enumeration entry value to a comparable type
          ulong currentIndexedValue = System.Convert.ToUInt64(values.GetValue(index));

          // special case the None enumeration
          if((index == 0) && (currentIndexedValue == 0L))
          {
            break;
          }

          // use a bit-field comparison technique
          if((currentEnumValue & currentIndexedValue) == currentIndexedValue)
          {
            currentEnumValue -= currentIndexedValue;
            enumValueCollection.Add(values.GetValue(index));
          }

          // move to the next up enumeration entry
          index--;
        }

        // special case the None enumeration
        // Add the assumed None enumeration if:
        //  the enumeration value collection is empty;
        //  and the current value is 0;
        //  and the current enumeration entry is the first entry;
        //  and the current enumeration entry matches the current value.
        if((enumValueCollection.Count == 0) && (currentEnumValue == 0L) && (index == 0) && (System.Convert.ToUInt64(values.GetValue(index)) == 0L))
        {
          enumValueCollection.Add(values.GetValue(index));
        }

        // reverse the enumeration value collection to go from least to greatest values
        enumValueCollection.Reverse();

        // the enumeration was completely covered if the current value is 0 and there is at lease one entry in the enumeration value collection
        enumCompletelyCovered = (currentEnumValue == 0L) && (enumValueCollection.Count > 0);
      }

      enumValues = enumValueCollection;
      return enumCompletelyCovered;
    }

public class LRDescriptionAttribute : System.ComponentModel.DescriptionAttribute
{
  private bool replaced;
  public LRDescriptionAttribute(string description) : base(description)
  {
    this.replaced = false;
  }
  public override string Description
  {
    get
    {
      if (!this.replaced)
      {
        string desc = LR.GetString(base.Description);
        this.DescriptionValue = desc;
        this.replaced = true;
      }
      return base.Description;
    }
  }
}

[LRDescription("MyControl_Desc")]public class MyControl { }

[AttributeUsage(AttributeTargets.All)]
public class LRDescriptionAttribute :
    System.ComponentModel.DescriptionAttribute
{  
    ...
}