Aerotech系列（6）Aerotech运动控制器回调机制的管理器

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using Aerotech.A3200.Exceptions;
using Aerotech.A3200.SystemDLLWrapper;

namespace Aerotech.A3200.Callbacks;

internal class CallbackRegistrar
{
    private class PerTaskCallbackHandler : IDisposable
    {
        private static readonly Dictionary<int, TypeCode> callbackTypeMappings;

        private readonly object listenLock = new object();

        private readonly Thread listener;

        private readonly ControllerHandle hAerCtrl;

        private readonly Dictionary<int, EventHandler<CallbackOccurredEventArgs>> registeredCallbacks = new Dictionary<int, EventHandler<CallbackOccurredEventArgs>>();

        private readonly Controller controller;

        private readonly CallbackRegistrar callbackRegistrar;

        private readonly TaskId task;

        private volatile bool shouldExit;

        private bool disposed;

        private volatile bool shouldListen = true;

        public TaskId TaskId => task;

        private bool Listening
        {
            get
            {
                lock (listenLock)
                {
                    return shouldListen;
                }
            }
            set
            {
                lock (listenLock)
                {
                    shouldListen = value;
                    if (shouldListen)
                    {
                        Monitor.Pulse(listenLock);
                    }
                    else
                    {
                        ExceptionResolver.ResolveThrow(Wrapper.AerCallbackWaitCancel(hAerCtrl.Value));
                    }
                }
            }
        }

        internal event EventHandler<CallbackErrorEventArgs> ErrorOccurred;

        static PerTaskCallbackHandler()
        {
            callbackTypeMappings = new Dictionary<int, TypeCode>();
            callbackTypeMappings[0] = TypeCode.Int32;
            callbackTypeMappings[1] = TypeCode.Double;
            callbackTypeMappings[3] = TypeCode.String;
        }

        public PerTaskCallbackHandler(Controller controller, CallbackRegistrar callbackRegistrar, TaskId task)
        {
            hAerCtrl = controller.Tasks.AllTasks[(int)task].TaskControllerHandle;
            this.controller = controller;
            this.callbackRegistrar = callbackRegistrar;
            this.task = task;
            listener = new Thread(InternalUtilities.WrapDelegateForCulture(listenForCallbacks));
            listener.Name = $"Callback listener ({this.task})";
            listener.IsBackground = true;
        }

        internal bool GetCanRegister(int callbackNumber)
        {
            lock (registeredCallbacks)
            {
                if (registeredCallbacks.ContainsKey(callbackNumber))
                {
                    return true;
                }
            }

            int pdwCount_ = 0;
            ExceptionResolver.ResolveThrow(Wrapper.AerIntCommServiceGetRegisteredInterruptCount(hAerCtrl.Value, 1, callbackNumber, (int)TaskId, ref pdwCount_));
            return pdwCount_ == 0;
        }

        void IDisposable.Dispose()
        {
            Dispose(disposing: true);
        }

        private void Dispose(bool disposing)
        {
            if (!(!disposed && disposing))
            {
                return;
            }

            lock (registeredCallbacks)
            {
                Listening = false;
                foreach (int key in registeredCallbacks.Keys)
                {
                    Wrapper.AerCallbackUnregister(hAerCtrl.Value, (int)task, key);
                }

                registeredCallbacks.Clear();
                hAerCtrl.Dispose();
                shouldExit = true;
                Listening = true;
            }

            disposed = true;
        }

        public voi