DEV Community: Ricky Stam

C# - The For Loop Paradox

Ricky Stam — Mon, 21 Sep 2020 07:31:38 +0000

For Loop Paradox

So first of all what is the for loop paradox?

It happens when you use i value of a for loop inside an async Task. What will happen is that your task will run only using the last value of i. Maybe if your for loop is very big some of your Tasks might get also some intermediate values.

But let's see some code to demonstrate this behavior:



class Program
{
    static async Task Main(string[] args)
    {
        var tasks = new List<Task>();

        for (var i = 0; i <= 9; i++)
        {
            tasks.Add(Task.Run(() =>
            {
                Console.WriteLine(i);
            }));
        }

        await Task.WhenAll(tasks.ToArray());
    }
}

The expected result would be to print on the console all the values from 0 to 9 in a random order since these are Tasks and ordering is not guaranteed.

But let's see what we actually get:

Hmmm... something is wrong we are actually printing only the number 10 which is not expected at all...

Why is this happening?

This is a common behavior with closures, what happen is that this piece of code:



tasks.Add(Task.Run(() =>
        {
            Console.WriteLine(i);
        }));

is using the value that i has at the time of the execution.

Closures close over variables, not over values.

Ok, but how to work around this behavior?

The fix is pretty simple, just assign the i value to a new variable.



class Program
{
    static async Task Main(string[] args)
    {
        var tasks = new List<Task>();

        for (var i = 0; i <= 9; i++)
        {
            // work around for closure behavior
            var j = i;

            tasks.Add(Task.Run(() =>
            {
                // use the new j variable here
                Console.WriteLine(j);
            }));
        }

        await Task.WhenAll(tasks.ToArray());
    }
}

Now every time we iterate over the for loop, we create a new variable j. Each closure is closed over a different j variable, which is assigned only once and keeps the correct current value of i variable at each iteration.

Now in our console we get the expected results!

History Lesson Incoming!

This behavior was also happening when using foreach loop but the C# Team did a breaking change when they released the C# 5 and "fix" this behavior.

But for the for loop they decided to keep it as it is.

More resources

You can read more about closures in C# and how to use them to your advantage on the article of one and only Jon Skeet The Beauty of Closures

I hope that by reading this article I'll save you some debug time!

This post was written with love ❤️

EF Core: How to implement basic Auditing on your Entities

Ricky Stam — Mon, 01 Jun 2020 08:00:48 +0000

EF Core Audit properties

A common requirement but also a good practice is to add some some auditing properties in all the entities you save in the database.

The most common properties to use are:

CreateBy (The user who created the initial entry)
ModifiedBy (The user who modified the entry last)
CreatedAt (The datetime of creation of initial Entry)
ModifiedAt (The datetime the entry was last modified)

Let's start implementing this functionality

First we are going to create a new base class named AuditableEntity that every other entity will inherit from when we need to add the audit functionality.

public class AuditableEntity
{
    public string CreatedBy { get; set; }
    public string ModifiedBy { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime ModifiedAt { get; set; }
}

For example if we have a Transaction entity and we want to add audit functionality we would inherit from our AuditableEntity like that:

public class Transaction : AuditableEntity
{
    public long TransactionId { get; set; }
    public string FromIban { get; set; }
    public string ToIban { get; set; }
    public decimal Amount { get; set; }
}

Now our Transaction class will have all the audit properties but we don't want to manually set these properties each time, we need to somehow move this responsibility to a single place.
The best place for this is the SaveChanges and SaveChangesAsync, so we'll have to override them in our DbContext class.

Here is how you would do it for the SaveChangesAsync:

public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default(CancellationToken))
{
    // Get all the entities that inherit from AuditableEntity
    // and have a state of Added or Modified
    var entries = ChangeTracker
        .Entries()
        .Where(e => e.Entity is AuditableEntity && (
                e.State == EntityState.Added
                || e.State == EntityState.Modified));

    // For each entity we will set the Audit properties
    foreach (var entityEntry in entries)
    {
        // If the entity state is Added let's set
        // the CreatedAt and CreatedBy properties
        if (entityEntry.State == EntityState.Added)
        {
            ((AuditableEntity)entityEntry.Entity).CreatedAt = DateTime.UtcNow;
            ((AuditableEntity)entityEntry.Entity).CreatedBy = this.httpContextAccessor?.HttpContext?.User?.Identity?.Name ?? "MyApp";
        }
        else
        {
            // If the state is Modified then we don't want
            // to modify the CreatedAt and CreatedBy properties
            // so we set their state as IsModified to false
            Entry((AuditableEntity)entityEntry.Entity).Property(p => p.CreatedAt).IsModified = false;
            Entry((AuditableEntity)entityEntry.Entity).Property(p => p.CreatedBy).IsModified = false;
        }

        // In any case we always want to set the properties
        // ModifiedAt and ModifiedBy
        ((AuditableEntity)entityEntry.Entity).ModifiedAt = DateTime.UtcNow;
        ((AuditableEntity)entityEntry.Entity).ModifiedBy = this.httpContextAccessor?.HttpContext?.User?.Identity?.Name ?? "MyApp";
    }

    // After we set all the needed properties
    // we call the base implementation of SaveChangesAsync
    // to actually save our entities in the database
    return await base.SaveChangesAsync(cancellationToken);
}

In this example I am using the HttpContextAccessor to get the current user in my .NET Core Web API.
To have HttpContextAccessor available you just inject it into your DbContext class.
In order for HttpContextAccessor to be available for injection you need to add it in your Startup.cs file inside ConfigureServices method like that:

services.AddHttpContextAccessor();

And that's it! That's how simple it is to implement basic auditing for your entities using Entity Framework Core.

MS SQL Server Audit Features

Please keep in mind that for a full featured auditing you can use SQL Server's Track Data Changes, it is available in two flavors:

Change Data Capture

Change data capture provides historical change information for a user table by capturing both the fact that DML changes were made and the actual data that was changed. Changes are captured by using an asynchronous process that reads the transaction log and has a low impact on the system.

Change Tracking

Change tracking captures the fact that rows in a table were changed, but does not capture the data that was changed. This enables applications to determine the rows that have changed with the latest row data being obtained directly from the user tables. Therefore, change tracking is more limited in the historical questions it can answer compared to change data capture. However, for those applications that do not require the historical information, there is far less storage overhead because of the changed data not being captured. A synchronous tracking mechanism is used to track the changes. This has been designed to have minimal overhead to the DML operations.

You can read more about it on the official docs here

You can find the full code on my GitHub

This post was written with love ❤️

.NET Core: Use HttpClientFactory and Polly to build rock solid services

Ricky Stam — Mon, 25 May 2020 07:09:11 +0000

In this post I will explain what is HttpClientFactory and Polly retry policies and why you should use them in your next project.

Let's start with `IHttpClientFactory`

A lot of clients call me to help them resolve issues regarding sudden and random request failures. They put a new service in production, it works fine for the first few days, but out the the blue they start seeing a lot of SocketException in their Application Insights.

Most of the time these failures are the result of wrong usage of HttpClient that is causing socket exhaustion.

HttpClient is intended to be instantiated once and reused throughout the life of an application. Instantiating an HttpClient class for every request will exhaust the number of sockets available under heavy loads.

So please avoid using code like this:



using (var httpClient = new HttpClient())
{
    var result = await httpClient.GetAsync("https://www.bing.com");
}

You can read more details about this issue here:
https://aspnetmonsters.com/2016/08/2016-08-27-httpclientwrong/

So, in order to mitigate this problem the .NET Core team introduced in .NET Core 2.1 the IHttpClientFactory that provides the following benefits:

Provides a central location for naming and configuring logical HttpClient objects. For example, you may configure a client (Service Agent) that's pre-configured to access a specific microservice.
Codify the concept of outgoing middleware via delegating handlers in HttpClient and implementing Polly-based middleware to take advantage of Polly's policies for resiliency.
HttpClient already has the concept of delegating handlers that could be linked together for outgoing HTTP requests. You can register HTTP clients into the factory and you can use a Polly handler to use Polly policies for Retry, CircuitBreakers, and so on.
Manage the lifetime of HttpMessageHandler to avoid the mentioned problems/issues that can occur when managing HttpClient lifetimes yourself.

So let's see a very simple example that leverages IHttpClientFactory.
In my example, I will use a very cool and free API the SuperHero (you can find many more free APIs to play around at https://apilist.fun/).

In a new Web API project, go to Startup.cs change ConfigureServices method like this:



public void ConfigureServices(IServiceCollection services)
{
    // the AddHttpClient() will provide us with an instance of HttpClient
    // available for Dependancy Injection in our services
    services.AddHttpClient<ISuperHeroService, SuperHeroService>(o =>                                    
                          o.BaseAddress = new Uri(Configuration["SuperHeroApiConfig:BaseUrl"]));

    services.AddControllers();
}

Let's create now our SuperHeroService:



public class SuperHeroService : ISuperHeroService
{

    private readonly HttpClient _httpClient;
    private readonly ISuperHeroApiConfig _superHeroApiConfig;

    public SuperHeroService(HttpClient httpClient, ISuperHeroApiConfig superHeroApiConfig)
    {
         _httpClient = httpClient;
         _superHeroApiConfig = superHeroApiConfig;
    }

     public async Task<PowerStats> GetPowerStats(int id)
     {
         return await _httpClient.GetFromJsonAsync<PowerStats>(
                $"{_superHeroApiConfig.AccessToken}/{id}/powerstats");
     }        
}

Last but not least let's create our SuperHeroController:



[ApiController]
[Route("api/[controller]")]
public class SuperHeroController : ControllerBase
{
    private readonly ILogger<SuperHeroController> _logger;
    private readonly ISuperHeroService _superHeroService;

    public SuperHeroController(ILogger<SuperHeroController> logger, ISuperHeroService superHeroService)
    {
        _logger = logger;
        _superHeroService = superHeroService;
    }

     [HttpGet("GetPowerStats/{id}")]
     public async Task<ActionResult> GetPowerStats(int id)
     {
         var result = await _superHeroService.GetPowerStats(id);

         return Ok(result);
     }       
}

You can use Postman or any other app to test your Super Hero service:

Now that we saw how easy it is to overcome the old HttpClient issues with IHttpClientFactory, let's make our Super Hero service more resilient to failures using Polly.

Polly

Polly is a .NET resilience and transient-fault-handling library that allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner.

I think most of us, at some point in time, we saw code like this, trying to implement some kind of retry logic.



public async Task<PowerStats> GetPowerStats(int id)
{
      var currentRetry = 0;

       while (true)
       {
            try
            {
                return await _httpClient.GetFromJsonAsync<PowerStats>(
                                $"{_superHeroApiConfig.AccessToken}/{id}/powerstats");

             }
             catch (Exception ex)
             {
                currentRetry++;

                 if (currentRetry > 3)
                 {
                     throw;
                 }
            }
        }
}

However, we can all agree that this approach is not clean and easily maintainable, especially in a big project with many different services and endpoints.

`Polly` comes to the rescue!

Step 1: Add the Polly nuget pachage Microsoft.Extensions.Http.Polly.

Step 2: Create your custom policy inside ConfigureServices method of Startup.cs.



// Create the retry policy we want
var retryPolicy = HttpPolicyExtensions
                .HandleTransientHttpError() // HttpRequestException, 5XX and 408
                .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(retryAttempt));

Step 3: Apply it to our SuperHeroService, it's super easy!



services.AddHttpClient<ISuperHeroService, SuperHeroService>(o => 
                            o.BaseAddress = new Uri(Configuration["SuperHeroApiConfig:BaseUrl"]))
                .AddPolicyHandler(retryPolicy);

So what will happen now when our SuperHeroService gets a TransientHttpError (HttpRequestException, 5XX, 408) ?

Our HttpClient will retry the request.
The 1st time it will wait 1 second and retry.
The 2nd time it will wait 2 seconds and retry.
The 3rd and last time it will wait 3 seconds and retry.
If it fails again it will not retry and just return.

This is a very simple example just to demonstrate basic Polly usage, but you can do many more things.
You can tailor your retry policies as you see fit, apply Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback with just a few lines of code.

Now you have the knowledge to build a rock solid service, use it!

You can find the full code on my GitHub

This post was written with love ❤️

Angular: How to build a full screen calendar like Outlook

Ricky Stam — Thu, 07 May 2020 16:49:11 +0000

In an Angular project a while back I needed to display a full screen calendar like the one in outlook. So as a good lazy developer I start looking on the web for a NPM package that could do the job.
To my surprise I didn't find anything that could cover my needs 100% so I went on and built one!

This is the end result:

P.S.: Please be kind with me, HTML and CSS are not my strong suit.

Here is the coding story of how I did:

1st let's have our Angular component

This is our starting point an Angular component and an Array that will hold the days that our calendar will display

@Component({
  selector: 'my-app',
  templateUrl: './app.component.html',
  styleUrls: [ './app.component.css' ]
})
export class AppComponent implements OnInit {
  public calendar: CalendarDay[] = []; 

}

2nd let's see how the CalendarDay class looks like

export class CalendarDay {
  public date: Date;
  public title: string;
  public isPastDate: boolean;
  public isToday: boolean;

  constructor(d: Date) {
    this.date = d;
    this.isPastDate = d.setHours(0, 0, 0, 0) < new Date().setHours(0, 0, 0, 0);
    this.isToday = d.setHours(0, 0, 0, 0) == new Date().setHours(0, 0, 0, 0);
  }

}

Let explain the constructor a little bit.

  this.isPastDate = d.setHours(0, 0, 0, 0) < new Date().setHours(0, 0, 0, 0);
  this.isToday = d.setHours(0, 0, 0, 0) == new Date().setHours(0, 0, 0, 0);

I set property isPastDate so my calendar knows how to display or disable past dates and isToday property so UI knows how to draw the today's date.

The reason I use .setHours(0,0,0,0) is cause I want to be sure I'm comparing the beginning of the day and hours don't matter.

3rd let's populate our calendar with the needed days

I have comments in my code that explain the logic.

  ngOnInit(): void {
    // here we initialize the calendar
    this.generateCalendarDays();
  }

  private generateCalendarDays(): void {
    // we reset our calendar every time
    this.calendar = [];

    // we set the date 
    let day: Date = new Date();

    // here we find the first day that our calendar will start from
    // it would be the last Monday of the previous month
    let startingDateOfCalendar = this.getStartDateForCalendar(day);

    // dateToAdd is an intermediate variable that will get increased
    // in the following for loop
    let dateToAdd = startingDateOfCalendar;

    // ok since we have our starting date then we get the next 41 days 
    // that we need to add in our calendar array
    // 41 cause our calendar will show 6 weeks and MATH say that
    // 6 weeks * 7 days = 42!!
    for (var i = 0; i < 42; i++) {
      this.calendar.push(new CalendarDay(new Date(dateToAdd)));
      dateToAdd = new Date(dateToAdd.setDate(dateToAdd.getDate() + 1));
    }
  }

  private getStartDateForCalendar(selectedDate: Date){
    // for the day we selected let's get the previous month last day
    let lastDayOfPreviousMonth = new Date(selectedDate.setDate(0));

    // start by setting the starting date of the calendar same as the last day of previous month
    let startingDateOfCalendar: Date = lastDayOfPreviousMonth;

    // but since we actually want to find the last Monday of previous month
    // we will start going back in days intil we encounter our last Monday of previous month
    if (startingDateOfCalendar.getDay() != 1) {
      do {
        startingDateOfCalendar = new Date(startingDateOfCalendar.setDate(startingDateOfCalendar.getDate() - 1));
      } while (startingDateOfCalendar.getDay() != 1);
    }

    return startingDateOfCalendar;
  }

4th let's add some HTML and CSS to actually start displaying our calendar

In the HTML you will see that I'm using a pipe named chunk I'll explain the use of it and the code in a bit

<table class='calendar-table' *ngIf="calendar">
  <thead>
    <tr>
      <th>Monday</th>
      <th>Tuesday</th>
      <th>Wednesday</th>
      <th>Thursday</th>
      <th>Friday</th>
      <th>Saturday</th>
      <th>Sunday</th>
    </tr>
  </thead>
  <tbody>
    <tr *ngFor="let row of calendar | chunk: 7; let i = index">
      <td class="calendar-day" [ngClass]="{'past-date': c.isPastDate, 'today': c.isToday}" *ngFor="let c of row; let j = index">
        <div class="calendar-day-header" [ngClass]="{'blue-date': c.isToday}"><strong>{{c.date.getDate()}}</strong> <strong *ngIf="c.isToday || (i==0 && j==0) || (c.date.getDate() == 1)"> {{monthNames[c.date.getMonth()]}}</strong></div>
      </td>
    </tr>
  </tbody>
</table>

.calendar-table {
  border-collapse: collapse;
  width: 100%;
  max-width: 100%;
  margin-bottom: 1rem;
  border: 1px solid #dee2e6;
  background-color: #fff;
}

.calendar-table thead th {
  vertical-align: bottom;
  border-bottom: 2px solid #dee2e6;
  width: 14.2%;
}

.calendar-table td, .calendar-table th {
  border: 1px solid #dee2e6;
}

.calendar-table td, .calendar-table th {
  padding: .75rem;
  vertical-align: top;
  border-top: 1px solid #dee2e6;
}

.calendar-day {
  height: 12vh;
  max-height: 12vh;
  cursor: pointer;
}

.calendar-items-wrapper {
  margin-left: -10px;
  margin-right: -10px;
  overflow-y: auto;
  max-height: calc(100% - 20px);
}

.calendar-day.past-date {
  background-color: rgb(248, 248, 248);
}

.calendar-day:hover {
  background-color: rgb(248, 248, 248);
}

.blue-date {
  color: rgb(16, 110, 190);
}

5th now it's time to explain and show the code for the chunk pipe

Since our calendar array has 42 elements but we want to show 7 elements in each row the chunk pipe will create an array with 6 arrays inside one array for each week.

@Pipe({
  name: 'chunk'
})
export class ChunkPipe implements PipeTransform {

  transform(calendarDaysArray: any, chunkSize: number): any {
    let calendarDays = [];
    let weekDays = [];

    calendarDaysArray.map((day,index) => {
        weekDays.push(day);
        // here we need to use ++ in front of the variable else index increase 
        //will happen after the evaluation but we need it to happen BEFORE
        if (++index % chunkSize  === 0) {
          calendarDays.push(weekDays);
          weekDays = [];
        }
    });
    return calendarDays;
  }
}

This post was written with love ❤️

.NET How to throttle HttpClient Requests using SemaphoreSlim

Ricky Stam — Wed, 08 Apr 2020 22:07:35 +0000

Last week I had to deal with an external API that didn't allow for more that 50 requests per second.

On my journey on how to deal with this limitation I stumbled upon SemaphoreSlim Class.

SemaphoreSlim limits the number of threads that can access a resource concurrently. It seemed a good fit and guess what... It was! 😛

I won't bother you with more details, let's see a simplified example on how we can limit our concurrent requests to just 3 per second with code:

class Program
    {
        private static HttpClient httpClient = new HttpClient();

        static async Task Main(string[] args)
        {
            var tasks = new List<Task>();

            // here we set the max allowed concurrent requests, in our case it is 3
            var throttler = new SemaphoreSlim(3);

            // Let's say that we have 12 requests in total that we want to send
            for (var i = 0; i < 12; i++)
            {
                // let's wait here until we can pass from the Semaphore
                await throttler.WaitAsync();

                // add our task logig here
                tasks.Add(Task.Run(async () =>
                {
                    try
                    {
                        var result = await ExecuteRequest();

                        // let's wait here for 1 second to honor the API's rate limit                         
                        await Task.Delay(1000);
                    }
                    finally
                    {
                        // here we release the throttler immediately
                        throttler.Release();
                    }
                }));
            }

            // await for all the tasks to complete
            await Task.WhenAll(tasks.ToArray());
        }

        private static async Task<HttpResponseMessage> ExecuteRequest()
        {
            var result = await httpClient.GetAsync("https://www.bing.com");
            return result;
        }
    }

Please let me know in the comments below what is the equivalent of SemaphoreSlim class in other languages.

You can find the full code on my GitHub

Just run the project and use Fiddler or any other network tool to verify the throttled behaviour.

ALWAYS TRUST BUT VERIFY 😁

This post was written with love ❤️

C# Pause a Thread - Wait For An Event To Happen - Continue Thread

Ricky Stam — Thu, 10 Jan 2019 18:41:15 +0000

Last week I came across a new problem that took me a while before I was able to solve it and I want to share my experience with you.

The problem

I had a console application and one Thread was adding Jobs to a List of Jobs and another thread was iterating this list to Execute these Jobs.

ConcurrentQueue<Job> _queue = new ConcurrentQueue<Job>();
BlockingCollection<Job> _jobs = new BlockingCollection<Job>(_queue);

 var job1 = new Job(1);
 var job2 = new Job(2);
 var job3 = new Job(3);


_jobs.Add(job1);
_jobs.Add(job2);
_jobs.Add(job3);

Here is a simplified version of the Job class:

public class Job
    {
        public delegate void JobFinishedHandler(object myObject, JobFinishedArgs myArgs);
        public event JobFinishedHandler OnJobFinished;
        public int JobId { get; set; } 
        public Job(int jobId)
        {
            this.JobId = jobId;
        }

        public void Execute()
        {
            Console.WriteLine($"Executing Job {this.JobId}");
            Thread.Sleep(new Random().Next(1000, 3000));
            OnJobFinished(this, new JobFinishedArgs("Job Finished!"));
        }
    }

public class JobFinishedArgs : EventArgs
    {
        private readonly string _message;
        public string Message { get { return _message; } }

        public JobFinishedArgs(string message)
        {
            this._message = message;
        }
    }

The initial code that iterated the List of Jobs was the following:

var thread = new Thread(() =>
            {
                while (!_jobs.IsCompleted)
                {
                    var innerThread = new Thread(() =>
                    {
                        Job job = null;

                        try
                        {
                            job = _jobs.Take();
                        }
                        catch (InvalidOperationException) { }

                        job?.Execute();
                    })
                    {
                        // This is important as it allows the process to exit
                        // while this thread is running
                        IsBackground = true
                    };
                    innerThread.Start();
                }
            })
            {
                // This is important as it allows the process to exit
                // while this thread is running
                IsBackground = true
            };
            thread.Start();

The problem with this approach was that the jobs are executing in parallel and it means that some times job3 will finish before the previously started jobs, something I didn't want.
I needed all jobs to execute sequentially one after the other.

While I was trying to find an elegant solution to my problem I came accross ManualResetEvent and as Microsoft docs says:

Notifies one or more waiting threads that an event has occurred. This class cannot be inherited.

It was exactly what i needed.
Now i was armed with new knowledge and this is:

I will use ManualResetEventSlim

Provides a slimmed down version of ManualResetEvent.

Use the constructor ManualResetEventSlim(Boolean)

Initializes a new instance of the ManualResetEventSlim class with a Boolean value indicating whether to set the intial state to signaled.

In my case I will initialize it to true cause I want to immediately execute the first job

Use Wait() Method of ManualResetEventSlim inside my Task.Run iteration

Blocks the current thread until the current ManualResetEventSlim is set.

And immediately call Reset() of ManualResetEventSlim Method

Sets the state of the event to nonsignaled, which causes threads to block.

to stop the current Thread from executing any other Job until this one is finished first.

So I refactor the code as following:

// Set Manual Reset Event to true cause I want to immediately 
// start executing the jobs, I don't want the tread to wait
ManualResetEventSlim _canExecute = new ManualResetEventSlim(true);
ConcurrentQueue<Job> _queue = new ConcurrentQueue<Job>();
BlockingCollection<Job> _jobs = new BlockingCollection<Job>(_queue);

var thread = new Thread(() =>
            {
                while (!_jobs.IsCompleted)
                {
                    var innerThread = new Thread(() =>
                    {
                        Job job = null;
                        // Now i wait for the ManualResetEvent to be set to True
                        _canExecute.Wait();
                        //and immediatly Reset it so that the Thread will pause
                        // on the above line and again wait for the ManualResetEvent
                        // to be set to true
                        _canExecute.Reset();
                        try
                        {
                            job = _jobs.Take();
                        }
                        catch (InvalidOperationException) { }

                        job?.Execute();
                    })
                    {
                        // This is important as it allows the process to exit
                        // while this thread is running
                        IsBackground = true
                    };
                    innerThread.Start();
                }
            })
            {
                // This is important as it allows the process to exit
                // while this thread is running
                IsBackground = true
            };
            thread.Start();

So far with the above changes only the first Job will be executed.
In order to continue with the rest of the Jobs we need to use the Set() Method of ManualResetEventSlim

Sets the state of the event to signaled, which allows one or more threads waiting on the event to proceed.

and we do that by subscribing to the OnJobFinished event and set the ManualResetEventSlim to true.

var job1 = new Job(1);
var job2 = new Job(2);
var job3 = new Job(3);

job1.OnJobFinished += (e, s) => _canExecute.Set();
job2.OnJobFinished += (e, s) => _canExecute.Set();
job3.OnJobFinished += (e, s) => _canExecute.Set();

_jobs.Add(job1);
_jobs.Add(job2);
_jobs.Add(job3);

Now our List of Jobs is executing sequentially one after the other!

You can find the full code on my GitHub

This post was written with love ❤️

C# Create new T()

Ricky Stam — Tue, 06 Feb 2018 20:46:47 +0000

For a long time now whenever i had to create a new instance of a generic type parameter i was using Activator.CreateInstace(Type) method
https://msdn.microsoft.com/en-us/library/wccyzw83.aspx

Example:

public class Dog : ISound
{
    public string Sound { get; set; } = "woof woof";
}

public class Animal<T> where T : ISound
{
    public ISound GetInstance()
    {
        return (ISound)Activator.CreateInstance(typeof(T));
    }
}

Recently i stumbled upon the new constraint keyword from the MS docs (somehow i missed that 😞)
https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/new-constraint
and the Generic class of Animal above can be rewritten as following:

public class Animal<T> where T : ISound, new()
{
    public T GetInstance()
    {
        return new T();
    }
}

and can be used:

var animal = new Animal<Dog>();
var dog = animal.GetInstance();
var sound = dog.Sound; //woof woof

Important: When you use the new() constraint with other constraints, it must be specified last.

This post was written with love ❤️

DEV Community: Ricky Stam

C# - The For Loop Paradox

For Loop Paradox

Why is this happening?

Ok, but how to work around this behavior?

History Lesson Incoming!

More resources

EF Core: How to implement basic Auditing on your Entities

EF Core Audit properties

Let's start implementing this functionality

MS SQL Server Audit Features

Change Data Capture

Change Tracking

.NET Core: Use HttpClientFactory and Polly to build rock solid services

Let's start with IHttpClientFactory

Polly

Polly comes to the rescue!

Angular: How to build a full screen calendar like Outlook

1st let's have our Angular component

2nd let's see how the CalendarDay class looks like

3rd let's populate our calendar with the needed days

4th let's add some HTML and CSS to actually start displaying our calendar

5th now it's time to explain and show the code for the chunk pipe

.NET How to throttle HttpClient Requests using SemaphoreSlim

C# Pause a Thread - Wait For An Event To Happen - Continue Thread

The problem

C# Create new T()

Let's start with `IHttpClientFactory`

`Polly` comes to the rescue!