Bit Flags Type Converter

Sponsored by

Become a Sponsor

Similar ArticlesMost ReadTop RatedLatest

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 property grid 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 own TypeConverter which would help to edit bit fields properties.

Sample Image

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.

To assign a custom type converter to a property, you should use the TypeConverterAttribute attribute:

Public Class TestClass

<TypeConverter(GetType(FlagsEnumConverter))> _

Public Property FontStyle() As FontStyle

Get

End Get

Set(ByVal value As FontStyle)

End Set

End Property

End Class

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:

Friend Class FlagsEnumConverter

Inherits EnumConverter

Public Overloads Overrides Function GetProperties(ByVal context As ITypeDescriptorContext, ByVal value As

Object, ByVal attributes As Attribute()) As PropertyDescriptorCollection

End Function

Public Overloads Overrides Function GetPropertiesSupported(ByVal context As ITypeDescriptorContext) As Boolean

End Function

End Class

TypeConverter has several overridable properties and methods which allow you to customize the appearance of a property in the property grid. In our type converter I overrode two methods: GetPropertiesSupported and GetProperties. By using these methods we inform the property grid 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 Overrides Function GetProperties(ByVal context As ITypeDescriptorContext, ByVal value As Object, ByVal attributes As Attribute()) As PropertyDescriptorCollection

Dim myType As Type = value.GetType

Dim myNames As String() = Enum.GetNames(myType)

Dim myValues As Array = Enum.GetValues(myType)

If Not (myNames Is Nothing) Then

Dim myCollection As PropertyDescriptorCollection = New PropertyDescriptorCollection(Nothing)

Dim i As Integer = 0

While i < myNames.Length

myCollection.Add(New EnumFieldDescriptor(myType, myNames(i), context))

System.Math.Min(System.Threading.Interlocked.Increment(i), i - 1)

End While

Return myCollection

End If

End Function

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 property grid. The main interest of the EnumFieldDescriptor class is the GetValue and SetValue methods. The GetValue method is called each time when the property grid 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 Overrides Function GetValue(ByVal component As Object) As Object

Return Not ((CType(component, Integer) And CType(Enum.Parse(ComponentType, Name), Integer)) = 0)

End Function

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 Overrides Sub SetValue(ByVal component As Object, ByVal value As Object)

Dim myValue As Boolean = CType(value, Boolean)

Dim myNewValue As Integer

If myValue Then

myNewValue = CType(component, Integer) Or CType(Enum.Parse(ComponentType, Name), Integer)

Else

myNewValue = CType(component, Integer) And Not CType(Enum.Parse(ComponentType, Name), Integer)

End If

Dim myField As FieldInfo = component.GetType.GetField("value_", BindingFlags.Instance Or BindingFlags.Public)

myField.SetValue(component, myNewValue)

fContext.PropertyDescriptor.SetValue(fContext.Instance, component)

End Sub

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 value type (non-reference type) and if we unbox it (convert from the object type to an enumeration type), we will obtain different object, not the one passed with the component parameter. To solve it, I have done a little trick. Enumeration in 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.

NOTE: THIS ARTICLE IS CONVERTED FROM C# TO VB.NET USING A CONVERSION TOOL. ORIGINAL ARTICLE CAN BE FOUND ON C# CORNER (http://www.c-sharpcorner.com/).