Introduction
I am a component developer at 10Tec Company. While developing one of our components, iGrid.NET, I came across a problem: the PropertyGrid
control does not provide you with a comfortable-enough editor for enumerations marked with the Flags
attribute (enumerations that can be treated as bit fields; that are a set of flags). The PropertyGrid
treats them as usual enumerations, and allows you to select a single field from the drop-down list or enter a value as text. So, I decided to implement our own TypeConverter
which would help to edit bit field properties.
There can be a few solutions to this problem, for example, we could show a check list box in the drop-down list. My solution is to show flags as sub-properties.
Using the code
To assign a custom type converter to a property, you should use the TypeConverterAttribute
attribute:
public class TestClass
{
…
[TypeConverter(typeof(FlagsEnumConverter))]
public FontStyle FontStyle
{
get
{
…
}
set
{
…
}
}
…
}
The parameter passed to the TypeConverterAttribute
attribute should be inherited from the TypeConverter
class or one of its descendents.
Our type converter is named FlagsEnumConverter
, and is inherited from the standard .NET EnumConverter
class:
internal class FlagsEnumConverter: EnumConverter
{
public override PropertyDescriptorCollection
GetProperties(ITypeDescriptorContext context,
object value, Attribute[] attributes)
{
…
}
public override bool GetPropertiesSupported(ITypeDescriptorContext context)
{
…
}
}
The TypeConverter
has several overridable properties and methods which allow you to customize the appearance of a property in the PropertyGrid
. In our type converter, I overrode two methods: GetPropertiesSupported
and GetProperties
. By using these methods, we inform the PropertyGrid
that our property is complex (has several nested properties), and return descriptors of these nested properties (we show a single nested boolean property for each bit flag):
public override PropertyDescriptorCollection
GetProperties(ITypeDescriptorContext context,
object value, Attribute[] attributes)
{
Type myType = value.GetType();
string[] myNames = Enum.GetNames(myType);
Array myValues = Enum.GetValues(myType);
if(myNames != null)
{
PropertyDescriptorCollection myCollection =
new PropertyDescriptorCollection(null);
for(int i = 0; i < myNames.Length; i++)
myCollection.Add(new EnumFieldDescriptor(myType,
myNames[i], context));
return myCollection;
}
}
Each bit flag (nested property) is represented with the EnumFieldDescriptor
class inherited from the standard .NET class named SimplePropertyDescriptor
. This is a base class which allows you to represent a custom property in the PropertyGrid
. The main interests of the EnumFieldDescriptor
class are the GetValue
and SetValue
methods. The GetValue
method is called each time the PropertyGrid
displays a custom property (a bit flag), and returns the value of the custom property (in our case it is a boolean value which indicates whether the bit flag is included in the enumeration property value):
public override object GetValue(object component)
{
return ((int)component & (int)Enum.Parse(ComponentType, Name)) != 0;
}
In the code snippet above, ComponentType
is the type of the enumeration, and Name
is the name of the enumeration field (bit flag).
The SetValue
method is more complicated, it is called when the user modifies a custom property. In our case, it sets a particular bit flag to the enumeration value:
public override void SetValue(object component, object value)
{
bool myValue = (bool)value;
int myNewValue;
if(myValue)
myNewValue = ((int)component) | (int)Enum.Parse(ComponentType, Name);
else
myNewValue = ((int)component) & ~(int)Enum.Parse(ComponentType, Name);
FieldInfo myField = component.GetType().GetField("value__",
BindingFlags.Instance | BindingFlags.Public);
myField.SetValue(component, myNewValue);
fContext.PropertyDescriptor.SetValue(fContext.Instance, component);
}
In this method, we accept a boxed enumeration value (the object type component
parameter) which we should modify. The main problem is that an enumeration is a value type (non-reference type) and if we unbox it (convert from the object type to an enumeration type), we will obtain a different object, not the one passed with the component
parameter. To solve it, I have done a little trick. An enumeration, in its core, stores its actual value in a private parameter named value__
(you can trace it with a disassembler or decompiler). I have accessed this parameter by using reflection, and set its value without unboxing.