Rust for C# Programmers: Complete Training Guide

A comprehensive guide to learning Rust for developers with C# experience. This guide covers everything from basic syntax to advanced patterns, focusing on the conceptual shifts and practical differences between the two languages.

Course Overview

The case for Rust — Why Rust matters for C# developers: performance, safety, and correctness
Getting started — Installation, tooling, and your first program
Basic building blocks — Types, variables, control flow
Data structures — Arrays, tuples, structs, collections
Pattern matching and enums — Algebraic data types and exhaustive matching
Ownership and borrowing — Rust's memory management model
Modules and crates — Code organization and dependencies
Error handling — Result-based error propagation
Traits and generics — Rust's type system
Closures and iterators — Functional programming patterns
Concurrency — Fearless concurrency with type-system guarantees, async/await deep dive
Unsafe Rust and FFI — When and how to go beyond safe Rust
Migration patterns — Real-world C# to Rust patterns and incremental adoption
Best practices — Idiomatic Rust for C# developers

Self-Study Guide

This material works both as an instructor-led course and for self-study. If you're working through it on your own, here's how to get the most out of it.

Pacing recommendations:

Chapters	Topic	Suggested Time	Checkpoint
1–4	Setup, types, control flow	1 day	You can write a CLI temperature converter in Rust
5–6	Data structures, enums, pattern matching	1–2 days	You can define an enum with data and `match` exhaustively on it
7	Ownership and borrowing	1–2 days	You can explain why `let s2 = s1` invalidates `s1`
8–9	Modules, error handling	1 day	You can create a multi-file project that propagates errors with `?`
10–12	Traits, generics, closures, iterators	1–2 days	You can translate a LINQ chain to Rust iterators
13	Concurrency and async	1 day	You can write a thread-safe counter with `Arc<Mutex<T>>`
14	Unsafe Rust, FFI, testing	1 day	You can call a Rust function from C# via P/Invoke
15–16	Migration, best practices, tooling	At your own pace	Reference material — consult as you write real code
17	Capstone project	1–2 days	You have a working CLI tool that fetches weather data

How to use the exercises:

Chapters include hands-on exercises in collapsible <details> blocks with solutions
Always try the exercise before expanding the solution. Struggling with the borrow checker is part of learning — the compiler's error messages are your teacher
If you're stuck for more than 15 minutes, expand the solution, study it, then close it and try again from scratch
The Rust Playground lets you run code without a local install

Difficulty indicators:

🟢 Beginner — Direct translation from C# concepts
🟡 Intermediate — Requires understanding ownership or traits
🔴 Advanced — Lifetimes, async internals, or unsafe code

When you hit a wall:

Read the compiler error message carefully — Rust's errors are exceptionally helpful
Re-read the relevant section; concepts like ownership (ch7) often click on the second pass
The Rust standard library docs are excellent — search for any type or method
For deeper async patterns, see the companion Async Rust Training

Part I — Foundations

1. Introduction and Motivation 🟢

2. Getting Started 🟢

3. Built-in Types and Variables 🟢

4. Control Flow 🟢

5. Data Structures and Collections 🟢

6. Enums and Pattern Matching 🟡

7. Ownership and Borrowing 🟡

8. Crates and Modules 🟢

9. Error Handling 🟡

10. Traits and Generics 🟡

11. From and Into Traits 🟡

12. Closures and Iterators 🟡

Part II — Concurrency & Systems

13. Concurrency 🔴

14. Unsafe Rust, FFI, and Testing 🟡

Part III — Migration & Best Practices

15. Migration Patterns and Case Studies 🟡

16. Best Practices and Reference 🟡

Capstone

17. Capstone Project 🟡

Build a CLI Weather Tool — combines structs, traits, error handling, async, modules, serde, and testing into a working application