European ASP.NET 4.5 Hosting BLOG

BLOG about ASP.NET 4, ASP.NET 4.5 Hosting and Its Technology - Dedicated to European Windows Hosting Customer

European ASP.NET Core 9.0 Hosting - HostForLIFE :: Task: Synchronous vs. Asynchronous.Task and WaitAll.WhenEverything in.NET

clock July 9, 2024 07:09 by author Peter

Asynchronous programming in C# frequently entails doing several tasks at once. Task and Split are two popular approaches to managing many tasks.Task.WhenAll and WaitAll. Despite their apparent similarities, they have different functions and are employed in various contexts. The distinctions between Task.WaitAll and Task.WhenAll are examined in this article, along with real-world examples to show how to use both.


What is Task.WaitAll?
Assignment.The synchronous function WaitAll stops the calling thread after each of the supplied tasks is finished. It's helpful when you have to make sure that a group of tasks is completed before moving on, but it does so in a blocking way, meaning that Task is called by the thread.Until every task is completed, WaitAll is in use.

Example Usage of Task.WaitAll
using System;
using System.Threading.Tasks;
class Program
{
    static void Main()
    {
        Task task1 = Task.Run(() => PerformTask(1));
        Task task2 = Task.Run(() => PerformTask(2));
        Task task3 = Task.Run(() => PerformTask(3));
        Task.WaitAll(task1, task2, task3); // Blocks until all tasks complete
        Console.WriteLine("All tasks completed.");
    }
    static void PerformTask(int taskId)
    {
        Console.WriteLine($"Task {taskId} starting.");
        Task.Delay(1000).Wait(); // Simulate work
        Console.WriteLine($"Task {taskId} completed.");
    }
}


In this example, Task.WaitAll blocks the main thread until all three tasks are complete.

What is Task.WhenAll?

Task.WhenAll is an asynchronous method that returns a single task that is completed when all the provided tasks have been completed. Unlike Task.WaitAll, it does not block the calling thread. Instead, it allows the calling code to continue executing asynchronously.

Example Usage of Task.WhenAll

using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main()
    {
        Task task1 = Task.Run(() => PerformTask(1));
        Task task2 = Task.Run(() => PerformTask(2));
        Task task3 = Task.Run(() => PerformTask(3));
        await Task.WhenAll(task1, task2, task3); // Waits for all tasks to complete asynchronously
        Console.WriteLine("All tasks completed.");
    }
    static void PerformTask(int taskId)
    {
        Console.WriteLine($"Task {taskId} starting.");
        Task.Delay(1000).Wait(); // Simulate work
        Console.WriteLine($"Task {taskId} completed.");
    }
}


In this example, Task.WhenAll allows the main method to await the completion of all tasks without blocking the calling thread.

Key Differences
Blocking vs. Non-blocking

  • Task.WaitAll: Blocks the calling thread until all tasks are complete.
  • Task.WhenAll: Returns a task that can be awaited, allowing the calling thread to continue execution asynchronously.

Return Type

  • Task.WaitAll: Does not return a value.
  • Task.WhenAll: Returns a Task that represents the completion of all provided tasks.

Usage Scenario

  • Task.WaitAll: Used when you need to block until tasks are complete, typically in non-UI or console applications.
  • Task.WhenAll: Used in asynchronous programming, especially in UI applications where blocking the main thread is undesirable.

Practical Use Cases
When to Use Task.WaitAll

  • In console applications where you need to ensure that certain tasks are completed before moving on.
  • When you are dealing with legacy code that doesn’t support async/await patterns.

When to Use Task.WhenAll

  • In UI applications keep the interface responsive.
  • In web applications handle multiple asynchronous operations without blocking the main thread.

Conclusion
Task.WaitAll and Task.WhenAll are essential tools in C# for handling multiple tasks. Use Task.WaitAll when you need to block the calling thread until tasks are complete, and Task.WhenAll for asynchronous waiting. Understanding their differences and appropriate use cases can help you write more efficient and responsive applications.



European ASP.NET Core 9.0 Hosting - HostForLIFE :: Resilience in a.NET 8 Web API Implementation

clock July 2, 2024 08:16 by author Peter

Creating robust APIs is more important than ever in the age of modern web development, especially with all these third-party integration we rely on. In this Blog, We will be guiding you how to introduce resilience in. Create an HTTP Client in a. Extensions. Http. Resilience library. In this section, we will take a look at features like setting up retry policies with exponential backoff and timeouts to make your API more resilient against the transient faults.

Step 1. Create a new. NET 8 Web API project Step First, if you have no existing Project then create new with. NET CLI dotnet new web or starting with the default Web API template.

Step 2. Install the Microsoft.AspNetCore. Extensions. Http. Resilience library via NuGet:
dotnet add package Microsoft.Extensions.Http.Resilience --version 8.0.0

Step 3. Configure Resilience in Program.cs
Modify the Program.cs file to set up HttpClient with resilience policies provided by Microsoft.Extensions.Http.Resilience. Here, we will define retry policies and timeouts.
//Add resilience pipeline
builder.Services.AddResiliencePipeline("default", x =>
{
    x.AddRetry(new Polly.Retry.RetryStrategyOptions
    {
        ShouldHandle = new PredicateBuilder().Handle<Exception>(),
        Delay = TimeSpan.FromSeconds(2),
        MaxRetryAttempts = 2,
        BackoffType = DelayBackoffType.Exponential,
        UseJitter = true
    })
    .AddTimeout(TimeSpan.FromSeconds(30));
});

Step 4. Use the Resilient HttpClient in a Service
Next, we'll inject and use the configured HttpClient in your Service. This example shows how to fetch data from an external API using the resilient HttpClient.
public class WeatherService
{
    private readonly HttpClient _httpClient;
    private readonly ResiliencePipelineProvider<string> _resiliencePipelineProvider;
    public WeatherService(HttpClient httpClient,
                         ResiliencePipelineProvider<string> resiliencePipelineProvider)
    {
        _httpClient = httpClient;
        _resiliencePipelineProvider = resiliencePipelineProvider;

    }
    public async Task<string> GetWeatherAsync()
    {
        var pipeline = _resiliencePipelineProvider.GetPipeline("default");
        var response = await pipeline
            .ExecuteAsync( async ct=> await _httpClient.GetAsync($"https://localhost:7187/weatherforecast",ct));

        return await response.Content.ReadAsStringAsync();
    }

}


Step 5. Add the endpoint in the Program.cs
app.MapGet("/weatherService/weather", async (WeatherService weatherService) =>
{
    var result = await weatherService.GetWeatherAsync();
    return result;
})
    .WithName("GetWeather")
    .WithOpenApi();


Step 6. Run the Application
Finally, run your application and navigate to the endpoint to see the resilient HttpClient in action.
References

Please refer to the below links for more details.

  • Building resilient cloud services with .NET 8
  • Learning from Microsoft

Conclusion
By following these steps, you have integrated resilience into your .NET 8 Web API project using Microsoft.Extensions.Http.Resilience library. The retry policies, circuit breaker settings, and timeouts will help ensure your API is robust against transient faults, improving its reliability and user experience.

 



European ASP.NET Core 9.0 Hosting - HostForLIFE :: Caching Strategies in Angular and .NET Core

clock June 25, 2024 08:07 by author Peter

One essential tactic for enhancing the scalability and performance of web applications is caching. Caching can be done in a variety of methods inside the frameworks of Angular (a client-side framework) and.NET Core (a server-side framework), each appropriate for a particular set of circumstances. The following are some typical caching techniques for both:

Angular Caching
Caching HTTP Requests with an HTTP Interceptor

  • To cache HTTP responses, use an HTTP interceptor. By delivering cached responses when appropriate, this can assist lower the amount of HTTP queries made to the server.
  • For instance. Construct an HTTP interceptor that looks through the cache before sending a network request, and a caching service that saves responses.
import { Injectable } from '@angular/core';
import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
import { Observable, of } from 'rxjs';
import { tap } from 'rxjs/operators';
@Injectable()
export class CacheInterceptor implements HttpInterceptor {
  private cache = new Map<string, any>();
  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
    if (req.method !== 'GET') {
      return next.handle(req);
    }
    const cachedResponse = this.cache.get(req.url);
    if (cachedResponse) {
      return of(cachedResponse);
    }
    return next.handle(req).pipe(
      tap(event => {
        this.cache.set(req.url, event);
      })
    );
  }
}


Service Worker for Offline Caching
  • Use Angular's built-in service worker support to cache assets and API responses for offline access and faster load times.
  • Example. Enable the Angular service worker by running ng add @angular/pwa and configure caching in the ngsw-config.json file.
Local Storage or IndexedDB
Store data in the browser's local storage or IndexedDB for long-term caching. This can be useful for storing user preferences or large datasets that rarely change.
Example. Use Angular's localStorage or IndexedDB wrappers to store and retrieve data.
localStorage.setItem('key', JSON.stringify(data));
const cachedData = JSON.parse(localStorage.getItem('key'));

Caching in .NET Core
In-Memory Caching
Store cache data in the memory of the web server. This is useful for small amounts of data that change frequently.
Example. Use the IMemoryCache interface to cache data in memory.
public class MyService
{
    private readonly IMemoryCache _memoryCache;
    public MyService(IMemoryCache memoryCache)
    {
        _memoryCache = memoryCache;
    }
    public string GetData()
    {
        string cacheKey = "myCacheKey";
        if (!_memoryCache.TryGetValue(cacheKey, out string cachedData))
        {
            cachedData = "Data from database";
            _memoryCache.Set(cacheKey, cachedData, TimeSpan.FromMinutes(5));
        }
        return cachedData;
    }
}


Distributed Caching
  • Store cache data in a distributed cache like Redis or SQL Server. This is useful for data that needs to be shared across multiple servers.
  • Example. Use the IDistributedCache interface to cache data in Redis.
public class MyService
    {
        private readonly IDistributedCache _distributedCache;
        public MyService(IDistributedCache distributedCache)
        {
            _distributedCache = distributedCache;
        }
        public async Task<string> GetDataAsync()
        {
            string cacheKey = "myCacheKey";
            var cachedData = await _distributedCache.GetStringAsync(cacheKey);
            if (cachedData == null)
            {
                cachedData = "Data from database";
                await _distributedCache.SetStringAsync(cacheKey, cachedData, new DistributedCacheEntryOptions
                {
                    AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5)
                });
            }
            return cachedData;
        }
    }

Response Caching Middleware
  • Cache HTTP responses at the server level to improve performance for subsequent requests.
  • Example. Configure response caching middleware in the Startup class.
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddResponseCaching();
    }
    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        app.UseResponseCaching();
        app.Use(async (context, next) =>
        {
            context.Response.GetTypedHeaders().CacheControl =
                new Microsoft.Net.Http.Headers.CacheControlHeaderValue()
                {
                    Public = true,
                    MaxAge = TimeSpan.FromSeconds(60)
                };
            await next();
        });
    }


Combining Angular and .NET Core Caching

To achieve optimal performance, you can combine caching strategies in Angular and .NET Core:

Client-Side Caching

Cache static assets and API responses in Angular using service workers or local storage.
Implement HTTP interceptors to cache responses and reduce server requests.

Server-Side Caching
Use in-memory or distributed caching in .NET Core to store frequently accessed data.
Implement response caching middleware to cache entire HTTP responses.

Conclusion
You can build a strong and effective caching strategy that greatly improves the efficiency and scalability of your Angular and.NET Core applications by utilizing both client-side and server-side caching.



European ASP.NET Core 9.0 Hosting - HostForLIFE :: How to Exploring the Experimental Attribute in C#?

clock June 20, 2024 13:52 by author Peter

In software development, the introduction of new features often involves a period of testing and feedback. During this period, developers need a way to indicate that certain features are not fully mature and may be subject to change. The Experimental attribute in C# serves this purpose by marking classes, methods, or other members as experimental. This blog will delve into what the Experimental attribute is, why it's useful, how to implement it, and provide detailed code snippets to illustrate its usage.


What is the Experimental Attribute?

The Experimental attribute is a custom attribute that can be applied to various members of your codebase (e.g., classes, methods, properties). It indicates that the marked feature is experimental, meaning it's in a testing phase and may undergo significant changes or might even be removed in future releases.
Why Do We Need It?

  • Communication: It communicates to other developers that the marked feature is not yet stable and should be used with caution.
  • Encapsulation: It helps encapsulate features that are still under development, making it easier to manage their lifecycle.
  • Documentation: It serves as a form of documentation, indicating the experimental nature directly in the code.


Implementing the Experimental Attribute
Step 1. Define the Experimental Attribute
First, you need to define the Experimental attribute. This is a simple custom attribute class.
using System;
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Property)]
public class ExperimentalAttribute : Attribute
{
    public string Message { get; }
    public ExperimentalAttribute(string message)
    {
        Message = message;
    }
}


Step 2. Applying the Experimental Attribute
You can apply the Experimental attribute to various parts of your codebase to indicate that they are experimental.
using System;
[Experimental("This class is experimental and may change in the future.")]
public class ExperimentalFeature
{
    [Experimental("This method is experimental and may change in the future.")]
    public void ExperimentalMethod()
    {
        Console.WriteLine("This is an experimental method.");
    }
    [Experimental("This property is experimental and may change in the future.")]
    public string ExperimentalProperty { get; set; }
}

Step 3. Using the Experimental Features
When using the experimental features, it’s important to handle them with care, knowing that their behavior might change.
public class Program
{
    public static void Main()
    {
        ExperimentalFeature feature = new ExperimentalFeature();
        feature.ExperimentalMethod();
        feature.ExperimentalProperty = "Testing";
        Console.WriteLine(feature.ExperimentalProperty);
    }
}


Detailed Explanation of Code Snippets
Defining the Attribute

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Property)]
public class ExperimentalAttribute : Attribute
{
    public string Message { get; }
    public ExperimentalAttribute(string message)
    {
        Message = message;
    }
}

  • [AttributeUsage]: Specifies the program elements to which the attribute can be applied. Here, it can be applied to classes, methods, and properties.
  • Constructor: Initializes the attribute with a message that provides additional context or warnings about the experimental feature.

Applying the Attribute
[Experimental("This class is experimental and may change in the future.")]
public class ExperimentalFeature
{
    [Experimental("This method is experimental and may change in the future.")]
    public void ExperimentalMethod()
    {
        Console.WriteLine("This is an experimental method.");
    }
    [Experimental("This property is experimental and may change in the future.")]
    public string ExperimentalProperty { get; set; }
}

  • Class Level: Marks the entire class as experimental.
  • Method Level: Marks a specific method within the class as experimental.
  • Property Level: Marks a property within the class as experimental.

Using the Experimental Features
public class Program
{
    public static void Main()
    {
        ExperimentalFeature feature = new ExperimentalFeature();
        feature.ExperimentalMethod();
        feature.ExperimentalProperty = "Testing";
        Console.WriteLine(feature.ExperimentalProperty);
    }
}


Creating an Instance: An instance of the ExperimentalFeature class is created and its experimental method and property are used. This is straightforward, but developers should be aware of the experimental status.

Conclusion

The Experimental attribute in C# is a powerful tool for marking features as experimental, providing clear communication to other developers about the stability and maturity of the code. By defining and applying this custom attribute, you can better manage the development and evolution of new features, ensuring that everyone involved in the project is aware of their experimental nature.

Using the Experimental attribute helps in documenting and encapsulating the experimental features effectively, making your codebase more maintainable and understandable. While the examples provided are simple, the approach can be scaled to larger and more complex projects, enhancing the overall development process.



About HostForLIFE.eu

HostForLIFE.eu is European Windows Hosting Provider which focuses on Windows Platform only. We deliver on-demand hosting solutions including Shared hosting, Reseller Hosting, Cloud Hosting, Dedicated Servers, and IT as a Service for companies of all sizes.

We have offered the latest Windows 2016 Hosting, ASP.NET Core 2.2.1 Hosting, ASP.NET MVC 6 Hosting and SQL 2017 Hosting.


Tag cloud

Sign in