Performance of LoadProperty Method

rlhiggin — Fri, 27 Apr 2012 17:11:14 GMT

Hi folks,

My team is working on a WPF application using CSLA 4.2.1 for our business layer implementation. We have one area within our application that currently displays a list of 5633 info objects. This list is taking approximately 3.0 seconds to load. So, I decided to investigate in order to determine what the bottleneck is. I discovered that the culprit is in the LoadProperty(IPropertyInfo propertyInfo, object newValue) method on ReadOnlyBase<T> that is being called to populate the objects from a data reader.

This particular info object has 33 fields which means that LoadProperty is being called 5633 * 33 or 185,889 times in order to create the list we are trying to display. Upon further inspection, I discovered that this LoadProperty method is doing some pretty heavy lifting via reflection in order to set the field manager properties. I also noticed that a lot of this heavy lifting could be done during type initialization rather than each time a property is loaded.

I wanted to try this idea out to see if it would work and to see whether or not the performance would improve noticeably. What I came up with was this:


public class MyInfoObject : ReadOnlyBase<MyInfoObject>
    {
        private static readonly Dictionary<IPropertyInfo, System.Reflection.MethodInfo> genericPropertyMethods;

        static MyInfoObject()
        {
            genericPropertyMethods = new Dictionary<IPropertyInfo, MethodInfo>();

            var methods = typeof(MyInfoObject).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

            var loadPropertyMethod = methods.FirstOrDefault(x => x.Name == "LoadProperty" && x.IsGenericMethod);

            var cslaPropertyFields = typeof(MyInfoObject).GetFields(BindingFlags.Static | BindingFlags.NonPublic).Where(x => x.FieldType.GetGenericTypeDefinition().IsAssignableFrom(typeof(Csla.PropertyInfo<>).GetGenericTypeDefinition()));

            foreach (var item in cslaPropertyFields)
            {
                var current = (IPropertyInfo)(item.GetValue(null));

                genericPropertyMethods.Add(current, loadPropertyMethod.MakeGenericMethod(new[] { current.Type }));
            }
        }

        protected override void LoadProperty(IPropertyInfo propertyInfo, object newValue)
        {
            genericPropertyMethods[propertyInfo].Invoke(this, new[] { propertyInfo, newValue });
        }
    }

The goal here is that instead of creating a generic method to access the property storage every time LoadProperty is called, we create all of the generic methods that will be needed one time at type intialization via a static constructor. We then store those methods in a static dictionary so they can be accessed by all instances of the type. Finally, the LoadProperty method is overridden to look up and invoke methods that are stored in the static dictionary rather than using the base implementation which would run through all the reflection code again.

The results of this experiment were exactly what I expected -- faster performance. The time to load the list was reduced from approximately 3.0 seconds to approximately 1.0 seconds.

This particular scenario was just a test that I setup within our system to gauge performance for loading larger lists. We will have other objects that have roughly the same number of properties that get loaded from the database and may eventually have 10-20x as many records returned once the software is fielded. In the interest of keeping our architecture scalable, we are considering implementing this logic in a generic base class such as this:


public class CustomReadOnlyBase<T> : ReadOnlyBase<T>
    {
        private static readonly Dictionary<IPropertyInfo, System.Reflection.MethodInfo> genericPropertyMethods;

        static CustomReadOnlyBase()
        {
            genericPropertyMethods = new Dictionary<IPropertyInfo, MethodInfo>();

            var methods = typeof(T).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

            var loadPropertyMethod = methods.FirstOrDefault(x => x.Name == "LoadProperty" && x.IsGenericMethod);

            var cslaPropertyFields = typeof(T).GetFields(BindingFlags.Static | BindingFlags.NonPublic).Where(x => x.FieldType.GetGenericTypeDefinition().IsAssignableFrom(typeof(Csla.PropertyInfo<>).GetGenericTypeDefinition()));

            foreach (var item in cslaPropertyFields)
            {
                var current = (IPropertyInfo)(item.GetValue(null));

                genericPropertyMethods.Add(current, loadPropertyMethod.MakeGenericMethod(new[] { current.Type }));
            }
        }

        protected override void LoadProperty(IPropertyInfo propertyInfo, object newValue)
        {
            genericPropertyMethods[propertyInfo].Invoke(this, new[] { propertyInfo, newValue });
        }
    }

This would allow all of our business objects to have the same behavior. Because of the way .NET handles static members in generic types, I believe that at run time, each read only business object type, T, would get it's own generic type, CustomReadOnlyBase<T> , which means we would have one static dictionary of methods for each read only business object.

The fact that this implementation is not already in the CSLA ReadOnlyBase<T> makes me question whether or not this is actually a good idea. The performance benefit in my test scenario was obvious, but I'm curious if there are any other implications that I may have overlooked.

So, while this thread was mostly intended to be a discussion, I do still have 2 questions:

1.) Is there a better way to get the performance increase that we are looking for?

2.) Is there a reason the reflection code was being run in every single call to LoadProperty rather than one time for type initialization? Or, to reword this question, is there a reason I should not create a CustomReadOnlyBase<T> with this implementation?

Search results matching tags 'Lists', 'ReadOnlyBase', 'LoadProperty', 'Performance', and '.NET 4'

Performance of LoadProperty Method