Omer van Kloeten's .NET Zen : How To

Circumventing the KB957543 .NET 3.5 SP1 Regression Bug

Omer van Kloeten — Thu, 29 Jan 2009 16:23:18 GMT

A couple of days ago I hit a regression bug in .NET 3.5 SP1, in which when you have a generic class that implements ISerializable and has static variables – you can not serialize it using a BinaryFormatter without your application either hanging (x86) or raising an exception (x64 – a TargetInvocationException containing an OutOfMemoryException). This only happens if you use a reference type as a generic argument.

It’s already well known, but I have yet to find a workaround documented anywhere. You could simply install the hotfix, but well, I wouldn’t if I were you – it hasn’t been thoroughly tested yet. Moreover, you might not even be able to do so due to either internal politics, strict IT rules or the fact that you simply do not have control over the hosting server.

Let’s take the simplest class that causes the issue:

[Serializable]
public class MyClass<T> : ISerializable
{
    private static int list = 0;

    public MyClass()
    {
    }

    protected MyClass(SerializationInfo info, StreamingContext context)
    {
    }

    void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
    {
    }
}

When using the class as such:

using (MemoryStream stream = new MemoryStream())
{
    BinaryFormatter formatter = new BinaryFormatter();
    formatter.Serialize(stream, new MyClass<string>());
    stream.Position = 0;
    MyClass<string> item = (MyClass<string>)formatter.Deserialize(stream);
}

The last line will hit the bug.

To work around this issue, simply move your static variables into a new subclass:

[Serializable]
public class MyClass<T> : ISerializable
{
    private static class KB957543
    {
        public static int list = 0;
    }

    public MyClass()
    {
    }

    protected MyClass(SerializationInfo info, StreamingContext context)
    {
    }

    void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
    {
    }
}

You can still access all of your static variables and you don’t hit the bug.

Note that when you use anonymous methods or lambdas, they are cached as static variables of the type, meaning that you will have to manually type all of your lambdas.

Here’s an example of such a type that is prone to the bug:

[Serializable]
public class MyClass<T> : ISerializable
{
    public MyClass()
    {
    }

    public static string Concat(IEnumerable<int> numbers)
    {
        return string.Join(", ", numbers.Select(i => i.ToString()).ToArray());
    }

    protected MyClass(SerializationInfo info, StreamingContext context)
    {
    }

    void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
    {
    }
}

If we look through Reflector, we can see that there is a cached delegate in our type:

Since this is a static member, it makes the type susceptible to the bug and we now need to manually create the cached member ourselves:

[Serializable]
public class MyClass<T> : ISerializable
{
    private static class KB957543
    {
        public static readonly Func<int, string> ToString = i => i.ToString();
    }

    public MyClass()
    {
    }

    public static string Concat(IEnumerable<int> numbers)
    {
        return string.Join(", ", numbers.Select(KB957543.ToString).ToArray());
    }

    protected MyClass(SerializationInfo info, StreamingContext context)
    {
    }

    void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
    {
    }
}

Your Mouth Says Windows-1255, But Your Eyes Say ISO-8859-1

Omer van Kloeten — Thu, 18 Dec 2008 16:45:34 GMT

I recently wrote an engine that gets XML files stored at our clients’ servers using HTTP requests. One of our clients decided to serve the XML file with one encoding and encode the file itself with another. This posed a problem to XDocument.

The client decided to encode their XML using the Windows-1255 encoding (Hebrew), noting the encoding correctly in the XML’s declaration, but served the file stating the ISO-8859-1 (Latin) encoding. This meant that I couldn’t just use XDocument’s normal Load method to load directly from the stream because XDocument looks at the HTTP headers and takes the document’s encoding from them.

Here’s a snippet of the code I used to get over that:

using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
    // Use response's charset.
    var encoding = Encoding.GetEncoding("ISO-8859-1");

    if (!string.IsNullOrEmpty(response.CharacterSet))
        encoding = Encoding.GetEncoding(response.CharacterSet);

    byte[] bytes = ReadStream(response.GetResponseStream());

    // Get the XML with the response's charset.
    string xml = new string(encoding.GetChars(bytes));
    int endOfDeclaration = xml.IndexOf("?>");

    if (endOfDeclaration != -1)
    {
        // Try to find out the encoding from the declaration.
        string decl = xml.Substring(0, endOfDeclaration + 2) + "<duperoot />";
        XDocument declDoc = XDocument.Parse(decl);
        var docEncoding = Encoding.GetEncoding(declDoc.Declaration.Encoding);

        if (docEncoding == encoding)
            return xml;
        else
            return new string(docEncoding.GetChars(bytes));
    }
    else
    {
        // Not XML or something... Send up.
    }
}

What I did here was to create a new document with the original XML’s declaration (the Latin characters which make up the XML’s declaration always have the same byte position), add a dupe root and parse that to get the name of the encoding used by the document. I then use that encoding to decode the document correctly.

Note that I’m using ISO-8859-1 as the default response’s encoding, since that is what HTTP’s specification demands.

Did You Know? Type Member Lookup by Prefix

Omer van Kloeten — Sun, 16 Dec 2007 06:51:21 GMT

You can look up for prefixed members, using reflection, by placing an asterisk after the prefix:

MemberInfo[] members = typeof(A).GetMember("hidden*", 
    BindingFlags.NonPublic | BindingFlags.Instance);

// members now contains three members: hiddenFlag1, hiddenFlag2 and hiddenMethod

// ...

public class A
{
    private bool hiddenFlag1;
    private bool hiddenFlag2;

    private void hiddenMethod()
    {
    }

    private void reallyHiddenMethod()
    {
    }
}

Registering to a DependencyProperty's Change Event

Omer van Kloeten — Tue, 18 Sep 2007 12:19:00 GMT

Sebastien Lambla wrote a cool post about how to correctly get notifications for the changes in dependency property values.

In a nutshell:

DependencyPropertyDescriptor prop = DependencyPropertyDescriptor.FromProperty(
    MyType.MyDependencyProperty,
    typeof(MyType));

prop.AddValueChanged(this, this.OnMyDependencyPropertyChanged);

How To Create a Really Accurate Timer

Omer van Kloeten — Tue, 08 May 2007 13:01:00 GMT

Some of the work on my current project requires accurately timing events, at a frequency of a few dozen per second (that means that each event has to follow the previous one within a few milliseconds). The resolution of those calls is so small, that even System.Threading.Timer can not handle it and lags behind.

After some searching, I found that Win32 Multimedia Timers are a good solution to this problem, as they are (probably) the timers with the highest resolution available on the platform. At the moment, there is no official wrapper for the API in the Framework and Leslie Sanford's article offers a nice implementation.

Save User Details For Team Explorer

Omer van Kloeten — Sun, 21 Jan 2007 13:55:44 GMT

Since I've started working with CodePlex, Team System failed to even remember my username whenever I started Visual Studio. After digging a bit, I found the answer.

Start the Stored User Names and Passwords control panel: rundll32 keymgr.dll,KRShowKeyMgr
Add a new server (for CodePlex, it's tfs01.codeplex.com), then type your username and password.

Now the username will appear in the list.

I'm still looking for a way to save the password too.

Quick Blurb - Generic Types

Omer van Kloeten — Thu, 07 Oct 2004 20:17:00 GMT

Just a quickie that's been bothering me:

The types MyType and MyType<T> are not the same type, as you might already know. Also, MyType<int> and MyType<string> are not of the same type. So, how do I find out if MyType<int> and MyType<string> are from the same MyType<T>?

I will use the Type.GetGenericTypeDefinition() method like so:

MyType<int> i, MyType<string> s;
bool b = s.GetType().GetGenericTypeDefinition() == i.GetType().GetGenericTypeDefinition();

Cool.

Storing Application Configuration

Omer van Kloeten — Mon, 28 Jun 2004 20:40:00 GMT

Phil Haack's words "Do not store user settings in an application configuration file!" reminded me of something I made a while back, in order to store user settings in an application. I used the Object Model Generator to create an object oriented representation of my configuration and wrote a wrapper for it to load from, and persist back to, an Xml based format.
Here's some code for you:

using System;
using System.IO;
using System.IO.IsolatedStorage;

namespace Utilities.Configuration
{
	public class ConfigurationFile
	{
		private static IsolatedStorageFile m_IsolatedStorage = null;
		private static ConfigurationElement m_Element = null;

		// This is the name of the configuration file I will use in isolated storage.
		private const string ConfigurationFileName = "configuration.xml";

		// This class can not be inherited.
		private ConfigurationFile()
		{
		}

		// The static constructor loads the file and creates the document object
		// model out of it, then stores it in memory for manipulations.
		static ConfigurationFile()
		{
			// Load the configuration file's contents.
			string configurationFile = LoadConfigurationFile();

			if (configurationFile != null)
			{
				// If the configuration file existed, create the object grid from it.
				ConfigurationDocument document = new ConfigurationDocument();
				document.LoadXml(configurationFile);
				m_Element = document.CreateDOM();
			}
			else
			{
				// If the configuration file has not been found,
				// create a new object grid.
				m_Element = new ConfigurationElement();
			}
		}

		// Using this property, we can access the configuration settings.
		public static ConfigurationElement DOM
		{
			get
			{
				return m_Element;
			}
		}

		// This method is called when the application is closed,
		// causing it to commit all the changes made to the object
		// grid back to the configuration file in the isolated storage.
		public static void Close()
		{
			// Save the configuration file.
			SaveConfigurationFile(ConfigurationDocument.FromDOM(m_Element).OuterXml);

			// Dispose of the isolates storage file.
			if (m_IsolatedStorage != null)
			{
				m_IsolatedStorage.Dispose();
			}
		}

		private static string LoadConfigurationFile()
		{
			if (m_IsolatedStorage == null)
			{
				// This gets storage isolated for this user using this application.
				m_IsolatedStorage = IsolatedStorageFile.GetUserStoreForAssembly();
			}

			// This looks for the file. If it is found,
			// it reads its contents and returns that.
			if (m_IsolatedStorage.GetFileNames(ConfigurationFileName).Length == 1)
			{
				using (StreamReader sr = new StreamReader(new IsolatedStorageFileStream(ConfigurationFileName, FileMode.Open, FileAccess.Read, FileShare.Read, m_IsolatedStorage)))
				{
					return sr.ReadToEnd();
				}
			}
			else
			{
				return null;
			}
		}

		private static void SaveConfigurationFile(string fileData)
		{
			// Store the data to its original file location.
			using (StreamWriter sw = new StreamWriter(new IsolatedStorageFileStream(ConfigurationFileName, FileMode.Create, FileAccess.Write, FileShare.None, m_IsolatedStorage)))
			{
				sw.Write(fileData);
			}
		}
	}
}

True Autosizable Label, part II

Omer van Kloeten — Sun, 13 Jun 2004 16:49:00 GMT

A while back, I wrote about the Windows Forms Label not autosizing in the vertical sense as well as the horizontal sense. I added some code that would add that ability to the Label class.

Today I received a comment from Chris Hockenberry telling me my code isn't Compact Framework compatible. I originally didn't mean for it to be CF-compatible, but Chris even went and added some code in the comment! Too cool :)

Go and check out his code if you need this ability in your application.

How To: Debug Into File References -- Correction

Omer van Kloeten — Thu, 05 Feb 2004 18:15:00 GMT

Quite a while ago, I posted a way to debug into file references when you have the source code. At the time, we believed it to be the only way, even though it did not work at all times. However, I have found an easier way to do just that:

While debugging, break and open the Modules pane (Ctrl+Alt+U).
Right click your Assembly and select "Reload Symbols".
Select the PDB file for your assembly.
Step into the code.

Easy, isn't it?
You can also reload the symbols from the Call Stack window, when selecting any method from the Assembly you wish to debug.

How To: Debug Into File References

Omer van Kloeten — Mon, 03 Nov 2003 06:44:00 GMT

It's annoying to have a DLL in Debug mode that you had another team make and give you their source with it, but not be able to debug into it without adding the source project to your solution and using a Project Reference.
Who said you couldn't?

AmiD has come up with a simple way that allows you to debug into the source of file references:

Take the PDB file that was created in your bin\Debug directory and place it in the same directory as the compiled Assembly (if it's in the GAC, you'll have to place it in the same directory as the version that is in the GAC; usually %WINDIR%\assembly\GAC\%Assembly Name%\%Version%).
Take the solution referencing the Assembly file and delete its .SUO file. This file saves Visual Studio.NET's configuration (Breakpoints, Open Document Windows, etc.).
Go to where you want to Debug Into (F11) the Assembly, press F11 and a dialog would appear asking you where the source files are. This selection can only be made once (unless you re-delete the SUO file).

This allows you to Debug into File References, provided you have the source files.

Hack Value:	[	X	X	X	X	-	]
Cool Value:	[	X	X	X	-	-	]
Usable Value:	[	X	X	X	X	X	]

How To: Create a Component Conscious UITypeEditor

Omer van Kloeten — Fri, 31 Oct 2003 19:24:00 GMT

Many a time do I find Design-Time support in Visual Studio.NET to be a no-man's land, be it because no one in my surroundings knows how to do something I have to do and I have to resort to an hour or more of internet research, at times in vain, or be it because I have to look into and touch Microsoft's internal/private classes.

This time I encountered a problem which required me to create a UITypeEditor that is on an Extender Provider's provided property. Easy enough, but it doesn't stop at that. I had to use reflection to scan the component this provided property was applied to, to find all public boolean properties with get/set accessors. Now we're in that no-man's land I was talking about earlier.

Point of Interest: If you want to apply Design-Time support attributes to properties supplied by an Extender Provider, you must apply them to both the Get and Set methods you create.

The following is the solution to this problem. I tried documenting it as best I can:

using System;
using System.ComponentModel;
using System.Globalization;
using System.Collections;
using System.Drawing.Design;
using System.Windows.Forms;
using System.Windows.Forms.Design;
using System.Reflection;

/// <summary>
/// Written by Omer van Kloeten. All rights reserved.
/// </summary>
namespace HowTo
{
    /// <summary>
    /// Provides a user interface for selecting a state property.
    /// </summary>
    public class ConsciousTypeEditor : UITypeEditor
    {
        // This class is the list that will pop up when we click
        // on the down arrow of the mock-combo box in the designer.
        private class PropertiesList : ListBox
        {
            public PropertiesList(Component component)
            {
                // Go over all properties, filtering out the ones we need (public/get/set/boolean).
                // None is a reserved type for a case where no property is selected.
                foreach (PropertyInfo info in component.GetType().GetProperties())
                {
                    if (info.GetGetMethod(false) != null &&
                        info.GetSetMethod(false) != null &&
                        info.PropertyType == typeof(bool) &&
                        info.Name != "None")
                    {
                        this.Items.Add(info.Name);
                    }
                }

                this.Items.Add("None");


                this.Sorted = true;
                 // Not setting the border to none just doesn't look good.
                this.BorderStyle = BorderStyle.None;
            }
        }

        /// <summary>
        /// Displays a list of available values for the specified component than sets the value.
        /// </summary>
        /// <param name="context">An ITypeDescriptorContext that can be used to gain additional context information.</param>
        /// <param name="provider">A service provider object through which editing services may be obtained.</param>
        /// <param name="value">An instance of the value being edited.</param>
        /// <returns>The new value of the object. If the value of the object hasn't changed, this method should return the same object it was passed.</returns>
        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
        {
            if (provider != null)
            {
                // This service is in charge of popping our ListBox.
                IWindowsFormsEditorService service1 = ((IWindowsFormsEditorService) provider.GetService(typeof(IWindowsFormsEditorService)));

                if (service1 != null)
                {
                    // This is an internal Microsoft class representing the PropertyGrid entry for our component.
                    if (provider.GetType().FullName == "System.Windows.Forms.PropertyGridInternal.PropertyDescriptorGridEntry")
                    {
                        // Get the component we're working on via reflection.
                        Component comp = ((Component)(provider.GetType().GetProperty("Component").GetGetMethod().Invoke(provider, new object[0])));

                        PropertiesList list = new PropertiesList(comp);

                        // Drop the list control.
                        service1.DropDownControl(list);

                        if (list.SelectedIndices.Count == 1)
                        {
                            value = list.SelectedItem.ToString();
                        }

                        // Close the list control after selection.
                        service1.CloseDropDown();
                    }
                }
             }

            return value;
        }

        /// <summary>
        /// Gets the editing style of the <see cref="EditValue"/> method.
        /// </summary>
        /// <param name="context">An ITypeDescriptorContext that can be used to gain additional context information.</param>
        /// <returns>Returns the DropDown style, since this editor uses a drop down list.</returns>
        public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context)
        {
            // We're using a drop down style UITypeEditor.
            return UITypeEditorEditStyle.DropDown;
        }
    }
}

Hack Value:	[	X	X	X	X	X	]
Cool Value:	[	X	X	X	X	-	]
Usable Value:	[	X	X	X	X	-	]

How To: Manually Run a Type Initializer

Omer van Kloeten — Thu, 30 Oct 2003 20:01:00 GMT

A Type Initializer is first called when referencing a static member or creating an instance of the class.
This might cause problems to some developers as the Type Initializers are not called upon loading the AppDomain, loading the Assembly or using Reflection on the Type.

This is solved by using System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(RuntimeTypeHandle), which invokes the Type Initializer.

Personally, I tried using it once and stopped since it's just too hackish.

Hack Value:	[	X	X	X	X	-	]
Cool Value:	[	X	X	X	X	-	]
Usable Value:	[	X	X	-	-	-	]