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:

1
 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

2
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:

3
 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");

4
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

5
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.

6
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 {

7
 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 .

8
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.

9
 • 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-

10
 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/

11
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

12