Tag: .net

Ignoring SSL certificate errors in C# RestSharp Library

//bypass ssl validation check by using RestClient object
var options = new RestClientOptions(baseurl) {
    RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true;
};
var restClient = new RestClient(options);

or in application level

//bypass ssl validation check globally for whole application.
ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => true;

 

Ignoring SSL certificate errors in C# HttpClient

var handler = new HttpClientHandler();
handler.ClientCertificateOptions = ClientCertificateOption.Manual;
handler.ServerCertificateCustomValidationCallback = 
    (httpRequestMessage, cert, cetChain, policyErrors) =>
{
    return true;
};

var client = new HttpClient(handler);

 

Checkpointing time series using Singular Spectrum Analysis (SSA) model

This code is using the CheckPoint method of the TimeSeriesPredictionEngine class in ML.NET. This method saves the state of the time series model to a file, so that it can be loaded and used for predictions later. For example, if you have a time series model that detects change points in data, you can use the CheckPoint method to save the model after training and then load it in another application to make predictions on new data.

SsaForecastingTransformer forecaster = forecastingPipeline.Fit(trainingData);

var forecastEngine = forecaster.CreateTimeSeriesEngine<ModelInput, ModelOutput>(mlContext);

// save model zip file
forecastEngine.CheckPoint(mlContext, ModelPath);

Load a List of Objects as Dataset in ML.NET

In ML.NET, you can load a list of objects as a dataset using the DataView API. ML.NET provides a flexible way to represent data as DataView, which can be consumed by machine learning algorithms. To do this, you’ll need to follow these steps:

  1. Define the class for your data objects: Create a class that represents the structure of your data. Each property of the class corresponds to a feature in your dataset.
  2. Create a list of data objects: Instantiate a list of objects with your data. Each object in the list represents one data point.
  3. Convert the list to a DataView: Use the MLContext class to create a DataView from the list of objects.

Here’s a step-by-step implementation:

Step 1: Define the class for your data objects

Assuming you have a class DataObject with properties Feature1, Feature2, and Label, it should look like this:

public class DataObject
{
    public float Feature1 { get; set; }
    public float Feature2 { get; set; }
    public float Label { get; set; }
}

Step 2: Create a list of data objects

Create a list of DataObject instances containing your data points:

var dataList = new List<DataObject>
{
    new DataObject { Feature1 = 1.2f, Feature2 = 5.4f, Label = 0.8f },
    new DataObject { Feature1 = 2.1f, Feature2 = 3.7f, Label = 0.5f },
    // Add more data points here
};

Step 3: Convert the list to a DataView

Use the MLContext class to create a DataView from the list of objects:

using System;
using System.Collections.Generic;
using Microsoft.ML;

// ...

var mlContext = new MLContext();

// Convert the list to a DataView
var dataView = mlContext.Data.LoadFromEnumerable(dataList);

Now you have the dataView, which you can use to train and evaluate your machine learning model in ML.NET. The DataView can be directly consumed by ML.NET’s algorithms or be pre-processed using data transformations.

Remember to replace DataObject with your actual class and modify the properties accordingly based on your dataset.

Load a Text File Dataset in ML.NET

Introduction

Machine learning has revolutionized the way we process and analyze data, making it easier to derive valuable insights and predictions. ML.NET, developed by Microsoft, is a powerful and user-friendly framework that allows developers to integrate machine learning into their .NET applications. One of the fundamental tasks in machine learning is loading datasets for model training or analysis. In this blog post, we’ll explore how to load a text file dataset using ML.NET and prepare it for further processing.

The Dataset

Let’s start with a simple dataset stored in a text file named data.txt. The dataset contains two columns: “City” and “Temperature”. Each row corresponds to a city’s name and its respective temperature. Here’s how the data.txt file looks:

City,Temperature 
Rasht,24 
Tehran,28 
Tabriz,8 
Ardabil,4

The Data Transfer Object (DTO)

In ML.NET, we need to create a Data Transfer Object (DTO) that represents the structure of the data we want to load. The DTO is essentially a C# class that matches the schema of our dataset. In our case, we’ll define a DataDto class to represent each row in the data.txt file. Here’s the DataDto.cs file:

public class DataDto
{
    [LoadColumn(0), ColumnName("City")] 
    public string City { get; set; }
    
    [LoadColumn(1), ColumnName("Temperature")]
    public float Temperature { get; set; }
}

The DataDto class has two properties, City and Temperature, which correspond to the columns in the dataset. The properties are decorated with attributes: LoadColumn and ColumnName. The LoadColumn attribute specifies the index of the column from which the property should load its data (0-based index), and the ColumnName attribute assigns the name for the corresponding column in the loaded data.

Loading the Dataset

With the DTO in place, we can now proceed to load the dataset using ML.NET. The entry point for ML.NET operations is the MLContext class. In our Program.cs, we’ll create an instance of MLContext, specify the path to the text file, and load the data into a DataView.

using System;
using Microsoft.ML;

public class Program
{
    static void Main()
    {
        // Create an MLContext
        var mlContext = new MLContext();
        
        // Specify the path to the text file dataset
        string dataPath = "data.txt";
        
        // Load the data from the text file into a DataView using the DataDto class as the schema
        var dataView = mlContext.Data.LoadFromTextFile<DataDto>(dataPath, separatorChar: ',', hasHeader: true);
        
        // Now you can use the dataView for further processing, like training a model, data analysis, etc.
        // ...
    }
}

The LoadFromTextFile method takes the path to the dataset file (dataPath) as well as the separator character (, in our case) and a boolean indicating whether the file has headers (hasHeader: true).

Conclusion

In this blog post, we’ve learned how to load a text file dataset in ML.NET using a Data Transfer Object (DTO) to define the structure of the data. By leveraging the LoadFromTextFile method, we can easily read the dataset into a DataView and utilize it for further processing, such as training a machine learning model or conducting data analysis. ML.NET simplifies the process of integrating machine learning capabilities into .NET applications, making it accessible to a broader range of developers and opening up new possibilities for data-driven solutions.

Install the ML.NET Command-Line Interface (CLI) tool

Windows

dotnet tool install --global mlnet-win-x64

Linux

dotnet tool install --global mlnet-linux-x64

Install a specific release version

If you’re trying to install a pre-release version or a specific version of the tool, you can specify the OS, processor architecture, and framework using the following format:

dotnet tool install -g mlnet-<OS>-<ARCH> --framework <FRAMEWORK>

dotnet tool install -g mlnet-linux-x64 --framework net7.0

Update the CLI package

dotnet tool list --global
dotnet tool update --global mlnet-linux-x64

References
https://learn.microsoft.com/en-us/dotnet/machine-learning/how-to-guides/install-ml-net-cli

Install the .NET SDK on Fedora

In the ever-evolving world of web development, security is paramount. Here we provide a step-by-step guide to not only installing the .NET Software Development Kit (SDK) on Fedora, but also generating an SSL Certificate for your .NET apps, thus ensuring secure connections between client and server.

Part 1: Installing the .NET SDK on Fedora

Our first step is to install the .NET SDK. The .NET SDK is a set of libraries and tools that allow developers to create .NET apps and libraries. It is the foundation for building applications and libraries with .NET Core.

Here’s how you can install the .NET SDK on your Fedora system:

  1. Open a terminal window.
  2. Input the following command: 
    sudo dnf install dotnet-sdk-7.0
  3. Press Enter. You might be asked for your password; if so, provide it and press Enter again.
  4. Let the installation process finish.

After the completion of the above steps, the .NET SDK should be installed successfully on your Fedora system.

Part 2: Creating an SSL Certificate for Your .NET Apps

Creating an SSL certificate for your .NET applications can enhance the security of your applications. Here’s how you can generate an SSL certificate:

  1. First, we need to install Easy-RSA, a CLI utility to build and manage a PKI CA. Run this command: 
    sudo dnf install easy-rsa
  2. Now, navigate to the home directory and create a new directory .easyrsa with permissions set to 700: 
    cd ~
mkdir .easyrsa
chmod 700 .easyrsa
  3. Copy the Easy-RSA scripts to our newly created directory: 
    cd .easyrsa
cp -r /usr/share/easy-rsa/3/* ./
  4. Initialize the Public Key Infrastructure: 
    ./easyrsa init-pki
  5. We need to set some variables for our certificate. Create a new file called vars and add the following details in it (You can modify these details according to your requirement): 
    cat << EOF > vars
set_var EASYRSA_REQ_COUNTRY "US"
set_var EASYRSA_REQ_PROVINCE "Texas"
set_var EASYRSA_REQ_CITY "Houston"
set_var EASYRSA_REQ_ORG "Development"
set_var EASYRSA_REQ_EMAIL "local@localhost.localdomain"
set_var EASYRSA_REQ_OU "LocalDevelopment"
set_var EASYRSA_ALGO "ec"
set_var EASYRSA_DIGEST "sha512"
EOF
  6. Now build the CA with nopass option to not secure the CA key with a passphrase: 
    ./easyrsa build-ca nopass
  7. Copy the generated certificate to the trusted CA directory and update the CA trust on your system: 
    sudo cp ./pki/ca.crt /etc/pki/ca-trust/source/anchors/easyrsaca.crt
sudo update-ca-trust
  8. Generate a new key and a certificate signing request for localhost: 
    mkdir req
cd req
openssl genrsa -out localhost.key
openssl req -new -key localhost.key -out localhost.req -subj /C=US/ST=Texas/L=Houston/O=Development/OU=LocalDevelopment/CN=localhost
cd ..
  9. Import the certificate signing request and sign it: 
    ./easyrsa import-req ./req/localhost.req localhost
./easyrsa sign-req server localhost
  10. Now, move the server certificate and key to a new directory .certs and convert the certificate to PKCS#12 format: 
    cd ~
mkdir .certs
cp .easyrsa/pki/issued/localhost.crt .certs/localhost.crt
cp .easyrsa/req/localhost.key .certs/localhost.key
cd .certs
openssl pkcs12 -export -out localhost.pfx -inkey localhost.key -in localhost.crt
  11. Lastly, add the path and the password for the certificate in the .bashrc file so the .NET Core Kestrel server can find it (replace YOUR_USERNAME with your actual username and PASSWORD with the password you want to use for your certificate): 
    cat << EOF >> ~/.bashrc
# .NET
export ASPNETCORE_Kestrel__Certificates__Default__Password="PASSWORD"
export ASPNETCORE_Kestrel__Certificates__Default__Path="/home/YOUR_USERNAME/.certs/localhost.pfx"
EOF

And that’s it! You’ve now installed the .NET SDK and generated an SSL certificate for your .NET apps. Your applications are not only more secure but also more professional, creating trust with users who value their data privacy and security.

ASP.NET Core Blazor file uploads

ASP.NET Core’s Blazor provides a modern, component-based architecture for developing interactive web applications. One of its powerful features is handling file uploads with minimal fuss. This blog post will walk you through the process of setting up file uploads in your Blazor application, ensuring your journey in creating a feature-rich, user-friendly app remains smooth.

Introduction to File Uploads in Blazor

Blazor makes it a breeze to accept file uploads, providing an intuitive approach to handle user interaction. At the heart of this feature is the <InputFile> component, an integral part of Blazor’s component library.

The syntax for utilizing this component is straightforward. You can use the OnChange attribute to specify an event callback, which will be triggered when the user selects a file. To allow multiple file selections, simply add the multiple attribute as shown below:

<InputFile OnChange="@LoadFiles" multiple />

Next, let’s dive into the LoadFiles method, which is invoked when the user selects a file (or files) to upload.

@code {
    private void LoadFiles(InputFileChangeEventArgs e)
    {
        ...
    }
}

InputFileChangeEventArgs gives you access to the selected files. You can then manipulate the file data according to your needs.

Handling File Streams

One common requirement during file uploads is to write the uploaded file data to disk. The Blazor framework provides a convenient method, OpenReadStream(), that returns a Stream. This stream can then be copied to a FileStream to write the data to disk.

Here is a sample code snippet for this:

await using FileStream fs = new(path, FileMode.Create);
await browserFile.OpenReadStream().CopyToAsync(fs);

In this snippet, path is the destination path where the file will be stored, and browserFile is an instance of IBrowserFile representing the uploaded file.

Integration with Azure Blob Storage

If you are using Azure Blob Storage for storing files, Blazor’s integration with Azure makes it easy to upload the file directly. Here’s how you can do this:

await blobContainerClient.UploadBlobAsync(
    trustedFileName, browserFile.OpenReadStream());

blobContainerClient is an instance of BlobContainerClient representing the Azure Blob Storage container, and trustedFileName is the name under which the file will be stored.

Limiting File Sizes

Sometimes, you may want to limit the size of the files that the users can upload. Blazor provides a neat way to do this. You can use the maxAllowedSize parameter in the OpenReadStream method:

// accept a file upto 307200 bytes (300kb) of size
await myFile.OpenReadStream(maxAllowedSize: 1024 * 300).ReadAsync(buffers);

This code will allow only files of size up to 300 KB to be uploaded. If a user tries to upload a larger file, an exception will be thrown.

Wrapping Up

The ability to handle file uploads effectively and efficiently is a key aspect of many web applications. ASP.NET Core Blazor simplifies this process with its robust, developer-friendly components and methods, making file uploads not only functional but also a cinch to implement. Whether you are writing files to disk or using Azure Blob Storage for handling your uploads, Blazor has got you covered. Happy coding!

Clear the NuGet Package Cache using the Command Line

The command dotnet nuget locals all --clear clears all local NuGet resources in the http-request cache, temporary cache, and machine-wide global packages folder.

The dotnet nuget locals command has two options: -c or --clear and -l or --list. The -c option clears the cache, and the -l option lists the cache.

The all argument in the command tells the dotnet nuget locals command to clear all three types of cache: http-request cache, temporary cache, and machine-wide global packages folder.

To clear the NuGet cache using the command line, you can run the following command:

dotnet nuget locals all --clear

This command will clear all local NuGet resources, including the http-request cache, temporary cache, and machine-wide global packages folder.

Note: If you are using Visual Studio, you can also clear the NuGet cache from the Tools menu. In the NuGet Package Manager menu, select Package Manager Settings. In the Options dialog, click the Clear All NuGet Cache(s) button.