YDotnet

https://github.com/y-crdt/ydotnet
Admin
YDotNet is a .NET binding for y-crdt, providing distributed data types for real-time collaboration...
Tokens:3,786
Snippets:8
Trust Score:6.4
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install YDotNet Core Package

Source: https://github.com/y-crdt/ydotnet/blob/main/README.md

Installs the core YDotNet library using the .NET CLI. This is the first step for any YDotNet project.

```shell
dotnet add package YDotNet
```

--------------------------------

### Configure ESLint for Type-Aware Linting in React/TypeScript

Source: https://github.com/y-crdt/ydotnet/blob/main/Demo/Client/README.md

This snippet demonstrates how to configure ESLint for a React and TypeScript project to enable type-aware linting rules. It involves updating `parserOptions` to include TypeScript project configurations and extending recommended type-checked rule sets for better code quality.

```javascript
parserOptions: {
  ecmaVersion: 'latest',
  sourceType: 'module',
  project: ['./tsconfig.json', './tsconfig.node.json'],
  tsconfigRootDir: __dirname,
}
```

--------------------------------

### Run Unit Tests

Source: https://github.com/y-crdt/ydotnet/blob/main/README.md

Executes all unit tests for the YDotNet.Tests.Unit project using the .NET CLI.

```sh
dotnet test
```

--------------------------------

### Rust Crate Type for C# Interop

Source: https://github.com/y-crdt/ydotnet/blob/main/README.md

Configures the Rust crate to build as a dynamic library (`cdylib`), which is necessary for it to be callable by C# code.

```toml
crate-type = "cdylib"
```

--------------------------------

### Memory Management with DisposableHandle

Source: https://github.com/y-crdt/ydotnet/blob/main/docs/decisions.md

Illustrates the transition from manual memory release to automatic management using DisposableHandle. The old pattern required explicit calls to MemoryWriter.Release, while the new pattern leverages IDisposable for automatic cleanup.

```csharp
var handle = MemoryWriter.WriteUtf8String(value);

// Perform native call

MemoryWriter.Release(value);
```

```csharp
internal sealed record DisposableHandle(nint Handle) : IDisposable
{
    public void Dispose()
    {
        if (Handle != nint.Zero)
        {
            Marshal.FreeHGlobal(Handle);
        }
    }
}
```

--------------------------------

### Synchronize YDotNet Documents Locally

Source: https://github.com/y-crdt/ydotnet/blob/main/README.md

Demonstrates how to synchronize two YDotNet documents locally. It involves creating documents, performing transactions, calculating state differences, and applying them to achieve synchronization.

```csharp
// Set up the local document with some sample data.
var localDoc = new Doc();
var localText = localDoc.Text("name");

var localTransaction = localDoc.WriteTransaction();
localText.Insert(localTransaction, 0, "Y-CRDT");
localTransaction.Commit();

// Set up the remote document.
var remoteDoc = new Doc();
var remoteText = remoteDoc.Text("name");

// Get the remote document state vector.
var remoteTransaction = remoteDoc.WriteTransaction();
var remoteState = remoteTransaction.StateVectorV1();

// Calculate the state diff between the local and the remote document.
localTransaction = localDoc.ReadTransaction();
var stateDiff = localTransaction.StateDiffV1(remoteState);
localTransaction.Commit();

// Apply the state diff to synchronize the remote document with the local changes.
var result = remoteTransaction.ApplyV1(stateDiff);

// Read the text from the remote document.
var text = remoteText.String(remoteTransaction);

// At this point, the `text` variable is "Y-CRDT" and this demonstrates how the two
// documents synchronized their state.
//
// This example does it locally but the same could be done over the Internet, for example.
```

--------------------------------

### Safe Memory Handling in Insert Operation

Source: https://github.com/y-crdt/ydotnet/blob/main/docs/decisions.md

Demonstrates the practical application of DisposableHandle within a method. Using 'using' statements ensures that native memory allocated by MemoryWriter.WriteUtf8String and MemoryWriter.WriteStruct is automatically freed upon exiting the scope, preventing memory leaks.

```csharp
public void Insert(Transaction transaction, string key, Input input)
{
    ThrowIfDisposed();

    using var unsafeKey = MemoryWriter.WriteUtf8String(key);
    using var unsafeValue = MemoryWriter.WriteStruct(input.InputNative);

    MapChannel.Insert(Handle, transaction.Handle, unsafeKey.Handle, unsafeValue.Handle);
}
```

--------------------------------

### C# NativeWithHandle Struct Definition

Source: https://github.com/y-crdt/ydotnet/blob/main/docs/decisions.md

Defines a generic struct `NativeWithHandle` to encapsulate native data along with its associated handle. This pattern is used to manage data structures that require both the value and a reference to native memory, ensuring proper pointer management and data access.

```csharp
internal record struct NativeWithHandle<T>(T Value, nint Handle) where T : struct;
```
Tokens:
Raw