Declaratieve beperkingen

Declaratieve beperkingen bieden een krachtige validatiemethode voor een activiteit en de bijbehorende relaties met andere activiteiten. Beperkingen worden geconfigureerd voor een activiteit tijdens het ontwerpproces, maar er kunnen ook extra beperkingen worden opgegeven door de werkstroomhost. In dit onderwerp vindt u een overzicht van het gebruik van declaratieve beperkingen om activiteitsvalidatie te bieden.

Declaratieve beperkingen gebruiken

Een beperking is een activiteit die validatielogica bevat. Deze beperkingsactiviteit kan worden geschreven in code of in XAML. Nadat een beperkingsactiviteit is gemaakt, voegen auteurs van activiteit deze beperking toe aan de Constraints eigenschap van de activiteit die moet worden gevalideerd of gebruiken ze de beperking om extra validatie te bieden met behulp van de AdditionalConstraints eigenschap van een ValidationSettings exemplaar. De validatielogica kan bestaan uit eenvoudige validaties, zoals het valideren van de metagegevens van een activiteit, maar het kan ook validatie uitvoeren waarbij rekening wordt gehouden met de relatie van de huidige activiteit met de bovenliggende, onderliggende en onderliggende activiteiten. Beperkingen worden gemaakt met behulp van de Constraint<T> activiteit en er worden verschillende aanvullende validatieactiviteiten geboden om u te helpen bij het maken van validatiefouten en waarschuwingen en om informatie te verstrekken over gerelateerde activiteiten in de werkstroom.

AssertValidation en AddValidationError

De AssertValidation-activiteit evalueert de expressie waarnaar wordt verwezen door de eigenschap Assertion, en als de expressie evalueert tot false, wordt er een validatiefout of waarschuwing toegevoegd aan de ValidationResults. De Message eigenschap beschrijft de validatiefout en de IsWarning eigenschap geeft aan of de validatiefout een fout of een waarschuwing is. De standaardwaarde voor IsWarning is false.

In het volgende voorbeeld wordt een beperking gedeclareerd die een validatiewaarschuwing retourneert als de DisplayName activiteit die wordt gevalideerd twee tekens of minder lang is. De generieke typeparameter die voor Constraint<T> wordt gebruikt, specificeert het type activiteit dat door de beperking wordt gevalideerd. Deze beperking wordt gebruikt Activity als het algemene type en kan worden gebruikt om alle typen activiteiten te valideren.

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."),  
            }  
        }  
    };  
}  

Als u deze beperking voor een activiteit wilt opgeven, wordt deze toegevoegd aan de Constraints activiteit, zoals wordt weergegeven in de volgende voorbeeldcode.

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

De host kan deze beperking ook opgeven voor activiteiten in een werkstroom met behulp van AdditionalConstraints, die in de volgende sectie wordt behandeld.

De AddValidationError activiteit wordt gebruikt om een validatiefout of waarschuwing te genereren zonder de evaluatie van een expressie te vereisen. De eigenschappen zijn vergelijkbaar met AssertValidation en kunnen worden gebruikt in combinatie met activiteiten voor stroombeheer van een beperking, zoals de If-activiteit.

Werkstroomrelatieactiviteiten

Er zijn verschillende validatieactiviteiten beschikbaar die informatie bieden over de andere activiteiten in de werkstroom ten opzichte van de activiteit die wordt gevalideerd. GetParentChain retourneert een verzameling activiteiten die alle activiteiten tussen de huidige activiteit en de hoofdactiviteit bevat. GetChildSubtree biedt een verzameling activiteiten met de onderliggende activiteiten in een recursief patroon en GetWorkflowTree haalt alle activiteiten in de werkstroom op.

In het volgende voorbeeld wordt een CreateState activiteit gedefinieerd. De CreateState activiteit moet zich in een CreateCountry activiteit bevinden en de GetParent methode retourneert een beperking die deze vereiste afdwingt. GetParent gebruikt de GetParentChain activiteit in combinatie met een ForEach<T> activiteit om de bovenliggende activiteiten van de CreateState activiteit te inspecteren om te bepalen of aan de vereiste wordt voldaan.

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

Aanvullende beperkingen

Auteurs van werkstroomhosts kunnen aanvullende validatiebeperkingen opgeven voor activiteiten in een werkstroom door beperkingen te maken en toe te voegen aan de AdditionalConstraints dictionary van een ValidationSettings instantie. Elk item in AdditionalConstraints bevat het type activiteit waarvoor de beperkingen van toepassing zijn en een lijst met de aanvullende beperkingen voor dat type activiteit. Wanneer validatie wordt aangeroepen voor de werkstroom, evalueert elke activiteit van het opgegeven type, inclusief afgeleide klassen, de beperkingen. In dit voorbeeld wordt de ActivityDisplayNameIsNotSetWarning beperking uit de vorige sectie toegepast op alle activiteiten in een werkstroom.

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

Als de OnlyUseAdditionalConstraints eigenschap van ValidationSettingstrue is, worden alleen de opgegeven aanvullende beperkingen geëvalueerd wanneer validatie wordt uitgevoerd door Validate aan te roepen. Dit kan handig zijn voor het inspecteren van werkstromen voor specifieke validatieconfiguraties. Houd er echter rekening mee dat wanneer de werkstroom wordt aangeroepen, de validatielogica die in de werkstroom is geconfigureerd, wordt geëvalueerd en moet slagen opdat de werkstroom succesvol kan starten. Zie Validatie van activiteit aanroepen voor meer informatie over het aanroepen van validatie.