C# Programming: Fundamentals to Advanced

C# is a modern, open-source, cross-platform object-oriented language

developed by Microsoft[1]. It combines strong static typing with high-level
features (LINQ, async/await, generics, etc.) and is widely used for desktop,
web, game, and mobile apps. This guide covers C# syntax, paradigms,
frameworks, and practices, with code examples and references to official
Microsoft documentation and trusted resources.

Fundamental Syntax and Concepts

Variables and Data Types
C# is statically typed: every variable has a type known at compile time. It
includes built-in value types (numeric types like int, double, bool; structs;
enums) and reference types (object, string, arrays, class instances)[2][3].
For example:

int count = 10; // 32-bit integer (System.Int32)

double price = 9.99; // double-precision floating point
bool isDone = false; // boolean
string name = "C#"; // reference type (System.String)

C# also has decimal (high-precision decimal), char, byte, and aliases (short
for Int16, long for Int64, etc.)[2]. All types ultimately derive from object, and
string is a reference type despite syntax similarities to a value type.

Variables and Expressions

Variables store data and can be used repeatedly. You can read/write to
variables by name. Literals like numbers or strings assign values. For
example, a classic "Hello World" uses the Console class’s WriteLine method
to print to the console[4]:

Console.WriteLine("Hello, World!"); // prints a message to the

console

Here, Console is a type representing the console window, and WriteLine is a

method that prints text[5]. C# also supports expressions (arithmetic, logical,
and string operations) just like other languages.

Control Structures
C# provides standard flow-control statements. Conditional statements ( if,
else, switch) choose which code to run: “The if, if-else, and switch
statements select statements to execute based on the value of an
expression”[6]. For example:
if (count > 0) {
Console.WriteLine("Positive");
} else {
Console.WriteLine("Non-positive");
}

switch (choice) {
case 1: DoOption1(); break;
case 2: DoOption2(); break;
default: Console.WriteLine("Invalid"); break;
}

Loops allow repeated execution. C# includes for, foreach, while, and do-
while loops. These “repeatedly execute a statement or block of statements”
until a condition fails[7]. For example:
// for loop (with implicit-typed loop variable)
for (var i = 0; i < 5; i++) {
Console.WriteLine(i);
}
// foreach over a collection
foreach (var name in names) {
Console.WriteLine(name);
}
// while loop
int x = 0;
while (x < 5) { Console.WriteLine(x); x++; }

The for loop initializes and updates a counter; foreach iterates over each
element of a collection[7]; while/do-while repeat based on a boolean
condition.

Object-Oriented Programming (OOP)

C# is deeply object-oriented. Classes define new types with fields (data)
and methods (behavior). Example:
public class Person {
public string Name { get; set; }
public void Greet() {
Console.WriteLine($"Hello, {Name}!");
}
}

You instantiate with new Person { Name = "Alice" }. C# uses single

inheritance: a class can inherit from one base class. Inheritance lets a
derived class reuse/extend its parent. “Inheritance is one of the fundamental
attributes of object-oriented programming. It allows you to define a child
class that reuses (inherits), extends, or modifies the behavior of a parent
class[8].” For example:
public class Animal { public void Eat() { /*...*/ } }
public class Dog : Animal { public void Bark() { /*...*/ } } // Dog
inherits Eat()

Interfaces specify contracts of methods/properties without implementation.

A class implements an interface’s members. C# uses interface IExample
{ ... }. “An interface contains definitions for a group of related
functionalities that a class or struct must implement[9].” Interfaces allow
multiple behavioral inheritance: “include behavior from multiple sources in a
class… important because C# doesn’t support multiple class
inheritance[10].” For instance:
public interface IMovable { void Move(); }
public class Car : IMovable {
public void Move() { Console.WriteLine("Driving"); }
}

Error Handling (Exceptions)

C# uses try, catch, and finally for exceptions. You wrap risky code in try;
use catch to handle exceptions; finally runs cleanup code regardless of
success. “A try block is used to wrap code that might be affected by an
exception. Associated catch blocks handle any resulting exceptions. A finally
block runs code whether or not an exception is thrown[11].” Example:
try {
int result = 10 / divisor;
Console.WriteLine(result);
}
catch (DivideByZeroException ex) {
Console.WriteLine("Cannot divide by zero.");
}
finally {
Console.WriteLine("Cleanup");
}

Always catch specific exceptions (not Exception directly) unless rethrowing,

to avoid hiding errors.

LINQ (Language-Integrated Query)

LINQ provides SQL-like query syntax over collections (in memory data,
databases, XML, etc.) with strong typing. “LINQ (Language-Integrated Query)
is the name for a set of technologies based on the integration of query
capabilities directly into C#[12].” It lets you use from/where/select queries
or fluent methods. Example querying an integer array:
int[] scores = { 97, 92, 81, 60 };
var highScores =
from score in scores
where score > 80
orderby score descending
select score;
foreach (var s in highScores) Console.WriteLine(s);

This prints 97, 92, 81. LINQ queries and lambdas improve readability when
filtering, ordering, or projecting data[12][13].

Asynchronous Programming (async/await)

C#’s async/await keywords simplify asynchronous programming by using
tasks (Task, Task<T>) without blocking threads. The Task-based
Asynchronous Pattern (TAP) “provides a layer of abstraction… to enable code
that reads like a sequence of statements, but executes in a more
complicated order”[14]. For example:
public async Task<string> FetchDataAsync(string url) {
using HttpClient client = new HttpClient();
string response = await client.GetStringAsync(url); //
asynchronous I/O
return response;
}

The await ensures the method asynchronously waits for GetStringAsync to

complete without blocking the calling thread (e.g., a UI thread). The
compiled code returns a Task<string>, and the runtime resumes the method
when the data arrives. This async/await pattern prevents UI freezes in
desktop/mobile apps and scales I/O-bound servers.

Advanced Topics
Generics
Generics let you define classes, methods, or interfaces with placeholder
types, enabling reuse and type safety. For example, List<T> is a generic list.
Generics “let you tailor a method, class, structure, or interface to the precise
data type it acts upon… Benefits include increased code reusability and type
safety[15].” Instead of using non-generic collections that box values, e.g.
ArrayList, use List<int>. Example:

List<string> names = new List<string>();

names.Add("Alice");
names.Add("Bob");

The compiler checks that only strings go into names. Similarly, you can write a
generic method:
public T Max<T>(T a, T b) where T : IComparable<T> {
return a.CompareTo(b) > 0 ? a : b;
}

This works for any comparable type.

Delegates and Events

A delegate is a type-safe function pointer. It “represents references to
methods with a particular parameter list and return type”[16]. You declare a
delegate type and then assign methods to delegate instances. Delegates
enable callbacks and are foundational for events. For instance:
public delegate int Compute(int x, int y);
public static int Add(int x, int y) => x + y;
Compute op = Add;
int result = op(2, 3); // invokes Add, result = 5

Delegates can also be combined (multicast) to call multiple methods. Events

use delegates under the hood to allow publishers to notify subscribers. An
event is declared in a class (the publisher) and other classes (subscribers)
register handlers. “Events enable a class or object to notify other classes or
objects when something of interest occurs[17].” In a UI, for example, a
Button raises a Click event when clicked, and your code handles it. You
declare public event EventHandler MyEvent; and use
MyEvent?.Invoke(this, args).

Reflection
Reflection lets C# code examine types, members, and assemblies at
runtime. Using classes in System.Reflection, you can inspect loaded
assemblies, find types/methods, and even create instances or invoke
methods dynamically[18]. For example, Type t = typeof(MyClass);
MethodInfo m = t.GetMethod("MyMethod"); m.Invoke(obj, null);. This is
used in serialization, dependency injection, or building IDE tools. The
reflection API provides Type, MethodInfo, FieldInfo, PropertyInfo, etc., to
explore metadata and call code without compile-time references[18].

Memory Management
C# runs on the .NET runtime, which uses a managed heap and automatic
garbage collection (GC). Developers do not manually free memory; the GC
reclaims objects that are no longer referenced. The GC is generational:
objects live in generation 0, 1, or 2, optimizing for short-lived objects. Newly
created objects start in Gen 0; if they survive a collection, they move to
higher generations[19]. “By default, .NET’s garbage collector uses a
generational approach with three generations (0, 1, 2) to optimize
performance, collecting short-lived objects frequently in gen 0 and
promoting survivors to gen 1 and 2[19].” Key guidelines: avoid forcing
frequent collections (avoid excess allocations in loops), dispose unmanaged
resources (IDisposable) with using or finalizers, and avoid unnecessary
finalizers (an empty finalizer hurts performance[20]). Profiling tools (Visual
Studio Diagnostic Tools or PerfView) help detect memory leaks and large
allocations.

Threading and Concurrency

C# provides threading via System.Threading (e.g. Thread, ThreadPool) and
the Task Parallel Library (TPL) for higher-level concurrency. “Starting
with .NET 4, the recommended way to utilize multithreading is to use Task
Parallel Library (TPL) and Parallel LINQ (PLINQ)[21].” You can start tasks with
Task.Run or use Parallel.ForEach/PLINQ for data parallelism. Example:

Parallel.For(0, items.Length, i => Process(items[i]));

Multiple threads improve responsiveness or throughput on multi-core

systems[22]. Use threads to keep a UI responsive (do background work), or
use async/await which frees threads for I/O. Synchronization primitives ( lock,
Mutex, SemaphoreSlim, etc.) guard shared data. The thread pool ( ThreadPool)
manages reusable threads automatically. In practice, use async/await and
TPL for most cases; direct Thread usage is less common. Always handle
exceptions in threads (unhandled exceptions on worker threads can crash
the process).

Performance Optimization
Writing high-performance C# means understanding common costs and using
appropriate constructs. According to Microsoft’s .NET performance tips[23]
[24]: - Avoid boxing/unboxing: Operations that convert value types (e.g.
int) to object are slow. Prefer generic collections (List<T>) over non-generic
(ArrayList) to avoid boxing[23].
- String handling: Repeated string concatenation in loops is expensive
(strings are immutable). Use StringBuilder for large or many
concatenations[24].
- Finalizers: Avoid empty or unnecessary finalizers. They add overhead to
garbage collection[20].
- LINQ vs loops: LINQ is convenient and often optimized, but very tight
loops might benefit from manual loops. Profile before micro-optimizing.
- Data structures: Use appropriate collections (e.g.
Dictionary<TKey,TValue> for lookups) to reduce algorithmic cost.
- Async and parallel: Use asynchronous APIs for I/O-bound tasks (non-
blocking) and Parallel/Task for CPU-bound tasks to leverage multiple
cores[21].
- Profiling: Always measure (Visual Studio Profiler, dotnet-counters,
BenchmarkDotNet) before optimizing. The specific tip page also emphasizes
understanding the costs (e.g. “Boxing and unboxing can be up to 20x
slower”[23]) and provides in-depth advice.
C# Application Domains
C# is versatile and used in many areas. Below are major domains and how
C# is applied.

Desktop Applications (Windows Forms, WPF)

C# can build rich Windows desktop apps. Windows Forms is a mature GUI
framework; WPF (Windows Presentation Foundation) is a newer XAML-
based UI framework for vector graphics and data binding. Both are open-
source on .NET[25][26].
- Windows Forms uses event-driven controls (buttons, textboxes) with drag-
drop designers in Visual Studio[25]. Code-behind files (in C#) handle events.
- WPF uses XAML for UI definitions with powerful data binding and styles[26].
It supports MVVM (Model-View-ViewModel) patterns, allowing separation of
logic and UI. (Official docs: WPF overview).
For example, a simple WPF button handler:
<Button Name="btnClick" Click="btnClick_Click">Click me</Button>

private void btnClick_Click(object sender, RoutedEventArgs e) {

MessageBox.Show("Button clicked!");
}

Both use the .NET runtime and base class libraries. Development is usually
done in Visual Studio or Visual Studio Code. Resources: the Windows Forms
and WPF docs provide tutorials and guides.

Web Development (ASP.NET Core, Blazor)

C# powers server-side and client-side web apps via ASP.NET. ASP.NET Core
is a cross-platform, high-performance, open-source framework for web and
APIs[27]. It supports MVC (Model-View-Controller), Razor Pages, Blazor, Web
APIs, and real-time (SignalR). Key features include a modular HTTP pipeline,
built-in dependency injection, and tooling. For example, a minimal API in
ASP.NET Core (available from .NET 6 onward) can be as simple as:
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Hello World!");

app.Run();

This hosts a web server and handles HTTP GET on “/”. ASP.NET Core apps are
typically built in Visual Studio or via the dotnet CLI.
Blazor allows writing client-side web apps in C#. Blazor WebAssembly runs
C# in the browser using WebAssembly[28]. In Blazor, you create reusable
components in .razor files. For example:
<button @onclick="OnClick">Click me</button>
<p>@message</p>

@code {
string message = "";
void OnClick() {
message = "You clicked!";
}
}

This code runs in-browser without JavaScript. Blazor Server is another model
where C# runs on the server and updates the client via SignalR. Blazor “lets
you write client-side logic and UI components in C#, compile them into .NET
assemblies, and run them directly in the browser using WebAssembly[28].”
It’s ideal for code reuse between server and client.

Game Development with Unity

C# is the primary scripting language for the Unity game engine (2D/3D
games, VR/AR). Unity uses a component-based architecture: all game
objects in Unity have scripts (C# classes) attached as components[29]. For
example, a script derives from MonoBehaviour and defines behavior:
public class PlayerController : MonoBehaviour {
void Update() {
if (Input.GetKeyDown(KeyCode.Space)) {
Jump();
}
}
void Jump() { /*...*/ }
}

Unity’s API (transform, physics, animation, etc.) is accessed via C#. The
official Unity scripting docs (Unity Manual and Scripting API) provide details.
Many Unity tutorials emphasize C# basics and Unity-specific patterns. The
image below illustrates Unity’s core concepts:
In Unity, every GameObject can have multiple Components attached
(including C# script components). Scripts (classes derived from
MonoBehaviour) implement game logic[29].

Unity also supports modern C# features (LINQ, async jobs, etc.) and has
introduced the DOTS (Data-Oriented Tech Stack) for high-performance
multithreading with C#. Unity’s website and Scripting in Unity guide are
authoritative resources.

Mobile Apps (Xamarin, .NET MAUI)

C# and .NET can build cross-platform mobile apps for Android and iOS.
Xamarin.Forms was the earlier framework for UI sharing on mobile; now
.NET Multi-platform App UI (MAUI) is the evolution. .NET MAUI is “a
cross-platform framework for creating native mobile and desktop apps with
C# and XAML”[30]. It lets you write one shared UI and codebase for Android,
iOS, macOS, and Windows[31]. The architecture:
.NET MAUI lets you write C# and XAML code in one project targeting multiple
platforms[30].
In MAUI, UI is defined in XAML (similar to WPF) or C#, and you can call native
APIs when needed. The MAUI docs and tutorials show how to create pages,
layouts, and handle device-specific features (camera, GPS, etc.).
Xamarin.Forms (now superseded) had a similar model. Both compile C# to
native ARM code (AOT) or JIT on mobile. See Microsoft’s MAUI overview and
Xamarin migration guides.

Best Practices: Clean Code, Testing, Debugging

 Clean Code: Follow consistent naming and style conventions.
Microsoft’s guidelines recommend PascalCase for types/methods,
meaningful names, and file organization[32]. Use var only when
obvious. Prefer C# keywords (int, string) over CLR type names
(System.Int32) for clarity[33]. Avoid overly complex logic; write simple,
readable code[34]. Tools like EditorConfig, Roslyn analyzers, and
StyleCop help enforce conventions. Regular code reviews and linters
maintain quality.
 SOLID Principles: Design code with single-responsibility classes,
clear abstractions, dependency injection, etc. Follow Framework
Design Guidelines for library design.
 Error Handling: Only catch exceptions you can handle meaningfully;
avoid empty or broad catch (Exception). Provide meaningful error
messages or fallbacks. Use using or try/finally to ensure disposal of
resources.
 Testing: .NET has mature unit testing frameworks: MSTest, NUnit, and
xUnit. Use test projects (e.g., dotnet new xunit) and write tests
covering logic. Visual Studio’s Test Explorer runs tests from these
frameworks (and even shows live results in Enterprise edition)[35]. For
example, an xUnit test:

[Fact]
public void Sum_AddsCorrectly() {
Assert.Equal(5, Math.Add(2, 3));
}

Automate tests in CI. For web apps, write integration and API tests. Use
mocking frameworks (Moq) for isolating dependencies.
 Debugging: Use Visual Studio or VS Code debuggers: set breakpoints,
inspect variables, step through code. For ASP.NET, attach to IIS or use
 dotnet watch with hot-reload. For Unity or MAUI, use platform
debuggers. Logging is vital: use ILogger (Microsoft.Extensions.Logging)
to output diagnostics, or IDE diagnostic tools and Performance Profiler
(Visual Studio’s Performance Profiler, dotnet trace, etc.) to find
bottlenecks.
 Performance Profiling: Use tools like BenchmarkDotNet for
microbenchmarks, Visual Studio Profiler or JetBrains dotTrace for
CPU/memory profiling. The official .NET performance tips discuss
common pitfalls (boxing, string usage, etc.)[23][24].

Common Libraries and Frameworks

Beyond the base class library, many libraries enrich C# development:
 Entity Framework Core: A popular open-source ORM for database
access[36]. It maps C# classes to database tables, so you can query
with LINQ instead of SQL. It supports migrations, change tracking, and
many providers (SQL Server, SQLite, PostgreSQL, etc.). Official docs: EF
Core overview[36].
 JSON Libraries: For JSON serialization, use the built-in
System.Text.Json (fast, modern) or the widely-used Newtonsoft.Json
(Json.NET). Both support converting objects to/from JSON.
 Dependency Injection: .NET’s built-in DI container (in
Microsoft.Extensions.DependencyInjection) is used across ASP.NET
Core and MAUI for managing services.
 Logging: Microsoft.Extensions.Logging interfaces with providers
(Console, Debug, Serilog, NLog). Use it to instrument apps.
 UI Frameworks: As above, WinForms, WPF, ASP.NET Core, Blazor,
MAUI, UnityEngine – these are the frameworks for UI and specialized
domains.
 Data/Cloud: Azure SDKs (Azure.Storage, Azure.Identity, etc.),
Microsoft.AspNetCore.Identity for auth, Grpc.Net.Client, Dapper
(micro ORM), HttpClient, etc.
 Testing: xUnit, NUnit, MSTest for tests; FluentAssertions for readable
assertions.
 Tools: NuGet for packages, Visual Studio (or VS Code) for IDE, Rider
(JetBrains), ReSharper.

Project Ideas by Skill Level

 Beginner: Start simple console or Windows apps to practice basics:
e.g., a calculator, number-guessing game, or to-do list console app.
Build a “Hello World” with methods. Create a basic WPF or WinForms
app (e.g., a “Hello User” form). Use simple data structures and LINQ.
 Intermediate: Tackle GUI or small web/API projects: e.g., a contact
manager with a WinForms or WPF front-end and local file or SQLite
 storage; a notes app or personal budget tracker. Build a small ASP.NET
Core MVC app (e.g., blog or shopping cart) with Entity Framework Core
for data. Create a RESTful Web API that returns JSON. Use async/await
for file I/O or web requests (e.g., fetch data from a public API). Try a
Unity 2D game tutorial (platformer or puzzle game) to get familiar with
MonoBehaviour scripting.
 Advanced: Develop larger applications: e.g., a full-feature e-
commerce site (covering products, cart, payment integration) using
ASP.NET Core and possibly Blazor for UI. Write a multiplayer networked
game in Unity with server logic. Build a cross-platform mobile app with
Xamarin/MAUI (e.g., a chat client). Work with multithreading or
parallelism (e.g., image processing or matrix math in parallel).
Contribute to open-source C# projects or use advanced features like
reflection or expression trees.
 Exercises: Solve problems on C# coding challenge sites. For each
project, write unit tests.
(Some example project ideas: Simple ATM simulator, movie library app, e-
commerce website, voting system, Twitter bot, note-taking app, Unity driving
game, search engine app, eBook reader, etc.) For inspiration, see community
lists[37][38][39].

Learning Resources
 Official Documentation: Microsoft’s docs are comprehensive. The C#
Guide on docs.microsoft.com covers fundamentals, language
reference, and examples. ASP.NET, WPF, and other frameworks have
dedicated Microsoft Learn docs (e.g., Learn C# portal, ASP.NET Core
overview[27]).
 Tutorials/Courses: Microsoft Learn has interactive C# paths and
modules (free)[40]. The C# Fundamentals for Absolute Beginners video
series (Channel 9/Microsoft) is great for new coders[41]. Community
channels (e.g., .NET YouTube, freeCodeCamp, Pluralsight, Udemy) offer
in-depth courses. For practice, platforms like Exercism and CodeWars
provide challenges to hone skills.
 Books: Recommended titles include “C# in Depth” by Jon Skeet
(advanced C#), “Pro C# 9.0” by Troelsen/Fjord (comprehensive),
“CLR via C#” by Richter (deep internals), “Head First C#” (beginner-
friendly), and “The C# Player’s Guide” (beginner-to-intermediate).
Rob Miles’s free online Yellow Book is also popular for learners.
 Samples and Community: Explore official samples on GitHub
(dotnet/samples), and .NET community GitHub projects. StackOverflow
and the .NET Discord/Reddit communities can help with questions.
 Tools and IDEs: Visual Studio (Community edition is free) or Visual
Studio Code with the C# extension are standard development
environments. Use built-in docs, IntelliSense, and debugging support.
Overall, start with core C# syntax and simple projects, then gradually
explore libraries and frameworks relevant to your interests (desktop, web,
games, mobile). Emphasize writing clean, tested code and learning by doing.
With practice and the wealth of Microsoft’s official tutorials and trusted
community resources, you’ll progress from basics to advanced C#
development.

[1] C# - a modern, open-source programming language | .NET

https://dotnet.microsoft.com/en-us/languages/csharp
[2] [3] Built-in types - C# reference | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-
types/built-in-types
[4] [5] Hello World - Introductory interactive tutorial - A tour of C# | Microsoft
Learn
https://learn.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/tutorials/
hello-world
[6] if and switch statements - select a code path to execute - C# reference |
Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/
statements/selection-statements
[7] Iteration statements -for, foreach, do, and while - C# reference |
Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/
statements/iteration-statements
[8] Tutorial: Introduction to Inheritance - C# | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/tutorials/
inheritance
[9] [10] Interfaces - define behavior for multiple types - C# | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/types/
interfaces
[11] Exception Handling - C# | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/exceptions/
exception-handling
[12] [13] Language Integrated Query (LINQ) - C# | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/csharp/linq/
[14] Asynchronous programming - C# | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/
[15] Generics in .NET - .NET | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/standard/generics/
[16] Work with delegate types in C# - C# | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/
delegates/
[17] Events - C# | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/events/
[18] Reflection in .NET | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/fundamentals/reflection/reflection
[19] Fundamentals of garbage collection - .NET | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/
fundamentals
[20] [23] [24] .NET Performance Tips - .NET Framework | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/framework/performance/
performance-tips
[21] [22] Threads and threading - .NET | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/standard/threading/threads-and-
threading
[25] Windows Forms for .NET documentation | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/desktop/winforms/
[26] Windows Presentation Foundation for .NET documentation | Microsoft
Learn
https://learn.microsoft.com/en-us/dotnet/desktop/wpf/
[27] Overview of ASP.NET Core | Microsoft Learn
https://learn.microsoft.com/en-us/aspnet/core/overview?view=aspnetcore-
9.0
[28] Blazor for ASP.NET Web Forms Developers - .NET | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/architecture/blazor-for-web-forms-
developers/
[29] Scripting in Unity for experienced C# & C++ programmers
https://unity.com/how-to/programming-unity
[30] [31] What is .NET MAUI? - .NET MAUI | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/maui/what-is-maui?view=net-maui-
9.0
[32] [33] [34] .NET Coding Conventions - C# | Microsoft Learn
https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/
coding-conventions
[35] Get started with unit testing - Visual Studio (Windows) | Microsoft Learn
https://learn.microsoft.com/en-us/visualstudio/test/getting-started-with-unit-
testing?view=vs-2022
[36] Overview of Entity Framework Core - EF Core | Microsoft Learn
https://learn.microsoft.com/en-us/ef/core/
[37] [38] [39] 20+ C# Project Ideas to Sharpen Up Your Skills - Udemy Blog
https://blog.udemy.com/c-sharp-projects/
[40] [41] Recommended learning resources for C# and .NET in 2025.
https://newsletter.techworld-with-milan.com/p/recommended-learning-
resources-for