Udostępnij przez

Przykład LineDisplay (wersja POS dla zestawu SDK platformy .NET w wersji 1.14)

Klasa LineDisplayBase jest stosunkowo cienką warstwą abstrakcji w porównaniu z innymi klasami bazy obiektów usługi — między aplikacją a urządzeniem fizycznym jest potrzebny niewielki kod. LineDisplay Obiekt usługi musi po prostu anonsować funkcje obsługiwane przez urządzenie fizyczne i zmodyfikować jego dane wyjściowe zgodnie z właściwościami wyświetlania ustawionymi przez aplikację.

Obiekt usługi LineDisplay może również monitorować zasilanie urządzenia i zgłaszać zmiany stanu lub inne zmiany stanu w aplikacji przy użyciu elementu StatusUpdateEvent. Można to zrobić przy użyciu metod kolejki lub, na przykład, za pomocą funkcji raportowania zasilania w programie PosCommon. Monitorowanie urządzenia w ten sposób zwykle wymaga uruchomienia nowego wątku w celu oczekiwania na zdarzenia sprzętowe i kolejkowanie odpowiedniego statusUpdateEvent. Obiekt usługi LineDisplay może również wysyłać zapytania DirectIOEvents do aplikacji.

Aby zaimplementować klasę i atrybuty LineDisplay

  1. Dodaj dyrektywy using dla przestrzeni nazw Microsoft.PointOfService i Microsoft.PointOfService.BaseServiceObject .

  2. Dodaj atrybut PosAssemblyAttribute globalny, aby program PosExplorer rozpoznawał go jako zestaw punktów usługi microsoft dla platformy .NET (POS dla platformy .NET).

  3. Utwórz nową klasę, która pochodzi z klasy LineDisplayBase.

  4. Dodaj atrybut ServiceObjectAttribute na poziomie klasy do nowej klasy, aby aplikacja PosExplorer rozpoznawała go jako obiekt usługi.

Aby zaimplementować abstrakcyjne elementy członkowskie LineDisplayBase

  1. Wszystkie obiekty usługi LineDisplay muszą obsługiwać co najmniej jeden tryb ekranu. Aby udostępnić aplikacji szczegółowe informacje o obsługiwanych trybach ekranu, zaimplementuj właściwość LineDisplayScreenModesabstrakcyjną .

  2. Co najmniej wszystkie obiekty usługi LineDisplay muszą być implementowane DisplayData(Cell[]) w celu wyświetlania znaków na urządzeniu wyjściowym.

Dodatkowe możliwości

Ustaw właściwości możliwości w obiekcie usługi, aby anonsować obsługę funkcji urządzenia. W tym przykładzie pokazano, jak zaimplementować funkcję migania LineDisplay .

  1. W konstruktorze ustaw CapBlink właściwość na DisplayBlink.All lub DisplayBlink.Each , aby wskazać, który tryb migania obsługuje ten obiekt usługi.

  2. Ustaw właściwość CapBlink na wartość truewskazującą, że szybkość migania może zostać ustawiona przez aplikację przez wywołanie metody BlinkRate.

  3. Weź pod uwagę te i inne ustawienia podczas implementowania funkcji DisplayData.

Przykład

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
    }
}

Zobacz też

Inne zasoby

  • Last updated on