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í omezení aktivity autoři aktivity přidají toto omezení k ověření do Constraints vlastnosti aktivity, 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 a sourozeneckým aktivitám. Omezení jsou vytvořena pomocí Constraint<T> aktivity, přičemž několik dalších ověřovacích aktivit pomáhá při vytváření chyb a upozornění na ověřování a poskytuje informace o souvisejících aktivitách v pracovním postupu.

Funkce AssertValidation a AddValidationError

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

V následujícím příkladu je deklarováno omezení, které vrátí upozornění na ověření, pokud délka názvu aktivity, která je ověřována, je dva znaky nebo méně. 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 v rámci omezení, například aktivitou If.

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. GetParent používá aktivitu GetParentChain ve spojení s aktivitou ForEach<T> ke kontrole nadřazených aktivit aktivity CreateState, aby zjistila, 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 hostitelů pracovních postupů mohou určit další ověřovací omezení pro aktivity v pracovním postupu vytvořením omezení a jejich přidáním k AdditionalConstraints slovníku instance ValidationSettings. 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);  
    }  
}  

Pokud je vlastnost OnlyUseAdditionalConstraintsValidationSettings, pak jsou vyhodnocena pouze zadaná další omezení, když je ověření vyvoláno voláním true. 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 validace nakonfigurovaná v pracovním postupu a musí být splněna, 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.