Delen via

X++-kenmerkklassen

Opmerking

Community-belangengroepen zijn nu verplaatst van Yammer naar Microsoft Viva Engage. Als u wilt deelnemen aan een Viva Engage-community en deel wilt nemen aan de meest recente discussies, vult u het formulier Toegang aanvragen tot Finance and Operations Viva Engage Community in en kiest u de community waaraan u wilt deelnemen.

In dit artikel wordt het gebruik van kenmerken in X++beschreven.

Een kenmerk is een niet-abstracte klasse die de SysAttribute-klasse uitbreidt (overgenomen van). Kenmerken vertegenwoordigen of opslaan metagegevens over typen en methoden. Een kenmerk kan worden gekoppeld aan een klasse, een klasseveld, een klassemethode, een interface of een tabel.

Kenmerken worden toegepast op de handlers van gemachtigden en methoden om de handlers toe te wijzen aan deze doelen.

Een kenmerkklasse maken

Een kenmerkklasse kan de SysAttribute-klasse rechtstreeks uitbreiden of elke afstammeling van de SysAttribute-klasse uitbreiden. De SysAttribute-klasse kan niet worden gebruikt als een kenmerk omdat deze abstract is gedeclareerd. In het volgende voorbeeld ziet u de declaratie en het ontwerp van een gewone kenmerkklasse die u kunt maken.

public class PracticeAttribute extends SysAttribute
{
    // Fields in the classDeclaration.
    StartEnd startEndEnum;
    str reason;
    // Constructor.
    public void new(StartEnd _startEndEnum, str _reason)
    {
        startEndEnum  = _startEndEnum;
        reason = _reason;
    }
    // Other methods can go here.
}

Een klasse decoreren met een kenmerk

In het volgende voorbeeld ziet u een klasse en een methode die zijn ingericht met de PracticeAttribute die in het vorige voorbeeld is opgegeven. Als de constructor van het kenmerk geen parameters gebruikt, zijn de haakjes voor de parameters optioneel. De kenmerkdecoratie kan zonder haakjes zijn [AnotherAttribute] .

[PracticeAttribute(StartEnd::End, "Use the RegularClass class at the end.")]
public class RegularClass
{
    [PracticeAttribute(Startend::Start, "Use the rehearse method at the start.")]
    public int rehearse()
    {
        // Logic goes here.
    }
    // More fields and methods belong here.
}

U kunt het achtervoegsel van de kenmerknaam weglaten als het achtervoegsel is Attribute. U kunt in plaats [Practice] daarvan bijvoorbeeld in het voorgaande voorbeeld gebruiken[PracticeAttribute].

Kenmerkconstructors

U kunt uw kenmerkklasse inschakelen om aangepaste metagegevens op te slaan telkens wanneer deze wordt gebruikt om een klasse te versieren door de constructor parameters te laten nemen. De parameters voor de constructor moeten letterlijke waarden van de primitieve typen zijn, zoals int,enum of str. De compiler maakt geen exemplaar van de kenmerkklasse. De naam van de kenmerkklasse wordt opgeslagen, plus de letterlijke waarden voor de constructor. Dus als de logica in een kenmerkconstructor een uitzondering zou genereren, wordt de uitzondering niet gevonden door een klasse met het kenmerk te decoreren. De uitzondering wordt later gevonden wanneer een proces naar een klasse kijkt om het kenmerk te zien waarmee het is ingericht. Dat is wanneer het kenmerk wordt samengesteld.

Naamgevingsconventies

Alle kenmerkklassen hebben het achtervoegselkenmerk in hun naam. Het kenmerkachtervoegsel is de naamconventie die we aanbevelen, maar het is geen systeemvereiste. U kunt bepalen of een klasse rechtstreeks vanuit SysAttributewordt uitgebreid door de klasse te selecteren in Application Explorer en de eigenschap Breidt te controleren in het venster Eigenschappen.

SysObsoleteAttribute

Het systeem biedt verschillende kenmerken, waaronder de klasse SysObsoleteAttribute . Een gebruik van de klasse SysObsoleteAttribute is om de compiler op de hoogte te stellen dat de compile moet mislukken als een bepaalde methode wordt aangeroepen in de broncode. De compiler weigert de compilatie en geeft het specifieke bericht weer dat is opgeslagen in dit gebruik van het kenmerk. De klasse SysObsoleteAttribute kan ook worden gebruikt om de compiler op de hoogte te stellen van waarschuwingsberichten in plaats van fouten.

Codevoorbeeld sysObsoleteAttribute

[SysObsoleteAttribute("The Automobile class might have faster performance.", false)]
class Bicycle
{
    // Members of the Bicycle class go here.
}

Weerspiegeling van metagegevens

U gebruikt weerspiegeling om de metagegevens van het kenmerk te vinden die aan een klasse zijn gekoppeld. De klassen die moeten worden gebruikt voor kenmerkspiegeling zijn als volgt:

  • DictClass-klasse : voor klassen en interfaces.
  • DictMethod-klasse : voor methoden voor klassen, interfaces of tabellen.

In de vorige reflectieklassen zijn de methoden voor het weergeven van kenmerkmetagegevens als volgt:

  • methode getAllAttributes
  • methode getAttribute
  • methode getAttributedClasses
  • methode getAttributes

Opmerking

Er is geen mechanisme voor het weergeven van alle methoden of klassen die zijn voorzien van een bepaald kenmerk uit X++-code. Omdat de X++-compiler deze informatie echter in de kruiszoekdatabase registreert, kan de informatie daar worden gemined.

Voorbeeld van weerspiegelingscode voor metagegevens

U gebruikt de klasse DictMethod om de metagegevenswaarde te vinden van een kenmerk dat decoratie is op een methode. In het volgende codevoorbeeld wordt de klasse SysEntryPointAttribute als kenmerk gebruikt. Hiermee worden de parameterwaarden voor de methodenaam geaccepteerd en voor de naam van de klasse die de methode bevat. De methode parmChecked is met name bedoeld voor de klasse SysEntryPointAttribute en wordt niet overgenomen van de basisklasse SysAttribute. Elke kenmerkklasse kan een eigen methodenaam hebben voor de metagegevens.

static public int MetadataOfSysEntryPointAttributeOnMethod
        (
        str _sNameOfClass,
        str _sNameOfMethod
        )
{
    // Return Values:
    // 0 == Has the attribute, its metadata value is false;
    // 1 == Has the attribute, its metadata value is true;
    // 2 == The method lacks the SysEntryPointAttribute.
    int nReturnValue = -1,
        nClassId;
    boolean boolParmChecked;
    DictMethod dm;
    Object attributeAsObject;
    SysEntryPointAttribute sepAttribute;
    Global::info("Starting AttributeReflection" 
        + " ::MetadataOfSysEntryPointAttributeOnMethod ....");
    Global::info(strFmt
        ("Parameters are: _sNameOfClass = %1 ,  _sNameOfMethod = %2 .", 
        _sNameOfClass, _sNameOfMethod)
        );
    nClassId = Global::className2Id(_sNameOfClass);
    dm = new DictMethod
        (UtilElementType::ClassInstanceMethod,
        nClassId,
        _sNameOfMethod
        );
    attributeAsObject = dm.getAttribute("SysEntryPointAttribute");
    if (attributeAsObject is SysEntryPointAttribute)
    {
        sepAttribute = attributeAsObject as SysEntryPointAttribute;
        boolParmChecked = sepAttribute.parmChecked();
        if (boolParmChecked)
            nReturnValue = 1;
        else
            nReturnValue = 0;
        Global::info(
            strFmt("Return value is %1.",
                nReturnValue)
            );
    }
    else
    {
        nReturnValue = 2;
        Global::error("Object is not a SysEntryPointAttribute??");
    }
    return nReturnValue;
}
/*** Output displayed in the Infolog.
Message (05:03:22 pm)
Starting AttributeReflection ::MetadataOfSysEntryPointAttributeOnMethod ....
Parameters are: _sNameOfClass = CustCustomerService ,  _sNameOfMethod = create .
Return value is 1.
***/
/**************
// Simple AOT > Jobs job to run the method.
static void AttributeReflection33Job(Args _args)
{
    AttributeReflection::MetadataOfSysEntryPointAttributeOnMethod
        ("CustCustomerService", "create");
}
**************/
  • Last updated on