IDictionary

AccessorRequest<NetMap> requests a map accessor for .NET types that implement IDictionary<,>. (Avalanche.Accessor.Net.dll)

// Create request
AccessorRequest request = new AccessorRequest(new NetMap(typeof(Dictionary<string, int>)));
// Issue request
IMapAccessor<Dictionary<string, int>, string, int> accessor =
    Services.Create(NetAccessorHandlers.Instance)
    .GetRequired<IRequest, IMapAccessor<Dictionary<string, int>, string, int>>(request);

Query

AccessorRequest(target) requests a IAccessor depending on type target.

// Create request
AccessorRequest request = new AccessorRequest(new NetMap(typeof(Dictionary<string, int>)));
// Issue request
IMapAccessor<Dictionary<string, int>, string, int> accessor =
    Services.Create(NetAccessorHandlers.Instance)
    .GetRequired<IRequest, IMapAccessor<Dictionary<string, int>, string, int>>(request);

MapAccessorRequest(target) requests a IMapAccessor<Map, Element> for .NET types that implement IDictionary<,>.

// Create request
MapAccessorRequest request = new MapAccessorRequest(new NetMap(typeof(Dictionary<string, int>)));
// Issue request
IMapAccessor<Dictionary<string, int>, string, int> accessor =
    Services.Create(NetAccessorHandlers.Instance)
    .GetRequired<IRequest, IMapAccessor<Dictionary<string, int>, string, int>>(request);

MapAccessorRequest is specifically a request for specific writers. Each can be assigned with explicit customization.

// Create service
IService service = Services.Create(NetAccessorHandlers.Instance);
// Create container target
IContainerTarget target = new NetMap(typeof(Dictionary<string, int>));
// Create request
IRequestFor<IMapAccessor> request = new MapAccessorRequest
{
    Constructor = new ConstructorRequest(target),
    Deconstructor = new DeconstructorRequest(target),
    DefaultConstructor = new DefaultConstructorRequest(target),
    Remove = new RemoveRequest(target),
    Get = new GetRequest(target),
    Set = new SetRequest(target),
    Clear = new ClearRequest(target),
    Count = new CountRequest(target),
    IsAssigned = new IsAssignedRequest(target),
    Unassign = new UnassignRequest(target),
    ContainerType = new ContainerTypeRequest(target),
    KeyType = new KeyTypeRequest(target),
    ValueType = new ValueTypeRequest(target),
    Referer = new RefererRequest(target),
};
// Issue request
IMapAccessor<Dictionary<string, int>, string, int> accessor = service.GetRequired<IRequest, IMapAccessor<Dictionary<string, int>, string, int>>(request);

Accessor can be acquired from Microsoft's dependency injection implementation.

IMapAccessor<Dictionary<string, int>> accessor =
    Services.Create(NetAccessorHandlers.Instance)
    .GetMapAccessor<Dictionary<string, int>>();

If dependency injection is used, MapAccessorRequest can be issued with service request to IMapAccessor<L>.

IMapAccessor<Dictionary<string, int>> accessor =
    Services.Create(NetAccessorHandlers.Instance)
    .GetRequiredService<IMapAccessor<Dictionary<string, int>>>();

Usage

.DefaultConstructor creates a map with default value.

Dictionary<string, int> map = accessor.DefaultConstructor.Read();

.Constructor creates a map from enumerable of elements.

Dictionary<string, int> map = accessor.Constructor.ReadAs<IEnumerable<KeyValuePair<string, int>>, Dictionary<string, int>>(new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } });

.Deconstructor reads values as an enumerable.

Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
IEnumerable<KeyValuePair<string, int>> deconstruction = accessor.Deconstructor.Read(map);

.Remove removes an element at index.

Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
accessor.Remove.Write("B", map);

.Get reads an element at index.

Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
int value = accessor.Get.Read((map, "B"));

.Set assigns an element at index.

Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
accessor.Set.Write(("D", 10), map);

.Clear removes all elements.

Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
accessor.Clear.Write(default, map);

.Count returns the number of elements.

Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
long count = accessor.Count.Read(map);

.IsAssigned tests whether a map is assigned in container.

Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
bool nonNull = accessor.IsAssigned.Read(map);

.Unassign removes map at container.

Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
accessor.Unassign.Write(default, ref map);

.Referer get a reference to element.

Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
ref int element = ref ((IReferer<(Dictionary<string, int>, string), int>)accessor.Referer).GetReference((map, "B"));

Writers

Writers for IDictionary<> types can be constructed separately without IService.

MapConstructor.Create(type) creates constructor for any IDictionary<>.

IWriterToRef<IEnumerable<KeyValuePair<string, int>>, Dictionary<string, int>> mapConstructor =
    (IWriterToRef<IEnumerable<KeyValuePair<string, int>>, Dictionary<string, int>>)
    MapConstructor.Create(typeof(Dictionary<string, int>));
KeyValuePair<string, int>[] values = new[] { new KeyValuePair<string, int>("A", 1), new KeyValuePair<string, int>("B", 2), new KeyValuePair<string, int>("C", 3) };
Dictionary<string, int> map = mapConstructor.Read(values);

Constructor can be adapted from a delegate.

IWriterToRef<IEnumerable<KeyValuePair<string, int>>, Dictionary<string, int>> mapConstructor = DelegateWriter.Reader((IEnumerable<KeyValuePair<string, int>> enumr) => new Dictionary<string, int>(enumr));
KeyValuePair<string, int>[] values = new[] { new KeyValuePair<string, int>("A", 1), new KeyValuePair<string, int>("B", 2), new KeyValuePair<string, int>("C", 3) };
Dictionary<string, int> map = mapConstructor.Read(values);

MapDeconstructor.Create(type) creates deconstructor for any IDictionary<>.

IWriterToRef<Dictionary<string, int>, IEnumerable<KeyValuePair<string, int>>> mapDeconstructor =
    (IWriterToRef<Dictionary<string, int>, IEnumerable<KeyValuePair<string, int>>>)
    MapDeconstructor.Create(typeof(Dictionary<string, int>));
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
IEnumerable<KeyValuePair<string, int>> enumr = mapDeconstructor.Read(map);

Deconstructor can be adapted from a delegate.

IWriterToRef<Dictionary<string, int>, IEnumerable<KeyValuePair<string, int>>> mapDeconstructor =
    DelegateWriter.Reader<Dictionary<string, int>, IEnumerable<KeyValuePair<string, int>>>((Dictionary<string, int> map) => map.ToArray());
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
IEnumerable<KeyValuePair<string, int>> enumr = mapDeconstructor.Read(map);

DefaultConstructor.Create(type) creates default instance for types that have a no parameter constructor.

var defaultConstructor = (IWriterToRef<Avalanche.Void, Dictionary<string, int>>)DefaultConstructor.Create(typeof(Dictionary<string, int>));
Dictionary<string, int> list = defaultConstructor.Read();

DefaultConstructor can be adapted from a delegate.

var defaultConstructor = DelegateWriter.Reader<Avalanche.Void, Dictionary<string, int>>(@void => new Dictionary<string, int>());

MapRemove.Create(listType, elementType) creates element remover.

// Create writer
IWriterBase<string, Dictionary<string, int>> mapRemove =
    (IWriterBase<string, Dictionary<string, int>>)
    MapRemove.Create(typeof(Dictionary<string, int>));
// Create map
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
// Remove key
mapRemove.Write("B", map);

Map element remover can be adapted from delegate.

IWriter<string, Dictionary<string, int>> mapRemove =
    DelegateWriter.Writer((string key, Dictionary<string, int> map) => map.Remove(key));
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
mapRemove.Write("B", map);

MapGet.Create(listType, elementType) creates getter.

IWriterToRef<(Dictionary<string, int>, string), int> mapGet =
    (IWriterToRef<(Dictionary<string, int>, string), int>)
    MapGet.Create(typeof(Dictionary<string, int>));
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
int value = mapGet.Read((map, "B"));

Map getter can be adapted from delegate.

IWriterToRef<(Dictionary<string, int>, string), int> mapGet =
    DelegateWriter.Writer<(Dictionary<string, int>, string), int>(
        ((Dictionary<string, int> map, string key) args, ref int value) =>
        args.map.TryGetValue(args.key, out value)
    );
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
int value = mapGet.Read((map, "B"));

MapSet.Create(listType, elementType) creates setter.

IWriter<(string, int), Dictionary<string, int>> mapSet =
    (IWriter<(string, int), Dictionary<string, int>>)
    MapSet.Create(typeof(Dictionary<string, int>));
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
mapSet.Write(("Z", 32), map);

Map setter can be adapted from delegate.

IWriter<(string, int), Dictionary<string, int>> mapSet =
    DelegateWriter.Writer<(string, int), Dictionary<string, int>>(
        ((string key, int value) args, Dictionary<string, int> map) =>
        map[args.key] = args.value
    );
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
mapSet.Write(("Z", 32), map);

MapClear.Create(listType, elementType) creates list element clearer.

IWriter<Avalanche.Void, Dictionary<string, int>> mapClear =
    (IWriter<Avalanche.Void, Dictionary<string, int>>)
    MapClear.Create(typeof(Dictionary<string, int>));
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
mapClear.Write(default, map);

Map clearer can be adapted from delegate.

IWriter<Avalanche.Void, Dictionary<string, int>> mapClear = DelegateWriter.Invoke<Dictionary<string, int>>(map => map.Clear());
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
mapClear.Write(default, map);

MapCount.Create(listType, elementType) creates list element counter.

IWriterToRef<Dictionary<string, int>, long> mapCount =
    (IWriterToRef<Dictionary<string, int>, long>)
    MapCount.Create(typeof(Dictionary<string, int>));
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
long count = mapCount.Read(map);

Map counter can be adapted from delegate.

IWriterToRef<Dictionary<string, int>, long> mapCount =
    DelegateWriter.Reader<Dictionary<string, int>, long>(map => map.Count);
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
long count = mapCount.Read(map);

MapReferer.Create(listType, elementType) creates list element referer.

// Create referer
IReferer<(Dictionary<string, int>, string), int> referer = (IReferer<(Dictionary<string, int>, string), int>)MapReferer.Create(typeof(Dictionary<string, int>));
// Create map
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
// Get pointer to index '2'
ref int elementPointer = ref referer.GetReference((map, "A"));
// Read
WriteLine(elementPointer);
// Write
elementPointer = 100;
// Read
WriteLine(map["A"]);

RefererRequest queries referer from service.

// Create service
IService service = Services.Create((ServiceHandlers.Instance, AccessorHandlers.Instance, NetAccessorHandlers.Instance), CachePolicies.Default);
// Create request
IRequest request = new RefererRequest(new NetMap(typeof(Dictionary<string, int>)));
// Create referer
IReferer<(Dictionary<string, int>, string), int> referer = service.GetRequired<IRequest, IReferer<(Dictionary<string, int>, string), int>>(request);
// Create map
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
// Get pointer to index '2'
ref int elementPointer = ref referer.GetReference((map, "A"));
// Read
WriteLine(elementPointer);
// Write
elementPointer = 100;
// Read
WriteLine(map["A"]);

IsAssigned.Create(type) creates default assignment tester.

var isAssigned = (IWriterToRef<Dictionary<string, int>, bool>)IsAssigned.Create(typeof(Dictionary<string, int>));
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
bool assigned = isAssigned.Read(map);

Assignment tester can be adapted from delegate.

IWriterToRef<Dictionary<string, int>, bool> isAssigned = DelegateWriter.Reader<Dictionary<string, int>, bool>(list => list is not null);
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
bool assigned = isAssigned.Read(map);

Unassign.Create(type) creates conteiner nuller.

var isAssigned = (IWriterToRef<Dictionary<string, int>, bool>)IsAssigned.Create(typeof(Dictionary<string, int>));
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
bool assigned = isAssigned.Read(map);

Null assigner can be adapted from delegate.

IWriterToRef<Dictionary<string, int>, bool> isAssigned = DelegateWriter.Reader<Dictionary<string, int>, bool>(list => list is not null);
Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
bool assigned = isAssigned.Read(map);

Full Example

Full example

using System.Collections.Generic;
using System.Linq;
using Avalanche.Accessor;
using Avalanche.DataType;
using Avalanche.Service;
using Avalanche.Utilities;
using Avalanche.Writer;
using Microsoft.Extensions.DependencyInjection;
using static System.Console;

public class idictionary
{
    public static void Run()
    {
        {
            // <10>
            // Create request
            AccessorRequest request = new AccessorRequest(new NetMap(typeof(Dictionary<string, int>)));
            // Issue request
            IMapAccessor<Dictionary<string, int>, string, int> accessor =
                Services.Create(NetAccessorHandlers.Instance)
                .GetRequired<IRequest, IMapAccessor<Dictionary<string, int>, string, int>>(request);
            // </10>
        }
        {
            // <11>
            // Create request
            MapAccessorRequest request = new MapAccessorRequest(new NetMap(typeof(Dictionary<string, int>)));
            // Issue request
            IMapAccessor<Dictionary<string, int>, string, int> accessor =
                Services.Create(NetAccessorHandlers.Instance)
                .GetRequired<IRequest, IMapAccessor<Dictionary<string, int>, string, int>>(request);
            // </11>
        }
        {
            // <12>
            // Create service
            IService service = Services.Create(NetAccessorHandlers.Instance);
            // Create container target
            IContainerTarget target = new NetMap(typeof(Dictionary<string, int>));
            // Create request
            IRequestFor<IMapAccessor> request = new MapAccessorRequest
            {
                Constructor = new ConstructorRequest(target),
                Deconstructor = new DeconstructorRequest(target),
                DefaultConstructor = new DefaultConstructorRequest(target),
                Remove = new RemoveRequest(target),
                Get = new GetRequest(target),
                Set = new SetRequest(target),
                Clear = new ClearRequest(target),
                Count = new CountRequest(target),
                IsAssigned = new IsAssignedRequest(target),
                Unassign = new UnassignRequest(target),
                ContainerType = new ContainerTypeRequest(target),
                KeyType = new KeyTypeRequest(target),
                ValueType = new ValueTypeRequest(target),
                Referer = new RefererRequest(target),
            };
            // Issue request
            IMapAccessor<Dictionary<string, int>, string, int> accessor = service.GetRequired<IRequest, IMapAccessor<Dictionary<string, int>, string, int>>(request);
            // </12>
        }
        {
            // <13>
            IMapAccessor<Dictionary<string, int>> accessor =
                Services.Create(NetAccessorHandlers.Instance)
                .GetMapAccessor<Dictionary<string, int>>();
            // </13>
        }
        {
            // <14>
            IMapAccessor<Dictionary<string, int>> accessor =
                Services.Create(NetAccessorHandlers.Instance)
                .GetRequiredService<IMapAccessor<Dictionary<string, int>>>();
            // </14>
        }

        {
            IMapAccessor<Dictionary<string, int>, string, int> accessor = Services.Create(NetAccessorHandlers.Instance).GetRequiredService<IMapAccessor<Dictionary<string, int>, string, int>>();
            {
                // <51>
                Dictionary<string, int> map = accessor.DefaultConstructor.Read();
                // </51>
            }
            {
                // <52>
                Dictionary<string, int> map = accessor.Constructor.ReadAs<IEnumerable<KeyValuePair<string, int>>, Dictionary<string, int>>(new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } });
                // </52>
            }
            {
                // <53>
                Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
                IEnumerable<KeyValuePair<string, int>> deconstruction = accessor.Deconstructor.Read(map);
                // </53>
            }
            {
                // <56>
                Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
                accessor.Remove.Write("B", map);
                // </56>
            }
            {
                // <57>
                Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
                int value = accessor.Get.Read((map, "B"));
                // </57>
            }
            {
                // <58>
                Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
                accessor.Set.Write(("D", 10), map);
                // </58>
            }
            {
                // <60>
                Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
                accessor.Clear.Write(default, map);
                // </60>
            }
            {
                // <61>
                Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
                long count = accessor.Count.Read(map);
                // </61>
            }
            {
                // <62>
                Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
                bool nonNull = accessor.IsAssigned.Read(map);
                // </62>
            }
            {
                // <63>
                Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
                accessor.Unassign.Write(default, ref map);
                // </63>
            }
            {
                // <64>
                Dictionary<string, int> map = new Dictionary<string, int> { { "A", 7 }, { "B", 8 }, { "C", 9 } };
                ref int element = ref ((IReferer<(Dictionary<string, int>, string), int>)accessor.Referer).GetReference((map, "B"));
                // </64>
            }
        }

        // 81: Constructor
        {
#pragma warning disable CS0168
            // <00>
            IWriterToRef<IEnumerable<KeyValuePair<string, int>>, Dictionary<string, int>> mapConstructor;
            // </00>
#pragma warning restore CS0168
        }
        {
            // <81B>
            IWriterToRef<IEnumerable<KeyValuePair<string, int>>, Dictionary<string, int>> mapConstructor =
                (IWriterToRef<IEnumerable<KeyValuePair<string, int>>, Dictionary<string, int>>)
                MapConstructor.Create(typeof(Dictionary<string, int>));
            KeyValuePair<string, int>[] values = new[] { new KeyValuePair<string, int>("A", 1), new KeyValuePair<string, int>("B", 2), new KeyValuePair<string, int>("C", 3) };
            Dictionary<string, int> map = mapConstructor.Read(values);
            // </81B>
        }
        {
            // <81E>
            IWriterToRef<IEnumerable<KeyValuePair<string, int>>, Dictionary<string, int>> mapConstructor = DelegateWriter.Reader((IEnumerable<KeyValuePair<string, int>> enumr) => new Dictionary<string, int>(enumr));
            KeyValuePair<string, int>[] values = new[] { new KeyValuePair<string, int>("A", 1), new KeyValuePair<string, int>("B", 2), new KeyValuePair<string, int>("C", 3) };
            Dictionary<string, int> map = mapConstructor.Read(values);
            // </81E>
        }
        {
            // <81F>
            IRequestFor<IWriter> request = new ConstructorRequest(new NetMap(typeof(Dictionary<string, int>)));
            IWriterToRef<IEnumerable<KeyValuePair<string, int>>, Dictionary<string, int>> mapConstructor =
                Services.Create(NetAccessorHandlers.Instance)
                .GetRequired<IRequest, IWriterToRef<IEnumerable<KeyValuePair<string, int>>, Dictionary<string, int>>>(request);
            KeyValuePair<string, int>[] values = new[] { new KeyValuePair<string, int>("A", 1), new KeyValuePair<string, int>("B", 2), new KeyValuePair<string, int>("C", 3) };
            Dictionary<string, int> map = mapConstructor.Read(values);
            // </81F>
        }

        // 82: Deconstructor
        {
#pragma warning disable CS0168
            // <00>
            IWriterToRef<Dictionary<string, int>, IEnumerable<KeyValuePair<string, int>>> mapDeconstructor;
            // </00>
#pragma warning restore CS0168
        }
        {
            // <82B>
            IWriterToRef<Dictionary<string, int>, IEnumerable<KeyValuePair<string, int>>> mapDeconstructor =
                (IWriterToRef<Dictionary<string, int>, IEnumerable<KeyValuePair<string, int>>>)
                MapDeconstructor.Create(typeof(Dictionary<string, int>));
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            IEnumerable<KeyValuePair<string, int>> enumr = mapDeconstructor.Read(map);
            // </82B>
        }
        {
            // <82E>
            IWriterToRef<Dictionary<string, int>, IEnumerable<KeyValuePair<string, int>>> mapDeconstructor =
                DelegateWriter.Reader<Dictionary<string, int>, IEnumerable<KeyValuePair<string, int>>>((Dictionary<string, int> map) => map.ToArray());
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            IEnumerable<KeyValuePair<string, int>> enumr = mapDeconstructor.Read(map);
            // </82E>
        }

        // 83: DefaultConstructor
        {
#pragma warning disable CS0168
            // <83>
            IWriterToRef<Avalanche.Void, Dictionary<string, int>> defaultConstructor;
            // </83>
#pragma warning restore CS0168
        }
        {
            // <83B>
            var defaultConstructor = (IWriterToRef<Avalanche.Void, Dictionary<string, int>>)DefaultConstructor.Create(typeof(Dictionary<string, int>));
            Dictionary<string, int> list = defaultConstructor.Read();
            // </83B>
        }
        {
            // <83E>
            var defaultConstructor = DelegateWriter.Reader<Avalanche.Void, Dictionary<string, int>>(@void => new Dictionary<string, int>());
            // </83E>
        }
        {
            // <83F>
            DefaultConstructorRequest request = new DefaultConstructorRequest(new NetMap(typeof(Dictionary<string, int>)));
            IWriterToRef<Avalanche.Void, Dictionary<string, int>> defaultConstructor =
                Services.Create(NetAccessorHandlers.Instance)
                .GetRequired<DefaultConstructorRequest, IWriterToRef<Avalanche.Void, Dictionary<string, int>>>(request);
            // </83F>
        }

        // 86: Remove
        {
#pragma warning disable CS0168
            // <86>
            IWriterBase<string, Dictionary<string, int>> mapRemove;
            // </86>
#pragma warning restore CS0168
        }
        {
            // <86B>
            // Create writer
            IWriterBase<string, Dictionary<string, int>> mapRemove =
                (IWriterBase<string, Dictionary<string, int>>)
                MapRemove.Create(typeof(Dictionary<string, int>));
            // Create map
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            // Remove key
            mapRemove.Write("B", map);
            // </86B>
        }
        {
            // <86E>
            IWriter<string, Dictionary<string, int>> mapRemove =
                DelegateWriter.Writer((string key, Dictionary<string, int> map) => map.Remove(key));
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            mapRemove.Write("B", map);
            // </86E>
        }
        {
            // <86F>
            IRequestFor<IWriter> request = new RemoveRequest(new NetMap(typeof(Dictionary<string, int>)));
            IWriter<string, Dictionary<string, int>> mapRemove = Services.Create(NetAccessorHandlers.Instance).GetRequired<IRequest, IWriter<string, Dictionary<string, int>>>(request);
            // Create map
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            // Remove element to map
            mapRemove.Write("B", map);
            // </86F>
        }

        // 87: Get
        {
#pragma warning disable CS0168
            // <87>
            IWriterToRef<(Dictionary<string, int>, string), int> mapGet;
            // </87>
#pragma warning restore CS0168
        }
        {
            // <87A>
            IWriterToRef<(Dictionary<string, int>, string), int> mapGet = new MapGet<Dictionary<string, int>, string, int>();
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            int value = mapGet.Read((map, "B"));
            // </87A>
        }
        {
            // <87B>
            IWriterToRef<(Dictionary<string, int>, string), int> mapGet =
                (IWriterToRef<(Dictionary<string, int>, string), int>)
                MapGet.Create(typeof(Dictionary<string, int>));
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            int value = mapGet.Read((map, "B"));
            // </87B>
        }
        {
            // <87E>
            IWriterToRef<(Dictionary<string, int>, string), int> mapGet =
                DelegateWriter.Writer<(Dictionary<string, int>, string), int>(
                    ((Dictionary<string, int> map, string key) args, ref int value) =>
                    args.map.TryGetValue(args.key, out value)
                );
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            int value = mapGet.Read((map, "B"));
            // </87E>
        }
        {
            // <87F>
            GetRequest mapRequest = new GetRequest(new NetMap(typeof(Dictionary<string, int>)));
            IWriterToRef<(Dictionary<string, int>, string), int> mapGet =
                Services.Create(NetAccessorHandlers.Instance)
                .GetRequired<GetRequest, IWriterToRef<(Dictionary<string, int>, string), int>>(mapRequest);
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            int value = mapGet.Read((map, "B"));
            // </87F>
        }

        // 88: Set
        {
#pragma warning disable CS0168
            // <88>
            IWriter<(string, int), Dictionary<string, int>> mapSet;
            // </88>
#pragma warning restore CS0168
        }
        {
            // <88A>
            IWriter<(string, int), Dictionary<string, int>> mapSet = new MapSet<Dictionary<string, int>, string, int>();
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            mapSet.Write(("Z", 32), map);
            // </88A>
        }
        {
            // <88B>
            IWriter<(string, int), Dictionary<string, int>> mapSet =
                (IWriter<(string, int), Dictionary<string, int>>)
                MapSet.Create(typeof(Dictionary<string, int>));
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            mapSet.Write(("Z", 32), map);
            // </88B>
        }
        {
            // <88E>
            IWriter<(string, int), Dictionary<string, int>> mapSet =
                DelegateWriter.Writer<(string, int), Dictionary<string, int>>(
                    ((string key, int value) args, Dictionary<string, int> map) =>
                    map[args.key] = args.value
                );
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            mapSet.Write(("Z", 32), map);
            // </88E>
        }
        {
            // <88F>
            SetRequest mapRequest = new SetRequest(new NetMap(typeof(Dictionary<string, int>)));
            IWriter<(string, int), Dictionary<string, int>> mapSet =
                Services.Create(NetAccessorHandlers.Instance)
                .GetRequired<SetRequest, IWriter<(string, int), Dictionary<string, int>>>(mapRequest);
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            mapSet.Write(("Z", 32), map);
            // </88F>
        }

        // 89: Clear
        {
#pragma warning disable CS0168
            // <89>
            IWriter<Avalanche.Void, Dictionary<string, int>> mapClear;
            // </89>
#pragma warning restore CS0168
        }
        {
            // <89A>
            IWriter<Avalanche.Void, Dictionary<string, int>> mapClear = new MapClear<Dictionary<string, int>, string, int>();
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            mapClear.Write(default, map);
            // </89A>
        }
        {
            // <89B>
            IWriter<Avalanche.Void, Dictionary<string, int>> mapClear =
                (IWriter<Avalanche.Void, Dictionary<string, int>>)
                MapClear.Create(typeof(Dictionary<string, int>));
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            mapClear.Write(default, map);
            // </89B>
        }
        {
            // <89E>
            IWriter<Avalanche.Void, Dictionary<string, int>> mapClear = DelegateWriter.Invoke<Dictionary<string, int>>(map => map.Clear());
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            mapClear.Write(default, map);
            // </89E>
        }
        {
            // <89F>
            ClearRequest mapRequest = new ClearRequest(new NetMap(typeof(Dictionary<string, int>)));
            IWriter<Avalanche.Void, Dictionary<string, int>> mapClear =
                Services.Create(NetAccessorHandlers.Instance)
                .GetRequired<ClearRequest, IWriter<Avalanche.Void, Dictionary<string, int>>>(mapRequest);
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            mapClear.Write(default, map);
            // </89F>
        }

        // 90: Count
        {
#pragma warning disable CS0168
            // <90>
            IWriterToRef<Dictionary<string, int>, long> mapCount;
            // </90>
#pragma warning restore CS0168
        }
        {
            // <90A>
            IWriterToRef<Dictionary<string, int>, long> mapCount = new MapCount<Dictionary<string, int>, string, int>();
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            long count = mapCount.Read(map);
            // </90A>
        }
        {
            // <90B>
            IWriterToRef<Dictionary<string, int>, long> mapCount =
                (IWriterToRef<Dictionary<string, int>, long>)
                MapCount.Create(typeof(Dictionary<string, int>));
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            long count = mapCount.Read(map);
            // </90B>
        }
        {
            // <90E>
            IWriterToRef<Dictionary<string, int>, long> mapCount =
                DelegateWriter.Reader<Dictionary<string, int>, long>(map => map.Count);
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            long count = mapCount.Read(map);
            // </90E>
        }
        {
            // <90F>
            CountRequest mapRequest = new CountRequest(new NetMap(typeof(Dictionary<string, int>)));
            IWriterToRef<Dictionary<string, int>, long> mapCount =
                Services.Create(NetAccessorHandlers.Instance)
                .GetRequired<CountRequest, IWriterToRef<Dictionary<string, int>, long>>(mapRequest);
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            long count = mapCount.Read(map);
            // </90F>
        }

        // 91: Referer
        {
            // <91A>
            // Create referer
            IReferer<(Dictionary<string, int>, string), int> referer = (IReferer<(Dictionary<string, int>, string), int>)MapReferer.Create(typeof(Dictionary<string, int>));
            // Create map
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            // Get pointer to index '2'
            ref int elementPointer = ref referer.GetReference((map, "A"));
            // Read
            WriteLine(elementPointer);
            // Write
            elementPointer = 100;
            // Read
            WriteLine(map["A"]);
            // </91A>
        }
        {
            // <91C>
            // Create service
            IService service = Services.Create((ServiceHandlers.Instance, AccessorHandlers.Instance, NetAccessorHandlers.Instance), CachePolicies.Default);
            // Create request
            IRequest request = new RefererRequest(new NetMap(typeof(Dictionary<string, int>)));
            // Create referer
            IReferer<(Dictionary<string, int>, string), int> referer = service.GetRequired<IRequest, IReferer<(Dictionary<string, int>, string), int>>(request);
            // Create map
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            // Get pointer to index '2'
            ref int elementPointer = ref referer.GetReference((map, "A"));
            // Read
            WriteLine(elementPointer);
            // Write
            elementPointer = 100;
            // Read
            WriteLine(map["A"]);
            // </91C>
        }

        // 98: IsAssigned
        {
            // <98A>
            IWriterToRef<Dictionary<string, int>, bool> isAssigned = new IsAssigned<Dictionary<string, int>>();
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            bool assigned = isAssigned.Read(map);
            // </98A>
        }
        {
            // <98B>
            var isAssigned = (IWriterToRef<Dictionary<string, int>, bool>)IsAssigned.Create(typeof(Dictionary<string, int>));
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            bool assigned = isAssigned.Read(map);
            // </98B>
        }
        {
            // <98E>
            IWriterToRef<Dictionary<string, int>, bool> isAssigned = DelegateWriter.Reader<Dictionary<string, int>, bool>(list => list is not null);
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            bool assigned = isAssigned.Read(map);
            // </98E>
        }
        {
            // <98F>
            IsAssignedRequest isAssignedRequest = new IsAssignedRequest(new NetList(typeof(Dictionary<string, int>)));
            IWriterToRef<Dictionary<string, int>, bool> isAssigned =
                Services.Create(NetAccessorHandlers.Instance)
                .GetRequired<IsAssignedRequest, IWriterToRef<Dictionary<string, int>, bool>>(isAssignedRequest);
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            bool assigned = isAssigned.Read(map);
            // </98F>
        }

        // 99: Unassign
        {
            // <99A>
            IWriterToRef<Avalanche.Void, Dictionary<string, int>> unassign = new Unassign<Dictionary<string, int>>();
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            unassign.Write(default, ref map);
            // </99A>
            }
        {
            // <99B>
            var unassign = (IWriterToRef<Avalanche.Void, Dictionary<string, int>>)Unassign.Create(typeof(Dictionary<string, int>));
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            unassign.Write(default, ref map);
            // </99B>
        }
        {
            // <99E>
            IWriterToRef<Avalanche.Void, Dictionary<string, int>> unassign = DelegateWriter.Writer((Avalanche.Void @void, ref Dictionary<string, int> list) => list = null!);
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            unassign.Write(default, ref map);
            // </99E>
        }
        {
            // <99F>
            UnassignRequest unassignRequest = new UnassignRequest(new NetList(typeof(Dictionary<string, int>)));
            IWriterToRef<Avalanche.Void, Dictionary<string, int>> unassign =
                Services.Create(NetAccessorHandlers.Instance)
                .GetRequired<UnassignRequest, IWriterToRef<Avalanche.Void, Dictionary<string, int>>>(unassignRequest);
            Dictionary<string, int> map = new Dictionary<string, int> { { "A", 1 }, { "B", 2 }, { "C", 3 } };
            unassign.Write(default, ref map);
            // </99F>
        }


    }
}