dotNET

#informatik/code/dotnet

dotNET ist Microsofts plattformübergreifende Entwicklungsplattform für Web-, Desktop-, Mobile-, Cloud- und Spiele-Apps.

Mentales Modell: das Microsoft-Pendant zu Java / Jakarta EE.

I. Was ist dotNET?

dotNET ist eine Runtime + Bibliotheken + Tools, mit denen du in C#, F# oder VB Anwendungen baust, die auf Windows, Linux und macOS laufen.

┌──────────────────────────────────────────────┐
│  Deine App (C# / F# / VB)                    │
├──────────────────────────────────────────────┤
│  BCL — Base Class Library (System.*, ...)    │
├──────────────────────────────────────────────┤
│  CLR — Common Language Runtime               │
│  ├─ JIT-Compiler (IL → Maschinencode)        │
│  ├─ Garbage Collector                        │
│  └─ Type System                              │
├──────────────────────────────────────────────┤
│  OS (Windows / Linux / macOS)                │
└──────────────────────────────────────────────┘

Java-Vergleich

CLR ≈ JVM, BCL ≈ JDK Standard Library, IL ≈ Bytecode.

II. Editionen — der Versions-Dschungel

Microsoft hat mehrmals umbenannt. Aktuell gilt:

Edition	Plattform	Status
.NET Framework (1.0 – 4.8)	nur Windows	Legacy, nur noch Bugfixes
.NET Core (1.0 – 3.1)	Cross-Platform	Legacy, ersetzt durch .NET 5+
.NET 5 / 6 / 7 / 8 / 9	Cross-Platform	✅ Aktuell
Mono / Xamarin	Mobile (alt)	abgelöst durch MAUI

".NET" ohne Zahl meint heute .NET 5+ (also .NET 8 / 9). Nicht das alte ".NET Framework"!

III. Hauptkomponenten

CLR — Common Language Runtime

Führt deinen Code aus.
JIT-kompiliert IL → Maschinencode.
Garbage Collector managt Speicher (wie JVM).

BCL — Base Class Library

System.*, System.Collections, System.IO, ...
Wie java.lang.* und java.util.* zusammen.

NuGet

Package Manager (wie Maven / Gradle in Java, npm in Node).
dotnet add package <name>.

MSBuild

Build-System (wie Gradle).
.csproj = Projekt-Datei (wie build.gradle).

IV. Sprachen auf dotNET

Sprache	Stil	Use Case
C#	OOP + funktional	Default, 99% aller Projekte
F#	funktional	Data Science, Finance
VB.NET	OOP	Legacy-Code

Alle drei kompilieren zu derselben IL → laufen auf der gleichen CLR.

V. App-Typen

Was du mit dotNET bauen kannst:

                  ┌─────────────────┐
                  │     .NET 8      │
                  └────────┬────────┘
        ┌──────────┬───────┼────────┬──────────┐
        │          │       │        │          │
    ┌───▼───┐  ┌───▼───┐ ┌─▼──┐ ┌───▼───┐  ┌───▼───┐
    │ASP.NET│  │  WPF  │ │MAUI│ │Console│  │ Blazor│
    │  Core │  │WinForm│ │    │ │       │  │       │
    └───────┘  └───────┘ └────┘ └───────┘  └───────┘
       Web      Desktop  Mobile   CLI        Web-UI

ASP.NET Core — Web (siehe ASP.NET Core Web App, ASP.NET Core Web App (MVC), ASP.NET Core Web App (Razor Pages))
WPF / WinForms — Windows Desktop
MAUI — Mobile + Desktop (Cross-Platform)
Blazor — Web-UI in C# statt JavaScript
Console App — CLI-Tools

VI. Mapping zu Jakarta EE

Meine mentale Brücke beim Jakarta-EE-Lernen bei Muckenhirn:

dotNET	Jakarta EE
`AddScoped`	@Stateless
`AddSingleton`	@Singleton
Session State	@Stateful
`[Inject]` / Constructor DI	@EJB / @Inject
`IServiceProvider`	JNDI
`DbContext` (EF Core)	EntityManager (JPA)
`[Table]`, `[Key]`	@Entity, `@Id`
`TransactionScope`	CMT
`appsettings.json`	`standalone.xml`
`dotnet publish` + IIS Restart	`.war` drop = Hot-Deploy
`FrameworkReference`	providedCompile
Castle DynamicProxy	Container-Proxy

VII. Castle DynamicProxy

dotNETs Equivalent zum Container-Proxy — generiert Proxy-Klassen zur Laufzeit. Beispiel: EF Core Lazy-Loading-Proxies.

VIII. Bsp — Hello World

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello, .NET!");
    }
}

Build + Run:

dotnet new console -n HelloApp
cd HelloApp
dotnet run

IX. Verwandte Notizen

C Sharp — die Hauptsprache
ASP.NET — Web-Framework
ASP.NET Core Web App — Web-App-Setup
Entity Framework Core — ORM
Unit Test .Net — Testing
Enterprise Java Bean — das Java-Pendant