Forem: Satya Karki

Unlocking Sentiment Insights in .NET 9 with ML.NET

Satya Karki — Mon, 07 Apr 2025 02:33:45 +0000

ML.NET is a tool for machine learning that was created by Microsoft. It’s designed for developers who are familiar with the .NET framework. With ML.NET, you can build, train, and deploy custom machine learning models without having to leave the .NET ecosystem. Thanks to the performance optimizations and seamless integration capabilities of .NET 9, ML.NET is an even better choice for adding intelligence to your applications. In this article, we’ll explore real-world use cases and provide sample code to help you implement them.

What Makes ML.NET Special?

Native .NET Integration: You can write machine learning code in C# or F#, using familiar tools like Visual Studio.
Wide Range of Algorithms: It supports classification, regression, clustering, anomaly detection, and more.
Model Builder: A GUI tool to simplify model creation for beginners.
It can also handle large data sets and works with cloud-based .NET 9 apps. Pre-trained models work with ONNX, TensorFlow, and Azure Cognitive Services for more complex situations.

Sentiment Analysis

Sentiment analysis is the process of determining the emotional tone behind text. It’s a powerful tool for businesses and developers. It can be used to gauge customer feedback, analyze social media trends, or enhance user experiences. Sentiment analysis can unlock valuable insights. With .NET 9 and ML.NET, Microsoft’s machine learning framework, developers can seamlessly integrate this capability into their applications without leaving the .NET ecosystem. In this article, we’ll show you how to create a sentiment analysis API in .NET 9 using ML.NET. We’ll provide practical code examples and tips for optimization.

Project Overview: Sentiment Analysis API

We’ll build an ASP.NET Core Web API that predicts whether a piece of text expresses positive or negative sentiment. This example will use ML.NET to train a model and deploy it within a .NET 9 application, showing how simple and useful it is.

For complete source code: Click here

Step 1: Setting Up the Project

Create a new ASP.NET Core Web API project:

dotnet new webapi -n dotnet9SentimentApi -f net9.0
cd dotnet9SentimentApi

Open the folder in VS code. The project should be as shown below:

Let’s add the ML.NET NuGet package:

You can either run command or do from VS code UI as illustrated below:

dotnet add package Microsoft.ML

Step 2: Define the Data Models

Create a folder named Models and add two classes: SentimentData and SentimentPrediction

SentimentData.cs: Represents the input data for the model.

namespace dotnet9SentimentApi.Models;

public record SentimentData
{
    public string Text { get; set; } = string.Empty;
}

SentimentPrediction.cs: Represents the model’s output.

namespace dotnet9SentimentApi.Models;

public record SentimentPrediction
{
    public bool Prediction { get; set; } // True = Positive, False = Negative
    public float Probability { get; set; }
}

Step 3: Training a Simple Sentiment Model with ML.NET

For simplicity, we’ll use a pre-trained model approach here, but ML.NET allows you to train your own model with a dataset. Create a SentimentModelTrainer.cs class in a Services folder to simulate model setup:

To train the model with your own data:

private void TrainModel()
    {
        // Simulated training data (in practice, load from a file or database)
        var data = BuildTrainingData();

        var dataView = _mlContext.Data.LoadFromEnumerable(data);

        // Enhanced pipeline with text preprocessing
        var pipeline = _mlContext.Transforms.Text.FeaturizeText("Features", new Microsoft.ML.Transforms.Text.TextFeaturizingEstimator.Options
        {
            WordFeatureExtractor = new Microsoft.ML.Transforms.Text.WordBagEstimator.Options(),
            StopWordsRemoverOptions = new Microsoft.ML.Transforms.Text.StopWordsRemovingEstimator.Options()
        }, nameof(SentimentTrainingData.Text))
            .Append(_mlContext.BinaryClassification.Trainers.LbfgsLogisticRegression(labelColumnName: nameof(SentimentTrainingData.Sentiment)));

        // Train the model
        _model = pipeline.Fit(dataView);

        // Optional: Save the model for reuse
        _mlContext.Model.Save(_model, dataView.Schema, "sentiment_model.zip");
    }

Note: In a real-world scenario, you’d train with a larger dataset (e.g., from a CSV file) and save the model using _mlContext.Model.Save().

Complete SentimentModelTrainer.cs class:

using System;
using dotnet9SentimentApi.Models;
using Microsoft.ML;

namespace dotnet9SentimentApi.Services;

public <em>class</em> SentimentModelTrainer
{
    private readonly MLContext _mlContext;
    private ITransformer _model;

    public SentimentModelTrainer()
    {
        _mlContext = new MLContext();
        TrainModel();

    }

    private void TrainModel()
    {
        // Simulated training data (in practice, load from a file or database)
        var data = BuildTrainingData();

        var dataView = _mlContext.Data.LoadFromEnumerable(data);
        // Enhanced pipeline with text preprocessing
        var pipeline = _mlContext.Transforms.Text.FeaturizeText("Features", new Microsoft.ML.Transforms.Text.TextFeaturizingEstimator.Options
        {
            WordFeatureExtractor = new Microsoft.ML.Transforms.Text.WordBagEstimator.Options(),
            StopWordsRemoverOptions = new Microsoft.ML.Transforms.Text.StopWordsRemovingEstimator.Options()
        }, nameof(SentimentTrainingData.Text))
            .Append(_mlContext.BinaryClassification.Trainers.LbfgsLogisticRegression(labelColumnName: nameof(SentimentTrainingData.Sentiment)));

        // Train the model
        _model = pipeline.Fit(dataView);

        // Optional: Save the model for reuse
        _mlContext.Model.Save(_model, dataView.Schema, "sentiment_model.zip");
    }

    public SentimentPrediction Predict(string text)
    {
        var predictionEngine = _mlContext.Model.CreatePredictionEngine<SentimentData, SentimentPrediction>(_model);
        return predictionEngine.Predict(new SentimentData { Text = text });
    }

    //build training data
    private List<SentimentTrainingData> BuildTrainingData()
    {
        return new List<SentimentTrainingData>
        {
            new() { Text = "I love this product!", Sentiment = true },
            new() { Text = "This is terrible.", Sentiment = false },
            new() { Text = "The weather is nice!", Sentiment = true },
            new() { Text = "Horrible service, never again.", Sentiment = false },
            new() { Text = "Absolutely fantastic experience!", Sentiment = true },
            new() { Text = "It’s a complete disaster.", Sentiment = false },
            new() { Text = "I’m so happy with this!", Sentiment = true },
            new() { Text = "Disappointing and awful.", Sentiment = false },
            new() { Text = "I’m so impressed!", Sentiment = true },
            new() { Text = "I’m never coming back.", Sentiment = false },
            new() { Text = "I’m so excited!", Sentiment = true },
            new() { Text = "I’m so disappointed.", Sentiment = false },
            new() { Text = "I’m so pleased with this!", Sentiment = true },
            new() { Text = "I’m so upset.", Sentiment = false },
            new() { Text = "I’m so satisfied with this!", Sentiment = true },
            new() { Text = "I’m so angry.", Sentiment = false },
            new() { Text = "I’m so grateful for this!", Sentiment = true },
            new() { Text = "I’m so annoyed.", Sentiment = false },
            new() { Text = "I’m so thankful for this!", Sentiment = true }
        };
    }


}
public record SentimentTrainingData
{
    public string Text { get; set; } = string.Empty;
    public bool Sentiment { get; set; }
}

Step 4: Build the API Controller

Create a SentimentController in the Controllers folder:

using dotnet9SentimentApi.Models;
using dotnet9SentimentApi.Services;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace dotnet9SentimentApi.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public <em>class</em> SentimentController : ControllerBase
    {
        private readonly SentimentModelTrainer _modelTrainer;

        public SentimentController(SentimentModelTrainer modelTrainer)
        {
            _modelTrainer = modelTrainer;
        }

        [HttpPost("analyze")]
        public ActionResult<SentimentPrediction> AnalyzeSentiment([FromBody] SentimentData input)
        {
            if (string.IsNullOrEmpty(input.Text))
                return BadRequest("Text cannot be empty.");

            var prediction = _modelTrainer.Predict(input.Text);
            return Ok(new { Sentiment = prediction.Prediction ? "Positive" : "Negative", Confidence = prediction.Probability });
        }
    }
}

Step 5: Register Services in Program.cs

Update Program.cs to use minimal APIs and register the service:

// Add services to the container
builder.Services.AddControllers();
builder.Services.AddSingleton<SentimentModelTrainer>();

// Configure the HTTP request pipeline
app.UseHttpsRedirection();
app.MapControllers();

Complete code for Program.cs

using dotnet9SentimentApi.Services;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
// Learn more about configuring OpenAPI at https://aka.ms/aspnet/openapi
builder.Services.AddOpenApi();

// Add services to the container
builder.Services.AddControllers();
builder.Services.AddSingleton<SentimentModelTrainer>();

var app = builder.Build();

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

// Configure the HTTP request pipeline
app.UseHttpsRedirection();
app.MapControllers();
app.Run();

Our solution is ready to test.

For complete source code: Click here

Test the API
dotnet run
You can use postman to test the api or http file in VS code. I will test using VS code .http file.

@dotnet9SentimentApi_HostAddress = http://localhost:5288

# post analyze sentiment
POST {{dotnet9SentimentApi_HostAddress}}/api/sentiment/analyze
Content-Type: application/json

{
  "text": "I am not happy with the result!"
}

###

The result is shown below.

The result is not as expected – indicates an issue with the sentiment analysis model’s training or configuration. Given the tiny dataset and simplistic setup in the original sample, the model isn’t learning meaningful patterns.

However, we can improve the result with more training data and testing.

Enhancing the Project

Scalability: Deploy to Azure with container support for cloud-native scaling.
Model Accuracy: Use a real dataset (e.g., IMDB reviews) and train with more sophisticated algorithms like FastTree.
Performance: Cache predictions for frequently analyzed text using MemoryCache.
Integration: Extend with Azure Cognitive Services or TensorFlow.NET for advanced AI capabilities.

Conclusion

Sentiment analysis in .NET 9 using ML.NET is easy to use and powerful. It lets developers add intelligence to their applications with little complexity. This API shows the basics, but there are many possibilities. You can integrate it with real-time data, use .NET 9’s cloud-native features, or enhance it with pre-trained models. As you explore further, you will see that ML.NET and .NET 9 together offer a robust platform for sentiment analysis and more.

Middleware Mastery in .NET with Essential Techniques and Hands-On Examples

Satya Karki — Thu, 20 Mar 2025 14:53:40 +0000

Middleware is an essential component of the ASP.NET request pipeline. It allows developers to run code during both the request and response lifecycle. In this article, we will explore what middleware is, and how it works, and provide real-world practical use cases with complete code examples.

What is Middleware in .NET?

Middleware in .NET is a software component that processes HTTP requests and responses. It is executed in a pipeline, where each middleware component can perform an action and decide whether to pass the request further or return a response.

Key Characteristics of Middleware

Executes sequentially in the request pipeline.
Can modify request and response objects.
Can terminate request processing if needed.
Supports dependency injection.
Used for authentication, logging, rate limiting, and more.

How Middleware Works in .NET?

Middleware components are registered in the Program.cs file using the UseMiddleware() method or inline with app.Use(). The middleware pipeline is executed in the order they are added.

Receives an HttpContext
Performs operations (e.g., logging, authentication, etc.)
Calls the next middleware in the pipeline (or short-circuits the request)

Real-world middleware Use Cases with Code Examples

1. Request Logging Middleware

Use Case: Logging request and response details for debugging and monitoring.

Implementation

public class RequestLoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestLoggingMiddleware> _logger;

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

    public async Task Invoke(HttpContext context)
    {
        _logger.LogInformation($"Request: {context.Request.Method} {context.Request.Path}");
        await _next(context);
    }
}

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.UseMiddleware<LoggingMiddleware>(); //register here!!

app.Run(async (context) =>
{
    await context.Response.WriteAsync("Hello, Middleware!");
});

app.Run();

2. Custom Authentication Middleware

Use Case: Checking if a request contains a valid API key before processing.

Implementation

public class ApiKeyMiddleware
{
    private readonly RequestDelegate _next;
    private const string API_KEY = "123456"; // Hardcoded for demonstration

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

    public async Task Invoke(HttpContext context)
    {
        if (!context.Request.Headers.TryGetValue("X-API-KEY", out var extractedApiKey) || extractedApiKey != API_KEY)
        {
            context.Response.StatusCode = 401; // Unauthorized
            await context.Response.WriteAsync("Invalid API Key.");
            return;
        }

        await _next(context);
    }
}

app.UseMiddleware<ApiKeyMiddleware>();

3. Exception Handling Middleware

Use Case: Global error handling to return meaningful error responses.

Implementation

public class ExceptionHandlingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<ExceptionHandlingMiddleware> _logger;

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

    public async Task Invoke(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "An unhandled exception occurred.");
            context.Response.StatusCode = 500;
            await context.Response.WriteAsync("An unexpected error occurred.");
        }
    }
}

4. Rate Limiting Middleware

Use Case: Preventing abuse by limiting the number of requests from a client in a given time period.

Implementation

public class RateLimitingMiddleware
{
    private static readonly Dictionary<string, (int Count, DateTime LastRequest)> _clients = new();
    private readonly RequestDelegate _next;
    private const int Limit = 5;
    private static readonly TimeSpan TimeWindow = TimeSpan.FromMinutes(1);

    public RateLimitingMiddleware(RequestDelegate next) => _next = next;

    public async Task Invoke(HttpContext context)
    {
        var clientIP = context.Connection.RemoteIpAddress?.ToString();
        if (clientIP == null || !_clients.ContainsKey(clientIP) || DateTime.UtcNow - _clients[clientIP].LastRequest > TimeWindow)
            _clients[clientIP] = (1, DateTime.UtcNow);
        else if (_clients[clientIP].Count >= Limit)
        {
            context.Response.StatusCode = 429;
            await context.Response.WriteAsync("Rate limit exceeded. Try again later.");
            return;
        }
        else
            _clients[clientIP] = (_clients[clientIP].Count + 1, DateTime.UtcNow);

        await _next(context);
    }
}

5. Content Compression Middleware

Use Case: Compressing responses to improve performance.

We can use built-in Response Compression or custom Content Compression Middleware.

Implementation:built-in

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddResponseCompression(options =>
{
    options.EnableForHttps = true; // Enable compression for HTTPS requests
    options.Providers.Add<BrotliCompressionProvider>(); // Brotli compression
    options.Providers.Add<GzipCompressionProvider>();  // Gzip compression
});

builder.Services.Configure<GzipCompressionProviderOptions>(options =>
{
    options.Level = System.IO.Compression.CompressionLevel.Fastest; // Adjust compression level
});

var app = builder.Build();

app.UseResponseCompression(); // Enable middleware

app.MapGet("/", async context =>
{
    var responseText = new string('A', 1000); // Large response for compression testing
    await context.Response.WriteAsync(responseText);
});

app.Run();

6. Custom Content Compression Middleware

If you need more control over compression, you can write a custom middleware.

Implementation

public class CustomCompressionMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task Invoke(HttpContext context)
    {
        var originalBodyStream = context.Response.Body;
        using var compressedStream = new MemoryStream();
        using var gzipStream = new GZipStream(compressedStream, CompressionMode.Compress, true);

        context.Response.Body = gzipStream;
        context.Response.Headers.Add("Content-Encoding", "gzip"); // Indicate compression

        await _next(context);

        gzipStream.Close();
        compressedStream.Seek(0, SeekOrigin.Begin);
        await compressedStream.CopyToAsync(originalBodyStream);
    }
}

7. Request Timing Middleware

Use Case: Measuring the time taken to process a request.

Implementation

public class RequestTimingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestTimingMiddleware> _logger;

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

    public async Task Invoke(HttpContext context)
    {
        var stopwatch = Stopwatch.StartNew();
        await _next(context);
        stopwatch.Stop();

        _logger.LogInformation($"Request took {stopwatch.ElapsedMilliseconds} ms");
    }
}

8. Maintenance Mode Middleware

Use Case: Temporarily disabling access to an application during updates.

Implementation

public class MaintenanceMiddleware
{
    private readonly RequestDelegate _next;
    private readonly bool _isUnderMaintenance = true; // Change to false to disable maintenance mode

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

    public async Task Invoke(HttpContext context)
    {
        if (_isUnderMaintenance)
        {
            context.Response.StatusCode = 503;
            await context.Response.WriteAsync("The site is under maintenance. Please try again later.");
            return;
        }

        await _next(context);
    }
}

9. Geo-Blocking Middleware

Use Case: Restricting access to specific countries based on IP address.

Implementation

public class GeoBlockingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly List<string> _blockedCountries = new() { "CN", "RU", "IR" }; // Example blocked countries

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

    public async Task Invoke(HttpContext context)
    {
        string userCountry = GetUserCountry(context); // Implement this based on an IP lookup service

        if (_blockedCountries.Contains(userCountry))
        {
            context.Response.StatusCode = 403;
            await context.Response.WriteAsync("Access denied for your region.");
            return;
        }

        await _next(context);
    }

    private string GetUserCountry(HttpContext context)
    {
        // Placeholder logic, use a third-party API or database lookup to determine the country from IP
        return "US"; // Assume US for this example
    }
}

10. Request IP Logger Middleware

Use Case: Logging the IP address of every client making a request.

Implementation

public class RequestIpLoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestIpLoggingMiddleware> _logger;

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

    public async Task Invoke(HttpContext context)
    {
        var ip = context.Connection.RemoteIpAddress?.ToString();
        _logger.LogInformation($"Request received from IP: {ip}");

        await _next(context);
    }
}

11. User Activity Tracking Middleware

public class UserActivityMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<UserActivityMiddleware> _logger;

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

    public async Task Invoke(HttpContext context)
    {
        var user = context.User.Identity?.Name ?? "Anonymous";
        var path = context.Request.Path;
        _logger.LogInformation($"User: {user} accessed {path} at {DateTime.UtcNow}");

        await _next(context);
    }
}

12. Dark Mode Cookie Middleware

Use Case: Storing user preferences (like dark mode) in cookies.

public class DarkModeMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task Invoke(HttpContext context)
    {
        if (!context.Request.Cookies.ContainsKey("DarkMode"))
        {
            context.Response.Cookies.Append("DarkMode", "false");
        }

        await _next(context);
    }
}

Likewise, we can use middleware in .NET for several other use cases.

Conclusion

Middleware is a powerful feature in .NET applications that allows developers to enhance security, optimize performance, and improve user experience. The examples above demonstrate how middleware can be used for logging, authentication, exception handling, rate limiting, rate timing response compression, and caching.

By leveraging middleware effectively, developers can build scalable, maintainable, and high-performance applications. Whether you’re securing APIs, optimizing request handling, or improving efficiency, middleware provides a flexible and extensible solution for modern .NET applications.

Reference

dotnetcopilot.com

ASP.NET Core Security: Using Azure Key Vault for Secret Storage

Satya Karki — Mon, 17 Mar 2025 09:31:32 +0000

Introduction

In modern cloud applications, securely managing sensitive data like API keys, database connection strings, and certificates is crucial. Hardcoding secrets in configuration files pose security risks, making applications vulnerable to breaches. Azure Key Vault offers a secure and centralized solution to store and manage secrets, ensuring they are protected and accessible only to authorized services.

This article provides a step-by-step guide to implementing Azure Key Vault in an ASP.NET Core application. You’ll learn how to store secrets in Key Vault, retrieve them dynamically in .NET applications, and configure secure access using Managed Identity. By following this approach, you can enhance security, simplify secret management, and ensure compliance with best practices in cloud security.

What is Azure Key Vault?

Azure Key Vault is a cloud-based service that securely stores and manages secrets, such as API keys, passwords, certificates, and cryptographic keys. It enhances security by controlling access to sensitive data and allows applications to retrieve secrets securely.

Why Use Azure Key Vault?

Centralized Security Management: Store secrets in one place instead of in appsettings.json or environment variables.
Access Control with RBAC: Uses Azure Active Directory (AAD) authentication for access.
Automatic Secret Rotation: Easily update and manage secrets without modifying the application code.
Compliance & Auditing: Meets security standards like ISO 27001, FedRAMP, and GDPR.

Implementing in ASP.NET Core project

Step 1. Create an Azure Key Vault

Step 1. Go to Azure Portal → Create a resource → Search for “Key Vault”.
Step 2. Click Create, and enter the following:

Resource Group: Select an existing one or create a new one.
Key Vault Name: Example: MyAppKeyVault
Region: Choose your Azure region.
Pricing Tier: Standard is fine for most cases.

Step 3. Click Review + Create → Create.

Step 2. Add Secrets to Azure Key Vault

Open Key Vault → Secrets → Click Generate/Import.
Enter Name (e.g., DatabaseConnection) and Value (e.g., Server=myserver;Database=mydb;User Id=myuser;Password=mypassword;).
Click Create.

Step 3. Assign Permissions (Managed Identity)

Step 1. Enable Managed Identity for Your App:

Go to Azure App Service → Identity → Enable System-Assigned Identity → Save.

Step 2. Grant Access in Key Vault:

Go to Key Vault → Access Control (IAM) → Add Role Assignment.
Select Key Vault Secrets User.
Assign to Your App Service.

Step 4. Create a new ASP.NET Core Web API project and Install the below NuGet Packages

Note: If you need to implement this in your existing project you don’t need to create a new project.

Run these commands to install the required dependencies:
dotnet add package Azure.Security.KeyVault.Secrets dotnet add package Azure.Identity

Step 5. Add the below code to Configure in appsettings.json

Add your Key Vault URL:

{
  "AzureKeyVault": {
    "VaultUri": "https://myappkeyvault.vault.azure.net/"
  }
}

Step 6. Load Azure Key Vault Secrets in the Program.cs

Modify Program.cs to fetch secrets securely:

// Get Key Vault URL from configuration
var keyVaultUrl = builder.Configuration["AzureKeyVault:VaultUri"];

if (!string.IsNullOrEmpty(keyVaultUrl))
{
    var client = new SecretClient(new Uri(keyVaultUrl), new DefaultAzureCredential());

    // Retrieve and load secrets into IConfiguration
    var secrets = client.GetPropertiesOfSecrets();
    foreach (var secret in secrets)
    {
        var secretValue = client.GetSecret(secret.Name);
        builder.Configuration[secret.Name] = secretValue.Value.Value;
    }
}

Step 7. Retrieve Secrets in a Controller

Create SecretsController.cs to test Key Vault secret retrieval:

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;

namespace KeyVaultDemo.Controllers
{
    [ApiController]
    [Route("api/secrets")]
    public class SecretsController : ControllerBase
    {
        private readonly IConfiguration _configuration;

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

        [HttpGet("{secretName}")]
        public IActionResult GetSecret(string secretName)
        {
            var secretValue = _configuration[secretName];
            if (string.IsNullOrEmpty(secretValue))
            {
                return NotFound($"Secret '{secretName}' not found.");
            }

            return Ok(new { secretName, secretValue });
        }
    }
}

Step 8. Run & Test the API

Now we can run and check the secrets value.

If you are using Visual Studio you can simply run the project or can use command.

dotnet run

Then we can use the http file or Postman to call the API. Below is the output of calling GetSecret API from the http file.

The sample code for this can be found here.

Conclusion

Azure Key Vault is an essential tool for securing sensitive information such as API keys, database credentials, and certificates in cloud applications. By integrating it into an ASP.NET Core application, we eliminate the risks of storing secrets in configuration files or hardcoding them in source code. In this guide, we covered the step-by-step implementation of Azure Key Vault in .NET 9, from creating a Key Vault to retrieving secrets dynamically using Azure.Identity and Azure.Security.KeyVault.Secrets.

We also demonstrated how to secure access using Managed Identity. By leveraging Azure Key Vault, your application benefits from enhanced security, centralized secret management, automatic secret rotation, and compliance with industry standards. Implementing this best practice ensures your applications remain secure, scalable, and manageable in a cloud environment.

A Complete Guide to Quartz.NET Job Scheduling in ASP.NET Core

Satya Karki — Sun, 16 Mar 2025 11:49:17 +0000

Introduction

Quartz.NET is an open-source job scheduling library for .NET applications, enabling developers to execute background tasks at specified times or intervals. This article explains what is quartz, it’s applications and use cases. Additionally, it will demonstrate how to implement it in a .NET application with an example and code sample.

What is Quartz.NET?

Quartz.NET is an open-source job scheduling library for .NET applications. It provides a robust, feature-rich, and scalable scheduling solution that enables developers to execute background tasks at specific times or intervals. Quartz.NET is a port of the Java-based Quartz Scheduler and is widely used in enterprise applications to handle scheduled jobs efficiently.

Why Use Quartz.NET?

In many software applications, there is a need to execute tasks at scheduled times, such as:

Running background maintenance tasks (e.g., cleaning logs, updating records, generating reports)
Sending scheduled notifications (emails, push notifications, SMS reminders)
Processing queued jobs asynchronously
Automating workflows and batch processing
Quartz.NET helps to achieve these functionalities with its flexible scheduling capabilities, making it an essential tool for developers.

Key Features of Quartz.NET

Quartz.NET provides several powerful features for developers for examples:

Flexible Scheduling: Supports simple intervals (e.g., every 10 minutes) and complex Cron-like expressions.
Persistent Jobs: Jobs can be stored in a database for reliability and resilience.
Clustered Execution: Supports job execution across multiple servers to ensure high availability.
Dependency Injection Support: Works seamlessly with .NET Core dependency injection.
Scalability: Can handle thousands of scheduled jobs with high performance.
Transactional Support: Ensures that jobs are executed reliably within a transactional context.
Multiple Job Types: Supports one-time jobs, recurring jobs, and jobs triggered by events.

Common use cases of Quartz.NET

1. Automated Report Generation

Many businesses require periodic reports (e.g., daily sales reports and system health reports). Quartz.NET can schedule jobs to generate and send these reports automatically.

2. Email and Notification Scheduling

Applications often send reminders, promotional emails, or system alerts at specific times. With Quartz.NET, you can schedule and manage email campaigns efficiently.

3. Database Maintenance Tasks

Background jobs like data cleanup, indexing, or archiving old records can be scheduled using Quartz.NET, ensuring the database remains optimized.

4. Batch Processing and Data Synchronization

Enterprise applications often require data synchronization between different systems. Quartz.NET can execute these tasks at defined intervals to maintain data consistency.

5. Automating Business Processes

Businesses use workflows for tasks like invoice generation, order processing, and billing cycles. Quartz.NET allows developers to schedule these processes efficiently.

How Quartz.NET Works?

Quartz.NET operates based on three core components:

Jobs: Define the task to be executed.
Triggers: Determine when the job should run (e.g., every hour, once a day, specific dates).
Schedulers: Manage and execute jobs based on their triggers.

Now, let’s move for implementation of Quartz.NET.

Implementing Quartz.NET in ASP.NET core web API

Step 1. Create ASP.NET Core Web API project using Visual Studio or VS code.

Step 2. Install the following packages for Quartz.NET

Install-Package Quartz

If you need JSON Serialization, just add the either Quartz.Serialization.SystemTextJson or Quartz.Serialization.Json package the same way.

Step 3. Code implementation

In Program.cs add the following line to register Quartz.NET as a hosted service.

// Add Quartz.NET as a hosted service
builder.Services.AddQuartzHostedService(options =>
{
    options.WaitForJobsToComplete = true;
});

Step 4. We will create Interface and service for Quartz Scheduler as follows:

public interface IQuartzJobScheduler
{
    Task ScheduleJobAsync<TJob>(TimeSpan delay, string userId, string message, CancellationToken cancellationToken) where TJob : IJob;
}

public class QuartzJobScheduler(ISchedulerFactory schedulerFactory, ILogger<QuartzJobScheduler> logger) : IQuartzJobScheduler
{
    private readonly ISchedulerFactory _schedulerFactory = schedulerFactory;
    private IScheduler? _scheduler;
    private readonly ILogger<QuartzJobScheduler> _logger = logger;

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        _scheduler = await _schedulerFactory.GetScheduler(cancellationToken);
        await _scheduler.Start(cancellationToken);
    }

    public async Task ScheduleJobAsync<TJob>(TimeSpan delay, string userId, string message, CancellationToken cancellationToken) where TJob : IJob
    {
        _logger.LogInformation("Scheduling job {JobName} for user {UserId} with message {Message}", typeof(TJob).Name, userId, message);

        var jobDetail = JobBuilder.Create<TJob>()
            .WithIdentity($"{typeof(TJob).Name}-{userId}")
            .UsingJobData("userId", userId)
            .UsingJobData("message", message)
            .Build();

        var scheduler = await _schedulerFactory.GetScheduler();
        var trigger = TriggerBuilder.Create()
            .StartAt(DateTimeOffset.Now.Add(delay))
            .Build();

        await scheduler.ScheduleJob(jobDetail, trigger, cancellationToken);
    }
}

Then, we will register Dependency in the services in Program.cs, as shown below.

//add dependency injection for QuartzJobScheduler
builder.Services.AddSingleton<IQuartzJobScheduler, QuartzJobScheduler>();

Here is a sample controller for the Schedular.

using Microsoft.AspNetCore.Mvc;
using QuartzSceduleSample.Jobs;

namespace QuartzSceduleSample.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class TestSceduleController : ControllerBase
    {
        private readonly IQuartzJobScheduler _quartzJobScheduler;
        public TestSceduleController(IQuartzJobScheduler quartzJobScheduler)
        {
            _quartzJobScheduler = quartzJobScheduler;
        }
        [HttpPost]
        public async Task<IActionResult> PostAsync(CancellationToken cancellationToken)
        {
            //create a new job sample job
            await _quartzJobScheduler.ScheduleJobAsync<EmailReminderJob>(TimeSpan.FromSeconds(10), "123", "Hello World", cancellationToken);
            return Ok("Job is scheduled");
        }
    }
}

In the above code, we schedule the job after 10 seconds.

Below is the project structure.

Now, let’s call the API and check the output of the controller is given below.

We will see the job will be executed after 10 seconds.

Here is the repository with the complete code, Click here.

Conclusion

Quartz.NET is a powerful and flexible job scheduling library that seamlessly integrates with ASP.NET Core. It enables developers to automate background tasks, schedule recurring jobs, and manage workflows efficiently. By implementing Quartz.NET, you can improve application performance, optimize resource utilization, and ensure timely execution of critical tasks. Whether you’re handling database cleanups, email notifications, or report generation, Quartz.NET provides a reliable solution for job scheduling in ASP.NET Core applications.

Reference

Quartz.NET

Features of .NET 8

Satya Karki — Tue, 16 Jan 2024 10:17:38 +0000

Microsoft released and introduced the .NET 8 on Nov 14th, 2023, the latest Long-Term Support (LTS) version of a premier development platform. .NET 8 brings forth numerous enhancements in performance, stability, and security. Additionally, it incorporates improvements in platforms and tools, fostering increased developer productivity and innovation velocity.

In this latest release, .NET transforms the landscape of constructing intelligent, cloud-native applications and high-traffic services designed to scale dynamically. Whether you opt for deployment on Linux or Windows, utilize containers, or follow a preferred cloud app model, .NET 8 simplifies the process of building such applications. It encompasses a collection of established libraries currently employed by numerous high-scale services at Microsoft. These libraries address fundamental challenges related to observability, resiliency, scalability, manageability, and beyond.

.NET 8 seamlessly incorporates extensive language models such as OpenAI’s GPT into your .NET application. Leverage a unified and robust component model for addressing all your web UI requirements through Blazor. Furthermore, you can effortlessly deploy your mobile applications on the newest versions of iOS and Android using .NET MAUI. Additionally, you can explore enhanced language features in C# 12 that enhance code conciseness and expressiveness.

You can download the .NET 8 SDK from here or you can use Visual Studio 2022 latest release Visual Studio 2022 17.8 release. If you have already Visual Studio 2022, then you can just upgrade to Visual Studio 2022 17.8 from the Visual Studio installer itself.

The features of .NET 8, as announced on the official Microsoft DevBlog, encompass a myriad of advancements. This release is characterized by thousands of improvements in performance, stability, and security.

Some of the Key Features are:
C# 12

.NET 8 release with C#12. In C# 12, any class or struct can now have primary constructors created with a concise syntax, eliminating the need for boilerplate code to initialize fields and properties. More here: Primary Constructor in C#
Additionally, we can use new default values for parameters in lambda expressions, which enhance code expressiveness.
You don’t need more overloading or null checks to handle optional arguments.
Moreover, can use the using directive to alias any type, not just named types.

ASP.NET Core 8

In ASP.NET Core 8 application you can see significant performance improvements, up to 18%, compared to .NET 7.
Native Ahead-of-Time (AOT) support for producing self-contained apps compiled into native code, resulting in smaller deployment size, quicker startup, and reduced memory usage.

Entity Framework Core 8

Entity Framework Core 8 supports for complex types for value objects (without identity), for example Address or Coordinate is included.
You can find the added support for lazy-loading of no-tracking queries for your program.

Performance Enhancements

Introduction of Dynamic Profile-Guided Optimization (PGO), optimizing code based on real-world usage, improving app performance by up to 20%.
Rewriting certain methods for better performance, including List.AddRange(IEnumerable) and Int32.ToString().

Cloud-Native Stack (.NET Aspire)

.NET Aspire is another cool feature added in the .NET 8.
The .NET 8 has first preview of .NET Aspire, an opinionated stack for building resilient, observable, and configurable cloud-native applications.
You can develop specific components for cloud-native development, such as a dashboard, telemetry, configuration, health checks, orchestration, etc.

Getting started with cloud native app with .NET Aspire can be found here.

Artificial Intelligence

.NET 8 makes ease of use of AI via first-class out of the box AI features in it’s SDK.
.NET 8 brings several enhancements to the System.Numeric library to enhance compatibility with Generative AI into .NET application. You can infuse AI into your .NET applications easily.
Large language Model integration with semantic Kernel.
It is simple to get started with Azure Open AI and Azure Cognitive Search SDKs in .NET 8.

Blazor Enhancements

Now, you can use Blazor for both client-side (Blazor WebAssembly) and server-side (Blazor Server) rendering in the same app.
It supports stateless server-side rendering, streaming rendering, progressive enhancement for navigation and form handling, and interactivity per component.

.NET MAUI

.NET MAUI is Successor to Xamarin.Forms, enabling the creation of projects for different platforms (WinUI, Mac, iOS, Android) with a single codebase.
.NET MAUI supports targeting iOS-like platforms.
.NET 8 release has introduced a new Visual Studio Code extension for .NET MAUI.
Elevated performance, reliability, and developer experience for .NET MAUI applications

Moreover, improved quality and significant feature enhancement for ARM64 platform and many other enhancements and improvements. More details about the release can be found here. And .NET 8 release notes can be found here.

Dependency Injection In .NET 6 For Windows Forms Development

Satya Karki — Mon, 15 Jan 2024 08:59:38 +0000

In the rapidly changing world of software development, one thing remains constant: the perpetual challenge of managing the complexity that naturally arises as applications grow in size and complexity. As our projects expand to encompass more features, functionalities, and interconnected parts, the need for maintainable, testable, and adaptable code becomes more critical than ever before.

Consider it this way: picture a sprawling metropolis, a city that started as a small village but has grown into a vast and intricate network of roads, buildings, and infrastructure. This city represents a software application, with each road and building symbolizing a component or piece of code.

In the early stages of the city’s development, it was relatively straightforward to navigate and manage. The roads were simple, and the buildings were few and far between. However, as time passed, the city grew in size and complexity. New roads were built, buildings sprouted up, and the once-simple layout became a labyrinth of interconnected streets and structures.

Similarly, in software development, a project that begins as a small, manageable codebase can quickly evolve into a sprawling application with many interconnected components, modules, and libraries.

Dependency Injection (DI) is a fundamental concept in modern software development that helps manage the complexity of large applications by promoting loose coupling between components. It’s widely used in .NET applications, including WinForms, to improve maintainability, testability, and code reuse. In this article, we’ll explore how to implement Dependency Injection in a .NET 6 Windows Forms application with real-world examples.

In this article, we explore dependency injection and how to implement it into Windows Forms Applications. The following topics will be covered in this article.

What is Dependency Injection?
Why Use Dependency Injection in Windows Forms?
Setting Up a .NET 6 Windows Forms Project
Implementing Dependency Injection
Registering Services
Resolving Dependencies
Constructor Injection
Property Injection
Conclusion

What is Dependency Injection?

Dependency Injection is a design pattern that enables the separation of concerns in an application by providing a way to inject dependencies (such as services, objects, or configurations) into a component rather than letting the component create them. This promotes modularity, testability, and code maintainability.

Why to Use Dependency Injection?

In Windows Forms applications, using Dependency Injection offers several advantages:

Testability :
Components can be tested in isolation by injecting mock or fake dependencies, allowing for unit testing.
**
Loose Coupling:
Dependencies are not hard-coded, making it easier to change or extend functionality without modifying existing code.
Readability and Maintainability: The code becomes more readable and maintainable as dependencies are explicitly defined and injected.
Code Reuse:
Dependencies can be reused across multiple components.
Scalability:
The application can scale by adding new services without affecting existing code.

Setting Up a .NET 6 Windows Forms Project

Before implementing Dependency Injection, create a .NET 6 Windows Forms project using Visual Studio or the .NET CLI. Ensure you have the necessary tools and SDK installed.

Visual Studio 2022
.NET 6 SDK
Windows Development Workload in Visual Studio We will commence by creating a Windows Forms Project from Visual Studio.

Give a name to the project. I have named as DIWinFormsSample. Choose .Net Framework, .NET 6.

Now our Windows Forms application is created.

Implementing Dependency Injection

To implement DI in the above Windows Forms application, follow these steps:

Add Required NuGet Packages
In the WinForms project, add the following NuGet packages:

Microsoft.Extensions.DependencyInjection
Microsoft.Extensions.Hosting

Tips: better to get the latest version of NuGet Packages.

We will navigate program.cs file and add a function CreateHostBuilder, as shown below.

Create a host builder to build the service provider.

public static IServiceProvider ServiceProvider { get; private set; }
static IHostBuilder CreateHostBuilder()
{
    return Host.CreateDefaultBuilder()
        .ConfigureServices((context, services) => {
            services.AddTransient<IBlobStorageService, BlobStorageService>();
            services.AddTransient<IErrorMessageLog, ErrorMessageLog>();
            services.AddTransient<IFileMigrationService, FileMigrationService>();
            services.AddTransient<IAttachmentDataAccess, AttachmentDataAccess>();
            services.AddTransient<MainForm>();
        });
}

In the ConfigureServices **method, use **services.AddScoped() to register your services and interfaces. Replace IMyService and MyService with your actual interface and service implementation.

We will call the Host Builder to build the services provider in Main function as shown below:

var host = CreateHostBuilder().Build();
ServiceProvider = host.Services;

Application.Run(ServiceProvider.GetRequiredService<MainForm>());

Complete Program.cs class.

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace DIWinFormsSample
{
    internal static class Program
    {
        /// <summary>
        ///  The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            // To customize application configuration such as set high DPI settings or default font,
            // see https://aka.ms/applicationconfiguration.
            ApplicationConfiguration.Initialize();
            var host = CreateHostBuilder().Build();
            ServiceProvider = host.Services;

            Application.Run(ServiceProvider.GetRequiredService<Form1>());
        }

        public static IServiceProvider ServiceProvider { get; private set; }
        /// <summary>
        /// Create a host builder to build the service provider
        /// </summary>
        /// <returns></returns>
        static IHostBuilder CreateHostBuilder()
        {
            return Host.CreateDefaultBuilder()
                .ConfigureServices((context, services) => {
                    //services.AddScoped<TInterface, TImplementation>();
                    services.AddTransient<Form1>();
                });
        }
    }
}

Now let’s create an interface and implement it.

IMessageService – Interface class MessageService – Implementation Class

IMessageService.cs

namespace DIWinFormsSample.Services
{
    public interface IMessageService
    {
        string GetSuccessMessage();
    }
}

MessageService.cs class

namespace DIWinFormsSample.Services
{
    public class MessageService : IMessageService
    {
        public string GetSuccessMessage()
        {
            return "Successful Operation!!";
        }
    }
}

Now, we will register the service into container in **program.cs **file.

Let's just Rename Form1 into Mainform.

Code:

static IHostBuilder CreateHostBuilder()
  {
      return Host.CreateDefaultBuilder()
          .ConfigureServices((context, services) => {
              services.AddTransient<IMessageService, MessageService>();
              services.AddTransient<MainForm>();
          });
  }

Create and Inject Services

We have already created the **Message **service. In the Windows Forms or components, you can now inject services using constructor injection.

Sample code:

public partial class MainForm : Form
{
    private readonly IMyService _myService;

    public MainForm(IMyService myService)
    {
        _myService = myService;
        InitializeComponent();
    }

    // ...
}

We will inject the **MessageService **in our **MainForm **through a constructor.

using DIWinFormsSample.Services;
namespace DIWinFormsSample
{
    public partial class MainForm : Form
    {
        private readonly IMessageService _messageService;
        public Form1(IMessageService messageService)
        {
            _messageService = messageService;
            InitializeComponent();
            lblMessage.Text = _messageService.GetSuccessMessage();
        }
    }
}

Let's run and see output. Output screen for the above solution.

Constructor Injection

Constructor injection is the preferred way to inject dependencies. It ensures that required dependencies are available when an object is created. In our example, the Form1 constructor expects an instance of IMessageService.

Alternatively, Property injection can be used when you need optional dependencies. You can create properties in your form and set them through the DI container. However, constructor injection is recommended for mandatory dependencies.

Complete Source code: GitHub.

Conclusion

Dependency Injection is a powerful technique for improving the structure, testability, and maintainability of .NET Windows Forms applications. With .NET 6, setting up DI has become easier than ever, thanks to Microsoft.Extensions.DependencyInjection library. By following the steps outlined in this article, you can harness the benefits of DI in your Windows Forms projects, making them more robust and maintainable.

Remember to register your services, use constructor injection for mandatory dependencies, and enjoy the benefits of a loosely coupled and easily testable application architecture.

References

Stratis Smart Contract Development using Visual Studio Code and C#

Satya Karki — Sun, 03 Sep 2023 06:28:44 +0000

Introduction

Visual Studio Code (VS Code) is a source code editor developed by Microsoft. It is most popular with several developers and educational institutions worldwide. It can be used for various programming languages, for instance, C, C#, C++, Java, Go, JavaScript, Python, Node.js, rust, and many more. These days VS code is getting more popular. It is a handy IDE for developing applications of any platform and is open source and entirely free for any development.

Moreover, it is available for Windows, Linux, and macOS. We can get several extensions and packages to develop applications in several languages inside it. Additionally, it is lightweight in comparison to Visual Studio.

This article will teach us to create the Stratis Smart Contarct program with Visual Studio code in the .NET 6 framework. Stratis Smart Contract must be written in C# language, and Stratis Blockchain is fully developed in .NET and C# language. However, some SDKs can be utilized for other programming languages, such as python SDK for python developers, Unity SDK for unity developers, JavaScript SDK, and Unreal Engine SDK, etc.

Prerequisites

Visual Studio Code
.NET 6 SDK and C# extension to be installed
Knowledge of C#

Create a Solution using VS Code

Step 1

Open VS code and the folder where you want to create a project. From the main menu, select File-> Open Folder.

Step 2

Open the Terminal by selecting View, then go to Terminal from the menu or(Ctrl+Shift+P), or simply click on the Terminal. Then the Terminal opens with the command prompt with the folder name.

Step 3
Run the below command to create a solution in the Terminal.

dotnet new sln

The solution will be created as shown below with the name of the folder.

Now, we will create a Class Library project.

Create a Class library project

Step 1

In the Terminal, you must run the command below to create a class library project.

dotnet new classlib -o YourClassLibraryprojectname

Below is an example of creating a HelloWorld class library project.

dotnet new classlib -o HelloWorld

It will create a class library project with the name HelloWorld.

Step 2

Add class lib project to the solution.

Run the below command to add the class lib project to the solution.

dotnet sln add HelloWorld/HelloWorld.csproj

The default Project structure will be like the one below.

Install Stratis Smart Contract NuGet Package

To add the NuGet package, you can use a command in the Terminal like the one below. The below command installs the Stratis.SmartContracts.NET6 package from NuGet store.

dotnet add HelloWorld package Stratis.SmartContracts.NET6

Now, we are ready to write the Stratis Smart Contract program.

Write Smart Contract Program in C

Now, we will write a simple Smart contract program that returns Greeting value. Rename the default Class1.cs to HelloWorld.cs and Write below the HelloWorld contract program.

using Stratis.SmartContracts;
[Deploy]
public class HelloWorld: SmartContract {
    private string Greeting {
        get {
            return this.State.GetString("Greeting");
        }
        set {
            this.State.SetString("Greeting", value);
        }
    }
    public HelloWorld(ISmartContractState smartContractState): base(smartContractState) {
        this.Greeting = "Namaste!";
    }
    public string SayHello() {
        return this.Greeting;
    }
}

Once the contract code is ready, we must validate it for format and determinism. We must use the Stratis Smart Contract tool (Sct) for that.

Smart Contract Tool

The smart contract tool is powered by the Stratis platform, which is used to validate and generate the byte code of the Smart contract.

After completing the Smart Contract code based on the requirement, we must validate it. Stratis has provided an Sct tool to validate whether the smart contract is correct. The validation process is mandatory to verify the valid constraints used in the contract. It validates the determinism and constraints used in the Smart Contract, i.e., validates the format and deterministic element of the contract. Determinism and format validation rules can be found in the Startis Academy. You can download the Sct tool from here.

Or clone the Stratis.SmartContracts.Tools.Sct repository by running the below command.

git clone https://github.com/stratisproject/Stratis.SmartContracts.Tools.Sct.git

Validating the Contract
Open the command terminal, and then you can go to the Smart Contract tool directly by running the below command.
cd src/Stratis.SmartContracts.Tools.Sct
After that, run the below command to validate the contract.

dotnet run — validate [Contract_PATH]

e.g.

dotnet run -- validate "C:\Users\rijsat\Desktop\Desktop\SampleDotnetProject\HelloWorld\HelloWorld\HelloWorld.cs"

Once you run the command, you can see the success or error of validation. On the success of validation, you will get the below information in the Terminal.

If you get an error in the validation step, based on the error message, you can correct your smart contract code or check validation rules and again do validation as above.

Compiling Contract
Once the Contract is validated, we must compile the Smart Contract code and generate the byte code. This smart contract byte code is the code that we need to deploy in the Blockchain.

To compile the code, run the below command.

dotnet run – – validate [CONTRACT_PATH] -sb

example:

dotnet run -- validate "C:\Users\rijsat\Desktop\Desktop\SampleDotnetProject\HelloWorld\HelloWorld\HelloWorld.cs" -sb

The above command first validates the Smart contract and then compiles the code. On the success of your compilation, you will get hash and byte code in your Terminal, as illustrated below. We will need the hash and byte code while deploying the contract on the Blockchain. So, copy and keep the hash and Contract Byte code.

For Stratis Smart Contract deployment and interaction we can use Cirrus core wallet, for that you can refer to the previous article here.

Summary

Hence, this article explained us to develop Stratis Smart Contract using Visual Studio code and .NET 6 framework. Additionally, we learned what is Stratis Smart Contract tool (SCT) is and how to validate, compile and generate the bytecode of a Stratis Smart Contract.

References

Beginners Guide to Get Started with Smart Contract in C#

Satya Karki — Mon, 16 Jan 2023 11:56:22 +0000

Introduction

A smart contract is a computer program where the parties have consent on predetermined conditions of the agreement. Smart contract stores and self-executes in the blockchain network. It runs when the predefined conditions are met. Smart Contract allows transactions to be made without the need of a middle man and those transactions are irreversible, transparent, and traceable. This article describes how to get started with Smart Contract in C# using Stratis blockchain. In the article I will cover, setting up an environment for the development of Smart Contract in C# using Stratis blockchain which includes the setting up of Stratis Smart Contract template in Visual Studio. Additionally, I will explain how to get and set up all the necessary tools for Contract Validation and running up Stratis private blockchain network in the development environment. This article is the guide for newbies to set up and get ready for Smart Contract development in C# using Stratis Blockchain.

The article will cover the following things:

Stratis Smart Contract Template setup in Visual Studio
Create Smart Contract Project in C# using Stratis Smart Contract Template
What is Sct Tool
How to Validate Smart Contract
How to generate Smart Contract Bytecode
What is Full Node
How to run Full Node in Development Environment

So, let’s begin. We need the following things to develop Smart Contract in C# utilizing Stratis blockchain in the development machine.

Stratis Smart Contract Template in Visual Studio
Sct Tool
Full Node

Prerequisites:

Visual Studio 2019 or Later

Visual Studio

We need Visual Studio 2019 or a later version either Community or any edition for Stratis Smart Contract development. If you don’t have you can download it and install it on your machine from here.

Once you have installed Visual Studio, you can set up Stratis Smart Contract Template. Let’s move for this.

Stratis Smart Contract Template Setup in Visual Studio

Stratis has provided a Smart Contract template for those who want to create a Smart Contract using C# and .NET in Visual Studio. To set up Stratis Smart Contract Template run the below command in your Visual Studio command terminal.

dotnet new --install Stratis.SmartContracts.Templates.CLI

Once, the command is successful you can see the Stratis Smart Contract template in the list as depicted below.

You can run the below command to view the list of new templates installed in visual studio.

dotnet new --list

If you are interested in watching a video for the same below is a video for you.

Smart Contract In C# Using Stratis Smart Contract Template

Step 1- Create Smart Contract Project

Create a new project in Visual Studio and search Stratis Smart Contract template by typing Stratis in the search textbox. You can see the template in the list. Select the Stratis Smart Contract Template (Stratis Group Ltd) and click on Next.

If you can find the Smart Contract Template in the list then move to Step 2. Otherwise, you need to do a quick fix. If you still cannot find the Stratis Smart Contract template in Visual Studio then go to Tool–>Options as shown below.

Then under Environment go to Preview Features and select “Show all .NET Core templates in the New Project dialog (requires restart)” and click on OK.

Once you enable this, restart your Visual Studio.

Step 2- Give Project Name

Once you select the Stratis Smart Contract Template while creating the project then, give the project name, folder location, and solution name and click on Create to create your first Stratis Smart Contract Project.

When Project is created you can see My Contract Class as shown below.

Stratis Smart Contract Template setup and project creation are completed. Now, you can write your contract code based on your requirement. You can get a Sample of Stratis Smart Contract from the repository here.
However, for this article we will go for the next steps on how to validate and generate the bytecode of the Smart Contract.

Sct Tool

We need the Sct tool to validate the Stratis Smart Contract and generate the byte code of the Contract. After the completion of the code of our Smart Contract based on the requirement, we need to validate it. Stratis has provided Sct tool to validate the smart contract whether is correct. The validation process is mandatory to verify the valid constraints used in the contract. It validates for the determinism and constraints used in the Smart Contract i.e. validates format and deterministic element of the contract. You can download Sct tool from here.

How to Validate Smart Contract Using Sct Tool

Open Sct Tools solution in Visual Studio, you will see two projects there one is the main project, and another is tests project as illustrated below.

Right-click on “Stratis.SmartContracts.Tools.Sct” and go to the terminal then run the following command.

dotnet run -- validate [Contract_PATH]

e.g.

dotnet run -- validate “F:\Blockchain\Demo Stratis Contract\Demo Stratis Contract\MyContract.cs”

or
from CLI you can run below commands

cd src/Stratis.SmartContracts.Tools.Sct

dotnet run -- validate [Contract_PATH]

Once you run the command you can see the success or error of validation. On the success of validation, you will get the below information in the terminal.

If you get an error while validating the contract, then based on the error message you can correct your smart contract code and then again do validation as above.

Compiling Contract using Sct tool

Once, Contract is validated, after that, we have to compile the Smart Contract code and generate the byte code. This smart contract bytecode is the code that we have to deploy in the Blockchain.

To compile the code run the below command.

dotnet run -- validate [CONTRACT_PATH] -sb

e.g.

dotnet run -- validate "F:\Blockchain\Demo Stratis Contract\Demo Stratis Contract\MyContract.cs”-sb

This command-line first validates the Smart contract and then compiles the code. On the success of your compilation, you will get hash and byte code in your terminal as illustrated below.

Stratis Full Node

Stratis Full Node is the core of Stratis private blockchain. This is the very crucial step to set up and run the Stratis Full Node on your development machine to run the project locally and interact with the Stratis Blockchain. For more details on Full Node visit this Stratis Academy.

You can download Stratis Full Node from here

How to Run the Stratis Full Node in Development Environment

Once downloaded, go to the folder and open the Stratis Full Node solution in Visual studio, there you will see many projects; however, you need to run the Stratis.CirusMinerD project with the -devmode parameter by executing the below command from CLI.

cd StratisFullNode\src\Stratis.CirrusMinerD

dotnet run -devmode=miner

Right-click on “Stratis.CirrusMinerD” Project and click on Open in Terminal then run below command.

dotnet run -devmode=miner

The above command runs a single block-producing node using the PoA (Proof-of-Authority) consensus algorithm. After the success of the above command open the http://localhost:38223/swagger on your device where you can see a list of APIS. These API endpoints will be used to interact with the blockchain.

Congratulations, your machine is set up for Stratis Smart Contract development and deployment for private blockchain which can be used for both development and testing purposes.

Conclusion

Hence, this article has described how to set up a template and get started with Smart Contract in C# using Stratis Blockchain. Moreover, the article explained what is Sct tool is, how to validate and generate Smart contract bytecode, how to run Stratis Full Node for development, and the testing environment locally using C#, dotNet, and visual studio.

The article was initially published on rijsat.com

Develop Minimal APIs in .NET 7 using Entity Framework Core 7

Satya Karki — Thu, 15 Dec 2022 11:46:18 +0000

Introduction

Minimal APIs are designed to create HTTP APIs with minimal dependencies. Minimal APIs are suitable for microservices and applications that include minimum files, features, and dependencies with ASP.NET Core. Minimal APIs were there since .NET 6 and it helps you to easily create API. At the time of this article write up .NET 7 is recently released. It has included several improvements in performance, new features for C#11 &F#, .Net MAUI, ASP.NET Core/Blazor improvement, Web APIs, and many more. Additionally, you can easily containerize your .NET 7 projects as well as configure CI/CD workflows for GitHub actions. Moreover, .NET MAUI is a part of the .NET 7. .NET 7 is officially supported by Microsoft for only 18 months, and it is labeled as Standard term support. This article demonstrates how to create Minimal APIs using .NET 7 and Entity Framework Core 7.

In this article, we will cover the followings:

Create Minimal APIs using .NET 7
Get familiar with Minimal APIs
Get Familiar with Entity Framework and use Entity Framework in Minimal API
Create APIs for CRUD operation

Prerequisites

Visual Studio 2022
.NET 7 SDK If you don’t have these prerequisites, you can download and install Visual Studio 2022 from here and .NET 7 SDK from here.

If you are new to .NET 7, you can get the previous article Getting Started with ASP.NET Core 7 and Some key features of.NET 7 here.

Create Minimal API Project

Follow the below steps to create a Minimal API.

Step 1 - Open Visual Studio and click on create a new project.

Step 2 - Select ASP.NET Core Web API as depicted below. You can see that this template comes with an example of a RESTFul HTTP service as well as it can be used for ASP.NET Core MVC Views and Controllers ( APIs with controller).

Step 3 - Give the project name, and directory of the project and then click on Next as illustrated below.

Step 4 - Select Framework: .Net 7.0 (Standard Term Support), uncheck Use Controller to use minimal APIs. uncheck Do not use top-level Statements. Select others as illustrated in the image below.

Step 5 - Exploring Default Program.cs code

Now, let’s explore the code of program.cs.

Below is the default code of Program.cs

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

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

app.UseHttpsRedirection();

var summaries = new[]
{
    "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
};

app.MapGet("/weatherforecast", () =>
{
    var forecast = Enumerable.Range(1, 5).Select(index =>
        new WeatherForecast
        (
            DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
            Random.Shared.Next(-20, 55),
            summaries[Random.Shared.Next(summaries.Length)]
        ))
        .ToArray();
    return forecast;
})
.WithName("GetWeatherForecast")
.WithOpenApi();

app.Run();

internal record WeatherForecast(DateOnly Date, int TemperatureC, string? Summary)
{
    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
}

The MapGet method in Minimal APIs can be used to handle the HTTP Get request. Meaning the weather forecast API is an HTTP Get endpoint: “/weatherforecast”.
The default Weather forecast displays the date, temperature, summary, and temperature. Default project Structure of Minimal API project.

Now, let’s run the default project. Below is the view of a Swagger page.

You can see in the above image that Minimal API comes with a default weather forecast and Swagger Documentation for Web API same as ASP.NET Core Web API with Controller.

Up to now we have only created and explored the default Minimal API. Now, we will go for creating new APIs.

Adding/Creating New APIs

Step 1- Add Entity Framework

Entity Framework Core: Entity Framework core is part of Entity Framework. After the Entity Framework 6.x it is labeled as Entity Framework core. Entity Framework core is an open-source, lightweight, extensible, and cross-platform version of Entity Framework. It works as an Object-relational mapper (ORM) which helps developer to work with database and .Net objects easily. With the use of EF, developers don’t need to write most of the data access code.

In Memory database: EF core has the ability to store and retrieve data from in memory. In memory database is used to test the application. It doesn’t store data in the physical database, it just stores data in the in-memory and it is volatile. We can use it just for testing whether our API is working perfectly or not in this demo Minimal API project.

So here we will install two components:

Microsoft.EntityFrameworkCore.InMemory
Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore Now, let’s move to add EF Core.

Right-click on Project and Go to Manage NuGet Package for the solution as shown below.

Then go to the Browse tab. In the Search box enter Microsoft.EntityFrameworkCore.InMemory select Microsoft.EntityFrameworkCore.InMemory and then install it.

Similarly, Go to the Browse tab -> In the Search box enter: Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore then you select it and install it.

Step 2 - Add Model class.

Now, let’s add the Student model class. Create a Model folder and add the Student class there.

Write the below code in your Student.cs class:

public class Student
{
    public int Id { get; set; }
    [Required]
    public string? Name { get; set; }
    [Required]
    public string? Email { get; set; }
    public string? Phone { get; set; }
}

Step 3 - Add DbContext.

Then let’s create a folder Data and add a class for data context. Let’s say MyDataContext class.

Code of MyDataContext

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

    public DbSet<Student> Students => Set<Student>();
}

Then add Datacontext in Program.cs as shown below.

//Add dbContext, here you can we are using In-memory database.
builder.Services.AddDbContext<MyDataContext>(opt => opt.UseInMemoryDatabase("Student"));

Step 4 - Create New APIs

In Minimal API we write all the API code inside the Program.cs file. So now, let’s go and add a basic API endpoint for a CRUD operation of the Student class.

Save API: Write the below code to Save Student data using entity framework core 7 in Minimal API. Here the Save API is HTTP Post endpoint.

app.MapPost("/SaveStudent", async (Student student, MyDataContext db) =>
{
    db.Students.Add(student);
    await db.SaveChangesAsync();

    return Results.Created($"/save/{student.Id}", student);
});

GetAll: Below is the code of the GetAll Student API endpoint. This is HTTP Get API.

app.MapGet("/GetAllStudent", async (MyDataContext db) =>
    await db.Students.ToListAsync());

Update: Below is the update code for Student detail which is HTTP Put API.

app.MapPut("/UpdateStudents/{id}", async (int id, Student studentinput, MyDataContext db) =>
{
    var student = await db.Students.FindAsync(id);

    if (student is null) return Results.NotFound();

    student.Name = studentinput.Name;
    student.Phone = studentinput.Phone;

    await db.SaveChangesAsync();

    return Results.NoContent();
});

A complete code of Program.cs with Post, Get, Put, and Delete APIs for Student is given below:

using Microsoft.EntityFrameworkCore;
using SampleMinimalAPI.Data;
using SampleMinimalAPI.Model;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

//Add dbContext
builder.Services.AddDbContext<MyDataContext>(opt => opt.UseInMemoryDatabase("Student"));
var app = builder.Build();

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

app.UseHttpsRedirection();

var summaries = new[]
{
    "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
};

app.MapGet("/weatherforecast", () =>
{
    var forecast = Enumerable.Range(1, 5).Select(index =>
        new WeatherForecast
        (
            DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
            Random.Shared.Next(-20, 55),
            summaries[Random.Shared.Next(summaries.Length)]
        ))
        .ToArray();
    return forecast;
})
.WithName("GetWeatherForecast")
.WithOpenApi();

//Student APIs
app.MapPost("/SaveStudent", async (Student student, MyDataContext db) =>
{
    db.Students.Add(student);
    await db.SaveChangesAsync();

    return Results.Created($"/save/{student.Id}", student);
});

app.MapGet("/GetAllStudent", async (MyDataContext db) =>
    await db.Students.ToListAsync());

app.MapGet("/GetStudentById/{id}", async (int id, MyDataContext db) =>
    await db.Students.FindAsync(id)
        is Student student
            ? Results.Ok(student)
            : Results.NotFound());

app.MapPut("/UpdateStudents/{id}", async (int id, Student studentinput, MyDataContext db) =>
{
    var student = await db.Students.FindAsync(id);

    if (student is null) return Results.NotFound();

    student.Name = studentinput.Name;
    student.Phone = studentinput.Phone;

    await db.SaveChangesAsync();

    return Results.NoContent();
});

app.MapDelete("/DeleteStudent/{id}", async (int id, MyDataContext db) =>
{
    if (await db.Students.FindAsync(id) is Student student)
    {
        db.Students.Remove(student);
        await db.SaveChangesAsync();
        return Results.Ok(student);
    }

    return Results.NotFound();
});

app.Run();

internal record WeatherForecast(DateOnly Date, int TemperatureC, string? Summary)
{
    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
}

Now, our Student APIs are ready, we can run and test APIs.

Below is an image of testing for Save API.

Below is an image of testing for the GetAll Student API.

In this way, we can test all the APIs of our minimal API project using an in-memory database.

The source code for Minimal APIs demonstrated in this article can be found here.

Summary

In a nutshell, Minimal APIs are designed to create HTTP APIs with minimal dependencies. Minimal APIs are suitable for microservices and applications that include minimum files, features, and dependencies with ASP.NET Core. Minimal APIs were available since .NET 6. Hence, the article described what is Minimal API and how to get started with Minimal API in .NET 7. Additionally, the article has demonstrated to create a new Custom API with an example of Student API. Furthermore, we have got an idea about Entity Framework Core 7 and implemented entity framework in the Minimal API project as well as created minimal API for CRUD operation using entity framework and in-memory database.

Reference

rijsat.com

Receiving Real-Time Data In An ASP.NET Core Client Application Using SignalR JavaScript Client

Satya Karki — Fri, 18 Nov 2022 05:32:58 +0000

Introduction

SignalR is an open-source library that facilitates to add real-time functionality to web applications. Using this, the server application can push real-time data to the client.

This article explains how to connect with SignalR Server hub and receive the message data from the server to the client application using the SignalR JavaScript client in ASP.NET Core 6 application. There are several ways to receive the data from SignalR server application to the client using different reference packages. Among them, we already learned one in the previous part of the article series where we used SignalR .NET Client. However, in this article, we will explore SignalR JavaScript client and use it in .NET6 application to receive the data from the server hub. In this example, we will focus on a client application. Same as the previous article, the scenario is useful when we have two different applications for SignalR server and client, and we need to use SignalR JavaScript client for ASP.NET Core 6 application where we need to use client-side JavaScipt code only. In the previous part of the article series, we used server-side code to receive data in the SignalR client application; however, in this part, we will use client-side code.

Prerequisites

Visual Studio 2022
Functioning SignalR Server Application If you have already an existing client application in .NET6.0 and you need to only implement the SignalR part using JavaScript Client in the client application to receive the real-time data from your server application using SignalR JavaScript client, then you can directly jump into Step 2.

Source code for client application check this Git Repo

Step 1 - Create an ASP.NET Core6 project as usual.

Open Visual Studio and click on Create a new project.

Select ASP.NET Core web app (MVC) as illustrated below and click on Next.

Give the project name, location of the project, and click on Next.

Then select the Framework: .NET 6.0(Long-term support) as shown below and click on Create.

Then, your default SignalR client app will be created. Which you can run and see the default design in the browser.

Now, we will move to SignalR client part.

Step 2 – Install SignalR JavaScript Client

Now, we will need to install SignalR JavaScript client. Open package manager console as depicted below.

Then run the below bash commands from the package manager console.

npm init -y
npm install @microsoft/signalr

Additionally, you can install it with LibMan from here.

Once installed: Create folder signalr under wwwroot/lib and go to node_modules\@microsoft\signalr\dist\browser folder and copy and paste the signalr.js file in the signalr folder as shown below.

Now, your signalr file is ready we can reference the SignalR JavaScript client in the script element such as.
<script src="~/lib/signalr/signalr.js"></script>

Step 3 - Add SignalR Client JavaScript

Now we will add a new JavaScript file under the js folder which we will use to connect with the SignalR Server hub and customize all our code in this file.

Step 4 – Connecting to Hub (SignalR Server application)

Similar to the previous article, in this step, we will get familiar with the connection hub builder, which we will be required to connect with the server hub. Only the difference is we are using JavaScript to connect with the Server.

To make a connection, we need to create HubConnectionBuilder and start the Build, where we have to provide the server URL and message event. The below example withUrl contains the SignalR server URL and SignalR event hub name. You need to provide the correct value in the WithUrl in order to connect with the server.

var connection = new signalR.HubConnectionBuilder().withUrl(“http://localhost:53150/ChatHub”)
    .configureLogging(signalR.LogLevel.Information)
    .build();

Additionally, to reconnect automatically when the server connection gets lost, we can use WithAutomaticReconnect() method as well. Moreover, we can use StartAsync() method to start the connection asynchronously.

The complete code for the connection is given below.

var connection = new signalR.HubConnectionBuilder().withUrl("http://localhost:39823/ChatHub", {
        skipNegotiation: true,
        transport: signalR.HttpTransportType.WebSockets
    }).withAutomaticReconnect() //when server get disconnects it reconnects with the serevr
    .configureLogging(signalR.LogLevel.Information).build();
connection.start().then(function() {}).catch(function(err) {
    return console.error(err.toString());
});

Note: You should have CORS enabled in your server app for the signalR client app to be connected.

Step 5 - Calling Client Method from the hub

Now, it’s time to call the client method to receive messages from the hub. For this, we will use on method of the HubConnection

We need two things for this.

Name of client method
Argument(s) that need to pass to the method Based on my client method name and argument on the method, the connection on code becomes:

connection.on("receiveEvent", function (message) {
  //receive your message here
 var value = message.Val1;
})

Below is the complete code of signalrConnection.js file.

"use strict"
var connection = new signalR.HubConnectionBuilder().withUrl("http://localhost:39823/events-hub", {
        skipNegotiation: true,
        transport: signalR.HttpTransportType.WebSockets
    }).withAutomaticReconnect() //when server get disconnects it reconnect with the serevr
    .configureLogging(signalR.LogLevel.Information).build();
connection.start().then(function() {}).catch(function(err) {
    return console.error(err.toString());
});
//Below method is for Receiving message
connection.on("receiveEvent", function(message) {
    var value = message.headerHeight;
    if (message.headerHeight) {
        document.getElementById('lblHeight').innerHTML = ` ${message.headerHeight}`;
    }
})

Step 6 - Link the js file

To get and display the received message data in your page, you need to just link the js file on the page where you require showing the message data.

For the simplicity of this demo, I have just shown the value of the message in the Index.asp page as portrayed below.

In my design page, I have just created a division and label to display the received message on the page.

Checking the output

Now we can run and open the Devtool or inspect the elements in the browser and see the received message. Below is the output of my client application after successfully connecting to the server hub and receiving real-time data from the server.

On successfully connecting to SignalR hub and receiving the message data, you can work on the design to display the messages on the page according to your need.

The Git repo of this example can be found here.

Summary

In a nutshell, the article has described and demonstrated how to get real-time data in ASP.NET Core client application from the server application using the SignalR JavaScript client. This article will help you when you have two different applications for SignalR server and client, and you need to use SignalR JavaScript client for your client application.

Thanks for reading the article.

If you like to implement the .NET Client for the same purpose, you can refer to the previous article here.

References

Receive Real-Time Data In .NET 6 Client Application Using SignalR

Satya Karki — Thu, 10 Nov 2022 12:24:54 +0000

Introduction

SignalR is an open-source library that facilitates to add real-time functionality to web applications. Using this, the server application can push real-time data to the client.

Microsoft has provided different ways to connect with the SignalR Server application from a client application using various client libraries. This article explains how to connect with the SignalR Server hub and receive message data from the server to the client application using the SignalR .NET client in ASP.NET Core 6 application. There are different ways to receive data from the SignalR server application to the client utilizing different reference packages. In this article we will explore SignalR .NET client and use it in the .NET 6 application to receive the data from the server hub. In this example, we will focus on a client application. This article explains and provides the code sample for the scenario where we have two different applications for the SignalR server and the client. We need to use the .NET client library for the ASP.NET Core 6 application.

Prerequisites:

Visual Studio 2022
Functioning SignalR Server Application If you already have an existing client application in .NET 6.0, you will need only to implement the signalR .NET client in order to receive the real-time data from your server application. Then you can directly jump into Step Two.

Source code

Let's get start.
Step 1 - Create an ASP.NET Core 6 project as usual
Open Visual Studio and click on Create a new project.

Select ASP.NET Core web app as illustrated below and click on Next.

Give the project name, location of the project, and click Next.

Then select the Framework: .NET 6.0(Long-term support) as shown below and click Create.

Then, your default SignalR client app will be created. You will be able to run it and see the default design in the browser.

Now, let’s move to SignalR client part.

Step 2 - Install SignalR .NET Client
Once the project is created, we can now move to the SignalR .NET client steps.

You can open the terminal in Visual Studio, and can install the SignalR .NET client using the command given below.

Install-Package Microsoft.AspNetCore.SignalR.Client

Alternatively, you can search and install it from the NuGet Package manager.

Step 3 - Connecting to Hub (SignalR Server application)
Here, we will become familiar with the connection hub builder. This is required for connecting with the server hub.

To make a connection, we need to create HubConnectionBuilder and start the Build. There we must provide the server URL and message event. The example below, withUrl, contains the signalR server URL and signalR event hub name. You need to provide the correct value in the WithUrl in order to connect with the server.

var connection = new HubConnectionBuilder()
                .WithUrl("http://localhost:53150/ChatHub")
                .Build();

Additionally, to reconnect automatically when the server connection gets lost, we can use WithAutomaticReconnect() method. Moreover, we can use the StartAsync() method to start the connection asynchronously.

The complete code for the connection is given below.

connection = new HubConnectionBuilder().WithUrl("http://localhost:39823/events-hub", options => {
    options.Transports = HttpTransportType.WebSockets;
}).WithAutomaticReconnect().Build();
await connection.StartAsync();

Let’s go to the project and create a connection with the Server and receive the message. For simplicity, I will use the Privacy Action Controller. In a real application, you can keep the connection and data receive code in your service class and call it in wherever you need it.

For simplicity, let’s go to the Privacy Action of HomeController and create a connection with the SignalR server.

Here is the code of my HomeController Privacy.

public async Task < IActionResult > PrivacyAsync() {
    var connection = new HubConnectionBuilder().WithUrl("http://localhost:39823/events-hub", options => {
        options.Transports = HttpTransportType.WebSockets;
    }).WithAutomaticReconnect().Build();
    await connection.StartAsync();
    return View();
}

using Microsoft.AspNetCore.Http.Connections;
using Microsoft.AspNetCore.SignalR.Client;

Note: The above should be included in the controller, and the HubConnection connection should be defined in the Home Controller.

Now, we need to change the default Privacy ActionResult to the Async as well.

Up until now, we have created the connection to the Server. Now we will move to receiving data in the client application.

To receive the data, write the following code just below the connection code in the same controller action.

public async Task < IActionResult > PrivacyAsync() {
    var connection = new HubConnectionBuilder().WithUrl("http://localhost:39823/events-hub", options => {
        options.Transports = HttpTransportType.WebSockets;
    }).WithAutomaticReconnect().Build();
    await connection.StartAsync();
    string newMessage1;
    connection.On < object > ("receiveEvent", (message) => {
        Console.WriteLine(message);
        var newMessage = JsonConvert.DeserializeObject < dynamic > (message.ToString());
        newMessage1 = $ "{newMessage.chainTip}";
    });
    return View();
}

In my case, the server will send data to the client with the name receiveEvent. In the chat application, it can appear as ReceiveMessage. You can check your server code for your own case.

Once receive the message, I have deserialized the it.

The complete code can be found below.

using DemoSignalRClientApp.Models;
using Microsoft.AspNetCore.Http.Connections;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR.Client;
using Newtonsoft.Json;
using System.Diagnostics;
namespace DemoSignalRClientApp.Controllers {
    public class HomeController: Controller {
        private readonly ILogger < HomeController > _logger;
        HubConnection connection;
        public HomeController(ILogger < HomeController > logger) {
            _logger = logger;
        }
        public IActionResult Index() {
            return View();
        }
        public async Task < IActionResult > PrivacyAsync() {
                var connection = new HubConnectionBuilder().WithUrl("http://localhost:39823/events-hub", options => {
                    options.Transports = HttpTransportType.WebSockets;
                }).WithAutomaticReconnect().Build();
                await connection.StartAsync();
                string newMessage1;
                connection.On < object > ("receiveEvent", (message) => {
                    Console.WriteLine(message); //write in the debug console
                    var newMessage = JsonConvert.DeserializeObject < dynamic > (message.ToString());
                    newMessage1 = $ "{newMessage.chainTip}";
                });
                return View();
            }
            [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public IActionResult Error() {
            return View(new ErrorViewModel {
                RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier
            });
        }
    }
}

So, our client application is ready now. We can run client and server applications at once and test whether the client app is able to receive data from the server or not.

Below is the result of my Client application successfully receiving the data from the server.

Conclusion

In this article, we have learned to how get the data in a client application from the server application using SignalR .Net client in ASP.NET Core web application.

As Microsoft has provided different ways to connect with the SignalR Server application from a client application, using various client libraries such as .NET Client, JavaScript Client, Java Client, and so on. In the next part of this series, we will learn how to use a JavaScript client library for the same purpose. If you have any queries, concerns, or feedback, please feel free to write them in the comment section.

References

Global AI Developer Days 2022- Philippines

Satya Karki — Wed, 19 Oct 2022 11:29:05 +0000

We are going to organize the Global AI developer days in the Philippines on October 26th 2022. It's a free webinar so If you would like to join the session please register in the provided link here and save the date.

Details can be found:
https://rijsat.com/2022/10/06/global-ai-developer-days-philippines-2022/