Parte 4.Part 4. Nozioni di base sul data bindingData Binding Basics

Scarica esempio Scaricare l'esempioDownload Sample Download the sample

Le associazioni dati consentono di collegare le proprietà di due oggetti in modo che una modifica in uno di essi provochi una modifica nell'altra. Si tratta di uno strumento molto utile e, mentre i data binding possono essere definiti interamente nel codice, XAML fornisce collegamenti e praticità. Di conseguenza, una delle estensioni di markup più importanti in Xamarin.Forms è l'associazione.Data bindings allow properties of two objects to be linked so that a change in one causes a change in the other. This is a very valuable tool, and while data bindings can be defined entirely in code, XAML provides shortcuts and convenience. Consequently, one of the most important markup extensions in Xamarin.Forms is Binding.

Associazioni datiData Bindings

Le associazioni dati connettono le proprietà di due oggetti, denominati origine e destinazione.Data bindings connect properties of two objects, called the source and the target. Nel codice sono necessari due passaggi: la BindingContext proprietà dell'oggetto di destinazione deve essere impostata sull'oggetto di origine e il SetBinding Metodo (spesso usato in combinazione con la Binding classe) deve essere chiamato sull'oggetto di destinazione per associare una proprietà di tale oggetto a una proprietà dell'oggetto di origine.In code, two steps are required: The BindingContext property of the target object must be set to the source object, and the SetBinding method (often used in conjunction with the Binding class) must be called on the target object to bind a property of that object to a property of the source object.

La proprietà di destinazione deve essere una proprietà associabile, il che significa che l'oggetto di destinazione deve derivare da BindableObject .The target property must be a bindable property, which means that the target object must derive from BindableObject. La Xamarin.Forms documentazione online indica quali proprietà sono proprietà associabili.The online Xamarin.Forms documentation indicates which properties are bindable properties. Una proprietà di Label , ad esempio, Text è associata alla proprietà associabile TextProperty .A property of Label such as Text is associated with the bindable property TextProperty.

Nel markup è inoltre necessario eseguire gli stessi due passaggi necessari nel codice, ad eccezione del fatto che l' Binding estensione di markup prende il posto della SetBinding chiamata e della Binding classe.In markup, you must also perform the same two steps that are required in code, except that the Binding markup extension takes the place of the SetBinding call and the Binding class.

Tuttavia, quando si definiscono le associazioni dati in XAML, esistono diversi modi per impostare la classe BindingContext dell'oggetto di destinazione.However, when you define data bindings in XAML, there are multiple ways to set the BindingContext of the target object. A volte è impostato dal file code-behind, a volte usando un' StaticResource x:Static estensione di markup o e talvolta come il contenuto dei BindingContext tag dell'elemento Property.Sometimes it’s set from the code-behind file, sometimes using a StaticResource or x:Static markup extension, and sometimes as the content of BindingContext property-element tags.

Le associazioni vengono usate più spesso per connettere gli oggetti visivi di un programma con un modello di dati sottostante, in genere in una realizzazione dell'architettura dell'applicazione MVVM (Model-View-ViewModel), come illustrato nella parte 5. Da data binding a MVVM, ma altri scenari sono possibili.Bindings are used most often to connect the visuals of a program with an underlying data model, usually in a realization of the MVVM (Model-View-ViewModel) application architecture, as discussed in Part 5. From Data Bindings to MVVM, but other scenarios are possible.

Associazioni viste-visualizzazioneView-to-View Bindings

È possibile definire associazioni dati per collegare le proprietà di due visualizzazioni nella stessa pagina.You can define data bindings to link properties of two views on the same page. In questo caso, si imposta l' BindingContext oggetto dell'oggetto di destinazione usando l' x:Reference estensione di markup.In this case, you set the BindingContext of the target object using the x:Reference markup extension.

Ecco un file XAML che contiene una Slider e due Label Visualizzazioni, una delle quali viene ruotata in base al Slider valore e un'altra che Visualizza il Slider valore:Here’s a XAML file that contains a Slider and two Label views, one of which is rotated by the Slider value and another which displays the Slider value:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="XamlSamples.SliderBindingsPage"
             Title="Slider Bindings Page">

    <StackLayout>
        <Label Text="ROTATION"
               BindingContext="{x:Reference Name=slider}"
               Rotation="{Binding Path=Value}"
               FontAttributes="Bold"
               FontSize="Large"
               HorizontalOptions="Center"
               VerticalOptions="CenterAndExpand" />

        <Slider x:Name="slider"
                Maximum="360"
                VerticalOptions="CenterAndExpand" />

        <Label BindingContext="{x:Reference slider}"
               Text="{Binding Value, StringFormat='The angle is {0:F0} degrees'}"
               FontAttributes="Bold"
               FontSize="Large"
               HorizontalOptions="Center"
               VerticalOptions="CenterAndExpand" />
    </StackLayout>
</ContentPage>

SliderContiene un x:Name attributo a cui fanno riferimento le due visualizzazioni che Label usano l' x:Reference estensione di markup.The Slider contains an x:Name attribute that is referenced by the two Label views using the x:Reference markup extension.

L' x:Reference estensione di binding definisce una proprietà denominata Name per impostare sul nome dell'elemento a cui si fa riferimento, in questo caso slider .The x:Reference binding extension defines a property named Name to set to the name of the referenced element, in this case slider. Tuttavia, la ReferenceExtension classe che definisce l' x:Reference estensione di markup definisce anche un ContentProperty attributo per Name , il che significa che non è richiesto in modo esplicito.However, the ReferenceExtension class that defines the x:Reference markup extension also defines a ContentProperty attribute for Name, which means that it isn’t explicitly required. Solo per la varietà, il primo x:Reference include "Name =", ma il secondo non:Just for variety, the first x:Reference includes “Name=” but the second does not:

BindingContext="{x:Reference Name=slider}"
…
BindingContext="{x:Reference slider}"

L' Binding estensione di markup può avere diverse proprietà, proprio come la BindingBase Binding classe e.The Binding markup extension itself can have several properties, just like the BindingBase and Binding class. ContentPropertyPer Binding è Path , ma la parte "Path =" dell'estensione di markup può essere omessa se il percorso è il primo elemento nell'estensione di Binding markup.The ContentProperty for Binding is Path, but the “Path=” part of the markup extension can be omitted if the path is the first item in the Binding markup extension. Il primo esempio ha "Path =", ma il secondo esempio lo omette:The first example has “Path=” but the second example omits it:

Rotation="{Binding Path=Value}"
…
Text="{Binding Value, StringFormat='The angle is {0:F0} degrees'}"

Le proprietà possono essere tutte in una riga o separate in più righe:The properties can all be on one line or separated into multiple lines:

Text="{Binding Value,
               StringFormat='The angle is {0:F0} degrees'}"

Eseguire tutte le operazioni più convenienti.Do whatever is convenient.

Si noti la StringFormat proprietà nella seconda Binding estensione di markup.Notice the StringFormat property in the second Binding markup extension. In Xamarin.Forms le associazioni non eseguono alcuna conversione implicita di tipi e, se è necessario visualizzare un oggetto non stringa come stringa, è necessario fornire un convertitore di tipi o utilizzare StringFormat .In Xamarin.Forms, bindings do not perform any implicit type conversions, and if you need to display a non-string object as a string you must provide a type converter or use StringFormat. Dietro le quinte, String.Format viene usato il metodo statico per StringFormat implementare.Behind the scenes, the static String.Format method is used to implement StringFormat. Questo è potenzialmente un problema perché le specifiche di formattazione .NET coinvolgono parentesi graffe, che vengono usate anche per delimitare le estensioni di markup.That’s potentially a problem, because .NET formatting specifications involve curly braces, which are also used to delimit markup extensions. Questo crea il rischio di confondere il parser XAML.This creates a risk of confusing the XAML parser. Per evitare tale indicizzazione, inserire l'intera stringa di formattazione tra virgolette singole:To avoid that, put the entire formatting string in single quotation marks:

Text="{Binding Value, StringFormat='The angle is {0:F0} degrees'}"

Ecco il programma in esecuzione:Here’s the running program:

Associazioni viste-visualizzazioneView-to-View Bindings

Modalità di associazioneThe Binding Mode

Una singola vista può avere data binding su diverse proprietà.A single view can have data bindings on several of its properties. Tuttavia, ogni vista può disporre di un solo BindingContext , pertanto più associazioni dati in tale vista devono fare riferimento a tutte le proprietà dello stesso oggetto.However, each view can have only one BindingContext, so multiple data bindings on that view must all reference properties of the same object.

La soluzione per questo e altri problemi riguarda la Mode proprietà, che è impostata su un membro dell' BindingMode enumerazione:The solution to this and other problems involves the Mode property, which is set to a member of the BindingMode enumeration:

  • Default
  • OneWay -i valori vengono trasferiti dall'origine alla destinazioneOneWay — values are transferred from the source to the target
  • OneWayToSource -i valori vengono trasferiti dalla destinazione all'origineOneWayToSource — values are transferred from the target to the source
  • TwoWay -i valori vengono trasferiti in entrambe le direzioni tra l'origine e la destinazioneTwoWay — values are transferred both ways between source and target
  • OneTime : i dati passano dall'origine alla destinazione, ma solo quando BindingContext cambianoOneTime — data goes from source to target, but only when the BindingContext changes

Nel programma seguente viene illustrato un uso comune delle OneWayToSource TwoWay modalità di associazione e.The following program demonstrates one common use of the OneWayToSource and TwoWay binding modes. Quattro Slider visualizzazioni sono progettate per controllare le Scale Rotate proprietà,, RotateX e RotateY di un oggetto Label .Four Slider views are intended to control the Scale, Rotate, RotateX, and RotateY properties of a Label. Inizialmente, sembra che queste quattro proprietà di Label debbano essere destinazioni di data binding perché ciascuna viene impostata da un oggetto Slider .At first, it seems as if these four properties of the Label should be data-binding targets because each is being set by a Slider. Tuttavia, BindingContext Label può essere un solo oggetto e sono presenti quattro dispositivi di scorrimento diversi.However, the BindingContext of Label can be only one object, and there are four different sliders.

Per questo motivo, tutte le associazioni sono impostate in modi apparentemente indietro: il BindingContext di ognuno dei quattro dispositivi di scorrimento è impostato Label su e le associazioni vengono impostate nelle Value proprietà dei dispositivi di scorrimento.For that reason, all the bindings are set in seemingly backwards ways: The BindingContext of each of the four sliders is set to the Label, and the bindings are set on the Value properties of the sliders. Utilizzando le OneWayToSource modalità e TwoWay , queste Value proprietà possono impostare le proprietà di origine, ovvero le Scale proprietà, Rotate , RotateX e RotateY di Label :By using the OneWayToSource and TwoWay modes, these Value properties can set the source properties, which are the Scale, Rotate, RotateX, and RotateY properties of the Label:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="XamlSamples.SliderTransformsPage"
             Padding="5"
             Title="Slider Transforms Page">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="*" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
        </Grid.RowDefinitions>

        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="*" />
            <ColumnDefinition Width="Auto" />
        </Grid.ColumnDefinitions>

        <!-- Scaled and rotated Label -->
        <Label x:Name="label"
               Text="TEXT"
               HorizontalOptions="Center"
               VerticalOptions="CenterAndExpand" />

        <!-- Slider and identifying Label for Scale -->
        <Slider x:Name="scaleSlider"
                BindingContext="{x:Reference label}"
                Grid.Row="1" Grid.Column="0"
                Maximum="10"
                Value="{Binding Scale, Mode=TwoWay}" />

        <Label BindingContext="{x:Reference scaleSlider}"
               Text="{Binding Value, StringFormat='Scale = {0:F1}'}"
               Grid.Row="1" Grid.Column="1"
               VerticalTextAlignment="Center" />

        <!-- Slider and identifying Label for Rotation -->
        <Slider x:Name="rotationSlider"
                BindingContext="{x:Reference label}"
                Grid.Row="2" Grid.Column="0"
                Maximum="360"
                Value="{Binding Rotation, Mode=OneWayToSource}" />

        <Label BindingContext="{x:Reference rotationSlider}"
               Text="{Binding Value, StringFormat='Rotation = {0:F0}'}"
               Grid.Row="2" Grid.Column="1"
               VerticalTextAlignment="Center" />

        <!-- Slider and identifying Label for RotationX -->
        <Slider x:Name="rotationXSlider"
                BindingContext="{x:Reference label}"
                Grid.Row="3" Grid.Column="0"
                Maximum="360"
                Value="{Binding RotationX, Mode=OneWayToSource}" />

        <Label BindingContext="{x:Reference rotationXSlider}"
               Text="{Binding Value, StringFormat='RotationX = {0:F0}'}"
               Grid.Row="3" Grid.Column="1"
               VerticalTextAlignment="Center" />

        <!-- Slider and identifying Label for RotationY -->
        <Slider x:Name="rotationYSlider"
                BindingContext="{x:Reference label}"
                Grid.Row="4" Grid.Column="0"
                Maximum="360"
                Value="{Binding RotationY, Mode=OneWayToSource}" />

        <Label BindingContext="{x:Reference rotationYSlider}"
               Text="{Binding Value, StringFormat='RotationY = {0:F0}'}"
               Grid.Row="4" Grid.Column="1"
               VerticalTextAlignment="Center" />
    </Grid>
</ContentPage>

Le associazioni in tre Slider visualizzazioni sono OneWayToSource , ovvero il Slider valore provoca una modifica nella proprietà di BindingContext , che è l'oggetto Label denominato label .The bindings on three of the Slider views are OneWayToSource, meaning that the Slider value causes a change in the property of its BindingContext, which is the Label named label. Queste tre Slider visualizzazioni generano modifiche alle Rotate RotateX proprietà, e RotateY di Label .These three Slider views cause changes to the Rotate, RotateX, and RotateY properties of the Label.

Tuttavia, l'associazione per la Scale proprietà è TwoWay .However, the binding for the Scale property is TwoWay. Poiché il valore Scale predefinito della proprietà è 1 e l'utilizzo di un' TwoWay associazione determina l'impostazione del Slider valore iniziale su 1 anziché su 0.This is because the Scale property has a default value of 1, and using a TwoWay binding causes the Slider initial value to be set at 1 rather than 0. Se tale associazione fosse OneWayToSource , la Scale proprietà verrebbe inizialmente impostata su 0 rispetto al Slider valore predefinito.If that binding were OneWayToSource, the Scale property would initially be set to 0 from the Slider default value. Il Label non è visibile e questo potrebbe causare confusione all'utente.The Label would not be visible, and that might cause some confusion to the user.

Binding all'indietroBackwards Bindings

Nota

La VisualElement classe dispone inoltre ScaleX di ScaleY proprietà e che scalano VisualElement rispettivamente sull'asse x e sull'asse y.The VisualElement class also has ScaleX and ScaleY properties, which scale the VisualElement on the x-axis and y-axis respectively.

Associazioni e raccolteBindings and Collections

Nulla illustra la potenza di XAML e le associazioni dati migliori rispetto a un modello ListView .Nothing illustrates the power of XAML and data bindings better than a templated ListView.

ListView definisce una ItemsSource proprietà di tipo IEnumerable e visualizza gli elementi della raccolta.ListView defines an ItemsSource property of type IEnumerable, and it displays the items in that collection. Questi elementi possono essere oggetti di qualsiasi tipo.These items can be objects of any type. Per impostazione predefinita, ListView Usa il ToString metodo di ogni elemento per visualizzare l'elemento.By default, ListView uses the ToString method of each item to display that item. In alcuni casi questo è solo quello che si desidera, ma in molti casi ToString restituisce solo il nome completo della classe dell'oggetto.Sometimes this is just what you want, but in many cases, ToString returns only the fully-qualified class name of the object.

Tuttavia, gli elementi della ListView raccolta possono essere visualizzati nel modo desiderato tramite l'uso di un modello, che implica una classe che deriva da Cell .However, the items in the ListView collection can be displayed any way you want through the use of a template, which involves a class that derives from Cell. Il modello viene clonato per ogni elemento in ListView e i data binding impostati nel modello vengono trasferiti ai singoli cloni.The template is cloned for every item in the ListView, and data bindings that have been set on the template are transferred to the individual clones.

Molto spesso, è consigliabile creare una cella personalizzata per questi elementi usando la ViewCell classe.Very often, you’ll want to create a custom cell for these items using the ViewCell class. Questo processo è piuttosto confuso nel codice, ma in XAML diventa molto semplice.This process is somewhat messy in code, but in XAML it becomes very straightforward.

Incluso nel progetto XamlSamples è una classe denominata NamedColor .Included in the XamlSamples project is a class called NamedColor. Ogni NamedColor oggetto dispone Name FriendlyName di proprietà e di tipo e string una Color proprietà di tipo Color .Each NamedColor object has Name and FriendlyName properties of type string, and a Color property of type Color. Inoltre, NamedColor presenta 141 campi statici di sola lettura di tipo Color corrispondenti ai colori definiti nella Xamarin.Forms Color classe.In addition, NamedColor has 141 static read-only fields of type Color corresponding to the colors defined in the Xamarin.Forms Color class. Un costruttore statico crea una IEnumerable<NamedColor> raccolta che contiene NamedColor oggetti corrispondenti a questi campi statici e la assegna alla relativa proprietà statica pubblica All .A static constructor creates an IEnumerable<NamedColor> collection that contains NamedColor objects corresponding to these static fields, and assigns it to its public static All property.

L'impostazione della NamedColor.All proprietà statica su ItemsSource di un ListView è semplice utilizzando l' x:Static estensione di markup:Setting the static NamedColor.All property to the ItemsSource of a ListView is easy using the x:Static markup extension:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:local="clr-namespace:XamlSamples;assembly=XamlSamples"
             x:Class="XamlSamples.ListViewDemoPage"
             Title="ListView Demo Page">

    <ListView ItemsSource="{x:Static local:NamedColor.All}" />

</ContentPage>

La visualizzazione risultante stabilisce che gli elementi sono effettivamente di tipo XamlSamples.NamedColor :The resultant display establishes that the items are truly of type XamlSamples.NamedColor:

Associazione a una raccoltaBinding to a Collection

Non si tratta di molte informazioni, ma ListView è scorrevole e selezionabile.It’s not much information, but the ListView is scrollable and selectable.

Per definire un modello per gli elementi, è opportuno suddividere la ItemTemplate proprietà come elemento Property e impostarla su un oggetto DataTemplate , che fa quindi riferimento a ViewCell .To define a template for the items, you’ll want to break out the ItemTemplate property as a property element, and set it to a DataTemplate, which then references a ViewCell. Alla View proprietà di ViewCell è possibile definire un layout di una o più visualizzazioni per visualizzare ogni elemento.To the View property of the ViewCell you can define a layout of one or more views to display each item. Ecco un semplice esempio:Here’s a simple example:

<ListView ItemsSource="{x:Static local:NamedColor.All}">
    <ListView.ItemTemplate>
        <DataTemplate>
            <ViewCell>
                <ViewCell.View>
                    <Label Text="{Binding FriendlyName}" />
                </ViewCell.View>
            </ViewCell>
        </DataTemplate>
    </ListView.ItemTemplate>
</ListView>

Nota

L'origine del binding per le celle e gli elementi figlio delle celle è la ListView.ItemsSource raccolta.The binding source for cells, and children of cells, is the ListView.ItemsSource collection.

L' Label elemento viene impostato sulla View proprietà di ViewCell .The Label element is set to the View property of the ViewCell. I ViewCell.View tag non sono necessari perché la View proprietà è la proprietà di contenuto di ViewCell . Questo markup Visualizza la FriendlyName proprietà di ogni NamedColor oggetto:(The ViewCell.View tags are not needed because the View property is the content property of ViewCell.) This markup displays the FriendlyName property of each NamedColor object:

Associazione a una raccolta con un oggetto DataTemplateBinding to a Collection with a DataTemplate

Molto meglio.Much better. A questo punto, è sufficiente ripulire il modello di elemento con altre informazioni e il colore effettivo.Now all that’s needed is to spruce up the item template with more information and the actual color. Per supportare questo modello, alcuni valori e oggetti sono stati definiti nel dizionario risorse della pagina:To support this template, some values and objects have been defined in the page’s resource dictionary:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:local="clr-namespace:XamlSamples"
             x:Class="XamlSamples.ListViewDemoPage"
             Title="ListView Demo Page">

    <ContentPage.Resources>
        <ResourceDictionary>
            <OnPlatform x:Key="boxSize"
                        x:TypeArguments="x:Double">
                <On Platform="iOS, Android, UWP" Value="50" />
            </OnPlatform>

            <OnPlatform x:Key="rowHeight"
                        x:TypeArguments="x:Int32">
                <On Platform="iOS, Android, UWP" Value="60" />
            </OnPlatform>

            <local:DoubleToIntConverter x:Key="intConverter" />

        </ResourceDictionary>
    </ContentPage.Resources>

    <ListView ItemsSource="{x:Static local:NamedColor.All}"
              RowHeight="{StaticResource rowHeight}">
        <ListView.ItemTemplate>
            <DataTemplate>
                <ViewCell>
                    <StackLayout Padding="5, 5, 0, 5"
                                 Orientation="Horizontal"
                                 Spacing="15">

                        <BoxView WidthRequest="{StaticResource boxSize}"
                                 HeightRequest="{StaticResource boxSize}"
                                 Color="{Binding Color}" />

                        <StackLayout Padding="5, 0, 0, 0"
                                     VerticalOptions="Center">

                            <Label Text="{Binding FriendlyName}"
                                   FontAttributes="Bold"
                                   FontSize="Medium" />

                            <StackLayout Orientation="Horizontal"
                                         Spacing="0">
                                <Label Text="{Binding Color.R,
                                       Converter={StaticResource intConverter},
                                       ConverterParameter=255,
                                       StringFormat='R={0:X2}'}" />

                                <Label Text="{Binding Color.G,
                                       Converter={StaticResource intConverter},
                                       ConverterParameter=255,
                                       StringFormat=', G={0:X2}'}" />

                                <Label Text="{Binding Color.B,
                                       Converter={StaticResource intConverter},
                                       ConverterParameter=255,
                                       StringFormat=', B={0:X2}'}" />
                            </StackLayout>
                        </StackLayout>
                    </StackLayout>
                </ViewCell>
            </DataTemplate>
        </ListView.ItemTemplate>
    </ListView>
</ContentPage>

Si noti l'uso di OnPlatform per definire le dimensioni di un oggetto BoxView e l'altezza delle ListView righe.Notice the use of OnPlatform to define the size of a BoxView and the height of the ListView rows. Sebbene i valori per tutte le piattaforme siano uguali, il markup può essere facilmente adattato per altri valori per ottimizzare la visualizzazione.Although the values for all the platforms are the same, the markup could easily be adapted for other values to fine-tune the display.

Convertitori di valori per i bindingBinding Value Converters

Il file XAML demo ListView precedente Visualizza le singole R G proprietà, e B della Xamarin.Forms Color struttura.The previous ListView Demo XAML file displays the individual R, G, and B properties of the Xamarin.Forms Color structure. Queste proprietà sono di tipo double e sono comprese tra 0 e 1.These properties are of type double and range from 0 to 1. Se si desidera visualizzare i valori esadecimali, non è possibile utilizzare semplicemente StringFormat con una specifica di formattazione "X2".If you want to display the hexadecimal values, you can’t simply use StringFormat with an “X2” formatting specification. Funziona solo per numeri interi e oltre a, i double valori devono essere moltiplicati per 255.That only works for integers and besides, the double values need to be multiplied by 255.

Questo piccolo problema è stato risolto con un convertitore di valori, detto anche convertitore di Binding.This little problem was solved with a value converter, also called a binding converter. Si tratta di una classe che implementa l' IValueConverter interfaccia, ovvero presenta due metodi denominati Convert e ConvertBack .This is a class that implements the IValueConverter interface, which means it has two methods named Convert and ConvertBack. Il Convert metodo viene chiamato quando un valore viene trasferito dall'origine alla destinazione; il ConvertBack metodo viene chiamato per i trasferimenti dalla destinazione all'origine OneWayToSource in TwoWay binding o:The Convert method is called when a value is transferred from source to target; the ConvertBack method is called for transfers from target to source in OneWayToSource or TwoWay bindings:

using System;
using System.Globalization;
using Xamarin.Forms;

namespace XamlSamples
{
    class DoubleToIntConverter : IValueConverter
    {
        public object Convert(object value, Type targetType,
                              object parameter, CultureInfo culture)
        {
            double multiplier;

            if (!Double.TryParse(parameter as string, out multiplier))
                multiplier = 1;

            return (int)Math.Round(multiplier * (double)value);
        }

        public object ConvertBack(object value, Type targetType,
                                  object parameter, CultureInfo culture)
        {
            double divider;

            if (!Double.TryParse(parameter as string, out divider))
                divider = 1;

            return ((double)(int)value) / divider;
        }
    }
}

Il ConvertBack metodo non svolge un ruolo in questo programma perché le associazioni sono solo unidirezionali dall'origine alla destinazione.The ConvertBack method does not play a role in this program because the bindings are only one way from source to target.

Un'associazione fa riferimento a un convertitore di associazioni con la Converter Proprietà.A binding references a binding converter with the Converter property. Un convertitore di associazioni può anche accettare un parametro specificato con la ConverterParameter Proprietà.A binding converter can also accept a parameter specified with the ConverterParameter property. Per una certa versatilità, questo è il modo in cui viene specificato il moltiplicatore.For some versatility, this is how the multiplier is specified. Il convertitore di associazioni controlla il parametro del convertitore per un double valore valido.The binding converter checks the converter parameter for a valid double value.

Viene creata un'istanza del convertitore nel dizionario risorse, in modo che possa essere condivisa tra più associazioni:The converter is instantiated in the resource dictionary so it can be shared among multiple bindings:

<local:DoubleToIntConverter x:Key="intConverter" />

Tre associazioni dati fanno riferimento a questa singola istanza.Three data bindings reference this single instance. Si noti che l' Binding estensione di markup contiene un'estensione di markup incorporata StaticResource :Notice that the Binding markup extension contains an embedded StaticResource markup extension:

<Label Text="{Binding Color.R,
                      Converter={StaticResource intConverter},
                      ConverterParameter=255,
                      StringFormat='R={0:X2}'}" />

Ecco il risultato:Here’s the result:

Associazione a una raccolta con DataTemplate e convertitoriBinding to a Collection with a DataTemplate and Converters

ListViewÈ piuttosto sofisticato per la gestione delle modifiche che possono verificarsi in modo dinamico nei dati sottostanti, ma solo se si esegue una determinata procedura.The ListView is quite sophisticated in handling changes that might dynamically occur in the underlying data, but only if you take certain steps. Se la raccolta di elementi assegnati alla ItemsSource proprietà delle ListView modifiche durante il runtime, ovvero se è possibile aggiungere o rimuovere elementi dalla raccolta, utilizzare una ObservableCollection classe per questi elementi.If the collection of items assigned to the ItemsSource property of the ListView changes during runtime—that is, if items can be added to or removed from the collection—use an ObservableCollection class for these items. ObservableCollection implementa l' INotifyCollectionChanged interfaccia e ListView installerà un gestore per l' CollectionChanged evento.ObservableCollection implements the INotifyCollectionChanged interface, and ListView will install a handler for the CollectionChanged event.

Se le proprietà degli elementi cambiano in fase di esecuzione, gli elementi della raccolta devono implementare l' INotifyPropertyChanged interfaccia e segnalare le modifiche ai valori delle proprietà usando l' PropertyChanged evento.If properties of the items themselves change during runtime, then the items in the collection should implement the INotifyPropertyChanged interface and signal changes to property values using the PropertyChanged event. Questa operazione viene illustrata nella parte successiva della serie, la parte 5. Dal data binding a MVVM.This is demonstrated in the next part of this series, Part 5. From Data Binding to MVVM.

RiepilogoSummary

Le associazioni dati forniscono un meccanismo potente per il collegamento delle proprietà tra due oggetti all'interno di una pagina o tra oggetti visivi e dati sottostanti.Data bindings provide a powerful mechanism for linking properties between two objects within a page, or between visual objects and underlying data. Tuttavia, quando l'applicazione inizia a lavorare con le origini dati, un modello di architettura dell'applicazione comune inizia a emergere come un paradigma utile.But when the application begins working with data sources, a popular application architectural pattern begins to emerge as a useful paradigm. Questa operazione è prevista nella parte 5. Da data binding a MVVM.This is covered in Part 5. From Data Bindings to MVVM.