Vereiste argumenten en overbelastingsgroepen

Activiteiten kunnen zodanig worden geconfigureerd dat bepaalde argumenten moeten worden gebonden aan de activiteit die geldig is voor uitvoering. Het RequiredArgument kenmerk wordt gebruikt om aan te geven dat bepaalde argumenten voor een activiteit vereist zijn en dat het OverloadGroup kenmerk wordt gebruikt om categorieën van vereiste argumenten te groeperen. Met behulp van de kenmerken kunnen auteurs van activiteiten eenvoudige of complexe configuraties voor activiteitsvalidatie bieden.

Vereiste argumenten gebruiken

Als u het RequiredArgument kenmerk in een activiteit wilt gebruiken, geeft u de gewenste argumenten aan met behulp van RequiredArgumentAttribute. In dit voorbeeld wordt een Add activiteit gedefinieerd met twee vereiste argumenten.

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

In XAML worden vereiste argumenten ook aangeduid met behulp van RequiredArgumentAttribute. In dit voorbeeld wordt de Add activiteit gedefinieerd met behulp van drie argumenten en wordt een Assign<T> activiteit gebruikt om de bewerking toevoegen uit te voeren.

<Activity x:Class="ValidationDemo.Add" ...>  
  <x:Members>  
    <x:Property Name="Operand1" Type="InArgument(x:Int32)">  
      <x:Property.Attributes>  
        <RequiredArgumentAttribute />  
      </x:Property.Attributes>  
    </x:Property>  
    <x:Property Name="Operand2" Type="InArgument(x:Int32)">  
      <x:Property.Attributes>  
        <RequiredArgumentAttribute />  
      </x:Property.Attributes>  
    </x:Property>  
    <x:Property Name="Result" Type="OutArgument(x:Int32)" />  
  </x:Members>  
  <Assign>  
    <Assign.To>  
      <OutArgument x:TypeArguments="x:Int32">[Result]</OutArgument>  
    </Assign.To>  
    <Assign.Value>  
      <InArgument x:TypeArguments="x:Int32">[Operand1 + Operand2]</InArgument>  
    </Assign.Value>  
  </Assign>  
</Activity>  

Als de activiteit wordt gebruikt en een van de vereiste argumenten niet is gebonden, wordt de volgende validatiefout geretourneerd.

Waarde voor een vereist activiteitsargument 'Operand1' is niet opgegeven.

Notitie

Zie Validatie van activiteit aanroepen voor meer informatie over het controleren en afhandelen van validatiefouten en waarschuwingen.

Overbelastingsgroepen gebruiken

Overbelastingsgroepen bieden een methode om aan te geven welke combinaties van argumenten geldig zijn in een activiteit. Argumenten worden gegroepeerd met behulp van OverloadGroupAttribute. Elke groep krijgt een naam die wordt opgegeven door de OverloadGroupAttribute. De activiteit is geldig wanneer slechts één set argumenten in een overbelastingsgroep afhankelijk is. In het volgende voorbeeld wordt een CreateLocation klasse gedefinieerd.

class CreateLocation: Activity  
{  
    [RequiredArgument]  
    public InArgument<string> Name { get; set; }  
  
    public InArgument<string> Description { get; set; }  
  
    [RequiredArgument]  
    [OverloadGroup("G1")]  
    public InArgument<int> Latitude { get; set; }  
  
    [RequiredArgument]  
    [OverloadGroup("G1")]  
    public InArgument<int> Longitude { get; set; }  
  
    [RequiredArgument]  
    [OverloadGroup("G2")]  
    [OverloadGroup("G3")]  
    public InArgument<string> Street { get; set; }  
  
    [RequiredArgument]  
    [OverloadGroup("G2")]  
    public InArgument<string> City { get; set; }  
  
    [RequiredArgument]  
    [OverloadGroup("G2")]  
    public InArgument<string> State { get; set; }  
  
    [RequiredArgument]  
    [OverloadGroup("G3")]  
    public InArgument<int> Zip { get; set; }
}  

Het doel van deze activiteit is om een locatie in de VS op te geven. Hiervoor kan de gebruiker van de activiteit de locatie opgeven met behulp van een van de drie groepen argumenten. Als u de geldige combinaties van argumenten wilt opgeven, worden er drie overbelastingsgroepen gedefinieerd. G1 bevat de Latitude en Longitude argumenten. G2 bevat Street, Cityen State. G3 bevat Street en Zip. Name is ook een vereist argument, maar maakt geen deel uit van een overbelastingsgroep. Als deze activiteit geldig is, Name moet deze worden gekoppeld aan alle argumenten van één en slechts één overbelastingsgroep.

In het volgende voorbeeld uit het voorbeeld databasetoegangsactiviteiten zijn er twee overbelastingsgroepen: ConnectionString en ConfigFileSectionName. Deze activiteit is alleen geldig als de ProviderName argumenten ConnectionString afhankelijk zijn of het ConfigName argument, maar niet beide.

public class DbUpdate: AsyncCodeActivity  
{  
    [RequiredArgument]  
    [OverloadGroup("ConnectionString")]  
    [DefaultValue(null)]  
    public InArgument<string> ProviderName { get; set; }  
  
    [RequiredArgument]  
    [OverloadGroup("ConnectionString")]  
    [DependsOn("ProviderName")]  
    [DefaultValue(null)]  
    public InArgument<string> ConnectionString { get; set; }  
  
    [RequiredArgument]  
    [OverloadGroup("ConfigFileSectionName")]  
    [DefaultValue(null)]  
    public InArgument<string> ConfigName { get; set; }  
  
    [DefaultValue(null)]  
    public CommandType CommandType { get; set; }  
  
    [RequiredArgument]  
    public InArgument<string> Sql { get; set; }  
  
    [DependsOn("Sql")]  
    [DefaultValue(null)]  
    public IDictionary<string, Argument> Parameters { get; }  
  
    [DependsOn("Parameters")]  
    public OutArgument<int> AffectedRecords { get; set; }
}  

Bij het definiëren van een overbelastingsgroep:

• Een overbelastingsgroep kan geen subset of een equivalente set van een andere overbelastingsgroep zijn.

  Notitie

  Er is één uitzondering op deze regel. Als een overbelastingsgroep een subset is van een andere overbelastingsgroep en de subset alleen argumenten bevat, RequiredArgument falseis de overbelastingsgroep geldig.

• Overbelastingsgroepen kunnen overlappen, maar het is een fout als het snijpunt van de groepen alle vereiste argumenten van een of beide overbelastingsgroepen bevat. In het vorige voorbeeld overlappen de G2 groepen en G3 overbelastingen elkaar, maar omdat het snijpunt niet alle argumenten van een of beide groepen bevat, is dit geldig.

Bij bindingsargumenten in een overbelastingsgroep:

• Een overbelastingsgroep wordt beschouwd als afhankelijk als alle RequiredArgument argumenten in de groep zijn gebonden.

• Als een groep nul RequiredArgument argumenten en ten minste één argumentgrens heeft, wordt de groep beschouwd als afhankelijk.

• Het is een validatiefout als er geen overbelastingsgroepen zijn gebonden, tenzij één overbelastingsgroep geen RequiredArgument argumenten bevat.

• Het is een fout dat er meer dan één overbelastingsgroep is gebonden, dat wil gezegd dat alle vereiste argumenten in de ene overbelastingsgroep gebonden zijn en elk argument in een andere overbelastingsgroep ook afhankelijk is.