Restricciones declarativas

Las restricciones declarativas proporcionan un método eficaz de validación para una actividad y sus relaciones con otras actividades. Las restricciones se configuran para una actividad durante el proceso de creación, pero el host de flujo de trabajo también puede especificar restricciones adicionales. En este tema se proporciona información general sobre el uso de restricciones declarativas para proporcionar validación de actividad.

Uso de restricciones declarativas

Una restricción es una actividad que contiene lógica de validación. Esta actividad de restricción se puede crear en código o en XAML. Una vez creada una actividad de restricción, los autores de la actividad agregan esta restricción a la Constraints propiedad de la actividad que se va a validar o usan la restricción para proporcionar validación adicional mediante la AdditionalConstraints propiedad de una ValidationSettings instancia. La lógica de validación puede constar de validaciones simples, como validar los metadatos de una actividad, pero también puede realizar la validación que tenga en cuenta la relación de la actividad actual con sus actividades primarias, secundarias y relacionadas. Las restricciones se crean mediante la Constraint<T> actividad y se proporcionan varias actividades de validación adicionales para ayudar con la creación de errores y advertencias de validación y para proporcionar información sobre las actividades relacionadas en el flujo de trabajo.

AssertValidation y AddValidationError

La AssertValidation actividad evalúa la expresión a la que hace referencia su Assertion propiedad y, si la expresión se evalúa como false, se agrega un error de validación o una advertencia a ValidationResults. La Message propiedad describe el error de validación y la IsWarning propiedad indica si el error de validación es un error o una advertencia. El valor predeterminado de IsWarning es false.

En el ejemplo siguiente, se declara una restricción que devuelve una advertencia de validación si la DisplayName de la actividad que se está validando es de dos caracteres o menos de longitud. El parámetro de tipo genérico usado para Constraint<T> especifica el tipo de actividad que valida la restricción. Esta restricción usa Activity como tipo genérico y se puede usar para validar todos los tipos de actividades.

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 esta restricción para una actividad, se agrega a Constraints de la actividad , como se muestra en el código de ejemplo siguiente.

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

El host también podría especificar esta restricción para las actividades de un flujo de trabajo mediante AdditionalConstraints, que se trata en la sección siguiente.

La AddValidationError actividad se usa para generar un error de validación o una advertencia sin necesidad de evaluar una expresión. Sus propiedades son similares a AssertValidation y se pueden usar junto con las actividades de control de flujo de una restricción, como la If actividad.

Actividades de relación de flujo de trabajo

Hay varias actividades de validación disponibles que proporcionan información sobre las demás actividades del flujo de trabajo en relación con la actividad que se está validando. GetParentChain devuelve una colección de actividades que contiene todas las actividades entre la actividad actual y la actividad raíz. GetChildSubtree proporciona una colección de actividades que contiene las actividades secundarias en un patrón recursivo y GetWorkflowTree obtiene todas las actividades del flujo de trabajo.

En el ejemplo siguiente, se define una CreateState actividad. La CreateState actividad debe estar contenida dentro de una CreateCountry actividad y el GetParent método devuelve una restricción que exige este requisito. GetParent usa la GetParentChain actividad junto con una ForEach<T> actividad para inspeccionar las actividades primarias de la CreateState actividad para determinar si se cumple el requisito.

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

Restricciones adicionales

Los autores de host de flujo de trabajo pueden especificar las restricciones de validación adicionales para las actividades en un flujo de trabajo creando las restricciones y agregándolas al diccionario de la propiedad AdditionalConstraints de una instancia de ValidationSettings. Cada elemento AdditionalConstraints de contiene el tipo de actividad para el que se aplican las restricciones y una lista de las restricciones adicionales para ese tipo de actividad. Cuando se invoca la validación para el flujo de trabajo, cada actividad del tipo especificado, incluidas las clases derivadas, evalúa las restricciones. En este ejemplo, la ActivityDisplayNameIsNotSetWarning restricción de la sección anterior se aplica a todas las actividades de un flujo de trabajo.

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

Si la OnlyUseAdditionalConstraints propiedad de ValidationSettings es true, solo se evalúan las restricciones adicionales especificadas cuando se invoca la validación llamando a Validate. Esto puede ser útil para inspeccionar flujos de trabajo para configuraciones de validación específicas. Tenga en cuenta, no obstante, que cuando se invoca el flujo de trabajo, la lógica de validación configurada en el flujo de trabajo se evalúa y debe aprobarse para que el flujo de trabajo pueda comenzar con éxito. Para obtener más información sobre la invocación de validación, vea Invocación de validación de actividad.