website·Indexed 29 days ago
https://rustfor.netA comprehensive guide for .NET developers learning Rust, covering core language concepts like ownership, lifetimes, and generics, as well as ecosystem tools including Axum for web APIs, SQLx for database interactions, Serde for serialization, and Mockall for testing.
Rust provides several key technical advantages over .NET for high-performance and resource-constrained applications:
Ownership is the foundation of Rust's memory safety, allowing the language to free memory without a garbage collector. Unlike .NET where multiple references can own an object, Rust enforces that every value has exactly one owner at a time.
Key behaviors include:
Copy trait, meaning they are duplicated rather than moved during assignment.| Feature | .NET | Rust |
|---|---|---|
| Memory Safety Enforcement | Runtime | Compile time |
| Memory Management | Garbage collection | Ownership & RAII |
| Data Race Prevention | Manual (locks) | Compiler enforced |
| Null Reference Handling | Nullable types + runtime checks | Option + compile-time checks |
| Resource Cleanup | Finalizers + IDisposable | Deterministic Drop |
| Concurrency Model | Shared mutable state | Ownership transfer or explicit sharing |
When refactoring a monolithic Rust API to a modular architecture, organize the project into the following structure to separate concerns and enforce boundaries:
core module: Use a folder-based module (src/core/mod.rs or src/core.rs with a core/ directory) to house domain models (e.g., User, UserDetails) and business logic.data_access.rs module: Use a single-file module to contain data storage mechanisms and state management (e.g., AppState).lib.rs: The application library containing the Axum API setup and routing logic.main.rs: The binary entry point containing the main() function that invokes the library.Use visibility modifiers like pub and pub(crate) to restrict access and maintain architectural boundaries between business logic and infrastructure.
log crate provides a standardized logging API that abstracts the logging implementation from the application code. This allows developers to write log messages using a consistent interface while swapping out the actual logging backend (similar to Serilog sinks in .NET).log::trace!("Trace message");
log::info!("Info message");
log::warn!("Warning message");
log::error!("Error message");macro_rules! macros) function as compiler-assisted search and replace. They operate on Rust code at compile time using a structure similar to a match expression to eliminate repetitive boilerplate and provide shorthands for common code patterns. A common example is println!, which expands into calls to std::io::_print and format_args! during compilation.// Example of a declarative macro call
println!("Hello {}", "James");
// What it unwraps to at compile time:
std::io::_print(format_args!("Hello {}", "James"));When transitioning from .NET to Rust, developers should be aware of several key challenges:
To create a flexible application architecture that allows swapping data access implementations (e.g., moving from in-memory storage to a database) without changing business logic, follow these architectural steps:
Result with a custom ApplicationError.InMemoryDataAccess) using a Mutex<Vec<User>> to handle thread-safe in-memory storage.AppState<TDataAccess> where TDataAccess is constrained by trait bounds: DataAccess + Send + Sync. This ensures the state can be shared across threads safely.// 1. Define the trait
#[async_trait]
trait DataAccess {
async fn with_email_address(&self, email_address: &str) -> Result<User, ApplicationError>;
async fn store(&self, user: User) -> Result<(), ApplicationError>;
}
// 2. Implement in-memory storage
struct InMemoryDataAccess {
users: Mutex<Vec<User>>,
}
impl DataAccess for InMemoryDataAccess {
// ... implementation of methods
}
// 3. Generic App State
struct AppState<TDataAccess>
where
TDataAccess: DataAccess + Send + Sync
{
data_access: TDataAccess,
}if let syntax is a shorthand for a match that only cares about one specific pattern. It is frequently used with Option types to check if a value exists and bind it to a variable in a single step. If the pattern does not match, the else block is executed.// Concise way to handle Option<T>
if let Some(age) = users_age {
println!("I'm {} years old.", age);
} else {
println!("I don't know my age.");
}