So like I LOVE partial classes, I love LLBLGen (most days), but the one thing that absolutely drives me nuts is that you can't have a partial or inherited enum.
I am constantly creating new enums just to tack on an extra field or two that I have to track, so I spent some time and wrote an enum replacement, it's not ideal mainly because you have to wait until runtime to determine that you made a mistake (i.e. manually numbered two entries the same.) but it does provide similar functionality at runtime to what enums provide.
I had originally created this as true generics, but the extra overhead to support various ordinal types just made the code confusing.
I appended the DisplayText on to it afterwards to emulate the Description Attribute we use internally on all our existing enums to provide Display Text for an enum name ('i.e. with spaces etc.)
Looking for thoughts on ways to improve it, one thing I know of that would simplify it is the ability to grab the variable name the class is being assigned to for use in the Name field, but I haven't been able to find how to determine that, and that would also require an attribute to not obfusicate the names.
Here is a sample use of it:
public sealed partial class MyFakeEnumB : CustomEnumBase
{
internal MyFakeEnumB(string name)
: base(null, name, null)
{
}
internal MyFakeEnumB(string name, string displayText)
: base(null, name, displayText)
{
}
internal MyFakeEnumB(int? ordinal, string name)
: base(ordinal, name, null)
{
}
internal MyFakeEnumB(int? ordinal, string name, string displayText)
: base(ordinal, name, displayText)
{
}
public static MyFakeEnumB Internal = new MyFakeEnumB("I"); // 1
public static MyFakeEnumB External = new MyFakeEnumB(4,"E"); // 4
public static MyFakeEnumB Unknown = new MyFakeEnumB(7,"U"); // 7
}
public sealed partial class MyFakeEnumB
{
public static MyFakeEnumB Override = new MyFakeEnumB("O", "zippy"); // 8
}
public class TestEnumsB
{
public TestEnumsB()
{
// Test Simple print
Console.WriteLine(string.Format("{0} {1}", MyFakeEnumB.External, MyFakeEnumB.External.ToOrdinal()));
// Test as a parameter to a call
TestAsParameter(MyFakeEnumB.Internal);
// Enumerate
foreach (CustomEnumEntry Entry in MyFakeEnumB.GetValues())
{
Console.WriteLine(string.Format("{0} {1}", Entry, Entry.Ordinal));
}
Console.WriteLine(string.Format("{0}", MyFakeEnumB.Parse("zippy", true)));
}
private void TestAsParameter(MyFakeEnumB myValue)
{
Console.WriteLine(string.Format("{0} {1}",myValue.ToString(), myValue.ToOrdinal()));
}
}
And here is the base class:
public struct CustomEnumEntry
{
private int _Ordinal;
private string _Name;
private string _DisplayText;
public int Ordinal
{
get
{
return _Ordinal;
}
set
{
_Ordinal = value;
}
}
public string Name
{
get
{
return _Name;
}
set
{
_Name = value;
}
}
public string DisplayText
{
get
{
return _DisplayText;
}
set
{
_DisplayText = value;
}
}
public CustomEnumEntry(int ordinal, string name, string displayText)
{
_Ordinal = ordinal;
_Name = name;
_DisplayText = displayText;
}
public override string ToString()
{
if (DisplayText != null)
return DisplayText;
else
return Name;
}
}
public abstract class CustomEnumBase : IEnumerable<CustomEnumEntry>
{
private CustomEnumEntry _EnumEntry;
private static List<CustomEnumEntry> _IndexedEnum = new List<CustomEnumEntry>();
protected CustomEnumBase(int? ordinal, string name, string displayText)
{
if (!ordinal.HasValue)
ordinal = FindNextOrdinal();
_EnumEntry = new CustomEnumEntry();
// must use local fields to verify no dupes
Ordinal = ordinal.Value;
Name = name;
_EnumEntry.DisplayText = displayText;
// add it to our static list
_IndexedEnum.Add(_EnumEntry);
}
private int? Ordinal
{
get
{
return _EnumEntry.Ordinal;
}
set
{
if (_IndexedEnum.FindIndex(OrdinalExists(value)) == -1)
{
_EnumEntry.Ordinal = value.Value;
}
else
throw new Exception("Ordinal already exists");
}
}
private string Name
{
get
{
return _EnumEntry.Name;
}
set
{
if (_IndexedEnum.FindIndex(NameExists(value)) == -1)
{
_EnumEntry.Name = value;
}
else
throw new Exception("Name already exists");
}
}
private string DisplayText
{
get
{
return _EnumEntry.DisplayText;
}
set
{
if (_IndexedEnum.FindIndex(DisplayTextExists(value)) == -1 || value == null)
{
_EnumEntry.DisplayText = value;
}
else
throw new Exception("DisplayText already exists");
}
}
public static CustomEnumEntry[] GetValues()
{
return _IndexedEnum.ToArray();
}
protected Predicate<CustomEnumEntry> OrdinalExists(int? ordinal)
{
return delegate(CustomEnumEntry EnumItem) { return (ordinal == EnumItem.Ordinal); };
}
protected Predicate<CustomEnumEntry> NameExists(string name)
{
return delegate(CustomEnumEntry EnumItem) { return (name == EnumItem.Name); };
}
protected Predicate<CustomEnumEntry> DisplayTextExists(string displayText)
{
return delegate(CustomEnumEntry EnumItem) { return (displayText == EnumItem.DisplayText); };
}
private static int FindNextOrdinal()
{
int HighestIndex = int.MinValue;
foreach (CustomEnumEntry Entry in _IndexedEnum)
{
if (Entry.Ordinal > HighestIndex)
HighestIndex = Entry.Ordinal;
}
if (HighestIndex == int.MinValue)
HighestIndex = 0;
HighestIndex++;
return HighestIndex;
}
public override string ToString()
{
if (_EnumEntry.DisplayText != null)
return _EnumEntry.DisplayText;
else
return _EnumEntry.Name;
}
public int ToOrdinal()
{
return _EnumEntry.Ordinal;
}
public static int Parse(string enumName)
{
return Parse(enumName, false);
}
public static int Parse(string enumName, bool ignoreCase)
{
int? FoundOrdinal = null;
foreach (CustomEnumEntry Entry in _IndexedEnum)
{
if (string.Compare(Entry.DisplayText, enumName, ignoreCase) == 0)
FoundOrdinal = Entry.Ordinal;
else
if (string.Compare(Entry.Name, enumName, ignoreCase) == 0)
FoundOrdinal = Entry.Ordinal;
if (FoundOrdinal != null)
break;
}
return FoundOrdinal ?? -1;
}
#region IEnumerable<CustomEnumEntry> Members
public IEnumerator<CustomEnumEntry> GetEnumerator()
{
return _IndexedEnum.GetEnumerator();
}
#endregion
#region IEnumerable Members
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return _IndexedEnum.GetEnumerator();
}
#endregion
}
