What do you need?

• Mono for Windows, Gtk#, and XSP

After the step by step installation, you should go to the library folder which usually is located here: C:\Program Files\Mono-2.8.2\lib\mono\4.0

Then you should copy all assemblies to

C:\Program Files\Reference Assemblies\Microsoft\Framework\.NETFramework\v3.5\Profile\Mono

After that you should create the RedistList folder under the Mono folder. Then you can create FrameworkList.xml file with the following content:

<?xml version="1.0" encoding="utf-8"?>
<FileList  Redist="Mono_2.8.2" Name="Mono 2.8.2 Profile" RuntimeVersion="2.0" ToolsVersion="2.0">
</FileList>

Now you should start the Visual Studio 2010 and change the target framework of your project via the properties panel:

Linux compatibility

If you want to check for the project compatibility with the Linux platform, you should download the Mono Migration Analyzer tool (MoMa) from here.

You can integrate it in your project build in this way:

Notice that you should add the installation folder of MoMa to the system environment variable PATH.

(MSDN) Dynamic methods expand the functionality of the types in the System.Reflection.Emit namespace in several ways:

• They have less overhead, because there is no need to generate dynamic assemblies, modules, and types to contain the methods.
• In long-running applications, they provide better resource utilization because the memory used by method bodies can be reclaimed when the method is no longer needed.
• Given sufficient security permissions, they provide the ability to associate code with an existing assembly or type, and that code can have the same visibility as internal types or private members.
• Given sufficient security permissions, they allow code to skip just-in-time (JIT) visibility checks and access the private and protected data of objects.

Before you define the method body, you should declare the delegate types that you should use to access the properties of the unknown type:

protected delegate void SetValueHandler(object component, object value);
protected delegate object GetValueHandler(object component);

To define the methods’ bodies you should feel comfortable with Microsoft Intermediate Language (IL).

By using the ILGenerator class, you can define the getter method in this way:

protected virtual GetValueHandler CreateGetValueHandler(PropertyInfo propertyInfo)
{
    MethodInfo getMethodInfo = propertyInfo.GetGetMethod();
    DynamicMethod getMethod = new DynamicMethod("GetValue", typeof(object), new Type[] { typeof(object) }, typeof(PropertyAccessor), true);
    ILGenerator ilGenerator = getMethod.GetILGenerator();

    ilGenerator.Emit(OpCodes.Ldarg_0);
    ilGenerator.Emit(OpCodes.Call, getMethodInfo);

    Type returnType = getMethodInfo.ReturnType;

    if (returnType.IsValueType)
    {
        ilGenerator.Emit(OpCodes.Box, returnType);
    }

    ilGenerator.Emit(OpCodes.Ret);

    return getMethod.CreateDelegate(typeof(GetValueHandler)) as GetValueHandler;

}

Also, the body of the setter method should be created as it’s shown in the following code snippet:

protected virtual SetValueHandler CreateSetValueHandler(PropertyInfo propertyInfo)
{
    MethodInfo setMethodInfo = propertyInfo.GetSetMethod(false);
    DynamicMethod setPropertyValue = new DynamicMethod("SetValue", typeof(void), new Type[] { typeof(object), typeof(object) }, typeof(PropertyAccessor), true);
    ILGenerator ilGenerator = setPropertyValue.GetILGenerator();

    ilGenerator.Emit(OpCodes.Ldarg_0);
    ilGenerator.Emit(OpCodes.Ldarg_1);

    Type parameterType = setMethodInfo.GetParameters()[0].ParameterType;

    if (parameterType.IsValueType)
    {
        ilGenerator.Emit(OpCodes.Unbox_Any, parameterType);
    }

    ilGenerator.Emit(OpCodes.Call, setMethodInfo);
    ilGenerator.Emit(OpCodes.Ret);

    return setPropertyValue.CreateDelegate(typeof(SetValueHandler)) as SetValueHandler;
}

I have encapsulated the dynamic method accesses in the PropertyAccessor class, which declaration looks as follows:

public class PropertyAccessor
{
    protected delegate void SetValueHandler(object component, object value);
    protected delegate object GetValueHandler(object component);

    private SetValueHandler setValueHandler;
    private GetValueHandler getValueHandler;

    public PropertyAccessor(Type ownerType, string propertyName)
        {
            PropertyInfo propertyInfo = ownerType.GetProperty(propertyName);

            if (propertyInfo.CanRead)
            {
                this.getValueHandler = this.CreateGetValueHandler(propertyInfo);
            }

            if (propertyInfo.CanWrite)
            {
                this.setValueHandler = this.CreateSetValueHandler(propertyInfo);
            }
        }

    public object GetValue(object component)
        {
            if (this.getValueHandler == null)
            {
                throw new InvalidOperationException();
            }

            return this.getValueHandler(component);
        }

    public void SetValue(object component, object value)
        {
            if (this.setValueHandler == null)
            {
                throw new InvalidOperationException();
            }

            this.setValueHandler(component, value);
        }
}

I measured the performance among the three approaches against 1 000 000 times invocation of one of the properties of the Employee entity class:

Notice that the direct access approach followed by the Dynamic Methods implementation are the fastest.

You can download the PropertyAccessor class implementation here.

This problem is scaled, when Microsoft ships Windows Presentation Foundation due to the lifecycle of visual element in the framework. They addressed this issue with implementation of Weak Event Design Pattern.

But what should do if we are not using WPF? After my research regarding the pattern I realised that we need something which is more simple than porting or implementing the weak event pattern. My idea is to use Weak Reference object as host of each event that I want to be automatically memory managed by the GC. This may be easily achieved by generic class that will wraps event handler and make it possible to be used the same as event handlers are used. But unfortunately it could not be used in case of wrapping delegate, because GC will collect it on next collection. This happens, because nobody keeps reference to the method delegate.

Design

Lets create a generic class WeakEventHandler<TEventArgs>, which can received as type parameter only arguments inherited from EventArgs class. We will have 3 methods (for subscribe, unsubscribe and raise event). To make the class to look more natively as the trivial EventHandler<TEventArgs> we will create also operators +/- with EventHandler<TEventArgs> object.

As you can see the overridden operators +/- are very useful. It looks like that you are using normal event handler. You should create the weak event handler as private field and expose it as public event property. This achieves that the user (the programmer that use your API) thinks that he is using a normal event.

Conclusion

Weak References gives a very flexible mechanism for memory management, which allows the Garbage Collector to collect all objects that have been subscribed for specified event and are not used anymore and not referenced by anybody. But they still don’t resolve the issue, because the delegate is collected on the next Garbage Collection.

References

After I created this article I searched in Google, regarding this approach and found several guys that has the similar or same ideas it before me. You may check their articles and approaches:

• Weak Events in C# By Daniel Grunwald
• Prevent .Net Memory Leaks with the WeakEventManager by Ronald

Note: I edited the article, because I don’t want to give a wrong example of using WeakReference class. See Part 2, where the right usage will be shown. In the first version I did a little joke to provoke people to write. Thanks to Beat Keiner that found what is wrong

Reading MSDN I figure out that Windows API provide the availability to get all child handles for specified handle. We should use unmanaged EnumChildWindows function provided by user32.dll.

MSDN Definition

EnumChildWindows function enumerates the child windows that belong to the specified parent window by passing the handle to each child window, in turn, to an application-defined callback function. EnumChildWindows continues until the last child window is enumerated or the callback function returns FALSE.

Syntax

BOOL EnumChildWindows(
         HWND hWndParent,
         WNDENUMPROC lpEnumFunc,
         LPARAM lParam
);

hWndParent

          [in] Handle to the parent window whose child windows are to be enumerated.

lpEnumFunc

[in] Pointer to an application-defined callback function.

lParam

[in] Specifies an application-defined value to be passed to the callback function.

Note: If a child window has created child windows of its own, EnumChildWindows enumerates those windows as well.

How is used from .NET Framework

We are using DLLImport attribute to expose the method in .NET Environment. The specific point is that we create a handle to the list where are collected all pointers, due to availability to access it from the callback function where we know which is the child handle.

References

• MSDN

Lets say that we have this class that derives Data Table:

As you can see I’m creating dummy WcfDataTable object, which I’m cloning using xml serialization and deserialization. The cloned object is not identical with the original object, because this additional field is not initialized with the original value (it’s null). The existing xml serialization doesn’t catch the new field in the class. To make possible this field for xml serialization we should override the existing xml serialization, but how to do it? The solution is really simple. You have to implement the interface IXmlSerializable with explicit override of all its methods.

After this workaround you can see that our new field is serialized and deserialized successfully.

Scenario

We are implementing our data access layer based on LINQ TO SQL. In the specifications that were created by our software architect is required to have generic method that load from the data base any record into entity object by primary key.

Problem

We become stuck, because each table has different primary key (count, name and data type of the primary key columns). So how to create a method that can be used in any case of  loading a record from the database by primary key. So we are facing the challenge how to implement GetEntityByPrimaryKey.

The Algorithm

1. Get tha mapping of the entity type
2. Use information for the mapping
  2.1 to get the name of the columns
  2.2 to get the name of the columns included in the primary key
3. Generate the T-SQL Query
4. Execute the Query via LINQ Framework to retrive the result as entity object

Before explain my approach to implement the algorithm above I want to explain you how linq expressions are executed.

Implementation and Solutions

I figured out 2 soltuions that are almost the same. The first solution (the simplest one) uses standard T-SQL that is translated by LINQ. The second one is using dynamic lambda expressions to build LINQ Query that is used to get the entity from the database.

Solution No.1

This is the easiest and simple way to get a entity by primary key. This is the solution that I gave to my colleague.

Solution No.2

This is the solution is more complicated than the one above.

Conclusion

  In Solution No.1 we generate T-SQL string that is executed by LINQ and the result is translated as entity object. Insead of this in Solution No.2 we created dynamic LINQ expression that is translated by LINQ TO SQL Framework to T-SQL, which expected to be costly. So I did some tests in Northwind database to prove my expectations.
  Solution No.1 loads 1 record from table Employees for 315 milliseconds (average speed) againts 292 milliseconds (average speed) for Solution No.2. So I can’t say which implementation is the best way to resolve the task. Presently I’m in doubt about that. Why solution no.2 is faster than Solution no.1? I hope that I will give the aswer of this question soon in further posts.