Rust Structs vs C# Classes: Less is More

Welcome back! After wrestling with Rust’s strict ownership rules, let’s ease into something a little more familiar (yet refreshingly different): structs. As a C# developer, you’re probably thinking, “Oh, great, Rust structs are just classes, right?” Well, not exactly. Rust structs offer a minimalist and highly efficient way to structure data, contrasting nicely with our beloved C# Plain Old CLR Objects (POCOs).

Structs: A Quick Rust Recap

Structs in Rust are fundamentally simple. They’re used to group related data together in a single type. Let’s jump right into a quick Rust example:

struct User {
    username: String,
    email: String,
    active: bool,
    sign_in_count: u64,
}

fn main() {
    let user1 = User {
        username: String::from("woodydev"),
        email: String::from("woody@dev.com"),
        active: true,
        sign_in_count: 1,
    };

    println!("Username: {}", user1.username);
}

Simple, right? Rust structs define clear, explicit fields and types without hidden behaviors. Everything you see is everything you get—no surprises.

But Wait, Aren’t C# Classes Similar?

In C#, you’re accustomed to using classes as your default building blocks:

var user1 = new User
{
    Username = "woodydev",
    Email = "woody@dev.com",
    Active = true,
    SignInCount = 1
};

Console.WriteLine($"Username: {user1.Username}");

public class User
{
    public string Username { get; set; }
    public string Email { get; set; }
    public bool Active { get; set; }
    public ulong SignInCount { get; set; }
}

Looks pretty similar, doesn’t it? But there’s a catch. C# classes come with more than meets the eye—they’re reference types, managed by the garbage collector, and they can have inheritance, polymorphism, and various built-in behaviors.

The Minimalist Philosophy

Rust embraces minimalism with structs, doing away with inheritance and hidden complexities. Structs in Rust are always value types (like structs in C#, but without limitations on size or usability). They encourage you to be explicit and intentional about how data is copied or referenced.

If you want methods on your Rust structs, no problem! Rust separates data and behavior clearly through implementations:

impl User {
    fn display_info(&self) {
        println!("{} ({})", self.username, self.email);
    }
}

fn main() {
    let user1 = User {
        username: String::from("woodydev"),
        email: String::from("woody@dev.com"),
        active: true,
        sign_in_count: 1,
    };

    user1.display_info();
}

Notice the clarity and explicitness. Unlike C#, Rust doesn’t hide object behaviors behind inheritance chains or virtual methods unless explicitly requested.

Struct vs. POCOs: Which Is Better?

Both have their places:

• Rust Structs: Lightweight, predictable, and highly performant. They’re perfect when you want clear, no-nonsense data grouping.
• C# Classes (POCOs): Feature-rich, easy to use, and integrated deeply with the .NET runtime. They offer more flexibility with inheritance and runtime features.

Rust’s minimalism might seem restrictive initially, but it actually helps prevent many issues that occur from unexpected object behaviors or memory management complexities in larger applications.

Less Is Indeed More

By removing layers of complexity, Rust structs help you create reliable and maintainable code that clearly expresses its intent. It’s an approach where simplicity becomes a strength, not a limitation.

Tomorrow, we’re exploring Rust enums—a feature that’s significantly more powerful than what you’re used to in C#. Get ready; it’s another step towards mastering Rust’s elegant simplicity.