Dynamics AX 2012 SysOperation Framework Snabböversikt

Publicerad: 15 februari 2025 kl. 22:35:43 UTC

Den här artikeln ger en snabb översikt (eller fuskblad) om hur man implementerar bearbetningsklasser och batchjobb i SysOperation-ramverket i Dynamics AX 2012 och Dynamics 365 for Operations.

Denna sida har maskinöversatts från engelska för att göra den tillgänglig för så många som möjligt. Tyvärr är maskinöversättning ännu inte en fulländad teknik, så fel kan uppstå. Om du föredrar det kan du se den engelska originalversionen här:

Dynamics AX 2012 SysOperation Framework Quick Overview

Informationen i det här inlägget är baserad på Dynamics AX 2012 R3. Det kan eller kanske inte är giltigt för andra versioner. (Uppdatering: Jag kan bekräfta att informationen i den här artikeln också är giltig för Dynamics 365 for Operations)

Det här inlägget är bara menat som en snabb översikt och fusk. Om du är ny på SysOperation-ramverket rekommenderar jag starkt att du också läser Microsofts vitbok om ämnet. Informationen här kan vara användbar om du bara behöver en snabb uppdatering av de olika klasserna som är involverade i att utveckla operationer med detta ramverk.

Det finns variationer, men när jag använder ramverket implementerar jag vanligtvis tre klasser:

Datakontrakt (bör förlänga SysOperationDataContractBase)
Tjänst (bör utöka SysOperationServiceBase)
Controller ( måste utöka SysOperationServiceController)

Dessutom kan jag också implementera en UIBuilder-klass ( måste utöka SysOperationUIBuilder), men det är bara nödvändigt om dialogen av någon anledning måste vara mer avancerad än vad ramverket genererar automatiskt.

Datakontrakt

Datakontraktet innehåller de datamedlemmar som behövs för din verksamhet. Det kan jämföras med det typiska CurrentList-makrot som definieras i RunBase-ramverket, men implementeras som en klass istället. Datakontraktet bör förlänga SysOperationDataContractBase, men kommer att fungera även om det inte gör det. Fördelen med att utöka superklassen är att den ger lite sessionsinformation som kan vara praktisk.

[DataContractAttribute]
class MyDataContract extends SysOperationDataContractBase
{
    ItemId itemId;
}

I det här exemplet är itemId en datamedlem. Du måste implementera en parm-metod för varje datamedlem och tagga den med DataMemberAttribute så att ramverket vet vad det är. Detta gör det möjligt för ramverket att automatiskt bygga dialogen åt dig.

[DataMemberAttribute]
public ItemId parmItemId(ItemId _itemId = itemId)
{
    ;

    itemId = _itemId;
    return itemId;
}

Service

Serviceklassen är den klass som innehåller den faktiska affärslogiken. Det handlar inte om att visa dialoger, batchbearbetning eller något liknande – det är kontrollklassens ansvar. Genom att separera detta är det mer sannolikt att du designar din kod väl och gör mer återanvändbar kod.

Liksom datakontraktsklassen behöver inte tjänsteklassen ärva från något speciellt, men den bör ärva från klassen SysOperationServiceBase, åtminstone om du förväntar dig att tjänsten kommer att köras som ett batchjobb, eftersom superklassen ger en del information om batchkontexten. Metoden som startar operationen (dvs. kör affärslogiken) måste ta ett objekt av din datakontraktsklass som indata och bör dekoreras med [SysEntryPointAttribute]. Till exempel:

class MyService extends SysOperationServiceBase
{
}

med en metod som heter run:

[SysEntryPointAttribute]
public void run(MyDataContract _dataContract)
{
    // run business logic here
}

Kontroller

Controllerklassen hanterar exekveringen och batchbearbetningen av din verksamhet. Den ser också till att koden exekveras i CIL för maximal prestanda. Regulatorklassen ärver vanligtvis från klassen SysOperationServiceController, även om det också finns andra alternativ.

class MyController extends SysOperationServiceController
{
}

Konstruktören av superklassen tar ett klassnamn, metodnamn och (valfritt) exekveringsläge som parametrar. Klass- och metodnamnen ska vara namnet på din serviceklass och den metod som ska köras på den. Så du kan implementera din kontrollers konstruktionsmetod så här:

public static MyController construct()
{
    ;

    return new MyController(classStr(MyService),
    methodStr(MyService, run));
}

Då kan huvudmetoden för MyController-klassen vara så enkel som

public static void main(Args _args)
{
    ;

    MyController::construct().startOperation();
}

Och du är i princip klar. Ovanstående är uppenbarligen ett väldigt enkelt exempel och ramverket innehåller en uppsjö av andra alternativ och möjligheter, men detta fungerar som en snabb överblick om du behöver en borsta upp när du inte har använt ramverket på ett tag.