Here are the steps to create a .NET Core API with Swagger documentation,
1. Create a new .NET Core project in Visual Studio or using the .NET Core CLI.
2. Install the Swashbuckle.AspNetCore NuGet package by running the following command in the Package Manager Console,

Install-Package Swashbuckle.AspNetCore

3. Open the Startup.cs file and add the following code to the ConfigureServices method,
services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });
});

This code registers the Swagger generator and configures a Swagger document titled "My API" and version "v1".

4. In the Configure method of the Startup.cs file, add the following code,
app.UseSwagger();
app.UseSwaggerUI(c =>
{
    c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
});

This code adds the Swagger middleware to generate the Swagger JSON endpoint and the Swagger UI.

5. Add XML comments to your API controllers and models to provide more detailed descriptions of your API. To enable XML documentation, add the following code to the .csproj file,
<PropertyGroup>
    <GenerateDocumentationFile>true</GenerateDocumentationFile>
    <NoWarn>$(NoWarn);1591</NoWarn>
</PropertyGroup>

This code generates an XML documentation file for your project and suppresses the warning for missing XML comments.

6. Run your API project and navigate to the Swagger UI page at https://localhost:{port}/swagger/index.html, where {port} is the port number of your API project. You should see the API documentation generated by Swagger.

That's it! You have now created a .NET Core API with Swagger documentation. You can customize the Swagger document by adding additional options to the AddSwaggerGen method, such as security definitions and operation filters.

Dependency Injection (DI) is a design pattern that allows for loose coupling between components of an application. In an ASP.NET Core application, DI is a key feature that makes it easier to manage dependencies between classes and promotes code reusability. In this article, we'll cover the basics of DI and its benefits and show how to use the built-in DI container in ASP.NET Core to register and inject dependencies.

What is Dependency Injection?
In a typical application, many classes depend on other classes to perform their tasks. For example, a 'ProductService' class may need a 'ProductRepository' class to retrieve data from a database. The traditional approach to handling dependencies like this is to create the dependent object inside the class that needs it. This creates a tight coupling between the two classes, making it difficult to change the implementation of the dependent class without modifying the class that uses it.

DI is an alternative approach to handling dependencies that promotes loose coupling between classes. With DI, the dependent object is provided to the class that needs it rather than being created inside the class. This is typically done using a constructor or a property. The benefit of this approach is that it makes the code more modular and easier to maintain. It also makes it possible to easily switch out implementations of the dependent object without modifying the class that uses it.

Configuring the Built-in DI Container in ASP.NET Core
ASP.NET Core includes a built-in DI container that makes registering and injecting dependencies easy. To use the DI container, you must first configure it in your application's Startup class. Here is an example of how to do that:
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Register services for DI here
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // Configure middleware here
    }
}

The 'ConfigureServices' method allows you to register your services for DI. The 'IServiceCollection' parameter is a collection of service descriptors that define the services available for injection.

Registering Services for Injection
To register a service for injection, you must create a service descriptor and add it to the 'IServiceCollection'. A service descriptor consists of three parts:
    The service type, which is the interface or base class that the service implements
    The implementation type, which is the concrete class that provides the implementation for the service
    The lifetime, which determines how long the service should be kept in memory

Here's an example of how to register a service for injection:
services.AddScoped<IProductRepository, SqlProductRepository>();

This code registers a service that implements the 'IProductRepository' interface and provides the implementation in the 'SqlProductRepository' class. The AddScoped method specifies that the service should have a scoped lifetime, which means that a new instance of the service will be created for each HTTP request.

Injecting Dependencies

Once you have registered your services for injection, you can inject them into your classes using constructor injection. Here is an example of how to do that:
public class ProductService
{
    private readonly IProductRepository _repository;

    public ProductService(IProductRepository repository)
    {
        _repository = repository;
    }

    // Product-related methods go here
}

This code shows a 'ProductService' class that depends on an 'IProductRepository' object. The 'IProductRepository' object is provided to the constructor of the 'ProductService' class and is stored in a private field for later use.

Setting up DI in ASP.NET Core
Setting up Dependency Injection (DI) in an ASP.NET Core application involves two primary steps: configuring the DI container and registering the services for injection. Here's a step-by-step guide to setting up DI in your ASP.NET Core application:

Step 1. Configure the DI Container
In the 'Startup.cs' file, in the 'ConfigureServices' method, you need to configure the DI container by adding the following line of code:
public void ConfigureServices(IServiceCollection services)
{
    // Add framework services.
    services.AddMvc();

    // Add your own services here.
    // ...

    // Configure the DI container
    services.AddScoped<IService, Service>();
}

In this example, we're adding a scoped service that implements the 'IService' interface, with an implementation in the 'Service' class. We're using the 'AddScoped' method to specify that a new service instance should be created for each HTTP request.

Step 2. Register the Services for Injection
To register a service for injection, you must create a service descriptor and add it to the 'IServiceCollection'. A service descriptor specifies the interface or abstract class that the service implements, the concrete class that provides the implementation, and the lifetime of the service.

Here's an example of how to register a service for injection:
services.AddScoped<IService, Service>();

In this example, we're registering a service that implements the IService interface and provides the implementation in the Service class. The AddScoped method specifies that the service should have a scoped lifetime, meaning a new service instance will be created for each HTTP request.

You can also use the AddTransient and AddSingleton methods to specify different lifetimes for your services:
    AddTransient: A new instance of the service is created each time it's requested
    AddScoped: A new instance of the service is created for each HTTP request
    AddSingleton: A single instance of the service is created for the lifetime of the application

Step 3. Inject the Services
Once you've registered your services for injection, you can inject them into your controllers or other classes using constructor injection. Here's an example of how to do that:
public class MyController : Controller
{
    private readonly IService _service;

    public MyController(IService service)
    {
        _service = service;
    }

    // Controller actions go here
}

In this example, we inject the 'IService' into the 'MyController' class using constructor injection. The 'IService' instance is stored in a private field for later use.

By following these steps, you can set up DI in your ASP.NET Core application, making it easier to manage dependencies between classes and promoting loose coupling between components.

Using DI in Controllers and Services
Dependency Injection (DI) is a powerful technique that can help you to manage the dependencies between your classes, making your code more modular and maintainable. This article will examine how to use DI in ASP.NET Core controllers and services.

Using DI in Controllers
Controllers are essential to an ASP.NET Core application and can benefit significantly from DI. To use DI in controllers, you need to inject the required services in the constructor of the controller.

Here's an example of a controller that uses DI:
public class HomeController : Controller
{
    private readonly ILogger<HomeController> _logger;
    private readonly IMyService _myService;

    public HomeController(ILogger<HomeController> logger, IMyService myService)
    {
        _logger = logger;
        _myService = myService;
    }

    public IActionResult Index()
    {
        _logger.LogInformation("Executing action Index.");
        var data = _myService.GetData();
        return View(data);
    }
}

In this example, the 'HomeController' injects two services using the constructor. The first service is an instance of 'ILogger<T>', used to log information. The second service is an instance of 'IMyService', which provides some business logic to get the data.

The constructor of the controller receives these services and stores them in private fields, making them available for use in the controller's action methods. In the example, the Index action method uses both services to log some information and retrieve data from the 'IMyService' instance.

Using DI in Services
Services are classes that provide some specific functionality to your application. They can be injected into your controllers or other services to provide their functionality. To use DI in services, you need to add the IService interface as a dependency in the constructor of the service and then inject the required services.

Here's an example of a service that uses DI:
public class MyService : IMyService
{
    private readonly IDataRepository _dataRepository;

    public MyService(IDataRepository dataRepository)
    {
        _dataRepository = dataRepository;
    }

    public IEnumerable<string> GetData()
    {
        var data = _dataRepository.GetData();
        return data.Select(x => x.Value);
    }
}

In this example, the 'MyService' class injects a single service, 'IDataRepository', using the constructor. The 'IDataRepository' instance is stored in a private field, making it available for use in the service's methods. In the example, the GetData method uses the 'IDataRepository' instance to get some data and then returns a filtered set of data.

Using DI in your services and controllers, you can promote loose coupling between your components, making your code more modular and maintainable. You can also easily replace or update your services without changing your controllers' code.

Using DI in Middleware
Dependency Injection (DI) is a powerful technique that can help you to manage the dependencies between your classes, making your code more modular and maintainable. This article will look at how to use DI in ASP.NET Core middleware.

Using DI in Middleware
Middleware is a powerful feature of ASP.NET Core that allows you to add custom logic to the request pipeline. Middleware typically adds application functionality such as authentication, logging, and error handling. Middleware can also be used to inject services and other dependencies.

To use DI in middleware, you need to add the required services in the constructor of the middleware. Here's an example of middleware that uses DI:
public class MyMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<MyMiddleware> _logger;

    public MyMiddleware(RequestDelegate next, ILogger<MyMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context, IMyService myService)
    {
        _logger.LogInformation("Executing middleware.");
        var data = myService.GetData();
        context.Response.Headers.Add("My-Header", data);
        await _next(context);
    }
}

In this example, the 'MyMiddleware' injects two services using the constructor. The first service is an instance of 'RequestDelegate', the next middleware in the pipeline. The second service is an instance of 'ILogger<T>', used to log information. The middleware also requires an instance of 'IMyService', which provides some business logic to get the data.

The constructor of the middleware receives these services and stores them in private fields, making them available for use in the middleware's 'InvokeAsync' method. In the example, the 'InvokeAsync' method uses both services to log some information, retrieve data from the 'IMyService' instance, and add a custom header to the response.

Registering Middleware with DI
To register your middleware with the DI container, use the UseMiddleware method, which allows you to specify the middleware type and any dependencies. Here's an example of registering the MyMiddleware with DI:
public void Configure(IApplicationBuilder app)
{
    app.UseMiddleware<MyMiddleware>();
}

In this example, the 'MyMiddleware' is added to the request pipeline using the 'UseMiddleware' method. The method automatically resolves any dependencies that are required by the middleware.

Using DI in your middleware, you can promote loose coupling between your components, making your code more modular and maintainable. You can also easily replace or update your middleware without changing your application's code.

Advanced DI topics
Dependency Injection (DI) is a powerful technique that can help you to manage the dependencies between your classes, making your code more modular and maintainable. In this article, we'll look at some advanced topics in DI that can help you to get the most out of this technique.
Named and Typed Services

Sometimes, you may want to register multiple services of the same type but with different implementations. For example, you may have multiple implementations of a logging service or multiple implementations of a data store. You can use named and typed services to differentiate between the implementations in these cases.

Named services are used to register services with a specific name, which can be used to differentiate between them. Here's an example of registering two named services:
services.AddSingleton<ILogger, ConsoleLogger>("console");
services.AddSingleton<ILogger, FileLogger>("file");

In this example, we're registering two 'ILogger' services, one with the name "console" and the other with the name "file". When you want to use one of these services, you can specify the name in the constructor:
public class MyService
{
    private readonly ILogger _consoleLogger;
    private readonly ILogger _fileLogger;

    public MyService(
        [Named("console")] ILogger consoleLogger,
        [Named("file")] ILogger fileLogger)
    {
        _consoleLogger = consoleLogger;
        _fileLogger = fileLogger;
    }

    // ...
}

Typed services are used to register services with a specific implementation type, which can be used to differentiate between them. Here's an example of registering two typed services:
services.AddSingleton<ILogger, ConsoleLogger>();
services.AddSingleton<ILogger, FileLogger>();

In this example, we're registering two 'ILogger' services, one with the 'ConsoleLogger' implementation and the other with the 'FileLogger' implementation. When you want to use one of these services, you can specify the implementation type in the constructor:
public class MyService
{
    private readonly ILogger _consoleLogger;
    private readonly ILogger _fileLogger;

    public MyService(
        IEnumerable<ILogger> loggers)
    {
        _consoleLogger = loggers.OfType<ConsoleLogger>().SingleOrDefault();
        _fileLogger = loggers.OfType<FileLogger>().SingleOrDefault();
    }

    // ...
}

Lifetime of Services
When you register a service in the DI container, you can specify its lifetime. The lifetime determines how long the service should live in the container and when it should be disposed. The available lifetime options are:

    Singleton: The service is created once and reused throughout the application's lifetime.
    Transient: A new instance of the service is created each time it's requested.
    Scoped: A new instance of the service is created for each HTTP request.

Here's an example of registering a service with a scoped lifetime:
services.AddScoped<IMyService, MyService>();

In this example, we're registering 'IMyService' with a scoped lifetime. This means a new instance of 'MyService' will be created for each HTTP request.

Conditional Registration
You can use conditional registration to register a service only if a certain condition is met. For example, you may want to register a service only if a certain environment variable is set. Here's an example of conditional registration:
services.AddHttpClient();

if (Environment.GetEnvironmentVariable("USE_MOCK_DATA") == "true")
{
    services.AddTransient<IMyService, MockMyService>();
}
else
{
    services.AddTransient<IMyService, RealMyService>();
}

In this example, we're registering two implementations of 'IMyService', one for use when the "USE_MOCK_DATA" environment variable is set to "true" and the other for use when it's not set or set to any other value. This allows you to switch between the two implementations based on a configuration value.

Using Factory Methods
Sometimes, you may need to create a service instance using custom logic rather than just invoking its constructor. For example, you may need to read configuration data or perform other complex logic to create the service. You can use a factory method to create the service instance in these cases.

Here's an example of using a factory method:
services.AddSingleton<IMyService>(sp =>
{
    var configuration = sp.GetRequiredService<IConfiguration>();
    var connectionString = configuration.GetConnectionString("MyDb");
    return new MyService(connectionString);
});

In this example, we're registering 'IMyService' using a factory method. The factory method takes an 'IServiceProvider' as a parameter, which allows it to access other services in the DI container. In this case, we're using the 'IConfiguration' service to read the connection string from the app settings and then create a new instance of 'MyService' with the connection string.

Conclusion
This article explored how to use dependency injection (DI) in ASP.NET Core using C#. We covered the basics of DI, including what it is and why it's important. We then looked at how to set up DI in an ASP.NET Core application, including registering services and injecting dependencies into controllers, services, and middleware.

We also covered some advanced topics in DI, including named and typed services, a lifetime of services, conditional registration, and using factory methods. Using these techniques, you can write more modular and maintainable code, making your applications more robust and scalable.

In summary, DI is a powerful technique that can help you to manage the dependencies between your classes and make your code more modular and maintainable. With ASP.NET Core, using DI is easy and intuitive, and the framework provides many features that make it even more powerful. By taking the time to understand DI and the features available in ASP.NET Core, you can write more effective and efficient applications that are easier to maintain and extend over time.  

In this article, we will learn how to use the YouTube API to retrieve information about a specific video on YouTube, given its video ID. The process involves using Videos.List() method of the YouTubeService class to retrieve the information and specifying the video ID as a parameter.

In a previously published article [YouTube API Integration With C# .NET], we learned how to search for and retrieve a list of videos on YouTube using the YouTube API. The process involves installing the YouTube API client library, obtaining an API key, importing the necessary namespaces and libraries, initializing the YouTube service, and using the Search.List() method of the YouTubeService class to specify the search parameters.

Here is a step-by-step guide on how to use the Videos.List() method to retrieve information about a specific video using the YouTube API in C#:

Step 1. Prerequisites
To Install the YouTube API client library, obtaining an API key, importing the necessary namespaces and libraries, initializing the YouTube service, please see my previous article on [YouTube API Integration With C# .NET].

Step 2. Initialize the YouTubeService Class
The second step is to initialize the YouTubeService class. This class is responsible for making requests to the YouTube API and processing the responses. To initialize the class, you need to pass an instance of the BaseClientService. Initializer class to its constructor. This instance should contain your API key and the name of your application.
YouTubeService youtubeService = new YouTubeService(new BaseClientService.Initializer()
{
    ApiKey = "YOUR_API_KEY",
    ApplicationName = "YOUR_APPLICATION_NAME"
});

Step 3. Define the Video ID
Next, you need to define the video ID of the video you want to retrieve information about. You can find the video ID in the URL of the video. For example, if the URL of the video is https://www.youtube.com/watch?v=abcdefg", the video ID is "abcdefg".
string videoId = "VIDEO_ID";

Step 4. Prepare the Request
Use the Videos.List() method to retrieve information about a specific video. Pass the video ID to the method, and set the Part parameter to “snippet, contentDetails, statistics, status”.
VideosResource.ListRequest listRequest = youtubeService.Videos.List("snippet,contentDetails,statistics,status");
listRequest.Id = videoId;

If you pass the parameter "snippet, contentDetails, statistics, status" to the Part parameter of the Videos.List() method, the following information about the video will be returned:
    Snippet
    This includes information about the video's title, description, channel information, tags, and the video's publication date.
     
    ContentDetails
    This includes information about the video's duration, aspect ratio, definition, and dimensions.
     
    Statistics
    This includes information about the video's view count, like count, dislike count, comment count, and favourite count.
     
    Status
    This includes information about the video's upload status, privacy status, and license information.

Step 5. Execute the Request
Execute the request by calling the Execute() method of the listRequest object.
VideoListResponse response = listRequest.Execute();

Step 6. Access the Video Information
Finally, you can access the information about the video from the response object. You can use the response object to access information such as the video title, description, view count, and more.
foreach(var item in response.Items) {
    Console.WriteLine("Title: " + item.Snippet.Title);
    Console.WriteLine("Description: " + item.Snippet.Description);
    Console.WriteLine("View Count: " + item.Statistics.ViewCount);
}

Below is the complete code for getting a specific YouTube video:
using Google.Apis.YouTube.v3;
using Google.Apis.YouTube.v3.Data;
using Google.Apis.Services;
using System;
namespace YouTubeAPIDemo {
    class Program {
        static void Main(string[] args) {
            // Initialize the YouTubeService class
            YouTubeService youtubeService = new YouTubeService(new BaseClientService.Initializer() {
                ApiKey = "YOUR_API_KEY",
                    ApplicationName = "YOUR_APPLICATION_NAME"
            });
            // Define the video ID
            string videoId = "VIDEO_ID";
            // Prepare the request
            VideosResource.ListRequest listRequest = youtubeService.Videos.List("snippet,contentDetails,statistics,status");
            listRequest.Id = videoId;
            try {
                // Execute the request
                VideoListResponse response = listRequest.Execute();
                // Access the video information
                foreach(var item in response.Items) {
                    Console.WriteLine("Title: " + item.Snippet.Title);
                    Console.WriteLine("Description: " + item.Snippet.Description);
                    Console.WriteLine("View Count: " + item.Statistics.ViewCount);
                }
            } catch (Exception e) {
                // Log the error
                Console.WriteLine("An error occurred: " + e.Message);
            }
            Console.ReadLine();
        }
    }
}

Note
You should replace the placeholders "YOUR_API_KEY" and "YOUR_APPLICATION_NAME" with your actual API key and application name, and replace "VIDEO_ID" with the actual video ID of the video, you want to retrieve information about. So here we have seen a very basic example of how to get video details by Video ID.

In conclusion, YouTube API's Videos resource provides an efficient way for developers to access and retrieve information about videos.

You can explore more by clicking here to YouTube API documentation for the Video's resource. The Videos resource provides methods for retrieving information about videos on YouTube, including the video's metadata and status, as well as information about the channel that uploaded the video. The resource provides methods for retrieving specific videos by ID, as well as methods for retrieving a list of videos that match specific criteria. The documentation provides detailed information about the available parameters for each method, as well as information about the format of the returned data.

I hope you will find this article helpful. If you have any suggestions, then please feel free to ask in the comment section.

Thank you.

.Net provides lots of types of Timer classes that you, as a developer, probably have come across in your day-to-day work. Below is the list:
    System.Web.UI.Timer
    System.Windows.Forms.Timer
    System.Timers.Timer
    System.Threading.Timer
    System.Windows.Threading.DispatcherTimer

.NET 6 introduces one more timer class, called PeriodicTimer. It doesn't rely on callbacks and instead waits asynchronously for timer ticks. So, if you don't want to use the callbacks as it has their own flaws WaitForNextTickAsync is a good alternative.

You can create the new PeriodicTimer instance by passing the one argument Period, the time interval in milliseconds between invocations
// create a new instance of PeriodicTimer which ticks after 1 second interval
PeriodicTimer secondTimer = new PeriodicTimer(new TimeSpan(0, 0, 1));

How to use Periodic Timer
You can call the WaitForNextTickAsync method in an infinite for or while loop to wait asynchronously between ticks.
while (await secondTimer.WaitForNextTickAsync())
{
     // add your async business logic here
}

Example
Let's write a small console application with two methods having their own PeridicTimer instances, one is configured to tick every minute and another one that ticks every second.

With every tick, increase the counter by one and print it in the console.
static async Task SecondTicker()
{
    PeriodicTimer secondTimer = new PeriodicTimer(new TimeSpan(0, 0, 1));

    while (await secondTimer.WaitForNextTickAsync())
    {
        secs++;
        Console.SetCursorPosition(0, 0);
        Console.Write($"secs: {secs.ToString("00")}");
    }
}

Another one, which sets the second counter to 0 as every minute elapses.
static async Task MinuteTicker()
{
    PeriodicTimer minuteTimer = new PeriodicTimer(new TimeSpan(0, 1, 0));

    while (await minuteTimer.WaitForNextTickAsync())
    {
        mins++;
        secs = 0;
        Console.SetCursorPosition(0, 1);
        Console.Write($"mins: {mins.ToString("00")}");
    }
}

Now let's run them in parallel
static int secs = 0, mins = 0;
static async Task Main(string[] args)
{
    Console.WriteLine("secs: 00");
    Console.WriteLine("mins: 00");

    var secondTicks = SecondTicker();
    var minuteTicks = MinuteTicker();
    await Task.WhenAll(secondTicks, minuteTicks);
}

That way we have two PeridicTimer instances running parallelly without blocking each other and here is the result.

Output

Key Notes

    This timer is intended to be used only by a single consumer at a time
    You can either use the  CancellationToken or call the Dispose() method to interrupt it and cause WaitForNextTickAsync() to return false