Deklarative Einschränkungen

Deklarative Einschränkungen bieten eine leistungsfähige Methode der Überprüfung für eine Aktivität und ihre Beziehungen zu anderen Aktivitäten. Einschränkungen werden während des Erstellungsprozesses für eine Aktivität konfiguriert, aber zusätzliche Einschränkungen können auch vom Workflowhost angegeben werden. Dieses Thema bietet eine Übersicht über die Verwendung deklarativer Einschränkungen zur Bereitstellung der Aktivitätsüberprüfung.

Verwenden deklarativer Einschränkungen

Eine Einschränkung ist eine Aktivität, die Gültigkeitsprüfungslogik enthält. Diese Einschränkungsaktivität kann im Code oder in XAML erstellt werden. Nachdem eine Einschränkungsaktivität erstellt wurde, fügen Aktivitätsautoren diese Einschränkung der Constraints Eigenschaft der zu überprüfenden Aktivität hinzu, oder sie verwenden die Einschränkung, um zusätzliche Überprüfung mithilfe der AdditionalConstraints Eigenschaft einer ValidationSettings Instanz bereitzustellen. Die Validierungslogik kann aus einfachen Validierungen wie der Validierung der Metadaten einer Aktivität bestehen, sie kann jedoch auch eine Validierung ausführen, die die Beziehung der betreffenden Aktivität zum übergeordneten Element, den untergeordneten Elementen und den gleichgeordneten Aktivitäten berücksichtigt. Einschränkungen werden mithilfe der Constraint<T> Aktivität erstellt, und mehrere zusätzliche Überprüfungsaktivitäten werden bereitgestellt, um die Erstellung von Überprüfungsfehlern und Warnungen zu unterstützen und Informationen zu verwandten Aktivitäten im Workflow bereitzustellen.

AssertValidation und AddValidationError

Die AssertValidation-Aktivität wertet den Ausdruck aus, auf den von der Assertion-Eigenschaft verwiesen wird. Wenn der ausgewertete Ausdruck false ergibt, wird ValidationResults ein Validierungsfehler oder eine Warnung hinzugefügt. Die Message Eigenschaft beschreibt den Überprüfungsfehler und die IsWarning Eigenschaft gibt an, ob der Überprüfungsfehler ein Fehler oder eine Warnung ist. Der Standardwert für IsWarning ist false.

Im folgenden Beispiel wird eine Einschränkung deklariert, die eine Überprüfungswarnung zurückgibt, wenn die DisplayName überprüfte Aktivität zwei Zeichen oder weniger lang ist. Der generische Typparameter, der für Constraint<T> verwendet wird, spezifiziert den Typ der Aktivität, die von der Beschränkung überprüft wird. Diese Einschränkung wird als generischer Typ verwendet Activity und kann verwendet werden, um alle Arten von Aktivitäten zu überprüfen.

public static Constraint ActivityDisplayNameIsNotSetWarning()  
{  
    DelegateInArgument<Activity> element = new DelegateInArgument<Activity>();  
  
    return new Constraint<Activity>  
    {  
        Body = new ActivityAction<Activity, ValidationContext>  
        {  
            Argument1 = element,  
            Handler = new AssertValidation  
            {  
                IsWarning = true,  
                Assertion = new InArgument<bool>(env => (element.Get(env).DisplayName.Length > 2)),  
                Message = new InArgument<string>("It is a best practice to have a DisplayName of more than 2 characters."),  
            }  
        }  
    };  
}  

Um diese Einschränkung für eine Aktivität anzugeben, wird sie der Constraints Aktivität hinzugefügt, wie im folgenden Beispielcode gezeigt.

public sealed class SampleActivity : CodeActivity  
{  
    public SampleActivity()  
    {  
        base.Constraints.Add(ActivityDisplayNameIsNotSetWarning());  
    }  
  
    // Activity implementation omitted.  
}  

Der Host könnte diese Einschränkung für Aktivitäten in einem Workflow auch mithilfe von AdditionalConstraints festlegen, was im nächsten Abschnitt behandelt wird.

Die AddValidationError Aktivität wird verwendet, um einen Überprüfungsfehler oder eine Warnung zu generieren, ohne dass eine Auswertung eines Ausdrucks erforderlich ist. Ihre Eigenschaften stimmen zum großen Teil mit denen des AssertValidation-Objekts überein, und die Aktivität kann zusammen mit den Flusssteuerungsaktivitäten einer Einschränkung wie der If-Aktivität verwendet werden.

Workflowbeziehungsaktivitäten

Es stehen mehrere Überprüfungsaktivitäten zur Verfügung, die Informationen zu den anderen Aktivitäten im Workflow in Bezug auf die zu überprüfende Aktivität bereitstellen. GetParentChain gibt eine Auflistung von Aktivitäten zurück, die alle Aktivitäten zwischen der aktuellen Aktivität und der Stammaktivität enthalten. GetChildSubtree stellt eine Auflistung von Aktivitäten bereit, die die untergeordneten Aktivitäten in einem rekursiven Muster enthält, und GetWorkflowTree ruft alle Aktivitäten im Workflow ab.

Im folgenden Beispiel wird eine CreateState -Aktivität definiert. Die CreateState Aktivität muss in einer CreateCountry Aktivität enthalten sein, und die GetParent Methode gibt eine Einschränkung zurück, die diese Anforderung erzwingt. GetParent verwendet die GetParentChain Aktivität in Verbindung mit einer ForEach<T> Aktivität, um die übergeordneten Aktivitäten der CreateState Aktivität zu überprüfen, um festzustellen, ob die Anforderung erfüllt ist.

public sealed class CreateState : CodeActivity  
{  
    public CreateState()  
    {  
        base.Constraints.Add(CheckParent());  
        this.Cities = new List<Activity>();
    }  
  
    public List<Activity> Cities { get; set; }  
  
    public string Name { get; set; }
  
    static Constraint CheckParent()  
    {  
        DelegateInArgument<CreateState> element = new DelegateInArgument<CreateState>();  
        DelegateInArgument<ValidationContext> context = new DelegateInArgument<ValidationContext>();
        Variable<bool> result = new Variable<bool>();  
        DelegateInArgument<Activity> parent = new DelegateInArgument<Activity>();  
  
        return new Constraint<CreateState>  
        {
            Body = new ActivityAction<CreateState,ValidationContext>  
            {
                Argument1 = element,  
                Argument2 = context,  
                Handler = new Sequence  
                {  
                    Variables =  
                    {  
                        result
                    },  
                    Activities =  
                    {  
                        new ForEach<Activity>  
                        {
                            Values = new GetParentChain  
                            {  
                                ValidationContext = context
                            },  
                            Body = new ActivityAction<Activity>  
                            {
                                Argument = parent,
                                Handler = new If()  
                                {
                                    Condition = new InArgument<bool>((env) => object.Equals(parent.Get(env).GetType(),typeof(CreateCountry))),
                                    Then = new Assign<bool>  
                                    {  
                                        Value = true,  
                                        To = result  
                                    }  
                                }  
                            }
                        },  
                        new AssertValidation  
                        {  
                            Assertion = new InArgument<bool>(result),  
                            Message = new InArgument<string> ("CreateState has to be inside a CreateCountry activity"),
                        }  
                    }  
                }  
            }  
        };  
    }  
  
    protected override void Execute(CodeActivityContext context)  
    {  
        // not needed for the sample  
    }  
}  

Zusätzliche Einschränkungen

Workflow-Host-Autoren können zusätzliche Validierungsbeschränkungen für Aktivitäten in einem Workflow angeben, indem sie Einschränkungen erstellen und sie dem AdditionalConstraints Dictionary einer ValidationSettings Instanz hinzufügen. Jedes Element in AdditionalConstraints enthält den Typ der Aktivität, für die die Einschränkungen gelten, und eine Liste der zusätzlichen Einschränkungen für diesen Aktivitätstyp. Wenn die Überprüfung für den Workflow aufgerufen wird, wertet jede Aktivität des angegebenen Typs, einschließlich abgeleiteter Klassen, die Einschränkungen aus. In diesem Beispiel wird die ActivityDisplayNameIsNotSetWarning Einschränkung aus dem vorherigen Abschnitt auf alle Aktivitäten in einem Workflow angewendet.

Activity wf = new Sequence  
{  
    // Workflow Details Omitted.  
};  
  
ValidationSettings settings = new ValidationSettings()  
{  
  
    AdditionalConstraints =  
    {  
        {typeof(Activity), new List<Constraint> {ActivityDisplayNameIsNotSetWarning()}},
    }  
};  
  
// Validate the workflow.  
ValidationResults results = ActivityValidationServices.Validate(wf, settings);  
  
// Evaluate the results.  
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 in " + error.Source.DisplayName + ": " + error.Message);  
    }  
    foreach (ValidationError warning in results.Warnings)  
    {  
        Console.WriteLine("Warning in " + warning.Source.DisplayName + ": " + warning.Message);  
    }  
}  

Wenn die OnlyUseAdditionalConstraints-Eigenschaft des ValidationSettings-Objekts true ist, werden nur die angegebenen zusätzlichen Einschränkungen ausgewertet, nachdem die Validierung über den Aufruf von Validate aufgerufen wird. Dies kann nützlich sein, um Workflows auf bestimmte Überprüfungskonfigurationen zu prüfen. Beachten Sie jedoch, dass beim Aufrufen des Workflows die im Workflow konfigurierte Überprüfungslogik ausgewertet wird und übergeben werden muss, damit der Workflow erfolgreich gestartet werden kann. Weitere Informationen zum Aufrufen der Überprüfung finden Sie unter "Aufrufen der Aktivitätsüberprüfung".