In-depth polling in.NET
A method for achieving real-time communication between a client and a server is called long polling. Long polling lowers latency and boosts efficiency by keeping the connection open until the server has new data to share, in contrast to regular polling, which involves the client requesting updates from the server often. We'll look at how to add lengthy polling for real-time updates to a.NET application in this blog post.

Benefits of Long Polling

• Real-Time Updates: Long polling allows for near-real-time communication between clients and servers, enabling instant updates and notifications.
• Reduced Latency: By keeping connections open until new data is available, long polling reduces latency compared to traditional polling techniques.
• Efficiency: Long polling minimizes unnecessary requests and server load by only retrieving data when updates are available.
• Simplicity: Implementing long polling in .NET is straightforward and requires minimal configuration, making it accessible for developers.

Use Cases

• Chat Applications: Long polling is commonly used in chat applications to deliver messages and notifications to users in real time.
• Live Updates: Websites or applications that require live updates, such as stock tickers, news feeds, or sports scores, can benefit from long polling.
• Collaborative Tools: Long polling enables collaborative editing tools, where multiple users can see changes made by others in real time.

Drawbacks of Long polling

• Connection Overhead: Long polling requires maintaining open connections, which can lead to increased server resource consumption and potential scalability challenges.
• Resource Consumption: Long-lived connections may tie up server resources, impacting the overall performance and scalability of the application.
• Timeouts: If a long-polling request times out before new data is available, the client must initiate a new request, potentially introducing delays.

Avoiding Drawbacks

• Connection Pooling: Use connection pooling to efficiently manage long-lived connections and prevent resource exhaustion on the server.
• Timeout Management: Implement appropriate timeout settings to ensure that long-polling requests do not remain open indefinitely, balancing responsiveness with resource usage.
• Scalability Planning: Monitor server performance and scalability to identify potential bottlenecks and optimize resource allocation as needed.

Alternatives

• WebSockets: WebSockets provide full-duplex communication channels over a single, long-lived connection, offering real-time, bi-directional communication between clients and servers.
• Server-Sent Events (SSE): SSE is a standard allowing servers to push updates to clients over HTTP connections, providing a simpler alternative to WebSockets for one-way communication.

1. Setting Up a .NET Web Application
Initiate a new.NET web application project using your IDE of choice. ASP.NET Core can be used to create a contemporary, cross-platform online application.
dotnet new web -n LongPollingDemo
cd LongPollingDemo

2. Implementing Long Polling Controller
In order to manage lengthy polling requests from clients, create a controller in your.NET application.
using Microsoft.AspNetCore.Mvc;
using System;
using System.Threading;
using System.Threading.Tasks;

[Route("api/[controller]")]
[ApiController]
public class UpdatesController : ControllerBase
{
    [HttpGet]
    public async Task<IActionResult> LongPoll()
    {
        // Simulate long-running operation
        await Task.Delay(5000);

        // Generate random data or fetch updates from database
        var randomUpdate = new { Message = $"Update received at {DateTime.UtcNow}" };

        return Ok(randomUpdate);
    }
}

3. Client-Side Implementation
Implement a lengthy polling mechanism on the client side (using JavaScript, for example) to make many requests for updates from the server.
function longPoll() {
    fetch('/api/updates')
        .then(response => response.json())
        .then(data => {
            // Process received update
            console.log(data);
            // Initiate next long poll request
            longPoll();
        })
        .catch(error => {
            console.error('Long poll request failed', error);
            // Retry long poll after a delay
            setTimeout(longPoll, 3000);
        });
}

// Start long polling
longPoll();

4. Configuring Server-Side Settings
Make sure the server-side program is set up to deal with timeouts and persistent connections in the right way. Modify the server configuration to support extended polling requests without disconnecting connections too soon.

5. Testing and Deployment
Test your long polling implementation locally to verify real-time updates between the client and server. Once tested, deploy your .NET web application to a production environment to provide real-time communication capabilities to users.

Conclusion
By implementing long polling in a .NET web application, you can achieve real-time communication between clients and servers, enabling instant updates and notifications without the overhead of constant polling. Long polling is particularly useful for applications requiring timely updates, such as chat applications, real-time monitoring dashboards, and collaborative editing tools. With the flexibility and scalability of .NET, you can build robust and responsive web applications that meet the demands of modern users.

A common option in.NET 8 for creating and running unit tests in C# is the xUnit testing framework, which is essential to the software development process. In this thorough tutorial, we will go over key ideas and offer code samples as we examine the foundations of unit testing using xUnit.

Establishing a Model Project
The first step is to use xUnit to construct a small console application in C# and a unit test project for it.

# Create a new console application
dotnet new console -n PeterConsoleApp

# Create a new xUnit test project
dotnet new xunit -n PeterConsoleApp.Tests

Write Our Console Application
We just printed this article's title and my name, Peter, in the Program.cs file. as demonstrated by the code example below.

Console.WriteLine("Hi and Welcome to Peter Article on Unit Testing with xUnit in .NET 8: A Comprehensive Guide");

Create Our Calculator Class
We just create a simple Calculator class with simple functions such as Add, Subtract, Multiply, Divide, and the key one Dispose of as the code example below.
namespace PeterConsoleApp
{
    public class Calculator : IDisposable
    {
        // Add method
        public int Add(int a, int b)
        {
            return a + b;
        }

        // Subtract method
        public int Subtract(int a, int b)
        {
            return a - b;
        }

        // Multiply method
        public int Multiply(int a, int b)
        {
            return a * b;
        }

        // Divide method
        public double Divide(int a, int b)
        {
            if (b == 0)
            {
                throw new ArgumentException("Cannot divide by zero.");
            }

            return (double)a / b;
        }

        private bool disposed = false;

        protected virtual void Dispose(bool disposing)
        {
            if (!disposed)
            {
                if (disposing)
                {
                    // Dispose of managed resources here go here
                }

                // Dispose of unmanaged resources goes here , if any
                disposed = true;
            }
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        ~Calculator()
        {
            Dispose(false);
        }
    }
}

Data Source
We will create two files for our Data Source one is an interface and the other is a class as code example below.
namespace PeterConsoleApp
{
    public interface IDataSource
    {
        string GetData();
    }
}

namespace PeterConsoleApp
{
    public class DataService
    {
        private readonly IDataSource _dataSource;

        public DataService(IDataSource dataSource)
        {
            _dataSource = dataSource;
        }

        public string ProcessData()
        {
            return _dataSource.GetData().ToUpper();
        }
    }
}

Now we are all set to create our Unit Tests 😊

Writing Our First Test
Our preferred code editor should open the PeterConsoleApp.Tests project. XUnit automatically creates a test file named UnitTest1.cs. To replace UnitTest1.cs with the following code example, please refer to the below code example. As an example, we will create a simple test method named TestAddition. The [Fact] attribute indicates that this method is a test.
namespace PeterConsoleApp.Tests
{
    public class PeterConsoleAppTests
    {
        [Fact]
        public void TestAddition()
        {
           // Arrange
           int a = 2;
           int b = 3;

           // Act
           int result = a + b;

           // Assert
           Assert.Equal(5, result);
        }
    }
}

Arrange
Putting the required things and circumstances in place.

Act
Executing the operation or calling the tested procedure.

Assert
Confirming that the outcome meets expectations.

Running the Tests
Now, let's run our unit tests.
# Navigate to the test project directory
cd PeterConsoleApp.Tests

# Run the tests
dotnet test
# Navigate to the test project directory
cd PeterConsoleApp.Tests

# Run the tests
dotnet test

There should be an output indicating that one test has been run and passed.

Writing More Tests
Let's add a few more tests to cover different scenarios. Let's replace UnitTest1.cs with the following code example. We will add a subtraction test and a parameterized multiplication test using the [Theory] and [InlineData] attributes.
namespace PeterConsoleApp.Tests
{
    public class PeterConsoleAppTests
    {
        [Fact]
        public void TestSubtraction()
        {
            // Arrange
            int a = 5;
            int b = 3;

            // Act
            int result = a - b;

            // Assert
            Assert.Equal(2, result);
        }

        [Theory]
        [InlineData(2, 3, 6)]
        [InlineData(5, 4, 20)]
        [InlineData(0, 7, 0)]
        public void TestMultiplication(int a, int b, int expected)
        {
            // Act
            int result = a * b;

            // Assert
            Assert.Equal(expected, result);
        }
    }
}

Advanced Concepts
Test Fixture
Generally, a test fixture contains one or more test methods. It can be used to share setup and cleanup code between tests.
namespace PeterConsoleApp
{
    public class CalculatorFixture : IDisposable
    {
        public Calculator Calculator { get; private set; }

        public CalculatorFixture()
        {
            // Initialize resources, create instances, etc.
            Calculator = new Calculator();
        }

        public void Dispose()
        {
            // Clean up resources, dispose of instances, etc.
            Calculator.Dispose();
        }
    }
}

namespace PeterConsoleApp.Tests
{
    public class CalculatorTests : IClassFixture<CalculatorFixture>
    {
        private readonly CalculatorFixture _fixture;

        public CalculatorTests(CalculatorFixture fixture)
        {
            _fixture = fixture;
        }

        [Fact]
        public void TestAddition()
        {
            // Arrange
            Calculator calculator = _fixture.Calculator;
            int a = 5;
            int b = 10;

            // Act
            int result = calculator.Add(a, b);

            // Assert
            Assert.Equal(15, result);
        }
    }
}

Mocking
The use of mocking libraries, such as Moq, can help isolate code units for testing.
using Moq;

namespace PeterConsoleApp.Tests;
public class DataServiceTests
{
    [Fact]
    public void TestDataProcessing()
    {
        // Arrange
        var mockDataSource = new Mock<IDataSource>();
        mockDataSource.Setup(d => d.GetData()).Returns("HELLO, I AM Peter");

        var dataService = new DataService(mockDataSource.Object);

        // Act
        string result = dataService.ProcessData();

        // Assert
        Assert.Equal("HELLO, I AM Peter", result);
    }
}

In this tutorial, we'll look at the StackLayout in.NET MAUI. If you are new to.NET MAUI, I recommend that you read the following topics in this series. StackLayout is a layout that allows us to organize the child views in a one-dimensional stack horizontally or vertically. The StackLayout's default orientation is vertical, however it can be modified to horizontal.

Let's look at few instances to better grasp StackLayout.

Stack layout with vertical orientation
In the first example, I added many Labels to the StackLayout and organized them vertically because the StackLayout's default orientation is 'Vertical'.
<StackLayout>
        <Label x:Name="lblOne" Text="Label One" BackgroundColor="Gray"></Label>
        <Label x:Name="lblTwo" Text="Label Two" BackgroundColor="AliceBlue"></Label>
        <Label x:Name="lblThree" Text="Label Three" BackgroundColor="Aqua"></Label>
        <Label x:Name="lblFour" Text="Label Four" BackgroundColor="LightCoral"></Label>
        <Label x:Name="lblFive" Text="Label Five" BackgroundColor="LightGreen"></Label>
        <Label x:Name="lblSix" Text="Label Six" BackgroundColor="Bisque"></Label>
</StackLayout>

Preview

StackLayout with Horizontal orientation
Let’s change the orientation property of the StackLayout to ‘Horizontal’.

<StackLayout Orientation="Horizontal">
        <Label x:Name="lblOne" Text="Label One" BackgroundColor="Gray"></Label>
        <Label x:Name="lblTwo" Text="Label Two" BackgroundColor="AliceBlue"></Label>
        <Label x:Name="lblThree" Text="Label Three" BackgroundColor="Aqua"></Label>
        <Label x:Name="lblFour" Text="Label Four" BackgroundColor="LightCoral"></Label>
        <Label x:Name="lblFive" Text="Label Five" BackgroundColor="LightGreen"></Label>
        <Label x:Name="lblSix" Text="Label Six" BackgroundColor="Bisque"></Label>
</StackLayout>

After changing the orientation, all the child elements under the StackLayout are arranged horizontally.

Spacing property in StackLayout
Another property of StackLayout is ‘Spacing’ which is of type double, and specifies the amount of space between the child views. Its default value is 0. For demonstration purposes, I am changing this value to 15.

HorizontalOptions and VerticalOptions in StackLayout
The HorizontalOptions and VerticalOptions properties of the StackLayout are of type LayoutOptions and are used to specify how a view should be aligned or positioned within its parent layout when there is unused space available. In the below example, I am changing the VerticalOptions of the StackLayout to Center.
<StackLayout Orientation="Vertical" Spacing="15" VerticalOptions="Center">
        <Label x:Name="lblOne" Text="Label One" BackgroundColor="Gray"></Label>
        <Label x:Name="lblTwo" Text="Label Two" BackgroundColor="AliceBlue"></Label>
        <Label x:Name="lblThree" Text="Label Three" BackgroundColor="Aqua"></Label>
        <Label x:Name="lblFour" Text="Label Four" BackgroundColor="LightCoral"></Label>
        <Label x:Name="lblFive" Text="Label Five" BackgroundColor="LightGreen"></Label>
        <Label x:Name="lblSix" Text="Label Six" BackgroundColor="Bisque"></Label>
</StackLayout>

Preview

There are 8 Layout options (Center, CenterAndExpand, End, EndAndExpand, Fill, FillAndExpand, Start, StartAndExpand) that you can use in HorizontalOptions and VerticalOptions based on the layout you are planning to design. It is important to understand that the behavior of the horizontal options and vertical options can vary depending on the parent layout.

In the below example, I have changed the HorizontalOptions & VerticalOptions properties to demonstrate the position of the Label object position within the StackLayout.
<StackLayout Orientation="Vertical" Spacing="15">
        <Label x:Name="lblOne" Text="Label One"
               BackgroundColor="Gray"
               HorizontalOptions="Start"></Label>
        <Label x:Name="lblTwo" Text="Label Two"
               BackgroundColor="AliceBlue"
               HorizontalOptions="End"></Label>
        <Label x:Name="lblThree" Text="Label Three"
               BackgroundColor="Aqua"
               HorizontalOptions="Center"></Label>
        <Label x:Name="lblFour" Text="Label Four"
               BackgroundColor="LightCoral"
               HorizontalOptions="Start"
               VerticalOptions="FillAndExpand"></Label>
        <Label x:Name="lblFive" Text="Label Five"
               BackgroundColor="LightGreen"
               HorizontalOptions="End"
               VerticalOptions="FillAndExpand"></Label>
        <Label x:Name="lblSix" Text="Label Six"
               BackgroundColor="Bisque"
               VerticalOptions="FillAndExpand"></Label>
</StackLayout>

Preview

Nested StackLayout Objects
We can create complex UI Structures by using nested StackLayout objects. In the below example, I have used the combination of Vertical and Horizontal orientation, as well as the nested StackLayout.

<StackLayout Orientation="Vertical" Spacing="15" Padding="10">
        <StackLayout Orientation="Horizontal" Spacing="10">
            <Label Text="1" BackgroundColor="LightBlue" Padding="10"></Label>
            <Label Text="2" BackgroundColor="LightPink" Padding="10"></Label>
            <Label Text="3" BackgroundColor="LightGreen" Padding="10"></Label>
            <Label Text="4" BackgroundColor="LightSalmon" Padding="10"></Label>
        </StackLayout>
        <StackLayout Orientation="Horizontal" Spacing="10">
            <Label Text="5" BackgroundColor="LightBlue" Padding="10"></Label>
            <Label Text="6" BackgroundColor="LightPink" Padding="10"></Label>
            <Label Text="7" BackgroundColor="LightGreen" Padding="10"></Label>
            <Label Text="8" BackgroundColor="LightSalmon" Padding="10"></Label>
        </StackLayout>
</StackLayout>

Implementing StackLayout using C#
In all the above examples, I have designed the layout using the XAML. Now let’s see How we can achieve the same using the c#. For demonstration purposes, I am creating a Simple StackLayout containing multiple Labels.
public partial class MainPage : ContentPage
{
    public MainPage()
    {
        InitializeComponent();

        StackLayout stackLayout = new StackLayout()
        {
            Orientation = StackOrientation.Vertical,
            VerticalOptions = LayoutOptions.Center,
            Spacing = 10
        };

        stackLayout.Add(new Label() { Text = "Label One", BackgroundColor = Color.FromRgb(255, 225, 225) });
        stackLayout.Add(new Label() { Text = "Label Two", BackgroundColor = Color.FromRgb(0, 204, 0) });
        stackLayout.Add(new Label() { Text = "Label Three", BackgroundColor = Color.FromRgb(255, 255, 204) });
        stackLayout.Add(new Label() { Text = "Label Four", BackgroundColor = Color.FromRgb(224, 224, 224) });

        Content= stackLayout;

    }
}

Preview

There are two other Layouts, i.e., HorizontalStackLayout and VerticalStackLayout, which are more performant alternatives to the StackLayout. However, implementation-wise, they are quite similar to StackLayout. To learn more about them, you may refer to the official Microsoft documentation.

Many current software applications rely on background processes or services to complete numerous functions asynchronously without interfering with the user experience. Background services, whether they're processing data, sending emails, or conducting routine maintenance activities, are critical to keeping applications responsive and efficient. Background services in the.NET Core ecosystem make it easy and efficient to implement asynchronous operations.

What are Background Services?
Background services in.NET Core are long-running processes that operate independently of the main application thread. They run in the background and often conduct activities like data processing, monitoring, or periodic actions without interfering with the main application's execution flow. These services are built on the BackgroundService base class supplied by the.NET Core framework, making it easy to manage their lifecycle and execution.

Benefits of Background Services

• Improved Performance: By offloading tasks to background services, the main application thread remains responsive, providing a smoother user experience.
• Scalability: Background services can be scaled independently, allowing applications to handle varying workloads efficiently.
• Asynchronous Processing: Background services enable asynchronous processing of tasks, enabling applications to perform multiple operations concurrently.
• Modular Design: Separating background tasks into services promotes modular and maintainable code, enhancing the overall codebase's readability and manageability.

Implementing Background Services in.NET Core
Let's look at an example to learn how to develop background services in.NET Core.

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System;
using System.Threading;
using System.Threading.Tasks;

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

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

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation("Background service is running at: {time}", DateTimeOffset.Now);
            // Perform your background task here

            await Task.Delay(5000, stoppingToken); // Delay for 5 seconds before the next iteration
        }
    }
}

In this example

• We create a class ExampleBackgroundService that inherits from BackgroundService.
• In the constructor, we inject an instance of ILogger to log messages.
• We override the ExecuteAsync method, where the actual background task logic resides. Inside this method, we have a loop that runs until cancellation is requested.
• Within the loop, we perform the background task, in this case, logging the current time.
• We use Task. Delay to introduce a 5-second delay before the next iteration.

Registering Background Services
To use background services in your .NET Core application, you need to register them with the Dependency Injection container in your Startup. cs file.
public void ConfigureServices(IServiceCollection services)
{
    services.AddHostedService<ExampleBackgroundService>();
}

Background services in .NET Core offer a powerful mechanism for implementing asynchronous tasks in applications. By leveraging the BackgroundService base class, developers can easily create and manage long-running background tasks, enhancing application responsiveness and scalability. With the provided example and insights, you should now have a solid understanding of how to implement and utilize background services effectively in your .NET Core applications.

The ".NET Framework" and ".NET" (previously known as ".NET Core") are two distinct implementations of the.NET platform, each having a different purpose and addressing various scenarios. However, they share a similar ancestor and are part of the larger.NET ecosystem.

Differences

• .NET Framework: The .NET Framework is the original implementation of the .NET platform, introduced in the early 2000s. It is primarily designed for building Windows-based applications, including desktop applications, web applications, and services. It includes libraries such as Windows Forms, ASP.NET Web Forms, and WPF.
• .NET (formerly .NET Core): .NET (or ".NET 5" and later versions) is a modern, cross-platform implementation of the .NET platform. It is designed to be lightweight, modular, and highly scalable, with support for building applications on Windows, Linux, and macOS. It includes libraries such as ASP.NET Core, Entity Framework Core, and ML.NET.

Evolution: For many years, the.NET Framework served as the platform's foundation. However, as the computing landscape developed, Microsoft introduced.NET Core as a modern, cross-platform alternative to the.NET Framework's restrictions. In November 2020, Microsoft combined.NET Core,.NET Framework, and Xamarin into a single.NET platform dubbed ".NET."

Migration Path: Although.NET Core and.NET Framework have different implementations, Microsoft has given tools and guidelines to help developers move their existing.NET Framework programs to.NET Core and, eventually, to.NET.

The.NET runtime employs IL (Intermediate Language) as a bridging language. It combines all high-level.NET languages into a single language. This is why you can create multilingual applications in.NET. You can write a portion of your program in F# while utilizing an entirely different.NET language for the remainder. Behind the scenes, there is only one language: IL. In our previous tutorial, we talked about the compilation process. It's now time to start creating small programs in the.NET IL language.

Benefits of Learning.NET IL

• Before we begin, let's grasp the importance of learning.NET IL:
• Deeper Understanding: IL can assist you in understanding what happens "under the hood" when you run your.NET software. This can be useful for troubleshooting complex problems or improving performance.
• Specific Tasks: Understanding IL is useful in some sophisticated applications, such as dynamic code generation.

Setting Up the Environment
There is no need to install any specialized programs! You can use a basic text editor such as Notepad++ (but Notepad++ is preferred). Visual Studio lacks a built-in template for writing IL code.

Launch your choice text editor and begin development.

.assembly extern mscorlib {}
.assembly firstILProject {}
.module firstILProject.exe

.class public Program extends [mscorlib]System.Object
{
 .method public static void MyMain(string[] args) cil managed
  {
  .entrypoint
  ldstr "Hello from IL code"
  call void [mscorlib]System.Console::WriteLine(string)
  call string [mscorlib]System.Console::ReadLine()
  pop
  ret
  }

}

Compiling Your Application
To compile your program, simply save it in any folder with the.il extension. Then, launch the "developer command prompt" and execute ilasm to compile your program.
Developer command prompt for Visual Studio.

Sample Code Structure
Here's a breakdown of a typical IL code structure:

External Reference
.assembly extern mscorlib {}

This line references the external mscorlib library, which provides functionalities your application might need.

Main Assembly
.assembly firstILProject {}

This line defines your application assembly and gives it a unique name (firstILProject in this case).

Module Definition
.module firstILProject.exe

This line defines a module named "firstILProject.exe." A module can represent an executable file (.exe) or a Dynamic-link library (DLL).

Class Definition
.class public extends [System.Object] firstILProject

This line creates a public class named firstILProject that inherits from System.Object (all classes in .NET inherit from System.Object by default).

Entry Point Method
.method static public void Main()

This line declares the Main method, the entry point for your console application.

Stack Operations
method static public void Main()

  .entrypoint

  ldstr "Hello, World!"  // Load string "Hello, World!" onto the stack
  call void [mscorlib]System.Console::WriteLine(string)  // Call the WriteLine method to print the string

  pop                     // Remove the string from the stack
  ret                      // Return from the method

  ldstr: This operator loads a string onto the stack.
  call: This keyword is used to call existing methods.
  pop: This removes the top element from the stack.
  ret: This returns from the current method.

Conclusion
This is a basic overview of writing .NET IL code. By understanding these concepts, you can begin creating simple applications and delve deeper into the world of .NET internals.

Rate limitation is an important feature of web application security and performance management since it helps to prevent misuse and guarantee that resources are used fairly. In ASP.NET Core, rate restriction can be implemented using middleware, which provides a centralized way for controlling the rate of incoming requests. This blog discusses rate-limiting middleware, its implementation in ASP.NET Core, and its importance in online application development.

What is Rate Limiting?
Rate limitation is a mechanism that limits the amount of requests a client can make to a web server during a given time period. It aids in the prevention of misuse, protects against denial-of-service (DoS) assaults, and ensures equal resource access.

Rate-Limiting Middleware for ASP.NET Core
The rate-limiting middleware in ASP.NET Core intercepts incoming requests and enforces rate limitations based on predefined constraints. It lies between the client and the application, monitoring request rates and returning appropriate HTTP status codes when limitations are reached.

1. Install Required Packages
Install the AspNetCoreRateLimit package from NuGet:
dotnet add package AspNetCoreRateLimit

2. Configure Rate-Limiting Middleware
In the Startup.cs file, add the rate-limiting middleware to the request processing pipeline:
using AspNetCoreRateLimit;

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    // Other middleware configurations

    app.UseIpRateLimiting();
    app.UseClientRateLimiting();
}

3. Configure Rate-Limiting Options
Configure rate-limiting options in the appsettings.json file:

{
  "IpRateLimiting": {
    "EnableEndpointRateLimiting": true,
    "StackBlockedRequests": true,
    "RealIpHeader": "X-Real-IP",
    "HttpStatusCode": 429,
    "QuotaExceededResponse": {
      "Content-Type": "application/json",
      "Content": "{\"error\": \"Rate limit exceeded\"}"
    },
    "GeneralRules": [
      {
        "Endpoint": "*",
        "Period": "1s",
        "Limit": 5
      }
    ]
  },
  "ClientRateLimiting": {
    "EnableEndpointRateLimiting": true,
    "StackBlockedRequests": true,
    "HttpStatusCode": 429,
    "QuotaExceededResponse": {
      "Content-Type": "application/json",
      "Content": "{\"error\": \"Rate limit exceeded\"}"
    },
    "GeneralRules": [
      {
        "Endpoint": "*",
        "Period": "1s",
        "Limit": 100
      }
    ]
  }
}

4. Test Rate Limiting
Test the rate-limiting middleware by sending requests to your ASP.NET Core application and observing the behavior when rate limits are exceeded.

Rate-limiting middleware in ASP.NET Core is a useful tool for controlling request rates and protecting online applications from misuse and overload. Rate limitation allows developers to improve the security, stability, and performance of their ASP.NET Core apps while also assuring fair and equitable access to resources for all users. Accept rate restriction as an essential component of web application development to protect your apps from malicious actions and resource depletion threats.

Conclusion
Rate-limiting middleware in ASP.NET Core is a useful tool for controlling request rates and protecting online applications from misuse and overload. Rate limitation allows developers to improve the security, stability, and performance of their ASP.NET Core apps while also assuring fair and equitable access to resources for all users. Accept rate restriction as an essential component of web application development to protect your apps from malicious actions and resource depletion threats.

Happy coding!

Data structures are at the foundation of software development, determining how information is organized, stored, and manipulated within applications. Developers in the.NET environment have access to a wide range of data structures that allow for efficient data management, resulting in strong and scalable software solutions. In this post, we will look at some key.NET data structures with practical examples, providing light on their uses and benefits.

1. Lists (.NET Dynamic Arrays)
Lists are dynamic arrays in.NET that allow for size flexibility and easy manipulation. Consider the following scenario: we need to keep track of the names of all our students.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<string> students = new List<string>();

        // Adding students to the list
        students.Add("Alice");
        students.Add("Bob");
        students.Add("Charlie");

        // Iterating over the list
        foreach (var student in students)
        {
            Console.WriteLine(student);
        }
    }
}

2. Queues (FIFO Principle)
Queues follow the First-In-First-Out (FIFO) principle, commonly used in task scheduling or message processing scenarios. Let's simulate a simple printing queue.
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Queue<string> printQueue = new Queue<string>();

        // Enqueueing documents to be printed
        printQueue.Enqueue("Document1");
        printQueue.Enqueue("Document2");
        printQueue.Enqueue("Document3");

        // Printing documents in the order they were added
        while (printQueue.Count > 0)
        {
            string document = printQueue.Dequeue();
            Console.WriteLine("Printing: " + document);
        }
    }
}

3. Stacks (LIFO Principle)
Stacks adhere to the Last-In-First-Out (LIFO) principle and are commonly used in situations like expression evaluation or browser history. Let's implement a simple browser history using a stack.
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Stack<string> browserHistory = new Stack<string>();

        // Navigating through web pages
        browserHistory.Push("Homepage");
        browserHistory.Push("About");
        browserHistory.Push("Contact");

        // Navigating back through history
        while (browserHistory.Count > 0)
        {
            string currentPage = browserHistory.Pop();
            Console.WriteLine("Current Page: " + currentPage);
        }
    }
}

4. Dictionaries (Key-Value Pairs)
Dictionaries in .NET store key-value pairs, enabling efficient lookup and retrieval based on keys. Let's create a simple dictionary to store the ages of individuals.
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Dictionary<string, int> ages = new Dictionary<string, int>();

        // Adding individuals and their ages
        ages["Alice"] = 25;
        ages["Bob"] = 30;
        ages["Charlie"] = 35;

        // Retrieving ages
        Console.WriteLine("Bob's age: " + ages["Bob"]);
    }
}

Conclusion
Understanding and utilizing.NET data structures is critical for effective program development. Developers can create more robust and scalable apps by learning about these data structures and their uses through real examples. Whether you're managing collections, creating algorithms, or improving performance, a good understanding of.NET data structures gives you the confidence to take on a variety of programming issues.

Within MAUI, a loading indication, often known as a "wait loader," is commonly used to alert the user of an ongoing time-consuming action, such as data collection, processing, or any operation that may cause the UI to become unresponsive or freeze.

Loading screen addresses various issues
Typically, a loading screen addresses various issues.

1. Visual Indication
Objective: Provide a visual indication to users that a task is currently being executed.
Significance: Users appreciate being informed that their action has been recognized and that the application is actively working on fulfilling their request.

2. User Interaction
Objective: Engage users during operations that may take some time.
Significance: A loader ensures that users do not feel like the application has frozen or stopped responding. It assures them that background processes are ongoing.

3. Managing Expectations
Objective: Clearly communicate the expected duration of a process.
Significance: Users are more likely to wait patiently if they have an estimate of how long the process will take. A loader helps manage expectations and reduces the perceived waiting time.

4. Restricting User Input
Objective: Limit or disable user interactions while a process is ongoing.
Significance: Restricting user input during a process helps prevent unexpected behavior or errors that could occur due to user actions at that time.

5. Displaying Progress
Objective: Show progress if the duration of the process is known.
Significance: In cases where the duration of a process is predictable, a loader can display progress, giving users an idea of the work completed and the remaining tasks.

The issue of a waiting loader with specific features can be resolved by utilizing the nuget package called "Custom.MAUI.AnimatedLoaders". As the proprietor of this package, I am pleased to provide the following features to the users.

1. mauiWaitLoaderColor: Color.FromArgb("#FF0000")
This feature allows the user to specify the color of the MAUI wait loader. By setting the color to red (#FF0000), the loader will be displayed in a vibrant red hue. The Color.FromArgb method is employed to create a color object based on an ARGB (Alpha, Red, Green, Blue) value.

2. loaderTextColor: Color.FromArgb("#FFFFFF")
This feature enables the user to determine the color of the text within the loader. By setting the color to white (#FFFFFF), the text will be displayed in a crisp white shade.

3. loaderHeightRequest: 150.0
With this feature, the user can set the height of the loader to 150.0 device-independent pixels (DIP). This ensures that the loader is displayed at the desired height on various devices.

4. loaderWidthRequest: 150.0
Similarly, this feature allows the user to set the width of the loader to 150.0 device-independent pixels (DIP). It ensures that the loader occupies the desired width on different devices.

5. loaderFontSize: 16.0
This feature enables the user to specify the font size of the loader text. By setting it to 16.0 device-independent pixels (DIP), the text will be displayed at the desired font size.

6. message: "Processing"
Lastly, this feature allows the user to define the message that will be displayed alongside the custom loader. In this case, the message is set to "Processing", indicating that some form of processing is taking place.

Please note that these features are provided within the "Custom.MAUI.AnimatedLoaders" nuget package, which I am the proprietor of.
Steps to implement custom loader in MAUI

The user has to follow the following steps to implement a custom loader in MAUI.

Step 1. To incorporate the functionality of "Custom.MAUI.AnimatedLoaders" into your project, you need to install the corresponding NuGet package.

Step 2. The initial configuration for the MAUI loader will resemble this.

using MAUI.Custom.LoaderEase;

namespace CustomMAUIAnimatedLoadersExample
{
    public partial class App : Application
    {
        public App()
        {
            InitializeComponent();

            // MAUI LOADER INITIAL SETUP
            MAUILoaderRegisterationSetup.ConfigureCustomMAUILoader(
                mauiWaitLoaderColor: Color.FromArgb("#FF0000"),
                loaderTextColor: Color.FromArgb("#FFFFFF"),
                loaderHeightRequest: 150.0,
                loaderWidthRequest: 150.0,
                loaderFontSize: 16.0
            );

            MainPage = new AppShell();
        }
    }
}

Step 3. Register the MAUICommunityToolkit in order to execute this loader.
using CommunityToolkit.Maui;
using MAUI.Custom.LoaderEase.AppPresentations.CommonSource;
using MAUI.Custom.LoaderEase.AppPresentations.Services;
using MAUI.Custom.LoaderEase.Interfaces;
using Microsoft.Extensions.Logging;

namespace CustomMAUIAnimatedLoadersExample
{
    public static class MauiProgram
    {
        public static MauiApp CreateMauiApp()
        {
            try
            {
                var builder = MauiApp.CreateBuilder();
                builder.UseMauiApp<App>().ConfigureFonts(fonts =>
                {
                    fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
                    fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
                });
                RegisterEssentials(builder.Services);
                RegisterPages(builder.Services);
                RegisterViewModels(builder.Services);
                builder.UseMauiCommunityToolkit(); // Registering for MAUI loader
                var app = builder.Build();
                MauiServiceHandler.MauiAppBuilder = app;
                return app;
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        static void RegisterPages(in IServiceCollection services)
        {
            services.AddTransient<MainPage>();
        }

        static void RegisterViewModels(in IServiceCollection services)
        {
            services.AddTransient<MainPageViewModel>();
        }

        static void RegisterEssentials(in IServiceCollection services)
        {
            // If the user intends to utilize this service through dependency injection,
            // they must register the loader service handler.
            services.AddSingleton<ICustomLoaderHandlerService, CustomLoaderHandlerService>();
        }
    }
}

Step 4. If the user intends to utilize this service through dependency injection, they must register the loader service handler.
static void RegisterEssentials(in IServiceCollection services)
{
    // If the user intends to utilize this service through dependency injection,
    // they must register the loader service handler.
    services.AddSingleton<ICustomLoaderHandlerService, CustomLoaderHandlerService>();
}

Step 5. Implement a custom loader call within the ViewModel using the MVVM pattern, whether through dependency injection or without the need to instantiate any objects.
using MAUI.Custom.LoaderEase.Interfaces;

namespace CustomMAUIAnimatedLoadersExample
{
    public class MainPageViewModel
    {
        private ICustomLoaderHandlerService loaderHandlerService = null;

        [Obsolete]
        public MainPageViewModel(ICustomLoaderHandlerService loaderHandlerService)
        {
            this.loaderHandlerService = loaderHandlerService;
            ShowWaitWindow();
            CloseLoader();
        }

        private void ShowWaitWindow()
        {
            // To display the loader using the Dependency Injection service.
            if (loaderHandlerService != null)
                loaderHandlerService.ShowCustomLoader(message: "Processing");

            // To display the loader without generating an instance.
            // LoaderHandler.ShowCustomLoader(message: "Searching", loaderType: LoaderType.QuantumQuikLoader);
        }

        [Obsolete]
        private void CloseLoader()
        {
            Device.StartTimer(TimeSpan.FromSeconds(20), () =>
            {
                // To hide the loader using the Dependency Injection service.
                loaderHandlerService.HideCustomLoader();

                // To hide the loader without generating an instance.
                // LoaderHandler.HideCustomLoader();

                return false;
            });
        }
    }
}

Step 6. View of wait loader.

In software development, error handling is a critical component. The way a software handles errors, no matter how minor or large, can have a significant impact on how well it functions for users. One neat error-handling technique in the world of.NET Core is dubbed "global exception handling using custom middleware." It's like having a superhero for your code who finds bugs and fixes them all in one location, strengthening and enhancing the dependability of your application.

Comprehending Global Exception Management
In most.NET Core programs, try-catch blocks are used to encircle any code that may potentially cause issues. However, if we do this everywhere, our code may become jumbled and repetitious. This is resolved by global exception handling, which establishes a central system that detects faults wherever they occur.

Personalized Middleware
In.NET Core, the phrase "middleware" refers to a fancy manner of handling requests and responses in a web application. Custom middleware expands on this concept. It allows us to add custom code to the process, such as additional support to handle problems. This makes our code easier to read and more orderly.

Putting Custom Exception Middleware in Place
These steps must be followed in order to configure global exception handling in.NET Core utilizing custom middleware.
1. Create Custom Middleware: Write a unique piece of code, or middleware, to detect application issues.

public class ExceptionMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            // Here we handle the error
            await HandleExceptionAsync(context, ex);
        }
    }

    private async Task HandleExceptionAsync(HttpContext context, Exception ex)
    {
        // Handle the error and let the user know
        // Respond with a message saying something went wrong
        context.Response.ContentType = "application/json";
        context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
        await context.Response.WriteAsync("An unexpected error occurred.");
    }
}

2. Register Middleware: Tell the application to use our special middleware to handle errors.
public void Configure(IApplicationBuilder app)
{
    app.UseMiddleware<ExceptionMiddleware>();
    // More configurations can go here...
}

Custom Exception Middleware's advantages
In.NET Core, there are several excellent benefits to using custom middleware for global exception handling.

Centralized Management of Errors
Because all error handling is done in one location, managing and comprehending the code is made simpler. Consistent Error Responses: Ensure that the user always receives the same type of message when something goes wrong, so that both they and us can identify the issue. More robust applications Our apps become more dependable and capable of handling issues without crashing when they handle errors gracefully.