The client configuration runtime will use (in order) the following methods to serialize/deserialize setting values
1) The sheme indicated by the SettingsSerializeAs attribute
2) TypeConverter.To/FromString() for the type converter associated with the type of the setting if it exists and supports converting to/from strings
3) XML Serialization
If you want to use a type that doesn't have the appropriate type converter and doesn't support XML serialization well (which happens to be true for quite a few of the collection types) you can still take advantage of client config by providing your own type converter. Below is a sample that (hopefully) will show what can be done. The sample uses the base64 encoded representation of the binary serialized values as the string representation for the value - this is not exactly easily read by humans, so depending on your specific requirements, you may want to use a different string representation of your data...
Option Strict On
Module Module1
Public Sub Main()
' Associate a type descriptor with the setting type. This could also be done by putting a TypeDescriptionProvider attribute
' on the type declaration itself.
System.ComponentModel.TypeDescriptor.AddProvider( _
New SerializableTypeDescriptionProvider(Of System.Collections.Generic.Dictionary(Of String, String)), _
GetType(System.Collections.Generic.Dictionary(Of String, String)))
' Create an instance of my test class
Dim s As New MyTestSettingsClass
s.Foo = New System.Collections.Generic.Dictionary(Of String, String)
s.Foo.Add("Bar", "Zoo")
s.Foo.Add("Doo", "Goo")
s.Save()
' Load the same settings again...
Dim s2 As New MyTestSettingsClass
Debug.WriteLine(s2.Foo.Count)
End Sub
''' <summary>
'''
''' </summary>
''' <typeparam name="T"></typeparam>
''' <remarks></remarks>
Public Class SerializableTypeDescriptionProvider(Of T)
Inherits System.ComponentModel.TypeDescriptionProvider
Public Overrides Function GetTypeDescriptor(ByVal objectType As System.Type, ByVal instance As Object) As System.ComponentModel.ICustomTypeDescriptor
If Not objectType Is GetType(T) Then
Return MyBase.GetTypeDescriptor(objectType, instance)
End If
Dim parentTypeDescriptor As System.ComponentModel.ICustomTypeDescriptor = MyBase.GetTypeDescriptor(objectType, instance)
If parentTypeDescriptor IsNot Nothing Then
Dim existingTypeConverter As System.ComponentModel.TypeConverter = _
parentTypeDescriptor.GetConverter()
If existingTypeConverter IsNot Nothing _
AndAlso existingTypeConverter.CanConvertFrom(GetType(String)) _
AndAlso existingTypeConverter.CanConvertTo(GetType(String)) _
Then
' If the parentdescriptor already supported to/from string, we might as well
' use that... We don't really *have* to check this, but...
Return MyBase.GetTypeDescriptor(objectType, instance)
End If
End If
Return New SerializableConverterProvider(Of T)(parentTypeDescriptor)
End Function
End Class
' Simple generic implementation that will provide a type converter
' that supports to/from string using base64 encoded string based on
' binary serialization
Public Class SerializableConverterProvider(Of T)
Inherits System.ComponentModel.CustomTypeDescriptor
Sub New(ByVal parentTypeDescriptor As System.ComponentModel.ICustomTypeDescriptor)
MyBase.New(parentTypeDescriptor)
End Sub
Public Overrides Function GetConverter() As System.ComponentModel.TypeConverter
Return New SerializeAsStringTypeConverter()
End Function
Private Class SerializeAsStringTypeConverter
Inherits System.ComponentModel.TypeConverter
Public Overrides Function CanConvertFrom(ByVal context As System.ComponentModel.ITypeDescriptorContext, ByVal sourceType As System.Type) As Boolean
If sourceType Is GetType(String) Then
Return True
Else
Return MyBase.CanConvertFrom(context, sourceType)
End If
End Function
Public Overrides Function CanConvertTo(ByVal context As System.ComponentModel.ITypeDescriptorContext, ByVal destinationType As System.Type) As Boolean
If destinationType Is GetType(String) Then
Return True
Else
Return MyBase.CanConvertTo(context, destinationType)
End If
End Function
Public Overrides Function ConvertTo(ByVal context As System.ComponentModel.ITypeDescriptorContext, ByVal culture As System.Globalization.CultureInfo, ByVal value As Object, ByVal destinationType As System.Type) As Object
If destinationType Is GetType(String) Then
Dim serializer As New System.Runtime.Serialization.Formatters.Binary.BinaryFormatter()
Dim stream As New System.IO.MemoryStream
serializer.Serialize(stream, value)
Return System.Convert.ToBase64String(stream.ToArray())
Else
Return MyBase.ConvertTo(context, culture, value, destinationType)
End If
End Function
Public Overrides Function ConvertFrom(ByVal context As System.ComponentModel.ITypeDescriptorContext, ByVal culture As System.Globalization.CultureInfo, ByVal value As Object) As Object
If TypeOf value Is String Then
Dim serializer As New System.Runtime.Serialization.Formatters.Binary.BinaryFormatter()
Dim bytes() As Byte = System.Convert.FromBase64String(DirectCast(value, String))
Dim stream As New System.IO.MemoryStream(bytes)
Return serializer.Deserialize(stream)
Else
Return MyBase.ConvertFrom(context, culture, value)
End If
End Function
End Class
End Class
' Since the settings designer isn't very good at handling generic types,
' I have created a (very) simplistic class that expose a setting of a type
' that ordinarily would have been problematic to persist...
Public Class MyTestSettingsClass
Inherits System.Configuration.ApplicationSettingsBase
<System.Configuration.UserScopedSetting()> _
Public Property Foo() As System.Collections.Generic.Dictionary(Of String, String)
Get
Return CType(Me("Foo"), System.Collections.Generic.Dictionary(Of String, String))
End Get
Set(ByVal value As System.Collections.Generic.Dictionary(Of String, String))
Me("Foo") = value
End Set
End Property
End Class
End Module
This posting is provided "AS IS" with no warranties, and confers no rights.
