Pasar argumentos

  • Artículo
  • Tiempo de lectura: 3 minutos

A menudo es necesario crear instancias de objetos con constructores que requieren argumentos o mediante una llamada a un método de creación estático. Esto se puede lograr en XAML de la interfaz de usuario de aplicaciones multiplataforma de .NET (.NET MAUI) mediante los x:Arguments atributos y x:FactoryMethod :

  • El x:Arguments atributo se usa para especificar argumentos de constructor para un constructor no predeterminado o para una declaración de objeto de método de fábrica. Para obtener más información, vea Paso de argumentos de constructor.
  • El x:FactoryMethod atributo se usa para especificar un método de fábrica que se puede usar para inicializar un objeto. Para obtener más información, vea Llamar a métodos de generador.

Además, el x:TypeArguments atributo se puede usar para especificar los argumentos de tipo genérico para el constructor de un tipo genérico. Para obtener más información, vea Especificar un argumento de tipo genérico.

Los argumentos se pueden pasar a constructores y métodos de fábrica mediante los siguientes primitivos del lenguaje XAML MAUI de .NET:

  • x:Array, que corresponde a Array.
  • x:Boolean, que corresponde a Boolean.
  • x:Byte, que corresponde a Byte.
  • x:Char, que corresponde a Char.
  • x:DateTime, que corresponde a DateTime.
  • x:Decimal, que corresponde a Decimal.
  • x:Double, que corresponde a Double.
  • x:Int16, que corresponde a Int16.
  • x:Int32, que corresponde a Int32.
  • x:Int64, que corresponde a Int64.
  • x:Object, que corresponde a Object.
  • x:Single, que corresponde a Single.
  • x:String, que corresponde a String.
  • x:TimeSpan, que corresponde a TimeSpan.

Con la excepción de x:DateTime, los otros primitivos de lenguaje se encuentran en la especificación XAML 2009.

Nota:

El x:Single primitivo de lenguaje se puede usar para pasar float argumentos.

Pasar argumentos de constructor

Los argumentos se pueden pasar a un constructor no predeterminado mediante el x:Arguments atributo . Cada argumento constructor debe delimitarse dentro de un elemento XML que representa el tipo del argumento.

En el ejemplo siguiente se muestra cómo usar el x:Arguments atributo con tres constructores diferentes Color :

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

El número de elementos dentro de la x:Arguments etiqueta y los tipos de estos elementos deben coincidir con uno de los Color constructores. El Color constructor con un único parámetro requiere un valor de escala float de grises de 0 (negro) a 1 (blanco). El Color constructor con tres parámetros requiere float valores rojo, verde y azul comprendidos entre 0 y 1. El Color constructor con cuatro parámetros agrega un float canal alfa como cuarto parámetro.

Llamar a métodos de fábrica

Se puede llamar a los métodos de fábrica en XAML de .NET MAUI especificando el nombre del método mediante el x:FactoryMethod atributo y sus argumentos mediante el x:Arguments atributo . Un método de fábrica es un public static método que devuelve objetos o valores del mismo tipo que la clase o estructura que define los métodos.

La Color estructura define una serie de métodos de fábrica y en el ejemplo siguiente se muestra cómo llamar a tres de ellos:

<BoxView HeightRequest="150"
         WidthRequest="150"
         HorizontalOptions="Center">
  <BoxView.Color>
    <Color x:FactoryMethod="FromRgba">
      <x:Arguments>
        <x:Byte>192</x:Byte>
        <x:Byte>75</x:Byte>
        <x:Byte>150</x:Byte>
        <x:Byte>128</x:Byte>
      </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>

El número de elementos dentro de la x:Arguments etiqueta y los tipos de estos elementos debe coincidir con los argumentos del método de fábrica al que se llama. El FromRgba método factory requiere cuatro byte argumentos, que representan los valores rojo, verde, azul y alfa, que van de 0 a 255 respectivamente. El FromHsla método de fábrica requiere cuatro float argumentos, que representan el matiz, la saturación, la luminosidad y los valores alfa, que van de 0 a 1 respectivamente. El FromHex método factory requiere un string argumento que representa el color hexadecimal (A)RGB.

Especificar un argumento de tipo genérico

Los argumentos de tipo genérico para el constructor de un tipo genérico se pueden especificar mediante el x:TypeArguments atributo , como se muestra en el ejemplo siguiente:

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

La OnPlatform clase es una clase genérica y se debe crear una instancia con un x:TypeArguments atributo que coincida con el tipo de destino. En la On clase , el Platform atributo puede aceptar un valor único string o varios valores delimitados por comas string . En este ejemplo, la StackLayout.Margin propiedad se establece en un específico Thicknessde la plataforma.

Para obtener más información sobre los argumentos de tipo genéricos, consulta Genéricos en XAML.