Erforderliche Argumente und Überladungsgruppen

Aktivitäten können so konfiguriert werden, dass bestimmte Argumente erforderlich sind, damit die Aktivität für die Ausführung gültig ist. Das RequiredArgument Attribut wird verwendet, um anzugeben, dass bestimmte Argumente für eine Aktivität erforderlich sind und das OverloadGroup Attribut verwendet wird, um Kategorien der erforderlichen Argumente zusammen zu gruppieren. Mithilfe der Attribute können Aktivitätsautoren einfache oder komplexe Aktivitätsüberprüfungskonfigurationen bereitstellen.

Erforderliche Argumente verwenden

Um das RequiredArgument-Attribut in einer Aktivität zu verwenden, geben Sie die gewünschten Argumente mithilfe von RequiredArgumentAttribute an. In diesem Beispiel wird eine Add Aktivität definiert, die über zwei erforderliche Argumente verfügt.

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 werden notwendige Argumente ebenfalls durch die Verwendung von RequiredArgumentAttribute angezeigt. In diesem Beispiel wird die Add Aktivität mithilfe von drei Argumenten definiert und verwendet eine Assign<T> Aktivität zum Ausführen des Add-Vorgangs.

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

Wenn die Aktivität verwendet wird und eines der erforderlichen Argumente nicht gebunden ist, wird der folgende Überprüfungsfehler zurückgegeben.

Der Wert für ein erforderliches Aktivitätsargument 'Operand1' wurde nicht angegeben.

Hinweis

Weitere Informationen zum Überprüfen und Behandeln von Überprüfungsfehlern und Warnungen finden Sie unter "Aufrufen der Aktivitätsüberprüfung".

Überladungsgruppen verwenden

Überladungsgruppen stellen eine Methode bereit, um anzugeben, welche Kombinationen von Argumenten in einer Aktivität gültig sind. Argumente werden mithilfe von OverloadGroupAttribute zusammengefasst. Jede Gruppe erhält einen Namen, der durch die Vorgaben von OverloadGroupAttribute festgelegt wird. Die Aktivität ist gültig, wenn nur ein Satz von Argumenten in einer Überladungsgruppe gebunden ist. Im folgenden Beispiel wird eine CreateLocation Klasse definiert.

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

Ziel dieser Aktivität ist es, einen Standort in den USA anzugeben. Dazu kann der Benutzer der Aktivität den Standort mithilfe einer von drei Argumentgruppen angeben. Um die gültigen Kombinationen von Argumenten anzugeben, werden drei Überladungsgruppen definiert. G1 enthält die Argumente Latitude und Longitude. G2 enthält Street, Cityund State. G3 enthält Street und Zip. Name ist auch ein erforderliches Argument, ist aber nicht Teil einer Überladungsgruppe. Damit diese Aktivität gültig ist, müsste Name zusammen mit allen Argumenten aus einer (und nur einer) der Überladungsgruppen gebunden werden.

Im folgenden Beispiel, das aus dem Beispiel für Datenbankzugriffsaktivitäten entnommen wurde, gibt es zwei Überladungsgruppen: ConnectionString und ConfigFileSectionName. Damit diese Aktivität gültig ist, müssen entweder die Argumente ProviderName und ConnectionString gebunden sein, oder das Argument ConfigName, aber nicht alle gleichzeitig.

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

Beim Definieren einer Überladungsgruppe:

• Eine Überladungsgruppe kann keine Teilmenge oder eine entsprechende Gruppe einer anderen Überladungsgruppe sein.

  Hinweis

  Es gibt eine Ausnahme für diese Regel. Wenn eine Überladungsgruppe eine Teilmenge einer anderen Überladungsgruppe ist und die Teilmenge nur Argumente enthält, bei denen RequiredArgument gleich false ist, dann ist die Überladungsgruppe gültig.

• Überladungsgruppen können sich überschneiden. Dabei tritt jedoch ein Fehler auf, wenn die Schnittmenge der Gruppen alle erforderlichen Argumente einer oder beider Überladungsgruppen enthält. Im vorherigen Beispiel überlappen sich die G2- und G3-Überladungsgruppen, aber obwohl die Schnittmenge nicht alle Argumente einer oder beider Gruppen enthielt, war dies korrekt.

Beim Binden von Argumenten in einer Überladungsgruppe gilt:

• Eine Überladungsgruppe wird als gebunden betrachtet, wenn alle RequiredArgument Argumente in der Gruppe gebunden sind.
• Wenn eine Gruppe null RequiredArgument Argumente enthält und mindestens ein Argument gebunden ist, wird die Gruppe als gebunden betrachtet.
• Es tritt ein Validierungsfehler auf, wenn keine der Überladungsgruppen gebunden ist, es sei denn, eine Überladungsgruppe enthält keine RequiredArgument-Argumente.
• Es ist ein Fehler, mehrere Überladungsgruppen gebunden zu haben, d. h., alle erforderlichen Argumente in einer Überladungsgruppe sind gebunden, und jedes Argument in einer anderen Überladungsgruppe ist ebenfalls gebunden.