Search results matching tag 'Performance'

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?

Major performance issue with loading ROLB

TSF — Thu, 12 Apr 2012 03:51:18 GMT

I'm hoping that someone can point me in the right direction for my SL4 / CSLA4 app.

A SQL recordset containing 2,500 rows (about 16 columns) is returned from the local DP. The proc executes in under 1 second. However, the time it takes to loop through each record in the ROLB DP method and pass it to the ROB via the DP.FetchChild (e.g. var item = DataPortal.FetchChild<ItemStatusInfo>(data);) takes approx 8 seconds.

To make matters worse, when I point the app to our remote DP on an application server, the WCF service generally times out after 30 seconds when trying to run the exact same query. I don't know if this second issue is due to trying to send that much info across the wire, or something else. Regardless, neither scenario is acceptable. (Note - I am using compression following Rocky's example in his e-book.)

I've followed the examples that I've seen for ROLB / ROB objects and am wondering if there is any way to significantly reduce the time it takes to load all this data in order to show in a data grid. I remember reading about a lazy load pattern, but am hoping to get some sense of direction before going down the wrong path. Thanks.

CSLA mobile objects network transmission

Direvius — Thu, 25 Aug 2011 08:52:55 GMT

Good day everyone!

We have a webapp based on Silverlight, WCF and CSLA. I've done some performance optimization for the app and the bottleneck for now is CSLA. I've analyzed the request, it was a search by UID operation.

UID is 10-digit decimal. CSLA had serialized an object (FindByUIDCriteria) with a huge amount of additional data (state stack for example) resulted in message size of 50 KB. We have to make about 850 similar requests per second which is obviously can make our 8-core CPU to cry (and the network).

Is there a way to reduce the message size (maybe by disabling the undo history or global and client contexts transmission)?

Thnx, Alexey.

Permission based authorization and performance in CLSA.NET v4

nhwilly — Tue, 09 Aug 2011 20:25:13 GMT

I thought I had a good initial design for doing a permission based authorization model based on Rocky's comments and my understanding of things - until I read in Using CSLA 4 how the principal and hence the identity have to be passed through the dataportal on each call. That, or they have to be reconstructed on the other end.

In the latest version of Using CSLA 4, Rocky makes a point of possible performance issues if too much data ends up in the identity. Uh oh.

Well, the design I have makes it possible to have quite a few permissions - hundreds possibly - in a given application - all stored in a SQL database. I don't want to reread all that on each dataportal call at the server and if the list is large, I don't want to passed it along the wire on each dataportal call. I know if there was some easy workaround, Rocky would have suggested it in his writings. So I guess it's a choice of the lesser of the evils, unless someone has a better idea.

I haven't finalized any of it yet and I thought I'd ask if anyone has used a permission set that's large and which approach they took. Maybe I'm worried too much about nothing, but I was hoping this security module would work for both my ASP.NET applications and my WPF app.

Thanks in advance.

Performance challange why shuld object take 7 second for fetching?

Saman — Thu, 14 Jul 2011 07:05:51 GMT

Hello

I searched about performance tuning in CSLA as my application is too slow

i checked the penalty of linq and i found that performance hit is not related to it.

first of all i have a business object Personnel that defined as follow:

[Serializable]
    [Csla.Server.ObjectFactory("PMS.PersonnelFactory,PMS", "Create", "Fetch", "Update", "Delete")]
    public class Personnel : BusinessBase<Personnel>
    {

public static Personnel GetPersonnel(string id)
        {
            FetchPersonnel type = new FetchPersonnel("ByID",id,"");
            return DataPortal.Fetch<Personnel>(new SingleCriteria<FetchPersonnel>(type));
        }

}

and i have factory class:

public Personnel Fetch(SingleCriteria<FetchPersonnel> criteria)
        {

            var obj = (Personnel)MethodCaller.CreateInstance(typeof(Personnel));
            using (var ctx = ContextManager<PMS.DAL.PMSDALDataContext>.GetManager("PMS"))
            {
                if (criteria.Value.SearchType == "ByID")
                {
                    try
                    {
                        var item = ctx.DataContext.fn_GetPersonnel(criteria.Value.SerarchID).First();
                        obj = GetPersonnel(item.PersonnelID_pkey, item.NationalID_id, item.Name_name, item.Family_name, item.Image_img.ToArray(), item.OrgPost_other, item.UnitID_pkey, item.UnitName_other, item.StatusID_pkey, item.StatusName_other, item.IPAddress_ipadd, item.RoleID_pkey, item.RoleName_other, item.ActiveID_pkey, item.Password_pass, "", "", "", "", "", "", "", "", "", "");
                    }catch(Exception){}
                }

}

this process takes 7 second.

am i using anything wrong?

CSLA performance issues with large data sets

JFernando — Tue, 19 Apr 2011 01:30:40 GMT

Normal 0 false false false EN-US X-NONE X-NONE

Hello folks,

Though CSLA works quite nicely with smaller datasets I am seeing a performance issue when accessing larger data sets. In particular I have a CSLA Read Only List Object that in some cases could contain over 19K child elements. In these cases, I am observing that Csla.ReadOnlyBase.LoadProperty chews up majority of time (in reflection) when building the list; and of course, this significantly impacts performance!

{To the interested reader – the profiling data is given below}

Has anyone seen this performance issue before?

Has this been fixed in the framework (I am currently using CSLA Ver 4.0.1.0) or is there a workaround?

Here’s the stack

Function Name

Inclusive Samples

Exclusive Samples

Inclusive Samples %

Exclusive Samples %

Module Name

-	MiddleTier.Library.AMS360ReadOnlyBase`1.LoadProperties(object)

6,562

96.01

0.01

MiddleTier.Library.DLL

-	MiddleTier.Library.AMS360ReadOnlyBase`1.LoadProperties(object,string[])

6,561

95.99

0.47

MiddleTier.Library.DLL

-	Csla.ReadOnlyBase`1.LoadProperty(class Csla.Core.IPropertyInfo,object)

5,544

81.11

0.63

Csla.DLL

System.RuntimeType.GetMethods(valuetype System.Reflection.BindingFlags)

1,633

23.89

mscorlib.ni.dll

System.Reflection.RuntimeMethodInfo.MakeGenericMethod(class System.Type[])

1,603

23.45

mscorlib.ni.dll

System.Reflection.MethodBase.Invoke(object,object[])

1,164

908

17.03

13.28

mscorlib.ni.dll

-	System.Linq.Enumerable.FirstOrDefault(class System.Collections.Generic.IEnumerable`1<!!0>)

929

334

13.59

4.89

System.Core.ni.dll

Csla.ReadOnlyBase`1.<LoadProperty>b__a(class System.Reflection.MethodInfo)

595

222

8.71

3.25

Csla.DLL

-	Csla.Reflection.MethodCaller.CallPropertyGetter(object,string)

570

8.34

0.73

Csla.DLL

Csla.Reflection.MethodCaller.GetCachedProperty(class System.Type,string)

413

6.04

0.13

Csla.DLL

And the function that takes up time

protected virtual void LoadProperty(IPropertyInfo propertyInfo, object newValue)

{

var t = this.GetType();

var flags = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance;

var method = t.GetMethods(flags).Where(c => c.Name == "LoadProperty" && c.IsGenericMethod).FirstOrDefault();

var gm = method.MakeGenericMethod(propertyInfo.Type);

var p = new object[] { propertyInfo, newValue };

gm.Invoke(this, p);

}

thanks,

CSLA 4.1 performance issue

slackmaster — Tue, 29 Mar 2011 00:41:56 GMT

I have a table of around 15 columns, with a few hundred records, potentially going to thousands. I present the user with a "search" form, so that they can select a record to work with. Using a ReadOnlyListBase/ReadOnlyBase combination, I populate a BindingSource, and bind that to a listbox.

The problem I have is this: it takes around 15 seconds for the ReadOnlyListBase to populate itself with the 300 or so records? Performing a direct select on the table in SQL Management Studio of course takes milliseconds. Here is a snippet of the ROB:

    internal TableInfo(WMSSafeDataReader dr)
    {
      Fetch(dr);
    }
 
    #endregion
 
    #region Data Access
 
    private void Fetch(WMSSafeDataReader dr)
    {
      this.Id = dr.GetInt32("ID");
      this.Code = dr.GetString("CODE");
      this.Description = dr.GetString("DESCRIPTION");
    }

and the ROLB:

    private void DataPortal_Fetch(Criteria criteria)
    {
      RaiseListChangedEvents = false;
      using (var ctx = ConnectionManager.GetManager(connectionString, false))
      {
        using (IDbCommand cm = ctx.Connection.CreateCommand())
        {
          cm.CommandText = "SELECT ID, CODE, DESCRIPTION FROM TABLE "; 
          if (criteria.ThisId != 0)
          {
            cm.CommandText += " WHERE ";
            cm.CommandText += " THIS_ID = @THIS_ID ";
            cm.Parameters.Add(CreateParm("THIS_ID", criteria.ThisId));
          }
  
          using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
          {
            IsReadOnly = false;
            while (dr.Read())
            {
              Add(new TableInfo(dr));
            }
            IsReadOnly = true;
          }
        }
      }
      RaiseListChangedEvents = true;
    }

Is there anything I can do differently to speed this up? 5 seconds per 100 records in absolutely unacceptable?! Thanks.

AddNew performance question

bartol — Tue, 18 Jan 2011 15:03:55 GMT

Hi,

I am using CSLA 4.0 and WPF and I have this BO that has a child collection (based on BusinessListBase) where the results of a calculation are stored. The child that is stored in the collection only has two properties: a Guid and a double.

The problem I have is when I use AddNew to create over 10,000 items (the results of my calculation) it takes a long time to create them. I am overriding AddNewCore as such:

protected override MyResult AddNewCore()
{
Add(MyResult.New());
return Items[Items.Count - 1];
}

The code that fills the collection is something like this:

foreach(var item in CalculationResults)
{
   var c = AddNew();
   c.Value = item.value;
   c.ReferenceId = item.Id;
}

I wonder if there is a better and faster way to do this? I stepped through the CSLA code and there are lot of IsValid checks during the process which maybe could be postponed until the end of my bulk operation.

Thanks,
B

Re: a critical performance issue.

keni_nan — Mon, 02 Aug 2010 05:52:50 GMT

hello Rock:

I have set the property 'RaiseListChangedEvents' to false when loading the list. but i found 'AddEventHooks(OnAddEventHooks)' is invoked by 'LoadPropertyValue'; and 'PropertyChanged' is invoked yet.

thanks!

a critical performance issue.

keni_nan — Mon, 02 Aug 2010 01:26:49 GMT

hello,

when i do a performance test on CSLA , I found that there two points('ExtendedBindingList`1::OnAddEventHooks' and ' BindableBase::add_PropertyChanged') spend the most of time .

how can i handle this case?

thanks!