Exemplo de LineDisplay (documentação do SDK do PDV para .NET v1.14)

A LineDisplayBase classe é uma camada de abstração relativamente fina quando comparada a outras classes Base de Objeto de Serviço — há pouco código necessário entre o aplicativo e o dispositivo físico. O LineDisplay objeto de serviço simplesmente precisa anunciar quais recursos o dispositivo físico suporta e modificar sua saída de acordo com as propriedades de exibição que o aplicativo definiu.

Um objeto de serviço LineDisplay também pode monitorar o dispositivo e relatar energia ou outras alterações de status de volta para o aplicativo usando um StatusUpdateEvent. Isso pode ser feito usando os métodos Queue ou, por exemplo, usando os recursos de relatório de energia no PosCommon. Monitorar o dispositivo dessa maneira geralmente exigirá iniciar um novo thread para aguardar eventos de hardware e enfileirar o StatusUpdateEvent apropriado. Um objeto de serviço LineDisplay também pode enviar DirectIOEvents para o aplicativo.

Para implementar a classe e os atributos LineDisplay

1. Adicione diretivas usando para os namespaces Microsoft.PointOfService e Microsoft.PointOfService.BaseServiceObject .

2. Adicione o atributo PosAssemblyAttribute global para que o PosExplorer reconheça isso como um assembly do Microsoft Point of Service for .NET (POS para .NET).

3. Crie uma nova classe que é derivada de LineDisplayBase.

4. Adicione o atributo ServiceObjectAttribute de nível de classe à sua nova classe para que o PosExplorer o reconheça como um objeto de serviço.

Para implementar membros abstratos do LineDisplayBase

1. Todos os objetos de serviço LineDisplay devem suportar pelo menos um modo de tela. Para fornecer ao aplicativo detalhes sobre os modos de tela suportados, implemente a propriedade LineDisplayScreenModesabstrata .

2. No mínimo, todos os objetos de serviço LineDisplay devem ser implementados DisplayData(Cell[]) para exibir caracteres no dispositivo de saída.

Capacidades adicionais

Defina as propriedades de capacidade no seu Objeto de Serviço para anunciar o suporte para os recursos do seu dispositivo. Este exemplo demonstra como implementar o recurso de piscar LineDisplay.

Para implementar o recurso de piscar

1. No construtor, defina a CapBlink propriedade como DisplayBlink.All ou DisplayBlink.Each para indicar qual modo de piscar este objeto de serviço suporta.

2. Defina a propriedade CapBlink como trueindicando que a taxa de piscar pode ser definida pelo aplicativo chamando BlinkRate.

3. Leve essas e outras configurações em consideração ao implementar DisplayData.

Exemplo

using System;
using System.Collections.Generic;
using System.Text;

using Microsoft.PointOfService;
using Microsoft.PointOfService.BaseServiceObjects;

[assembly: PosAssembly("Service Object Contractors, Inc.")]

namespace SOSample.LineDisplay
{
    [ServiceObject(
            DeviceType.LineDisplay,
            "SampleLineDisplay",
            "Sample LineDisplay Service Object",
            1,
            9)]

    public class SampleLineDisplay : LineDisplayBase
    {
        SampleLineDisplay()
        {
            // The CapBlink property is initially set to
            // DisplayBlink.None in LineDisplayBase. This property
            // will be set here to indicate what mode of blinking
            // text our Service Object can support.
            Properties.CapBlink = DisplayBlink.All;

            // Set the CapBlinkRate property to true to indicate
            // that this device has the ability to change the
            // rate at which it blinks by setting the property
            // BlinkRate.
            Properties.CapBlinkRate = true;
        }

        #region Implement Abstract LineDisplayBase Members
        // LineDisplayScreenMode must be implemented to
        // allow the application to find out which screen modes
        // are supported by this device.
        protected override LineDisplayScreenMode[]
                                    LineDisplayScreenModes
        {
            get
            {
                LineDisplayScreenMode[] SupportedModes;

                // Create a LineDisplayScreenMode object; this SO
                // has a screen mode 10 columns wide and 2 rows deep.
                LineDisplayScreenMode mode =
                        new LineDisplayScreenMode(10, 2, 0, 0);

                // Allocate space for our screen mode array and
                // initialize it to hold our supported screen
                // mode(s).
                SupportedModes =
                        new LineDisplayScreenMode[] { mode };

                return SupportedModes;
            }
        }

        // DisplayData is the method called from the application
        // specifying what data should be displayed on the
        // device.
        protected override void DisplayData(Cell[] cells)
        {
            // Your code here:
            // Send the data to your device. Take settings such
            // as blink and blink rate into account here.
            return;
        }
        #endregion Implement Abstract LineDisplayBase Members

        #region Implement Abstract PosCommon Members
        private string MyHealthText = "";

        // PosCommon.CheckHealthText.
        public override string CheckHealthText
        {
            get
            {
                // VerifyState(mustBeClaimed,
                // mustBeEnabled).
                VerifyState(false, false);
                return MyHealthText;
            }
        }

        //  PosCommon.CheckHealth.
        public override string CheckHealth(
                        HealthCheckLevel level)
        {
            // Verify that the device is open, claimed and enabled.
            VerifyState(true, true);

            // Your code here:
            // check the health of the device and return a
            // descriptive string.

            // Cache result in the CheckHealthText property.
            MyHealthText = "Ok";
            return MyHealthText;
        }

        // PosCommon.DirectIOData.
        public override DirectIOData DirectIO(
                                int command,
                                int data,
                                object obj)
        {
            // Verify that the device is open.
            VerifyState(false, false);

            return new DirectIOData(data, obj);
        }
        #endregion Abstract PosCommon Members
    }
}

Consulte Também

Outros Recursos

• Implementação do LineDisplay
• Desenvolvendo objetos de serviço usando classes base