Category: AOPMethods

For see fast what is happening with your server, you can use the Server Timing API.

One of the implementations for .NET is https://github.com/tpeczek/Lib.AspNetCore.ServerTiming .

Not a big deal – implemented separately with AOPMethodsCommon – but I think it is a good idea to use it.

The implementation was straightforward

builder.Services.AddScoped<ServerTiming>();
var app = builder.Build();
app.UseServerTiming();

And then use DI to get the instance of the class.

With this occasion , look how is different calling same method twice

vs

If you do not realize, there are 50 ms vs 1 ms . That difference is from caching

private async Task<TILT_Note_Table[]?> privateLatestTILTs(string urlPart, int numberTILTS)
{
    if (cache.TryGetValue<TILT_Note_Table[]>(urlPart, out var result))
    {
        return result;
    }
//code
}

Nice, right ? See the timing right in your browser.

Tools used

https://github.com/tpeczek/Lib.AspNetCore.ServerTiming

https://github.com/ignatandrei/AOP_With_Roslyn/

I make a microservices Buffet . In this I consider having email as a service . When the DevOps wants email, he can choose between various plugins ( simple smtp email, gmail, exchange, others). Those plugins can have various properties – that must be edited by the primary administrator of the microservice. The properties can be discovered at runtime ( via Reflection ) o r at build time ( via Roslyn Source Code Generators  – RSCG ).

But – we should see what is faster, right ?   And the feeling is that RSCG is always faster – but it is , really ? Let’s see…

So = let’s make a test with https://github.com/dotnet/BenchmarkDotNet . You can have the source code by going to https://github.com/ignatandrei/AOP_With_Roslyn/tree/master/AOPMethods .

First , the class that is tested

Second, with AOPMethods I generate the read properties values – properties that  you can read – via a dictionary and via a switch. This can be achieved simply :

And this will be generated by RSCG for the switch

and for the dictionary

The spec for benchmark are :

BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19043.1052 (21H1/May2021Update)
Intel Core i7-6600U CPU 2.60GHz (Skylake), 1 CPU, 4 logical and 2 physical cores
.NET SDK=5.0.301
  [Host]     : .NET 5.0.7 (5.0.721.25508), X64 RyuJIT
  DefaultJob : .NET 5.0.7 (5.0.721.25508), X64 RyuJIT

Third, I benchmark obtaining one single property – the Host – via the 3 methods:

And in Program.cs

( of course, I have added on the class
//[SimpleJob(RuntimeMoniker.Net50)]
//[ShortRunJob(RuntimeMoniker.Net50)]
//[DryJob(RuntimeMoniker.Net50)]
[Orderer(SummaryOrderPolicy.FastestToSlowest, MethodOrderPolicy.Declared)]
//[SimpleJob(RuntimeMoniker.NetCoreApp31)]
[RPlotExporter]
[CsvMeasurementsExporter]
[MemoryDiagnoser]
[HtmlExporter]
[MarkdownExporterAttribute.GitHub]
)
The results are in ns –so, the less/smaller , that means  better results.

The results are here in HTML form :

The graphic may be more interesting:

Surprised ? The RSCG Switch Property is indeed the fastest one – but the Reflection is faster than RSCG Property Dictionary ( or , at least , for my implementation).

However, I realized that in real life , I will retrieve all properties in a Dictionary to be edited . So all implementations should occur the penalty of creating a Dictionary . Time for next benchmark . This time , the code is

and the results are:

Now the graphic will help:

Interesting , right ?

Reflection = as normal –  is the slowest one. But the difference between RSCG switch and RSCG Dictionary is not too much…

Conclusion 1:  the feeling  was right at the end. But – the first result was deceiving

Conclusion 2: Creating a dictionary is more time consuming than a simple reflection for one property retrieved

Conclusion 3: I do prefer RSCG Dictionary vs RSCG switch – less work for me as a programmer and similar time results.

Conclusion 4: do not over engineer if you do not feel the need . For just one property, Reflection is better….

Conclusion 5: This is not final. I should also write the values of the properties . Maybe next time a new benchmark….

I was trying to apply AOPMethods to – surprise! –  AOPMethods project itself. And I have discovered a new reason: I do not want to make the methods public. I just want to put try/catch around them to know what is wrong.

The fast – and not so good – idea was to transform

MethodPrefix =”pub”

into a

Dictionary<MethodsPrefix: string,  VIsibilty: string>

in order to pass something like that

{ “pub”, “public” } , {“prv”, “private”}

The second idea was better : what if I allow multiple instances and generate accordingly  ?

So I came up with this definition

[AutoMethods(template = TemplateMethod.MethodWithPartial, MethodPrefix =”pub”)]
[AutoMethods(template = TemplateMethod.CustomTemplateFile,CustomTemplateFileName =”privateTryCatch.txt”,  MethodSuffix = “bup”)]
partial class Person

And the code  processes both attributes – and generates the code. One slightly problem: Cannot have GeneratedCode and CompilerGenerated on both generated files. But – it works!

The problems that I have encountered were:

1.  The ThisAssembly  RoslynGenerator that I use should not be put as reference in the nuget. I have fixed this by adding

<PackageReference Include=”ThisAssembly.AssemblyInfo” Version=”1.0.0″ ReferenceOutputAssembly=”false” />

2. I have problems generating code to async code with Task . The problem was that I have added logging ( very basic – Console.WriteLine) and the order of the logging was errating. I figured out that I should must use the async /await and then my template was modified as

strAwait = “”
strAsync =””
if mi.IsAsync == true
     strAwait = ” await “
     strAsync  = ” async “
end

public {{strAsync}} {{mi.ReturnType}} {{mi.NewName}} ({{mi.parametersDefinitionCSharp }} {{separator}} 

//more code

{{
     if mi.ReturnsVoid == false
}}
     return
{{
     end
}}
{{  strAwait }}

{{mi.Name}}({{ mi.parametersCallCSharp }});

And this is worth noting.

The code is not so much different from SkinnyControllers : Implement ISourceGenerator , putting the Generator attribute on the class

[Generator]
    public partial class AutoActionsGenerator : ISourceGenerator

inspecting the classes if they have the common attribute , generating code with Scriban

The problem was : How can the AOPMethods can

1. differentiate between the private function that must be made public
2. generate the code for a similar public function, with same parameters (and maybe more) , but with different name ?

So I decide to go the route of convention: The programmer will declare the private function that he wants to autmatically make public ( and add templating code ) with a prefix or a suffix . This will be declared into the attribute of the class – and that will be all.

For example , I have this method

public  string FullName()
{
            
     return FirstName + ” ” + LastName;
}

That I want to monitor ( add logs, info and so on ) . I will make it private and start with pub

private string pubFullName()
{
            
     return FirstName + ” ” + LastName;
}

Then , on the class , I will declare the pub prefix

[AutoMethods(template = TemplateMethod.CallerAtttributes, MethodPrefix =”pub”, MethodSuffix =”bup”)]

And the following will be generated

public string FullName(
[CallerMemberName] string memberName = “”,
[CallerFilePath] string sourceFilePath = “”,
[CallerLineNumber] int sourceLineNumber = 0)
{
     try
     {
         Console.WriteLine(“–pubFullName start “);
         Console.WriteLine(“called class :” + memberName);
         Console.WriteLine(“called file :” + sourceFilePath);
         Console.WriteLine(“called line :” + sourceLineNumber);

        return

    pubFullName();
     }
     catch (Exception ex)
     {
         Console.WriteLine(“error in pubFullName:” + ex.Message);
         throw;
     }
     finally
     {
         Console.WriteLine(“——–pubFullName end”);
     }

}

The caller attributes templates can be found at  AOP_With_Roslyn\AOPMethods\AOPMethods\templates\CallerAtttributes.txt

//——————————————————————————
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//——————————————————————————
using System;
using System.CodeDom.Compiler;
using System.Runtime.CompilerServices;

namespace {{NamespaceName}} {

    /// <summary>
     /// Generates code from  {{ClassName}}
     /// </summary>
   [GeneratedCode(“AOPMethods”, “{{version}}”)]
   [CompilerGenerated]
   partial class {{ClassName}}{
    /*
     public int id(){
     System.Diagnostics.Debugger.Break();
     return 1;
     }
     */
     {{~ for mi in Methods ~}}
         {{
             separator = “”
             if(mi.NrParameters > 0)
                 separator = “,”
             end
             strAwait = “”
             strAsync =””
             if mi.IsAsync == true
                 strAwait = ” await “
                 strAsync  = ” async “
             end
         }}
         public {{strAsync}} {{mi.ReturnType}} {{mi.NewName}} ({{mi.parametersDefinitionCSharp }} {{separator}} 
         [CallerMemberName] string memberName = “”,
         [CallerFilePath] string sourceFilePath = “”,
         [CallerLineNumber] int sourceLineNumber = 0){
             try{
                 Console.WriteLine(“–{{mi.Name}} start “);
                 Console.WriteLine(“called class :”+memberName );
                 Console.WriteLine(“called file :”+sourceFilePath );
                 Console.WriteLine(“called line :”+sourceLineNumber );
             {{
                 if mi.ReturnsVoid == false
             }}
                 return
             {{
                 end
             }}
             {{  strAwait }}

            {{mi.Name}}({{ mi.parametersCallCSharp }});
             }
             catch(Exception ex){
                 Console.WriteLine(“error in {{mi.Name}}:” + ex.Message);
                 throw;
             }
             finally{
                 Console.WriteLine(“——–{{mi.Name}} end”);
             }

         }

     
     {{~ end ~}}   
    
   }
}             

You can add logging , security, anything else that is a vertical to the business

As I have done with Roslyn for SkinnyControllers , I said – what about generating public methods at compile time ?

For example, what if this method

private string pubFullName()
{

return FirstName + ” ” + LastName;

}

is transformed into this

public string FullName(
[CallerMemberName] string memberName = “”,
[CallerFilePath] string sourceFilePath = “”,
[CallerLineNumber] int sourceLineNumber = 0)
{
try
{
Console.WriteLine(“–pubFullName start ” + _cc);
Console.WriteLine(“called class :” + memberName);
Console.WriteLine(“called file :” + sourceFilePath);
Console.WriteLine(“called line :” + sourceLineNumber);

return pubFullName();
}
catch (Exception ex)
{
Console.WriteLine(“error in pubFullName:” + ex.Message);
throw;
}
finally
{
Console.WriteLine(“——–pubFullName end”);

}
}

automatically, based on a template ? And all methods will have this ?

Enter AOP Methods : https://www.nuget.org/packages/AOPMethodsGenerator/  and https://www.nuget.org/packages/AOPMethodsCommon/

The first one is the generator. The second one is containing the attribute that tells to transform.