Description: A value type is like a piece of paper with a number or value written on it. When you give it to someone (or assign it to another variable), you’re giving them a copy of that paper. Changing the copy doesn’t affect the original. Value types store the actual data directly and are typically simple, like numbers or true/false values.

Key Characteristics:

• Stored directly in memory (on the stack, for tech folks).

• Includes most predefined types like int, double, bool, char, and structs like DateTime.

• When assigned, a copy of the value is made.

Use Cases:

• Storing simple data like ages, prices, or counts.

• Representing dates or times (e.g., DateTime).

• Using in calculations where you don’t want the original value to change accidentally.

Code Sample :

using System;

class Program
{
    static void Main()
    {
        // Value type: int
        int original = 10;
        int copy = original; // Creates a copy of the value
        copy = 20; // Changing copy doesn't affect original

        Console.WriteLine($"Original: {original}"); // Still 10
        Console.WriteLine($"Copy: {copy}"); // Now 20

        // Value type: struct (DateTime)
        DateTime date = DateTime.Now;
        DateTime copyDate = date; // Creates a copy
        copyDate = copyDate.AddDays(1); // Changing copy doesn't affect original

        Console.WriteLine($"Original Date: {date}");
        Console.WriteLine($"Copy Date: {copyDate}");
    }

Example:

• Scenario: A program tracks a person’s age and the current date.

• Value Types: int for age, DateTime for the date.

• Behavior: Changing the copy variable (age) or copyDate (date) doesn’t affect original or date.

• Output (example, assuming today is May 28, 2025):

Output :

2. Reference Types

Description: A reference type is like a treasure map. Instead of holding the treasure (data) directly, it holds a pointer (or address) to where the treasure is stored. When you give someone the map (assign it to another variable), you’re giving them a copy of the map, not the treasure. Both maps point to the same treasure, so changing the treasure affects everyone with a map.

Key Characteristics:

• Stored in memory (on the heap), with variables holding a reference (pointer) to the data.

• Includes classes, arrays, strings, and objects like List<T>.

• When assigned, only the reference is copied, not the data itself.

Use Cases:

• Storing complex data like a customer’s full profile (name, address, etc.).

• Managing lists or collections (e.g., a list of students).

• Sharing data across multiple parts of a program where changes should be reflected everywhere.

Code Sample:

using System;
using System.Collections.Generic;

class Person
{
    public string Name { get; set; }
}

class Program
{
    static void Main()
    {
        // Reference type: class
        Person originalPerson = new Person { Name = "Alice" };
        Person referencePerson = originalPerson; // Copies the reference, not the object

        referencePerson.Name = "Bob"; // Changes the same object

        Console.WriteLine($"Original Person Name: {originalPerson.Name}"); // Bob
        Console.WriteLine($"Reference Person Name: {referencePerson.Name}"); // Bob

        // Reference type: List
        List<int> numbers = new List<int> { 1, 2, 3 };
        List<int> referenceNumbers = numbers; // Copies the reference
        referenceNumbers.Add(4); // Changes the same list

        Console.WriteLine("Numbers: " + string.Join(", ", numbers)); // 1, 2, 3, 4
        Console.WriteLine("Reference Numbers: " + string.Join(", ", referenceNumbers)); // 1, 2, 3, 4
    }
}

Example:

• Scenario: A program tracks a person’s name and a list of scores.

• Reference Types: Person (a class) and List<int> (a collection).

• Behavior: Changing reference Person.Name or adding to referenceNumbers affects the original because they point to the same data.

• Output :

  

3. Nullable Types

Description: A nullable type is like a box that can either hold a value (like a number) or be empty (null). Normally, value types (like int) must have a value, but nullable types let them be “nothing” if needed. It’s like saying, “I don’t know the answer yet” instead of being forced to pick a number.

Key Characteristics:

• Applies to value types (e.g., int, double, bool) using the ? symbol (e.g., int?).

• Can hold a value or null.

• Useful when a value might not be available or applicable.

Use Cases:

• Storing optional data, like a middle initial that someone might not have.

• Handling database fields that can be null (e.g., a “date of graduation” that’s not set yet).

• Representing missing or unknown values in calculations.

Code Sample

using System;

class Program
{
    static void Main()
    {
        // Nullable type: int?
        int? age = null; // No value yet
        Console.WriteLine($"Age: {(age.HasValue ? age.Value.ToString() : "Unknown")}");

        age = 30; // Now has a value
        Console.WriteLine($"Age: {age}");

        // Nullable type: double?
        double? temperature = null;
        Console.WriteLine($"Temperature: {(temperature.HasValue ? temperature.Value.ToString() : "Not recorded")}");

        temperature = 72.5;
        Console.WriteLine($"Temperature: {temperature}");
    }
}

Example:

• Scenario: A form collects a person’s age and the room’s temperature, but the user might not provide either.

• Nullable Types: int? for age, double? for temperature.

• Behavior: The program checks if there’s a value using HasValue before using it.

• Output :

• 

Description :

• These are the names you give to things you create in your code, like variables, constants, or classes. It’s like naming your pet—you pick a name, but it has to follow some rules (e.g., no spaces, can’t start with a number).

• Scope: This is about where in your program a variable or constant can be used. It’s like deciding if a toy is only available in one room (local scope) or the whole house (global scope).

Rules for Identifiers:

• Can include letters, numbers, and underscores (_).

• Must start with a letter or underscore.

• Can’t be a keyword (e.g., int or class).

Use Cases:

• Naming variables to store data (e.g., userAge, totalPrice).

• Defining constants for fixed values (e.g., MaxAttempts).

• Controlling access to variables in different parts of the program (e.g., local variables in a method vs. global variables in a class).

Invalid Identifiers

Refers to names used for variables, functions, classes, etc., that don't follow the naming rules of the programming language you're using

Examples :

1. 2cool : Starts with a digit.

   1. Valid Alternatives : cool2

2. first-name : Contains a hyphen.

   1. Valid Alternatives : first_name, firstName

3. class : Reserved keyword

   1. Valid Alternatives : className, _class

4. user name : Contains a space

   1. Valid Alternatives: user_name, userName

5. total$amount : Special character $

   1. Valid Alternatives: total_amount

Note : If you're getting an "invalid identifier" error, check:

• Typos

• Special characters

• If the name is a reserved keyword

2. Pre-defined Types

Predefined types are like the basic ingredients C# gives you to work with, like flour, sugar, or eggs in baking. They’re the building blocks for storing things, like numbers, words, or true/false values.

Common Types

Use Case:

If you want to store someone’s age, you use the int type (for whole numbers). If you want their name, you use the string type (for words).

Code Example: Using Pre-defined Types in C#

using System;

class Program
{
    static void Main()
    {
        // Predefined types
        int age = 25;              // Whole number
        double height = 5.9;       // Decimal number
        string name = "Charlie";   // Text
        bool isStudent = true;     // True or False
        char grade = 'A';          // Single character
        decimal amount = 5.9M;       // Decimal number for Money

        Console.WriteLine($"Name: {name}");
        Console.WriteLine($"Age: {age}");
        Console.WriteLine($"Height: {height} feet");
        Console.WriteLine($"Is Student: {isStudent}");
        Console.WriteLine($"Grade: {grade}");
    }
}

C# has ready-made types like int (numbers), string (text), bool (true/false), and others. You pick the right type for what you’re storing, just like picking the right ingredient for a recipe.

3. Keywords

Keywords are special words that C# reserves for its own use. They’re like instructions the language understands, so you can’t use them as names for your variables or constants. Think of them as the “command words” the computer listens to.

Use Cases:

• Defining program structure (e.g., class, if, for).

• Specifying data types (e.g., int, string).

• Controlling program flow (e.g., break, return).

Examples of Keywords:

• int, string, double (for data types).

• if, else, for, while (for control flow).

• class, static, void (for defining program structure).

Scenario: A program checks if someone is an adult based on their age.

• Keywords Used: int (to define the age variable), if and else (to make a decision).

using System;

class Program
{
    static void Main()
    {
        // Using keywords: int, if, else
        int age = 20;

        if (age >= 18)
        {
            Console.WriteLine("You are an adult.");
        }
        else
        {
            Console.WriteLine("You are a minor.");
        }
    }
}
// Output : 
You are a minor.

Output :

Note: Keywords can not be used as a name of things you define in your code . The Compiler already set a meaning to them so they are not valid identifiers. Only Valid identifiers you can use in naming stuff in your code like variables , constants , classes , methods etc.

4. Variables

A variable is like a labeled box where you can store information, like a number or text, and change what’s inside the box whenever you need to. It’s a way to keep track of data in your program.

Variables: Changeable storage boxes for data

Use Cases:

• Storing user input (e.g., a player’s name in a game).

• Keeping track of numbers for calculations (e.g., a score or total price).

• Holding temporary data, like a counter in a loop.

Code Example: Creating Variable in C#

using System;

class Program
{
    static void Main()
    {
        // Declare a variable to store a player's name
        string playerName = "Alice";
        // Declare a variable to store a score
        int score = 100;

        Console.WriteLine($"Player: {playerName}, Score: {score}");

        // Change the variable values
        playerName = "Bob";
        score = 150;

        Console.WriteLine($"Player: {playerName}, Score: {score}");
    }
}

// Output
Player: Alice, Score: 100
Player: Bob, Score: 150

Example:

• Scenario: A game tracks a player’s score.

• Variable: score holds the value 100. Later, it changes to 150 when the player earns more points.

Console.Writeline() : This is how you display on a Console(Terminal) the value stored in your variable

5. Constants

A constant is like a variable, but its value is locked in and can’t be changed once set. It’s like writing a value in permanent marker on a box—you can’t erase or overwrite it.

Constants: Unchangeable values

Use Cases:

• Defining fixed values like tax rates or mathematical constants (e.g., π).

• Setting configuration values that shouldn’t change, like maximum retries in a program.

• Ensuring critical values remain unchanged to avoid bugs.

Code Sample:

using System;

class Program
{
    // Declare a constant for the tax rate
    const double TaxRate = 0.08;

    static void Main()
    {
        double price = 100.00;
        double tax = price * TaxRate;

        Console.WriteLine($"Price: ${price}, Tax: ${tax}, Total: ${price + tax}");

        // This would cause an error: TaxRate = 0.10; // Constants can't be changed
    }
}

Example:

• Scenario: A shopping app calculates tax on a $100 item using a fixed tax rate of 8%.

• Constant: TaxRate is set to 0.08 and never changes.

• Output :

  

Dotnet Restore :

• Downloads all the external packages (NuGet packages) your project depends on. Think of it like , Checking your shopping list and downloading everything from the store before you start cooking

  What it does:

  • Reads your .csproj or packages.config

  • Connects to NuGet

  • Downloads the required packages into your local machine (usually in ~/.nuget/packages/)

  • Usually happens automatically with dotnet build in .NET Core and later versions

Dotnet Build :

• Compiles your project source code into a .dll or .exe file. Think of it like, Cooking the meal using the ingredients you got from the store.

  What it does:

  • Runs the compiler (Roslyn)

  • Turns your .cs files into IL (Intermediate Language)

  • Outputs into the /bin/Debug or /bin/Release folder

Dotnet Run

• • The dotnet run command builds and immediately executes your .NET application. Think of it like pressing the "Play" button in Visual Studio — your app compiles and launches

    What Happens When You Run

    It performs these steps under the hood:

    1. Restores NuGet packages (if needed)

    2. Builds the project (compiles code)

    3. Runs the app

This is the command line interface to develop .net applications . You can use the cli to create a solution , create new application, add application to solution, build , test , run , publish applications and many more

Most Common .Net CLI Commands you will need on a regular basis as a .Net developer

> dotnet new --list  # List templates for all types of application
> dotnet --info # Check SDK info
> dotnet --version # Check SDK version

> dotnet new sln -n <MySolution> # Creates a new solution file named MySolution.sln

> dotnet new console -n <MyApp> # Creates a new Console App in a folder called MyApp

> dotnet new webapi -n MyApi           # ASP.NET Core Web API
> dotnet new mvc -n MyMvcApp           # ASP.NET MVC
> dotnet new blazorserver -n MyBlazor  # Blazor Server app
> dotnet new classlib -n MyLibrary     # Class library

> dotnet sln MySolution.sln add MyApp/MyApp.csproj  # Adds the MyApp project to the solution file

> dotnet build # Compiles the app and checks for errors.
> dotnet build MyApp/MyApp.csproj # You can specify a project 
> dotnet restore # Restore packages or dependencies

> dotnet test # Run Tests

> dotnet run --project MyApp #Runs the specified project. 
> dotnet run

> dotnet publish -c Release -o ./publish  # Builds the app and prepares it for deployment into the ./publish folder.
> dotnet publish MyApp/MyApp.csproj -c Release -o ./publish

2. Visual Studio Code (VS Code)

A lightweight, fast, and customizable code editor from Microsoft. Ideal for web, cloud, and cross-platform development.

2. Best for:

   • Web developers

   • .NET Core, JavaScript, Python, Go, etc.

   • Cross-platform use (Windows, macOS, Linux)

   • Download link : 👉 https://code.visualstudio.com/

3. Visual Studio (Full IDE)

A full-featured Integrated Development Environment (IDE) mainly used for .NET and C++ development. It includes advanced debugging, UI designers, code generation, profiling tools, and more.

Best for:

• Windows users building enterprise apps

• ASP.NET Core, Blazor, WPF, Xamarin, and WinForms

• Serious .NET development and large solutions

🔗 Download link:

👉 https://visualstudio.microsoft.com/

Choose “Community Edition” if you’re an individual or student — it’s free

4. WSL 2

WSL 2 lets you run a Linux environment directly inside Windows, including the Linux command line, tools, and apps.

🔹 Best for:

• Developers who want Linux tools on Windows

• Running Docker, bash, Python, Node, etc.

• Full-stack developers working in Linux-based environments

🔗 Download + install guide:

👉 https://learn.microsoft.com/windows/wsl/install

⚠️ You need Windows 10 version 2004+ or Windows 11

5. Docker Desktop

2. A tool that lets you build, run, and manage containers on your local machine. Docker Desktop includes everything needed to run containers using Docker Engine.

   🔹 Best for:

   • Creating isolated dev/test environments

   • Running microservices and APIs

   • Learning DevOps, Kubernetes, and CI/CD

🔗 Download link:

👉 https://www.docker.com/products/docker-desktop/

⚠️ Requires WSL 2 on Windows for Linux container support.

6. Databases (Optional)

If your application needs to connect to a database , then you have to choose from this major databases .-

• Relational Database

  • Sql Lite

  • MS SQL

  • My SQL

  • Postgres SQL

• Document Database

  • Mongo DB

• Cache

1 .Net SDK

An SDK is a collection of tools, libraries, documentation, and code samples provided by a platform or service to help developers build applications for that platform. For developing .Net Application, you need to install the .NET SDK which contains the .Net CLI (Command Line Interface), Runtimes etc . Withe the .Net CLI , you can create new applications based on templates , restore packages , build , test the application and create deployment packages.If you use Visual Studio , .Net SDK is installed as part of it’s dependencies.

SDK = Runtime + developer tools to build, test, and run applications + templates

• It includes compilers, build tools, debuggers, and libraries.

• Lets you write, compile, and run code.

• Use case : Developer machine

• Examples : .NET SDK, JDK, Android SDK

🧠 Think of it like:

“I have everything I need to create and run the movie.”

You can install multiple versions of .Net Sdk

> dotnet --list-sdks :  shows different versions of .Net SDK installed on your system.

> dotnet --version : To view the current version

By default , the latest version is used.

2 .Net Runtime

A Runtime is the minimum environment needed to run an application built with a specific framework.

• It executes precompiled apps

• It does not include tools to create or build apps

• Use Case : End-user or production servers

• Example: .NET Runtime, Java Runtime Environment (JRE), Node.js Runtime.

🧠 Think of it like:

“I can watch the movie, but I can't make or edit it.”

> dotnet --list-runtimes : To view which runtime is installed on the system

3 .Net CLR

The Common Language Runtime (CLR) is the engine or brain of the .NET framework that actually runs your .NET code. The C# Compiler compiles your code into MSIL - Microsoft Intermediate Language . This code is more low level like an assemble code with more OOP features. The MSIL code is later compiled to native code by the CLR

Nuget Packages

A NuGet package is like a ready-made box of code that you can plug into your .NET project to save time. They help you add features to your app without writing it all yourself. They are available on Nuget Server at https://www.nuget.com

🧠 Think of it like:

You're building a LEGO house, and instead of building every piece from scratch, you buy a pre-made door, window, or roof and snap it into your project. That’s what NuGet packages do — they give you reusable building blocks of functionality

A .nupkg (NuGet package) file typically contains:

• Compiled DLLs (libraries)

• Metadata (like version, author, description)

• Optional dependencies (other packages it needs)

Adding & Removing Nuget Package in your Project

> dotnet add package <Package-Name> # Adding package to your project 
> dotnet remove package <PackageName>  # Remove package
Examples : 
> dotnet remove package Newtonsoft.Json

Updating Packages

The .NET CLI doesn't have a direct dotnet update package command. Instead, Re-add the package with a newer version

dotnet add package <PackageName> --version <Version>
Example : 
> dotnet add package Newtonsoft.Json --version 13.0.2

NuGet Package Source

A NuGet Package Source is a location where your .NET project looks for NuGet packages — either to install, restore, or update them. Think of it as a feed (like a repository or URL) that contains packages.

> dotnet nuget add source <SourceURL> --name <SourceName> # Adding a package source

Example : 
> dotnet nuget add source <https://api.nuget.org/v3/index.json> --name NuGetOrg

Optional: Add credentials (e.g., for private feeds)

> dotnet nuget add source <SourceURL> --name <Name> --username <User> --password <Pass> --store-password-in-clear-text

Other Nuget Sources Command

> dotnet nuget list source # List Package Sources

> dotnet nuget remove source <SourceName> # Remove a Package Source
Example : 
> dotnet nuget remove source NuGetOrg

🏗️ Common Types of NuGet Package Sources

1. Official NuGet Source (default):

   • URL: https://api.nuget.org/v3/index.json

   • Contains public packages like Newtonsoft.Json, Serilog, etc.

2. Private/Internal Feeds:

   • Hosted on Azure Artifacts, GitHub Packages, or internal servers.

   • Used to share company-specific or proprietary packages.

3. Local Feeds:

   • A folder on your machine (e.g., C:\\packages) that contains .nupkg files.

   • Useful for testing or offline development.

📁 Where Sources Are Stored

NuGet sources are usually listed in a config file:

• User-wide config: ~/.nuget/NuGet/NuGet.Config (Linux/macOS) or %appdata%\\NuGet\\NuGet.Config (Windows)

• Project-specific config: NuGet.Config in your repo/project root

⚙️ Example of NuGet.Config

<configuration>
  <packageSources>
    <add key="nuget.org" value="<https://api.nuget.org/v3/index.json>" />
    <add key="MyPrivateFeed" value="<https://myserver.com/nuget>" />
    <add key="Local" value="C:\\MyPackages" />
  </packageSources>
</configuration>

C# Language

It’s a Programming language used to write code that runs on the .NET platform and Unity framework . It designed by Microsoft, led by Anders Hejlsberg. C# has the following core features which makes highly suitable for modern enterprise application development.

Features:

• Fully object-oriented with support for encapsulation, inheritance, and polymorphism

• Type Safety : Strongly typed, Static typing & Generic types for type-safe collections and algorithms

• Modern language features like LINQ, async/await, pattern matching, etc.

• Memory Management : Automatic garbage collection. No direct pointer manipulation (except in unsafe context)

• LINQ (Language Integrated Query) for data manipulation

• Async/await pattern for asynchronous programming

• Cross-platform via .NET Core/.NET 5+ (Windows, macOS, Linux)

• Compatible with Microsoft ecosystem (Azure, Windows, etc.)

• Native support for web, desktop, mobile, and cloud applications

• Comprehensive standard library

Usage :

C# can be used to write or build the following applications:

1. Web Applications ( MVC, Razor & Blazor )

2. Web APIs ( Asp.Net Web API )

3. Desktop Applications ( Win Form , WPF, UWP, Win UI, MAUI )

4. Mobile Applications ( MAUI ) - Cross - Platform

5. Games ( Unity ) : used in buidling 2D, 3D , Augmented Reality , Virtual Reality Applications.

.Net Framework

It’s a framework or platform for building enterprise applications. It was introduced in 2000, built for windows operating system only. Provides a runtime environment and libraries to build and run applications (web, desktop, mobile, cloud, etc.) It Supports multiple languages including C#, F#, VB.NET, etc. Nowadays C# has become the go to language for .Net development.

.Net Core Framework

.NET Core is a cross-platform, open-source framework developed by Microsoft for building modern applications. It was introduced to overcome the limitations of the original .NET Framework, especially its Windows-only nature. It was released in 2016 which support most of the old features in .net with better improvement in performance and tooling.

Unified .Net Framework

The term "Unified .NET Framework" generally refers to the .NET 5+ platform, which consolidates the previously separate .NET technologies into a single, unified platform for building all types of applications. It started with .Net 5 launched in 2020 , “Core” was removed . No more Old windows only .Net and Cross platform .Net Core , now we have .Net as a unified framework .

Going forward , you can hear .Net 5, 6, 7, 8 , 9 , 10 et.c . With a single BCL ( Base Class Library) and a single SDK ( Software Development Kit) , you can now build

• Web apps

• APIs

• Desktop apps (WinForms, WPF)

• Mobile apps (via MAUI)

• Cloud apps

• Games (via Unity)

• IoT apps

.Net Version Support Length

When you’re working in the new era of .Net, you should know about versions and different support cycles. .Net releases differ based on Current or Long Term Support (LTS)

• LTS : are versions supported at least 3 years or 1 year after the next LTS version is released. (recommended for production apps)

• Standard/ Short Term Support : Supported for 18 months (good for early access to new features)

• .Net 1, .Net 1.1 , .Net 2.1 , .Net 3.1 , .Net 6 , .Net 8 & .Net 10 ( to be released Nov, 2025) : Are all LTS Support Level

• .Net 2.0 , .Net 2.2 , .Net 3, .Net 5 & .Net 7 : STS

Microsoft follows a yearly release schedule for .NET:

• Even-numbered years (e.g., .NET 6, .NET 8) → LTS

• Odd-numbered years (e.g., .NET 5, .NET 7, .NET 9) → STS

Application Types

As a developer , the major reason you learn programming is to solve some problems and build applications. The following are various application types you can build with C# and .Net .

🔹 1. Console Application

✅ What It Is: A text-based application that runs in a terminal or command prompt window — no graphical interface.

✅ Use Cases:

• Utility tools

• Data migration scripts

• Test programs

• Background processes

✅ Create With CLI:

> dotnet new console -n MyConsoleApp

✅ Example Code:

Console.WriteLine("Hello, world!");

🌐 2. Web Application

✅ What It Is:

An application that runs in a web browser. Built using ASP.NET Core, often with Razor Pages, MVC, or Blazor for a single page application. Blazor is the .net equivalent of popular SPA like React, Angular & Vue.js.

✅ Use Cases:

• E-commerce websites

• Dashboards

• Admin panels

• Web-based CRMs

✅ Frameworks:

• ASP.NET Core MVC

• Blazor Server / Blazor WebAssembly

• Razor Pages

✅ Create With CLI:

> dotnet new mvc -n MyWebApp

🔗 3. Web Services / API

✅ What It Is:

Backend services (usually RESTful APIs) that expose endpoints which can be consumed by web apps, mobile apps, IoT devices, etc.

✅ Use Cases:

• Backend for mobile apps

• Microservices

• Public/Private APIs

✅ Framework:

• ASP.NET Core Web API

✅ Create With CLI:

> dotnet new webapi -n MyApi

🖥️ 4. Desktop Application

✅ What It Is:

Apps that run on Windows (sometimes cross-platform) desktop computers. Built with GUI frameworks like WPF, WinForms, or MAUI.

✅ Use Cases:

• Accounting software

• Point-of-sale (POS) systems

• Rich client applications

✅ Technologies:

• WinForms (oldest)

• WPF (modern, XAML-based)

• .NET MAUI (for cross-platform desktop + mobile)

✅ Create WPF Project:

> dotnet new wpf -n MyDesktopApp

📱 5. Mobile Application

✅ What It Is:

Apps that run on Android and iOS, built using .NET MAUI or formerly Xamarin.

✅ Use Cases:

• Business mobile apps

• Social network apps

• Hybrid cross-platform tools

• Consumer apps (To-do, Finance, etc.)

✅ Framework:

• .NET MAUI (recommended)

• Xamarin (older, being phased out)

✅ Create With CLI:

> dotnet new maui -n MyMobileApp

📚 6. Class Library

✅ What It Is:

A reusable collection of code (DLL) that can be shared across multiple projects.

✅ Use Cases:

• Shared business logic

• Utility/helper functions

• Domain models

• Custom libraries (NuGet packages)

✅ Create With CLI:

> dotnet new classlib -n MyLibrary

🛠️ 7. Dev Tools

✅ What It Is:

Tools or apps built to assist developers, often running as CLI apps, analyzers, generators, or even IDE extensions.

✅ Use Cases:

• Code generators

• Linting tools

• Project scaffolding

• CLI-based workflows

✅ Can be built with:

• Console apps

• Roslyn analyzers

• Custom CLI commands (System.CommandLine, Spectre.Console)