DEV Community: Sergei Belialov

Quick and easy DbContext setup in .NET

Sergei Belialov — Sun, 21 May 2023 16:15:38 +0000

In .NET, a DbContext is a class that allows you to interact with a database using entity classes. In this article, we'll explore how to create a DbContext in .NET with code examples.

Creating a DbContext
To create a DbContext, we need to create a class that inherits from the DbContext class. In this example, we'll create a ProductDbContext class that represents a database of products:

public class ProductDbContext : DbContext
{
    public ProductDbContext(DbContextOptions<ProductDbContext> options) : base(options)
    {
    }

    public DbSet<Product> Products { get; set; }
}

This code creates a ProductDbContext class that inherits from the DbContext class. The constructor accepts an options parameter of type DbContextOptions<ProductDbContext>, which allows us to configure the database connection. In this example, we're passing the options to the base constructor.

The ProductDbContext class also contains a DbSet<Product> property that represents the entity set for products.

Register DbContext
In order to use the ProductDbContext class in your application, you need to register it with the dependency injection container. This can typically be done in your Startup class, like so:

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Register the DbContext
        services.AddDbContext<ProductDbContext>(options =>
            options.UseSqlite("Data Source=products.db"));

        // Other service registrations...
    }
}

This code uses the AddDbContext method to register the ProductDbContext with the dependency injection container. It also configures the DbContext to use SQLite as the database provider, the database file location as products.db or you could use the connection string retrieved from the application configuration.

Migrating the Database
Once we’ve created and configured the DbContext, we need to create the database schema. To do this, we'll use Entity Framework Core migrations.

First, install the Entity Framework Core tools using the following command:

dotnet tool install --global dotnet-ef

Next, add a migration using the following command:

dotnet ef migrations add InitialCreate

This command creates a new migration with the name InitialCreate.

Finally, apply the migration to the database using the following command:

dotnet ef database update

This command applies the migration to the database and creates the schema.

Using the DbContext
Now that we’ve created and configured the DbContext, we can use it to interact with the database.

public class ProductService
{
    private readonly ProductDbContext _dbContext;

    public ProductService(ProductDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task<List<Product>> GetProductsAsync()
    {
        return await _dbContext.Products.ToListAsync();
    }

    public async Task<Product> GetProductByIdAsync(int id)
    {
        return await _dbContext.Products.FindAsync(id);
    }

    public async Task AddProductAsync(Product product)
    {
        await _dbContext.Products.AddAsync(product);
        await _dbContext.SaveChangesAsync();
    }

    public async Task UpdateProductAsync(Product product)
    {
        _dbContext.Entry(product).State = EntityState.Modified;
        await _dbContext.SaveChangesAsync();
    }

    public async Task DeleteProductAsync(int id)
    {
        var product = await _dbContext.Products.FindAsync(id);
        _dbContext.Products.Remove(product);
        await _dbContext.SaveChangesAsync();
    }
}

In this example, we’ve defined a ProductService class with a constructor that takes an instance of ProductDbContext as a parameter. The ProductDbContext instance is then stored in a private field called _dbContext.

We’ve also defined a few methods for interacting with the products stored in the database. These methods use the _dbContext instance to query, add, update, and delete Product entities.

With this setup, you can easily use the ProductService class in your controllers or other services, and the ProductDbContext instance will be automatically injected by the dependency injection container. For example, here's how you might use the ProductService class in a controller:

public class ProductsController : Controller
{
    private readonly ProductService _productService;

    public ProductsController(ProductService productService)
    {
        _productService = productService;
    }

    public async Task<IActionResult> Index()
    {
        var products = await _productService.GetProductsAsync();
        return View(products);
    }

    // Other action methods...
}

Conclusion
In this article, we’ve explored how to create a DbContext in .NET with code examples. We've also seen how to configure the DbContext and use it to interact with a database using entity classes. By following these examples, you should be able to create your own DbContext and interact with a database in your .NET application.

A brief introduction to MediatR in .NET

Sergei Belialov — Sun, 21 May 2023 16:02:17 +0000

MediatR is a popular open-source package for implementing the mediator pattern in .NET applications. It provides a simple way to separate the concerns of your application’s components by routing requests and responses through a mediator. In this article, we’ll explore how to install and use the MediatR package in .NET applications with code examples.

You could support the project here:
https://github.com/jbogard/MediatR

Installing MediatR Package
To install MediatR, we can use the NuGet Package Manager in Visual Studio or the .NET CLI. In this example, we’ll use the .NET CLI.

First, navigate to the root directory of your .NET application in the command prompt. Then, run the following command:

dotnet add package MediatR

This will install the latest version of the MediatR package in your .NET application.

Using MediatR Package
To use the MediatR package, we need to create a mediator and define the requests and handlers.

Creating a Mediator
To create a mediator, we need to register the MediatR services in the dependency injection container. In this example, we’ll use the default Microsoft dependency injection container.

First, add the following line of code to the ConfigureServicesmethod in the Startup.cs file:

services.AddMediatR(typeof(Startup));

This will register the MediatR services in the dependency injection container and allow us to use the IMediator interface to send requests.

Defining Requests and Handlers
Requests in MediatR represent the input to the mediator. Handlers represent the logic for processing the requests. To define a request and its handler, we need to create two classes: a request class and a handler class.

First, let’s create a request class. In this example, we’ll create a simple request to get a list of products:

public class GetProductListQuery : IRequest<List<Product>>
{
}

This request class inherits from the IRequest<TResponse>interface, where TResponse is the type of the response we expect from the handler.

Next, let’s create a handler class to process the request. In this example, we’ll create a handler that returns a list of hardcoded products:

public class GetProductListHandler : IRequestHandler<GetProductListQuery, List<Product>>
{
    public Task<List<Product>> Handle(GetProductListQuery request, CancellationToken cancellationToken)
    {
        List<Product> productList = new List<Product>()
        {
            new Product() { Id = 1, Name = "Product 1" },
            new Product() { Id = 2, Name = "Product 2" },
            new Product() { Id = 3, Name = "Product 3" },
        };

        return Task.FromResult(productList);
    }
}

This handler class implements the IRequestHandler<TRequest, TResponse> interface, where TRequest is the type of the request and TResponse is the type of the response.

Sending Requests
To send a request to the mediator, we can use the IMediator interface. In this example, we'll send a request to get a list of products and display the results in the console:

public class ProductService
{
    private readonly IMediator mediator;

    public ProductService(IMediator mediator)
    {
        this.mediator = mediator;
    }

    public async Task GetProductList()
    {
        var productList = await mediator.Send(new GetProductListQuery());
        foreach (var product in productList)
        {
            Console.WriteLine(product.Name);
        }
    }
}

This code creates a ProductService class that accepts an IMediator interface in the constructor. The GetProductList sends a request to Mediatr with query params and accepts the results.

Setting up a Python Environment

Sergei Belialov — Sun, 21 May 2023 15:53:06 +0000

Python is a versatile programming language used for various purposes, including data analysis, web development, and artificial intelligence. One of the most useful features of Python is the ability to create and use virtual environments. In this article, we’ll explore how to create and use a Python environment with examples.

What is a Python environment?
A Python environment is a self-contained directory tree that contains a specific version of Python along with any required packages and dependencies. Python environments are useful for isolating different projects and avoiding conflicts between different versions of Python or installed packages.

Creating a Python environment
To create a Python environment, we can use the built-in venv module. First, we need to navigate to the directory where we want to create the environment. Then, we can run the following command:

python -m venv myenv

This will create a new directory called myenv in the current directory, containing the necessary files for a new Python environment.

Activating the Python environment
To activate the Python environment, we need to run the activate script located in the Scripts directory of the environment. On Windows, we can activate the environment with the following command:

myenv\Scripts\activate.bat

On Linux or macOS, we can activate the environment with the following command:

source myenv/bin/activate

After running the activate command, the terminal prompt will change to indicate that we are now in the virtual environment.

Installing packages in the Python environment
Once we have activated the Python environment, we can install packages using the pip command. For example, to install the numpy package, we can run the following command:

pip install numpy

This will install the numpy package in the myenv environment. We can verify that the package is installed by running the following command:

pip list

This will display a list of all installed packages in the current environment.

Using the Python environment
Once we have installed the necessary packages in the Python environment, we can run Python scripts as usual. However, any packages or dependencies required by the script must be installed in the virtual environment.

For example, suppose we have a script called my_script.py that uses the numpy package. We can run the script in the myenv environment by first activating the environment and then running the script:

source myenv/bin/activate
python my_script.py

This will run the script in the myenv environment with the numpy package installed.

Conclusion
Python environments are a powerful tool for managing Python projects and dependencies. By creating a virtual environment for each project, we can avoid conflicts between different versions of Python or installed packages. In this article, we’ve explored how to create and use a Python environment with examples.

.NET 5.0 Blazor Web Assembly TODO List simple app

Sergei Belialov — Sat, 12 Dec 2020 20:49:27 +0000

Not so long ago Microsoft released .NET 5.0 and with this release, their front-end framework Blazor is getting even better support for Web Assembly hosting solution.

In this article, we will try to write a TODO list SPA Web Assembly application using this framework.

But before diving in let’s talk a little bit about what kind of benefits and downsides Web Assembly hosting solution carry with it.

WebAssembly (often shortened to Wasm) is an open standard that defines a portable binary code format for executable programs, and a corresponding textual assembly language, as well as interfaces for facilitating interactions between such programs and their host environment. — Wikipedia

To say simply it is an interface between compiled binary code (mostly C++ and Rust) and the environment where it executed — in our case web browser (JavaScript). All modern browsers support Wasm so you don’t need to worry about this part.

The Blazor WebAssembly hosting model offers several benefits:

There’s no .NET server-side dependency.
The app is fully functioning after downloaded to the client.
Client resources and capabilities are fully leveraged.
Work is offloaded from the server to the client.
An ASP.NET Core web server isn’t required to host the app. Serverless deployment scenarios are possible (for example, serving the app from a CDN).

However, there are some downsides to Blazor WebAssembly hosting:

The app is restricted to the capabilities of the browser.
Capable client hardware and software (for example, WebAssembly support) are required.
Download size is larger, and apps take longer to load.
.NET runtime and tooling support are less mature. For example, limitations exist in .NET Standard support and debugging.

Even with all downsides listed above, this solution looks really promising, so let say no more and start with our app!

But before building it we still need to install .NET 5.0.100 SDK

We are not going to write everything from scratch but instead, we start from Blazor WASM template by running the next command:

dotnet new blazorwasm -o ToDoList

It will generate a ToDoList folder with the following project structure:

Let’s quickly go over some pieces of it, but if you bootstrapped Blazor projects before it will look very familiar to you.

Pages folder – Contains razor files for pages (routable), while Shared holds all shared components used in Pages. wwwroot is a public folder that contains all static data such as css style files and index.html. As you can see template shipped with Bootstrap components library. Still, one minor version behind (on the date of writing this article Bootstrap has version 4.4 while template shipped with version 4.3.1, Microsoft should update templates faster, really…)

Also, you may notice open-iconinc which is an open-source sibling of Iconic, the icons library. Kinda cool addition, but you always could switch to any other icon library, e.g. Bootstrap introduced their own icon library bootstrap-icons.

Program.cs – is the main entry point of the whole app. for now it contains only a few basic lines. Services can be configured with the ConfigureServices method on the host builder.

E.g:

builder.Services.AddSingleton<IMyDependency, MyDependency>();

Configuration can be supplied via the host builder builder.Configuration. This is the main difference between Blazor Server and WebAssembly is the type of builder. As you could see for WASM application it is WebAssemblyHostBuilder

RootComponents specifies the HTML tag ID where App will be rendered, in this case <app>…</app> tag:

Another interesting line here is <script> tag that points to blazor.webassembly.js file. This JS file is responsible for:

Downloading the .NET runtime, the app, and the app’s dependencies.
Initializing the runtime to run the app.

App.razor — The root component of the app that sets up client-side routing using the Router component. The Router component intercepts browser navigation and renders the page that matches the requested address.

This structure of components and their name styles reminds some other popular frameworks, such as VueJS.

_Imports.razor — Includes common Razor directives to include in the app’s components (.razor), such as @using directives for namespaces.

NOTE: You could run the app by pressing F5 in VS Code. Alternatively to run it from CLI use dotnet run command. The app will be served at http://localhost:5000.

But finally, let get to our app… For real this time!

Let's add a new page file named Todo.razor to the app in the Pages folder. Notice @page "/todo" binds this page to the new route.

And update the navigation bar inside Shared/NavMenu.razor:

Let's run the app with dotnet watch run command and we should see our link to TODO list on the NavBar that will bring us to our new page.

NOTE. dotnet watch run will track the changes in the project files and refresh the browser. Similar to the live server. So you don't need to run it every time.

Ok. The next step is to introduce TodoItem model. Let's create a Model folder where we create TodoItem.cs file with next class:

Now when we have a model let use it inside Todo component. Go back to Pages/Todo.razor and add @code section at the bottom of the file. This section holds all component business logic. You could think about this section as a nested Class within the Component.

We will add a private field of List<TodoItem> there:

Let's use this list to render TodoItems into UI. We are going to use an unordered list tag

foreach

As you may notice the @ symbol is used for UI logic code insertions. Similar to mustache syntax used in many popular Frontend frameworks.

Alright looks like we missing an input to actually add data to todos list. Go add it:

Now our ToDo list looks way more attractive!

But it is not functional =( Let’s go fix it!. First we need to hook up @onclick handler to the button. For that create a private method within @code section and add @onlcick attribute so it will look like this:

Ok, but we missing a data binding between <input> tag for Todo Title and component class. Let's introduce another string field and bind it to the <input> tag with @bind attribute:

And some spicy logic to the AddTodo method.

Let’s test what we have so far. Because we using dotnet watch run the app already reloaded in the browser and we could try adding some “todos”.

It works! …. But looks boring… We will drop some extra functionality to gasp Blazor skills. Add UI tags and bind them to the model so we could edit “todos” title and status, but also count of undone tasks:

Let see what we have this time?

Delightful! Try changing values and see how reactivity works with model binding in Balzor. As you may notice when you change the title in the input, it reflects only when you unfocus the input element. This is the default behavior of Blazor @bind attribute. It triggers on <input> “onchange” event:

But of course, this behavior could be changed.

And that is it. We build or SPA ToDo list using Web Assembly with Blazor framework. To stop serving the app press Ctrl + C.

Conclusion.

I really like how Blazor framework evolves and becomes more and more attractive, but like all other frameworks, it has its pros and cons. I like how easy it is to implement routing and model binding. Another benefit I like is a strong typed C# with and .NET 5.0 support that brings a lot of new features to the table.

It really helps C# developers who like to develop some frontend but doesn’t really want to dive into JavaScript nightmare =).

As for WebAssembly: yes it works fast but only when it's loaded. As you could see from Lighthouse report below, we build a pretty small app but it already has a size of around 9mb. So if your Web App is supposed to be more fast and lightweight from a user perspective, I will suggest you to avoid WASM.

But if you build an online tool (e.g. photo editor or smth heavyweight and static) that loads once and performance very very good and fast — then WASM is a solution for you!

Source code could be found here: https://github.com/godszerg86/BalozorWASM_ToDO

In the next article, we will try to host a .NET 5.0 WASM application using Docker image locally on your machine.