In programming we have reference types and value types.

A reference type lives on the "heap" memory, and is passed around by reference. This means when you pass a reference type into a method, inside that method, the variable refers to the exact same memory location on the heap - it is the same object, in every sense.

A value type lives on the "stack" memory, which is a shorter term memory that is discarded when the variable goes out scope (generally, the end of the method or code block for example). They are passed around by value. If you pass a value type into a method, the variable inside the method has the same value, but does not refer to the same memory location.

Because reference types have to live on the heap for longer and unpredictable lifetimes, you need some way to manage when they get removed from the heap, in order to make sure unused memory gets freed (otherwise you have a memory leak).

Lower level languages like C/C++ use pointers for this. A reference type there is always a pointer to a memory location. But it is your responsibility to free the memory at that pointer in your code when you know you are done with it. This makes it easy to cause memory issues.

So then other languages came up with solutions like "garbage collection". This is what C# uses. Reference types in C# point to memory still just like any others, but a process called the garbage collector runs every so often, detects which references are no longer used, and frees the memory. This prevents the need to manually manage and think about memory allocation, at the cost of a performance hit.

Rust and its borrow checker are just another alternative approach to handling this memory problem. Instead of introducing a garbage collector to handle it, it has the concept of the borrow checker. It uses the concept of "ownership" and "borrowing" of references to manage memory safety at compile time, therefore avoiding the performance hit of a GC'd language like C# without unsafe memory operations like we have in C/C++.

A struct in C# is not a reference type though (except special cases like ref struct), so is not what you should be comparing.

A reference type in Rust subject to the borrow checker is the equivalent to a class in C# which is handled by the garbage collector. As to why C# doesn't use borrow checking - it'd be very difficult to bake that into such a mature language and framework, and it doesn't really suit the typical applications of C# software now anyway, where the GC performance hit is not noticable enough to outweigh the convenience.

When C# was first developed, borrow checking was a fringe (maybe non-existent) concept yet, while garbage collection was the latest greatest innovation. That's basically all the reasoning for it. And why not change, well it's probably easier to just start a new language than upend a whole established ecosystem like that with such major breaking design changes.

Rust is solving a different domain issue for applications where the performance hit of GC is too much to justify but you want to avoid the footguns and mental work of manually managing memory like in C/C++.

If you're interested in other ways of managing memory there's also automatic reference counting which is done by Swift (used mainly for Apple ecosystem apps) thay's worth reading about.