Tevékenység érvényesítésének meghívása

A tevékenységérvényesítés egy metódust biztosít a tevékenységek konfigurációjában szereplő hibák azonosítására és jelentésére a végrehajtás előtt. Az érvényesítés akkor történik, ha a munkafolyamat-tervező módosít egy munkafolyamatot, és a munkafolyamat-tervezőben bármilyen érvényesítési hiba vagy figyelmeztetés jelenik meg. Az érvényesítés futásidőben is megtörténik, amikor egy munkafolyamatot meghívnak, és ha bármilyen érvényesítési hiba történik, InvalidWorkflowException az alapértelmezett érvényesítési logika elindít egy hibát. A Windows Workflow Foundation (WF) biztosítja azt az osztályt, amelyet a ActivityValidationServices munkafolyamat-alkalmazás és az eszközfejlesztők használhatnak egy tevékenység explicit érvényesítéséhez. Ez a témakör azt ismerteti, hogyan lehet a ActivityValidationServices segítségével végrehajtani a tevékenységellenőrzést.

Az ActivityValidationServices használata

ActivityValidationServices két Validate túlterheléssel rendelkezik, amelyek egy tevékenység érvényesítési logikájának meghívására szolgálnak. Az első túlterhelés ellenőrzi a gyökértevékenységet, és érvényesítési hibák és figyelmeztetések gyűjteményét adja vissza. Az alábbi példában egy egyéni Add tevékenységet használunk, amelynek két kötelező argumentuma van.

public sealed class Add : CodeActivity<int>
{
    [RequiredArgument]
    public InArgument<int> Operand1 { get; set; }

    [RequiredArgument]
    public InArgument<int> Operand2 { get; set; }

    protected override int Execute(CodeActivityContext context)
    {
        return Operand1.Get(context) + Operand2.Get(context);
    }
}

A Add tevékenység egy Sequenceadott területen belül van használva, de két kötelező argumentuma nem kötött, ahogy az alábbi példában is látható.

Variable<int> Operand1 = new Variable<int>{ Default = 10 };
Variable<int> Operand2 = new Variable<int>{ Default = 15 };
Variable<int> Result = new Variable<int>();

Activity wf = new Sequence
{
    Variables = { Operand1, Operand2, Result },
    Activities =
    {
        new Add(),
        new WriteLine
        {
            Text = new InArgument<string>(env => "The result is " + Result.Get(env))
        }
    }
};

Ez a munkafolyamat a hívással Validateérvényesíthető. Validate a tevékenység és a gyermekek által tartalmazott ellenőrzési hibák vagy figyelmeztetések gyűjteményét adja vissza az alábbi példában látható módon.

ValidationResults results = ActivityValidationServices.Validate(wf);

if (results.Errors.Count == 0 && results.Warnings.Count == 0)
{
    Console.WriteLine("No warnings or errors");
}
else
{
    foreach (ValidationError error in results.Errors)
    {
        Console.WriteLine("Error: {0}", error.Message);
    }
    foreach (ValidationError warning in results.Warnings)
    {
        Console.WriteLine("Warning: {0}", warning.Message);
    }
}

Amikor meghívják a Validate mintafolyamatot, két érvényesítési hiba kerül visszaadásra.

Hiba: Az "Operand2" kötelező tevékenységargumentum értéke nem lett megadva.Hiba: Az "Operand1" kötelező tevékenységargumentum értéke nem lett megadva. Ha ezt a munkafolyamatot meghívták, a rendszer a következő példában látható módon elindít egy InvalidWorkflowException hibát.

try
{
    WorkflowInvoker.Invoke(wf);
}
catch (Exception ex)
{
    Console.WriteLine(ex);
}

System.Activities.InvalidWorkflowException:A munkafolyamat-fa feldolgozása során a következő hibák léptek fel:"Hozzáadás":Az "Operand2" kötelező tevékenységargumentum értéke nem lett megadva.'Hozzáadás': Az "Operand1" kötelező tevékenységargumentum értéke nem lett megadva. Ahhoz, hogy ez a példa munkafolyamat érvényes legyen, a tevékenység két kötelező argumentumát Add kötelező megadni. Az alábbi példában a két szükséges argumentum a munkafolyamat változóihoz és az eredményértékhez van kötve. Ebben a példában az Result argumentum a két kötelező argumentummal együtt van kötve. Az Result argumentumot nem kötelező kötve megadni, és nem okoz érvényesítési hibát, ha nem. A munkafolyamat szerzőjének feladata Result kötése, ha annak értékét a munkafolyamat más részein használják.

new Add
{
    Operand1 = Operand1,
    Operand2 = Operand2,
    Result = Result
}

Kötelező argumentumok érvényesítése a gyökértevékenységen

Ha a munkafolyamat gyökértevékenysége argumentumokkal rendelkezik, ezek nem lesznek kötve, amíg a munkafolyamat meg nem hívja, és a paramétereket a rendszer átadja a munkafolyamatnak. A következő munkafolyamat megfelel az ellenőrzésnek, de kivételt jelent, ha a munkafolyamatot a rendszer a szükséges argumentumok megadása nélkül hívja meg, ahogyan az alábbi példában is látható.

Activity wf = new Add();

ValidationResults results = ActivityValidationServices.Validate(wf);
// results has no errors or warnings, but when the workflow
// is invoked, an InvalidWorkflowException is thrown.
try
{
    WorkflowInvoker.Invoke(wf);
}
catch (Exception ex)
{
    Console.WriteLine(ex);
}

System.ArgumentException: A gyökértevékenység argumentumbeállításai helytelenek.Javítsa ki a munkafolyamat-definíciót, vagy adja meg a bemeneti értékeket a következő hibák kijavításához:"Hozzáadás": Az "Operand2" kötelező tevékenységargumentum értéke nem lett megadva.'Hozzáadás': Az "Operand1" kötelező tevékenységargumentum értéke nem lett megadva. A megfelelő argumentumok átadása után a munkafolyamat sikeresen befejeződik, ahogy az az alábbi példában is látható.

Add wf = new Add();

ValidationResults results = ActivityValidationServices.Validate(wf);
// results has no errors or warnings, and the workflow completes
// successfully because the required arguments were passed.
try
{
    Dictionary<string, object> wfparams = new Dictionary<string, object>
    {
        { "Operand1", 10 },
        { "Operand2", 15 }
    };

    int result = WorkflowInvoker.Invoke(wf, wfparams);
    Console.WriteLine("Result: {0}", result);
}
catch (Exception ex)
{
    Console.WriteLine(ex);
}

Megjegyzés:

Ebben a példában a gyökértevékenységet Add helyett Activity deklaráltuk, mint az előző példában. Ez lehetővé teszi, hogy a WorkflowInvoker.Invoke metódus egyetlen egész számot adjon vissza, amely argumentumok szótára Add helyett a out tevékenység eredményeit jelöli. A változót wfActivity<int>-ként is lehetett volna deklarálni.

Alapértelmezett argumentumok érvényesítésekor a gazdagépalkalmazás felelőssége annak biztosítása, hogy a munkafolyamat meghívásakor minden szükséges argumentum átadásra kerüljön.

Imperatív kódbázisú érvényesítés.

Az imperatív alapú kódvalidáció egyszerű módot biztosít egy tevékenység számára, hogy validálja önmagát, és elérhető azoknál a tevékenységeknél, amelyek a CodeActivity, AsyncCodeActivity és NativeActivity osztályokból származnak. Az érvényesítési hibákat vagy figyelmeztetéseket meghatározó érvényesítési kód hozzáadódik a tevékenységhez. Amikor egy tevékenységen érvényesítést kezdeményez, ezek a figyelmeztetések vagy hibák a hívás Validate által visszaadott gyűjteményben találhatók. Az alábbi példában egy CreateProduct tevékenység van definiálva. Ha az Cost nagyobb, mint a Price, akkor egy érvényesítési hibát adunk hozzá a CacheMetadata felülbírálás metaadataihoz.

public sealed class CreateProduct : CodeActivity
{
    public double Price { get; set; }
    public double Cost { get; set; }

    // [RequiredArgument] attribute will generate a validation error
    // if the Description argument is not set.
    [RequiredArgument]
    public InArgument<string> Description { get; set; }

    protected override void CacheMetadata(CodeActivityMetadata metadata)
    {
        base.CacheMetadata(metadata);
        // Determine when the activity has been configured in an invalid way.
        if (this.Cost > this.Price)
        {
            // Add a validation error with a custom message.
            metadata.AddValidationError("The Cost must be less than or equal to the Price.");
        }
    }

    protected override void Execute(CodeActivityContext context)
    {
        // Not needed for the sample.
    }
}

Ebben a példában a CreateProduct tevékenységgel konfigurálják a munkafolyamatot. Ebben a munkafolyamatban a Cost nagyobb, mint a Price, és a szükséges Description argumentum nincs beállítva. Az ellenőrzés meghívásakor a rendszer a következő hibákat adja vissza.

Activity wf = new Sequence
{
    Activities =
    {
        new CreateProduct
        {
            Cost = 75.00,
            Price = 55.00
            // Cost > Price and required Description argument not set.
        },
        new WriteLine
        {
            Text = "Product added."
        }
    }
};

ValidationResults results = ActivityValidationServices.Validate(wf);

if (results.Errors.Count == 0 && results.Warnings.Count == 0)
{
    Console.WriteLine("No warnings or errors");
}
else
{
    foreach (ValidationError error in results.Errors)
    {
        Console.WriteLine("Error: {0}", error.Message);
    }
    foreach (ValidationError warning in results.Warnings)
    {
        Console.WriteLine("Warning: {0}", warning.Message);
    }
}

Hiba: A költségnek kisebbnek vagy egyenlőnek kell lennie az árnál.Hiba: A "Leírás" kötelező tevékenységargumentum értéke nem lett megadva.

Megjegyzés:

Az egyéni tevékenységszerzők érvényesítési logikát adhatnak egy tevékenység felülbírálásához CacheMetadata . Bármely CacheMetadata-ből dobott kivétel nem tekintendő érvényesítési hibának. Ezek a kivételek kikerülnek a hívásból Validate , és a hívónak kell kezelnie őket.

ValidationSettings használata

Alapértelmezés szerint a tevékenységfa összes tevékenységét kiértékeli a rendszer, amikor a rendszer meghívja ActivityValidationServicesaz ellenőrzést. ValidationSettings A három tulajdonság konfigurálásával az ellenőrzés több különböző módon is testre szabható. SingleLevel meghatározza, hogy az érvényesítőnek végig kell-e járnia a teljes tevékenységfát, vagy csak érvényesítési logikát kell alkalmaznia a megadott tevékenységre. Ennek az értéknek az alapértelmezett értéke a következő false. AdditionalConstraints további kényszerleképezést ad meg egy típustól a kényszerek listájáig. Az ellenőrzés alatt álló tevékenységfa egyes tevékenységeinek az alaptípusa esetében keresés történik a AdditionalConstraints-ban/-ben. Ha talál egyező kényszerlistát, a rendszer kiértékeli a listában szereplő összes kényszert a tevékenységhez. OnlyUseAdditionalConstraintsmegadja, hogy az érvényesítőnek ki kell-e értékelnie az összes korlátozást, vagy csak a megadottakat.AdditionalConstraints Az alapértelmezett érték a false. AdditionalConstraints és OnlyUseAdditionalConstraints hasznosak lehetnek a munkafolyamat-gazdagép fejlesztők számára, hogy további validációkat adjanak a munkafolyamatokhoz, például olyan eszközökre vonatkozó irányelvek alkalmazásával, mint az FxCop. A korlátozásokról további információt a Deklaratív korlátozások című témakörben talál.

A ValidationSettings használatához konfigurálja a kívánt tulajdonságokat, majd adja át a hívásban Validate. Ebben a példában egy munkafolyamat, amely egy egyéni Sequence tevékenységet tartalmaz, kerül érvényesítésre. A Add tevékenységnek két kötelező argumentuma van.

public sealed class Add : CodeActivity<int>
{
    [RequiredArgument]
    public InArgument<int> Operand1 { get; set; }

    [RequiredArgument]
    public InArgument<int> Operand2 { get; set; }

    protected override int Execute(CodeActivityContext context)
    {
        return Operand1.Get(context) + Operand2.Get(context);
    }
}

A következő Add tevékenységet használják egy Sequence-ben, de a két kötelező argumentuma nincs kötve.

Variable<int> Operand1 = new Variable<int> { Default = 10 };
Variable<int> Operand2 = new Variable<int> { Default = 15 };
Variable<int> Result = new Variable<int>();

Activity wf = new Sequence
{
    Variables = { Operand1, Operand2, Result },
    Activities =
    {
        new Add(),
        new WriteLine
        {
            Text = new InArgument<string>(env => "The result is " + Result.Get(env))
        }
    }
};

Az alábbi példában az érvényesítést úgy végezzük, hogy a SingleLevel értéke true-re van beállítva, így csak a gyökér Sequence tevékenység kerül érvényesítésre.

ValidationSettings settings = new ValidationSettings
{
    SingleLevel = true
};

ValidationResults results = ActivityValidationServices.Validate(wf, settings);

if (results.Errors.Count == 0 && results.Warnings.Count == 0)
{
    Console.WriteLine("No warnings or errors");
}
else
{
    foreach (ValidationError error in results.Errors)
    {
        Console.WriteLine("Error: {0}", error.Message);
    }
    foreach (ValidationError warning in results.Warnings)
    {
        Console.WriteLine("Warning: {0}", warning.Message);
    }
}

Ez a kód a következő kimenetet jeleníti meg:

Nincsenek figyelmeztetések vagy hibák Annak ellenére, hogy a Add tevékenységhez nem kötött argumentumok szükségesek, az ellenőrzés sikeres, mert csak a gyökértevékenység lesz kiértékelve. Ez az érvényesítési típus csak a tevékenységfa adott elemeinek ellenőrzéséhez hasznos, például egyetlen tevékenység tulajdonságváltozásának ellenőrzése a tervezőben. Vegye figyelembe, hogy a munkafolyamat meghívása esetén a rendszer kiértékeli a munkafolyamatban konfigurált teljes ellenőrzést, és a rendszer elindít egy InvalidWorkflowException hibát. ActivityValidationServices és ValidationSettings csak azokat az érvényesítéseket konfigurálja, amelyeket a gazdagép explicit módon meghív, nem pedig azokat, amelyek egy munkafolyamat meghívásakor történnek.