Small Introduction on what we will be covering in this course, which will be manipulating and adding data to 10,000 files I have on my desktop using C#.

I recommend the best way to learn is to follow step by step, however here is a link to the complete GitHub repo if you want to see the complete code:
https://github.com/workingdeadnft/RandomRankMetadataAssign

Introduction

Here is just a quick overview of the code for the program. I know it looks a lot, but do not worry! We will go through and write it step by step as we go through the course.

What you will learn

In this video we will cover,

- Installing Visual Studio:
[https://visualstudio.microsoft.com/downloads/](url)

- Talking about how Namespaces work.

- Installing an external package Newtonsoft.Json

- Download these test JSON metadata files to run the script on.
[https://github.com/workingdeadnft/metadata-gen](url)


Getting Started

Orientation

Using the tool:
https://json2csharp.com/ 

We are able to convert an example metadata file into a object like below. 

```
public class Attribute
    {
        public string trait_type { get; set; }
        public string value { get; set; }
    }

    public class Metadata
    {
        public string name { get; set; }
        public string image { get; set; }
        public string description { get; set; }
        public List<Attribute> attributes { get; set; }
    }
``` 

Create your first class

In the world of C# programming, an "object" is like a magic container that holds data and functions together. Imagine it as a real-world object, like a car or a dog. Just like a car has characteristics (color, speed, and brand) and can perform actions (drive, honk), C# objects have attributes (variables) and behaviors (methods).

Attributes (Variables): Objects have properties or attributes that describe them. For example, a "Person" object might have attributes like "Name," "Age," and "Gender." These attributes are called variables in C#.

Behaviors (Methods): Objects can perform actions or behaviors. Continuing with the "Person" example, behaviors might include "Walk," "Talk," or "Eat." In C#, these actions are defined as methods.

In our example in this video we have used a car, which is made up of a make, model and wheels count.

Digging Deeper into Objects

In the world of C# programming with Visual Studio, a "breakpoint" is like a navigation tool that helps you inspect and understand your code while it's running. Imagine it as a pause button for your program, allowing you to stop execution at a specific line of code to examine the program's state.

Purpose of Breakpoints:

Breakpoints serve several important purposes:

Debugging: Breakpoints are primarily used for debugging. When you suspect there's a problem in your code, you can set a breakpoint at a particular line where you want to pause the program's execution. This allows you to inspect variables, check the flow of your program, and identify errors.

Understanding Code Flow: Breakpoints are invaluable for understanding how your code flows during execution. By pausing at specific points, you can see the order in which statements are executed, helping you grasp the logic of your program.

Setting a Breakpoint:

Here's how you can set a breakpoint in Visual Studio:

Open your C# project in Visual Studio.
Navigate to the line of code where you want to set the breakpoint.
Click in the left margin of the code editor window next to the line where you want the breakpoint. A red dot will appear, indicating the breakpoint.
Using Breakpoints:

Once you've set a breakpoint, follow these steps to use it:

Start debugging your program by clicking the "Start Debugging" button (usually a green arrow) or pressing F5.
When your program reaches the line with the breakpoint, it will pause, and Visual Studio will switch to the "Debug" perspective.
You can now inspect variables, step through your code line by line, and see the values of variables in the "Locals" window.
Removing a Breakpoint:

If you want to remove a breakpoint, simply click on the red dot in the left margin again, and it will disappear.

Breakpoints are essential tools for developers, helping them track down and fix issues in their code efficiently. As you become more familiar with C# and Visual Studio, you'll find breakpoints to be one of your most valuable assets in ensuring your programs run smoothly.

Breakpoints

A foreach loop in C# is a specialized iteration construct designed for iterating over elements in enumerable collections, such as arrays, lists, dictionaries, or other data structures that implement the IEnumerable interface. It simplifies the process of iterating through elements without the need for an explicit index.



Loops and Deserialisation

Serializing and deserializing data in C# using Newtonsoft.Json (often referred to as JSON.NET) is a common task in modern software development. JSON (JavaScript Object Notation) is a lightweight data interchange format that is widely used for data storage and exchange between different systems and platforms. Newtonsoft.Json is a popular third-party library for working with JSON data in C#.

Change and serialise

Writing Code

Now we need to tell the program about the different ranks that we want to assign. You can follow and write your own ranks on what you seen fit and how you would like to distribute them.



Setting up Ranks

Create an instance of the Random class. This is done by declaring a variable of type Random, like this:
```
Random random = new Random();
```
Now, you can use methods provided by the Random class to generate random numbers.
a. To generate a random integer, you can use the Next() method. This method takes two arguments, the inclusive minimum value and the exclusive maximum value. It returns a random integer within the specified range. For example, to generate a random number between 1 and 10:

```
int randomNumber = random.Next(1, 11);
```
b. To generate a random floating-point number (decimal), you can use the NextDouble() method. This method returns a random floating-point number between 0.0 (inclusive) and 1.0 (exclusive). For example:

```
double randomDecimal = random.NextDouble();
```
c. If you need a random boolean value (true or false), you can use the Next() method with a range of 0 and 2. This method returns either 0 or 1, which can be interpreted as true or false, respectively. For example:

```
bool randomBoolean = random.Next(0, 2) == 1;
```
That's it! You now have the basic knowledge to generate random numbers in C#. Remember to always create one instance of the Random class and reuse it throughout your program to avoid predictable patterns in the generated numbers.

Generating Random Numbers

In this video we need to be able to define the difference between the 5,000 skulls and 5,000 robots by writing some code that looks at the attributes of the metadata and captures which is which.

Splitting the Groups

Ranks and Random Numbers

Testing Get Random Rank

We've been able to confirm that the tool works and does what we expect. However there are a few finishing touches we need to make to cover all bases and ensure the entire 10,000 finals are generated based on all the rank numbers.

Finishing Touches

Great job, if you followed these videos I hope you now have a basic understanding of how to use a small fraction of tools of what is available in C# to make useful scripts. 

It really is that simple!

Here is the complete GitHub repo for you to clone and check out:
https://github.com/workingdeadnft/RandomRankMetadataAssign

Conclude

Testing and Wrapping Up

Learn how to use C# to change or add to metadata files. This course will take you through how we randomly assigned ranks to The Working Dead Bot Wars 10,000 collection. 

Learn how to use C# to change or add to metadata files. 

Creating a simple terminal script in C#

Course Details

Level:

Lessons:

Modules:

Ratings:

Public ADA Price:

Holder $WORK Price:

Public ADA Price:

Holder ADA Price:

Public SOL Price:

Holder SOL Price:

NFT Token Gated Policy ID:

NFT Token Gated Contract: