# Skill 01 - .NET Platform and Tooling

## Core Concepts

- Modern .NET is the cross-platform line that evolved from .NET Core.
- Legacy .NET includes .NET Framework, older Mono/Xamarin-era models, and older .NET Standard-centered libraries.
- The .NET SDK includes compilers, templates, build tools, and the runtime.
- The runtime alone is enough to run framework-dependent apps, but not enough to build them.
- Use the `dotnet` CLI as the source of truth. IDEs are views over project files and command-line tools.

## Project Rules

- Inspect `TargetFramework`, `LangVersion`, `Nullable`, `ImplicitUsings`, and package references before changing code.
- Prefer SDK-style project files.
- Use `global.json` when a repo must pin or roll forward SDK versions predictably.
- Use `Directory.Build.props` for shared build settings.
- Use `Directory.Packages.props` for central package management in multi-project solutions.
- Keep app code, class libraries, test projects, and infrastructure scripts separated.

## CLI Commands

```bash
dotnet --info
dotnet new list
dotnet new sln
dotnet new console -n App
dotnet new classlib -n Domain
dotnet new xunit -n Domain.Tests
dotnet sln add src/Domain/Domain.csproj
dotnet add src/App/App.csproj reference src/Domain/Domain.csproj
dotnet restore
dotnet build
dotnet test
dotnet format
```

## Tooling Best Practices

- Use Visual Studio, VS Code with C# Dev Kit, or Rider according to team preference.
- Keep generated `bin` and `obj` folders out of source control.
- Prefer reproducible builds over IDE-only configuration.
- Test on the same operating system family used in production when filesystem, paths, permissions, or casing matter.
- Keep SDKs patched. Runtime and SDK patch updates often contain security and reliability fixes.