FieldWrite<Record, Field>

FieldWrite<Record, Field> is delegate type that writes field to record at 'ref' pointer.

/// <summary>Assign new value to <paramref name="newValue"/>.</summary>
public delegate void FieldWrite<Record, Field>(ref Record record, Field newValue);

FieldWrite.TryCreateFieldWriteDelegate(this fieldDescription, out delegate) tries to create FieldWrite<Record, Field> delegate.

// Get field reference
FieldInfo fi = typeof(MyStruct).GetField(nameof(MyStruct.value))!;
// Convert to description
IFieldDescription fieldDescription = FieldDescription.Create[fi];
// Create delegate
fieldDescription.TryCreateFieldWriteDelegate(out Delegate @delegate);
// Cast delegate
FieldWrite<MyStruct, int> fieldWrite = (FieldWrite<MyStruct, int>)@delegate;
// Create struct
MyStruct myStruct = new MyStruct(2);
// Write field
fieldWrite(ref myStruct, 10);
// Print value
WriteLine(myStruct.value); // 10

public struct MyStruct
{
    public int value;

    public MyStruct(int value)
    {
        this.value = value;
    }
}

FieldWrite.Create[fieldDescription] is a provider that creates new write delegates.

// Create delegate
FieldWrite<MyStruct, int> fieldWrite = (FieldWrite<MyStruct, int>)FieldWrite.Create[fieldDescription];

FieldWrite.Cached[fieldDescription] is a provider that creates and caches write delegates.

// Get field reference
FieldInfo fi = typeof(MyStruct).GetField(nameof(MyStruct.value))!;
// Convert to description
IFieldDescription fieldDescription = FieldDescription.Cached[fi];
// Get (weak key) cached delegate
FieldWrite<MyStruct, int> fieldWrite = (FieldWrite<MyStruct, int>)FieldWrite.Cached[fieldDescription];

FieldWrite.CreateFromObject[memberInfo] is a provider that creates new write delegates from FieldInfo and PropertyInfo.

// Get field reference
FieldInfo fi = typeof(MyStruct).GetField(nameof(MyStruct.value))!;
// Create delegate
FieldWrite<MyStruct, int> fieldWrite = (FieldWrite<MyStruct, int>)FieldWrite.CreateFromObject[fi];

FieldWrite.CachedFromObject[memberInfo] is a provider that creates and caches write delegates from FieldInfo and PropertyInfo.

// Get (weak key) cached delegate
FieldWrite<MyStruct, int> fieldWrite = (FieldWrite<MyStruct, int>)FieldWrite.CachedFromObject[fi];

Action<Record, Field>

FieldWrite.TryCreateFieldWriteAction(this fieldDescription, out delegate) tries to create FieldWrite<Record, Field> delegate.

// Get field reference
FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
// Convert to description
IFieldDescription fieldDescription = FieldDescription.Create[fi];
// Create delegate
fieldDescription.TryCreateFieldWriteAction(out Delegate @delegate);
// Cast delegate
Action<MyClass, int> fieldWrite = (Action<MyClass, int>)@delegate;
// Create class
MyClass myClass = new MyClass(2);
// Write field
fieldWrite(myClass, 10);
// Print value
WriteLine(myClass.value); // 10

FieldWriteAction.Create[fieldDescription] is a provider that creates new write delegates Action<Record, Field>.

// Get field reference
FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
// Convert to description
IFieldDescription fieldDescription = FieldDescription.Cached[fi];
// Create delegate
Action<MyClass, int> fieldWrite = (Action<MyClass, int>)FieldWriteAction.Create[fieldDescription];
// Create class
MyClass myClass = new MyClass(2);
// Write field
fieldWrite(myClass, 10);
// Print value
WriteLine(myClass.value); // 10

public class MyClass
{
    public int value;

    public MyClass(int value)
    {
        this.value = value;
    }
}

FieldWriteAction.Cached[fieldDescription] is a provider that creates and caches write delegates.

// Get field reference
FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
// Convert to description
IFieldDescription fieldDescription = FieldDescription.Cached[fi];
// Get (weak key) cached delegate
Action<MyClass, int> fieldWrite = (Action<MyClass, int>)FieldWriteAction.Cached[fieldDescription];

FieldWriteAction.CreateFromObject[memberInfo] is a provider that creates new write delegates from FieldInfo and PropertyInfo.

// Get field reference
FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
// Create delegate
Action<MyClass, int> fieldWrite = (Action<MyClass, int>)FieldWriteAction.CreateFromObject[fi];

FieldWriteAction.CachedFromObject[memberInfo] is a provider that creates and caches write delegates from FieldInfo and PropertyInfo.

// Get (weak key) cached delegate
Action<MyClass, int> fieldWrite = (Action<MyClass, int>)FieldWriteAction.CachedFromObject[fi];

Action<object, object>

FieldWrite.TryCreateFieldWriteActionOO(this fieldDescription, out delegate) tries to create FieldWrite<Record, Field> delegate.

// Get field reference
FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
// Convert to description
IFieldDescription fieldDescription = FieldDescription.Create[fi];
// Create delegate
fieldDescription.TryCreateFieldWriteActionOO(out Action<object, object> fieldWrite);
// Create class
MyClass myClass = new MyClass(2);
// Write field
fieldWrite(myClass, 10);
// Print value
WriteLine(myClass.value); // 10

FieldWriteActionOO.Create[fieldDescription] is a provider that creates new write delegates Action<object, object>.

// Get field reference
FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
// Convert to description
IFieldDescription fieldDescription = FieldDescription.Cached[fi];
// Create delegate
Action<object, object> fieldWrite = (Action<object, object>)FieldWriteActionOO.Create[fieldDescription];
// Create class
MyClass myClass = new MyClass(2);
// Write field
fieldWrite(myClass, 10);
// Print value
WriteLine(myClass.value); // 10

FieldWriteActionOO.Cached[fieldDescription] is a provider that creates and caches write delegates.

// Get field reference
FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
// Convert to description
IFieldDescription fieldDescription = FieldDescription.Cached[fi];
// Get (weak key) cached delegate
Action<object, object> fieldWrite = (Action<object, object>)FieldWriteActionOO.Cached[fieldDescription];

FieldWriteActionOO.CreateFromObject[memberInfo] is a provider that creates new write delegates from FieldInfo and PropertyInfo.

// Get field reference
FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
// Create delegate
Action<object, object> fieldWrite = (Action<object, object>)FieldWriteActionOO.CreateFromObject[fi];

FieldWriteActionOO.CachedFromObject[memberInfo] is a provider that creates and caches write delegates from FieldInfo and PropertyInfo.

// Get (weak key) cached delegate
Action<object, object> fieldWrite = (Action<object, object>)FieldWriteActionOO.CachedFromObject[fi];

Full Example

Full example

using System;
using System.Reflection;
using Avalanche.Utilities.Record;
using static System.Console;

class fieldwrite
{
    public static void Run()
    {
        // FieldWrite<Record, Field>
        {
            // <00>
            // Get field reference
            FieldInfo fi = typeof(MyStruct).GetField(nameof(MyStruct.value))!;
            // Convert to description
            IFieldDescription fieldDescription = FieldDescription.Create[fi];
            // Create delegate
            fieldDescription.TryCreateFieldWriteDelegate(out Delegate @delegate);
            // Cast delegate
            FieldWrite<MyStruct, int> fieldWrite = (FieldWrite<MyStruct, int>)@delegate;
            // Create struct
            MyStruct myStruct = new MyStruct(2);
            // Write field
            fieldWrite(ref myStruct, 10);
            // Print value
            WriteLine(myStruct.value); // 10
            // </00>
        }

        {
            // Get field reference
            FieldInfo fi = typeof(MyStruct).GetField(nameof(MyStruct.value))!;
            // Convert to description
            IFieldDescription fieldDescription = FieldDescription.Cached[fi];
            // <01>
            // Create delegate
            FieldWrite<MyStruct, int> fieldWrite = (FieldWrite<MyStruct, int>)FieldWrite.Create[fieldDescription];
            // </01>
            // Create struct
            MyStruct myStruct = new MyStruct(2);
            // Write field
            fieldWrite(ref myStruct, 10);
            // Print value
            WriteLine(myStruct.value); // 10
        }
        {
            // <02>
            // Get field reference
            FieldInfo fi = typeof(MyStruct).GetField(nameof(MyStruct.value))!;
            // Convert to description
            IFieldDescription fieldDescription = FieldDescription.Cached[fi];
            // Get (weak key) cached delegate
            FieldWrite<MyStruct, int> fieldWrite = (FieldWrite<MyStruct, int>)FieldWrite.Cached[fieldDescription];
            // </02>
            // Create struct
            MyStruct myStruct = new MyStruct(2);
            // Write field
            fieldWrite(ref myStruct, 10);
            // Print value
            WriteLine(myStruct.value); // 10
        }
        {
            // <03>
            // Get field reference
            FieldInfo fi = typeof(MyStruct).GetField(nameof(MyStruct.value))!;
            // Create delegate
            FieldWrite<MyStruct, int> fieldWrite = (FieldWrite<MyStruct, int>)FieldWrite.CreateFromObject[fi];
            // </03>
            // Create struct
            MyStruct myStruct = new MyStruct(2);
            // Write field
            fieldWrite(ref myStruct, 10);
            // Print value
            WriteLine(myStruct.value); // 10
        }
        {
            // Get field reference
            FieldInfo fi = typeof(MyStruct).GetField(nameof(MyStruct.value))!;
            // <04>
            // Get (weak key) cached delegate
            FieldWrite<MyStruct, int> fieldWrite = (FieldWrite<MyStruct, int>)FieldWrite.CachedFromObject[fi];
            // </04>
            // Create struct
            MyStruct myStruct = new MyStruct(2);
            // Write field
            fieldWrite(ref myStruct, 10);
            // Print value
            WriteLine(myStruct.value); // 10
        }


        // Action<Record, Field>
        {
            // <10>
            // Get field reference
            FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
            // Convert to description
            IFieldDescription fieldDescription = FieldDescription.Create[fi];
            // Create delegate
            fieldDescription.TryCreateFieldWriteAction(out Delegate @delegate);
            // Cast delegate
            Action<MyClass, int> fieldWrite = (Action<MyClass, int>)@delegate;
            // Create class
            MyClass myClass = new MyClass(2);
            // Write field
            fieldWrite(myClass, 10);
            // Print value
            WriteLine(myClass.value); // 10
            // </10>
        }
        {
            // <11>
            // Get field reference
            FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
            // Convert to description
            IFieldDescription fieldDescription = FieldDescription.Cached[fi];
            // Create delegate
            Action<MyClass, int> fieldWrite = (Action<MyClass, int>)FieldWriteAction.Create[fieldDescription];
            // Create class
            MyClass myClass = new MyClass(2);
            // Write field
            fieldWrite(myClass, 10);
            // Print value
            WriteLine(myClass.value); // 10
            // </11>
        }
        {
            // <12>
            // Get field reference
            FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
            // Convert to description
            IFieldDescription fieldDescription = FieldDescription.Cached[fi];
            // Get (weak key) cached delegate
            Action<MyClass, int> fieldWrite = (Action<MyClass, int>)FieldWriteAction.Cached[fieldDescription];
            // </12>
            // Create Class
            MyClass myClass = new MyClass(2);
            // Write field
            fieldWrite(myClass, 10);
            // Print value
            WriteLine(myClass.value); // 10
        }
        {
            // <13>
            // Get field reference
            FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
            // Create delegate
            Action<MyClass, int> fieldWrite = (Action<MyClass, int>)FieldWriteAction.CreateFromObject[fi];
            // </13>
            // Create Class
            MyClass myClass = new MyClass(2);
            // Write field
            fieldWrite(myClass, 10);
            // Print value
            WriteLine(myClass.value); // 10
        }
        {
            // Get field reference
            FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
            // <14>
            // Get (weak key) cached delegate
            Action<MyClass, int> fieldWrite = (Action<MyClass, int>)FieldWriteAction.CachedFromObject[fi];
            // </14>
            // Create Class
            MyClass myClass = new MyClass(2);
            // Write field
            fieldWrite(myClass, 10);
            // Print value
            WriteLine(myClass.value); // 10
        }



        // Action<object, object>
        {
            // <20>
            // Get field reference
            FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
            // Convert to description
            IFieldDescription fieldDescription = FieldDescription.Create[fi];
            // Create delegate
            fieldDescription.TryCreateFieldWriteActionOO(out Action<object, object> fieldWrite);
            // Create class
            MyClass myClass = new MyClass(2);
            // Write field
            fieldWrite(myClass, 10);
            // Print value
            WriteLine(myClass.value); // 10
            // </20>
        }
        {
            // <21>
            // Get field reference
            FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
            // Convert to description
            IFieldDescription fieldDescription = FieldDescription.Cached[fi];
            // Create delegate
            Action<object, object> fieldWrite = (Action<object, object>)FieldWriteActionOO.Create[fieldDescription];
            // Create class
            MyClass myClass = new MyClass(2);
            // Write field
            fieldWrite(myClass, 10);
            // Print value
            WriteLine(myClass.value); // 10
            // </21>
        }
        {
            // <22>
            // Get field reference
            FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
            // Convert to description
            IFieldDescription fieldDescription = FieldDescription.Cached[fi];
            // Get (weak key) cached delegate
            Action<object, object> fieldWrite = (Action<object, object>)FieldWriteActionOO.Cached[fieldDescription];
            // </22>
            // Create Class
            MyClass myClass = new MyClass(2);
            // Write field
            fieldWrite(myClass, 10);
            // Print value
            WriteLine(myClass.value); // 10
        }
        {
            // <23>
            // Get field reference
            FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
            // Create delegate
            Action<object, object> fieldWrite = (Action<object, object>)FieldWriteActionOO.CreateFromObject[fi];
            // </23>
            // Create Class
            MyClass myClass = new MyClass(2);
            // Write field
            fieldWrite(myClass, 10);
            // Print value
            WriteLine(myClass.value); // 10
        }
        {
            // Get field reference
            FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
            // <24>
            // Get (weak key) cached delegate
            Action<object, object> fieldWrite = (Action<object, object>)FieldWriteActionOO.CachedFromObject[fi];
            // </24>
            // Create Class
            MyClass myClass = new MyClass(2);
            // Write field
            fieldWrite(myClass, 10);
            // Print value
            WriteLine(myClass.value); // 10
        }


    }

    // <100>
    public class MyClass
    {
        public int value;

        public MyClass(int value)
        {
            this.value = value;
        }
    }
    // </100>
    // <101>
    public struct MyStruct
    {
        public int value;

        public MyStruct(int value)
        {
            this.value = value;
        }
    }
    // </101>
}