DEV Community

Cover image for From C# to Rust: Fundamentals

From C# to Rust: Fundamentals

Seb Nilsson
Professional problem-solver, developing great ideas into solutions with value. Focus on Open Source, .NET, JavaScript/TypeScript, Azure, Web, DevOps, Agile & Leadership.
Originally published at on ・5 min read

There are some fundamental tools and concepts which we should understand before we get into actually coding Rust.

Since this series focuses on Rust from the perspective of a C#-developer, we will try to relate the Rust-concepts to the equivalent concepts in C# and .NET.

Modern Toolchain

Rust comes with a complete toolchain of everything you need to compile and run your Rust-code. All the way from the compiler, to package-management, testing, code-formatting, linting, documentation-generation, and more.

The Rust Compiler

The compiler for Rust can be executed by using the command rustc. This is usually not done by Rust-developers, but instead, it's done through the Cargo-tool.

.NET equivalent: MSBuild / The C#-compiler (csc.exe)

Cargo: Build System & Package Manager

Cargo is used by Rust-developers to manage, build, test, and document their projects. This is done by using various cargo-commands.

.NET equivalent: .NET CLI and NuGet


Cargo can be used to create a new project by running, for example, cargo new example_project.

.NET equivalent: dotnet new

As mentioned above, Cargo builds the project and this is done by running the command cargo build.

.NET equivalent: dotnet build

Cargo is the Rust-equivalent of .NET's NuGet, so it's also used to resolve and download libraries, which it does automatically when you run the cargo build-command.

Now that your code has been built, you can run the code, given that it's a binary. This is done by using cargo run.

.NET equivalent: dotnet run

To just check that the code is valid and if that it can build, but not actually do a full build, there is a more lightweight command in Rust, which is cargo check.

Rustup: Rust Toolchain Installer

To easily get access to the complete toolchain, we use rustup, the Rust toolchain installer, which installs rustc, cargo, the rustup-CLI, and other Rust-tools.

.NET equivalent: .NET Core SDK

With Rustup, you can change which version of Rust is used, install different platforms for cross-compiling, and installing various other components.

Rust on Windows

For Rust and Rustup to work on Windows, you need to install Visual Studio, or the C++ Build Tools and the Windows 10 SDK separately. Details on this can be found on Rustup's GitHub-page.

Package Manifest

When you run cargo new, your new project will get a Cargo.toml-file, which is the manifest that contains the meta-data about your project.

An example-version of the file, with the added dependency to the regex-package, looks like this:

name = "example_project"
version = "0.1.0"
authors = ["Seb Nilsson"]
edition = "2018"

regex = "1.3.9"

.NET equivalent: The .csproj-file (or the formerly used packages.config-file).

Node.js equivalent: The package.json-file.


In Rust, the term crate is used for a package. It can be either an executable binary or a library.

.NET equivalent: NuGet-packages

To find useful packages/crates to include in your Rust-projects, the registry-site is used.

.NET equivalent:

Formatting Rust-code

Cargo contains a command which can automatically format all the Rust-code in your project. It's called rustfmt and can be executed by running cargo fmt.

Customizing the rules applied when formatting is done by adding a rustfmt.toml-file to the project, which rustfmt then will follow.

.NET equivalent: There is no built-in way to do this in the .NET CLI, but there is .NET Global Tool from the .NET-team called dotnet-format, which allows you to run dotnet format on your project.


Running the tests in a project is also done through Cargo, by running cargo test.

.NET equivalent: dotnet test

Testing is built into Rust, so you do not need to add any external testing-package.

VS Code Setup

First, make sure you've installed Rustup. You can verify that you have it installed by running the command rustup --version, which should show you a version-number.

To get started developing in Rust, with features such as syntax highlighting, auto-complete, code-formatting, refactoring, debugging, and much more, you can install Visual Studio Code, with the Rust-extension and the CodeLLDB-extension.

Next, create a new Rust-project by running cargo new. Now, all you have to do now is press F5 in VS Code and it will automatically create a launch.json for you, which allows you to debug your Rust-code.


By just installing rustup, we get access to the complete Rust-toolchain. This includes, among other things, Cargo, which lets us work through the full development-cycle with our projects, like: create new projects, compile the code, run the code, format the code, and run the tests in our projects.

Add VS Code with a few Rust-extensions, and you'll have a great developer-experience to get started with.

Discussion (1)

nigelpage profile image
Nigel Page

I would suggest adding installation of the Rust Analyzer to this list.