Restrições declarativas

Restrições declarativas fornecem um método avançado de validação para uma atividade e suas relações com outras atividades. As restrições são configuradas para uma atividade durante o processo de criação, mas restrições adicionais também podem ser especificadas pelo host de fluxo de trabalho. Este tópico fornece uma visão geral do uso de restrições declarativas para fornecer validação de atividade.

Usando restrições declarativas

Uma restrição é uma atividade que contém a lógica de validação. Essa atividade de restrição pode ser criada no código ou em XAML. Depois que uma atividade de restrição é criada, os autores da atividade adicionam essa restrição à Constraints propriedade da atividade a ser validada ou usam a restrição para fornecer validação adicional usando a AdditionalConstraints propriedade de uma ValidationSettings instância. A lógica de validação pode consistir em validações simples, como validar metadados de uma atividade, mas também pode executar a validação que leva em conta a relação da atividade atual com suas atividades pai, filho e irmão. As restrições são criadas usando a Constraint<T> atividade e várias atividades de validação adicionais são fornecidas para auxiliar na criação de erros e avisos de validação e fornecer informações sobre atividades relacionadas no fluxo de trabalho.

AssertValidation e AddValidationError

A AssertValidation atividade avalia a expressão referenciada pela sua Assertion propriedade e, se a expressão for avaliada como false, um erro de validação ou aviso será adicionado ao ValidationResults. A Message propriedade descreve o erro de validação e a IsWarning propriedade indica se a falha de validação é um erro ou um aviso. O valor padrão para IsWarning é false.

No exemplo a seguir, uma restrição é declarada que retorna um aviso de validação se a DisplayName atividade que está sendo validada tiver dois caracteres ou menos de comprimento. O parâmetro de tipo genérico usado para Constraint<T> especifica o tipo de atividade validado pela restrição. Essa restrição usa Activity como o tipo genérico e pode ser usada para validar todos os tipos de atividades.

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

Para especificar essa restrição para uma atividade, ela é adicionada à Constraints atividade, conforme mostrado no código de exemplo a seguir.

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

O host também pode especificar essa restrição para atividades em um fluxo de trabalho usando AdditionalConstraints, que é abordado na próxima seção.

A AddValidationError atividade é usada para gerar um erro ou aviso de validação sem exigir a avaliação de uma expressão. Suas propriedades são semelhantes às de AssertValidation e podem ser usadas em conjunto com atividades de controle de fluxo de uma restrição, como a atividade If.

Atividades de relação de fluxo de trabalho

Há várias atividades de validação disponíveis que fornecem informações sobre as outras atividades no fluxo de trabalho em relação à atividade que está sendo validada. GetParentChain retorna uma coleção de atividades que contém todas as atividades entre a atividade atual e a atividade raiz. GetChildSubtree fornece uma coleção de atividades que contém as atividades filho em um padrão recursiva, e GetWorkflowTree obtém todas as atividades no fluxo de trabalho.

No exemplo a seguir, uma atividade de CreateState é definida. A CreateState atividade deve estar contida em uma CreateCountry atividade e o GetParent método retorna uma restrição que impõe esse requisito. GetParent usa a atividade de GetParentChain em conjunto com uma atividade de ForEach<T> verificar as atividades pai de atividade de CreateState para determinar se o requisito é atingido.

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

Restrições adicionais

Os autores de host de fluxo de trabalho podem especificar restrições adicionais de validação para atividades em um fluxo de trabalho criando as restrições e adicionando ao dicionário de AdditionalConstraints de uma instância de ValidationSettings . AdditionalConstraints Cada item contém o tipo de atividade para o qual as restrições se aplicam e uma lista das restrições adicionais para esse tipo de atividade. Quando a validação é invocada para o fluxo de trabalho, cada atividade do tipo especificado, incluindo classes derivadas, avalia as restrições. Neste exemplo, a ActivityDisplayNameIsNotSetWarning restrição da seção anterior é aplicada a todas as atividades em um fluxo de trabalho.

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

Se a propriedade de OnlyUseAdditionalConstraints de ValidationSettings é true, então somente as restrições adicionais especificadas são avaliadas quando a validação é chamada chamando o Validate. Isso pode ser útil para inspecionar fluxos de trabalho para configurações de validação específicas. No entanto, observe que, quando o fluxo de trabalho é invocado, a lógica de validação configurada no fluxo de trabalho é avaliada e deve passar para que o fluxo de trabalho seja iniciado com êxito. Para obter mais informações sobre como invocar a validação, consulte Invocando validação de atividade.