Hi Sanping,

The first time any .NET code executes it must first be JIT compiled. The more complex the code the higher the JIT cost, usually showing as CPU and time costs. Please don't use the cost of the first execution to evaluate any .NET runtime.

Just take a List<int> for example. I create it and add some values to it. After calling 5 times, we can also see the cost of the first time is much higher than other times.

    class Program
    {
        static void Main(string[] args)
        {
            // Run 5 times
            for (int i = 0; i < 5; i++)
            {
                TestList();
            }
            
            Console.ReadKey();
        }
        
        private static void TestList() 
        {
            Stopwatch st = new Stopwatch();
            st.Start();

            var list = new List<int>();
            for (int i = 0; i < 100; i++)
            {
                list.Add(i);
            }
            
            st.Stop();
            
            Console.WriteLine("TotalMilliseconds:" + st.Elapsed.TotalMilliseconds);
        }
    }

It will cost more if you are creating a DataStore using Compute the first time because of the complex code for processing the string PB DataWindow expressions. But it will cost much lesser since the second time for any DataStore. This is my testing result based on your code:

Regards, Logan

Hi,Armeen,

    thanks for your reply.

    I have visited the site you provided,the performance is very good!

 but my test code as below(referenced the .net datastore sample code from github):

Console.WriteLine("Please input enter!");
Console.ReadKey();
{
Stopwatch st = new Stopwatch();
st.Start();
for (int i = 0; i < 1000; i++)
{
DataStore<appfunc> ds = new DataStore<appfunc>();
//lst.Add(ds);
}
st.Stop();
Console.WriteLine("new datastore:" + st.Elapsed.TotalMilliseconds);
}

appfunc is a POCO Model class has six compute columns and about 10 common columns

//-----------------------------------------
//computes
[DwCompute(@"disabled+1+flagdelete+1+sortid+1")]
public int? total { get; set; }
[DwCompute(@"disabled+1+flagdelete+1+sortid+1")]
public int? total1 { get; set; }
[DwCompute(@"disabled+1+flagdelete+1+sortid+1")]
public int? total2 { get; set; }
[DwCompute(@"disabled+1+flagdelete+1+sortid+1")]
public int? total3 { get; set; }
[DwCompute(@"disabled+1+flagdelete+1+sortid+1")]
public int? total4 { get; set; }
[DwCompute(@"disabled+1+flagdelete+1+sortid+1")]
public int? total5 { get; set; }

1000 times new cost about 10 seconds

but only once create datastore instance,cost about  357 ms

the performance seems not so good.

after remove compute columns,once create datastore instance,cost about  159 ms

Why?

Is there any best practice sample code for developer?

thanks!

Best regards,
Sanping

Hi Sanping,

EF Core and Dapper are very different ORMs.  With Dapper you are coding SQL whereas in EF Core you are not.  

.NET DataStore is similar to EF Core and driven by C# models.  Even though there are similarities, Appeon invested to create .NET DataStore to address some shortcomings of EF Core:

1. EF Core is very complex framework.  Many developers don't really understand how to properly use it.  This is why you see some developers complain about performance problems while others say it is great.

2. EF Core is not low-code development.  You can compare the sample code in the showcase, and for more complex development there is even bigger difference.  Basically, programming business logic with .NET DataStore is similar productivity as DataWindow in native PB.

3. EF Core has huge learning curve for PowerBuilder developers.  Whereas .NET DataStore has virtually all the same properties, events, and functions as the DataWindow in native PB.

Performance wise EF Core is very good (if you know what you are doing), but I want to caution you because it is complex framework I think for many customers the .NET DataStore will perform better in real-life situation.  By the way, the .NET DataStore showcase has some performance benchmarks.

Best regards,
Armeen