microsoft-rust-training

仓库: aradotso/trending-skills
安装量: 379
排名: #5721

安装

npx skills add https://github.com/aradotso/trending-skills --skill microsoft-rust-training

Microsoft Rust Training Skill by ara.so — Daily 2026 Skills collection. A collection of seven structured Rust training books maintained by Microsoft, covering Rust from multiple entry points (C/C++, C#/Java, Python backgrounds) through deep dives on async, advanced patterns, type-level correctness, and engineering practices. Each book contains 15–16 chapters with Mermaid diagrams, editable Rust playgrounds, and exercises. Book Catalog Book Level Focus c-cpp-book 🟢 Bridge Move semantics, RAII, FFI, embedded, no_std csharp-book 🟢 Bridge C#/Java/Swift → ownership & type system python-book 🟢 Bridge Dynamic → static typing, GIL-free concurrency async-book 🔵 Deep Dive Tokio, streams, cancellation safety rust-patterns-book 🟡 Advanced Pin, allocators, lock-free structures, unsafe type-driven-correctness-book 🟣 Expert Type-state, phantom types, capability tokens engineering-book 🟤 Practices Build scripts, cross-compilation, CI/CD, Miri Installation & Setup Prerequisites

Install Rust via rustup

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Install mdBook and Mermaid preprocessor

cargo install mdbook mdbook-mermaid Clone and Build git clone https://github.com/microsoft/RustTraining.git cd RustTraining

Build all books into site/

cargo xtask build

Serve all books locally at http://localhost:3000

cargo xtask serve

Build for GitHub Pages deployment (outputs to docs/)

cargo xtask deploy

Clean build artifacts

cargo xtask clean Serve a Single Book cd c-cpp-book && mdbook serve --open

http://localhost:3000

cd python-book && mdbook serve --open cd async-book && mdbook serve --open Repository Structure RustTraining/ ├── c-cpp-book/ │ ├── book.toml │ └── src/ │ ├── SUMMARY.md # Table of contents │ └── *.md # Chapter files ├── csharp-book/ ├── python-book/ ├── async-book/ ├── rust-patterns-book/ ├── type-driven-correctness-book/ ├── engineering-book/ ├── xtask/ # Build automation (cargo xtask) │ └── src/main.rs ├── docs/ # GitHub Pages output ├── site/ # Local preview output └── .github/workflows/ └── pages.yml # Auto-deploy on push to master mdBook Configuration ( book.toml ) Each book contains a book.toml . Example configuration pattern: [ book ] title = "Async Rust" authors = [ "Microsoft" ] language = "en" src = "src" [ build ] build-dir = "../site/async-book" [ preprocessor.mermaid ] command = "mdbook-mermaid" [ output.html ] default-theme = "navy" preferred-dark-theme = "navy" git-repository-url = "https://github.com/microsoft/RustTraining" edit-url-template = "https://github.com/microsoft/RustTraining/edit/master/{path}" [ output.html.search ] enable = true Key Rust Concepts Covered by Book Bridge: Rust for C/C++ Programmers Ownership & Move Semantics // C++ has copy by default; Rust moves by default fn take_ownership ( s : String ) { println! ( "{s}" ) ; } // s is dropped here fn main ( ) { let s = String :: from ( "hello" ) ; take_ownership ( s ) ; // println!("{s}"); // ERROR: s was moved // Use clone for explicit deep copy let s2 = String :: from ( "world" ) ; let s3 = s2 . clone ( ) ; println! ( "{s2} {s3}" ) ; // Both valid } RAII — No Manual Memory Management use std :: fs :: File ; use std :: io :: { self , Write } ; fn write_data ( path : & str , data : & [ u8 ] ) -> io :: Result < ( )

{ let mut file = File :: create ( path ) ? ; // Opens file file . write_all ( data ) ? ; Ok ( ( ) ) } // file automatically closed here — no explicit close needed FFI Example // Calling C from Rust extern "C" { fn abs ( x : i32 ) -> i32 ; } fn main ( ) { unsafe { println! ( "abs(-5) = {}" , abs ( - 5 ) ) ; } } Bridge: Rust for Python Programmers Static Typing with Type Inference // Python: x = [1, 2, 3] // Rust infers the type from usage: let mut numbers = Vec :: new ( ) ; numbers . push ( 1_i32 ) ; numbers . push ( 2 ) ; numbers . push ( 3 ) ; // Explicit when needed: let numbers : Vec < i32

= vec! [ 1 , 2 , 3 ] ; Error Handling (no exceptions) use std :: num :: ParseIntError ; fn double_number ( s : & str ) -> Result < i32 , ParseIntError

{ let n = s . trim ( ) . parse :: < i32

( ) ? ; // ? propagates error Ok ( n * 2 ) } fn main ( ) { match double_number ( "5" ) { Ok ( n ) => println! ( "Doubled: {n}" ) , Err ( e ) => println! ( "Error: {e}" ) , } } GIL-Free Concurrency use std :: thread ; use std :: sync :: { Arc , Mutex } ; fn main ( ) { let counter = Arc :: new ( Mutex :: new ( 0 ) ) ; let mut handles = vec! [ ] ; for _ in 0 .. 10 { let counter = Arc :: clone ( & counter ) ; let handle = thread :: spawn ( move | | { let mut num = counter . lock ( ) . unwrap ( ) ; * num += 1 ; } ) ; handles . push ( handle ) ; } for handle in handles { handle . join ( ) . unwrap ( ) ; } println! ( "Result: {}" , * counter . lock ( ) . unwrap ( ) ) ; // 10 } Deep Dive: Async Rust Basic Async with Tokio use tokio :: time :: { sleep , Duration } ;

[tokio::main]

async fn main ( ) { let result = fetch_data ( ) . await ; println! ( "{result}" ) ; } async fn fetch_data ( ) -> String { sleep ( Duration :: from_millis ( 100 ) ) . await ; "data loaded" . to_string ( ) } Concurrent Tasks use tokio :: task ;

[tokio::main]

async fn main ( ) { let ( a , b ) = tokio :: join! ( task :: spawn ( async { expensive_computation ( 1 ) . await } ) , task :: spawn ( async { expensive_computation ( 2 ) . await } ) , ) ; println! ( "{} {}" , a . unwrap ( ) , b . unwrap ( ) ) ; } async fn expensive_computation ( n : u64 ) -> u64 { tokio :: time :: sleep ( std :: time :: Duration :: from_millis ( n * 100 ) ) . await ; n * 42 } Cancellation-Safe Streams use tokio_stream :: { self as stream , StreamExt } ;

[tokio::main]

async fn main ( ) { let mut s = stream :: iter ( vec! [ 1 , 2 , 3 , 4 , 5 ] ) ; while let Some ( value ) = s . next ( ) . await { println! ( "got {value}" ) ; } } Advanced: Rust Patterns Type-Safe Builder Pattern

[derive(Debug)]

struct Config { host : String , port : u16 , max_connections : usize , } struct ConfigBuilder { host : String , port : u16 , max_connections : usize , } impl ConfigBuilder { fn new ( ) -> Self { Self { host : "localhost" . into ( ) , port : 8080 , max_connections : 100 , } } fn host ( mut self , h : impl Into < String

) -> Self { self . host = h . into ( ) ; self } fn port ( mut self , p : u16 ) -> Self { self . port = p ; self } fn max_connections ( mut self , m : usize ) -> Self { self . max_connections = m ; self } fn build ( self ) -> Config { Config { host : self . host , port : self . port , max_connections : self . max_connections } } } fn main ( ) { let config = ConfigBuilder :: new ( ) . host ( "0.0.0.0" ) . port ( 9090 ) . max_connections ( 500 ) . build ( ) ; println! ( "{config:?}" ) ; } Custom Allocator use std :: alloc :: { GlobalAlloc , Layout , System } ; use std :: sync :: atomic :: { AtomicUsize , Ordering } ; static ALLOCATED : AtomicUsize = AtomicUsize :: new ( 0 ) ; struct TrackingAllocator ; unsafe impl GlobalAlloc for TrackingAllocator { unsafe fn alloc ( & self , layout : Layout ) -> * mut u8 { ALLOCATED . fetch_add ( layout . size ( ) , Ordering :: Relaxed ) ; System . alloc ( layout ) } unsafe fn dealloc ( & self , ptr : * mut u8 , layout : Layout ) { ALLOCATED . fetch_sub ( layout . size ( ) , Ordering :: Relaxed ) ; System . dealloc ( ptr , layout ) } }

[global_allocator]

static A : TrackingAllocator = TrackingAllocator ; fn main ( ) { let _v : Vec < u8

= vec! [ 0u8 ; 1024 ] ; println! ( "Allocated: {} bytes" , ALLOCATED . load ( Ordering :: Relaxed ) ) ; } Expert: Type-Driven Correctness Typestate Pattern use std :: marker :: PhantomData ; struct Locked ; struct Unlocked ; struct Safe < State

{ contents : String , _state : PhantomData < State

, } impl Safe < Locked

{ fn new ( contents : impl Into < String

) -> Self { Safe { contents : contents . into ( ) , _state : PhantomData } } fn unlock ( self , _key : & str ) -> Safe < Unlocked

{ Safe { contents : self . contents , _state : PhantomData } } } impl Safe < Unlocked

{ fn get_contents ( & self ) -> & str { & self . contents } fn lock ( self ) -> Safe < Locked

{ Safe { contents : self . contents , _state : PhantomData } } } fn main ( ) { let safe = Safe :: < Locked

:: new ( "secret data" ) ; // safe.get_contents(); // ERROR: method not available on Locked state let open = safe . unlock ( "correct-key" ) ; println! ( "{}" , open . get_contents ( ) ) ; let _locked_again = open . lock ( ) ; } Phantom Types for Unit Safety use std :: marker :: PhantomData ; struct Meters ; struct Feet ; struct Distance < Unit

{ value : f64 , _unit : PhantomData < Unit

, } impl < Unit

Distance < Unit

{ fn new ( value : f64 ) -> Self { Distance { value , _unit : PhantomData } } fn value ( & self ) -> f64 { self . value } } impl Distance < Meters

{ fn to_feet ( self ) -> Distance < Feet

{ Distance :: new ( self . value * 3.28084 ) } } fn main ( ) { let d_m : Distance < Meters

= Distance :: new ( 100.0 ) ; let d_f : Distance < Feet

= d_m . to_feet ( ) ; println! ( "{:.2} feet" , d_f . value ( ) ) ; // Can't mix units — type system prevents it } Practices: Rust Engineering Build Script ( build.rs ) // build.rs — runs before compilation fn main ( ) { // Tell Cargo to rerun if C source changes println! ( "cargo:rerun-if-changed=src/native/lib.c" ) ; // Compile a C library cc :: Build :: new ( ) . file ( "src/native/lib.c" ) . compile ( "native" ) ; // Emit link search path println! ( "cargo:rustc-link-search=native=/usr/local/lib" ) ; println! ( "cargo:rustc-link-lib=ssl" ) ; } Cross-Compilation

Add a target

rustup target add aarch64-unknown-linux-gnu

Build for that target

cargo build --target aarch64-unknown-linux-gnu

In .cargo/config.toml:

[target.aarch64-unknown-linux-gnu]

linker = "aarch64-linux-gnu-gcc"

Running Miri for Undefined Behavior Detection

Install Miri

rustup component add miri

Run tests under Miri

cargo miri test

Run a specific binary under Miri

cargo miri run Adding Content to a Book SUMMARY.md Structure

Summary

Introduction - Chapter 1: Ownership - Borrowing - Lifetimes - Chapter 2: Types Mermaid Diagrams in Chapters

mermaid
graph
TD
A
[Value Created]
-->
B
{Ownership Transfer?}
B
-->
|Move|
C
[New Owner]
B
-->
|Borrow|
D
[Temporary Reference]
C
-->
E
[Original Invalid]
D
-->
F
[Original Still Valid]

Rust Playground Links You can run this example in the Rust Playground . xtask Automation The xtask pattern lets you write build scripts in Rust instead of shell: // xtask/src/main.rs — simplified pattern use std :: process :: Command ; fn main ( ) { let task = std :: env :: args ( ) . nth ( 1 ) . unwrap_or_default ( ) ; match task . as_str ( ) { "build" => build_all ( ) , "serve" => serve_all ( ) , "deploy" => deploy ( ) , "clean" => clean ( ) , _ => eprintln! ( "Unknown task: {task}" ) , } } fn build_all ( ) { for book in & [ "c-cpp-book" , "python-book" , "async-book" ] { let status = Command :: new ( "mdbook" ) . args ( [ "build" , book ] ) . status ( ) . expect ( "mdbook not found" ) ; assert! ( status . success ( ) , "Failed to build {book}" ) ; } } Run with: cargo xtask build (configured in .cargo/config.toml as an alias). CI/CD — GitHub Pages Deployment

.github/workflows/pages.yml

name : Deploy to GitHub Pages on : push : branches : [ master ] jobs : deploy : runs-on : ubuntu - latest steps : - uses : actions/checkout@v4 - uses : dtolnay/rust - toolchain@stable - run : cargo install mdbook mdbook - mermaid - run : cargo xtask deploy - uses : peaceiris/actions - gh - pages@v3 with : github_token : $ { { secrets.GITHUB_TOKEN } } publish_dir : ./docs Troubleshooting mdbook command not found cargo install mdbook mdbook-mermaid

Ensure ~/.cargo/bin is in your PATH

export PATH = " $HOME /.cargo/bin: $PATH " Mermaid diagrams not rendering

Ensure preprocessor is installed

cargo install mdbook-mermaid

Verify book.toml has:

[preprocessor.mermaid]

command = "mdbook-mermaid"

Port already in use

Specify a different port

mdbook serve --port 3001 Build fails on specific book cd < book-name

mdbook build 2

&1

See full error output

Miri test failures

Update Miri to latest nightly

rustup update nightly rustup component add miri --toolchain nightly cargo +nightly miri test Cross-compilation linker errors

Install cross (Docker-based cross compilation)

cargo install cross cross build --target aarch64-unknown-linux-gnu Reading Path Recommendations New to Rust, coming from Python: python-book → async-book → rust-patterns-book Coming from C/C++: c-cpp-book → rust-patterns-book → type-driven-correctness-book Coming from C#/Java: csharp-book → async-book → engineering-book Already know Rust basics: rust-patterns-book → type-driven-correctness-book → engineering-book Production Rust: engineering-book + async-book (cancellation safety chapters) License Dual-licensed under MIT and CC-BY-4.0 . Code examples are MIT; prose and diagrams are CC-BY-4.0.

← 返回排行榜