NETCore Study Notes

async/await Fundamentals

How async/await really works under the hood in .NET, the differences between Task, Task<T>, and ValueTask<T>, and how to avoid the classic deadlock trap.

Benchmarking with BenchmarkDotNet

Why naive stopwatch timing misleads you, and how BenchmarkDotNet produces statistically rigorous, allocation-aware performance measurements for .NET code.

CI/CD for .NET Apps

How to build automated build, test, and deployment pipelines for .NET applications using GitHub Actions, the dotnet CLI, and containerized deployments.

Class Libraries and NuGet Packages

Understand how to build reusable .NET class libraries, reference them across projects, and package and publish them as NuGet packages.

Configuration in .NET

How .NET Core layers configuration providers into one IConfiguration and binds settings to strongly typed, validated options.

Console Apps in .NET

Learn how .NET console applications are structured, how they read input and produce output, and how they're built and published as standalone command-line tool…

.csproj and MSBuild Basics

How the .csproj file and the MSBuild engine work together to define, configure, and drive every .NET Core build.

Dependency Injection in .NET

How .NET Core's built-in DI container registers, resolves, and manages the lifetime of application services.

.NET and Docker

Learn how to containerize .NET applications with multi-stage Dockerfiles, choose the right base images, and use the SDK's built-in container publishing.

.NET CLI Basics

How to use the dotnet command-line interface to scaffold, build, test, and publish .NET applications.

.NET Core Interview Questions

A focused review of the .NET Core concepts most commonly probed in technical interviews: the CLR, async/await, and dependency injection.

.NET on Linux and macOS

How the .NET SDK and runtime install, behave, and get deployed across Linux and macOS, and the platform differences that matter for portable code.

.NET Core Quick Reference

A condensed reference covering essential dotnet CLI commands, LINQ/collection quick facts, and configuration patterns for everyday .NET Core development.

.NET Runtime vs SDK

The difference between the .NET Runtime (needed to run apps) and the .NET SDK (needed to build them), and when to install each.

.NET Versioning and LTS Releases

How .NET's release cadence, LTS vs STS support tiers, and target framework monikers work, and how to plan upgrades around them.

dotnet watch and Hot Reload

How dotnet watch automatically rebuilds your app on file changes, and how Hot Reload patches a running process live to speed up the edit-test loop.

Garbage Collection in .NET

How the .NET runtime automatically tracks and reclaims managed memory using a generational, tracing garbage collector, and how to work with it instead of again…

Global and Local Tools

How to install, pin, build, and manage .NET CLI tools, both globally on a machine and locally per repository via a tool manifest.

Logging in .NET

How .NET Core's ILogger abstraction, log levels, structured logging, and scopes work together, and how providers like Serilog plug in.

NuGet Package Management

How .NET Core projects declare, resolve, and centrally manage third-party dependencies through NuGet.

Project and Solution Structure

How .csproj project files and .sln solution files organize .NET code, dependencies, and multi-project applications.

Publishing Single-File Apps

How .NET's single-file publishing bundles an app and its dependencies into one executable, how extraction and trimming work, and what caveats to expect.

Runtime Identifiers and Native AOT

How Runtime Identifiers (RIDs) target specific platforms and how Native AOT compiles .NET apps straight to native code for fast, lightweight startup.

Self-Contained Deployments

Understand the difference between framework-dependent and self-contained .NET deployments, and how to publish, trim, and single-file your apps for target machi…