Avalanche.Binding

Avalanche.Binding is class library for .NET 7.

Avalanche.Binding uses one-to-many binding architecture. A binding written for one type-system can be coupled with bindings of all other type-domains. Each implementation is written for its specific domain, and doesn't require consideration against other type-systems.

BindingRequest is request for a binding.

// Create service
IService service = Services.Create((BindingHandlers.Instance, Avalanche.DataType.Dto.Module.Instance, Avalanche.Accessor.Dto.Module.Instance));
// Create binding target
IContainerTarget target = DtoTarget.Record(typeof(MyRecord));
// Create binding request
IRequestFor<IBinding> request = new BindingRequest(target);
// Create binding
IRecordBinding<MyRecord> binding = service.GetRequired<IRequest, IRecordBinding<MyRecord>>(request);

Bindings for .NET types can be requested from IServiceProvider.

// Create service
IServiceProvider service = Services.Create((BindingHandlers.Instance, Avalanche.DataType.Dto.Module.Instance, Avalanche.Accessor.Dto.Module.Instance));
// Create binding
var binding = service.GetService(typeof(IRecordBinding<MyRecord>>)) as IRecordBinding<MyRecord>>;

.DataType describes type structure as IDataType.

// Get number of fields
int count = binding.DataType.Fields.Length;
// Print datatype
System.Console.WriteLine(binding.DataType.PrintTree());

.Accessor exposes access to domain specific containers as IAccessor.

// Create empty record
MyRecord myRecord = binding.Accessor.DefaultConstructor.Read();
// Assign name
binding.Accessor.Fields[0].Writer.Write("Name", myRecord);

Protobuf3Binary is target for Protobuf v3 serialization.

// Create service
IService service = Services.Create((BindingHandlers.Instance, Protobuf3AccessorHandlers.Instance, Avalanche.DataType.Dto.Module.Instance));
// Create binding target
IContainerTarget target = new Protobuf3Binary(DataTypeRequest.Create(DtoTarget.Record(typeof(MyRecord)), typeof(StreamSpan));
// Create binding request
IRequestFor<IBinding> request = new BindingRequest(target);
// Create binding
IRecordBinding<StreamSpan, StreamSpan> binaryBinding = service.GetRequired<IRequest, IRecordBinding<StreamSpan, StreamSpan>>(request);

Binary binding accesses container as byte segments.

// Create stream
MemoryStream ms = new MemoryStream();
// Create stream span
StreamSpan ss = new StreamSpan(ms);
// Create empty record
binaryBinding.Accessor.DefaultConstructor.Write(ref ss);
// Assign name
binaryBinding.Accessor.Fields[0].Writer.TypeCast<string, StreamSpan>().Write("Name", ref ss);
// Get data
byte[] data = ms.ToArray();

ConverterRequest is a request for a converter between two bindings.

// Create serializer
IWriterBase<MyRecord, StreamSpan> serializer = service.GetRequired<IRequest, IWriterBase<MyRecord, StreamSpan>>(new ConverterRequest(binding, binaryBinding));
// Create stream span
StreamSpan ss = new StreamSpan(new MemoryStream());
// Serialize
serializer.Write(new MyRecord("Name"), ref ss);

// Create deserializer
IWriterBase<StreamSpan, MyRecord> deserializer = service.GetRequired<IRequest, IWriterBase<StreamSpan, MyRecord>>(new ConverterRequest(binaryBinding, binding));
// Deserialize
MyRecord myRecord = deserializer.Read(ss);

Hierarchical request creates a serializer with one go.

// Create service
IService service = Services.Create((BindingHandlers.Instance, Avalanche.DataType.Dto.Module.Instance, Avalanche.Accessor.Dto.Module.Instance, Protobuf3AccessorHandlers.Instance));
// Create binding target
IContainerTarget target = DtoTarget.Record(typeof(MyRecord));
// Create request
IRequestFor<IWriterBase> serializerRequest = 
    new ConverterRequest(
        from: new BindingRequest(target),
        to: new BindingRequest(new Protobuf3Binary(DataTypeRequest.Create(target), typeof(StreamSpan)))
    );
// Create serializer
IWriterBase<MyRecord, StreamSpan> serializer = service.GetRequired<IRequest, IWriterBase<MyRecord, StreamSpan>>(serializerRequest);

// Create stream span
StreamSpan ss = new StreamSpan(new MemoryStream());
// Serialize
serializer.Write(new MyRecord("Name"), ref ss);

SerializationContext is required when serializing referable objects. Context keeps track of object identities.

// Create stream span
StreamSpan ss = new StreamSpan(new MemoryStream());
// Create graph
Node a = new Node("A"), b = new Node("B"), c = new Node("C");
a.Edges.Add(b);
b.Edges.Add(c);
c.Edges.Add(a);
// Create serialization context
IServiceProvider ctx = new SerializationContext();
// Serialize
serializer.Write(a, ref ss, ctx);

public class Node { public List<Node> Edges = new(); }

Class libraries:

• Avalanche.Binding.dll
• Avalanche.Binding.Abstractions.dll
• Avalanche.Binding.DependecyInjection.dll

Other:

• Interoperability: .NET 7 and upwards

The following GlobalUsings.cs can be used to include all extension methods.

global using Avalanche.Accessor;
global using Avalanche.Binding;
global using Avalanche.Converter;
global using Avalanche.DataType;
global using Avalanche.Identity;
global using Avalanche.Message;
global using Avalanche.Service;
global using Avalanche.Template;
global using Avalanche.Utilities;
global using Avalanche.Utilities.Provider;
global using Avalanche.Writer;