Partilhar via

Argumentos necessários e grupos de sobrecarga

  • Artigo

As atividades podem ser configuradas para que determinados argumentos sejam obrigados a ser vinculados para que a atividade seja válida para execução. O RequiredArgument atributo é usado para indicar que determinados argumentos em uma atividade são necessários e o OverloadGroup atributo é usado para agrupar categorias de argumentos necessários juntos. Usando os atributos, os autores de atividades podem fornecer configurações de validação de atividades simples ou complexas.

Usando argumentos necessários

Para usar o RequiredArgument atributo em uma atividade, indique os argumentos desejados usando RequiredArgumentAttribute. Neste exemplo, é definida uma Add atividade que tem dois argumentos necessários.

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

Em XAML, os argumentos necessários também são indicados usando RequiredArgumentAttribute. Neste exemplo, a Add atividade é definida usando três argumentos e usa uma Assign<T> atividade para executar a operação add.

<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 a atividade for usada e qualquer um dos argumentos necessários não estiver vinculado, o seguinte erro de validação será retornado.

O valor para um argumento de atividade necessária 'Operand1' não foi fornecido.

Nota

Para obter mais informações sobre como verificar e manipular erros e avisos de validação, consulte Invocando validação de atividade.

Usando grupos de sobrecarga

Os grupos de sobrecarga fornecem um método para indicar quais combinações de argumentos são válidas em uma atividade. Os argumentos são agrupados usando OverloadGroupAttribute. Cada grupo recebe um nome especificado pelo OverloadGroupAttribute. A atividade é válida quando apenas um conjunto de argumentos em um grupo de sobrecarga é vinculado. No exemplo a seguir, uma CreateLocation classe é definida.

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

O objetivo desta atividade é especificar uma localização nos EUA. Para fazer isso, o usuário da atividade pode especificar o local usando um dos três grupos de argumentos. Para especificar as combinações válidas de argumentos, três grupos de sobrecarga são definidos. G1 contém os Latitude e Longitude argumentos. G2 contém Street, City, e State. G3 contém Street e Zip. Name também é um argumento necessário, mas não faz parte de um grupo de sobrecarga. Para que esta atividade seja válida, Name teria que estar ligada a todos os argumentos de um único grupo de sobrecarga.

No exemplo a seguir, extraído do exemplo Atividades de Acesso ao Banco de Dados, há dois grupos de sobrecarga: ConnectionString e ConfigFileSectionName. Para que essa atividade seja válida, ou os ProviderName argumentos e ConnectionString devem ser vinculados, ou o ConfigName argumento, mas não ambos.

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

Ao definir um grupo de sobrecarga:

  • Um grupo de sobrecarga não pode ser um subconjunto ou um conjunto equivalente de outro grupo de sobrecarga.

    Nota

    Há uma exceção a esta regra. Se um grupo de sobrecarga for um subconjunto de outro grupo de sobrecarga e o subconjunto contiver apenas argumentos onde RequiredArgument é false, então o grupo de sobrecarga será válido.

  • Os grupos de sobrecarga podem se sobrepor, mas é um erro se a interseção dos grupos contiver todos os argumentos necessários de um ou ambos os grupos de sobrecarga. No exemplo anterior, os G2 grupos e G3 sobrecarga se sobrepunham, mas como a interseção não continha todos os argumentos de um ou ambos os grupos, isso era válido.

Ao vincular argumentos em um grupo de sobrecarga:

  • Um grupo de sobrecarga é considerado vinculado se todos os RequiredArgument argumentos no grupo estiverem vinculados.

  • Se um grupo tiver zero RequiredArgument argumentos e pelo menos um argumento vinculado, o grupo será considerado vinculado.

  • É um erro de validação se nenhum grupo de sobrecarga estiver vinculado, a menos que um grupo de sobrecarga não RequiredArgument tenha argumentos.

  • É um erro ter mais de um grupo de sobrecarga vinculado, ou seja, todos os argumentos necessários em um grupo de sobrecarga são vinculados e qualquer argumento em outro grupo de sobrecarga também é vinculado.