Compartilhar via

Diretiva x:Arguments

  • Artigo

Empacota argumentos de construção para uma declaração de elemento de objeto de construtor não sem parâmetros no XAML ou para uma declaração de objeto de método de fábrica.

Uso do elemento XAML (construtor sem parâmetros)

<object ...>
  <x:Arguments>
    oneOrMoreObjectElements
  </x:Arguments>
</object>

Uso do elemento XAML (método factory)

<object x:FactoryMethod="methodName"...>
  <x:Arguments>
    oneOrMoreObjectElements
  </x:Arguments>
</object>

Valores XAML

Valor Descrição
oneOrMoreObjectElements Um ou mais elementos de objeto que especificam argumentos a serem passados para o construtor ou método de fábrica sem parâmetros de suporte.

O uso típico é usar o texto de inicialização dentro dos elementos do objeto para especificar os valores reais do argumento. Consulte a seção Exemplos.

A ordem dos elementos é significativa. Os tipos XAML na ordem devem corresponder aos tipos e à ordem de tipo da sobrecarga do construtor de backup ou do método de fábrica.
methodName O nome do método de fábrica que deve processar quaisquer argumentos x:Arguments.

Dependências

x:FactoryMethod pode modificar o escopo e o comportamento em que x:Arguments se aplica.

Se nenhuma x:FactoryMethod for especificada, x:Arguments se aplicará a assinaturas alternativas (não padrão) dos construtores de backup.

Se x:FactoryMethod for especificado, x:Arguments se aplicará a uma sobrecarga do método nomeado.

Observações

O XAML 2006 pode dar suporte à inicialização não padrão por meio do texto de inicialização. No entanto, a aplicação prática de uma técnica de construção de texto de inicialização é limitada. O texto de inicialização é tratado como uma única cadeia de caracteres de texto; portanto, ele só adiciona funcionalidade para uma inicialização de parâmetro único, a menos que um conversor de tipo seja definido para o comportamento de construção que pode analisar itens de informações personalizadas e delimitadores personalizados da cadeia de caracteres. Além disso, a cadeia de caracteres de texto para a lógica de objeto é potencialmente um conversor de tipo padrão nativo do analisador XAML para lidar com primitivos diferentes de uma cadeia de caracteres verdadeira.

O uso de XAML x:Arguments não é o uso de elementos de propriedade no sentido típico, pois a marcação de diretiva não faz referência ao tipo do elemento de objeto que contém. É mais semelhante a outras diretivas, como x:Code em que o elemento demarca um intervalo no qual a marcação deve ser interpretada como diferente do padrão para conteúdo filho. Nesse caso, o tipo XAML de cada elemento de objeto comunica informações sobre os tipos de argumento, que é usado por analisadores XAML para determinar qual método de fábrica de construtores específico a assinatura de um uso x:Arguments está tentando fazer referência.

x:Arguments para um elemento de objeto que está sendo construído deve preceder quaisquer outros elementos de propriedade, conteúdo, texto interno ou cadeias de caracteres de inicialização do elemento objeto. Os elementos de objeto dentro x:Arguments podem incluir atributos e cadeias de caracteres de inicialização, conforme permitido por esse tipo XAML e seu construtor de backup ou método de fábrica. Para o objeto ou os argumentos, você pode especificar tipos XAML personalizados ou tipos XAML que, de outra forma, estão fora do namespace XAML padrão referenciando mapeamentos de prefixo estabelecidos.

Os processadores XAML usam as diretrizes a seguir para determinar como os argumentos especificados em x:Arguments devem ser usados para construir um objeto. Se x:FactoryMethod for especificado, as informações serão comparadas com o x:FactoryMethod especificado (observe que o valor de x:FactoryMethod é o nome do método e o método nomeado pode ter sobrecargas. Se x:FactoryMethod não for especificado, as informações serão comparadas com o conjunto de todas as sobrecargas do construtor público do objeto. A lógica de processamento XAML compara o número de parâmetros e seleciona a sobrecarga com a aridade correspondente. Se houver mais de uma correspondência, o processador XAML deverá comparar os tipos dos parâmetros com base nos tipos XAML dos elementos de objeto fornecidos. Se ainda houver mais de uma correspondência, o comportamento do processador XAML será indefinido. Se um x:FactoryMethod for especificado, mas o método não puder ser resolvido, um processador XAML deverá gerar uma exceção.

Um <x:Arguments>string</x:Arguments> de uso de atributo XAML é tecnicamente possível. No entanto, isso não fornece recursos além do que poderia ser feito de outra forma por meio de conversores de tipo e texto de inicialização, e usar essa sintaxe não é a intenção de design dos recursos do método de fábrica XAML 2009.

Exemplos

O exemplo a seguir mostra uma assinatura de construtor sem parâmetros e, em seguida, o uso XAML de x:Arguments que acessa essa assinatura.

public class Food {
  private string _name;
  private Int32 _calories;
  public Food(string name, Int32 calories) {
      _name=name;
      _calories=calories;
  }
}

<my:Food>
  <x:Arguments>
      <x:String>Apple</x:String>
      <x:Int32>150</x:Int32>
  </x:Arguments>
</my:Food>

O exemplo a seguir mostra uma assinatura de método de fábrica de destino e, em seguida, o uso XAML de x:Arguments que acessa essa assinatura.

public Food TryLookupFood(string name)
{
switch (name) {
  case "Apple": return new Food("Apple",150);
  case "Chocolate": return new Food("Chocolate",200);
  case "Cheese": return new Food("Cheese", 450);
  default: {return new Food(name,0);
}
}

<my:Food x:FactoryMethod="TryLookupFood">
  <x:Arguments>
      <x:String>Apple</x:String>
  </x:Arguments>
</my:Food>

Consulte também