does rust like ownership type in CSharp possible?

[John0King]

a few days ago, I see a few amzing project on github, one is a rust compiler for CLR

maybe I remember it wrong or I switch to a different timeline, because what I remember is it compile rust to CLR's unmanaged memory, and nothing to do with the managed heap. but now I can only find this project and it's different https://github.com/FractalFir/rustc_codegen_clr

rust is memory safe lanague , and it's ownership base memeory management is amazing , and now c# is designe to work more on unmanaged memory(eg. Span<T>, NativeMemroy .etc), I'm wonder does it possible to add an ownership base native memory type system in dotnet.

some ideas

//  no GC  class
public  owned  native class Foo
{
    public int A;

    public void Execute(Managed<object>  managedObject)
    {
        //do something with Managed<T>
        ....
       // pass ref to managed object;
         var doo = new Doo();
         doo.Exeucte(&this);  // give the reference to GC with the `OwnedReference<T>`  and pass it to managed method;
    }
}

// normal  GC tracked class.
public class Doo
{

    public void Run()
 {
       var foo = new Foo();  // foo won't tracked by GC
       foo.A = 1;
      var parameter = new object()
       foo.Execute(parameter); // auto convert to managed<T>
 }  

    public void Execute(OwnedReference<T> nativeRef)
   {
          // do something with the native ref

    }

}

[ufcpp]

#7624
#7620
#7335
#4808

[timdinh]

I was told that due to the dotnet runtime and garbage collection it is not possible to modify csharp to use borrow checker and ownership like rust. However, Python is also used garbage collection and has a runtime. So what they did is created another language called Mojo that has the same syntax as Python but use borrow checker instead and has no garbage collection and it can run Python code as well. Maybe csharp can do something similar and call it d# lol

[iam3yal]

D# sounds like yet another Dead language. 😄

[ris-work]

It looks like ref/structs/stackalloc have similar behaviour. I too hope this would be possible for NativeAOT at least, to avoid GC for certain variables with a static analyzer and wrap everything that fails in a Garbage Collected Mutex :D

[PavelCibulka]

It looks like ref/structs/stackalloc have similar behaviour.

You can also experiment with scoped keyword.

Ownership base memory in C# would be great. It is probably too soon for it right now. It is going to be big change. It needs carefull consideration.

[ris-work]

It looks like ref/structs/stackalloc have similar behaviour.

You can also experiment with scoped keyword.

Ownership base memory in C# would be great. It is probably too soon for it right now. It is going to be big change. It needs carefull consideration.

Thanks!

[etomm]

The first thing I would introduce is the concept of ownership, separated from the borrow checker. Ownership is an important concept to drive development on itself.

For example, the standard constructor for StreamReader should declare the Stream argument as the ownership of that class will be transfered to the instance of the StreamReader, because after it the Stream will be disposed. The Stream logically should not be used anymore outside of the StreamReader.

Another example are the constructors of some of the collections, where the IEnumerable instance is passed, enumerated and added to the collection. In case of arrays in many collections you would be able to take ownership of the array and use it inside the collection, reducing memory allocation and enumerations.

This would by itself enhance C# and allows in a second moment to introduce also a Borrow Checker to mark some instances for a release at the end of a method call instead of entering the big family of the GC instances.