Obligatoriska argument och överlagringsgrupper

Aktiviteter kan konfigureras så att vissa argument krävs för att aktiviteten ska vara giltig för körning. Attributet RequiredArgument används för att indikera att vissa argument för en aktivitet krävs och OverloadGroup att attributet används för att gruppera kategorier av obligatoriska argument tillsammans. Med hjälp av attributen kan aktivitetsförfattare tillhandahålla enkla eller komplexa aktivitetsvalideringskonfigurationer.

Använda nödvändiga argument

Om du vill använda RequiredArgument attributet i en aktivitet anger du önskade argument med hjälp av RequiredArgumentAttribute. I det här exemplet definieras en 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);  
    }  
}  

I XAML anges även obligatoriska argument med hjälp RequiredArgumentAttributeav . I det här exemplet Add definieras aktiviteten med hjälp av tre argument och använder en Assign<T> aktivitet för att utföra tilläggsåtgärden.

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

Om aktiviteten används och något av de argument som krävs inte är bundet returneras följande verifieringsfel.

Värdet för det obligatoriska aktivitetsargumentet Operand1 angavs inte.

Kommentar

Mer information om hur du söker efter och hanterar valideringsfel och varningar finns i Anropa aktivitetsverifiering.

Använda överbelastningsgrupper

Överlagringsgrupper tillhandahåller en metod för att ange vilka kombinationer av argument som är giltiga i en aktivitet. Argument grupperas tillsammans med hjälp OverloadGroupAttributeav . Varje grupp får ett namn som anges av OverloadGroupAttribute. Aktiviteten är giltig när endast en uppsättning argument i en överlagringsgrupp är bundna. I följande exempel definieras en CreateLocation klass.

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

Målet med den här aktiviteten är att ange en plats i USA. För att göra detta kan användaren av aktiviteten ange platsen med hjälp av en av tre grupper med argument. För att ange giltiga kombinationer av argument definieras tre överlagringsgrupper. G1 innehåller argumenten Latitude och Longitude . G2 innehåller Street, Cityoch State. G3 innehåller Street och Zip. Name är också ett obligatoriskt argument, men det ingår inte i en överlagringsgrupp. För att den här aktiviteten ska vara giltig Name måste den bindas samman med alla argument från en och endast en överlagringsgrupp.

I följande exempel, som tas från exemplet Databasåtkomstaktiviteter , finns det två överlagringsgrupper: ConnectionString och ConfigFileSectionName. För att den här aktiviteten ska vara giltig måste antingen argumenten ProviderName och ConnectionString vara bundna eller ConfigName argumentet, men inte båda.

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

När du definierar en överlagringsgrupp:

• En överlagringsgrupp får inte vara en delmängd eller en motsvarande uppsättning av en annan överlagringsgrupp.

  Kommentar

  Det finns ett undantag till den här regeln. Om en överlagringsgrupp är en delmängd av en annan överlagringsgrupp och delmängden endast innehåller argument där RequiredArgument är false, är överlagringsgruppen giltig.

• Överlagringsgrupper kan överlappa varandra, men det är ett fel om skärningspunkten mellan grupperna innehåller alla argument som krävs för en eller båda överbelastningsgrupperna. I föregående exempel G2 överlappade och G3 överlagrade grupperna, men eftersom skärningspunkten inte innehöll alla argument för en eller båda grupperna var detta giltigt.

När du binder argument i en överlagringsgrupp:

• En överlagringsgrupp anses vara bunden om alla RequiredArgument argument i gruppen är bundna.

• Om en grupp har noll RequiredArgument argument och minst ett argument är bundet anses gruppen vara bunden.

• Det är ett verifieringsfel om inga överlagringsgrupper är bundna såvida inte en överlagringsgrupp inte har några RequiredArgument argument i sig.

• Det är ett fel att ha fler än en överlagringsgrupp bunden, dvs. alla nödvändiga argument i en överlagringsgrupp är bundna och alla argument i en annan överlagringsgrupp är också bundna.