Aufrufen der Aktivitätsüberprüfung

Die Aktivitätsüberprüfung stellt eine Methode zum Identifizieren und Melden von Fehlern in der Konfiguration einer Aktivität vor der Ausführung bereit. Die Überprüfung erfolgt, wenn ein Workflow im Workflow-Designer geändert wird und alle Überprüfungsfehler oder Warnungen im Workflow-Designer angezeigt werden. Die Überprüfung erfolgt auch zur Laufzeit, wenn ein Workflow aufgerufen wird und wenn Validierungsfehler auftreten, wird eine InvalidWorkflowException von der Standardüberprüfungslogik ausgelöst. Windows Workflow Foundation (WF) stellt die ActivityValidationServices Klasse bereit, die von Workflowanwendungs- und Toolentwicklern verwendet werden kann, um eine Aktivität explizit zu überprüfen. In diesem Thema wird beschrieben, wie Sie mit ActivityValidationServices die Aktivitätsvalidierung durchführen.

Verwenden von ActivityValidationServices

ActivityValidationServices verfügt über zwei Validate Überladungen, die zum Aufrufen der Validierungslogik einer Aktivität verwendet werden. Die erste Überladung verwendet die zu überprüfende Stammaktivität und gibt eine Sammlung von Überprüfungsfehlern und Warnungen zurück. Im folgenden Beispiel wird eine benutzerdefinierte Add Aktivität verwendet, die über zwei erforderliche Argumente verfügt.

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

Die Add Aktivität wird in einem Sequence benutzt, aber die beiden erforderlichen Argumente sind nicht gebunden, wie im folgenden Beispiel gezeigt.

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

Dieser Workflow kann durch Aufrufen Validateüberprüft werden. Validate gibt eine Auflistung aller Überprüfungsfehler oder Warnungen zurück, die in der Aktivität und allen untergeordneten Elementen enthalten sind, wie im folgenden Beispiel gezeigt.

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

Wenn Validate bei diesem Beispielworkflow aufgerufen wird, werden zwei Überprüfungsfehler zurückgegeben.

Fehler: Der Wert für ein erforderliches Aktivitätsargument 'Operand2' wurde nicht angegeben.Fehler: Der Wert für ein erforderliches Aktivitätsargument 'Operand1' wurde nicht angegeben. Wenn dieser Workflow aufgerufen wurde, wird ein InvalidWorkflowException Fehler ausgelöst, wie im folgenden Beispiel gezeigt.

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

```plaintext System.Activities.InvalidWorkflowException:Die folgenden Fehler wurden beim Verarbeiten der Workflowstruktur festgestellt:'Add': Der Wert für ein erforderliches Aktivitätsargument 'Operand2' wurde nicht angegeben.'Add': Der Wert für ein erforderliches Aktivitätsargument 'Operand1' wurde nicht angegeben. Damit dieser Beispielworkflow gültig ist, müssen die beiden erforderlichen Argumente der Add Aktivität gebunden sein. ``` Im folgenden Beispiel werden die beiden erforderlichen Argumente zusammen mit dem Ergebniswert an Workflowvariablen gebunden. In diesem Beispiel ist das Result Argument zusammen mit den beiden erforderlichen Argumenten gebunden. Das Result Argument muss nicht gebunden werden und verursacht keinen Überprüfungsfehler, wenn es nicht der Fall ist. Es liegt in der Verantwortung des Workflowautors, Result zu binden, wenn dessen Wert an anderer Stelle im Workflow verwendet wird.

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

Überprüfen der erforderlichen Argumente für die Stammaktivität

Wenn die Stammaktivität eines Workflows Argumente enthält, sind diese erst gebunden, wenn der Workflow aufgerufen wird und Parameter an den Workflow übergeben werden. Der nachfolgende Workflow besteht die Validierung, aber eine Ausnahme tritt auf, wenn der Workflow aufgerufen wird, ohne die erforderlichen Argumente zu übermitteln, wie im Beispiel unten gezeigt wird.

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: Die Argumenteinstellungen der Stammaktivität sind falsch.Beheben Sie entweder die Workflowdefinition, oder geben Sie Eingabewerte an, um diese Fehler zu beheben:'Add': Wert für ein erforderliches Aktivitätsargument 'Operand2' wurde nicht angegeben.'Add': Der Wert für ein erforderliches Aktivitätsargument 'Operand1' wurde nicht angegeben. Nachdem die richtigen Argumente übergeben wurden, wird der Workflow erfolgreich abgeschlossen, wie im folgenden Beispiel gezeigt.

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

Beim Überprüfen von Stammargumenten liegt die Verantwortung der Hostanwendung darin, sicherzustellen, dass alle erforderlichen Argumente übergeben werden, wenn der Workflow aufgerufen wird.

Aufrufen der imperativen code-basierten Validierung

Imperative codebasierte Validierung ermöglicht es einer Aktivität, einfach eine Überprüfung über sich selbst bereitzustellen, und steht für Aktivitäten zur Verfügung, die von CodeActivity, AsyncCodeActivity und NativeActivity abgeleitet sind. Der Überprüfungscode, der alle Überprüfungsfehler oder Warnungen bestimmt, wird der Aktivität hinzugefügt. Wenn die Überprüfung für die Aktivität aufgerufen wird, sind diese Warnungen oder Fehler in der Auflistung enthalten, die vom Aufruf Validate zurückgegeben wird. Im folgenden Beispiel wird eine CreateProduct Aktivität definiert. Wenn der Cost größer als der Price ist, wird ein Validierungsfehler zu den Metadaten in der CacheMetadata-Überschreibung hinzugefügt.

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

In diesem Beispiel wird ein Workflow mithilfe der CreateProduct Aktivität konfiguriert. In diesem Workflow ist der Cost Wert größer als das Price, und das erforderliche Description Argument ist nicht festgelegt. Wenn die Überprüfung aufgerufen wird, werden die folgenden Fehler zurückgegeben.

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

Fehler: Die Kosten müssen kleiner oder gleich dem Preis sein.Fehler: Der Wert für ein erforderliches Aktivitätsargument "Description" wurde nicht angegeben.

Verwenden von ValidationSettings

Standardmäßig werden alle Aktivitäten im Aktivitätsbaum ausgewertet, wenn die Validierung von ActivityValidationServices ausgelöst wird. ValidationSettings ermöglicht die Anpassung der Überprüfung auf verschiedene Arten, indem die drei Eigenschaften konfiguriert werden. SingleLevel Gibt an, ob der Validator die gesamte Aktivitätsstruktur durchlaufen oder nur die Gültigkeitsprüfungslogik auf die angegebene Aktivität anwenden soll. Der Standardwert für diesen Wert ist false. AdditionalConstraints Gibt zusätzliche Einschränkungszuordnung von einem Typ zu einer Liste von Einschränkungen an. Für den Basistyp jeder Aktivität im zu überprüfenden Aktivitätsbaum erfolgt ein Nachschlagen AdditionalConstraints. Wenn eine übereinstimmende Einschränkungsliste gefunden wird, werden alle Einschränkungen in der Liste für die Aktivität ausgewertet. OnlyUseAdditionalConstraints Gibt an, ob der Validator alle Einschränkungen oder nur diejenigen auswerten soll, die in AdditionalConstraints. Der Standardwert ist false. AdditionalConstraints und OnlyUseAdditionalConstraints sind nützlich für Workflowhostautoren, um zusätzliche Validierung für Workflows hinzuzufügen, z. B. Richtlinieneinschränkungen für Tools wie FxCop. Weitere Informationen zu Einschränkungen finden Sie unter Deklarative Einschränkungen.

Konfigurieren Sie zum Verwenden von ValidationSettings die gewünschten Eigenschaften, und übergeben Sie sie dann im Aufruf von Validate. In diesem Beispiel wird ein Workflow überprüft, der aus einer Sequence benutzerdefinierten Add Aktivität besteht. Die Add Aktivität weist zwei erforderliche Argumente auf.

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

Die folgende Add Aktivität wird in einem Sequence verwendet, aber die beiden erforderlichen Argumente sind nicht gebunden.

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

Im folgenden Beispiel wird die Validierung durchgeführt, indem SingleLevel auf true gesetzt wird, sodass nur die Stammaktivität Sequence überprüft wird.

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

Dieser Code zeigt die folgende Ausgabe an:

Keine Warnungen oder Fehler Obwohl die Aktivität erforderliche Argumente enthält, die Add nicht gebunden sind, ist die Überprüfung erfolgreich, da nur die Stammaktivität ausgewertet wird. Diese Art der Überprüfung ist nützlich, um nur bestimmte Elemente in einer Aktivitätsstruktur zu validieren, z. B. die Überprüfung einer Eigenschaftsänderung einer einzelnen Aktivität in einem Designer. Beachten Sie, dass, wenn dieser Workflow aufgerufen wird, die im Workflow konfigurierte vollständige Überprüfung ausgewertet wird und ein Fehler vom Typ InvalidWorkflowException ausgelöst wird. ActivityValidationServices und ValidationSettings konfigurieren nur die vom Host explizit aufgerufene Überprüfung und nicht die Überprüfung, die erfolgt, wenn ein Workflow aufgerufen wird.