Povinné argumenty a skupiny přetížení

Aktivity je možné nakonfigurovat tak, aby určité argumenty musely být vázány, aby aktivita byla platná pro spuštění. Atribut RequiredArgument slouží k označení, že určité argumenty aktivity jsou povinné a OverloadGroup atribut se používá k seskupení kategorií požadovaných argumentů. Pomocí atributů můžou autoři aktivit poskytovat jednoduché nebo složité konfigurace ověřování aktivit.

Použití povinných argumentů

Chcete-li použít RequiredArgument atribut v aktivitě, uveďte požadované argumenty pomocí RequiredArgumentAttribute. V tomto příkladu je definována Add aktivita, která má dva povinné 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);  
    }  
}  

V jazyce XAML jsou povinné argumenty také označeny pomocí .RequiredArgumentAttribute V tomto příkladu Add je aktivita definována pomocí tří argumentů a používá Assign<T> aktivitu k provedení operace přidání.

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

Pokud se použije aktivita a některý z požadovaných argumentů není vázán na následující chybu ověření, vrátí se následující chyba ověření.

Hodnota argumentu požadované aktivity Operand1 nebyla zadána.

Poznámka:

Další informace o kontrole a zpracování chyb a upozornění ověřování najdete v tématu Vyvolání ověření aktivity.

Použití skupin přetížení

Skupiny přetížení poskytují metodu pro určení, které kombinace argumentů jsou platné v aktivitě. Argumenty jsou seskupené pomocí .OverloadGroupAttribute Každé skupině je přidělen název, který je určen .OverloadGroupAttribute Aktivita je platná, pokud je vázána pouze jedna sada argumentů ve skupině přetížení. V následujícím příkladu je definována CreateLocation třída.

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

Cílem této aktivity je určit umístění v USA. K tomu může uživatel aktivity zadat umístění pomocí jedné ze tří skupin argumentů. Chcete-li určit platné kombinace argumentů, jsou definovány tři skupiny přetížení. G1 obsahuje argumenty Latitude a Longitude argumenty. G2 obsahuje Street, Citya State. G3 obsahuje Street a Zip. Name je také povinný argument, ale není součástí skupiny přetížení. Aby byla tato aktivita platná, Name musí být vázána společně se všemi argumenty z jedné a pouze jedné skupiny přetížení.

V následujícím příkladu , odebraných z ukázky aktivit accessové databáze, existují dvě skupiny přetížení: ConnectionString a ConfigFileSectionName. Aby byla tato aktivita platná, ProviderName musí být buď svázané, ConnectionString nebo ConfigName argumenty, ale ne 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; }
}  

Při definování skupiny přetížení:

• Skupina přetížení nemůže být podmnožinou nebo ekvivalentní sadou jiné skupiny přetížení.

  Poznámka:

  Toto pravidlo má jednu výjimku. Pokud je skupina přetížení podmnožinou jiné skupiny přetížení a podmnožina obsahuje pouze argumenty, kde RequiredArgument je false, pak je skupina přetížení platná.

• Skupiny přetížení se můžou překrývat, ale jedná se o chybu, pokud průnik skupin obsahuje všechny požadované argumenty jedné nebo obou skupin přetížení. V předchozím příkladu se G2 skupiny přetížení G3 překrývaly, ale protože průnik neobsahoval všechny argumenty jedné nebo obou skupin, které byly platné.

Při vazbě argumentů ve skupině přetížení:

• Skupina přetížení se považuje za vázanou, RequiredArgument pokud jsou všechny argumenty ve skupině vázány.

• Pokud má skupina nula RequiredArgument argumentů a alespoň jeden argument vázán, je skupina považována za vázanou.

• Jedná se o chybu ověření, pokud nejsou vázány žádné skupiny přetížení, pokud jedna skupina přetížení nemá žádné RequiredArgument argumenty.

• Jedná se o chybu, že je vázáno více než jedna skupina přetížení, to znamená, že všechny požadované argumenty v jedné skupině přetížení jsou vázány a všechny argumenty v jiné skupině přetížení jsou také vázány.