Wymagane argumenty i grupy przeciążenia

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żyj 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 aktywność Add jest definiowana przy użyciu trzech argumentów i używa aktywności Assign<T> 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 / Notatka

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. Aktywność jest prawidłowa, gdy w grupie przeciążeniowej powiązany jest tylko jeden zestaw argumentów. 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, albo argumenty ProviderName i ConnectionString muszą być powiązane, albo argument ConfigName, ale nie oba jednocześnie.

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

  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ążeniowe mogą się nakładać, ale jest to błąd, jeżeli przecięcie tych grup zawiera wszystkie wymagane argumenty jednej lub obu grup. W poprzednim przykładzie grupy przeciążeń G2 i G3 nakładały się, ale ponieważ część wspólna nie zawierała wszystkich argumentów jednej lub obu grup, było to poprawne.

Wiążąc argumenty w grupie przeciążeniowej:

• 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 ma żadnych argumentów RequiredArgument.
• Jest błędem, gdy więcej niż jedna grupa przeciążenia jest powiązana, tzn. wszystkie wymagane argumenty w jednej grupie przeciążenia są powiązane i którykolwiek argument w innej grupie przeciążenia jest również powiązany.