Anropa aktivitetsverifiering

Aktivitetsverifiering ger en metod för att identifiera och rapportera fel i någon aktivitets konfiguration innan den körs. Validering sker när ett arbetsflöde ändras i arbetsflödesdesignern och eventuella valideringsfel eller varningar visas i arbetsflödesdesignern. Validering sker också vid körning när ett arbetsflöde anropas och om några valideringsfel inträffar genereras en InvalidWorkflowException av standardverifieringslogik. Windows Workflow Foundation (WF) tillhandahåller klassen ActivityValidationServices som kan användas av arbetsflödesprogram och verktygsutvecklare för att explicit verifiera en aktivitet. I det här avsnittet beskrivs hur du använder ActivityValidationServices för att utföra aktivitetsverifiering.

Använda ActivityValidationServices

ActivityValidationServices har två Validate överlagringar som används för att anropa en aktivitets valideringslogik. Den första överlagringen tar rotaktiviteten att verifieras och returnerar en samling valideringsfel och varningar. I följande exempel används en anpassad Add aktivitet som har två obligatoriska argument.

public sealed class Add : CodeActivity<int>  
{  
    [RequiredArgument]  
    public InArgument<int> Operand1 { get; set; }  
  
    [RequiredArgument]  
    public InArgument<int> Operand2 { get; set; }  
  
    protected override int Execute(CodeActivityContext context)  
    {  
        return Operand1.Get(context) + Operand2.Get(context);  
    }  
}  

Aktiviteten Add används i en Sequence, men dess två obligatoriska argument är inte bundna, som du ser i följande exempel.

Variable<int> Operand1 = new Variable<int>{ Default = 10 };  
Variable<int> Operand2 = new Variable<int>{ Default = 15 };  
Variable<int> Result = new Variable<int>();  
  
Activity wf = new Sequence  
{  
    Variables = { Operand1, Operand2, Result },  
    Activities =
    {  
        new Add(),  
        new WriteLine  
        {  
            Text = new InArgument<string>(env => "The result is " + Result.Get(env))  
        }  
    }  
};  

Det här arbetsflödet kan verifieras genom att anropa Validate. Validate returnerar en samling av valideringsfel eller varningar som ingår i aktiviteten och eventuella underordnade objekt, enligt följande exempel.

ValidationResults results = ActivityValidationServices.Validate(wf);  
  
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: {0}", error.Message);  
    }  
    foreach (ValidationError warning in results.Warnings)  
    {  
        Console.WriteLine("Warning: {0}", warning.Message);  
    }  
}  

När Validate anropas i det här exempelarbetsflödet returneras två valideringsfel.

Fel: Värdet för det obligatoriska aktivitetsargumentet Operand2 angavs inte.
Fel: Värdet för det obligatoriska aktivitetsargumentet Operand1 angavs inte. Om det här arbetsflödet anropades utlöses ett InvalidWorkflowException , enligt följande exempel.

try  
{  
    WorkflowInvoker.Invoke(wf);  
}  
catch (Exception ex)  
{  
    Console.WriteLine(ex);  
}  

System.Activities.InvalidWorkflowException:
Följande fel påträffades när arbetsflödesträdet bearbetades:"Lägg till": Värdet för ett obligatoriskt aktivitetsargument "Operand2" angavs inte. Lägg till: Värdet för det obligatoriska aktivitetsargumentet Operand1 angavs inte. För att det här exempelarbetsflödet ska vara giltigt måste de två obligatoriska argumenten för Add aktiviteten vara bundna. I följande exempel är de två obligatoriska argumenten bundna till arbetsflödesvariabler tillsammans med resultatvärdet. I det här exemplet är argumentet bundet Result tillsammans med de två argument som krävs. Argumentet Result måste inte vara bundet och orsakar inte ett verifieringsfel om det inte är det. Det är arbetsflödesförfattarens ansvar att binda Result om dess värde används någon annanstans i arbetsflödet.

new Add  
{  
    Operand1 = Operand1,  
    Operand2 = Operand2,  
    Result = Result  
}  

Verifiera nödvändiga argument för rotaktiviteten

Om rotaktiviteten för ett arbetsflöde har argument är dessa inte bundna förrän arbetsflödet anropas och parametrar skickas till arbetsflödet. Följande arbetsflöde godkänns validering, men ett undantag utlöses om arbetsflödet anropas utan att de argument som krävs skickas, som du ser i följande exempel.

Activity wf = new Add();  
  
ValidationResults results = ActivityValidationServices.Validate(wf);  
// results has no errors or warnings, but when the workflow  
// is invoked, an InvalidWorkflowException is thrown.  
try  
{  
    WorkflowInvoker.Invoke(wf);  
}  
catch (Exception ex)  
{  
    Console.WriteLine(ex);  
}  

System.ArgumentException: Rotaktivitetens argumentinställningar är felaktiga.
Åtgärda antingen arbetsflödesdefinitionen eller ange indatavärden för att åtgärda dessa fel:"Lägg till": Värdet för det obligatoriska aktivitetsargumentet Operand2 angavs inte. Lägg till: Värdet för det obligatoriska aktivitetsargumentet Operand1 angavs inte. När rätt argument har skickats slutförs arbetsflödet, enligt följande exempel.

Add wf = new Add();  
  
ValidationResults results = ActivityValidationServices.Validate(wf);  
// results has no errors or warnings, and the workflow completes  
// successfully because the required arguments were passed.  
try  
{  
    Dictionary<string, object> wfparams = new Dictionary<string, object>  
    {  
        { "Operand1", 10 },  
        { "Operand2", 15 }  
    };  
  
    int result = WorkflowInvoker.Invoke(wf, wfparams);  
    Console.WriteLine("Result: {0}", result);  
}  
catch (Exception ex)  
{  
    Console.WriteLine(ex);  
}  

När du verifierar rotargument är det värdprogrammets ansvar att se till att alla nödvändiga argument skickas när arbetsflödet anropas.

Anropa imperativ kodbaserad validering

Imperativ kodbaserad validering är ett enkelt sätt för en aktivitet att tillhandahålla verifiering om sig själv och är tillgänglig för aktiviteter som härleds från CodeActivity, AsyncCodeActivityoch NativeActivity. Verifieringskod som avgör eventuella valideringsfel eller varningar läggs till i aktiviteten. När verifieringen anropas för aktiviteten finns dessa varningar eller fel i samlingen som returneras av anropet till Validate. I följande exempel definieras en CreateProduct aktivitet. Cost Om är större än Priceläggs ett valideringsfel till i metadata i åsidosättningenCacheMetadata.

public sealed class CreateProduct : CodeActivity  
{  
    public double Price { get; set; }  
    public double Cost { get; set; }  
  
    // [RequiredArgument] attribute will generate a validation error
    // if the Description argument is not set.  
    [RequiredArgument]  
    public InArgument<string> Description { get; set; }  
  
    protected override void CacheMetadata(CodeActivityMetadata metadata)  
    {  
        base.CacheMetadata(metadata);  
        // Determine when the activity has been configured in an invalid way.  
        if (this.Cost > this.Price)  
        {  
            // Add a validation error with a custom message.  
            metadata.AddValidationError("The Cost must be less than or equal to the Price.");  
        }  
    }  
  
    protected override void Execute(CodeActivityContext context)  
    {  
        // Not needed for the sample.  
    }  
}  

I det här exemplet konfigureras ett arbetsflöde med hjälp av CreateProduct aktiviteten. I det här arbetsflödet Cost är större än Price, och det obligatoriska Description argumentet har inte angetts. När verifieringen anropas returneras följande fel.

Activity wf = new Sequence  
{  
    Activities =
    {  
        new CreateProduct  
        {  
            Cost = 75.00,  
            Price = 55.00  
            // Cost > Price and required Description argument not set.  
        },  
        new WriteLine  
        {  
            Text = "Product added."  
        }  
    }  
};  
  
ValidationResults results = ActivityValidationServices.Validate(wf);  
  
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: {0}", error.Message);  
    }  
    foreach (ValidationError warning in results.Warnings)  
    {  
        Console.WriteLine("Warning: {0}", warning.Message);  
    }  
}  

Fel: Kostnaden måste vara mindre än eller lika med priset.
Fel: Värdet för det obligatoriska aktivitetsargumentet "Description" angavs inte.

Använda validering Inställningar

Som standard utvärderas alla aktiviteter i aktivitetsträdet när valideringen anropas av ActivityValidationServices. ValidationSettings gör att valideringen kan anpassas på flera olika sätt genom att konfigurera dess tre egenskaper. SingleLevel anger om validatorn ska gå genom hela aktivitetsträdet eller endast tillämpa valideringslogik på den angivna aktiviteten. Standardvärdet för det här värdet är false. AdditionalConstraints anger ytterligare villkorsmappning från en typ till en lista med begränsningar. För bastypen för varje aktivitet i aktivitetsträdet som verifieras finns det en sökning i AdditionalConstraints. Om en matchande begränsningslista hittas utvärderas alla begränsningar i listan för aktiviteten. OnlyUseAdditionalConstraints anger om validatorn ska utvärdera alla begränsningar eller endast de som anges i AdditionalConstraints. Standardvärdet är false. AdditionalConstraints och OnlyUseAdditionalConstraints är användbara för arbetsflödesvärdförfattare att lägga till ytterligare validering för arbetsflöden, till exempel principbegränsningar för verktyg som FxCop. Mer information om begränsningar finns i Deklarativa begränsningar.

Om du vill använda ValidationSettingskonfigurerar du önskade egenskaper och skickar sedan det i anropet till Validate. I det här exemplet verifieras ett arbetsflöde som består av en Sequence med en anpassad Add aktivitet. Aktiviteten Add har två obligatoriska argument.

public sealed class Add : CodeActivity<int>  
{  
    [RequiredArgument]  
    public InArgument<int> Operand1 { get; set; }  
  
    [RequiredArgument]  
    public InArgument<int> Operand2 { get; set; }  
  
    protected override int Execute(CodeActivityContext context)  
    {  
        return Operand1.Get(context) + Operand2.Get(context);  
    }  
}  

Följande Add aktivitet används i en Sequence, men dess två obligatoriska argument är inte bundna.

Variable<int> Operand1 = new Variable<int> { Default = 10 };  
Variable<int> Operand2 = new Variable<int> { Default = 15 };  
Variable<int> Result = new Variable<int>();  
  
Activity wf = new Sequence  
{  
    Variables = { Operand1, Operand2, Result },  
    Activities =
    {  
        new Add(),  
        new WriteLine  
        {  
            Text = new InArgument<string>(env => "The result is " + Result.Get(env))  
        }  
    }  
};  

I följande exempel utförs valideringen med SingleLevel inställt på true, så endast rotaktiviteten Sequence verifieras.

ValidationSettings settings = new ValidationSettings  
{  
    SingleLevel = true  
};  
  
ValidationResults results = ActivityValidationServices.Validate(wf, settings);  
  
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: {0}", error.Message);  
    }  
    foreach (ValidationError warning in results.Warnings)  
    {  
        Console.WriteLine("Warning: {0}", warning.Message);  
    }  
}  

Den här koden visar följande utdata:

Inga varningar eller fel Även om Add aktiviteten har obligatoriska argument som inte är bundna lyckas valideringen eftersom endast rotaktiviteten utvärderas. Den här typen av validering är användbar för att endast verifiera specifika element i ett aktivitetsträd, till exempel validering av en egenskapsändring av en enskild aktivitet i en designer. Observera att om det här arbetsflödet anropas utvärderas den fullständiga valideringen som konfigurerats i arbetsflödet och en InvalidWorkflowException utlöses. ActivityValidationServices och ValidationSettings konfigurera endast validering som uttryckligen anropas av värden och inte den validering som inträffar när ett arbetsflöde anropas.