C# Reflection and Attributes on Jeppe Spanggaard - Software Developer | .NET, Azure & Microsoft 365

Web Api logging attribute

Jeppe — Sun, 18 Feb 2024 00:00:00 +0000

Have logging ever irritated you?

If yes, then you’re definitely not alone! Often when I work with Web APIs in C#, logging tends to take up a lot of space, making the code quickly look “ugly.” I like to log what parameters the method is called with, which controller the method is in, etc. Therefore, a method often looks like this for me, in a simplified way:

[HttpGet("{id}")]
public ActionResult Get(int id)
{
    _logger.LogInformation($"Starting to find weather forecast with ID: {id}");
    { ... }
    _logger.LogInformation($"Weather forecast with id {id} is fetched");
    return new WeatherForecast();
}

Output

Starting to find weather forecast with ID: 234
Weather forecast with id 234 is fetched

I definitely don’t find it visually appealing, and it contributes to my classes sometimes becoming extremely long. Therefore, I’ve been thinking that it should be possible to make it easier and also more elegant. It got me thinking about how you can do so many cool things with custom attributes, so why not create some nice logging with an attribute?

And, as so many times before, almost anything is possible with C#; it’s mainly just a matter of having the idea for it. So what I’ve come up with is just an attribute that inherits from IActionFilter, since IActionFilter already implements OnActionExecuted and OnActionExecuting.

[ActionLogger] // <-- Custom attribute
[HttpGet("{id}")]
public ActionResult Get(int id)
{
    return new WeatherForecast();
}

Output

[GET][WeatherForecastController][/WeatherForecast/234] Executing with parameters: [id, 234]
[GET][WeatherForecastController][/WeatherForecast/234] Executed

How did I go about implementing it then?

public class ActionLoggerAttribute : Attribute, IActionFilter
{
    public void OnActionExecuted(ActionExecutedContext context)
    {
        ILogger? logger = GetLogger(context, context.Controller.GetType());
        var httpMethod = context.HttpContext.Request.Method;
        var routeUrl = context.HttpContext.Request.Path;
        var controllerName = context.Controller.GetType().Name;

        if (logger == null)
        {
            return;
        }

        logger.LogInformation($"[{httpMethod}][{controllerName}][{routeUrl}] Executed");
    }

    public void OnActionExecuting(ActionExecutingContext context)
    {
        ILogger? logger = GetLogger(context, context.Controller.GetType());
        var parameters = context.ActionArguments;
        var httpMethod = context.HttpContext.Request.Method;
        var routeUrl = context.HttpContext.Request.Path;
        var controllerName = context.Controller.GetType().Name;

        if (logger == null)
        {
            return;
        }

        string baseMessage = $"[{httpMethod}][{controllerName}][{routeUrl}] Executing";
        switch (httpMethod)
        {
            case "POST":
                // Get the type of body content
                var bodyType = context.ActionDescriptor.Parameters
                    .FirstOrDefault(p => p.BindingInfo?.BindingSource?.DisplayName == "Body")
                    ?.Name;
                // Get the value of bodytype
                var bodyContent = bodyType != null ? JsonSerializer.Serialize(parameters[bodyType]) : null;

                if (bodyContent != null)
                {
                    logger.LogInformation($"{baseMessage} with body content: {bodyContent}");
                    break;
                }
                logger.LogInformation($"{baseMessage} without body content");
                break;
            case "GET":
                if (parameters.Count > 0)
                {
                    logger.LogInformation($"{baseMessage} with parameters: {string.Join(", ", parameters)}"
                    break;
                }
                logger.LogInformation($"{baseMessage} without parameters");
                break;
            default:
                logger.LogInformation($"{baseMessage} with parameters: {string.Join(", ", parameters)}");
                break;
        }
    }

    private ILogger? GetLogger(FilterContext context, T type)
    {
        return (ILogger?)context.HttpContext.RequestServices.GetService(typeof(ILogger));
    }
}

As mentioned, I simply created an attribute that inherits from IActionFilter, allowing me to override what should happen in OnActionExecuted and OnActionExecuting. In the specific code I’ve written for my test to see what’s possible, I might have gone a bit overkill – but then again, it’s just to test the limits. I don’t think in a “real” setup you’d want to log the entire received request.

Best practice?

I know it’s not the best practice or the least resource-intensive way to log, but regardless, I’m thinking of using this type of attribute in some future projects because it’s easy, quick, and doesn’t clutter the code. Often, for me, it’s just as good, as it doesn’t necessarily matter much for the solutions I create whether it takes 40ms or 80ms, but rather how quickly I can pinpoint the root cause when an error occurs.

[Link to code]

SQL save changes w. trigger

Jeppe — Sat, 03 Feb 2024 00:00:00 +0000

The other day at work, I had to work on an old solution (some C# web API with an SQL) that a colleague had created a long time ago. Part of this solution was to create a kind of version history of objects and who had made the individual changes.

As I opened up the project, I saw some of the wildest code (in my opinion) I’ve seen in a long time to solve an otherwise simple problem😮. Without going too deep into what was done, I can say that the person who created it was very fond of reflection in C#.

How would I have done it?

Since I’ve worked a lot with SQL, it would be obvious for me to look at how to solve this directly in the database, rather than having to create a lot of generic C# code that almost no one would be able to read afterwards. So the obvious choice would be to create an SQL trigger on the exact table that should have a version history.

So let’s take an example

Let’s say we have a Person table like this:

CREATE TABLE [dbo].[Persons](
	[ID] [int] IDENTITY(1,1) NOT NULL,
	[Firstname] [nvarchar](255) NOT NULL,
	[Lastname] [nvarchar](255) NOT NULL,
	[Email] [nvarchar](255) NULL,
	[Phone] [int] NULL,
	[Address] [nvarchar](255) NULL,
	[ModifiedAt] [datetime] NULL,
	[ModifiedBy] [nvarchar](255) NULL,
 CONSTRAINT [PK_ID] PRIMARY KEY CLUSTERED 
 ( [ID] ASC )
) ON [PRIMARY]

From this table, we want to log every time a change occurs, not just that a change happens, but also what individual value changes from and to. This should, of course, be stored in a table as well, and such a table could look like this:

CREATE TABLE [dbo].[Persons_Changes](
	[TriggerID] [int] NOT NULL,
	[Firstname_Old] [nvarchar](255) NULL,
	[Firstname_New] [nvarchar](255) NULL,
	[Lastname_Old] [nvarchar](255) NULL,
	[Lastname_New] [nvarchar](255) NULL,
	[Email_Old] [nvarchar](255) NULL,
	[Email_New] [nvarchar](255) NULL,
	[Phone_Old] [int] NULL,
	[Phone_New] [int] NULL,
	[Address_Old] [nvarchar](255) NULL,
	[Address_New] [nvarchar](255) NULL,
	[ModifiedBy] [nvarchar](255) NULL,
	[ModifiedAt] [datetime] NULL
) ON [PRIMARY]

Now for the fun part🎉 - namely, the logic that triggers each time a row in the Person table is updated. The trigger is designed to only save the values that are actually changed; the others that remain unchanged are simply set to NULL.

Trigger code

CREATE TRIGGER TriggerPerson_AfterUpdate
ON dbo.Persons
AFTER UPDATE
AS
BEGIN
	DECLARE @ColumnOrdinalTotal INT = 0;
	SELECT @ColumnOrdinalTotal = @ColumnOrdinalTotal 
        + POWER (
                2 
                , COLUMNPROPERTY(t.object_id,c.name,'ColumnID') - 1
            )
    FROM sys.schemas s
        INNER JOIN sys.tables t ON s.schema_id = t.schema_id
        INNER JOIN sys.columns c ON t.object_id = c.object_id
    WHERE s.name = 'dbo'
        AND t.name = 'Persons'
        AND c.name IN (
            'Firstname',
			'Lastname',
			'Email',
			'Phone',
			'Address',
			'ModifiedAt',
			'ModifiedBy'
        );

	IF (COLUMNS_UPDATED() & @ColumnOrdinalTotal) > 0
    BEGIN
        INSERT INTO dbo.Persons_Changes
        (
			dbo.Persons_Changes.TriggerID,
			dbo.Persons_Changes.Firstname_Old,
			dbo.Persons_Changes.Firstname_New,
			dbo.Persons_Changes.Lastname_Old,
			dbo.Persons_Changes.Lastname_New,
			dbo.Persons_Changes.Email_Old,
			dbo.Persons_Changes.Email_New,
			dbo.Persons_Changes.ModifiedBy,
			dbo.Persons_Changes.ModifiedAt
        )
        SELECT d.ID
            , CASE WHEN d.Firstname = i.Firstname THEN NULL ELSE d.Firstname END
			, CASE WHEN d.Firstname = i.Firstname THEN NULL ELSE i.Firstname END
			, CASE WHEN d.Lastname = i.Lastname THEN NULL ELSE d.Lastname END
			, CASE WHEN d.Lastname = i.Lastname THEN NULL ELSE i.Lastname END
			, CASE WHEN d.Email = i.Email THEN NULL ELSE d.Email END
			, CASE WHEN d.Email = i.Email THEN NULL ELSE i.Email END
			, i.ModifiedBy
			, i.ModifiedAt
        FROM inserted i 
            LEFT JOIN deleted d ON i.ID = d.ID;
    END
END
GO

Now there should be a row like these every time a Person is updated

TriggerID	Firstname_Old	Firstname_New	Lastname_Old	Lastname_New	…	ModifiedBy	ModifiedAt
1	Jeppe1	Jeppe	NULL	NULL	…	JSC	2024-02-03 11:30:19
1	NULL	NULL	Spanggaard	Christensen	…	JSC	2024-02-03 11:35:23

And now just for fun - how can this be used in C#? First of all, we need to create the DTO classes, one for the Persons table and one for Persons_Changes. Unlike many, I hardly ever use scaffold with Entity Framework; I create the models myself.

Persons class:

    [Table("Persons", Schema = "dbo")]
    internal class Person
    {
        [Column("ID")]
        public int Id { get; set; }
        [Column("Firstname")]
        public string? Firstname { get; set; }
        [Column("Lastname")]
        public string? Lastname { get; set; }
        [Column("Email")]
        public string? Email { get; set; }
        [Column("Phone")]
        public int? Phone { get; set; }
        [Column("Address")]
        public string? Address { get; set; }
        [Column("ModifiedAt")]
        public DateTime? ModifiedAt { get; set; }
        [Column("ModifiedBy")]
        public string? ModifiedBy { get; set; }
    }

Persons_Changes:

    [Table("Persons_Changes", Schema = "dbo")]
    internal class PersonChange
    {
        [Column("TriggerID")]
        public int Id { get; set; }
        [Column("Firstname_Old")]
        public string? FirstnameOld { get; set; }
        [Column("Firstname_New")]
        public string? FirstnameNew { get; set; }
        [Column("Lastname_Old")]
        public string? LastnameOld { get; set; }
        [Column("Lastname_New")]
        public string? LastnameNew { get; set; }
        [Column("Email_Old")]
        public string? EmailOld { get; set; }
        [Column("Email_New")]
        public string? EmailNew { get; set; }
        [Column("Phone_Old")]
        public int? PhoneOld { get; set; }
        [Column("Phone_New")]
        public int? PhoneNew { get; set; }
        [Column("Address_Old")]
        public string? AddressOld { get; set; }
        [Column("Address_New")]
        public string? AddressNew { get; set; }
        [Column("ModifiedAt")]
        public DateTime? ModifiedAt { get; set; }
        [Column("ModifiedBy")]
        public string? ModifiedBy { get; set; }
    }

DbContext:

    internal class TestDbContext : DbContext
    {
        public DbSet Persons { get; set; }
        public DbSet PersonChanges { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlServer("CONNECTION_STRING");
        }

        protected void OnModelCreation(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
        }
    }

Once we have this in place, we can start playing with the data in C#, and for fun, I’m thinking of creating a ’nice’ display of who and when the individual values were changed. And even though I started joking about reflection, I use it myself (when it makes sense)😜.

internal static string FormatChange(T changeObj)
    {
        Liststring,string?,string?>> changes = new Liststring, string?, string?>>();
        var properties = typeof(T).GetProperties();
        var filteredProperties = properties
            .Where(x => x.Name.Contains("Old") || x.Name.Contains("New"));
        var distinctProperties = filteredProperties
            .Select(x => x.Name.Substring(0, x.Name.Length - 3))
            .Distinct();
        foreach (var property in distinctProperties)
        {
            var oldValueProperty = typeof(T).GetProperty($"{property}Old");
            var newValueProperty = typeof(T).GetProperty($"{property}New");
            if (oldValueProperty != null && newValueProperty != null)
            {
                var oldValue = oldValueProperty.GetValue(changeObj);
                var newValue = newValueProperty.GetValue(changeObj);
                if (oldValue != null && newValue != null)
                {
                    changes.Add(
                        new Tuple<string, string?, string?>(
                            property, 
                            oldValue?.ToString(), 
                            newValue?.ToString()
                        ));
                }
            }
        }
        StringBuilder sb = new StringBuilder();
        foreach (var change in changes)
        {
            if (change.Equals(changes.Last()))
            {
                sb.Append($"{change.Item1} from '{change.Item2}' to '{change.Item3}'");
                break;
            }
            sb.Append($"{change.Item1} from '{change.Item2}' to '{change.Item3}' and ");
        }
        return sb.ToString();
    }

When we bring it all together in a test application like this:

static void Main(string[] args)
{
    Console.WriteLine("Hello, World!");
    TestDbContext dbContext = new TestDbContext();

    List persons = dbContext.Persons.ToList();
    Person person1 = persons.First();

    List personChanges = dbContext.PersonChanges
        .Where(x => x.Id == person1.Id)
        .OrderBy(x => x.ModifiedAt)
        .AsNoTracking()
        .ToList();

   foreach (PersonChange change in personChanges)
    {
        Console.WriteLine(
            $"[{change.ModifiedAt}] {change.ModifiedBy} " +
            "updated the the properties " + 
            FormatChange(change));
    }
}

We get this output:

[2024-02-03 11:30:19] JSC updated the the properties Firstname from 'Jeppe1' to 'Jeppe'
[2024-02-03 11:35:23] JSC updated the the properties Lastname from 'Spanggaard' to 'Christensen'

Is it then a better solution?

I can’t answer that, but for me, it is - and that’s because I believe something like this belongs in a database and not in code. Also, for me, it’s much easier to read a trigger than a bunch of reflection code😏.

EF for SharePoint

Jeppe — Sun, 23 Jul 2023 00:00:00 +0000

Why and how?

Wouldn’t it be great to have the ability to retrieve data from SharePoint in the same manner you are familiar with from Entity Framework? :face_with_monocle: At least that’s what I thought when I began working with SharePoint, having worked with EF for several years.

I thought there must be a way to retrieve data from SharePoint without having to work with dictionaries and create custom parsers to convert it into class models.

And then it hit me! Why not attempt to replicate the approach used by Entity Framework? EF is user-friendly, easily extensible, and does not require numerous custom parsers.

So that’s why I’ve started a Proof of Concept (POC), where I aim to implement the functionality from EF. I have made my repository public, so everyone is welcome to provide input and contribute ideas.

See GitHub repository

How does it work?

To make it work, you need to add a number of custom attributes to its class models.

SPList
SPField

Example class

[SPList(listGuid: "128b4e17-691a-4e28-9934-7bd399ba907a", listTitle: "EmployeeTasks")]
internal class EmployeeTaskModel {
  [SPField(internalName: "ID")]
  public string? Id { get; set; }
  [SPField(internalName: "Title")]
  public string? Title { get; set; }
  [SPField(internalName: "EmployeeTask_Done")]
  public bool? Done { get; set; }
  [SPField(internalName: "EmployeeTask_Employeer")]
  public FieldLookupValue? Employeer { get; set; }
}

SPList - It should be thought of as similar to the Table-attribute (e.g [Table(“StudentMaster”)]) from EF, but it accepts both a GUID and a title. First, the code will attempt to find the list using the GUID, and if not found, it will try to find it using the title.

SPField - It should be regarded as the Column-attribute from EF, and similarly, it accepts the internal name of the list field. This will be expanded significantly in the future. One of the ideas I have is to allow you to define whether it should be converted to an enum as well.

How to use it

To use this, it doesn’t take much effort as it is neatly packed away. Therefore, only a few methods are exposed/displayed. However, it must be noted that it is still only a POC, and therefore, not everything is thoroughly tested or handled for errors very gracefully.

A prerequisite for using this is to have the PnP Core SDK installed, as all extensions, etc., are built on PnP’s web context and models.

Get list items

Normally, data would need to be extracted in the following way.

var list = context.Web.Lists.GetById(new Guid(...), p => p.Title, p => p.Items, p => p.Fields);
var listItems = list.Items.AsRequested();

Now, it is neatly packed away, so data is extracted in this manner. Unlike the previous method, this one parses the data to the specified class model.

IEnumerable items = context.Web.GetItems(p => ...);

Update a list item

Updating a list item can be done incredibly easily and quickly. Just take a look at this method:

internal EmployeeTaskModel UpdateEmployeeTask(EmployeeTaskModel employeeTask){
  EmployeeTaskModel updatedTask = context.Web.UpdateItem(employeeTask);
  return updatedTask;
}

To summarize

This POC was created to determine if it was feasible to extract data from SharePoint in an easy and efficient manner, similar to what we are accustomed to with EF.

I will continue working on this POC with the hope that one day it will evolve beyond just a proof of concept. Perhaps, in the future, it could become a part of the PnP Core SDK? :star_struck: