Compartir a través de

Introducción a los subprocesos del lector de objetos de servicio (documentación de POS para el SDK de .NET v1.14)

La mayoría de los objetos de servicio deben poder responder a eventos de hardware de forma asincrónica iniciando un subproceso del lector de hardware independiente. Los objetos de servicio son el vínculo entre la aplicación de punto de servicio y el hardware. Por lo tanto, los objetos de servicio deben leer datos del hardware asociado mientras siguen estando disponibles para la aplicación.

En esta sección, se muestra una manera de implementar el código necesario para los objetos de servicio con varios subprocesos.

Requisitos

Para compilar este código, la aplicación debe incluir una referencia al espacio de nombres System.Threading.

En el ejemplo siguiente, se implementa una clase auxiliar de subprocesos que pueden usar las implementaciones de objetos de servicio, pero no se compila ni se ejecuta por sí misma.

Muestra

En este ejemplo, se muestra cómo pueden usar subprocesos los objetos de servicio para admitir la supervisión de eventos de hardware de forma asincrónica. El código de ejemplo implementa una clase auxiliar de subprocesos que se puede usar para agregar compatibilidad básica con subprocesos a un objeto de servicio.

Para usar la clase auxiliar de subprocesos proporcionada en esta sección, deberá crear una clase derivada de ServiceObjectThreadHelper, que se incluye en el código siguiente, e implementar los métodos siguientes:

  • ServiceObjectThreadOpen Se llama a este método desde el método OpenThread de la clase auxiliar de subprocesos una vez completada la inicialización. Implemente aquí cualquier código de inicialización específico del hardware. Este método es virtual. La implementación predeterminada simplemente vuelve.

  • ServiceObjectThreadClose Se llama a este método cuando el objeto auxiliar de subprocesos termina su subproceso o al llamar al método Dispose y se debe usar para liberar los manipuladores no administrados u otros recursos relacionados con el dispositivo. Este método es virtual. La implementación predeterminada simplemente vuelve.

  • ServiceObjectProcedure Este método se invocará una vez que se haya realizado toda la inicialización y el subproceso se haya iniciado correctamente. Este método es abstracto y se debe implementar en la clase derivada de la clase auxiliar de subprocesos. El método ServiceObjectProcedure toma un único argumento, un manipulador ManualEvent. El procedimiento del subproceso debe salir cuando se establece este identificador. Esto se hace llamando a ManualEvent.WaitOne dentro de un bucle while. Por ejemplo:

    
    while (true)
    {
        // Wait for a hardware event or the thread stop event.

        // Test to see if the thread terminated event is set and
        // exit the thread if so.
        if (ThreadStopEvent.WaitOne(0, false))
        {
           break;
        }

        // The thread is not terminating, so it must be a
        // a hardware event.
    }

Ejemplo

using System;
using System.Threading;
using Microsoft.PointOfService;

namespace Samples.ServiceObjects.Advanced
{
    // The following code implements a thread helper class.
    // This class may be used by other Point Of Service
    // samples which may require a separate thread for monitoring
    // hardware.
    public abstract class ServiceObjectThreadHelper : IDisposable
    {
        // The thread object which will wait for data from the POS
        // device.
        private Thread ReadThread;

        // These events signal that the thread is starting or stopping.
        private AutoResetEvent ThreadTerminating;
        private AutoResetEvent ThreadStarted;

        // Keeps track of whether or not a thread should
        // be running.
        bool ThreadWasStarted;

        public ServiceObjectThreadHelper()
        {
            // Create events to signal the reader thread.
            ThreadTerminating = new AutoResetEvent(false);
            ThreadStarted = new AutoResetEvent(false);

            ThreadWasStarted = false;

            // You need to handle the ApplicationExit event so
            // that you can properly clean up the thread.
            System.Windows.Forms.Application.ApplicationExit +=
                        new EventHandler(Application_ApplicationExit);
        }

        ~ServiceObjectThreadHelper()
        {
            Dispose(true);
        }

        public virtual void ServiceObjectThreadOpen()
        {
            return;
        }

        public virtual void ServiceObjectThreadClose()
        {
            return;
        }

        // This is called when the thread starts successfully and
        // will be run on the new thread.
        public abstract void ServiceObjectThreadProcedure(
                AutoResetEvent ThreadStopEvent);

        private bool IsDisposed = false;
        protected virtual void Dispose(bool disposing)
        {
            if (!IsDisposed)
            {
                try
                {
                    if (disposing == true)
                    {
                        CloseThread();
                    }
                }
                finally
                {
                    IsDisposed = true;
                }
            }
        }

        public void Dispose()
        {
            Dispose(true);

            // This object has been disposed of, so no need for
            // the GC to call the finalization code again.
            GC.SuppressFinalize(this);
        }

        public void OpenThread()
        {
            try
            {
                // Check to see if this object is still valid.
                if (IsDisposed)
                {
                    // Throw system exception to indicate that
                        // the object has already been disposed.
                    throw new ObjectDisposedException(
                            "ServiceObjectSampleThread");
                }

                // In case the application has called OpenThread
                // before calling CloseThread, stop any previously
                // started thread.
                SignalThreadClose();

                ServiceObjectThreadOpen();

                // Reset event used to signal the thread to quit.
                ThreadTerminating.Reset();

                // Reset the event that used by the thread to signal
                // that it has started.
                ThreadStarted.Reset();

                // Create the thread object and give it a name. The
                // method used here, ThreadMethod, is a wrapper around
                // the actual thread procedure, which will be run in
                // the threading object provided by the Service
                // Object.
                ReadThread = new Thread(
                        new ThreadStart(ThreadMethod));

                // Set the thread background mode.
                ReadThread.IsBackground = false;

                // Finally, attempt to start the thread.
                ReadThread.Start();

                // Wait for the thread to start, or until the time-out
                // is reached.
                if (!ThreadStarted.WaitOne(3000, false))
                {
                    // If the time-out was reached before the event
                    // was set, then throw an exception.
                    throw new PosControlException(
                            "Unable to open the device for reading",
                            ErrorCode.Failure);
                }

                // The thread has started successfully.
                ThreadWasStarted = true;
            }
            catch (Exception e)
            {
                // If an error occurred, be sure the new thread is
                // stopped.
                CloseThread();

                // Re-throw to let the application handle the
                // failure.
                throw;
            }
        }

        private void SignalThreadClose()
        {
            if(ThreadTerminating != null && ThreadWasStarted)
            {
                // Tell the thread to terminate.
                ThreadTerminating.Set();

                // Give the thread a few seconds to end.
                ThreadStarted.WaitOne(10000, false);

                // Mark the thread as being terminated.
                ThreadWasStarted = false;
            }
        }

        public void CloseThread()
        {
            // Signal the thread that it should stop.
            SignalThreadClose();

            // Call back into the SO for any cleanup.
            ServiceObjectThreadClose();
        }

        private void Application_ApplicationExit(
                            object sender,
                            EventArgs e)
        {
            SignalThreadClose();
        }

        // This is the method run on the new thread. First it signals
        // the caller indicating that the thread has started
        // correctly. Next, it calls the service object's thread
        // method which will loop waiting for data or a signal
        // to close.
        private void ThreadMethod()
        {
            try
            {
                // Set the event to indicate that the thread has
                // started successfully.
                ThreadStarted.Set();

                // Call into the thread procedure defined by the
                // Service Object.
                ServiceObjectThreadProcedure(ThreadTerminating);

                // Signal that the thread procedure is exiting.
                ThreadStarted.Set();
            }
            catch (Exception e)
            {
                Logger.Info("ServiceObjectThreadHelper",
                        "ThreadMethod Exception = " + e.ToString());
                throw;
            }
        }
    }
}

Consulte también

Tareas

Otros recursos

  • Last updated on