Argumentos necesarios y grupos de sobrecargas

Las actividades se pueden configurar para que determinados argumentos se deban enlazar para que la actividad sea válida para su ejecución. El RequiredArgument atributo se usa para indicar que se requieren ciertos argumentos en una actividad y el OverloadGroup atributo se usa para agrupar categorías de argumentos necesarios. Mediante el uso de los atributos , los autores de actividades pueden proporcionar configuraciones de validación de actividad sencillas o complejas.

Uso de argumentos necesarios

Para usar el RequiredArgument atributo en una actividad, indique los argumentos deseados mediante RequiredArgumentAttribute. En este ejemplo, se define una Add actividad que tiene dos argumentos necesarios.

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

En XAML, los argumentos necesarios también se indican mediante RequiredArgumentAttribute. En este ejemplo, la Add actividad se define mediante tres argumentos y usa una Assign<T> actividad para realizar la operación de adició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>

Si se usa la actividad y alguno de los argumentos necesarios no está enlazado, se devuelve el siguiente error de validación.

No se proporcionó el valor de un argumento de actividad necesario 'Operando1'.

Nota:

Para obtener más información sobre cómo comprobar y controlar errores y advertencias de validación, consulte Invocación de validación de actividad.

Uso de grupos de sobrecargas

Los grupos de sobrecargas proporcionan un método para indicar qué combinaciones de argumentos son válidas en una actividad. Los argumentos se agrupan mediante OverloadGroupAttribute. A cada grupo se le asigna un nombre especificado por .OverloadGroupAttribute La actividad es válida cuando solo se enlaza un conjunto de argumentos de un grupo de sobrecargas. En el ejemplo siguiente, se define una CreateLocation clase .

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

El objetivo de esta actividad es especificar una ubicación en Estados Unidos. Para ello, el usuario de la actividad puede especificar la ubicación mediante uno de los tres grupos de argumentos. Para especificar las combinaciones válidas de argumentos, se definen tres grupos de sobrecarga. G1 contiene los Latitude argumentos y Longitude . G2 contiene Street, Cityy State. G3 contiene Street y Zip. Name también es un argumento obligatorio, pero no forma parte de un grupo de sobrecargas. Para que esta actividad sea válida, Name tendría que enlazarse junto con todos los argumentos de uno y solo un grupo de sobrecargas.

En el ejemplo siguiente, tomado del ejemplo Actividades de acceso a la base de datos, hay dos grupos de sobrecarga: ConnectionString y .ConfigFileSectionName Para que esta actividad sea válida, los ProviderName argumentos y ConnectionString deben estar enlazados o el ConfigName argumento, pero no 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; }
}

Al definir un grupo de sobrecargas:

• Un grupo de sobrecargas no puede ser un subconjunto o un conjunto equivalente de otro grupo de sobrecargas.

  Nota:

  Hay una excepción a esta regla. Si un grupo de sobrecargas es un subconjunto de otro grupo de sobrecargas y el subconjunto solo contiene argumentos donde RequiredArgument es false, el grupo de sobrecargas es válido.

• Los grupos de sobrecargas se pueden superponer, pero es un error si la intersección de los grupos contiene todos los argumentos necesarios de uno o ambos grupos de sobrecargas. En el ejemplo anterior, los G2 grupos de sobrecargas y G3 se superponen, pero porque la intersección no contenía todos los argumentos de uno o ambos grupos, esto era válido.

Al enlazar argumentos en un grupo de sobrecargas:

• Un grupo de sobrecarga se considera enlazado si todos los RequiredArgument argumentos del grupo están enlazados.
• Si un grupo tiene cero RequiredArgument argumentos y al menos un argumento enlazado, el grupo se considera enlazado.
• Se trata de un error de validación si no se enlaza ningún grupo de sobrecargas a menos que un grupo de sobrecargas no RequiredArgument tenga argumentos en él.
• Es un error tener más de un grupo de sobrecarga enlazado, es decir, todos los argumentos necesarios de un grupo de sobrecargas están enlazados y cualquier argumento de otro grupo de sobrecargas también está enlazado.