DEV Community: Mauro Petrini 👨‍💻

[PoC] I've built a logging provider using .NET Core

Mauro Petrini 👨‍💻 — Mon, 17 Aug 2020 19:18:33 +0000

.NET Core 3.0 releases new compelling features.

Two of these new features are Channels and the new API System.Text.Json, which are heavily motivated by performance.

These features allow us to achieve better performance when we are building our applications.

To try out these features, I've created a logging provider component using .NET Core 3.0. The project is a PoC.

Architecture Diagram

The architecture diagram of the component looks like

The idea is simple; the app writes logs into a shared channel synchronously. Then, two hosted services are listening in the background and pulling messages from the channel to execute the bulk insert into a SQL Server database.

Limitations

It writes log records into a SQL Server Database using batch sizes or when the timer reaches the end. You can use this project to getting started to write log records wherever you want.

To dig into the code

mpetrinidev / yadl

Yet another dotnet logger

Yadl stands for Yet another dotnet logger 😅. This project is a PoC.

The implementation is built on top of the dotnet logger using Channels and System.Text.Json. These features are new in .NET Core 3.0

Architecture

Here's the architecture diagram of the component.

Set up the database

Execute ./build.sh or ./build.ps1 depending on your operating system to create the SQL server and begin to use the sample. These files execute the docker container to download the SQL server image and run the necessary script to create the logs table's database.

Limitations

It writes log records into a SQL Server Database using batch sizes or when the timer reaches the end. You can use this project to getting started to write log records wherever you want.

👍 Feel free to file an issue to ask a question, propose a new feature or if anything is not working as expected

View on GitHub

Closing Thoughts

Channels and System.Text.Json are new compelling features to come into the latest version of .NET Core.

On the other, creating a PoC helps me to try out new features in a programming language and make better decisions in the software that I am building.

We are looking forward to .NET 5 🤩

📦 Reduce the size of your app in .NET Core 3 and above

Mauro Petrini 👨‍💻 — Mon, 27 Apr 2020 13:56:39 +0000

Welcome! Spanish articles on LinkedIn. You can follow me on Twitter for news.

If you want to reduce the size of your app developed in .NET Core 3, you are in the right article!

New options to publish our app 👨‍💻👩‍💻

.NET Core 3 SDK comes with a tool that can reduce the size of apps by analyzing IL and trimming unused assemblies 📦.

The MSBuild property to apply this feature is called PublishTrimmed.

When we enabled the option, we have to publish our app as a self-contained that includes the .NET Core runtime, libraries, the application, and its dependencies.

It is often useful because the application can run on a machine that doesn't have the .NET Core runtime installed.

Let's dive into a small sample 🥳

I've created a simple console application with the new .NET 5.0 preview 3 🤯 using dotnet CLI

    dotnet new console -n test_net5

The .csproj file should be looks like

    <Project Sdk="Microsoft.NET.Sdk">

      <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>net5.0</TargetFramework>
      </PropertyGroup>

    </Project>

Add PublishSingleFile property

First, we're going to add the option to publish our console application as a single file (.exe).

    <Project Sdk="Microsoft.NET.Sdk">

      <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>net5.0</TargetFramework>
        <Configuration>Release</Configuration>

        <RuntimeIdentifier>win10-x64</RuntimeIdentifier>
        <PublishSingleFile>true</PublishSingleFile>
      </PropertyGroup>

    </Project>

PublishSingleFile is a new option to generate a single executable for our application. We have to include a rid (aka runtime identifier) to specify the target platform, in this case, for Windows 10 / Windows Server 2016 operating system.

Publish our application

Run the following command in the console to publish our application.

    dotnet publish

The result is an executable called test_net5.exe with a size of 68,204,270 bytes (84 MB on disk) 😲

Let's reduce the size of our application.

We are going to add PublishTrimmed property to our .csproj file and set the value to true.

The final .csproj file should look like

    <Project Sdk="Microsoft.NET.Sdk">

      <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>net5.0</TargetFramework>
        <Configuration>Release</Configuration>

        <RuntimeIdentifier>win10-x64</RuntimeIdentifier>
        <PublishSingleFile>true</PublishSingleFile>

        <PublishTrimmed>true</PublishTrimmed>
      </PropertyGroup>

    </Project>

Then, run the following command again in the console to publish our application.

    dotnet publish

We got the same result, but the executable now has a size of 26,073,963 bytes (26.3 MB on disk) 🤯

Conclusion

As I said before, this new option allows us to reduce the size of the app by analyzing IL and trimming unused assemblies. We have to be careful because if our application use reflection or implement some dynamic behavior, it is probably going to break when trimmed because the linker doesn't know about this dynamic behavior and can't determine which framework types are required for reflection. The IL Linker tool can be configured to be aware of this scenario, but we have to test our app after trimming.

You can read more about IL Linker tool here to see what happen under the hood.

I hope you've enjoyed the article!

Stay safe, and keep learning!

A guide to bulk write operations in MongoDB with C#

Mauro Petrini 👨‍💻 — Wed, 22 Jan 2020 14:58:25 +0000

Welcome! Spanish articles on LinkedIn. You can follow me on Twitter for news.

MongoDB and C# intro
Insert operations
Update operations
Delete operations
Put it all together

MongoDB and C# introduction

🚀 MongoDB provides the ability to perform bulk insert, update, and delete operations.

In the MongoDB C# Driver,, we can use the BulkWriteAsync() method that supports the following write operations:

InsertOne
UpdateOne
UpdateMany
DeleteOne
DeleteMany

We are going to show how to use these methods with the MongoDB's C# driver.

I'll work through this sample in MongoDB Atlas, the global cloud database service offered by MongoDB.

You can create your cluster in minutes, completely free here

Let's begin

I create a user collection with the following fields.

_id
name
email
createdAt
isBlocked

YES! There is no password! It's not the scope of this post.

    public class User
    {
        [BsonId] public ObjectId _id { get; set; }
        public BsonString name { get; set; }
        public BsonString email { get; set; }
        public BsonDateTime createdAt { get; set; }
        public BsonBoolean isBlocked { get; set; }
    }

Insert operations

BulkWriteAsync method

This method is responsible for executing the bulk operations. BulkWriteAsync takes a variable number (list) of WriteModel instances.

We set our User model as a generic type parameter to the WriteModel class.

    var listWrites = new List<WriteModel<User>>();

Creating a fake user dataset

Then, we are going to create a fake dataset of 1000 new users and add this to the list of WriteModel type.

    var totalNewUsers = 1000;

    for (int i = 0; i < totalNewUsers; i++)
    {
        var newUser = new User
        {
            name = $"customName-{i}",
            email = $"customEmail-{i}@domain{i}.com",
            createdAt = DateTime.Now,
            isBlocked = false
        };

        listWrites.Add(new InsertOneModel<User>(newUser));
    }

Pay attention to the InsertOneModel object. We are telling MongoDB that it's an insert operation.

Execute batch insert operation

Finally, we get the user collection and execute the bulk insert.

    var userCollection = db.GetCollection<User>("users");
    var resultWrites = await userCollection.BulkWriteAsync(listWrites);

    Console.WriteLine($"OK?: {resultWrites.IsAcknowledged} - Inserted Count: {resultWrites.InsertedCount}");

By default, MongoDB executes the bulk insert with an ordered approach. That's means perform the operations serially. If an error occurs of one of the insert operation, MongoDB ends the bulk insert. If you want MongoDB to continue with the bulk insert, you need to specify the unordered approach passing a BulkWriteOptions object:

    var resultWrites = await userCollection.BulkWriteAsync(listWrites, new BulkWriteOptions
    {
        IsOrdered = false
    });

Complete Code

    public static async Task BulkInsertMongoDb()
    {
        IMongoDatabase db = _client.GetDatabase("sample_blog");

        var listWrites = new List<WriteModel<User>>();
        var totalNewUsers = 1000;

        for (int i = 0; i < totalNewUsers; i++)
        {
            var newUser = new User
            {
                name = $"customName-{i}",
                email = $"customEmail-{i}@domain{i}.com",
                createdAt = DateTime.Now,
                isBlocked = false
            };

            listWrites.Add(new InsertOneModel<User>(newUser));
        }

        var userCollection = db.GetCollection<User>("users");
        var resultWrites = await userCollection.BulkWriteAsync(listWrites);

        Console.WriteLine($"OK?: {resultWrites.IsAcknowledged} - Inserted Count: {resultWrites.InsertedCount}");
    }

Update operations

After insert 1,000 new users, we are going to update some of them!

UpdateOne

This class (UpdateOneModel) provides us a way to update only one document that matches a specific condition.

We need to set up a filter definition (condition) and the update definition (what fields are going to update)

    var filterDefinition = Builders<User>.Filter.Eq(p => p.email, "customEmail-0@domain0.com");
    var updateDefinition = Builders<User>.Update.Set(p => p.isBlocked, true);

Then, add these definitions to our UpdateOneModel instance.

    listWrites.Add(new UpdateOneModel<User>(filterDefinition, updateDefinition));

Complete code for UpdateOne

    public static async Task BulkUpdateOneMongoDb()
    {
        IMongoDatabase db = _client.GetDatabase("sample_blog");
        var userCollection = db.GetCollection<User>("users");

        var listWrites = new List<WriteModel<User>>();

        var filterDefinition = Builders<User>.Filter.Eq(p => p.email, "customEmail-0@domain0.com");
        var updateDefinition = Builders<User>.Update.Set(p => p.isBlocked, true);

        listWrites.Add(new UpdateOneModel<User>(filterDefinition, updateDefinition));

        await userCollection.BulkWriteAsync(listWrites);
    }

UpdateMany

This class (UpdateManyModel) allows us to update multiple documents that match a specific condition.

As we did with UpdateOne, we need to set up a filter definition and the updated definition.

    var filterDefinition = Builders<User>.Filter.Eq(p => p.isBlocked, false);
    var updateDefinition = Builders<User>.Update.Set(p => p.isBlocked, true);

In this case, we are going to block all users that there aren't blocked yet.

Complete code for UpdateMany

    public static async Task BulkUpdateManyMongoDb()
    {
        IMongoDatabase db = _client.GetDatabase("sample_blog");
        var userCollection = db.GetCollection<User>("users");

        var listWrites = new List<WriteModel<User>>();

        var filterDefinition = Builders<User>.Filter.Eq(p => p.isBlocked, false);
        var updateDefinition = Builders<User>.Update.Set(p => p.isBlocked, true);

        listWrites.Add(new UpdateManyModel<User>(filterDefinition, updateDefinition));

        await userCollection.BulkWriteAsync(listWrites);
    }

UpdateOne and UpdateMany

As we saw, the implementations of these methods are the same. The main difference is that if the condition matches multiple documents, UpdateOne will update the first matching document only while UpdateMany updates all documents.

Delete operations

It's very similar to update operations, but in this case, we are going to delete some documents in our user collection.

DeleteOne

This class (DeleteOneModel) provides us a way to delete only one document that matches a specific condition

We need to set up a filter definition (condition)

    var filterDefinition = Builders<User>.Filter.Eq(p => p.email, "customEmail-0@domain0.com");

In this case, we are going to delete the first document that matches an email equals customEmail-0@domain0.com.

Complete code for DeleteOne

    public static async Task BulkDeleteOneMongoDb()
    {
        IMongoDatabase db = _client.GetDatabase("sample_blog");
        var userCollection = db.GetCollection<User>("users");

        var listWrites = new List<WriteModel<User>>();

        var filterDefinition = Builders<User>.Filter.Eq(p => p.email, "customEmail-0@domain0.com");
        listWrites.Add(new DeleteOneModel<User>(filterDefinition));

        await userCollection.BulkWriteAsync(listWrites);
    }

DeleteMany

This class (DeleteManyModel) allows us to delete multiple documents that match a specific condition.

As we did with DeleteOne, we need to set up a filter definition.

    var filterDefinition = Builders<User>.Filter.Eq(p => p.isBlocked, true);

In this case, we are going to delete all users that there are blocked.

Complete code for DeleteMany

    public static async Task BulkDeleteManyMongoDb()
    {
        IMongoDatabase db = _client.GetDatabase("sample_blog");
        var userCollection = db.GetCollection<User>("users");

        var listWrites = new List<WriteModel<User>>();

        var filterDefinition = Builders<User>.Filter.Eq(p => p.isBlocked, true);
        listWrites.Add(new DeleteManyModel<User>(filterDefinition));

        await userCollection.BulkWriteAsync(listWrites);
    }

DeleteOne and DeleteMany

As we said with UpdateOne and UpdateMany, the implementations of these methods are the same. The main difference is that if the condition matches multiple documents, DeleteOne will delete the first matching document only while DeleteMany deletes all documents.

Put it all together

MongoDB allows us to execute all of this together 🤩
The following sample does not make sense, but I want to show that it is possible!

We are going to group all previous operations in the same bulk write operations so that we will create 1,000 new users, then execute UpdateOne, UpdateMany, DeleteOne, and DeleteMany operations in the same bulk in order.

    public static async Task BulkAllTogetherMongoDb()
    {
        IMongoDatabase db = _client.GetDatabase("sample_blog");

        var listWrites = new List<WriteModel<User>>();
        var totalNewUsers = 1000;

        //InsertOne
        for (int i = 0; i < totalNewUsers; i++)
        {
            var newUser = new User
            {
                name = $"customName-{i}",
                email = $"customEmail-{i}@domain{i}.com",
                createdAt = DateTime.Now,
                isBlocked = false
            };

            listWrites.Add(new InsertOneModel<User>(newUser));
        }

        //UpdateOne
        var filterDefinition = Builders<User>.Filter.Eq(p => p.email, "customEmail-0@domain0.com");
        var updateDefinition = Builders<User>.Update.Set(p => p.isBlocked, true);

        listWrites.Add(new UpdateOneModel<User>(filterDefinition, updateDefinition));

        //UpdateMany
        var filterDefinitionUpdateMany = Builders<User>.Filter.Eq(p => p.isBlocked, false);
        var updateDefinitionUpdateMany = Builders<User>.Update.Set(p => p.isBlocked, true);

        listWrites.Add(new UpdateManyModel<User>(filterDefinitionUpdateMany, updateDefinitionUpdateMany));

        //DeleteOne
        var filterDefinitionDeleteOne = Builders<User>.Filter.Eq(p => p.email, "customEmail-0@domain0.com");
        listWrites.Add(new DeleteOneModel<User>(filterDefinitionDeleteOne));

        //DeleteMany
        var filterDefinitionDeleteMany = Builders<User>.Filter.Eq(p => p.isBlocked, true);
        listWrites.Add(new DeleteManyModel<User>(filterDefinitionDeleteMany));

        var userCollection = db.GetCollection<User>("users");
        var resultWrites = await userCollection.BulkWriteAsync(listWrites);

        Console.WriteLine($"OK?: {resultWrites.IsAcknowledged} - Inserted Count: {resultWrites.InsertedCount}");
        Console.WriteLine($"Updated Count: {resultWrites.ModifiedCount}");
        Console.WriteLine($"Deleted Count: {resultWrites.DeletedCount}");
    }

Console output:

OK?: True - Inserted Count: 1000
Updated Count: 1000
Deleted Count: 1000

I hope you enjoyed the post!

Combine xUnit with Fluent Assertions

Mauro Petrini 👨‍💻 — Mon, 25 Nov 2019 01:46:42 +0000

Welcome! Spanish articles on LinkedIn. You can follow me on Twitter for news.

xUnit

One of the most popular frameworks to test code in the .NET ecosystem is xUnit.

xUnit.net is a free, open-source, community-focused unit testing tool for .NET.

A common situation using xUnit

xUnit uses the Assert class to verify conditions during the process of running tests. This class provides various extensions methods that commonly use two parameters:

Expected value
Actual value

Let's see an example.

    var variable = 1;

    Assert.Equal(10, variable);
    Assert.Equal(variable, 10);

So, which one of these Assert.Equal methods are correct? When we mix up the expected and the actual value parameters, if the test fails, the failure message may not make much sense.

In the first case, we get the correct message.

Assert.Equal() Failure
Expected: 10
Actual: 1

The second one is incorrect cause are expecting 10, not 1

Assert.Equal() Failure
Expected: 1
Actual: 10

Fluent Assertions

Fluent Assertions is a library that provides us:

Clearer explanations about why a test failed
Improve readability of test source code

Basically, with this library, we can read a test more like an English sentence.

If we perform the same test using Fluent Assertions library, the code will look something like this:

    var variable = 1;

    variable.Should().Be(10);

Let's take a look at the failure message.

Expected variable to be 10 but found 1.

This message is clearer than the Assert failure message. A more descriptive failure message may prevent the need for debugging through the test.

Let's dive into some examples

Inline asserts

We could write our asserts inline using the And constraint of fluent assertions.

    [Fact]
    public void xUnit_StringTest()
    {
        string code = "001SUMMERCODE";

        Assert.NotNull(code);
        Assert.NotEmpty(code);
        Assert.StartsWith("001", code);
        Assert.EndsWith("code".ToUpper(), code);
    }

    [Fact]
    public void xUnit_FluentAssertions_StringTest()
    {
        string code = "001SUMMERCODE";

        //code.Should().NotBeNullOrEmpty();
        //code.Should().StartWith("001");
        //code.Should().EndWithEquivalent("code");

        code.Should().NotBeNullOrEmpty().And.StartWith("001").And.EndWithEquivalent("code");
    }

Custom messages

The because parameter allows us to set a custom message when a test fails.

    [Fact]
    public void xUnit_FluentAssertions_CustomMessageTest()
    {
        string code = "002SUMMERCODE";

        code.Should().NotBeNullOrEmpty().And.
            StartWith("001", because: "the first batch of codes start with 001").And.
            EndWithEquivalent("code");
    }

Output

Expected code to start with
"001" because the first batch of codes start with 001, but
"002SUMMERCODE" differs near "2SU" (index 2).

Assertion scope

If we have multiple asserts and one fails, the next ones do not execute. This is the default behavior, but we can change it through the AssertionScope.

    [Fact]
    public void xUnit_FluentAssertions_StringTest()
    {
        string code = "001SUMMERCODE";

        code.Should().NotBeNullOrEmpty();
        code.Should().StartWith("002"); //fails
        code.Should().EndWithEquivalent("code");
        code.Should().ContainEquivalentOf("SUMMERS");//fails
    }

Output

Expected code to start with
"002", but
"001SUMMERCODE" differs near "1SU" (index 2).

Using AssertionScope

    [Fact]
    public void xUnit_FluentAssertions_StringTest()
    {
        string code = "001SUMMERCODE";

        using (new AssertionScope())
        {
            code.Should().NotBeNullOrEmpty();
            code.Should().StartWith("002"); //fails
            code.Should().EndWithEquivalent("code");
            code.Should().ContainEquivalentOf("SUMMERS"); //fails
        }
    }

Output

Expected code to start with
"002", but
"001SUMMERCODE" differs near "1SU" (index 2).
Expected code to contain equivalent of
"SUMMERS" but found
"001SUMMERCODE".

The difference is that with AssertionScope, we run all asserts.

Exceptions

The Throw and ThrowExactly methods help us to test if a method throws an exception. I recommend using ThrowExactly because Throw pass tests when check inheritance.

Let's define a Person class.

    public class Person
    {
        public string Name { get; }

        public Person(string name)
        {
            Name = name ?? throw new ArgumentNullException(nameof(name));
        }
    }

Then, test the constructor to throw the ArgumentNullException using Throw.

    [Fact]
    public void xUnit_FluentAssertions_ExceptionTest()
    {
        Action act = () => new Person(null);

        act.Should().Throw<Exception>()
            .WithMessage("Value cannot be null. (Parameter 'name')");
    }

That's a successful test!

Switch to ThrowExactly

    [Fact]
    public void xUnit_FluentAssertions_ExceptionTest()
    {
        Action act = () => new Person(null);

        act.Should().ThrowExactly<Exception>()
            .WithMessage("Value cannot be null. (Parameter 'name')");
    }

Output

Expected type to be System.Exception, but found System.ArgumentNullException.

End!

That was an introduction to this amazing library! I use a lot in the projects that I'm working on because of readability and easy use.

Test IOptionsMonitor in ASP.NET Core

Mauro Petrini 👨‍💻 — Sat, 23 Nov 2019 01:01:47 +0000

Welcome! Spanish articles on LinkedIn. You can follow me on Twitter for news.

Imagine you are using the options pattern in .NET Core to set up some configuration in your application, and you need to test it. Through this example, you will learn how to test the options you have configured.

Let's begin

Option Class

An options class must be non-abstract with a public parameterless constructor. I create a class called GmailSmtpOptions to simulate the configuration that we need for a Gmail email service.

    public class GmailSmtpOptions
    {
        public string Server { get; set; }
        public bool UseAuthentication { get; set; }
        public bool UseSecureConnection { get; set; }
        public string Username { get; set; }
        public string Password { get; set; }
        public int Port { get; set; }    
    }

Service collection extension

I create a simple service collection extension to add GmailSmtpOptions to the container.

I'm configuring the options passing a delegate in the AddCustomOptions and use the Configure method of the container.

    public static class ServiceCollectionExtensions
    {
        public static IServiceCollection AddCustomOptions(this IServiceCollection serviceCollection, Action<GmailSmtpOptions> gmailSmtpOptions)
        {
            serviceCollection.Configure(gmailSmtpOptions);
            return serviceCollection;
        }
    }

xUnit class for test

Arrange

I set up the test with some information about the SMTP server. Also, I use the service collection to call the AddCustomOptions extension method that we previously created.

    var server = "smtp.gmail.com";
    var useAuth = true;
    var useSecCon = true;
    var username = "username";
    var password = "password";
    var port = 465;

    var serviceCollection = new ServiceCollection();
    serviceCollection.AddCustomOptions(gmail =>
    {
        gmail.Server = server;
        gmail.UseAuthentication = useAuth;
        gmail.UseSecureConnection = useSecCon;
        gmail.Username = username;
        gmail.Password = password;
        gmail.Port = port;
    });

Act

Then, I call the BuildServiceProvider method to create the provider containing services from the provided IServiceCollection and get the IOptionsMonitor<T> service.

    var builder = serviceCollection.BuildServiceProvider();
    var optionsMonitor = builder.GetService<IOptionsMonitor<GmailSmtpOptions>>();

Assert

We get the IOptionsMonitor, and now we need to compare the values configured previously. We use the CurrentValue property to get the current TOptions instance (GmailSmtpOptions).

    //Assert 1
    optionsMonitor.Should().NotBeNull();
    optionsMonitor.CurrentValue.Should().NotBeNull().And.BeOfType<GmailSmtpOptions>();

    var gmailOptions = optionsMonitor.CurrentValue;

    //Assert 2
    gmailOptions.Should().NotBeNull();

    //Assert 3
    gmailOptions.Server.Should().NotBeNullOrEmpty().And.Be(server);
    gmailOptions.UseAuthentication.Should().Be(useAuth);
    gmailOptions.UseSecureConnection.Should().Be(useSecCon);
    gmailOptions.Username.Should().NotBeNullOrEmpty().And.Be(username);
    gmailOptions.Password.Should().NotBeNullOrEmpty().And.Be(password);
    gmailOptions.Port.Should().Be(port);

That's all!

Complete code

    public class ServiceCollectionExtensionsTest
    {
        [Fact]
        public void AddCustomOptions_NoConfigureOptions_ConfigureOptionsOk()
        {
            //Arrange
            var server = "smtp.gmail.com";
            var useAuth = true;
            var useSecCon = true;
            var username = "username";
            var password = "password";
            var port = 465;

            var serviceCollection = new ServiceCollection();
            serviceCollection.AddCustomOptions(gmail =>
            {
                gmail.Server = server;
                gmail.UseAuthentication = useAuth;
                gmail.UseSecureConnection = useSecCon;
                gmail.Username = username;
                gmail.Password = password;
                gmail.Port = port;
            });

            //Act
            var builder = serviceCollection.BuildServiceProvider();
            var optionsMonitor = builder.GetService<IOptionsMonitor<GmailSmtpOptions>>();

            //Assert 1
            optionsMonitor.Should().NotBeNull();
            optionsMonitor.CurrentValue.Should().NotBeNull().And.BeOfType<GmailSmtpOptions>();

            var gmailOptions = optionsMonitor.CurrentValue;

            //Assert 2
            gmailOptions.Should().NotBeNull();

            //Assert 3
            gmailOptions.Server.Should().NotBeNullOrEmpty().And.Be(server);
            gmailOptions.UseAuthentication.Should().Be(useAuth);
            gmailOptions.UseSecureConnection.Should().Be(useSecCon);
            gmailOptions.Username.Should().NotBeNullOrEmpty().And.Be(username);
            gmailOptions.Password.Should().NotBeNullOrEmpty().And.Be(password);
            gmailOptions.Port.Should().Be(port);
        }
    }

I'm using the following packages in the test project.

    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
    <PackageReference Include="xunit" Version="2.4.0" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
    <PackageReference Include="coverlet.collector" Version="1.0.1" />

Injecting and Resolving dependencies in AspNet Core

Mauro Petrini 👨‍💻 — Wed, 06 Nov 2019 19:02:46 +0000

Welcome! Spanish articles on LinkedIn. You can follow me on Twitter for news.

Benefits of Dependency Injection
Components of Microsoft Dependency Injection
Example
Constructor injection
- Controllers
- Middleware
- Filters
- Tag Helpers
- View Components
- Razor Page Models
- Razor Views
Action Injection

We are not going to dig into the main concepts of Dependency Injection, but I want to remember the main benefits.

Benefits of Dependency Injection

Loose coupling of components
Logical abstraction of components
Supports unit testing
Cleaner, more readable code

If you want to learn about Dependency Injection, I'd recommend Steve Gordon's Pluralsight course. It's a perfect way to getting started.

Components of Microsoft Dependency Injection

IServiceCollection defines a contract for register and configure a collection of service descriptors.

IServiceProvider provides a mechanism to retrieve a required service at runtime.

In this post, we are going to take a look at which elements of AspNet Core could retrieve and resolve dependencies.

Example

We are going to use the following interface and concrete class as an example.

    public interface IExampleDependency
    {
        Guid Code { get; }
    }

    public class ExampleDependency : IExampleDependency
    {
        public Guid Code { get; } = Guid.NewGuid();
    }

Then, we register the service in our ConfigureServices method in the Startup class as scoped.

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddScoped<IExampleDependency, ExampleDependency>();
        //Code
    }

Constructor injection

Dependencies can easy be injected via constructors. Remember that a public constructor is required. We can inject a dependency into the constructor of:

Controllers
Middleware
Filters
Tag Helpers
View Components
Razor page models
Razor Views

Controllers

    [ApiController]
    [Route("[controller]")]
    public class ValuesController : ControllerBase
    {
        private readonly ILogger<ValuesController> _logger;
        private readonly IExampleDependency _exampleDependency;

        public ValuesController(ILogger<ValuesController> logger, IExampleDependency exampleDependency)
        {
            _logger = logger;
            _exampleDependency = exampleDependency;
        }

        [HttpGet]
        public string Get()
        {
            return _exampleDependency.Code.ToString();
        }
    }

Middleware

Middleware components are constructed once during the life of the application. We shouldn't inject short-lived scopes or transients services via the constructor. Our service is scope, so we need another solution. Middleware supports a second point of injection via the InvokeAsync method. This method is invoked on each request.

    public class CustomMiddleware
    {
        private readonly RequestDelegate _next;

        public CustomMiddleware(RequestDelegate next)
        {
            _next = next;
        }

        public async Task InvokeAsync(HttpContext httpContext, IExampleDependency exampleDependency)
        {
            httpContext.Response.Headers.Add("X-Code", exampleDependency.Code.ToString());
            await _next(httpContext);
        }
    }

Remember to configure the middleware in the Configure method in the Startup class.

    app.UseMiddleware<CustomMiddleware>();

Filters

We can inject a service in the constructor of a filter. Let's take a look at this example.

    public class CustomAsyncFilter : IAsyncActionFilter
    {
        private readonly IExampleDependency _exampleDependency;

        public CustomAsyncFilter(IExampleDependency exampleDependency)
        {
            _exampleDependency = exampleDependency;
        }

        public async Task OnActionExecutionAsync(
            ActionExecutingContext context,
            ActionExecutionDelegate next)
        {
            // Do something before the action executes.
            context.HttpContext.Response.Headers.Add("X-Code-Filter", _exampleDependency.Code.ToString());

            // next() calls the action method.
            var resultContext = await next();
            // resultContext.Result is set.
            // Do something after the action executes.
        }
    }

Remember to configure the service in the ConfigureServices method in the Startup class.

    services.AddControllers(opt => { opt.Filters.Add(typeof(CustomAsyncFilter)); });

We are adding the CustomAsyncFilter by type and not by instance.

Tag Helpers

Tag helpers enable server-side code to participate in creating and rendering HTML elements in Razor files.

    public class TitleTagHelper : TagHelper
    {
        private readonly IExampleDependency _exampleDependency;

        public TitleTagHelper(IExampleDependency exampleDependency)
        {
            _exampleDependency = exampleDependency;
        }

        public override void Process(TagHelperContext context, TagHelperOutput output)
        {
            output.TagName = "h1";
            output.AddClass("display-4", HtmlEncoder.Default);
            output.Content.SetContent($"Welcome {_exampleDependency.Code.ToString()}");
        }
    }

And then, on your Razor page.

    @page
    @model IndexModel
    @{
        ViewData["Title"] = "Home page";
    }

    <div class="text-center">
        <title></title>
        <p>Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
    </div>

View Components

View components are similar to partial views, but they are much more powerful.

    public class CustomViewComponent : ViewComponent
    {
        private readonly IExampleDependency _exampleDependency;

        public CustomViewComponent(IExampleDependency exampleDependency)
        {
            _exampleDependency = exampleDependency;
        }

        public Task<IViewComponentResult> InvokeAsync()
        {
            return Task.FromResult((IViewComponentResult)View("Default", _exampleDependency.Code.ToString()));
        }
    }

Then, create the Razor page for the custom view component under Pages/Components/Custom/Default.cshtml.

    @model string
    <h1 class="display-4">@Model</h1>

Finally, use the custom view component in the Razor page.

    @page
    @model IndexModel
    @{
        ViewData["Title"] = "Home page";
    }

    <div class="text-center">
        @await Component.InvokeAsync("Custom");

        <p>Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
    </div>

Razor page models

Razor page models is the same that controller injection

    public class IndexModel : PageModel
    {
        private readonly ILogger<IndexModel> _logger;
        private readonly IExampleDependency _exampleDependency;

        public IndexModel(ILogger<IndexModel> logger, IExampleDependency exampleDependency)
        {
            _logger = logger;
            _exampleDependency = exampleDependency;
        }

        public void OnGet()
        {
            ViewData["code"] = _exampleDependency.Code;
        }
    }

Razor views

In razor views, we use the @inject directive to inject a service in a view.

    @page
    @using WebApplication2.Demo
    @model IndexModel

    //Here
    @inject IExampleDependency _exampleDependency

    @{
        ViewData["Title"] = "Home page";
    }

    <div class="text-center">
        <h1 class="display-4">Welcome @_exampleDependency.Code.ToString()</h1>
        <p>Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
    </div>

Action Injection

AspNet Core controllers supports a second point of injection called action injection.

It's a common practice to use action injection over constructor injection when you need to use a service only once time on an action.

We have to apply [FromServices] attribute to tell that this parameter is coming from dependency injection.

    [ApiController]
    [Route("[controller]")]
    public class ValuesController : ControllerBase
    {
        private readonly ILogger<ValuesController> _logger;

        public ValuesController(ILogger<ValuesController> logger)
        {
            _logger = logger;
        }

        [HttpGet]
        public string Get([FromServices] IExampleDependency exampleDependency)
        {
            return exampleDependency.Code.ToString();
        }
    }

I think that there are common ways to inject and resolve dependencies in AspNet Core.

Am I forgetting some? Leave your comment below!

Call Github GraphQL API using c#

Mauro Petrini 👨‍💻 — Mon, 04 Nov 2019 22:47:08 +0000

Welcome! Spanish articles on LinkedIn. You can follow me on Twitter for news.

GraphQL API V4

You can perform a request to any Github resource through the REST API (v3) or the new GraphQL API (V4). The advantage of using the last one is you can replace multiple REST requests with a single call to fetch the data you specify.

Through a Youtube video, I'll show how to call Github GraphQL API using c# without dying while trying.

The sample covers the basis the get the login username (our account)

Endpoint

The REST API (v3) has numerous endpoints but the GraphQL API has a single endpoint:

https://api.github.com/graphql

This endpoint remains constant no matter what operation you perform

Authentication

To communicate with Github, you will need an OAuth token with the right scopes.

To create a personal token you can follow the steps in this page:

https://help.github.com/en/github/authenticating-to-github/creating-a-personal-access-token-for-the-command-line

Basic Authentication

We need to send the personal token and the username as basic authentication header in our request

string basicValue = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{Configs.GithubAccount}:{Configs.PersonalToken}"));

httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", basicValue);

User-Agent header

All API requests must include a valid User-Agent. Request with no User-Agent header will be rejected so we need to add:

httpClient.DefaultRequestHeaders.Add("User-Agent", "MyConsoleApp");

HTTP Method

In GraphQL, you will provide a JSON-encoded body whether you are performing a query or mutation, so the HTTP verb is POST

Youtube video

Github GIST

The null-coalescing operator in C# 8.0

Mauro Petrini 👨‍💻 — Mon, 23 Sep 2019 20:46:53 +0000

Welcome! Spanish articles on LinkedIn. You can follow me on Twitter for news.

What is null-coalescing?

According to ms docs, the null-coalescing operator ?? returns the value of its left-hand if it isn't null; otherwise, it evaluates the right-hand operand and returns its result. The ?? operator does not evaluate its right-hand operand if the left-hand operand evaluates to non-null.

Through a Youtube video, I'll show how to use the null coalescing operator in C# 8.0 and the evolution of this:

Old way
With C# 7
Finally with C# 8.0

Example

We have a variable called age with a null value

    static int? GetNullAge() => null;
    static int? GetAge() => 27;

    int? age = GetNullAge();

Old way

We need to check if the value is null and then assign the value

    if (age == null)
    {
        age = GetAge();
    }

C# 7

We use the null coalescing operator

    age = age ?? GetAge();

C# 8.0

We use the compound assignment operator

    age ??= GetAge();

For more information:

DEV Community: Mauro Petrini 👨‍💻

[PoC] I've built a logging provider using .NET Core

Architecture Diagram

Limitations

To dig into the code

mpetrinidev / yadl

Yet another dotnet logger

Architecture

Set up the database

Limitations

Closing Thoughts

📦 Reduce the size of your app in .NET Core 3 and above

New options to publish our app 👨‍💻👩‍💻

Let's dive into a small sample 🥳

Add PublishSingleFile property

Publish our application

Let's reduce the size of our application.

Conclusion

A guide to bulk write operations in MongoDB with C#

Table of Contents

MongoDB and C# introduction

Let's begin

Insert operations

BulkWriteAsync method

Creating a fake user dataset

Execute batch insert operation

Complete Code

Update operations

UpdateOne

Complete code for UpdateOne

UpdateMany

Complete code for UpdateMany

UpdateOne and UpdateMany

Delete operations

DeleteOne

Complete code for DeleteOne

DeleteMany

Complete code for DeleteMany

DeleteOne and DeleteMany

Put it all together

Combine xUnit with Fluent Assertions

xUnit

A common situation using xUnit

Fluent Assertions

Let's dive into some examples

Inline asserts

Custom messages

Assertion scope

Exceptions

End!

Test IOptionsMonitor in ASP.NET Core

Let's begin

Option Class

Service collection extension

xUnit class for test

Arrange

Act

Assert

Complete code

Injecting and Resolving dependencies in AspNet Core

Table of Contents

Benefits of Dependency Injection

Components of Microsoft Dependency Injection

Example

Constructor injection

Controllers

Middleware

Filters

Tag Helpers

View Components

Razor page models

Razor views

Action Injection

Call Github GraphQL API using c#

GraphQL API V4

Endpoint

Authentication

Basic Authentication

User-Agent header

HTTP Method