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 8+ 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. Students practice the topics covered through challenging hands-on lab exercises, including a capstone async service that exercises traits, async, and idiomatic error handling.

Software Requirements

A free GitHub account, the latest stable Rust toolchain installed via rustup (Rust 1.95+ 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

Capstone

• Build a small async Rust service with idiomatic error handling, traits, and tests — written with AI assistance and validated by the compiler, clippy, and a benchmark
• Course wrap-up and recommended next courses