Blockchain technology has revolutionized numerous industries by providing a secure, decentralized, and transparent platform for conducting transactions and maintaining records. With the increasing demand for blockchain applications, integrating blockchain into web applications has become essential for many businesses. In this article, we will explore how to implement blockchain in ASP.NET Core, one of the most popular web development frameworks, using the C# programming language. We will cover the key concepts of blockchain and walk through code examples to demonstrate its implementation.

Blockchain is a distributed ledger technology that enables the creation of a decentralized, tamper-proof, and transparent system for recording transactions. It consists of a chain of blocks, where each block contains a set of transactions and a reference to the previous block. The key features of blockchain include immutability, transparency, and consensus.

we will use Nethereum, Nethereum is a popular Ethereum library for .NET

Now for the Part of Implementing the Blockchain Logic.
First we will create a new folder called “Blockchain” in the project root directory.
Now inside the blockchain folder we will add new class file Block.cs This class represents a block in the blockchain.

public class Block
{
    public int Index { get; set; }
    public DateTime Timestamp { get; set; }
    public string Data { get; set; }
    public string PreviousHash { get; set; }
    public string Hash { get; set; }
}

Below is the description of the Class Block Properties.

Index: It is an integer property representing the index or position of the block within the blockchain.

Timestamp: It is a DateTime property representing the timestamp or the time at which the block was created or added to the blockchain.

Data: It is a string property that holds the data or information associated with the block. The data can vary depending on the purpose of the blockchain.

PreviousHash: It is a string property that stores the hash value of the previous block in the blockchain. This property is used to maintain the integrity and chronological order of the blocks in the blockchain.

Hash: It is a string property that stores the hash value of the current block. The hash is calculated based on the combination of all the block’s properties (including Index, Timestamp, Data, and PreviousHash) and serves as a unique identifier for the block. It ensures the immutability and security of the block’s contents.

next step is to add a new class file called Blockchain.cs to represent the entire blockchain and provide the necessary methods for managing blocks.

public class Blockchain
{
    private List<Block> chain;

    public Blockchain()
    {
        chain = new List<Block>();
        InitializeGenesisBlock();
    }

    private void InitializeGenesisBlock()
    {
        chain.Add(CreateGenesisBlock());
    }

    private Block CreateGenesisBlock()
    {
        return new Block
        {
            Index = 0,
            Timestamp = DateTime.Now,
            Data = "Genesis Block",
            PreviousHash = string.Empty,
            Hash = CalculateBlockHash(0, DateTime.Now, "Genesis Block", string.Empty)
        };
    }

    private string CalculateBlockHash(int index, DateTime timestamp, string data, string previousHash)
    {
        
        string blockData = $"{index}-{timestamp}-{data}-{previousHash}";
        byte[] bytes = Encoding.UTF8.GetBytes(blockData);
        byte[] hashBytes;

        using (SHA256 sha256 = SHA256.Create())
        {
            hashBytes = sha256.ComputeHash(bytes);
        }

        StringBuilder builder = new StringBuilder();
        foreach (byte b in hashBytes)
        {
            builder.Append(b.ToString("x2"));
        }

        return builder.ToString();
    }

    
}

Futhermore, the detailed explanation of the above code is as follows.

Block Class:

This class represents a block in the blockchain.
It contains properties such as Index, Timestamp, Data, PreviousHash, and Hash.
The properties store information about the block’s position, creation time, data, and hash values.
The Hash property is calculated based on the block’s properties and serves as a unique identifier.
Blockchain Class:

This class represents the blockchain itself and manages the chain of blocks.
It has a private member variable called chain, which is a list of Block objects representing the blocks in the chain.
Blockchain() Constructor:

This constructor initializes a new instance of the Blockchain class.
It creates an empty list for the chain and calls the InitializeGenesisBlock() method.
InitializeGenesisBlock() Method:

This method adds the genesis block (the first block in the blockchain) to the chain.
It calls the CreateGenesisBlock() method to create the genesis block and adds it to the chain list.
CreateGenesisBlock() Method:

This method creates and returns the genesis block.
It sets the properties of the genesis block, including the index, timestamp, data, previous hash, and calculates the hash value based on these properties using the CalculateBlockHash() method.
CalculateBlockHash() Method:

This method calculates and returns the hash value of a block.
It concatenates the index, timestamp, data, and previous hash into a single string.It converts the concatenated string to bytes and uses the SHA256 algorithm to compute the hash value.The hash bytes are then converted to a hexadecimal string representation and returned.
Overall the Blockchain class, it will automatically initialize with a genesis block.
we will add our class as a service in Program.cs services.AddSingleton(); next to test run the application to see the result in json Format.

Introduction:

In the digital age, we generate massive amounts of data every day. Sentiment analysis helps us understand the emotions expressed in text data, such as whether it’s positive, negative, or neutral. ML.NET is a machine learning framework that enables developers to perform sentiment analysis using C# or any .NET programming language. In this blog post, we’ll explore the basics of sentiment analysis in ML.NET and how it can help unlock valuable insights from text data.

Sentiment Analysis:

Sentiment analysis is all about figuring out the emotional tone of a piece of text. It helps us determine whether the sentiment is positive (happy, satisfied), negative (sad, angry), or neutral (neutral, indifferent). By analyzing text from social media posts, customer reviews, and other sources, sentiment analysis allows businesses to make informed decisions, improve customer experiences, and spot emerging trends.

ML.NET:

ML.NET is a machine learning framework developed by Microsoft. It lets developers build custom machine learning models using C# or any .NET language. ML.NET simplifies the integration of machine learning into applications and offers various algorithms and pre-trained models. It’s designed to make machine learning accessible to developers with different levels of expertise.

Performing Sentiment Analysis with ML.NET:

1.Select the C# Console App project template.

2.Change the project name to myMLApp.

3.Make sure Place solution and project in the same directory is unchecked

4.Select .NET 7.0 (Standard Term support) as the Framework.

5.Right-click on the myMLApp project in Solution Explorer and select Add > Machine Learning Model.

6.In the Add New Item dialog, make sure Machine Learning Model (ML.NET) is selected.

7.Change the Name field to SentimentModel.mbconfig and select the Add button

8.Pick a scenario

To begin, open the Model Builder tool and select the “Data classification” scenario from the available options. This scenario is suitable for predicting the category of a comment, such as determining whether it falls into a positive or negative sentiment.

After selecting the “Data classification” scenario, ensure that the training environment is set to “Local.” Although some scenarios allow for training in Azure, classification specifically supports only local training. Once you have confirmed the local environment, proceed to the next step, which is the “Data” step.

Add data

In Model Builder, you can add data from a local file or connect to a SQL Server database. In this case, you’ll add yelp_labelled.txt from a file.

1. Select File as the input data source type.
2. Browse for yelp_labelled.txt. Once you select your dataset, a preview of your data appears in the Data Preview section. Since your dataset does not have a header, headers are auto-generated (“col0” and “col1”).
3. Under Column to predict (Label), select “col1”. The Label is what you’re predicting, which in this case is the sentiment found in the second column (“col1”) of the dataset.
4. The columns that are used to help predict the Label are called Features. All of the columns in the dataset besides the Label are automatically selected as Features. In this case, the review comment column (“col0”) is the Feature column. You can update the Feature columns and modify other data loading options in Advanced data options, but it is not necessary for this example.

Train your model

Now, you’ll train your model with the yelp_labelled.txt dataset.

Model Builder evaluates many models with varying algorithms and settings based on the amount of training time given to build the best performing model.

1. Change the Time to train, which is the amount of time you’d like Model Builder to explore various models, to 60 seconds (you can try increasing this number if no models are found after training) . Note that for larger datasets, the training time will be longer. Model Builder automatically adjusts the training time based on the dataset size.
2. Select Start training to start the training process. Once training starts, you can see the time remaining.

Training results

• Best accuracy – This shows you the accuracy of the best model that Model Builder found. Higher accuracy means the model predicted more correctly on test data.
• Best model – This shows you which algorithm performed the best during Model Builder’s exploration.
• Training time – This shows you the total amount of time that was spent training / exploring models.
• Models explored (total) – This shows you the total number of models explored by Model Builder in the given amount of time.

Evaluate your model

Consume your model

The last step is to consume your trained model in the end-user application.

1. Replace the Program.cs code in your myMLApp project with the following code:

Run myMLApp (select Ctrl+F5 or Debug > Start Without Debugging). You should see the following output, predicting whether the input statement is positive or negative.

Introduction:

Object detection is a fundamental task in computer vision, and YOLO (You Only Look Once) is a popular real-time object detection algorithm. In this blog, we will explore how to perform object detection using YOLOv3 in C# with the Emgu.CV library. We will build a simple application that can detect objects in real-time using a webcam.

Prerequisites:

To follow along with this tutorial, make sure you have the following prerequisites:

1. Visual Studio or any C# development environment installed.
2. Emgu.CV library installed.
3. Darknet YOLOv3 configuration file (.cfg) and pre-trained weights file (.weights).
4. COCO dataset class labels file (coco.names).
5. Webcam or a video source to capture frames.

Step 1: Setting Up the Project First, create a new C# project in your preferred development environment. Make sure you have the Emgu.CV library referenced in your project.

Step 2: Loading YOLOv3 Model and Class Labels In the provided code, we start by loading the YOLOv3 model and the corresponding class labels from the files. Adjust the paths to the configuration file (“yolov3.cfg”), weights file (“yolov3.weights”), and class labels file (“coco.names”) based on your local file system.

Step 3: Setting Backend and Target for DNN Next, we set the preferable backend and target for the DNN (Deep Neural Network) module. In this case, we choose the OpenCV backend and CPU as the target device. However, you can modify these settings based on your hardware capabilities and requirements.

Step 4: Initializing VideoCapture and Frame Processing We create a VideoCapture object to access the webcam or video source. The code inside the while loop continuously captures frames and processes them for object detection.

Step 5: Preprocessing and Forward Pass For each captured frame, we resize it and convert it to the required format for the YOLOv3 model. The frame is then passed through the network for a forward pass, and the output is obtained.

Step 6: Object Detection and Visualization The output from the network is processed to extract the bounding boxes, class indices, and confidence scores for detected objects. We filter out detections with confidence below a certain threshold (0.8 in this case). Non-maximum suppression (NMS) is applied to remove overlapping bounding boxes.

Finally, we draw the bounding boxes and class labels on the frame. The resulting frame is then resized and displayed using the OpenCV imshow function.

Step 7: Exiting the Application The application continues to capture frames and perform object detection until the user presses the ‘Esc’ key. This is achieved by checking for a keyboard event using the CvInvoke.WaitKey function.

Object detection from Webcam

using Emgu.CV;
using Emgu.CV.Dnn;
using Emgu.CV.Structure;
using Emgu.CV.Util;

class Program
{
static void Main(string[] args)
{
// Step 2: Loading YOLOv3 Model and Class Labels
var net = DnnInvoke.ReadNetFromDarknet(“F:\OpenCVTutorials-masters\OpenCVTutorials-master\detection\yolov3.cfg”, “F:\OpenCVTutorials-masters\OpenCVTutorials-master\detection\yolov3.weights”);
var classLabels = File.ReadAllLines(“F:\OpenCVTutorials-masters\OpenCVTutorials-master\detection\coco.names”);

// Step 3: Setting Backend and Target for DNN
net.SetPreferableBackend(Emgu.CV.Dnn.Backend.OpenCV);
net.SetPreferableTarget(Emgu.CV.Dnn.Target.Cpu);

// Step 4: Initializing VideoCapture and Frame Processing
var vc = new VideoCapture(0, VideoCapture.API.DShow);
Mat frame = new();
VectorOfMat output = new();

VectorOfRect boxes = new();
VectorOfFloat scores = new();
VectorOfInt indices = new();

while (true)
{
vc.Read(frame);

CvInvoke.Resize(frame, frame, new System.Drawing.Size(0, 0), .4, .4);

boxes = new();
indices = new();
scores = new();

var image = frame.ToImage<Bgr, byte>();

// Step 5: Preprocessing and Forward Pass
var input = DnnInvoke.BlobFromImage(image, 1 / 255.0, swapRB: true);

net.SetInput(input);

net.Forward(output, net.UnconnectedOutLayersNames);

for (int i = 0; i < output.Size; i++)
{
var mat = output[i];
var data = (float[,])mat.GetData();

for (int j = 0; j < data.GetLength(0); j++)
{
float[] row = Enumerable.Range(0, data.GetLength(1))
.Select(x => data[j, x])
.ToArray();

var rowScore = row.Skip(5).ToArray();
var classId = rowScore.ToList().IndexOf(rowScore.Max());
var confidence = rowScore[classId];

if (confidence > 0.8f)
{
var centerX = (int)(row[0] * frame.Width);
var centerY = (int)(row[1] * frame.Height);
var boxWidth = (int)(row[2] * frame.Width);
var boxHeight = (int)(row[3] * frame.Height);

var x = (int)(centerX – (boxWidth / 2));
var y = (int)(centerY – (boxHeight / 2));

boxes.Push(new System.Drawing.Rectangle[] { new System.Drawing.Rectangle(x, y, boxWidth, boxHeight) });
indices.Push(new int[] { classId });
scores.Push(new float[] { confidence });
}
}
}

// Step 6: Object Detection and Visualization
var bestIndex = DnnInvoke.NMSBoxes(boxes.ToArray(), scores.ToArray(), .8f, .8f);

var frameOut = frame.ToImage<Bgr, byte>();

for (int i = 0; i < bestIndex.Length; i++)
{
int index = bestIndex[i];
var box = boxes[index];
CvInvoke.Rectangle(frameOut, box, new MCvScalar(0, 255, 0), 2);
CvInvoke.PutText(frameOut, classLabels[indices[index]], new System.Drawing.Point(box.X, box.Y – 20),
Emgu.CV.CvEnum.FontFace.HersheyPlain, 1.0, new MCvScalar(0, 0, 255), 2);
}

CvInvoke.Resize(frameOut, frameOut, new System.Drawing.Size(0, 0), 4, 4);
CvInvoke.Imshow(“output”, frameOut);

// Step 7: Exiting the Application
if (CvInvoke.WaitKey(1) == 27)
break;
}
}

}

Conclusion: In this blog post, we learned how to perform real-time object detection using YOLOv3 in C# with the Emgu.CV library. We explored the code that loads the YOLOv3 model, captures frames from a video source, and performs object detection using the model’s output. The detected objects are then visualized by drawing bounding boxes and class labels on the frames.

Web3 is a term that refers to the next generation of the World Wide Web, where decentralized technologies are used to build applications that are more open, transparent, and secure. Web3 incorporates blockchain technology and smart contracts to enable peer-to-peer transactions, decentralized identity, and decentralized applications (dApps). In the context of C# and .NET development, Nethereum is a powerful library that allows you to interact with the Ethereum blockchain using C#.

Started with QuickNode

QuickNode is a platform that provides infrastructure and hosting services for blockchain and Web3 applications. It allows developers to easily deploy and manage their own nodes, which are essential for interacting with various blockchain networks. QuickNode supports a wide range of blockchain networks, including Ethereum, Bitcoin, Binance Smart Chain, and more.

By using QuickNode, developers can access the full functionality of blockchain networks without the need to set up and maintain their own infrastructure. QuickNode offers reliable and scalable node hosting, real-time monitoring, API access, and developer tools to simplify the process of building decentralized applications (dApps) and interacting with blockchain networks.

Step1: Go to https://QuickNode.com/, create account and verify your email.

Step2: Select your Plan

Step3: Create your endpoint

, the URL in the HTTP provider “https://black-indulgent-mountain.discover.quiknode.pro/d0129a8c1559a7d8f6c69a6641591f0a7813e561/” is passed as a parameter when creating a new instance of the Web3 class. This URL specifies the endpoint of the QuikNode service that hosts the Ethereum node.

How to connect to Ethereum using .NET (Nethereum)

Nethereum is a .NET integration library for Ethereum, which allows developers to interact with the Ethereum blockchain using .NET and C#. It provides a comprehensive set of tools and functionalities for building decentralized applications (dApps) and interacting with Ethereum smart contracts.

Installing Nethereum​

Nethereum requires .NET Core or .NET Framework(4.5.1+) installed. We’ll install .NET Core SDK to make Nethereum work. Download and install the .NET Core SDK ver 3.1 based on your operating system. Then go to your terminal/command line and type the following.

$ dotnet new console -o nethereuma

This will create a new .NET application in the current directory. You can give your application any name

Now cd into your application.

$ cd nethereuma

Add package reference to Nethereum.Web3

$ dotnet add package Nethereum.Web3

This might take a while. After the package reference is added, download/update the package by typing the following.

$ dotnet restore

If everything goes right, Nethereum will be added to your system with nethereum web3 package.

Booting our Ethereum node

After you’ve created your free ethereum endpoint, copy your HTTP Provider endpoint:

You’ll need this later, so copy it and save it.

Connecting with Ethereum

Now go to your .NET app folder and open the Program.cs C# file in a text editor .

Connect with Ethereum and then get the latest block number from the Ethereum blockchain.

class Program
{
    static void Main()
    {
        GetBlockNumber().Wait();
       
    }

static async Task GetBlockNumber()
{
     var web3 = new Web3("ADD_YOUR_ETHEREUM_NODE_URL");
     var latestBlockNumber = await     web3.Eth.Blocks.GetBlockNumber.SendRequestAsync();
     Console.WriteLine($"Latest Block Number is: {latestBlockNumber}");
        }
}

Generate a Ethereum Address

While signing in to any platform on the internet, you need to authenticate using a combination of credentials. Consider an Ethereum address as your username and a corresponding private key as the password. While your Ethereum address is public and can be shared, the private key must always be kept secret. Using this combination lets you interact with the Ethereum blockchain. An Ethereum address is your identity on the blockchain, and it looks like this “0x6E0d01A76C3Cf4288372a29124A26D4353EE51BE”.

 static void GenerateEthereumAddress()
    {
        // Generate a new Ethereum account
        var ecKey = Nethereum.Signer.EthECKey.GenerateKey();
        var privateKey = ecKey.GetPrivateKey();
        var address = ecKey.GetPublicAddress();

        // Output the generated address and private key
        Console.WriteLine("Ethereum Address: " + address);
        Console.WriteLine("Private Key: " + privateKey);
    }

Run the code