Argomenti obbligatori e gruppi di sovraccarico

Le attività possono essere configurate in modo che determinati argomenti siano tenuti a essere associati affinché l'attività sia valida per l'esecuzione. L'attributo RequiredArgument viene usato per indicare che alcuni argomenti di un'attività sono obbligatori e l'attributo OverloadGroup viene usato per raggruppare le categorie di argomenti obbligatori. Usando gli attributi, gli autori di attività possono fornire configurazioni di convalida delle attività semplici o complesse.

Usare gli argomenti obbligatori

Per usare l'attributo RequiredArgument in un'attività, indicare gli argomenti desiderati usando RequiredArgumentAttribute. In questo esempio viene definita un'attività Add con due argomenti obbligatori.

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, gli argomenti obbligatori sono indicati anche usando RequiredArgumentAttribute. In questo esempio l'attività Add viene definita usando tre argomenti e usa un'attività Assign<T> per eseguire l'operazione di aggiunta.

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

Se l'attività viene utilizzata e uno degli argomenti obbligatori non è associato, viene restituito l'errore di convalida seguente.

Il valore per un argomento di attività obbligatorio 'Operand1' non è stato specificato.

Annotazioni

Per altre informazioni sul controllo e sulla gestione degli errori e degli avvisi di convalida, vedere Richiamo della convalida delle attività.

Usare i gruppi di overload

I gruppi di overload forniscono un metodo per indicare quali combinazioni di argomenti sono valide in un'attività. Gli argomenti vengono raggruppati usando OverloadGroupAttribute. A ogni gruppo viene assegnato un nome specificato da OverloadGroupAttribute. L'attività è valida quando viene associato un solo set di argomenti in un gruppo di overload. Nell'esempio seguente viene definita una CreateLocation classe .

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

L'obiettivo di questa attività è quello di specificare una località negli Stati Uniti. A tale scopo, l'utente dell'attività può specificare la posizione usando uno dei tre gruppi di argomenti. Per specificare le combinazioni valide di argomenti, vengono definiti tre gruppi di overload. G1 contiene gli argomenti Latitude e Longitude. G2 contiene Street, Citye State. G3 contiene Street e Zip. Name è anche un argomento obbligatorio, ma non fa parte di un gruppo di overload. Affinché questa attività sia valida, Name deve essere associata a tutti gli argomenti di uno e un solo gruppo di overload.

Nell'esempio seguente, tratto dall'esempio Attività di accesso al database, sono presenti due gruppi di overload: ConnectionString e .ConfigFileSectionName Affinché questa attività sia valida, devono essere associati gli argomenti ProviderName e ConnectionString, oppure l'argomento ConfigName, ma non entrambi.

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

Quando si definisce un gruppo di overload:

• Un gruppo di overload non può essere un subset o un set equivalente di un altro gruppo di overload.

  Annotazioni

  Esiste un'eccezione a questa regola. Se un gruppo di overload è un subset di un altro gruppo di overload e il subset contiene solo argomenti dove RequiredArgument è false, il gruppo di overload è valido.

• I gruppi di overload possono sovrapporsi, ma si tratta di un errore se l'intersezione dei gruppi contiene tutti gli argomenti obbligatori di uno o entrambi i gruppi di overload. Nell'esempio precedente, i gruppi di overload G2 e G3 si sovrapponevano, ma poiché l'intersezione non conteneva tutti gli argomenti di uno o entrambi i gruppi, ciò era valido.

Quando si associano argomenti in un gruppo di overload:

• Un gruppo di overload è considerato vincolato se tutti gli argomenti RequiredArgument nel gruppo sono vincolati.
• Se un gruppo ha zero RequiredArgument argomenti e almeno un argomento vincolato, allora il gruppo è considerato vincolato.
• Si tratta di un errore di convalida se nessun gruppo di overload è legato, a meno che uno dei gruppi di overload non abbia RequiredArgument argomenti al suo interno.
• È un errore avere più di un gruppo di overload associato, ovvero tutti gli argomenti obbligatori in un gruppo di overload sono associati e uno o più argomenti in un altro gruppo di overload sono anch'essi associati.