Rust for C# Programmers | Rust 面向 C# 程序员

Performance Comparison: Managed vs Native
性能对比：托管环境与原生环境

What you’ll learn: Real-world performance differences between C# and Rust — startup time, memory usage, throughput benchmarks, CPU-intensive workloads, and a decision tree for when to migrate vs when to stay in C#.
本章将学到什么： C# 和 Rust 在真实世界里的性能差异，包括启动时间、内存占用、吞吐基准、CPU 密集型负载，以及到底该迁移还是继续留在 C# 的决策树。

Difficulty: 🟡 Intermediate
难度： 🟡 进阶

Real-World Performance Characteristics
真实世界里的性能特征

Note on .NET 8+ AOT: Native AOT compilation closes the startup gap significantly (5-30ms). For throughput and memory, GC overhead and pauses remain. When evaluating a migration, benchmark your specific workload — headline numbers can be misleading.
关于 .NET 8+ AOT 的说明： Native AOT 已经显著缩小了启动时间差距，通常能压到 5-30ms。但在吞吐和内存方面，GC 带来的开销和停顿依然存在。评估迁移时，重点还是测 自身负载，因为宣传数字很容易误导判断。

Benchmark Examples
基准示例

// C# - JSON processing benchmark
public class JsonProcessor
{
    public async Task<List<User>> ProcessJsonFile(string path)
    {
        var json = await File.ReadAllTextAsync(path);
        var users = JsonSerializer.Deserialize<List<User>>(json);
        
        return users.Where(u => u.Age > 18)
                   .OrderBy(u => u.Name)
                   .Take(1000)
                   .ToList();
    }
}

// Typical performance: ~200ms for 100MB file
// Memory usage: ~500MB peak (GC overhead)
// Binary size: ~80MB (self-contained)

#![allow(unused)]
fn main() {
// Rust - Equivalent JSON processing
use serde::{Deserialize, Serialize};
use tokio::fs;

#[derive(Deserialize, Serialize)]
struct User {
    name: String,
    age: u32,
}

pub async fn process_json_file(path: &str) -> Result<Vec<User>, Box<dyn std::error::Error>> {
    let json = fs::read_to_string(path).await?;
    let mut users: Vec<User> = serde_json::from_str(&json)?;
    
    users.retain(|u| u.age > 18);
    users.sort_by(|a, b| a.name.cmp(&b.name));
    users.truncate(1000);
    
    Ok(users)
}

// Typical performance: ~120ms for same 100MB file
// Memory usage: ~200MB peak (no GC overhead)
// Binary size: ~8MB (static binary)
}

CPU-Intensive Workloads
CPU 密集型负载

// C# - Mathematical computation
public class Mandelbrot
{
    public static int[,] Generate(int width, int height, int maxIterations)
    {
        var result = new int[height, width];
        
        Parallel.For(0, height, y =>
        {
            for (int x = 0; x < width; x++)
            {
                var c = new Complex(
                    (x - width / 2.0) * 4.0 / width,
                    (y - height / 2.0) * 4.0 / height);
                
                result[y, x] = CalculateIterations(c, maxIterations);
            }
        });
        
        return result;
    }
}

// Performance: ~2.3 seconds (8-core machine)
// Memory: ~500MB

#![allow(unused)]
fn main() {
// Rust - Same computation with Rayon
use rayon::prelude::*;
use num_complex::Complex;

pub fn generate_mandelbrot(width: usize, height: usize, max_iterations: u32) -> Vec<Vec<u32>> {
    (0..height)
        .into_par_iter()
        .map(|y| {
            (0..width)
                .map(|x| {
                    let c = Complex::new(
                        (x as f64 - width as f64 / 2.0) * 4.0 / width as f64,
                        (y as f64 - height as f64 / 2.0) * 4.0 / height as f64,
                    );
                    calculate_iterations(c, max_iterations)
                })
                .collect()
        })
        .collect()
}

// Performance: ~1.1 seconds (same 8-core machine)  
// Memory: ~200MB
// 2x faster with 60% less memory usage
}

When to Choose Each Language
什么时候该选哪门语言

Choose C# when:
以下情况更适合 C#：

• Rapid development is crucial - Rich tooling ecosystem
  开发速度优先：工具链成熟，生态顺手。
• Team expertise in .NET - Existing knowledge and skills
  团队已经深耕 .NET：现有知识和经验可以直接复用。
• Enterprise integration - Heavy use of Microsoft ecosystem
  企业集成要求高：大量依赖微软生态。
• Moderate performance requirements - Performance is adequate
  性能要求中等：当前性能已经够用。
• Rich UI applications - WPF, WinUI, Blazor applications
  富界面应用：例如 WPF、WinUI、Blazor 这类项目。
• Prototyping and MVPs - Fast time to market
  原型和 MVP 阶段：更看重上线速度。

Choose Rust when:
以下情况更适合 Rust：

• Performance is critical - CPU/memory-intensive applications
  性能就是核心指标：CPU 或内存消耗特别重。
• Resource constraints matter - Embedded, edge computing, serverless
  资源受限很重要：嵌入式、边缘计算、serverless。
• Long-running services - Web servers, databases, system services
  服务会长时间运行：比如 Web 服务、数据库、系统服务。
• System-level programming - OS components, drivers, network tools
  系统级开发：操作系统组件、驱动、网络工具。
• High reliability requirements - Financial systems, safety-critical applications
  可靠性要求极高：金融系统、安全关键系统。
• Concurrent/parallel workloads - High-throughput data processing
  并发或并行负载很重：高吞吐数据处理场景。

Migration Strategy Decision Tree
迁移策略决策树

graph TD
    START["Considering Rust?"]
    PERFORMANCE["Is performance critical?"]
    TEAM["Team has time to learn?"]
    EXISTING["Large existing C# codebase?"]
    NEW_PROJECT["New project or component?"]
    
    INCREMENTAL["Incremental adoption:<br/>• CLI tools first<br/>• Performance-critical components<br/>• New microservices"]
    
    FULL_RUST["Full Rust adoption:<br/>• Greenfield projects<br/>• System-level services<br/>• High-performance APIs"]
    
    STAY_CSHARP["Stay with C#:<br/>• Optimize existing code<br/>• Use .NET AOT / performance features<br/>• Consider .NET Native"]
    
    START --> PERFORMANCE
    PERFORMANCE -->|Yes| TEAM
    PERFORMANCE -->|No| STAY_CSHARP
    
    TEAM -->|Yes| EXISTING
    TEAM -->|No| STAY_CSHARP
    
    EXISTING -->|Yes| NEW_PROJECT
    EXISTING -->|No| FULL_RUST
    
    NEW_PROJECT -->|New| FULL_RUST
    NEW_PROJECT -->|Existing| INCREMENTAL
    
    style FULL_RUST fill:#c8e6c9,color:#000
    style INCREMENTAL fill:#fff3e0,color:#000
    style STAY_CSHARP fill:#e3f2fd,color:#000