FieldRead<Record, Field>

FieldRead<Record, Field> is delegate type that reads field from record at 'ref' pointer.

/// <summary>Read field value</summary>
public delegate Field FieldRead<Record, Field>(ref Record record);

FieldRead.TryCreateFieldReadDelegate(this fieldDescription, out delegate) tries to create FieldRead<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.TryCreateFieldReadDelegate(out Delegate @delegate);
// Cast delegate
FieldRead<MyStruct, int> fieldRead = (FieldRead<MyStruct, int>)@delegate;
// Create struct
MyStruct myStruct = new MyStruct(10);
// Read field
int value = fieldRead(ref myStruct);
// Print value
WriteLine(value); // 10

public struct MyStruct
{
    public int value;

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

FieldRead.Create[fieldDescription] is a provider that creates new read delegates.

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

FieldRead.Cached[fieldDescription] is a provider that creates and caches read 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
FieldRead<MyStruct, int> fieldRead = (FieldRead<MyStruct, int>)FieldRead.Cached[fieldDescription];

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

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

FieldRead.CachedFromObject[memberInfo] is a provider that creates and caches read delegate from FieldInfo and PropertyInfo.

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

Func<Record, Field>

FieldRead.TryCreateFieldReadFunc(this fieldDescription, out delegate) tries to create FieldRead<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.TryCreateFieldReadFunc(out Delegate @delegate);
// Cast delegate
Func<MyClass, int> fieldRead = (Func<MyClass, int>)@delegate;
// Create class
MyClass myClass = new MyClass(10);
// Read field
int value = fieldRead(myClass);
// Print value
WriteLine(value); // 10

public class MyClass
{
    public int value;

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

FieldReadFunc.Create[fieldDescription] is a provider that creates a new read delegate Func<Record, Field>.

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

public class MyClass
{
    public int value;

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

FieldReadFunc.Cached[fieldDescription] is a provider that creates and caches read 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
Func<MyClass, int> fieldRead = (Func<MyClass, int>)FieldReadFunc.Cached[fieldDescription];

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

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

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

// Get (weak key) cached delegate
Func<MyClass, int> fieldRead = (Func<MyClass, int>)FieldReadFunc.CachedFromObject[fi];

Func<object, object>

FieldRead.TryCreateFieldReadFuncOO(this fieldDescription, out delegate) tries to create FieldRead<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.TryCreateFieldReadFuncOO(out Func<object, object> fieldRead);
// Create class
MyClass myClass = new MyClass(10);
// Read field
int value = (int)fieldRead(myClass);
// Print value
WriteLine(value); // 10

FieldReadFuncOO.Create[fieldDescription] is a provider that creates new read Func<object, object> delegates.

// Get field reference
FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
// Convert to description
IFieldDescription fieldDescription = FieldDescription.Cached[fi];
// Create delegate
Func<object, object> fieldRead = FieldReadFuncOO.Create[fieldDescription];
// Create class
MyClass myClass = new MyClass(10);
// Read field
int value = (int)fieldRead(myClass);
// Print value
WriteLine(value); // 10

FieldReadFuncOO.Cached[fieldDescription] is a provider that creates and caches read 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
Func<object, object> fieldRead = FieldReadFuncOO.Cached[fieldDescription];

FieldReadFuncOO.CreateFromObject[memberInfo] is a provider that creates a new read delegate from FieldInfo and PropertyInfo.

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

FieldReadFuncOO.CachedFromObject[memberInfo] is a provider that creates and caches read delegate from FieldInfo and PropertyInfo.

// Get (weak key) cached delegate
Func<object, object> fieldRead = FieldReadFuncOO.CachedFromObject[fi];

Full Example

Full example

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

class fieldread
{
    public static void Run()
    {
        // FieldRead<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.TryCreateFieldReadDelegate(out Delegate @delegate);
            // Cast delegate
            FieldRead<MyStruct, int> fieldRead = (FieldRead<MyStruct, int>)@delegate;
            // Create struct
            MyStruct myStruct = new MyStruct(10);
            // Read field
            int value = fieldRead(ref myStruct);
            // Print value
            WriteLine(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
            FieldRead<MyStruct, int> fieldRead = (FieldRead<MyStruct, int>)FieldRead.Create[fieldDescription];
            // </01>
            // Create struct
            MyStruct myStruct = new MyStruct(10);
            // Read field
            int value = fieldRead(ref myStruct);
            // Print value
            WriteLine(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
            FieldRead<MyStruct, int> fieldRead = (FieldRead<MyStruct, int>)FieldRead.Cached[fieldDescription];
            // </02>
            // Create struct
            MyStruct myStruct = new MyStruct(10);
            // Read field
            int value = fieldRead(ref myStruct);
            // Print value
            WriteLine(value); // 10
        }
        {
            // <03>
            // Get field reference
            FieldInfo fi = typeof(MyStruct).GetField(nameof(MyStruct.value))!;
            // Create delegate
            FieldRead<MyStruct, int> fieldRead = (FieldRead<MyStruct, int>)FieldRead.CreateFromObject[fi];
            // </03>
            // Create struct
            MyStruct myStruct = new MyStruct(10);
            // Read field
            int value = fieldRead(ref myStruct);
            // Print value
            WriteLine(value); // 10
        }
        {
            // Get field reference
            FieldInfo fi = typeof(MyStruct).GetField(nameof(MyStruct.value))!;
            // <04>
            // Get (weak key) cached delegate
            FieldRead<MyStruct, int> fieldRead = (FieldRead<MyStruct, int>)FieldRead.CachedFromObject[fi];
            // </04>
            // Create struct
            MyStruct myStruct = new MyStruct(10);
            // Read field
            int value = fieldRead(ref myStruct);
            // Print value
            WriteLine(value); // 10
        }


        // Func<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.TryCreateFieldReadFunc(out Delegate @delegate);
            // Cast delegate
            Func<MyClass, int> fieldRead = (Func<MyClass, int>)@delegate;
            // Create class
            MyClass myClass = new MyClass(10);
            // Read field
            int value = fieldRead(myClass);
            // Print value
            WriteLine(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
            Func<MyClass, int> fieldRead = (Func<MyClass, int>)FieldReadFunc.Create[fieldDescription];
            // Create class
            MyClass myClass = new MyClass(10);
            // Read field
            int value = fieldRead(myClass);
            // Print value
            WriteLine(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
            Func<MyClass, int> fieldRead = (Func<MyClass, int>)FieldReadFunc.Cached[fieldDescription];
            // </12>
            // Create Class
            MyClass myClass = new MyClass(10);
            // Read field
            int value = fieldRead(myClass);
            // Print value
            WriteLine(value); // 10
        }
        {
            // <13>
            // Get field reference
            FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
            // Create delegate
            Func<MyClass, int> fieldRead = (Func<MyClass, int>)FieldReadFunc.CreateFromObject[fi];
            // </13>
            // Create Class
            MyClass myClass = new MyClass(10);
            // Read field
            int value = fieldRead(myClass);
            // Print value
            WriteLine(value); // 10
        }
        {
            // Get field reference
            FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
            // <14>
            // Get (weak key) cached delegate
            Func<MyClass, int> fieldRead = (Func<MyClass, int>)FieldReadFunc.CachedFromObject[fi];
            // </14>
            // Create Class
            MyClass myClass = new MyClass(10);
            // Read field
            int value = fieldRead(myClass);
            // Print value
            WriteLine(value); // 10
        }



        // Func<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.TryCreateFieldReadFuncOO(out Func<object, object> fieldRead);
            // Create class
            MyClass myClass = new MyClass(10);
            // Read field
            int value = (int)fieldRead(myClass);
            // Print value
            WriteLine(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
            Func<object, object> fieldRead = FieldReadFuncOO.Create[fieldDescription];
            // Create class
            MyClass myClass = new MyClass(10);
            // Read field
            int value = (int)fieldRead(myClass);
            // Print value
            WriteLine(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
            Func<object, object> fieldRead = FieldReadFuncOO.Cached[fieldDescription];
            // </22>
            // Create Class
            MyClass myClass = new MyClass(10);
            // Read field
            int value = (int)fieldRead(myClass);
            // Print value
            WriteLine(value); // 10
        }
        {
            // <23>
            // Get field reference
            FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
            // Create delegate
            Func<object, object> fieldRead = FieldReadFuncOO.CreateFromObject[fi];
            // </23>
            // Create Class
            MyClass myClass = new MyClass(10);
            // Read field
            int value = (int)fieldRead(myClass);
            // Print value
            WriteLine(value); // 10
        }
        {
            // Get field reference
            FieldInfo fi = typeof(MyClass).GetField(nameof(MyClass.value))!;
            // <24>
            // Get (weak key) cached delegate
            Func<object, object> fieldRead = FieldReadFuncOO.CachedFromObject[fi];
            // </24>
            // Create Class
            MyClass myClass = new MyClass(10);
            // Read field
            int value = (int)fieldRead(myClass);
            // Print value
            WriteLine(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>
}