Deklarativní omezení

Deklarativní omezení poskytují výkonnou metodu ověřování pro aktivitu a její vztahy s jinými aktivitami. Omezení se konfigurují pro aktivitu během procesu vytváření, ale hostitel pracovního postupu může také určit další omezení. Toto téma obsahuje přehled použití deklarativních omezení k zajištění ověřování aktivit.

Použití deklarativních omezení

Omezení je aktivita, která obsahuje logiku ověřování. Tuto aktivitu omezení lze vytvořit v kódu nebo v xaml. Po vytvoření aktivity omezení autoři aktivity toto omezení přidají do Constraints vlastnosti aktivity k ověření, nebo používají omezení k poskytnutí dalšího ověření pomocí AdditionalConstraints vlastnosti ValidationSettings instance. Logika ověřování se může skládat z jednoduchých ověření, jako je ověřování metadat aktivity, ale může také provádět ověření, které bere v úvahu vztah aktuální aktivity k nadřazeným, podřízeným položkám a aktivitám na stejné straně. Omezení jsou vytvořena pomocí Constraint<T> aktivity a poskytuje několik dalších ověřovacích aktivit, které pomáhají při vytváření chyb ověřování a upozornění a poskytování informací o souvisejících aktivitách v pracovním postupu.

AssertValidation a AddValidationError

Aktivita AssertValidation vyhodnocuje výraz, na který odkazuje jeho Assertion vlastnost, a pokud se výraz vyhodnotí jako false, přidá se do objektu ValidationResults. Vlastnost Message popisuje chybu ověření a IsWarning vlastnost označuje, zda je chyba ověření chyba nebo upozornění. Výchozí hodnota je IsWarningfalse.

V následujícím příkladu je omezení deklarováno, které vrátí upozornění na ověření, pokud DisplayName je ověřená aktivita dva znaky nebo kratší. Parametr obecného typu použitý pro Constraint<T> určuje typ aktivity, která je ověřena omezením. Toto omezení se používá Activity jako obecný typ a lze ho použít k ověření všech typů aktivit.

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

Chcete-li určit toto omezení pro aktivitu, přidá se do Constraints aktivity, jak je znázorněno v následujícím ukázkovém kódu.

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

Hostitel může také určit toto omezení pro aktivity v pracovním postupu pomocí AdditionalConstraints, který je popsán v další části.

Aktivita AddValidationError se používá k vygenerování chyby ověření nebo upozornění bez nutnosti vyhodnocení výrazu. Jeho vlastnosti jsou podobné AssertValidation a lze jej použít ve spojení s aktivitami řízení toku omezení, jako If je aktivita.

Aktivity vztahů pracovního postupu

K dispozici je několik aktivit ověřování, které poskytují informace o ostatních aktivitách v pracovním postupu ve vztahu k ověřované aktivitě. GetParentChain vrátí kolekci aktivit, které obsahují všechny aktivity mezi aktuální aktivitou a kořenovou aktivitou. GetChildSubtree poskytuje kolekci aktivit, které obsahují podřízené aktivity v rekurzivním vzoru, a GetWorkflowTree získá všechny aktivity v pracovním postupu.

V následujícím příkladu je definována CreateState aktivita. Aktivita CreateState musí být obsažena v aktivitě CreateCountry a GetParent metoda vrací omezení, které tento požadavek vynucuje. GetParentGetParentChain používá aktivitu ve spojení s aktivitou ForEach<T> ke kontrole nadřazených CreateState aktivit aktivity, aby určila, zda je požadavek splněn.

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

Další omezení

Autoři hostitele pracovního postupu můžou určit další omezení ověřování pro aktivity v pracovním postupu vytvořením omezení a jejich přidáním do AdditionalConstraints slovníku ValidationSettings instance. Každá položka obsahuje AdditionalConstraints typ aktivity, pro kterou platí omezení, a seznam dalších omezení pro daný typ aktivity. Při vyvolání ověřování pro pracovní postup vyhodnocuje každá aktivita zadaného typu, včetně odvozených tříd, omezení. V tomto příkladu ActivityDisplayNameIsNotSetWarning se omezení z předchozí části použije na všechny aktivity v pracovním postupu.

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 Pokud je truevlastnost ValidationSettings , pak pouze zadaná další omezení jsou vyhodnocena při ověření vyvolána voláním Validate. To může být užitečné při kontrole pracovních postupů pro konkrétní konfigurace ověřování. Všimněte si však, že při vyvolání pracovního postupu se vyhodnotí logika ověření nakonfigurovaná v pracovním postupu a musí předat, aby se pracovní postup úspěšně zahájil. Další informace o vyvolání ověřování naleznete v tématu Vyvolání ověření aktivity.