Compartilhar via

Argumentos necessários e grupos de sobrecarga

As atividades podem ser configuradas para que determinados argumentos sejam obrigados a serem associados 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 atividade podem fornecer configurações de validação de atividade simples ou complexas.

Use argumentos necessários

Para usar o RequiredArgument atributo em uma atividade, indique os argumentos desejados usando RequiredArgumentAttribute. Neste exemplo, uma Add atividade é definida 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);
    }
}

No 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 de adição.

<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 erro de validação a seguir será retornado.

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

Observação

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

Usar 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 só um conjunto de argumentos em um grupo de sobrecarga está 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 dessa atividade é especificar um local 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 argumentos e Longitude . G2 contém Street, Citye 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 é válida, Name terá que ser associado junto com todos os argumentos de um e somente um grupo de sobrecarga.

No exemplo a seguir, extraído do exemplo de Atividades de Acesso ao Banco de Dados , há dois grupos de sobrecarga: ConnectionString e ConfigFileSectionName. Para que essa atividade seja válida, os argumentos ProviderName e ConnectionString devem ser associados, ou o argumento ConfigName, 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.

    Observação

    Há uma exceção a essa regra. Se um grupo de sobrecarga for um subconjunto de outro grupo de sobrecarga e o subconjunto contiver apenas argumentos em que RequiredArgument estiver false, o grupo de sobrecarga será válido.

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

Ao associar argumentos em um grupo de sobrecarga:

  • Um grupo de sobrecarga será considerado ligado se todos os RequiredArgument argumentos no grupo estiverem ligados.
  • Se um grupo tem os argumentos de RequiredArgument zero e pelo menos um argumento associado, então o grupo está sendo associado.
  • É um erro de validação se nenhum grupo de sobrecarga é associado a menos que um grupo de sobrecarga não tem nenhum argumento de RequiredArgument nele.
  • É um erro ter mais de um grupo de sobrecarga associado, ou seja, todos os argumentos necessários em um grupo de sobrecarga são associados e qualquer argumento em outro grupo de sobrecarga também está associado.
  • Last updated on