Passando argumentos em XAMLPassing Arguments in XAML

Baixar Exemplo Baixar o exemploDownload Sample Download the sample

Este artigo demonstra como usar os atributos XAML que podem ser usados para passar argumentos para construtores não padrão, para chamar métodos de fábrica e para especificar o tipo de um argumento genérico.This article demonstrates using the XAML attributes that can be used to pass arguments to non-default constructors, to call factory methods, and to specify the type of a generic argument.

Visão geralOverview

Geralmente, é necessário criar uma instância de objetos com construtores que exigem argumentos ou chamando um método de criação estático.It's often necessary to instantiate objects with constructors that require arguments, or by calling a static creation method. Isso pode ser obtido em XAML usando os x:Arguments atributos e x:FactoryMethod :This can be achieved in XAML by using the x:Arguments and x:FactoryMethod attributes:

  • O x:Arguments atributo é usado para especificar argumentos de construtor para um construtor não padrão ou para uma declaração de objeto de método de fábrica.The x:Arguments attribute is used to specify constructor arguments for a non-default constructor, or for a factory method object declaration. Para obter mais informações, consulte passando argumentos de Construtor.For more information, see Passing Constructor Arguments.
  • O x:FactoryMethod atributo é usado para especificar um método de fábrica que pode ser usado para inicializar um objeto.The x:FactoryMethod attribute is used to specify a factory method that can be used to initialize an object. Para obter mais informações, consulte chamando métodos de fábrica.For more information, see Calling Factory Methods.

Além disso, o x:TypeArguments atributo pode ser usado para especificar os argumentos de tipo genérico para o construtor de um tipo genérico.In addition, the x:TypeArguments attribute can be used to specify the generic type arguments to the constructor of a generic type. Para obter mais informações, consulte especificando um argumento de tipo genérico.For more information, see Specifying a Generic Type Argument.

Passando argumentos de ConstrutorPassing Constructor Arguments

Os argumentos podem ser passados para um construtor não padrão usando o x:Arguments atributo.Arguments can be passed to a non-default constructor using the x:Arguments attribute. Cada argumento de construtor deve ser delimitado em um elemento XML que representa o tipo do argumento.Each constructor argument must be delimited within an XML element that represents the type of the argument. Xamarin.Forms o oferece suporte aos seguintes elementos para tipos básicos:Xamarin.Forms supports the following elements for basic types:

  • x:Array
  • x:Boolean
  • x:Byte
  • x:Char
  • x:DateTime
  • x:Decimal
  • x:Double
  • x:Int16
  • x:Int32
  • x:Int64
  • x:Object
  • x:Single
  • x:String
  • x:TimeSpan

O exemplo de código a seguir demonstra como usar o x:Arguments atributo com três Color construtores:The following code example demonstrates using the x:Arguments attribute with three Color constructors:

<BoxView HeightRequest="150" WidthRequest="150" HorizontalOptions="Center">
  <BoxView.Color>
    <Color>
      <x:Arguments>
        <x:Double>0.9</x:Double>
      </x:Arguments>
    </Color>
  </BoxView.Color>
</BoxView>
<BoxView HeightRequest="150" WidthRequest="150" HorizontalOptions="Center">
  <BoxView.Color>
    <Color>
      <x:Arguments>
        <x:Double>0.25</x:Double>
        <x:Double>0.5</x:Double>
        <x:Double>0.75</x:Double>
      </x:Arguments>
    </Color>
  </BoxView.Color>
</BoxView>
<BoxView HeightRequest="150" WidthRequest="150" HorizontalOptions="Center">
  <BoxView.Color>
    <Color>
      <x:Arguments>
        <x:Double>0.8</x:Double>
        <x:Double>0.5</x:Double>
        <x:Double>0.2</x:Double>
        <x:Double>0.5</x:Double>
      </x:Arguments>
    </Color>
  </BoxView.Color>
</BoxView>

O número de elementos dentro da x:Arguments marca e os tipos desses elementos devem corresponder a um dos Color construtores.The number of elements within the x:Arguments tag, and the types of these elements, must match one of the Color constructors. O Color Construtor com um único parâmetro requer um valor de escala de cinza de 0 (preto) para 1 (branco).The Color constructor with a single parameter requires a grayscale value from 0 (black) to 1 (white). O Color Construtor com três parâmetros requer um valor vermelho, verde e azul, que varia de 0 a 1.The Color constructor with three parameters requires a red, green, and blue value ranging from 0 to 1. O Color Construtor com quatro parâmetros adiciona um canal alfa como o quarto parâmetro.The Color constructor with four parameters adds an alpha channel as the fourth parameter.

As capturas de tela a seguir mostram o resultado da chamada de cada Color Construtor com os valores de argumento especificados:The following screenshots show the result of calling each Color constructor with the specified argument values:

BoxView. Color especificada com x:Arguments

Chamando métodos de fábricaCalling Factory Methods

Os métodos de fábrica podem ser chamados em XAML especificando o nome do método usando o x:FactoryMethod atributo e seus argumentos usando o x:Arguments atributo.Factory methods can be called in XAML by specifying the method's name using the x:FactoryMethod attribute, and its arguments using the x:Arguments attribute. Um método de fábrica é um public static método que retorna objetos ou valores do mesmo tipo da classe ou estrutura que define os métodos.A factory method is a public static method that returns objects or values of the same type as the class or structure that defines the methods.

A Color estrutura define um número de métodos de fábrica e o exemplo de código a seguir demonstra como chamar três deles:The Color structure defines a number of factory methods, and the following code example demonstrates calling three of them:

<BoxView HeightRequest="150" WidthRequest="150" HorizontalOptions="Center">
  <BoxView.Color>
    <Color x:FactoryMethod="FromRgba">
      <x:Arguments>
        <x:Int32>192</x:Int32>
        <x:Int32>75</x:Int32>
        <x:Int32>150</x:Int32>                        
        <x:Int32>128</x:Int32>
      </x:Arguments>
    </Color>
  </BoxView.Color>
</BoxView>
<BoxView HeightRequest="150" WidthRequest="150" HorizontalOptions="Center">
  <BoxView.Color>
    <Color x:FactoryMethod="FromHsla">
      <x:Arguments>
        <x:Double>0.23</x:Double>
        <x:Double>0.42</x:Double>
        <x:Double>0.69</x:Double>
        <x:Double>0.7</x:Double>
      </x:Arguments>
    </Color>
  </BoxView.Color>
</BoxView>
<BoxView HeightRequest="150" WidthRequest="150" HorizontalOptions="Center">
  <BoxView.Color>
    <Color x:FactoryMethod="FromHex">
      <x:Arguments>
        <x:String>#FF048B9A</x:String>
      </x:Arguments>
    </Color>
  </BoxView.Color>
</BoxView>

O número de elementos dentro da x:Arguments marca e os tipos desses elementos devem corresponder aos argumentos do método de fábrica que está sendo chamado.The number of elements within the x:Arguments tag, and the types of these elements, must match the arguments of the factory method being called. O FromRgba método de fábrica requer quatro Int32 parâmetros, que representam os valores vermelho, verde, azul e alfa, variando de 0 a 255, respectivamente.The FromRgba factory method requires four Int32 parameters, which represent the red, green, blue, and alpha values, ranging from 0 to 255 respectively. O FromHsla método de fábrica requer quatro Double parâmetros, que representam os valores de matiz, saturação, luminosidade e alfa, variando de 0 a 1, respectivamente.The FromHsla factory method requires four Double parameters, which represent the hue, saturation, luminosity, and alpha values, ranging from 0 to 1 respectively. O FromHex método de fábrica requer um String que represente a cor hexadecimal (a) RGB.The FromHex factory method requires a String that represents the hexadecimal (A)RGB color.

As capturas de tela a seguir mostram o resultado da chamada de cada Color método de fábrica com os valores de argumento especificados:The following screenshots show the result of calling each Color factory method with the specified argument values:

BoxView. Color especificada com x:FactoryMethod e x:Arguments

Especificando um argumento de tipo genéricoSpecifying a Generic Type Argument

Argumentos de tipo genérico para o construtor de um tipo genérico podem ser especificados usando o x:TypeArguments atributo, conforme demonstrado no exemplo de código a seguir:Generic type arguments for the constructor of a generic type can be specified using the x:TypeArguments attribute, as demonstrated in the following code example:

<ContentPage ...>
  <StackLayout>
    <StackLayout.Margin>
      <OnPlatform x:TypeArguments="Thickness">
        <On Platform="iOS" Value="0,20,0,0" />
        <On Platform="Android" Value="5, 10" />
        <On Platform="UWP" Value="10" />
      </OnPlatform>
    </StackLayout.Margin>
  </StackLayout>
</ContentPage>

A OnPlatform classe é uma classe genérica e deve ser instanciada com um x:TypeArguments atributo que corresponda ao tipo de destino.The OnPlatform class is a generic class and must be instantiated with an x:TypeArguments attribute that matches the target type. Na On classe, o Platform atributo pode aceitar um único string valor ou vários valores delimitados por vírgula string .In the On class, the Platform attribute can accept a single string value, or multiple comma-delimited string values. Neste exemplo, a StackLayout.Margin propriedade é definida como uma plataforma específica Thickness .In this example, the StackLayout.Margin property is set to a platform-specific Thickness.

Para obter mais informações sobre argumentos de tipo genérico, consulte genéricos em Xamarin.Forms XAML.For more information about generic type arguments, see Generics in Xamarin.Forms XAML.