DEV Community: VzlDev

Mastering Async and Await in C#

VzlDev — Tue, 06 Aug 2024 11:00:35 +0000

Understanding the Async and Await Keywords

The async and await keywords are essential tools in C# for asynchronous programming. They streamline the creation of non-blocking code, enhancing readability and maintainability.

Async Keyword

The async keyword is used to mark a method as asynchronous, indicating that the method can perform a non-blocking operation

Await Keyword

The await keyword is used inside of an async method to temporarily suspend its execution and yield control back to the calling method until the awaited task is completed. This allows other tasks to continue executing in the meantime.

Example

Imagine you're a chef in a kitchen. Instead of waiting for each ingredient to be ready before moving on, you can do multiple tasks at the same time to improve the time of preparing a meal.

Synchronous Code

In a synchronous approach, each task waits for the previous one to complete before starting the next. Here’s an example:

static void Main(string[] args)
{
    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();

    PrepareMeal();

    stopwatch.Stop();
    TimeSpan elapsed = stopwatch.Elapsed;
    Console.WriteLine($"Elapsed Time (Seconds): {elapsed.TotalSeconds} s");
    Console.ReadLine();
}

private static void PrepareMeal()
{
    Console.WriteLine("Preparing meal");
    CutVegetables();
    BoilWater();   
    CookVegetables();
}

private static void BoilWater()
{
    Console.WriteLine("Boiling water");
    Task.Delay(3000).Wait();
    Console.WriteLine("Water is boiling!");
}

private static void CutVegetables()
{
    Console.WriteLine("Cutting vegetables");
    Task.Delay(3000).Wait();
    Console.WriteLine("Vegetables are cut!");
}

private static void CookVegetables()
{
    Console.WriteLine("Put vegetables on boiling water");
    Task.Delay(5000).Wait();
    Console.WriteLine("Meal Done!");
}

The output of the preparation of this meal will be:

Preparing meal
Boiling water
Water is boiling!
Cutting vegetables
Vegetables are cut!
Put vegetables on boiling water
Meal Done!
Final time - 11.03 seconds

In this example, each task must finish before the next one starts, leading to a longer overall completion time.

Asynchronous Code

Using async and await allows tasks to overlap, enhancing efficiency. Here’s the asynchronous version:

static async Task Main(string[] args)
{
    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();

    await PrepareMealAsynchronously();

    stopwatch.Stop();
    TimeSpan elapsed = stopwatch.Elapsed;
    Console.WriteLine($"Elapsed Time (Seconds): {elapsed.TotalSeconds} s");
    Console.ReadLine();
}

private static async Task PrepareMealAsynchronously()
{
    Console.WriteLine("Preparing meal asynchronously");

    Task boilWaterTask = BoilWaterAsynchronously();
    Task cutVegetablesTask = CutVegetablesAsynchronously();

    await Task.WhenAll(boilWaterTask, cutVegetablesTask);

    await CookVegetablesAsynchronously();
}

private static async Task BoilWaterAsynchronously()
{
    Console.WriteLine("Boiling water");
    await Task.Delay(3000);
    Console.WriteLine("Water is boiling!");
}

private static async Task CutVegetablesAsynchronously()
{
    Console.WriteLine("Cutting vegetables");
    await Task.Delay(3000);
    Console.WriteLine("Vegetables are cut!");
}

private static async Task CookVegetablesAsynchronously()
{
    Console.WriteLine("Put vegetables on boiling water");
    await Task.Delay(5000);
    Console.WriteLine("Meal done!");
}

The output of the preparation of this meal will be:

Preparing meal asynchronously
Boiling water
Cutting vegetables
Water is boiling!
Vegetables are cut!
Put vegetables on boiling water
Done cooking!
Final time - 8.01 seconds

In this asynchronous approach, tasks like boiling water and chopping vegetables can proceed simultaneously, reducing the overall cooking time.

Benefits of Asynchronous Approach

Asynchronous cooking, or programming, allows tasks to be executed concurrently, making better use of time and resources. This results in faster completion of tasks, as the system can handle multiple operations at once. For instance, while waiting for the water to boil, you can simultaneously chop vegetables, significantly cutting down the total time needed.

And that's it guys, a simple explanation and example of asynchronous calls with .net.
There's still plenty more to learn, I hope you liked it, stay tuned for more!

Integrating PostgreSQL with a .NET: A Step-by-Step Guide

VzlDev — Thu, 27 Jun 2024 12:54:47 +0000

In today's world of ever-evolving technologies, PostgreSQL stands out as a powerful, open-source relational database management system that is robust, reliable, and feature-rich. Integrating PostgreSQL with a .NET API can open up a lot of opportunities for building scalable and high-performance applications. In this guide, we'll walk you through the process of setting up and integrating PostgreSQL with a .NET API.

Prerequisites

Before we dive in, ensure you have the following installed on your machine:

PostgreSQL
.NET SDK

Step 1: Set Up Your .NET Project

First things first, create a .NET Project.

Step 2: Install Required Packages

Next, we need to install the necessary packages to work with PostgreSQL in .NET.
Install the following nuGet package:

Npgsql.EntityFrameworkCore.PostgreSQL

This package allows Entity Framework Core to communicate with PostgreSQL.

Step 3: Configure the Database Connection

Open appsettings.json and add your PostgreSQL connection string:

{
  "ConnectionStrings": {
    "DefaultConnection": "Host=localhost;Database=mydatabase;Username=postgres;Password=yourpassword"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

Step 4: Create a Data Context Class

Create a new class named MyDbContext.cs in the Models directory (create the directory if it doesn't exist). Define your DbContext class as follows:

using Microsoft.EntityFrameworkCore;

namespace MyApi.Models
{
    public class MyDbContext : DbContext
    {
        public MyDbContext(DbContextOptions<MyDbContext> options) : base(options) { }

        public DbSet<User> Users { get; set; }
    }

    public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
    }
}

Step 5: Configure Services in Program.cs

Open program.cs and configure the services to use PostgreSQL:

 services.AddDbContext<MyDbContext>(options =>     options.UseNpgsql(Configuration.GetConnectionString("DefaultConnection")));

Step 6: Create and Apply Migrations
To keep your database schema in sync with your EF Core models, use migrations. Open a terminal and run:

dotnet ef migrations add InitialCreate
dotnet ef database update

Step 7: Create API Endpoints

Create a new controller named UsersController.cs in the Controllers directory:

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MyApi.Models;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

[Route("api/[controller]")]
[ApiController]
public class UsersController : ControllerBase
{
    private readonly MyDbContext _context;

    public UsersController(MyDbContext context)
    {
        _context = context;
    }

    [HttpGet]
    public async Task<ActionResult<IEnumerable<User>>> GetUsers()
    {
        return await _context.Users.ToListAsync();
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<User>> GetUser(int id)
    {
        var user = await _context.Users.FindAsync(id);

        if (user == null)
        {
            return NotFound();
        }

        return user;
    }

    [HttpPost]
    public async Task<ActionResult<User>> PostUser(User user)
    {
        _context.Users.Add(user);
        await _context.SaveChangesAsync();

        return CreatedAtAction(nameof(GetUser), new { id = user.Id }, user);
    }

    [HttpPut("{id}")]
    public async Task<IActionResult> PutUser(int id, User user)
    {
        if (id != user.Id)
        {
            return BadRequest();
        }

        _context.Entry(user).State = EntityState.Modified;

        try
        {
            await _context.SaveChangesAsync();
        }
        catch (DbUpdateConcurrencyException)
        {
            if (!UserExists(id))
            {
                return NotFound();
            }
            else
            {
                throw;
            }
        }

        return NoContent();
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> DeleteUser(int id)
    {
        var user = await _context.Users.FindAsync(id);
        if (user == null)
        {
            return NotFound();
        }

        _context.Users.Remove(user);
        await _context.SaveChangesAsync();

        return NoContent();
    }

    private bool UserExists(int id)
    {
        return _context.Users.Any(e => e.Id == id);
    }
}

Step 8: Run the Application

To manage postgreSQL databases, I use the pgAdmin 4, so you can see here an example of a user:

And that's it guys, a very very very simple case of postgreSQL integration with .net, there's still plenty more to learn, I hope you liked it, stay tuned for more!

First experience with graphQL

VzlDev — Thu, 27 Jun 2024 10:14:58 +0000

As developers, we're constantly seeking efficient and flexible ways to manage data and interactions in our applications. For many years, RESTful APIs have been the standard for handling these interactions. However, a new contender has emerged in recent years, promising more flexibility and efficiency: GraphQL.

What is GraphQL?

GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. GraphQL provides a complete and understandable description of the data in your API, gives clients the power to ask for exactly what they need and nothing more, makes it easier to evolve APIs over time, and enables powerful developer tools.

Key Features of GraphQL:

Declarative Data Fetching: Clients can request exactly the data they need, and nothing more.
Single Endpoint: All interactions are routed through a single endpoint, simplifying network architecture.
Strongly Typed Schema: The API's schema is defined using types, ensuring clients know exactly what data is available and how it can be used.

Setting Up GraphQL with .NET

To give you a practical taste, let's set up a simple GraphQL API.

Step 1: Install Required Packages

First, install the necessary NuGet packages:

GraphQL
GraphQL.Server.Transports.AspNetCore
GraphQL.Server.Ui.GraphiQL

Step 2: Define Your Data Models

Create your data models. For instance, let's define Author and Book models:

public class Author
{
    public int Id { get; set; }
    public string Name { get; set; }
    public List<Book> Books { get; set; }
}

public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    public int AuthorId { get; set; }
    public Author Author { get; set; }
}

Step 3: Create Your DbContext

Define your LibraryContext:

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

    public DbSet<Book> Books { get; set; }
    public DbSet<Author> Authors { get; set; }
}

Step 4: Setup your repository

Create your repository class:

public interface ILibraryRepository
{
    IEnumerable<Book> GetBooks();
    Book GetBookById(int id);
    Book AddBook(string title, int authorId);
    IEnumerable<Author> GetAuthors();

    Author GetAuthorById(int id);

    Author AddAuthor(Author author);
}

public class LibraryRepository : ILibraryRepository
{
    private readonly LibraryContext _context;

    public LibraryRepository(LibraryContext context)
    {
        _context = context;
    }

    public IEnumerable<Book> GetBooks() => _context.Books.Include(b => b.Author).ToList();

    public Book GetBookById(int id) => _context.Books.Include(b => b.Author).FirstOrDefault(b => b.Id == id);

    public Book AddBook(string title, int authorId)
    {
        var book = new Book { Title = title, AuthorId = authorId };
        _context.Books.Add(book);
        _context.SaveChanges();
        return book;
    }

    public IEnumerable<Author> GetAuthors() => _context.Authors.Include(a => a.Books).ToList();

    public Author GetAuthorById(int id) => _context.Authors.Include(a => a.Books).FirstOrDefault(b => b.Id == id);

    public Author AddAuthor(Author author)
    {
        _context.Authors.Add(author);
        _context.SaveChanges();
        return author;
    }
}

Step 5: Set Up GraphQL Types

Create GraphQL types:

public class AuthorType : ObjectGraphType<Author>
{
    public AuthorType()
    {
        Field(x => x.Id);
        Field(x => x.Name);
        Field<ListGraphType<BookType>>("books", resolve: context => context.Source.Books);
    }
}


public class BookType : ObjectGraphType<Book>
{
    public BookType()
    {
        Field(x => x.Id);
        Field(x => x.Title);
        Field<AuthorType>("author", resolve: context => context.Source.Author);
    }
}

Step 6: Define Queries and Mutations

public class LibraryQuery : ObjectGraphType
{
    public LibraryQuery(ILibraryRepository repository)
    {
        Field<ListGraphType<BookType>>(
            "books",
            resolve: context => repository.GetBooks());

        Field<BookType>(
            "book",
            arguments: new QueryArguments(new QueryArgument<IntGraphType> { Name = "id" }),
            resolve: context => repository.GetBookById(context.GetArgument<int>("id")));

        Field<ListGraphType<AuthorType>>(
            "authors",
            resolve: context => repository.GetAuthors());

        Field<AuthorType>(
            "author",
            arguments: new QueryArguments(new QueryArgument<IntGraphType> { Name = "id" }),
            resolve: context => repository.GetAuthorById(context.GetArgument<int>("id")));
    }
}

public class LibraryMutation : ObjectGraphType
{
    public LibraryMutation(ILibraryRepository repository)
    {
        Field<BookType>(
            "addBook",
            arguments: new QueryArguments(
                new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "title" },
                new QueryArgument<NonNullGraphType<IntGraphType>> { Name = "authorId" }),
            resolve: context =>
            {
                var title = context.GetArgument<string>("title");
                var authorId = context.GetArgument<int>("authorId");
                return repository.AddBook(title, authorId);
            });

        Field<AuthorType>(
            "addAuthor",
            arguments: new QueryArguments(
                new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "name" }),
            resolve: context =>
            {
                var name = context.GetArgument<string>("name");
                var author = new Author
                {
                    Name = name,
                    Books = new List<Book>() // Initialize books list as needed
                };
                return repository.AddAuthor(author);
            });
    }
}

Step 7: Define Schema

public class LibrarySchema : Schema
{
    public LibrarySchema(IServiceProvider provider) : base(provider)
    {
        Query = provider.GetRequiredService<LibraryQuery>();
        Mutation = provider.GetRequiredService<LibraryMutation>();
    }
}

Step 8: Configure program.cs

In your program.cs file add the following:

var connectionString = builder.Configuration.GetConnectionString("LibraryContext");
builder.Services.AddDbContext<LibraryContext>(options =>
        options.UseSqlServer(connectionString));

builder.Services.AddScoped<ILibraryRepository, LibraryRepository>();

builder.Services.AddScoped<BookType>();
builder.Services.AddScoped<AuthorType>();
builder.Services.AddScoped<LibraryQuery>();
builder.Services.AddScoped<LibraryMutation>();
builder.Services.AddScoped<ISchema, LibrarySchema>();

builder.Services.AddGraphQL(b => b.AddSystemTextJson());

pp.UseGraphQL<ISchema>();
app.UseGraphQLGraphiQL();

Step 9: Test API

To test the graphQL API, I used GraphiQL. You must run your api and append '/ui/graphiql' to the API url to launch the playground.

An example of a mutation:

An example of a query:

And that's it guys, a simple use of graphQL, I hope you liked it, stay tuned for more!

First experience with gRPC

VzlDev — Fri, 21 Jun 2024 14:30:34 +0000

I heard some colleagues talking about gRPC framework and its benefits and advantages regarding Rest, so I dig a little in the gRPC world and its concepts to learn new ways to develop an API.

What is gRPC?

gRPC is an open-source API architecture and system. It’s based on the Remote Procedure Call (RPC) model. While the RPC model is broad, gRPC is a specific implementation.
gRPC is a system that implements traditional RPC with several optimizations. For instance, gRPC uses Protocol Buffers and HTTP 2 for data transmission. It also abstracts the data exchange mechanism from the developer.

gRPC vs REST

The following image compares the basics of REST APIs and gRPC:

Implementation

To better learn the gRPC concepts, I created a simple chat room scenario.

Project Setup

We'll create two projects within a solution:

ChatAppServer: The gRPC server that handles chat room logic.
ChatAppClient: The client application that users will run to join chat rooms and send messages (This is a console App project).

Then we'll install the following nuget packages:

Grpc.AspNetCore
Grpc.Tools
Grpc.AspNetCore.Server.ClientFactory (this one only on the ChatAppClient project)

Proto file

We'll need to create a '.proto' file to define the gRPC service. This file specifies the service methods and message types.
This is my chat.proto file:

syntax = "proto3";

option csharp_namespace = "ChatApp";

package chat;

service ChatService {
  rpc JoinRoom (JoinRoomRequest) returns (JoinRoomResponse);
  rpc SendMessage (SendMessageRequest) returns (SendMessageResponse);
  rpc ReceiveMessages (ReceiveMessagesRequest) returns (stream ChatMessage);
}

message JoinRoomRequest {
  string username = 1;
  string room = 2;
}

message JoinRoomResponse {
  bool success = 1;
}

message SendMessageRequest {
  string username = 1;
  string room = 2;
  string message = 3;
}

message SendMessageResponse {
  bool success = 1;
}

message ReceiveMessagesRequest {
  string room = 1;
}

message ChatMessage {
  string username = 1;
  string message = 2;
  int64 timestamp = 3;
}

We have to include the .proto file on the .csproj so we can enable the code generator, so on the ChatAppServer.csproj file add the following:

<ItemGroup>
  <Protobuf Include="Protos\chat.proto" GrpcServices="Server" />
</ItemGroup>

And on the ChatAppClient.csproj add the following:

<ItemGroup>
  <Protobuf Include="Protos\chat.proto" GrpcServices="Client" />
</ItemGroup>

After this, if we clean, restore and build the projects, the code will be generated and you can check it out on the path "obj\Debug\net6.0\Protos".

Implement the server

In the server project, implement the ChatService.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading.Tasks;
using ChatApp;
using Grpc.Core;
using Microsoft.Extensions.Logging;

namespace ChatAppServer.Services
{
    public class ChatServiceImpl : ChatService.ChatServiceBase
    {
        private static readonly ConcurrentDictionary<string, List<IServerStreamWriter<ChatMessage>>> _rooms = new ConcurrentDictionary<string, List<IServerStreamWriter<ChatMessage>>>();

        public override Task<JoinRoomResponse> JoinRoom(JoinRoomRequest request, ServerCallContext context)
        {
            if (!_rooms.ContainsKey(request.Room))
            {
                _rooms[request.Room] = new List<IServerStreamWriter<ChatMessage>>();
            }
            return Task.FromResult(new JoinRoomResponse { Success = true });
        }

        public override Task<SendMessageResponse> SendMessage(SendMessageRequest request, ServerCallContext context)
        {
            if (_rooms.TryGetValue(request.Room, out var clients))
            {
                var message = new ChatMessage
                {
                    Username = request.Username,
                    Message = request.Message,
                    Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
                };

                foreach (var client in clients)
                {
                    client.WriteAsync(message);
                }
            }
            return Task.FromResult(new SendMessageResponse { Success = true });
        }

        public override async Task ReceiveMessages(ReceiveMessagesRequest request, IServerStreamWriter<ChatMessage> responseStream, ServerCallContext context)
        {
            if (_rooms.TryGetValue(request.Room, out var clients))
            {
                clients.Add(responseStream);
                try
                {
                    await Task.Delay(Timeout.Infinite, context.CancellationToken);
                }
                finally
                {
                    clients.Remove(responseStream);
                }
            }
        }
    }
}

And we need to add the following on the Progra.cs file:

builder.Services.AddGrpc();
app.MapGrpcService<ChatServiceImpl>();

Implement the client

Modify the Program.cs file of the client project:

using System;
using System.Threading.Tasks;
using Grpc.Net.Client;
using ChatApp;
using Grpc.Core;

class Program
{
    static async Task Main(string[] args)
    {
        // Create a channel to the gRPC server
        var channel = GrpcChannel.ForAddress("https://localhost:7187");
        var client = new ChatService.ChatServiceClient(channel);

        Console.WriteLine("Enter your username:");
        var username = Console.ReadLine();

        Console.WriteLine("Enter the room you want to join:");
        var room = Console.ReadLine();

        // Join the specified room
        var joinResponse = await client.JoinRoomAsync(new JoinRoomRequest
        {
            Username = username,
            Room = room
        });

        if (joinResponse.Success)
        {
            Console.WriteLine($"Joined room: {room}");
        }
        else
        {
            Console.WriteLine("Failed to join room");
            return;
        }

        // Task for receiving messages
        var receiveTask = Task.Run(async () =>
        {
            using var call = client.ReceiveMessages(new ReceiveMessagesRequest { Room = room });
            await foreach (var message in call.ResponseStream.ReadAllAsync())
            {
                Console.WriteLine($"[{message.Username}] {message.Message}");
            }
        });

        // Loop to send messages
        while (true)
        {
            var message = Console.ReadLine();
            if (message.ToLower() == "exit") break;

            var sendMessageResponse = await client.SendMessageAsync(new SendMessageRequest
            {
                Username = username,
                Room = room,
                Message = message
            });

            if (!sendMessageResponse.Success)
            {
                Console.WriteLine("Failed to send message");
            }
        }

        // Wait for the receiving task to complete
        await receiveTask;
    }
}

Running the application

Use the dotnet run command to run the projects.
Open 2 terminals of clients to interact with each other.

Conclusion

This is still a very simple case of implementing gRPC framework to develop an API, and I still have a lot to work on and learn about this, I'm very excited!

And that's it guys, I hope you liked it, stay tuned for more!

First experience with gRPC

VzlDev — Fri, 21 Jun 2024 14:30:34 +0000

I heard some colleagues talking about gRPC framework and its benefits and advantages regarding Rest, so I dig a little in the gRPC world and its concepts to learn new ways to develop an API.

What is gRPC?

gRPC vs REST

The following image compares the basics of REST APIs and gRPC:

Implementation

To better learn the gRPC concepts, I created a simple chat room scenario.

Project Setup

We'll create two projects within a solution:

ChatAppServer: The gRPC server that handles chat room logic.
ChatAppClient: The client application that users will run to join chat rooms and send messages (This is a console App project).

Then we'll install the following nuget packages:

Grpc.AspNetCore
Grpc.Tools
Grpc.AspNetCore.Server.ClientFactory (this one only on the ChatAppClient project)

Proto file

We'll need to create a '.proto' file to define the gRPC service. This file specifies the service methods and message types.
This is my chat.proto file:

syntax = "proto3";

option csharp_namespace = "ChatApp";

package chat;

service ChatService {
  rpc JoinRoom (JoinRoomRequest) returns (JoinRoomResponse);
  rpc SendMessage (SendMessageRequest) returns (SendMessageResponse);
  rpc ReceiveMessages (ReceiveMessagesRequest) returns (stream ChatMessage);
}

message JoinRoomRequest {
  string username = 1;
  string room = 2;
}

message JoinRoomResponse {
  bool success = 1;
}

message SendMessageRequest {
  string username = 1;
  string room = 2;
  string message = 3;
}

message SendMessageResponse {
  bool success = 1;
}

message ReceiveMessagesRequest {
  string room = 1;
}

message ChatMessage {
  string username = 1;
  string message = 2;
  int64 timestamp = 3;
}

We have to include the .proto file on the .csproj so we can enable the code generator, so on the ChatAppServer.csproj file add the following:

<ItemGroup>
  <Protobuf Include="Protos\chat.proto" GrpcServices="Server" />
</ItemGroup>

And on the ChatAppClient.csproj add the following:

<ItemGroup>
  <Protobuf Include="Protos\chat.proto" GrpcServices="Client" />
</ItemGroup>

After this, if we clean, restore and build the projects, the code will be generated and you can check it out on the path "obj\Debug\net6.0\Protos".

Implement the server

In the server project, implement the ChatService.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading.Tasks;
using ChatApp;
using Grpc.Core;
using Microsoft.Extensions.Logging;

namespace ChatAppServer.Services
{
    public class ChatServiceImpl : ChatService.ChatServiceBase
    {
        private static readonly ConcurrentDictionary<string, List<IServerStreamWriter<ChatMessage>>> _rooms = new ConcurrentDictionary<string, List<IServerStreamWriter<ChatMessage>>>();

        public override Task<JoinRoomResponse> JoinRoom(JoinRoomRequest request, ServerCallContext context)
        {
            if (!_rooms.ContainsKey(request.Room))
            {
                _rooms[request.Room] = new List<IServerStreamWriter<ChatMessage>>();
            }
            return Task.FromResult(new JoinRoomResponse { Success = true });
        }

        public override Task<SendMessageResponse> SendMessage(SendMessageRequest request, ServerCallContext context)
        {
            if (_rooms.TryGetValue(request.Room, out var clients))
            {
                var message = new ChatMessage
                {
                    Username = request.Username,
                    Message = request.Message,
                    Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
                };

                foreach (var client in clients)
                {
                    client.WriteAsync(message);
                }
            }
            return Task.FromResult(new SendMessageResponse { Success = true });
        }

        public override async Task ReceiveMessages(ReceiveMessagesRequest request, IServerStreamWriter<ChatMessage> responseStream, ServerCallContext context)
        {
            if (_rooms.TryGetValue(request.Room, out var clients))
            {
                clients.Add(responseStream);
                try
                {
                    await Task.Delay(Timeout.Infinite, context.CancellationToken);
                }
                finally
                {
                    clients.Remove(responseStream);
                }
            }
        }
    }
}

And we need to add the following on the Progra.cs file:

builder.Services.AddGrpc();
app.MapGrpcService<ChatServiceImpl>();

Implement the client

Modify the Program.cs file of the client project:

using System;
using System.Threading.Tasks;
using Grpc.Net.Client;
using ChatApp;
using Grpc.Core;

class Program
{
    static async Task Main(string[] args)
    {
        // Create a channel to the gRPC server
        var channel = GrpcChannel.ForAddress("https://localhost:7187");
        var client = new ChatService.ChatServiceClient(channel);

        Console.WriteLine("Enter your username:");
        var username = Console.ReadLine();

        Console.WriteLine("Enter the room you want to join:");
        var room = Console.ReadLine();

        // Join the specified room
        var joinResponse = await client.JoinRoomAsync(new JoinRoomRequest
        {
            Username = username,
            Room = room
        });

        if (joinResponse.Success)
        {
            Console.WriteLine($"Joined room: {room}");
        }
        else
        {
            Console.WriteLine("Failed to join room");
            return;
        }

        // Task for receiving messages
        var receiveTask = Task.Run(async () =>
        {
            using var call = client.ReceiveMessages(new ReceiveMessagesRequest { Room = room });
            await foreach (var message in call.ResponseStream.ReadAllAsync())
            {
                Console.WriteLine($"[{message.Username}] {message.Message}");
            }
        });

        // Loop to send messages
        while (true)
        {
            var message = Console.ReadLine();
            if (message.ToLower() == "exit") break;

            var sendMessageResponse = await client.SendMessageAsync(new SendMessageRequest
            {
                Username = username,
                Room = room,
                Message = message
            });

            if (!sendMessageResponse.Success)
            {
                Console.WriteLine("Failed to send message");
            }
        }

        // Wait for the receiving task to complete
        await receiveTask;
    }
}

Running the application

Use the dotnet run command to run the projects.
Open 2 terminals of clients to interact with each other.

Conclusion

This is still a very simple case of implementing gRPC framework to develop an API, and I still have a lot to work on and learn about this, I'm very excited!

And that's it guys, I hope you liked it, stay tuned for more!

Use Kafka in your Web Api

VzlDev — Fri, 14 Jun 2024 17:34:26 +0000

Hello guys!
Today I challenged myself to learn a little bit about event streaming, so I created an example using Kafka.

What is event streaming?

Event streaming is the practice of capturing data in real-time from event sources like databases, sensors, mobile devices, cloud services, and software applications in the form of streams of events; storing these event streams durably for later retrieval; manipulating, processing, and reacting to the event streams in real-time as well as retrospectively; and routing the event streams to different destination technologies as needed. (https://kafka.apache.org/intro)

What is Kafka?

Kafka is an event streaming platform, that allows:

Write/read data.
Store data.
Process data.

Key Kafka Concepts

Event, the events in a nutshell are the data that we'll store. It can also be called record or message. When you read or write data to Kafka, you do this in the form of events.
Topic, is the place where the events will be stored.
Producers are those client applications that publish (write) events to Kafka
Consumersare those that subscribe to (read and process) events

In my project, i made changes to my EventsAPI, so that now when a user is registered in an event, i will store some data in a topic, that a new LogsApi will read and store in a db.

Using Kafka step by step

Step 1

To start using Kafka I recommend using an image container and run that image in the docker container.
After you pull the image, run it.

Step 2

In your Producer and Consumer API install the following nuget package:

Confluent.Kafka

Step 3

Update your producer api to write data to a kafka topic:

[Route("[controller]")]
[ApiController]
public class EventEnrollmentController : ControllerBase
{
    protected IEventsRepository _repository;
    private readonly IProducer<string, string> _producer;

    public EventEnrollmentController(IEventsRepository repository)
    {
        _repository = repository;
        var config = new ProducerConfig { BootstrapServers = "localhost:9092" };
        _producer = new ProducerBuilder<string, string>(config).Build();
    }

    [HttpPut("{eventId}/register")]
    public async Task<ActionResult<bool>> AddUserToEvent(Guid userId, Guid eventId)
    {
        Event evento = await _repository.GetEventById(eventId);

        if (evento == null)
        {
            return NotFound();
        }

        evento.Users.Add(userId);

        LogEntry log = new LogEntry()
        {
            Id = Guid.NewGuid(),
            EventTitle = evento.Title,
            UserId = userId,
            RegistrationTime = DateTime.UtcNow,
        };

        await _producer.ProduceAsync("user-event-registrations", new Message<string, string>
        {
            Key = "UserEventRegistered",
            Value = JsonConvert.SerializeObject(log)
        });

        return await _repository.UpdateEvent(evento);
    }
}

In this case, a topic called user-event-registrations is created.

Step 4

On your consumer API, do the following changes, so it will consume data of the user-event-registrations topic

public class LogService : BackgroundService
{
    private readonly IServiceProvider _serviceProvider;
    private readonly IConsumer<string, string> _consumer;
    private readonly ILogger<LogService> _logger;

    public LogService(IServiceProvider serviceProvider, ILogger<LogService> logger)
    {
        _serviceProvider = serviceProvider;
        _logger = logger;

        var config = new ConsumerConfig
        {
            GroupId = "log-group",
            BootstrapServers = "localhost:9092",
            AutoOffsetReset = AutoOffsetReset.Earliest
        };
        _consumer = new ConsumerBuilder<string, string>(config).Build();
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _consumer.Subscribe("user-event-registrations");

        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                var consumeResult = _consumer.Consume(stoppingToken);
                var registration = JsonConvert.DeserializeObject<LogEntry>(consumeResult.Message.Value);

                using (var scope = _serviceProvider.CreateScope())
                {
                    var context = scope.ServiceProvider.GetRequiredService<LogContext>();

                    context.LogEntries.Add(registration);
                    await context.SaveChangesAsync(stoppingToken);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error processing Kafka message.");
            }
        }
    }
}

Don't forget to add the dependencies to your Program.cs file.

And that's it guys, a simple use case of event streaming using Kafka. I hope you liked it, stay tuned for more!

Create a API Gateway using Ocelot

VzlDev — Fri, 14 Jun 2024 17:10:30 +0000

Hello guys!
Today I challenged myself to learn a little bit about Api Gateway, so I created one in my project using Ocelot.

What is an API Gateway?

An API gateway is a server that acts as an intermediary between clients and backend services. It functions as a reverse proxy to accept all application programming interface (API) calls, aggregate the various services required to fulfill them, and return the appropriate result.

What is Ocelot?

Ocelot is an open-source API Gateway built on the .NET platform. It is designed to manage and secure the flow of traffic between clients and backend services, particularly in microservices architectures. Ocelot provides a range of features to facilitate the handling of API requests and responses.

How to create an API Gateway using Ocelot step by step?

Step 1

First of all, you need to set up 2 different API's, in my project I created an UsersAPI and an EventsAPI
I have the following endpoints for the 2 controllers:

Step 2

Next you'll need to create a new api for the gateway, and do not add any controller.

Step 3

Add the Ocelot package to your gateway api.

Step 4

Create a file named ocelot.json in your gateway api.
Here's mine:

{
  "Routes": [
    {
      "DownstreamPathTemplate": "/users/{everything}",
      "DownstreamScheme": "https",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": 7239
        }
      ],
      "UpstreamPathTemplate": "/api/users/{everything}",
      "UpstreamHttpMethod": [ "GET", "POST", "PUT", "DELETE" ]
    },
    {
      "DownstreamPathTemplate": "/events/{everything}",
      "DownstreamScheme": "https",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": 7235
        }
      ],
      "UpstreamPathTemplate": "/api/events/{everything}",
      "UpstreamHttpMethod": [ "GET", "POST", "PUT", "DELETE" ]
    }
  ],
  "GlobalConfiguration": {
    "BaseUrl": "https://localhost:7174"
  }
}

In the GlobalConfiguration section, the BaseUrl is the URL of the API Gateway. When running the API Gateway it will run on this base URL and the users will interact with this URL.
The UpStreamPathTemplate section represents the API Gateway endpoint, this will be the public endpoint for the users to ping.
The DownStreamTemplate section represents the APIs endpoints.

By the above configuration, when you hit the endpoint http://localhost:7174/api/events, it will be redirected to API endpoint http://localhost:7235/Events

Step 5

In your program.cs file, add the following:

builder.Configuration.AddJsonFile("ocelot.json", optional: false, reloadOnChange: true);

builder.Services.AddOcelot(builder.Configuration);

app.UseOcelot();

Step 6

Try yourself and enjoy!

And that's it guys, a simple use case of using an api gateway with ocelot. I hope you liked it, stay tuned for more!

Create a Web API with MongoDB

VzlDev — Fri, 14 Jun 2024 16:45:18 +0000

Hello guys!
Today I challenged myself to learn a little bit about MongoDB, so I created an API that will connect to a MongoDB database.

What is MongoDB?

MongoDB is a NOSQL database and NOSQL means "Not Only SQL". This is because MongoDB is not only a relational database. NOSQL can store unstructured data.

MongoDB is a document database. It stores data in a type of JSON format called BSON. A record in MongoDB is a document, which is a data structure composed of key value pairs similar to the structure of JSON objects.
And this documents are stored in collections (you can compare a collection like as a table in SQL Relational databases). And all this collections are stored in a database!

MongoDB Setup

To start using MongoDB the first thing that you need is the MongoDB "engine". For that I recommend using a image container and run that image in the docker container.

After pull the image and run it, you need a way to interact with the database. I used MongoDB Compass.

MongoDB integration

To integrate your MongoDB database with your .NET API, you'll need to install the following nuget package:

MongoDB.Driver

I have in the Model folder a Event class that represent the document in MongoDB.
Important thing to notice here is there is specific Data Annotations to handle MongoDB data.

public class Event
{
    [BsonId]
    public Guid EventId { get; set; }

    [BsonElement("title")]
    public string Title { get; set; }

    [BsonElement("description")]
    public string Description { get; set; }

    [BsonElement("location")]
    public string Location { get; set; }

    [BsonElement("date")]
    public DateTime Date { get; set; }

    [BsonElement("users")]
    public List<Guid> Users { get; set; } // List of users associated with the event
}

The next thing you need is to establish connection to the MongoDB. In this example I create a factory class to do that.

public class MongoDbConnection : IMongoDbConnection
{
    private readonly IConfiguration _configuration;

    public MongoDbConnection(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    public IMongoDatabase GetDatabase()
    {
        var connectionString = _configuration.GetSection("MyDb").GetValue<string>("ConnectionString");
        var databaseName = _configuration.GetSection("MyDb").GetValue<string>("DatabaseName");

        var url = MongoUrl.Create(connectionString);
        var client = new MongoClient(url);
        var database = client.GetDatabase(databaseName);

        return database;
    }
}

And on the appsettings.json file, I added the connection string:

"MyDb": {
  "ConnectionString": "mongodb://localhost:27017",
  "DatabaseName": "Eventsdb",
  "EventsCollectionName": "events"
}

I created a repository class to interact with the database:

public class EventsRepository : IEventsRepository
{
    private readonly IMongoDbConnection _connection;
    private readonly IMongoCollection<Event> _collection;

    public EventsRepository(IMongoDbConnection connection)
    {
        _connection = connection;

        var database = _connection.GetDatabase();
        _collection = database.GetCollection<Event>("events");
    }

    public async Task<bool> CreateEvent(Event evento)
    {
        try
        {
            await _collection.InsertOneAsync(evento);
            return true;
        }
        catch (Exception)
        {
            throw;
        }
    }

    public async Task<bool> DeleteEvent(Guid id)
    {
        var filterDefinition = Builders<Event>.Filter.Eq(a => a.EventId, id);
        var result = await _collection.DeleteOneAsync(filterDefinition);
        return result.DeletedCount > 0;
    }

    public async Task<List<Event>> GetAllEvents()
    {
        return await _collection.Find(Builders<Event>.Filter.Empty).ToListAsync();
    }

    public async Task<Event> GetEventById(Guid id)
    {
        var filterDefinition = Builders<Event>.Filter.Eq(a => a.EventId, id);
        return await _collection.Find(filterDefinition).FirstAsync();
    }

    public async Task<bool> UpdateEvent(Event evento)
    {
        var filterDefinition = Builders<Event>.Filter.Eq(a => a.EventId, evento.EventId);
        var result = await _collection.ReplaceOneAsync(filterDefinition, evento);
        return result.ModifiedCount > 0;
    }
}

And that's it guys, a simple use case of using a api with mongodb. I hope you liked it, stay tuned for more!

Redis Cache in .NET

VzlDev — Mon, 18 Mar 2024 11:33:01 +0000

Hello guys!

Today I'll demonstrate how to implement Redis Cache in a .NET project.

What is Redis Cache?

Redis is an open source (BSD licensed), in-memory data structure store that can be used as a database, cache, message broker, and streaming engine.

Why Redis?

All Redis data resides in memory, which enables low latency and high throughput data access. Unlike traditional databases, In-memory data stores don’t require a trip to disk, reducing engine latency to microseconds. Because of this, in-memory data stores can support an order of magnitude more operations and faster response times.
Easy to use.
High availability and scalability.
Open Source.
Flexible data structures.

Step 1

You need to configure your Redis server. For that you can download and run an image of Redis in a docker container.

Step 2

Once your Redis server is up and running you need to install the following nuget package

Microsoft.Extensions.Caching.StackExchangeRedis

Step 3

On the ConnectionStrings section of the appsettings.json file, add the following entry

 "ConnectionStrings": {
    "Redis" : "localhost:6379"
  },

Step 4

Then you need to configure your connection to the Redis server in the Program.cs file

builder.Services.AddStackExchangeRedisCache(redisOptions =>
{
    string connection = builder.Configuration.GetConnectionString("Redis");
    redisOptions.Configuration = connection;
});

Step 5

On your controller, you'll need to inject IDistributedCachevia Dependency Injection.

        private readonly IDistributedCache? _cache;

        public TvShowsController(TvShowContext context, IDistributedCache cache)
        {
            _context = context;
            _cache = cache;
        }

Step 6

Finally is time to store and retrieve values to and from your Redis Cache.

[HttpGet]
        public ActionResult<IEnumerable<TvShow>> GetTvShows()
        {
            string cachedData = _cache.GetString("cachedData");
            if (string.IsNullOrEmpty(cachedData))
            {
                var tvShows = _context.TvShows.ToList();
                string serializedObject = JsonConvert.SerializeObject(tvShows);
                _cache.SetString("cachedData", serializedObject, new DistributedCacheEntryOptions() { AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10) });
                return tvShows;
            }

            return JsonConvert.DeserializeObject<List<TvShow>>(cachedData);
        }

I hope you liked it, stay tuned for more!

Implementing Entity Framework: Code-First Approach

VzlDev — Fri, 15 Mar 2024 15:52:10 +0000

Hello guys! In this post I'm talk a little bit about Entity Framework (EF), and how to implement it using the code-first approach.

Entity Framework is an open-source object-relational mapping (ORM) framework for .NET applications developed by Microsoft. It simplifies the process of interaction with databases.

Why choosing Entity Framework?

Using EF has several advantages like:

Simplifies the interactions with databases.
Provides a high-level abstraction over the underlying database, hiding complex SQL queries.
Supports LINQ (Language Integrated Query).
Supports multiple database providers.

Lets start with the implementation of Entity Framework. For this tutorial I will use a scenario of TV Shows and store them in a db, with the possibility to execute CRUD operations on them.

Step 1

First of all you need to create a new .NET project.

Step 2

Install the Entity Framework Core in your project:

Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.Design
Microsoft.EntityFrameworkCore.SqlServer
Microsoft.EntityFrameworkCore.Tools

Step 3

Add the Connection string to the Appsettings.json

"ConnectionStrings": {
    "TvShowContext": "Server=(localdb)\\MSSQLLocalDB;Database=TvShows;Integrated Security=True;"
  }

Step 4

You need to create your model (for this tutorial only the TvShow.cs will be created)

public class TvShow
    {
        [Key]
        public int Id { get; set; }

        public string Name { get; set; }

        public double ImdbRating { get; set; }

        public TvShow()
        {
        }
    }

Step 5

When you complete the creation of your model, it's time to set up the database context. This is the class that will allow interactions with the database.

public partial class TvShowContext : DbContext
    {
        public TvShowContext(DbContextOptions
        <TvShowContext> options)
            : base(options)
        {
        }
        public DbSet<TvShow> TvShows { get; set; }
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<TvShow>(entity =>
            {
                entity.HasKey(k => k.Id);
            });
            OnModelCreatingPartial(modelBuilder);
        }
        partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
    }

Step 6

Now you need to update your Program.cs to add the database connection.

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();

//Add your connectionString and DBContext
var connectionString = builder.Configuration.GetConnectionString("TvShowContext");
builder.Services.AddDbContext<TvShowContext>(options => options.UseSqlServer(connectionString));

builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

Step 7

In this step you will run the first database migration, to create your database and table if it doesn't exist.
Open the Package Manager Console in the Visual Studio and run the following command:

ADD-MIGRATION {MigrationName}

This command will create a new folder "Migrations" in your project containing the migration files.

Now that the migration is created you must apply the migration to the database using the following command:

Update-Database

Now you can go check the changes to your database.

Step 8

Now that you have all set up, it's time to create your controller to handle the requests for CRUD operations.

[Route("[controller]")]
    [ApiController]
    public class TvShowsController : ControllerBase
    {
        private readonly TvShowContext _context;

        public TvShowsController(TvShowContext context)
        {
            _context = context;
        }

        [HttpGet]
        public ActionResult<IEnumerable<TvShow>> GetTvShows()
        {
            return _context.TvShows.ToList();
        }

        [HttpGet("{id}")]
        public ActionResult<TvShow> GetTvShow(int id)
        {
            var tvshow = _context.TvShows.Find(id);
            if (tvshow == null)
            {
                return NotFound();
            }
            return tvshow;
        }

        [HttpPost]
        public ActionResult<TvShow> CreateTvShow(TvShow tvShow)
        {
            if (tvShow == null)
            {
                return BadRequest();
            }
            _context.TvShows.Add(tvShow);
            _context.SaveChanges();
            return Ok();
        }

        [HttpDelete("{id}")]
        public ActionResult DeleteTvShow(int id)
        {
            var tvshow = _context.TvShows.Find(id);
            if (tvshow == null)
            {
                return NotFound();
            }
            _context.TvShows.Remove(tvshow);
            _context.SaveChanges();
            return NoContent();
        }

        [HttpPut("{id}")]
        public ActionResult<TvShow> UpdateTvShow(int id, TvShow tvShow)
        {
            var existingTvShow = _context.TvShows.Find(id);
            if (existingTvShow == null)
            {
                return NotFound();
            }

            existingTvShow.Name = tvShow.Name;
            existingTvShow.ImdbRating = tvShow.ImdbRating;

            _context.SaveChanges();
            return NoContent();
        }

Step 9

Finally you can run your projects and use postman to do your requests, like for example:

I hope you liked it, stay tuned for more!

Bridge Pattern

VzlDev — Fri, 15 Mar 2024 10:36:36 +0000

Hello, today i'm gonna talk about a structural design pattern, more specifically about the Bridge design pattern and its advantages.

The Bridge Pattern decouples an abstraction from its implementation, allowing them to vary independently. It is particularly useful when there are multiple dimensions of variability in a system. The pattern achieves this by creating two separate class hierarchies: one for the abstraction and another for the implementation. These hierarchies are then connected by composition rather than inheritance.

Let's imagine that we go watch a movie, and the cinema have a promotion that is selling movie licenses, and we have the option to buy a 2 days movie license and a lifetime movie license. In top of that when purchasing these licenses, discounts may be applied, such as "Military discount" and "Senior Discount".
So right now our code structure would look like this:

But that doesn't seem correct. If the cinema wants to introduce here a 5 day movie license or imagine, a discount for students and another for their own workers, the code structure would be very confuse and hard to maintain.
So we have to separate our concerns and divide the movie license and the movie discount, and our code structure should be something like this:

This way is very easy to maintain our code and to introduce new licenses or discounts.