Rust for C# Programmers

Class Duration

35 hours of live training delivered over 5-10 days to accommodate your scheduling needs.

Student Prerequisites

• Strong working proficiency in C# and .NET (.NET 10+ familiarity recommended)
• Comfort with dotnet CLI, NuGet, and async/await
• No prior Rust experience required

Target Audience

C# and .NET engineers adding Rust to their toolkit — for performance-critical services, native libraries, CLIs, embedded work, or memory-safe replacements for legacy unmanaged components. Particularly relevant for teams that have hit GC pause limits, run hot paths through Span<T>/Memory<T>, or want a compiled-language story without a runtime.

Training Materials

All students receive comprehensive courseware covering all topics in the course. Courseware is distributed via GitHub in the form of documentation and extensive code samples.

Software Requirements

A free GitHub account, the latest stable Rust toolchain installed via rustup (Rust 1.96+ on the 2024 edition), Visual Studio Code or another supported editor with the rust-analyzer extension, and an AI coding assistant of choice (GitHub Copilot, Cursor, or Claude Code). A cloud-based environment can be provided if local installation is restricted.

Introduction: Rust from a C# Perspective

• What Rust is and where it fits relative to C#/.NET
• Rust 2024 edition: what's new and why it matters
• Rust vs. C#: type system, runtime, packaging, performance
• The Rust ecosystem and community

Toolchain and Editor Setup

• Installing Rust with rustup
• cargo vs. dotnet CLI: similarities and differences
• VS Code, JetBrains RustRover, and Zed with rust-analyzer
• AI assistants for Rust: Copilot, Cursor, and Claude Code
• The Rust Playground for quick experimentation

Cargo and Crates

• cargo new, cargo run, cargo build, cargo test
• Cargo.toml and dependencies vs. csproj and NuGet
• Workspaces and cargo publish --workspace
• Popular crates: serde, tokio, reqwest, sqlx, anyhow, thiserror, tracing

Rust vs. C#: A Working Map

• Memory management: ownership vs. GC
• Errors: Result/Option vs. exceptions
• Sequence, selection, and iteration
• Structs vs. classes and records
• Enums with associated data vs. records and unions
• Traits vs. interfaces (and what neither has)
• Generics: monomorphization vs. .NET generics
• Concurrency: Tokio + async/await vs. Task and TPL

Scalar Types, Control Flow, and Functions

• Integers, floats, booleans, characters
• Constants, statics, and const fn
• if/else as expressions, loop, while, for
• 2024-edition let-chains in if and while
• Functions, closures, and capture modes

Modules and the Standard Library

• Module hierarchy with mod and use
• Importing from the standard library and crates.io
• Visibility and re-exports
• A short tour of the standard library a C# developer will recognize

Built-In Macros

• print!, println!, eprintln!, format!, dbg!
• vec!, assert!, include_str!, include_bytes!
• cfg!, env!, panic!

Memory Management and Ownership

• Ownership, moves, and copies
• Borrowing: &T and &mut T
• Lifetimes and the borrow checker
• Box, Rc, Arc, and when each is appropriate
• Drop and the Drop trait
• Common C# developer pitfalls

Strings, Tuples, Enums, Structs, Collections

• String vs. &str
• Tuples and tuple structs
• Enums with associated data, Option<T>, Result<T, E>
• Structs, methods, associated functions, constructors
• Vec, HashMap, HashSet, BTreeMap/BTreeSet
• Iterators and combinators (map, filter, fold, try_fold)

Pattern Matching

• match and exhaustiveness
• if let, while let, and 2024 let-chains
• Destructuring nested data
• Guards, bindings, and @ patterns

Traits and Generics

• Defining and implementing traits
• Default methods, supertraits, and trait objects (dyn Trait)
• Generics, bounds, and where clauses
• Static dispatch (monomorphization) vs. dynamic dispatch
• Async fn in traits

Async/Await with Tokio

• The async/await mental model from a C# Task perspective
• Tokio runtime fundamentals
• 2024-edition async closures
• tokio::select!, JoinSet, structured cancellation
• HTTP with reqwest, JSON with serde, databases with sqlx

Concurrent Programming

• Threads vs. async tasks
• Send, Sync, and the data-race story
• Arc, Mutex, RwLock, channels
• A short tour of rayon for data parallelism

Unsafe Rust

• The unsafe superpowers and what they mean
• Raw pointers, dereferencing, and pointer arithmetic
• Calling unsafe functions and writing safe abstractions
• Auditing unsafe blocks

Macros and Metaprogramming

• Declarative macros with macro_rules!
• Procedural macros: derive, attribute, and function-like
• Working with syn, quote, and proc-macro2 at a glance
• Comparison with Roslyn source generators

Tests, Documentation, and Quality

• Unit tests, integration tests, and doctests
• rustdoc and writing documentation that compiles
• clippy and rustfmt in CI

AI-Assisted Rust Development for .NET Engineers

• The 2026 AI-coding-tool landscape and how .NET developers use it for Rust
• Prompts that work well for Rust ownership, lifetimes, and trait design
• Letting the compiler, clippy, and tests catch what AI gets wrong
• Reviewing AI-generated unsafe, unwrap, and reflexive Arc<Mutex<T>>
• Agentic Rust workflows: AI-assisted refactors, code review, and CI