Deklarativa begränsningar

Deklarativa begränsningar ger en kraftfull valideringsmetod för en aktivitet och dess relationer till andra aktiviteter. Begränsningar konfigureras för en aktivitet under skapandeprocessen, men ytterligare begränsningar kan också anges av arbetsflödets värd. Det här avsnittet innehåller en översikt över hur du använder deklarativa begränsningar för att tillhandahålla aktivitetsverifiering.

Använda deklarativa begränsningar

En begränsning är en aktivitet som innehåller valideringslogik. Den här begränsningsaktiviteten kan redigeras i kod eller I XAML. När en begränsningsaktivitet har skapats lägger aktivitetsförfattare till den här begränsningen Constraints till egenskapen för aktiviteten för att verifiera, eller så använder de villkoret för att tillhandahålla ytterligare validering med hjälp AdditionalConstraints av egenskapen för en ValidationSettings instans. Valideringslogik kan bestå av enkla valideringar, till exempel validering av en aktivitets metadata, men den kan också utföra validering som tar hänsyn till relationen mellan den aktuella aktiviteten och dess överordnade aktiviteter, underordnade aktiviteter och syskonaktiviteter. Begränsningar skapas med hjälp Constraint<T> av aktiviteten, och flera ytterligare verifieringsaktiviteter tillhandahålls för att hjälpa till med att skapa valideringsfel och varningar och för att ge information om relaterade aktiviteter i arbetsflödet.

AssertValidation och AddValidationError

Aktiviteten AssertValidation utvärderar uttrycket som refereras av dess Assertion egenskap och om uttrycket utvärderas till falseläggs ett valideringsfel eller en varning till i ValidationResults. Egenskapen Message beskriver verifieringsfelet och egenskapen IsWarning anger om verifieringsfelet är ett fel eller en varning. Standardvärdet för IsWarning är false.

I följande exempel deklareras en begränsning som returnerar en valideringsvarning om aktiviteten DisplayName som verifieras är två tecken eller mindre lång. Den generiska typparametern som används för Constraint<T> anger vilken typ av aktivitet som verifieras av villkoret. Den här begränsningen används Activity som allmän typ och kan användas för att verifiera alla typer av aktiviteter.

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

Om du vill ange den här begränsningen för en aktivitet läggs den Constraints till i aktiviteten, som du ser i följande exempelkod.

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

Värden kan också ange den här begränsningen för aktiviteter i ett arbetsflöde med hjälp av AdditionalConstraints, vilket beskrivs i nästa avsnitt.

Aktiviteten AddValidationError används för att generera ett valideringsfel eller en varning utan att ett uttryck behöver utvärderas. Dess egenskaper liknar AssertValidation och det kan användas tillsammans med flödeskontrollaktiviteter i en restriktion såsom If-aktiviteten.

Arbetsflödesrelationsaktiviteter

Det finns flera valideringsaktiviteter som ger information om de andra aktiviteterna i arbetsflödet i förhållande till den aktivitet som verifieras. GetParentChain returnerar en samling aktiviteter som innehåller alla aktiviteter mellan den aktuella aktiviteten och rotaktiviteten. GetChildSubtree tillhandahåller en samling aktiviteter som innehåller underordnade aktiviteter i ett rekursivt mönster och GetWorkflowTree hämtar alla aktiviteter i arbetsflödet.

I följande exempel definieras en CreateState aktivitet. Aktiviteten CreateState måste finnas i en CreateCountry aktivitet och GetParent metoden returnerar en begränsning som framtvingar detta krav. GetParent använder aktiviteten GetParentChain tillsammans med en ForEach<T> aktivitet för att inspektera de överordnade aktiviteterna till CreateState-aktiviteten och avgöra om kravet uppfylls.

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

Ytterligare begränsningar

Författare av arbetsflödets värd kan ange ytterligare valideringsbegränsningar för aktiviteter i ett arbetsflöde genom att skapa begränsningar och lägga till dem i ordlistan för en AdditionalConstraints-instans ValidationSettings. Varje objekt i AdditionalConstraints innehåller den typ av aktivitet som begränsningarna gäller för och en lista över ytterligare begränsningar för den typen av aktivitet. När valideringen anropas för arbetsflödet utvärderar varje aktivitet av den angivna typen, inklusive härledda klasser, begränsningarna. I det här exemplet tillämpas villkoret ActivityDisplayNameIsNotSetWarning från föregående avsnitt på alla aktiviteter i ett arbetsflöde.

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

OnlyUseAdditionalConstraints Om egenskapen ValidationSettings för är trueutvärderas endast de angivna ytterligare begränsningarna när valideringen anropas genom att anropa Validate. Detta kan vara användbart för att inspektera arbetsflöden för specifika valideringskonfigurationer. Observera dock att när arbetsflödet anropas utvärderas valideringslogik som konfigurerats i arbetsflödet och måste skickas för att arbetsflödet ska börja. Mer information om hur du anropar validering finns i Anropa aktivitetsverifiering.