DEV Community: Fernando Sonego

.Net Core | User Secrets

Fernando Sonego — Tue, 29 Sep 2020 00:17:16 +0000

In development time .Net Core has a functionality that allows us to save configurations in our local user profile in a safe and simple way. This functionality helps us not to upload by mistake or modify the files with private information on servers or even in our source code control systems such as GitHub, Bitbucket or Team Foundation Service.

In the past, in our .Net applications, we had the ability to encrypt our secret information contained in the web.config files. Sometimes it made it a bit awkward to have to deploy the applications or store this sensitive information in our repositories.

We can keep sensitive information from User Secrets safely. Among the things that we can save we have: connection strings, API keys, customer data, data from any social network, or from any application. Everything that we consider as sensitive data can be stored without risking exposing it publicly.

In my case, it is very useful to me when I upload examples to GitHub. I use it to upload an example without having to upload access data to an API that I use in Azure or some social network.

Microsoft.Extensions.SecretManager.Tools

We must install Microsoft.Extensions.SecretManager.Tools. Secret manager stores the information outside the project and allows us not only to use it in the current project, but it also gives us the possibility to use it in several projects.

We will install it from the console of the Nuget packages in our application.

Once installed, we right-click on our project and select the option "Manage User Secrets" from the menu:

It will open a JSON file called secrets.json. This file will save the data we need. This is created automatically and is located inside a protected folder on the system. We can find it through a folder structure similar to this:

%APPDATA%\Microsoft\UserSecrets\user-secrets-id\secrets.json

If we want to see the User-Secrets-Id we can locate it by right-clicking on the project and selecting the option “Edit .csproj”. This will show us the project's configuration file with the id inside:

In our JSON file we will add value in order to have information to be consumed later:

{
"TopSecret": "TopSecretValuePasssUserRoot"
}

The next step is to configure the service in our Web application. We will open the Startup.cs file and modify the constructor so that we have it available with the following lines:

So far we already have our UserSecrets service active, we add value in our secrets.json file and configure in the constructor to be able to access. Now we are going to consume the value from our file. We will go to the HomeController.cs and inject the IConfiguration constructor to have the value query available:

Finally, we will run it and check if it is recovering the error correctly:

Conclusion

In this post, we have seen what it is, how to configure it, and how to use UserSecrets. The use of this functionality does not provide a great possibility of not being obliged or by mistake to upload confidential information from our social media accounts, database connection, or any sensitive information that we consider.

Asynchronous Programming in .Net Core (Part 2)

Fernando Sonego — Mon, 21 Sep 2020 22:09:01 +0000

In the previous post, we saw a small introduction to the features that .Net has to work asynchronously. In this post, we will see how to create our asynchronous methods, how to handle exceptions, and good practices when using this paradigm.

Our asynchronous method

We should always think that our code should not be too long. Let's remember that our code must be as clean as possible, therefore, we are going to refactor the code from the previous post, which was the following:

private async void button_Click(object sender, RoutedEventArgs e)
{

    using (var client = new HttpClient())
    {
        var result = await client.GetAsync($"https://localhost:44356/api/customers/search/" + search);

        try {
             result.EnsureSuccessStatusCode();
             var content = await result.Content.ReadAsStringAsync();
             var data = JsonConvert.DeserializeObject<IEnumerable<Customer>>(content);
             CustomersGrid.ItemsSource = data;
         } catch (Exception ex) {
            txtOut.Text += ex.Message;
        }
    }

}

We will make some changes, we will create a method that we will call GetPeople (). We will make sure that our application does not modify its behavior despite being in a separate method. We will modify our code. It will look like this:

private async void button_Click(object sender, RoutedEventArgs e)
{
    await GetPeople(search);
}

public async Task GetPeople(string search) {

    using (var client = new HttpClient())
    {
        var result = await client.GetAsync($"https://localhost:44356/api/customers/search/" + search);

        try
        {
             result.EnsureSuccessStatusCode();
             var content = await result.Content.ReadAsStringAsync();
             var data = JsonConvert.DeserializeObject<IEnumerable<Customer>>(content);
            CustomersGrid.ItemsSource = data;
        }
        catch (Exception ex)
        {
            txtOut.Text += ex.Message;
        }
    }
}

The first thing we can notice is that our GetPeople () method is declared as async and Task. Note: we should not do async methods that return a void type, we should only use it when they are Event Handlers.

Declaring it as Task means that the method will automatically return a reference to the operation that is in progress and at some point, it will be invoked waiting for the resolution. Visual Studio will not show any errors, this is because a method declared as an async task must explicitly return something and the compiler will take care of it.

In the click event, we invoke GetPeople () and declare it with the await keyword so that the code waits. Let's see in the image that nothing has changed:

It is very easy to refactor your code by creating an asynchronous method. By doing so we made our code a bit more readable. Remember, again, that this approach can be applied in any environment of .Net, ASP.Net, console, Xamarin, etc.

Exceptions

Our methods can fail. Suppose our method is calling the API but it is not available at the moment. Our application will fail. For this reason, the await keyword is so important. This guarantees that the exception is handled, and if we do not use it, the application will never know that an exception has occurred.

Visual Studio warns us when we have a call to a method that returns a Task and is not being invoked with the word await.

Another example would be, what happens if we use a try..catch block?

try
{
    GetPeople(search);
}
catch (Exception)
{
    throw;
}

Exactly the same would happen, the exception will not be handled. But if we add the await keyword we can handle the exception.

Another important point, async methods should not be void. The reason is that void methods cannot be handled by their exceptions because they return nothing. By using Task we make sure that something is returned.

For this reason, the await and async Task combination are very important. Thanks to this combination we can ensure that we can handle exceptions. The method will return a type and when invoked it will wait for something to happen.

Good Practices and Conclusions

Where we can use these practices in .Net:

Windows Presentation Foundation
Windows Forms
Xamarin
Console apps
Asp.Net

We can use it in any type of .Net application we need. The only difference is that ASP.Net does not have a user interface but it will help us to lighten the load on the webserver.

Let's summarize what is wrong and what is correct:

I hope that the information is useful to you and covers all the needs that arise. In future posts, I will touch on more topics on synchronous and parallel programming.

Asynchronous Programming in .Net Core (Part 1)

Fernando Sonego — Mon, 14 Sep 2020 12:40:09 +0000

We always want to create fast applications with great performance. For this reason, it is very important to know the asynchronous principles that .Net offers us. We will see the main concepts, common problems, complex scenarios, and what keywords that C # gives us to be able to work asynchronously.

Asynchronous programming in .NET

To begin with, it does not matter if we are not working in Asp.Net, in a console application, Windows Presentation Foundation, Windows Forms applications, or Xamarin, the asynchronous principles can be applied in any .Net environment.

Before looking at how it works in detail, let's look at an application that does not take advantage of these features. We will use a Windows Presentation Foundation application to see in detail what happens when having synchronous connections.

Our apps search for people by the color of their eyes. We have a TextBox and a Button to search for. Also, a grid where we will see the results, a text box to write, and a progress bar. Our application consults an API to retrieve the data. Let's see what happens.

The code that is executed when pressing the search button is the following:

var client = new WebClient();
var content = client.DownloadString($"https://localhost:44356/api/customers/search/" + search);
var data = JsonConvert.DeserializeObject<IEnumerable<Customer>>(content);

CustomersGrid.ItemsSource = data;

We are using a class that is now deprecated, which is WebClient. This class has the problem that it blocks the main thread, which is where the user interface is located, causing it to crash as well.

So what can we do? Well, first we will use a class that is designed to make use of asynchronous technology that is HttpClient. This class has the GetAsync method, and as its name indicates, it is an asynchronous operation, implying that it will not block the main thread where the interface is located.

try {
    using (var client = new HttpClient()) {

        var result = await client.GetAsync($"https://localhost:44356/api/customers/search/" + search);
        var content = await result.Content.ReadAsStringAsync();
        var data = JsonConvert.DeserializeObject<IEnumerable<Customer>>(content);

        CustomersGrid.ItemsSource = data;
    }
} catch (Exception ex) { 
}

We can see that the await keyword is found in our new code. This is the best way to indicate that we want to return to this part of the code once the data is loaded from the API we are querying. Let's see the behavior now that the code is written so as not to generate locks:

We can see our UI now is not blocked when consulting a service. We can also see the progress bar running without interruptions while waiting for the resolution of the data.

Actually, as you have surely noticed, with a few small changes in our application we can take advantage of the principles of asynchronism, providing a better user experience in this case.

Async and Await in .NET

Let's see the execution of the code where the button's click event is declared:

private async void button_Click(object sender, RoutedEventArgs e)
{

    try
    {
        using (var client = new HttpClient())
        {

            var result = await client.GetAsync($"https://localhost:44356/api/customers/search/" + search);
            var content = await result.Content.ReadAsStringAsync();
            var data = JsonConvert.DeserializeObject<IEnumerable<Customer>>(content);

            CustomersGrid.ItemsSource = data;
        }
     }catch (Exception ex) { }

}

Next to private appears the word async, this indicates that the event will be asynchronous, but it will not be enough for us to work correctly. For this, we must use the word await, which, as we commented previously, is in charge of notifying that it must wait until it is finished executing.

Suppose we only have the word async and never use await. Visual Studio will tell us that it will be waiting for the word await inside the method.

Another point that we must take into account is the method. As we can see the method is now called GetAsync (), in fact, it returns a task of the HttpResponseMessage type, we will talk later in the post, for now, we will only say that it will make it run in a different thread.

The asynchronous principles that we talk about in our applications are not only intended for Windows applications or mobile applications. These asynchronous principles are suitable for any type of I / O operations. For example, disk access, database access, memory or services as in the example.

We can also apply the same principle to server-side code in ASP.NET. Let's see the code of the rest API that is being invoked, which returns the list of people.

[Route("api/customers/search/{valor}")]       
public async Task<IList<Customer>> Get(string valor)
{
    List<Customer> items;

    using (StreamReader r = new StreamReader(@"customers.json"))
    {
        var json = await r.ReadToEndAsync();
        items = JsonConvert.DeserializeObject<List<Customer>>(json);
    }

    return items.Where(p => p.EyeColor == valor).ToList();
}

We have declared the controller method as asynchronous. Also, the type will be Task. This means that ASP.Net will know that there is an asynchronous operation in progress and then when all the results are available, they will be returned by the method.

The benefit that it offers us within ASP.Net is to reduce the excessive load on the web servers without interrupting the normal execution, allowing it to continue serving requests while it is waiting for the resolution of data or external accesses.

Understanding the flow

So far we have seen how to declare our methods as asynchronous, we saw the keywords as await and we understood how the operations are executed in a separate thread and not in the main thread of the applications.

Await allows us to retrieve the result of an asynchronous operation when it is available. It also assures us that there are no exceptions or problems with the currently running task. This means that it is not only the best way to wait, but also to validate the current operation.

This is where the term Continuation comes in. Continuation is the block of code that is executed after the await word.

As we can see in the image, our method called GetAsync (…) is marked with the word await, this means that what is marked in red is our Continuation block. Again, where the RadAsStringAsync () method is found, it is marked with await, this means that the next 2 lines would be our Continuation.

Let's make a change to test if there is a problem, for example, that it does not find any records. Our code would look like this:

using (var client = new HttpClient())
{
    var result = await client.GetAsync($"https://localhost:44356/api/customers/search/" + search);

    try {

        result.EnsureSuccessStatusCode();

        var content = await result.Content.ReadAsStringAsync();
        var data = JsonConvert.DeserializeObject<IEnumerable<Customer>>(content);

        CustomersGrid.ItemsSource = data;

        } catch (Exception ex) {
            txtOut.Text += ex.Message;
        }
}

Our method makes the asynchronous call but will not return an error. For this, we change our Try..Catch and inside we invoke result.EnsureSuccessStatusCode (). This validates the response code, as it is not 200 it will throw an exception. Finally, it will be caught by the catch by typing the error in the text box.

We can see that after the await word the code will be executed giving the feeling that we should not worry about working in another thread and that if it has a problem we can validate and retrieve the context of where we are executing our code.

Conclusion

In our applications, it is very important that we understand and begin to implement these asynchronous patterns. Not only because of the fact that our applications will have fewer blocks and will have a better user experience, but also that these blocks can produce additional costs. If we are working in the cloud we must not forget that the more we waste resources, the more we will have to pay. This is a good way to save costs with our applications.

In the next post, we will see how to create our own asynchronous methods, how to handle exceptions, and the best practices for it.

Visual Studio Intellicode

Fernando Sonego — Mon, 07 Sep 2020 16:17:57 +0000

At the Build 2019 conference, Microsoft announced the release of Intellicode. This tool based on artificial intelligence will help us developers while we are developing code. Intellicode is responsible for analyzing millions of lines of code coming from public GitHub projects to provide the best options for our projects and increase their quality, also, it does not give the ability to be more productive.

It supports the following languages in Visual Studio 2019:

C#
Java
Python
SQL Server
TypeScript / Javascript
XAML

Sure you wonder how it works? Intellicode analyzes millions of lines of code sourced from high-scoring public GitHub repositories. While we are writing our code, Visual Studio will show us the recommendations differentiated with a star, let's see the image:

In the image we can see how when writing our code the suggestions related to the context of what we are doing are displayed. In our context, that of the example, in the recommendations we see the most used options at the beginning of the list marked with a star.

This technology is based on GitHub line learning models. But we can create our own models for our projects. This allows us to customize our project adapting to our work team. The tool will analyze our projects or solutions, automatically generating recommendations.

Another interesting feature is Code Styles. This functionality allows us to have code conventions to automatically make style and format corrections. It will help us keep our code clean and organized. For this we must add the file editorconfig. This file will contain the necessary information on the basic styles that we can then configure as we wish.

All the recommendations configured in these files can be seen in the error list window in Messages.

Let's do a simple test. We will change in our editorconfig file that our indentation instead of being 4 spaces is 15. We will only have to change this line.

indent_size = 4 to indent_size = 15

After saving our file, we will return to our code and press the Ctrl K + D keys to activate the automatic style adjustment. We will see how the indentation changes in our code.

Conclusion

Over time, more and more languages will be added, providing greater support to the tool. Intellicode will be a very helpful tool for programmers, being able to reduce a large number of common errors, maintain a clean, orderly and consistent code almost by the hand of an automatic refactoring.

StyleCop: Create code with style

Fernando Sonego — Mon, 31 Aug 2020 13:11:39 +0000

One of the discussions in the teams of programmers always styles that you must code. Most of the time, no two programmers write code in the same way as the other. This is because it is more a matter of taste than of a methodology itself.

Let's imagine that the team agrees and we have a person who is dedicated to reviewing the coding style, quite tedious, right? This is where we can use an automation tool like StyleCop.

What is StyleCop?

What is StyleCop?
StyleCop parses our C # code to apply a set of style and consistency rules to our code. We must bear in mind that there are 2 versions of StyleCop. Until recently, StyleCop was used, but now the recommendation is to use StyleCop Analyzer because the previous version will not have major changes or new features.

Let's see an example of things that we can solve with StyleCop.

if(condition) return;

The tool will be in charge of identifying all the places where the declaration of the first part of the example is found and it alerts us when compiling that there is code that does not comply with the style rules.

Recall that these rules must be agreed with the team. By default, StyleCop, brings many rules, for example, quantity of white spaces, how to declare names of properties, variables, or methods, but perhaps, we do not like all of them or suit our team.

Configure StyleCop

After creating our project to add StyleCop we must do it from a Nuget package. For this we will right-click on our project, select "Nuget Package Manager" and the sale will open. In the search engine, we will write StyleCop.Analyzers and press install. You can see it in the following animation.

Perfect! We already have it available in our project.

How to use StyleCop?

The first thing we will do is modify our main method with the following code:

using System;

namespace StyleCopDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            HelloWorld1();
            HelloWorld2();
            HelloWorld3();

            Console.ReadLine();
        }

        private static void HelloWorld1()
        {
            Console.WriteLine("Hello World! 1");
        }

        private static void HelloWorld2()
        {
            Console.WriteLine("Hello World! 2");
        }
        private static void HelloWorld3()
        {
            Console.WriteLine("Hello World! 3");
        }
    }
}

We will see that in our error list window, errors that begin with the StyleCop Analyzer SA code will appear in the Warnings section.

A little trick, if we click on the code, it will take us to the website that will explain what this error is due to and the information corresponding to the rule that triggers it and how we must repair that code to eliminate the warning.

Configure Rules

To configure the rules that will be applied to the code we have 2 paths. The first is to do it from the rules panel, it is accessed by right-clicking on the project and selecting properties. The second is to add a stylecop.json file to the project.

To see the first panel of rules we must go to Solution Explorer, display dependencies, analyzers, finally, we select StyleCope.Analyzer.

We can configure what level of severity it has between error, warning, suggestion, silence, or none.

Each of the options has a different result, the most important:

Warning, appears in the list of errors in the warnings section. *Error, it will be shown in the error section, and the invalid code is highlighted in red in the editor preventing the compilation of the project. *Security, it will appear in the suggestions section. *None, the rule will not be checked.

Another way to configure the rules is to use a stylecop.json file. We can create it automatically from a rule. When the lamp is marking us, press and select "Add StyleCop setting ...". This will create the file with the rule.

The rule we created has to do with copyright as the head of the files. In our JSON file, in “companyName” we complete with “StyleCop DEMO”. The next step is to add the file as an additional parser file. For this, we have to go to the properties of the file and configure it in configuration actions. A ready bird when applying the rule we will see how it puts the new companyName.

Now we can see that the using is marking us. One of the rules says that all using must be declared inside the namespaces:

If we want to change this line, and leave the using ones outside the namespace, we can add the rule in our configuration file.

'orderingRules': {
     'usingDirectivesPlacement': 'outsideNamespace'
 }

To see all the rules we can consult the corresponding documentation. But almost always the default rules cover all basic and standard needs.

Finally, let's see one more example:

public class Customers {
     public string _name;
}

We have a class that does not respect several rules. First, we have the rule "a C# code file contains more than one unique type." executing the rule will move the type to a new c # file. Second, we have the class format rule. Third and last, it does not say that the class must be documented but suppose that we do not want to do so, we can add an exception so that it is not taken into account.

Conclusions

We must always reach an agreement with the team that regulations we want to implement and how serious they can be not respecting them. For this reason, the best way is to let StyleCop do the work for us with only an initial setup effort. This guide is quite simple, but I invite you to continue investigating a little more about this excellent tool.

.Net Core: Multiple Environments

Fernando Sonego — Sun, 23 Aug 2020 21:38:28 +0000

One of the best features of .Net Core is the ability to work with multiple environments. We can use environments like development, test, and production. This configuration will allow us to modify the behavior according to the environment in which the application is running. The objective of this publication is to discuss the possible uses of this new feature together with good practices in application development.

Suppose we have 3 environments where we must run or load different configurations: Development, Staging, and Production. Asp.Net Core allows us to distinguish these environments by means of variables called “Environment Variable”. the variable we are referring to is called ASPNETCORE_ENVIROMENT. This is what will allow us to configure our environment. The most common values are Development, Staging, and Production.

Once this variable is configured, we can detect at runtime what the value of this variable is and in what environment we are running the application.

We must bear in mind that in Linux the name is case sensitive, for this reason, the files and configurations will be taken as case sensitive as a good practice.

Development

This environment is that we will use while we are developing our application. How do we configure it? we must right-click on our project, select configuration, a window will open and select from the left tab "Debug" as we can see in the next window.

Remember that when I modify this screen, the configuration is modified in the launchSessting.json file inside the properties folder. In this file we can include any environment that we want, for example, we can add several configuration profiles as we can see in the following code:

{
    "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
        "applicationUrl": "http://localhost:40088/",
        "sslPort": 0
    }
},
    "profiles": { 
        "IIS Express": {
            "commandName": "IISExpress",
            "launchBrowser": true,
        "environmentVariables":{ 
            "ASPNETCORE_ENVIRONMENT": "Development"
        }
    } 
},
    "IIS Express (Staging)": { 
        "commandName": "IISExpress",
        "launchBrowser": true,
        "environmentVariables": {
            "ASPNETCORE_ENVIRONMENT": "Staging"
        }
    }
}

If we change any of these settings in the file, the effects will not be taken automatically. We will have to restart the servers, especially Kestrel will need to restart, once it has been modified to be able to correctly detect the change.

Staging

This is the environment that we will use for a test or pre-production environment. Almost always for a final test before making a move to production. This environment should almost always be a production mirror to reduce deployment impact.

Production

This is the environment that is often called Alive. It is an environment where we configure security, performance, and reliability characteristics of the application. some of the characteristics that the production environment can have are:

Enable cache functions
Client-side file settings such as packages, shrinking js and css files or CDN (Content Delivery Network) settings
Disable diagnostic functions
Activate logging and monitoring settings.

The list can be longer depending on the needs of each application.

Setting up the environments

In Windows we can make use of the configuration by means of once our application is running:

Command line

set ASPNETCORE_ENVIRONMENT = »Development»

PowerShell

$ Env: ASPNETCORE_ENVIRONMENT = "Development"

These commands will only be validated while the window where it is being executed is open. If we close it we will lose this configuration. In case we want the value to be global we must configure it from Control Panel> System> Advanced System Configuration, in the Advanced Options tab we must add the ASPNETCORE_ENVIRONMENT variable as we see in the following screenshot:

In macOS we must use the following command from bash

ASPNETCORE_ENVIRONMENT = Development dotnet run

At the operating system or machine level, we must configure the variables in the .bashrc or .bash.profile files. we must edit the file and add the following:

export ASPNETCORE_ENVIRONMENT = Development

In Linux, we must use the export command from the console for the open session or modify the bash_profile file for the entire operating system or machine.

How to verify the environment at runtime

Asp.Net provides a service based on the IHostingEnviroment interface that is available through Dependency Injection in the main container. In the startup.cs file we can see how the env variable is injected, which will allow us to access the environment.

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseDatabaseErrorPage();
        app.UseBrowserLink();
    }else{
        app.UseExceptionHandler("/Home/Error");
    }
}

To check a specific environment while we are running the application, IHostingEnvironment provides the method IsEnviroment ("Environment name").

In the code we can see that it is asking if the environment is Development through the method IsDevelopment () which will configure some options for this environment. For example, we see that app.UseBrowserLink () is configured; which is a characteristic of Visual Studio that we will not use in production.

We also have the possibility to use these configurations through Tag Helper within the MVC Views. For example, we can tell you to use uncompressed css or js files in Development and in Staging and Production to use compressed files.

<environment include="Development">
    <div>The effective tag is: &lt;environment include="Development"&gt;</div>
</environment>
<environment exclude="Development">
    <div>The effective tag is: &lt;environment exclude="Development"&gt;</div>
</environment>
<environment include="Staging,Development,Staging_2">
    <div>
        The effective tag is:
        &lt;environment include="Staging,Development,Staging_2"&gt;
    </div>
</environment>

Conclusion

Asp.Net Core has a number of features that we as developers can take very good advantage of as well as great control over the environments in which we usually work. This configuration allows us to change the behavior of our application with a simple change of value in the environment variable.

Worker Services with Asp.Net Core

Fernando Sonego — Sun, 16 Aug 2020 15:54:45 +0000

Since the release of Asp.Net Core 3 we have a new feature called Worker Services. These services are not really a novelty, the concept has been around for a long time and you have surely used it before when our web applications needed to run some task periodically in the background, such as a notification via email.

Before .Net Core 3.0 we could do them, but now from this version, we have templates available to create them. All these kinds of background tasks can also be implemented as a Windows Service or a Daemon in Linux.

In this post we will see the creation of a Worker Service that will periodically log something particular and how it will be consumed. For this we will use VS Code. We can use Visual Studio 2019. Let's get started.

Worker Services

To begin we create the template project from the console with the command:

dotnet new worker

Let's open the code with the VSCode we will see something like this:

We can see, after creating the project, we have 3 fundamentals files: appsettings.json, programs.cs, and worker.cs. Let's start by looking at the program.cs file. Inside we will find the configuration of how the service should be hosted and the configuration of its dependency injection.

public class Program
 {
     public static void Main(string[] args)
     {
         CreateHostBuilder(args).Build().Run();
     }

     public static IHostBuilder CreateHostBuilder(string[] args) =>
         Host.CreateDefaultBuilder(args)
             .ConfigureServices((hostContext, services) =>
             {
                 services.AddHostedService<Worker>();
             });
 }

If we need to add some extra service, for example, to send mail or some kind of notification, we will have to inject it from this section.

Let's now look at our worker.cs.

public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;

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

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
                await Task.Delay(1000, stoppingToken);
            }
        }
    }

We see that our class inherits from BackgroundService which is the one that implements IHostedService. You must implement ExecuteAsync which will be the method that runs in the background. We must bear in mind that we must always use the cancellation token to be able to quickly end and close the service correctly.

public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;

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

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
                await Task.Delay(1000, stoppingToken);
            }
        }
    }

We can run it to see how the default template works from the console with dotnet new. We will see how the service is called once per second.

We can implement service initialization and termination events to inform us of these events. For this, we will create the class WorkerExtend.cs

public class WorkerExtend : BackgroundService
    {
        private readonly ILogger<WorkerExtend> _logger;

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

        public override async Task StartAsync(CancellationToken cancellationToken)
        {           
            _logger.LogInformation("Worker Start: {time}", DateTimeOffset.Now);
            await base.StartAsync(cancellationToken);
        }

        public override async Task StopAsync(CancellationToken cancellationToken)
        {           
            _logger.LogInformation("Worker Stop: {time}", DateTimeOffset.Now);
            await base.StopAsync(cancellationToken);
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
                await Task.Delay(1000, stoppingToken);
            }
        }

        public override void Dispose()
        {

        }
    }
}

We will execute it from the console and we will see the outputs of the corresponding events.

However, before commenting that we can implement it as a Windows Service. To do so, we just have to add the injection to do it in the program.cs file.

public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .UseWindowsService()
                .ConfigureServices((hostContext, services) =>
                {
                    services.AddHostedService<WorkerExtend>();
                });

Then to implement it we can use the sc.exe tool in the following way.

sc.exe create DemoWS binpath= PathToThePublishFolder\YourWorkerClassName.exe
sc.exe start YourWorkerClassName

Conclusion

In previous versions of .Net Core we could work with Workers, let's keep that in mind. The advantage of this new template is that it allows us to have small separate services that are easy to maintain. Running these services in the background has a very low processing cost that makes them quite useful to use even if they are long running. Hope you enjoy this functionality. See you in the next post.

Productivity with Visual Studio: Refactoring | Part 4

Fernando Sonego — Sun, 09 Aug 2020 21:22:02 +0000

In this last installment, we will talk about Refactoring. Many of us surely use ReSharper to do effective code refactoring. Since the 2019 release of Visual Studio, refactoring capabilities have been greatly improved making other tools unnecessary. Let's see what we got.

Change identifier names

We can change the names of objects or identifiers such as variables, fields, classes, etc. To do this we will select the identifier and press Ctrl + R + R (R 2 times). As we start typing the new identifier name, we'll see how it changes in the places where the identifier is located.

Keep in mind that this change may not only affect the current file. We may need to rename references or rename files. Before making the final change, you can see in the preview window the changes that will be made. In the context window, we should select "Preview Changes" and press Apply.

Extract methods

You can activate Quick Actions and Refactorings using the Ctrl + key. I think it's one of the shortcuts that we should always keep in mind, if you didn't know it until now, paste a post-it on the monitor with this command.

If we want to extract a snippet to a method, we need to do the following steps: first, we select the desired lines of code, then press Ctrl +. , finally, we select "Extract method". Once selected it will be positioned in place, it will be green so that we type the name.

Clean and sort

Many times, when we refactor, maybe the using is deprecated or we add new ones quickly without having a default order. We can automatically clean and sort using from the menu Edit > Intellisense > Remove and Sort Usings.

It does not have a hotkey, but we can configure from the menu Tools > Options > Keyboards.

Another way, perhaps faster, is to position ourselves on the using and press the yellow lamp on the left. We will choose the option to Remove Unnecessary Usings. The most interesting thing about this window is that down to the right we can see several options, not only can we clean the document, but we can also do in a project or in the complete solution.

Using missing when copying and pasting

When we copy and paste code snippets, we may have errors due to the lack of the using needed for the east. To fix it, after pasting the snippet we press Ctrl + . and we choose to Add missing usings.

Create properties from the constructor

Suppose we have a constructor that receives some variables. Easily, we can convert all these variables into properties, and they will be self-assigned within the constructor. This functionality is very useful when working with dependency injection. We may not need properties, but, the declaration of a private variable and its assignment, we can also do so.

To use the functionality we must stop over the declaration, press Ctrl +. , and the option "Create and initialize property". If we want it to be a field, we choose "Create and initialize field".

Create constructor from properties

Like the previous one, we can generate a constructor from a set of properties. Choose the fragment with the properties, press Ctrl +. , and choose "Generate Constructor".

Convert a foreach expression to Linq

Many times, when we have one loop, within another and we have a conditional within the latter, it is possible to convert it to a simple LINQ expression. You may not be able in some cases, but for the most part, it is possible. If the pattern we see in the image is met, we can do it.

Select the entire foreach block, press Ctrl + . and choose "Convert to LINQ".

Extract Class to an Interface

This option is for the laziest, who prefer to write the class first and then the interface. We must position ourselves in the class, press Ctrl +. and choose the option "Extract Interface". It will show you a dialog box with the options with which you will create the interface. Press Ok and automatically add inheritance to the class from which we extracted the interface and create the file.

Move to Namespaces

When we create a new code file in C-, Visual Studio, we automatically complete the Namespaces. Let's say we create a new class, complete it, and later realize that we create it in another folder, and it has other Namespaces. We can move it, but it is left with the old Namespaces. If we position ourselves on the object and press Ctrl + . will give us the option "Move to Namespace". This option will not open a dialog box to change the Namespaces, even has a list from which we can choose the correct one.

Add parameter to an existing method

Suppose we are invoking a method and realize that it is missing a parameter or overload. We can invoke the method and type the missing parameter, then select the parameter, press Ctrl + . and we chose the option "Add parameter to".

Simplify string interpolation

The correct path to making interpolations was always String.Format. Over time, improvements were added to C# to be done in a simpler way by means of $ and the { }. It is possible to transform the first to the second structure. Choose the String.Format, press Ctrl +. , and choose the option "Convert to interpolated string".

Conclusions

With the advancement of time, with each new update, Visual Studio becomes an increasingly powerful tool. Since the 2019 releases it has improved in its refactoring functionalities and many more are on the way. I thank you for having accompanied me in this post series. See you in the next post.

Productivity with Visual Studio: Debug | Part 3

Fernando Sonego — Sun, 02 Aug 2020 23:44:28 +0000

Until now, in the first part and in the second, we have seen tricks for the code editor and improving our navigation in it. Now it's time for some tricks to improve our debugging.

Most of us know the basic commands like F5 to start debugging, F9 to set a breakpoint, or F11 to get into the implementation. In addition to these, there are many functionalities in the tool that we can use to make our work easier.

Move the execution point

The first is to move the point where it is running. On the left side of the editor, we can find a yellow arrow, this indicates where the execution is stopped. If we need to go to another line to run from there, all we have to do is hold down the arrow and drag it to the desired place.

Run up to a point

Suppose we have a breakpoint on the first line, but we want to run up to one in particular. We can do is click on the line and press Ctrl + F10 or press right-click and select it from the Run to Cursor context menu

Another path is through the green marker to the left of the code line. We position ourselves on the line to which we want to go, on the right, the green marker will appear, indicating that we can advance to that point by clicking on it.

We can go to an execution line without the need to execute the middle code. Again, if we stand on the line, we see the green marker on the left side. If we press the control, we will see that it turns yellow, we click and it will go to the line without executing the intermediate code. It is for this reason that when viewing the tracking window the object is null.

Set breakpoints

Breakpoints don't just stop because we mark them. We can configure a breakpoint by configuring different conditions or when a particular event happens. It is very useful when we are debugging and we depend on the values that the objects contain.

We can configure a property of an object to stop when it has changed. In the image, we can see how we should do it. We configure that when changing ProductId of the product object it stops. Notice how the line is gray.

Suppose we need to stop execution when a property takes a specific value. For this, on the red marker of the breakpoint, we press on the configuration gear and select Conditions. We see that we have several configuration parameters. We complete it to stop when p, which is inside a loop, in the Description property is equal to “Product 2”. This will make the loop run until the condition is as desired.

Now instead of stopping, we also want to see all the outputs of the loop. We can use Actions. Again, on the breakpoint, we select the gear and select Actions. Here we can write a text and then enter {} the name of the variable or object that we want to print in the output window.

View function values

Many times, we execute a method that returns a value, but we ignore it or do not assign it to a variable. This makes it not accessible at run time or debugging. The debugging time can be seen, if necessary, from the auto window. We can open it, at debugging time, from Debug> Windows> Auto.

Verify unchanged objects from immediate window and observation

Whenever we execute a method from the immediate window we change the value of some property or object. As we see in the image, each time we execute the method, the value in the observation window is updated, notifying us that the value has changed. To have no effect, we can use the prefix nse.

Decompile the IL code

Many times we create libraries to reuse in our projects. We refer to our project to the assembly that has a dll extension. In this example, we have Math.dll, it is a project that I create to use in the example.

Once we referenced it, it will work as a black box, where we can't see the implementation. Visual Studio gives us the possibility of being able to do it even though it is compiled. This functionality allows us to decompile the component and have the implementation code available.

To access the value we must use what is called a pseudo-variable, in this case, $ReturnValue. As we see in the image, after executing the method, we immediately write $ReturnValue in the window and we will see the result.

Conclusions

With all this set of functionalities and tools, we can make it easier to search for any problem that we have in our application. In the next post, we will see tricks for refactoring. I hope you find it useful and take advantage of it.

Productivity with Visual Studio: Navigation | Part 2

Fernando Sonego — Sun, 26 Jul 2020 23:36:54 +0000

In the previous post, we saw how to increase our productivity by maximizing the use of Visual Studio. Now it's up to the topic of Navigation tricks in the tool. All these functionalities that we will see will help us move more quickly within the code and go to the exact points that we want in our project or solution.

The first thing we learn to use is the command ctrl + shift + f, but we have much more. Fortunately, the tool offers us many functionalities to achieve better navigation in the code.

Search bar

Above the title bar, we have a search bar available. Very few people see that it is there. If you work with Visual Studio Code you surely know this functionality, they are very similar in Visual Studio. This allows us to search through various objects such as Code elements, files, Visual Studio command, Settings, and much more!

we can see in the image, we write, for example, IApp Visual Studio will search for everything related to interfaces, configurations, files, etc. As we continue to write, the search listing will change. Just clicking on an item in the list will take us to the desired place.

If we write command, such as Go To Line, it not only shows us the shortcut but also, if we click on it, it activates the command showing us the dialog window to select the line we want to go to.

These search tools are very powerful, but we have even more in the next section.

Elements in the code

When we must search for elements in our code the best way is to use the combination ctrl + t. The difference with the previous one is that instead of searching the entire Visual Studio, it will allow us to search for elements related to the code: Lines, Files, Types, members, and Symbols.

If we write for example IApplication again, it will search all our code elements, you can see in the image even in a test project. If we wanted to search only the interfaces or the related type we can add the filter t using it this way t IApplication. We can learn each of the filters to do a faster search. To further refine the search, we can use ctrl + alt + c limiting the search to the current document, or alt + x, for the rest.

Something interesting we can do is customize it. At the top right, we can see a gear, selecting it will give us 3 options, use in a tab preview, show the details and center the result on the screen. We can adjust it to our comfort.

Go to the definition or see it in the same editor

Something we commonly do is go to the definition of a class or interface to see what it has implemented. We do this with the F12 key. This key takes us directly to the definition by opening the file involved, but sometimes, it is tedious having to change tabs to get back to where we were working. For this, we have the following improvement using alt + f12. This will open a small window, within the editor, that will let us see the implementation code without changing places or opening a new tab.

If we want to see all the available navigation options, we can right-click on our code and the context menu will open. Note all the options that we have available:

Search References

To quickly see the references on an element or object we must position ourselves on it and press shift + f12. This will open the references window:

Also, we can group the results by projects, types, by files and some more.

CodeLens

This is one of the features that I like, when it came out it was not to the liking of many people, but over time, it became so useful that everyone loves them today. Above identifiers, we can see the word reference with the number of references that the identifier has. With Git we can see the last modification and commits if we select it.

As we can see in the image, when clicking on references, the list will open and we will be able to choose an item that will take us to the corresponding code.

Go to Base or implementation

When positioning on an identifier we can do 2 things, first pressing alt + home will take us to the base class or the implementation interface. But, if we press ctrl + f12 it will take us to the derived classes or classes that implement an interface.

Call hierarchy

The call hierarchy allows us to navigate through all the invocations from a method, property, or constructor, allowing us to examine various levels of code and to see the complex paths of one or several calls.

To use it we must stop on a member, we will press ctrl + k ctrl + t, the window will open where we can see the hierarchy of calls.

Find Comments: TODO

According to Clean Code practices, the only comment allowed is TODO. TODO allows us to leave a comment for something we should do later. We can track these comments from the Task List window that Visual Studio has.

We can define a query if we want, we can do this from, Option > Environment > Task List:

Lines of code

In the previous post, we saw that we can put marks in our code, this is something similar to those marks. We can put direct access to a line of code with the ctrl + k + h keys and with the same combination, we deactivate it.

Once we place a mark we can visualize them in the Task List. Something interesting is that if we close Visual Studio, they will remain the next time we resume work.

Go to closings and select by block

We can stop on a { and go to the corresponding closing } by pressing the corresponding key ctrl }. If we are standing on }, pressing ctrl {, it will go to the start. This can also be done with () [] and <>.

Also, if we press Ctrl + Shift }, it will select the block.

Conclusions

I hope they are useful and help you increase your productivity. Remember, with a little practice, you will be able to remember and master them without problems. In future posts, we will see other functionalities that allow us to be more productive with this wonderful tool called Visual Studio.

Productivity with Visual Studio: Code Editor | Part 1

Fernando Sonego — Tue, 21 Jul 2020 00:55:47 +0000

In recent days we entered into a discussion with some friends and colleagues on how to increase productivity while developing applications. For my part, I suggested that the first thing we should do, before learning complex programming patterns or techniques, is to know perfectly with the tool we are working with. This made me think about doing a series of posts to see some tricks to increase our productivity with Visual Studio.

In this first part, we will see some tricks for the code editor, in future posts, we will see debugging, refactoring, and other quite interesting tricks. I recommend that these tricks make them part of your daily work.

Move lines up or down

We can select one or several lines of our code to move them up or down. It is as simple as selecting the lines and pressing alt plus the up or down key. alt+⬆️ alt+⬇️.

Select in the shape of a rectangle

It is very useful when we need to edit portions of code on multiple lines and multiple columns. We can activate it by pressing alt + shift and pressing the arrows.

Edit multiple lines at once

Using the above functionality, alt + shift + arrows, we select a text and several lines and we will directly start typing. We will see that everything that was selected in the rectangle will begin to change as we type.

Editing in multiple places at the same time

At some point, you surely needed to insert or edit the same text in different places. We can do this by choosing multiple entry points. We must hold down ctrl + alt, then, with the left mouse button, press in the places where we want to use as entry points. ctrl + alt + click.

Selection of code blocks

Suppose we want to select code blocks for their closure, in C# for example {...}, standing inside we can use the key combination alt + shift + = to select outward if we want to make an inward select we will use alt + shift + -.

Lowercase to uppercase to lowercase

Sometimes we have to change upper or lower case texts or vice versa. We can select the text and press ctrl + shift + u, for upper case and ctrl + u to make it lower case.

Expand, collapse and collapse our code

Visual Studio allows us to collapse, expand or contract our code depending on the language and the block closing structure, for example in C# es {..}. we always see that on the left side of the editor window the + or - to be able to do it with the mouse. It is also possible to do it with the key combination ctrl + m ctrl + m (collapses), ctrl + m ctrl + p (expands).

Code map

This is one of the most useful functionalities of the code editor in Visual Studio, also present in Visual Studio Code, it does not help to quickly position ourselves somewhere in our code file, especially if it is very extensive.

If we want to change the behavior of the bar we can do it from the Visual Studio configuration. We should go: Tools > Options > Text Editor > All Languages > Scroll Bars > Behavior.

Markers

Maybe the same thing happens to me, many times we have a large number of open files editing them at the same time. There are several ways to get from one place to another in the code, such as Go to the definition. Other times it is not possible. This is where bookmarks will be useful to us, we can put them in our lines of code to go from one place to another and they remain, although we close Visual Studio, they are:

Ctrl+K, Ctrl+K, put a marker.
Ctrl+K Ctrl+N, go to the next marker.
Ctrl+K Ctrl+P, go to the previous marker.
Ctrl+K Ctrl+L, clear all our bookmarks.

Multiple Clipboards

We copy a lot of code all the time, we copy something, then we copy another, we use it, but we also needed the old one. Visual Studio keeps a history of all the ctrl + c that we do while we are working. To access history we must stop at the place where we want to insert any of the codes copied previously and press ctrl + shift + v and the history will be displayed.

Conclusion

After these tips and practicing them a lot, we can increase our productivity. Remember, this is not simple at first, it takes practice and a good memory. Many of these functionalities are also present in the Visual Studio Code, so you can use them without problems. In future posts, we will see more tricks for Visual Studio that help us increase our Productivity.

Upgrading .Net Core 3.1 to Net 5.0 Preview 6

Fernando Sonego — Mon, 13 Jul 2020 00:19:28 +0000

We are getting closer to the final release of .Net 5, the new version of this wonderful framework created by Microsoft. This new version, as we saw in other posts, is not a simple update, it is the unification of what we know with .Net Core and .Net Framework. As it is not a minor issue, Microsoft has recommended migrating all the applications that we have in previous versions to .Net Core 3.1 to this version. Considering that time is running out and that many of us have a curious soul, I leave this guide to update to .Net 5 to test our applications on the new version of the platform.

As we talked, we are going to see the necessary steps to update a project to the current version of .Net 5 which is Preview 6. Before we start we must have 3 points in mind:

Although this Preview is quite advanced, they may have some errors that correspond to the version, the recommendation that I can give you is to review the release notes for particular cases. Also, be patient, we will surely have a new Preview in a short time.
Let's take this practice as evidence of future migrations and that the new products we will make will be of a quick update. This means that once the final version of .Net 5 is there, we should not stop there, we must start thinking about the next version.
Any problem or error that we find, let's not stop reporting it to the Microsoft team, this will help make the next preview or version more solid and stable. Also, if we find any recommendation and opinion. The team that carries out this framework is open to all the feedback we can give you.

The first thing to do is download the latest available version of .Net 5. You can download it from the following link dotnet5 . Once downloaded we will proceed to install it. We will see the image screen, we just have to follow the steps.

To correctly verify the version, we will open the Windows console and execute the command dotnet --info.

The next thing will be to install the Preview version of Visual Studio 2019 that is currently in version 16.7 Preview 3.1, you can download it from this link https://docs.microsoft.com/en-us/visualstudio/releases/2019/release -notes-preview . In my case I will use the professional version, but you can choose any version you want.

In the installation steps we will only choose that we want to install the development tools "Asp.Net and Web development".

We will create a solution with 3 types of projects: Web MVC Razor, Web API and Test Unit that we will use to do the update process.

The Web project and WebApi are using .Net Core 3.1, they are based on the MVC model. This base template will have the drivers for defaults that come in the templates, for example, in the WebApi project, we will have a driver that returns weather information.

In both projects we must update the csproj file with the new version. To be able to do it we must select the project, right click, "Edit Project File".

Both projects will have the same configuration. We can see the code here:

<Project Sdk = "Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework> netcoreapp3.1 </TargetFramework>
  </PropertyGroup>
</Project>

We must modify the “TargetFramework” tag from netcoreapp3.1 to netcoreapp5.0, remaining as follows:

<Project Sdk = "Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework> netcoreapp5.0 </TargetFramework>
  </PropertyGroup>
</Project>

It is quite simple, then we compile the application to see that it updates the packages and verify that everything is correct.

It may be that some more updates are necessary if we are using some references such as EntityFramework or some additional third-party package. The recommended steps to update are as follows:

Update "Microsoft.AspNetCore" to the latest version.
Update "Microsoft.EntityFrameworCore" to the latest version.
If we have some third party dependencies in our project, it is a good time to update those dependencies.

Once these steps are ready, we are all ready to compile the projects. We will run each of the applications to verify that everything is correct.

Finally, we have the unit testing project. Although the csproj may look a little different, we will follow the same steps that we used in the previous projects, we will modify the csproj. Before modifying it looks like this:

<Project Sdk = "Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework> netcoreapp3.1 </TargetFramework>
    <IsPackable> false </IsPackable>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include = "Microsoft.NET.Test.Sdk" Version = "16.5.0" />
    <PackageReference Include = "MSTest.TestAdapter" Version = "2.1.0" />
    <PackageReference Include = "MSTest.TestFramework" Version = "2.1.0" />
    <PackageReference Include = "coverlet.collector" Version = "1.2.0" />
  </ItemGroup>
</Project>

Modified as follows:

<Project Sdk = "Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework> net5.0 </TargetFramework>
    <IsPackable> false </IsPackable>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include = "Microsoft.NET.Test.Sdk" Version = "16.6.1" />
    <PackageReference Include = "MSTest.TestAdapter" Version = "2.1.1" />
    <PackageReference Include = "MSTest.TestFramework" Version = "2.1.1" />
    <PackageReference Include = "coverlet.collector" Version = "1.3.0" />
  </ItemGroup>
</Project>

We will also need to update the Microsoft.Net.Test.SDK reference. Build and everything ready.

conclusion

In this post we saw how in a fast and easy way we could transform our applications in .Net Core 3.1 to Net 5. Please, keep in mind that this is a preliminary version, in no way should we put these versions in productive environments. If it is recommended, test the migration of our current applications to the new versions of .Net. In future posts we will continue to see the news provided by the new versions of .net 5.