https://microsoft.github.io/rust-for-dotnet-devs/latest/

 1. Introduction
 2. License
 3. Contributing
 4. 1. Getting Started
 5. 2. Language
 6.
     1. 2.1. Scalar Types
     2. 2.2. Strings
     3. 2.3. Structured Types
     4. 2.4. Custom Types
     5.
         1. 2.4.1. Classes
         2. 2.4.2. Records
         3. 2.4.3. Structures
         4. 2.4.4. Interfaces
         5. 2.4.5. Enumeration Types
         6. 2.4.6. Members
     6. 2.5. Local Functions
     7. 2.6. Lambda and Closures
     8. 2.7. Variables
     9. 2.8. Namespaces
    10. 2.9. Equality
    11. 2.10. Generics
    12. 2.11. Polymorphism
    13. 2.12. Inheritance
    14. 2.13. Exception Handling
    15. 2.14. Nullability and Optionality
    16. 2.15. Discards
    17. 2.16. Conversion and Casting
    18. 2.17. Operator Overloading
    19. 2.18. Documentation Comments
 7. 3. Memory Management
 8. 4. Resource Management
 9. 5. Threading
10.
     1. 5.1. Synchronization
     2. 5.2. Producer-Consumer
11. 6. Testing
12. 7. Benchmarking
13. 8. Logging and Tracing
14. 9. Conditional Compilation
15. 10. Environment and Configuration
16. 11. LINQ
17. 12. Meta Programming
18. 13. Asynchronous Programming
19. 14. Project Structure
20. 15. Compilation and Building

  * Light
  * Rust
  * Coal
  * Navy
  * Ayu

Rust for C#/.NET Developers

   
[                    ]

Introduction

This is a (non-comprehensive) guide for C# and .NET developers that
are completely new to the Rust programming language. Some concepts
and constructs translate fairly well between C#/.NET and Rust, but
which may be expressed differently, whereas others are a radical
departure, like memory management. This guide provides a brief
comparison and mapping of those constructs and concepts with concise
examples.

The original authors^1 of this guide were themselves C#/.NET
developers who were completely new to Rust. This guide is the
compilation of the knowledge acquired by the authors writing Rust
code over the course of several months. It is the guide the authors
wish they had when they started on their Rust journey. That said, the
authors would encourage you to read books and other material
available on the Web to embrace Rust and its idioms rather than
attempting to learn it exclusively through the lens of C# and .NET.
Meanwhile, this guide can help answers some question quickly, like:
Does Rust support inheritance, threading, asynchronous programming,
etc.?

Assumptions:

  * Reader is a seasoned C#/.NET developer.
  * Reader is completely new to Rust.

Goals:

  * Provide a brief comparison and mapping of various C#/.NET topics
    to their counterparts in Rust.
  * Provide links to Rust reference, book and articles for further
    reading on topics.

Non-goals:

  * Discussion of design patterns and architectures.
  * Tutorial on the Rust language.
  * Reader is proficient in Rust after reading this guide.
  * While there are short examples that contrast C# and Rust code for
    some topics, this guide is not meant to be a cookbook of coding
    recipes in the two languages.

---------------------------------------------------------------------
^1

The original authors of this guide were (in alphabetical order): Atif
Aziz, Bastian Burger, Daniele Antonio Maggio, Dariusz Parys and
Patrick Schuler.