Wymagane argumenty i grupy metod przeciążonych

Działania można skonfigurować tak, aby niektóre argumenty musiały być powiązane, aby działanie było prawidłowe do wykonania. Atrybut RequiredArgument służy do wskazywania, że niektóre argumenty działania są wymagane, a OverloadGroup atrybut służy do grupowania kategorii wymaganych argumentów. Korzystając z atrybutów, autorzy działań mogą udostępniać proste lub złożone konfiguracje weryfikacji działań.

Używanie wymaganych argumentów

Aby użyć atrybutu RequiredArgument w działaniu, wskaż żądane argumenty przy użyciu polecenia RequiredArgumentAttribute. W tym przykładzie Add zdefiniowano działanie, które ma dwa wymagane argumenty.

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

W języku XAML wymagane argumenty są również wskazywane przy użyciu metody RequiredArgumentAttribute. W tym przykładzie działanie jest definiowane Add przy użyciu trzech argumentów i używa Assign<T> działania do wykonania operacji dodawania.

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

Jeśli działanie jest używane i którykolwiek z wymaganych argumentów nie jest powiązany, zwracany jest następujący błąd weryfikacji.

Nie podano wartości wymaganego argumentu działania "Operand1".

Uwaga

Aby uzyskać więcej informacji na temat sprawdzania błędów i ostrzeżeń walidacji oraz obsługi ich, zobacz Wywoływanie walidacji działania.

Korzystanie z grup przeciążenia

Grupy przeciążenia zapewniają metodę wskazującą, które kombinacje argumentów są prawidłowe w działaniu. Argumenty są grupowane razem przy użyciu polecenia OverloadGroupAttribute. Każda grupa ma nazwę określoną przez element OverloadGroupAttribute. Działanie jest prawidłowe, gdy jest powiązany tylko jeden zestaw argumentów w grupie przeciążeń. W poniższym przykładzie zdefiniowano klasę CreateLocation .

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

Celem tego działania jest określenie lokalizacji w STANACH Zjednoczonych. W tym celu użytkownik działania może określić lokalizację przy użyciu jednej z trzech grup argumentów. Aby określić prawidłowe kombinacje argumentów, zdefiniowano trzy grupy przeciążenia. G1 zawiera argumenty Latitude i Longitude . G2 zawiera Street, Cityi State. G3 zawiera Street i Zip. Name jest również wymaganym argumentem, ale nie jest częścią grupy przeciążeń. Aby to działanie było prawidłowe, Name musi być powiązane ze wszystkimi argumentami z jednej i tylko jednej grupy przeciążeń.

W poniższym przykładzie pobranym z przykładu Działania dostępu do bazy danych istnieją dwie grupy przeciążenia: ConnectionString i ConfigFileSectionName. Aby to działanie było prawidłowe, ProviderName argumenty i ConnectionString muszą być powiązane lub ConfigName argumenty, ale nie oba.

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

Podczas definiowania grupy przeciążenia:

• Grupa przeciążeń nie może być podzbiorem ani równoważnym zestawem innej grupy przeciążeń.

  Uwaga

  Istnieje jeden wyjątek od tej reguły. Jeśli grupa przeciążeń jest podzbiorem innej grupy przeciążeń, a podzbiór zawiera tylko argumenty, gdzie RequiredArgument jest false, grupa przeciążeń jest prawidłowa.

• Grupy przeciążenia mogą się nakładać, ale jest to błąd, jeśli przecięcie grup zawiera wszystkie wymagane argumenty jednej lub obu grup przeciążeń. W poprzednim przykładzie G2 grupy i G3 przeciążenia nakładały się na siebie, ale ponieważ skrzyżowanie nie zawierało wszystkich argumentów jednej lub obu grup, było to prawidłowe.

Gdy argumenty powiązania w grupie przeciążeń:

• Grupa przeciążeń jest uznawana za powiązaną, jeśli wszystkie RequiredArgument argumenty w grupie są powiązane.

• Jeśli grupa ma zero RequiredArgument argumentów i co najmniej jeden argument powiązany, grupa jest traktowana jako powiązana.

• Jest to błąd weryfikacji, jeśli grupy przeciążenia nie są powiązane, chyba że jedna grupa przeciążenia nie RequiredArgument ma w niej żadnych argumentów.

• Jest to błąd, aby mieć więcej niż jedną granicę grupy przeciążenia, czyli wszystkie wymagane argumenty w jednej grupie przeciążenia są powiązane i każdy argument w innej grupie przeciążenia jest również powiązany.