Estensione di markup {x:Bind}{x:Bind} markup extension

Nota   Per informazioni generali sull'uso di data binding nell'app con {x:bind} (e per un confronto totale tra {X:bind} e {Binding}), vedere Data Binding in Depth.Note  For general info about using data binding in your app with {x:Bind} (and for an all-up comparison between {x:Bind} and {Binding}), see Data binding in depth.

L’estensione di markup {x:Bind}, introdotta in Windows 10, è un’alternativa a {Binding}.The {x:Bind} markup extension—new for Windows 10—is an alternative to {Binding}. {x:bind} viene eseguito in meno tempo e meno memoria di {Binding} e supporta il debug migliore.{x:Bind} runs in less time and less memory than {Binding} and supports better debugging.

In fase di compilazione XAML, {x:Bind} viene convertito in codice che riceverà un valore da una proprietà in un'origine dati e lo imposterà nella proprietà specificata nel markup.At XAML compile time, {x:Bind} is converted into code that will get a value from a property on a data source, and set it on the property specified in markup. È possibile configurare facoltativamente l'oggetto Binding per osservare le modifiche apportate al valore della proprietà dell'origine dati e aggiornarle in base a tali modifiche ( Mode="OneWay" ).The binding object can optionally be configured to observe changes in the value of the data source property and refresh itself based on those changes (Mode="OneWay"). Facoltativamente, può anche essere configurato per eseguire il push delle modifiche nel proprio valore alla proprietà di origine ( Mode="TwoWay" ).It can also optionally be configured to push changes in its own value back to the source property (Mode="TwoWay").

Gli oggetti di binding creati da {x:Bind} e {Binding} sono in gran parte equivalenti dal punto di vista funzionale.The binding objects created by {x:Bind} and {Binding} are largely functionally equivalent. {x:Bind} esegue però un codice speciale, che genera in fase di compilazione, e {Binding} usa un’ispezione generica degli oggetti runtime.But {x:Bind} executes special-purpose code, which it generates at compile-time, and {Binding} uses general-purpose runtime object inspection. Di conseguenza, i binding {x:Bind} (spesso definiti binding compilati) hanno ottime prestazioni, eseguono la convalida delle espressioni di binding in fase di compilazione e supportano il debug consentendoti di impostare punti di interruzione nei file di codice generati come classe parziale per la tua pagina.Consequently, {x:Bind} bindings (often referred-to as compiled bindings) have great performance, provide compile-time validation of your binding expressions, and support debugging by enabling you to set breakpoints in the code files that are generated as the partial class for your page. Questi file sono disponibili nella cartella obj, con nomi come (per C#) <view name>.g.cs.These files can be found in your obj folder, with names like (for C#) <view name>.g.cs.

Suggerimento

{x:bind} ha una modalità predefinita, adifferenza di {Binding}, che ha una modalità predefinita di OneWay.{x:Bind} has a default mode of OneTime, unlike {Binding}, which has a default mode of OneWay. Questa scelta è stata scelta per motivi di prestazioni, in quanto l'utilizzo di OneWay comporta la generazione di più codice per il collegamento e la gestione del rilevamento delle modifiche.This was chosen for performance reasons, as using OneWay causes more code to be generated to hookup and handle change detection. È possibile specificare in modo esplicito una modalità per usare l'associazione OneWay o TwoWay.You can explicitly specify a mode to use OneWay or TwoWay binding. È anche possibile usare x:DefaultBindMode per modificare la modalità predefinita per {x:bind} per un segmento specifico dell'albero di markup.You can also use x:DefaultBindMode to change the default mode for {x:Bind} for a specific segment of the markup tree. La modalità specificata si applica a qualsiasi espressione {x:bind} su tale elemento e ai relativi elementi figlio, che non specificano in modo esplicito una modalità come parte dell'associazione.The specified mode applies to any {x:Bind} expressions on that element and its children, that do not explicitly specify a mode as part of the binding.

App di esempio che illustrano {x:Bind}Sample apps that demonstrate {x:Bind}

Sintassi degli attributi XAMLXAML attribute usage

<object property="{x:Bind}" .../>
-or-
<object property="{x:Bind propertyPath}" .../>
-or-
<object property="{x:Bind bindingProperties}" .../>
-or-
<object property="{x:Bind propertyPath, bindingProperties}" .../>
-or-
<object property="{x:Bind pathToFunction.functionName(functionParameter1, functionParameter2, ...), bindingProperties}" .../>
TermineTerm DescrizioneDescription
propertyPathpropertyPath Stringa che specifica il percorso della proprietà per il binding.A string that specifies the property path for the binding. Altre info sono disponibili nella sezione Percorso delle proprietà seguente.More info is in the Property path section below.
bindingPropertiesbindingProperties
propName = valore [ , valore propName = value]*propName=value[, propName=value]* Una o più proprietà di binding che vengono specificate usando una sintassi di coppie nome/valore.One or more binding properties that are specified using a name/value pair syntax.
propNamepropName Nome della stringa della proprietà da impostare sull'oggetto di binding,The string name of the property to set on the binding object. ad esempio "Converter".For example, "Converter".
valuevalue Valore su cui impostare la proprietà.The value to set the property to. La sintassi dell'argomento dipende dalla proprietà da impostare.The syntax of the argument depends on the property being set. Di seguito è riportato un esempio di utilizzo del valore propName = value , in cui il valore è a sua volta un'estensione di markup: Converter={StaticResource myConverterClass} .Here's an example of a propName=value usage where the value is itself a markup extension: Converter={StaticResource myConverterClass}. Per altre info, vedi più avanti la sezione Proprietà che è possibile impostare con {x:Bind}.For more info, see Properties that you can set with {x:Bind} section below.

EsempiExamples

<Page x:Class="QuizGame.View.HostView" ... >
    <Button Content="{x:Bind Path=ViewModel.NextButtonText, Mode=OneWay}" ... />
</Page>

Questo XAML di esempio usa {x:Bind} con una proprietà ListView.ItemTemplate.This example XAML uses {x:Bind} with a ListView.ItemTemplate property. Nota la dichiarazione di un valore x:DataType.Note the declaration of an x:DataType value.

  <DataTemplate x:Key="SimpleItemTemplate" x:DataType="data:SampleDataGroup">
    <StackPanel Orientation="Vertical" Height="50">
      <TextBlock Text="{x:Bind Title}"/>
      <TextBlock Text="{x:Bind Description}"/>
    </StackPanel>
  </DataTemplate>

Percorso proprietàProperty path

PropertyPath imposta Path per un’espressione {x:Bind}.PropertyPath sets the Path for an {x:Bind} expression. Path è un percorso di proprietà che specifica il valore della proprietà, della proprietà secondaria, del campo o del metodo a cui stai eseguendo il binding (l’origine).Path is a property path specifying the value of the property, sub-property, field, or method that you're binding to (the source). Puoi citare il nome della proprietà Path in modo esplicito: {x:Bind Path=...}.You can mention the name of the Path property explicitly: {x:Bind Path=...}. Oppure puoi ometterlo: {x:Bind ...}.Or you can omit it: {x:Bind ...}.

Risoluzione del percorso delle proprietàProperty path resolution

{x:Bind} non usa DataContext come origine predefinita, ma usa invece la pagina o il controllo utente stesso.{x:Bind} does not use the DataContext as a default source—instead, it uses the page or user control itself. Quindi cercherà nel code-behind della pagina o del controllo utente le proprietà, i campi e i metodi.So it will look in the code-behind of your page or user control for properties, fields, and methods. Per esporre il tuo modello di visualizzazione a {x:Bind}, dovrai in genere aggiungere nuovi campi o proprietà al code-behind della pagina o del controllo utente.To expose your view model to {x:Bind}, you will typically want to add new fields or properties to the code behind for your page or user control. I passaggi di un percorso di proprietà sono delimitati da punti (.) e puoi includere più delimitatori per attraversare le proprietà secondarie successive.Steps in a property path are delimited by dots (.), and you can include multiple delimiters to traverse successive sub-properties. Usa il delimitatore punto indipendentemente dal linguaggio di programmazione usato per implementare l'oggetto a cui viene eseguito il binding.Use the dot delimiter regardless of the programming language used to implement the object being bound to.

Ad esempio, in una pagina Text="{x:Bind Employee.FirstName}" cercherà un membro Employee nella pagina e quindi un membro FirstName nell’oggetto restituito da Employee.For example: in a page, Text="{x:Bind Employee.FirstName}" will look for an Employee member on the page and then a FirstName member on the object returned by Employee. Se stai eseguendo il binding di un controllo elementi a una proprietà contenente gli elementi che dipendono dal dipendente, il percorso della proprietà potrebbe essere "Employee.Dependents". Un modello di elemento del controllo elementi si occuperà della visualizzazione degli elementi in "Dependents".If you are binding an items control to a property that contains an employee's dependents, your property path might be "Employee.Dependents", and the item template of the items control would take care of displaying the items in "Dependents".

Per C++/CX, {x:Bind} non può eseguire il binding a proprietà e campi privati nella pagina o nel modello di dati. Per eseguire il binding a una proprietà, è necessario che questa sia pubblica.For C++/CX, {x:Bind} cannot bind to private fields and properties in the page or data model – you will need to have a public property for it to be bindable. La superficie di attacco per il binding deve essere esposta come classe/interfaccia CX per poter ottenere i metadati pertinenti.The surface area for binding needs to be exposed as CX classes/interfaces so that we can get the relevant metadata. L'attributo ** [ associabile ] ** non dovrebbe essere necessario.The [Bindable] attribute should not be needed.

Con x:Bind non hai bisogno di usare ElementName=xxx come parte dell'espressione di binding.With x:Bind, you do not need to use ElementName=xxx as part of the binding expression. In alternativa, è possibile usare il nome dell'elemento come prima parte del percorso per l'associazione perché gli elementi denominati diventano campi all'interno della pagina o del controllo utente che rappresenta l'origine del binding radice.Instead, you can use the name of the element as the first part of the path for the binding because named elements become fields within the page or user control that represents the root binding source.

RaccolteCollections

Se l'origine dati è una raccolta, un percorso di proprietà può specificare gli elementi della raccolta in base alla posizione o all'indice.If the data source is a collection, then a property path can specify items in the collection by their position or index. Ad esempio, "Teams [ 0 ] . Players ", dove il valore letterale" [ ] "racchiude" 0 "che richiede il primo elemento in una raccolta con indice zero.For example, "Teams[0].Players", where the literal "[]" encloses the "0" that requests the first item in a zero-indexed collection.

Per usare un indicizzatore, il modello deve implementare IList<T> o IVector<T> nel tipo della proprietà che verrà indicizzata.To use an indexer, the model needs to implement IList<T> or IVector<T> on the type of the property that is going to be indexed. Si noti che IReadOnlyList < T > e IVectorView < t non > supportano la sintassi dell'indicizzatore. Se il tipo della proprietà indicizzata supporta INotifyCollectionChanged o IObservableVector e l'associazione è OneWay o TwoWay, verranno registrate e ascoltate le notifiche di modifica su tali interfacce.(Note that IReadOnlyList<T> and IVectorView<T> do not support the indexer syntax.) If the type of the indexed property supports INotifyCollectionChanged or IObservableVector and the binding is OneWay or TwoWay, then it will register and listen for change notifications on those interfaces. La logica di rilevamento delle modifiche verrà aggiornata in base a tutte le modifiche della raccolta, anche se ciò non ha effetto sullo specifico valore indicizzato.The change detection logic will update based on all collection changes, even if that doesn’t affect the specific indexed value. Infatti la logica di ascolto è comune a tutte le istanze della raccolta.This is because the listening logic is common across all instances of the collection.

Se l'origine dati è un dizionario o una mappa, un percorso di proprietà può specificare gli elementi della raccolta in base al nome della stringa.If the data source is a Dictionary or Map, then a property path can specify items in the collection by their string name. Ad esempio, ** < TextBlock Text = "{x:bind Players [ ' John Smith ' ] } > "/** cercherà un elemento nel dizionario denominato "John Smith".For example <TextBlock Text="{x:Bind Players['John Smith']}" /> will look for an item in the dictionary named "John Smith". Il nome deve essere racchiuso tra virgolette, singole o doppie.The name needs to be enclosed in quotes, and either single or double quotes can be used. L'accento circonflesso (^) può essere usato come carattere di escape per le virgolette nelle stringhe.Hat (^) can be used to escape quotes in strings. In genere è più semplice usare le virgolette alternative rispetto a quelle usate per l'attributo XAML.It's usually easiest to use alternate quotes from those used for the XAML attribute. Si noti che IReadOnlyDictionary < T > e IMapView < t non > supportano la sintassi dell'indicizzatore.(Note that IReadOnlyDictionary<T> and IMapView<T> do not support the indexer syntax.)

Per usare un indicizzatore di stringa, il modello deve implementare IDictionary<string, T> o IMap<string, T> nel tipo della proprietà che verrà indicizzata.To use an string indexer, the model needs to implement IDictionary<string, T> or IMap<string, T> on the type of the property that is going to be indexed. Se il tipo della proprietà indicizzata supporta IObservableMap e il binding è OneWay o TwoWay, registrerà e sarà in ascolto delle notifiche di modifica in tali interfacce.If the type of the indexed property supports IObservableMap and the binding is OneWay or TwoWay, then it will register and listen for change notifications on those interfaces. La logica di rilevamento delle modifiche verrà aggiornata in base a tutte le modifiche della raccolta, anche se ciò non ha effetto sullo specifico valore indicizzato.The change detection logic will update based on all collection changes, even if that doesn’t affect the specific indexed value. Infatti la logica di ascolto è comune a tutte le istanze della raccolta.This is because the listening logic is common across all instances of the collection.

Proprietà associateAttached Properties

Per eseguire l'associazione alle proprietà associate, è necessario inserire la classe e il nome della proprietà tra parentesi dopo il punto.To bind to attached properties, you need to put the class and property name into parentheses after the dot. Ad esempio, Text="{x:Bind Button22.(Grid.Row)}".For example Text="{x:Bind Button22.(Grid.Row)}". Se la proprietà non viene dichiarata in uno spazio dei nomi Xaml, dovrai inserire come prefisso uno spazio dei nomi xml, di cui eseguire il mapping con un spazio dei nomi del codice all'inizio del documento.If the property is not declared in a Xaml namespace, then you will need to prefix it with a xml namespace, which you should map to a code namespace at the head of the document.

CastCasting

I binding compilati sono fortemente tipizzati e risolveranno il tipo di ogni passaggio in un percorso.Compiled bindings are strongly typed, and will resolve the type of each step in a path. Se il tipo restituito non ha il membro, avrà esito negativo in fase di compilazione.If the type returned doesn’t have the member, it will fail at compile time. Puoi specificare un cast per indicare al binding il tipo effettivo dell'oggetto.You can specify a cast to tell binding the real type of the object.

Nel caso seguente obj è una proprietà dell'oggetto tipo, ma contiene una casella di testo e quindi possiamo usare Text="{x:Bind ((TextBox)obj).Text}" o Text="{x:Bind obj.(TextBox.Text)}".In the following case, obj is a property of type object, but contains a text box, so we can use either Text="{x:Bind ((TextBox)obj).Text}" or Text="{x:Bind obj.(TextBox.Text)}".

Il campo groups3 in Text = "{x:Bind ((Data: SampleDataGroup) groups3 [ 0 ] ). Title} " è un dizionario di oggetti, quindi è necessario eseguirne il cast ai dati: SampleDataGroup.The groups3 field in Text="{x:Bind ((data:SampleDataGroup)groups3[0]).Title}" is a dictionary of objects, so you must cast it to data:SampleDataGroup. Nota l'uso del prefisso dello spazio dei nomi xml data: per il mapping del tipo di oggetto a uno spazio dei nomi del codice che non fa parte dello spazio dei nomi XAML predefinito.Note the use of the xml data: namespace prefix for mapping the object type to a code namespace that isn't part of the default XAML namespace.

Nota: la sintassi del cast di tipo C# è più flessibile rispetto alla sintassi della proprietà associata ed è la sintassi consigliata per il futuro.Note: The C#-style cast syntax is more flexible than the attached property syntax, and is the recommended syntax going forward.

Casting non tracciatoPathless casting

Il parser di binding nativo non fornisce una parola chiave da rappresentare this come parametro di funzione, ma supporta il cast senza percorso (ad esempio, {x:Bind (x:String)} ), che può essere usato come parametro di funzione.The native bind parser doesn't provide a keyword to represent this as a function parameter, but it does support pathless casting (for example, {x:Bind (x:String)}), which can be used as a function parameter. Pertanto, {x:Bind MethodName((namespace:TypeOfThis))} è un modo valido per eseguire l'elemento concettualmente equivalente a {x:Bind MethodName(this)} .Therefore, {x:Bind MethodName((namespace:TypeOfThis))} is a valid way to perform what is conceptually equivalent to {x:Bind MethodName(this)}.

Esempio:Example:

Text="{x:Bind local:MainPage.GenerateSongTitle((local:SongItem))}"

<Page
    x:Class="AppSample.MainPage"
    ...
    xmlns:local="using:AppSample">

    <Grid>
        <ListView ItemsSource="{x:Bind Songs}">
            <ListView.ItemTemplate>
                <DataTemplate x:DataType="local:SongItem">
                    <TextBlock
                        Margin="12"
                        FontSize="40"
                        Text="{x:Bind local:MainPage.GenerateSongTitle((local:SongItem))}" />
                </DataTemplate>
            </ListView.ItemTemplate>
        </ListView>
    </Grid>
</Page>
namespace AppSample
{
    public class SongItem
    {
        public string TrackName { get; private set; }
        public string ArtistName { get; private set; }

        public SongItem(string trackName, string artistName)
        {
            ArtistName = artistName;
            TrackName = trackName;
        }
    }

    public sealed partial class MainPage : Page
    {
        public List<SongItem> Songs { get; }
        public MainPage()
        {
            Songs = new List<SongItem>()
            {
                new SongItem("Track 1", "Artist 1"),
                new SongItem("Track 2", "Artist 2"),
                new SongItem("Track 3", "Artist 3")
            };

            this.InitializeComponent();
        }

        public static string GenerateSongTitle(SongItem song)
        {
            return $"{song.TrackName} - {song.ArtistName}";
        }
    }
}

Funzioni nei percorsi di bindingFunctions in binding paths

A partire da Windows 10 versione 1607, {x:Bind} supporta l'uso di una funzione come passaggio foglia del percorso di binding.Starting in Windows 10, version 1607, {x:Bind} supports using a function as the leaf step of the binding path. Si tratta di una funzionalità potente per l'associazione dati che consente diversi scenari di markup.This is a powerful feature for databinding that enables several scenarios in markup. Per informazioni dettagliate, vedere associazioni di funzioni .See function bindings for details.

Binding di eventiEvent Binding

Il binding di eventi è una funzionalità specifica per il binding compilato.Event binding is a unique feature for compiled binding. Consente di specificare il gestore di un evento con un binding, anziché come metodo nel code-behind.It enables you to specify the handler for an event using a binding, rather than it having to be a method on the code behind. Ad esempio: Click="{x:Bind rootFrame.GoForward}".For example: Click="{x:Bind rootFrame.GoForward}".

Per gli eventi, il metodo di destinazione non deve essere sovraccaricato e deve anche:For events, the target method must not be overloaded and must also:

  • Corrispondere alla firma dell'evento.Match the signature of the event.
  • OPPURE non avere parametri.OR have no parameters.
  • OPPURE avere lo stesso numero di parametri di tipi assegnabili dai tipi dei parametri degli eventi.OR have the same number of parameters of types that are assignable from the types of the event parameters.

Nel code-behind generato il binding compilato gestisce l'evento e lo instrada al metodo nel modello, valutando il percorso dell'espressione di binding quando si verifica l'evento.In generated code-behind, compiled binding handles the event and routes it to the method on the model, evaluating the path of the binding expression when the event occurs. Questo significa che, diversamente dai binding delle proprietà, non tiene traccia delle modifiche al modello.This means that, unlike property bindings, it doesn’t track changes to the model.

Per altre info sulla sintassi delle stringhe per un percorso delle proprietà, vedi Sintassi proprietà-percorso, ricordando le differenze descritte qui per {x:Bind}.For more info about the string syntax for a property path, see Property-path syntax, keeping in mind the differences described here for {x:Bind}.

Proprietà che è possibile impostare con {x:Bind}Properties that you can set with {x:Bind}

{x:Bind} viene illustrato con la sintassi del segnaposto bindingProperties perché sono presenti più proprietà di lettura/scrittura che è possibile impostare nell'estensione di markup.{x:Bind} is illustrated with the bindingProperties placeholder syntax because there are multiple read/write properties that can be set in the markup extension. Le proprietà possono essere impostate in qualsiasi ordine con le coppie di valori propNameseparate da virgole = value .The properties can be set in any order with comma-separated propName=value pairs. Tieni presente che non puoi includere interruzioni di riga nell'espressione di binding.Note that you cannot include line breaks in the binding expression. Alcune delle proprietà richiedono tipi che non hanno una conversione di tipi e quindi necessitano di estensioni di markup proprie annidate in {x:Bind}.Some of the properties require types that don't have a type conversion, so these require markup extensions of their own nested within the {x:Bind}.

Queste proprietà funzionano in modo molto simile alle proprietà della classe Binding.These properties work in much the same way as the properties of the Binding class.

ProprietàProperty DescrizioneDescription
PercorsoPath Vedi la sezione Percorso delle proprietà precedente.See the Property path section above.
ConverterConverter Specifica l'oggetto convertitore che viene chiamato dal motore di binding.Specifies the converter object that is called by the binding engine. Il convertitore può essere impostato in XAML, ma solo se fai riferimento a un’istanza di oggetto assegnata in un riferimento di un’estensione di markup {StaticResource} a tale oggetto nel dizionario risorse.The converter can be set in XAML, but only if you refer to an object instance that you've assigned in a {StaticResource} markup extension reference to that object in the resource dictionary.
ConverterLanguageConverterLanguage Specifica le impostazioni cultura che devono essere usate dal convertitoreSpecifies the culture to be used by the converter. (se imposti ConverterLanguage devi impostare anche Converter). Le impostazioni cultura vengono specificate come identificatore basato su standard.(If you're setting ConverterLanguage you should also be setting Converter.) The culture is set as a standards-based identifier. Per altre informazioni, vedere ConverterLanguage.For more info, see ConverterLanguage.
ConverterParameterConverterParameter Specifica il parametro convertitore che è possibile usare nella logica del convertitoreSpecifies the converter parameter that can be used in converter logic. (se imposti ConverterParameter devi impostare anche Converter). La maggior parte dei convertitori usa una logica semplice per ottenere tutte le info necessarie dal valore passato per la conversione e non richiede un valore ConverterParameter.(If you're setting ConverterParameter you should also be setting Converter.) Most converters use simple logic that get all the info they need from the passed value to convert, and don't need a ConverterParameter value. Il parametro ConverterParameter è destinato a implementazioni di convertitori moderatamente avanzate con più di una logica specifica per quanto viene passato in ConverterParameter.The ConverterParameter parameter is for moderately advanced converter implementations that have more than one logic that keys off what's passed in ConverterParameter. È possibile scrivere un convertitore che usa valori diversi dalle stringhe, ma questo non è comune, vedere la sezione Osservazioni in ConverterParameter per altre informazioni.You can write a converter that uses values other than strings but this is uncommon, see Remarks in ConverterParameter for more info.
FallbackValueFallbackValue Specifica un valore da visualizzare quando non è possibile risolvere l'origine o il percorso.Specifies a value to display when the source or path cannot be resolved.
ModalitàMode Specifica la modalità di binding sotto forma di una delle stringhe seguenti: "OneTime", "OneWay" o "TwoWay".Specifies the binding mode, as one of these strings: "OneTime", "OneWay", or "TwoWay". Il valore predefinito è "OneTime".The default is "OneTime". Nota che è diversa dall’impostazione predefinita per {Binding}, che è "OneWay" nella maggior parte dei casi.Note that this differs from the default for {Binding}, which is "OneWay" in most cases.
TargetNullValueTargetNullValue Specifica un valore da visualizzare quando il valore dell’origine viene risolto, ma è esplicitamente null.Specifies a value to display when the source value resolves but is explicitly null.
BindBackBindBack Specifica una funzione da usare per la direzione inversa di un binding bidirezionale.Specifies a function to use for the reverse direction of a two-way binding.
UpdateSourceTriggerUpdateSourceTrigger Specifica quando eseguire il push delle modifiche dal controllo al modello nelle associazioni TwoWay.Specifies when to push changes back from the control to the model in TwoWay bindings. Il valore predefinito per tutte le proprietà eccetto TextBox. Text è PropertyChanged; TextBox. Text è disattivato.The default for all properties except TextBox.Text is PropertyChanged; TextBox.Text is LostFocus.

Nota

Se si converte il markup da {Binding} a {x:bind}, tenere presente le differenze nei valori predefiniti per la proprietà mode .If you're converting markup from {Binding} to {x:Bind}, then be aware of the differences in default values for the Mode property. x:DefaultBindMode può essere usato per modificare la modalità predefinita per x:Bind per un segmento specifico dell'albero di markup.x:DefaultBindMode can be used to change the default mode for x:Bind for a specific segment of the markup tree. La modalità selezionata applica le espressioni x:Bind su tale elemento e sui relativi elementi figlio, che non specificano in modo esplicito una modalità come parte dell'associazione.The mode selected will apply any x:Bind expressions on that element and its children, that do not explicitly specify a mode as part of the binding. Una volta è più efficiente di OneWay perché l'uso di OneWay provocherà la generazione di più codice per il collegamento e la gestione del rilevamento delle modifiche.OneTime is more performant than OneWay as using OneWay will cause more code to be generated to hookup and handle the change detection.

CommentiRemarks

Poiché {x:Bind} usa il codice generato per ottenerne i vantaggi, richiede le informazioni sul tipo in fase di compilazione.Because {x:Bind} uses generated code to achieve its benefits, it requires type information at compile time. Questo significa che non puoi eseguire il binding alle proprietà di cui non conosci il tipo in anticipo.This means that you cannot bind to properties where you do not know the type ahead of time. Di conseguenza, non puoi usare {x:Bind} con la proprietà DataContext, che è di tipo Object ed è anche soggetta a modifiche in fase di esecuzione.Because of this, you cannot use {x:Bind} with the DataContext property, which is of type Object, and is also subject to change at run time.

Quando si usa {x:bind} con i modelli di dati, è necessario indicare il tipo a cui viene associato impostando un valore di x:DataType , come illustrato nella sezione degli esempi .When using {x:Bind} with data templates, you must indicate the type being bound to by setting an x:DataType value, as shown in the Examples section. Puoi anche impostare il tipo su un'interfaccia o un tipo di classe di base e quindi usare i cast, se necessario per formulare un'espressione completa.You can also set the type to an interface or base class type, and then use casts if necessary to formulate a full expression.

I binding compilati dipendono dalla generazione del codice.Compiled bindings depend on code generation. Per questo, se usi {x:Bind} in un dizionario risorse, il dizionario deve avere una classe code-behind.So if you use {x:Bind} in a resource dictionary then the resource dictionary needs to have a code-behind class. Per un esempio di codice, vedi Dizionari di risorse con {x:Bind}.See Resource dictionaries with {x:Bind} for a code example.

Le pagine e i controlli utente che includono binding compilati avranno una proprietà "Bindings" nel codice generato.Pages and user controls that include Compiled bindings will have a "Bindings" property in the generated code. Sono inclusi i metodi seguenti:This includes the following methods:

  • Update (): aggiornerà i valori di tutti i binding compilati.Update() - This will update the values of all compiled bindings. Per i binding unidirezionali/bidirezionali vengono associati listener per il rilevamento delle modifiche.Any one-way/Two-Way bindings will have the listeners hooked up to detect changes.
  • Initialize(): se i binding non sono ancora stati inizializzati, chiamerà Update() per inizializzarliInitialize() - If the bindings have not already been initialized, then it will call Update() to initialize the bindings
  • StopTracking(): disassocerà tutti i listener creati per i binding unidirezionali e bidirezionali.StopTracking() - This will unhook all listeners created for one-way and two-way bindings. Possono essere reinizializzati usando il metodo Update ().They can be re-initialized using the Update() method.

Nota

A partire da Windows 10 versione 1607, il framework XAML fornisce un valore booleano predefinito per il convertitore Visibility.Starting in Windows 10, version 1607, the XAML framework provides a built in Boolean to Visibility converter. Il convertitore esegue il mapping true al valore di enumerazione visibile e false a compresso , in modo da poter associare una proprietà Visibility a un valore booleano senza creare un convertitore.The converter maps true to the Visible enumeration value and false to Collapsed so you can bind a Visibility property to a Boolean without creating a converter. Si noti che non si tratta di una funzionalità dell'associazione di funzioni, ma solo dell'associazione di proprietà.Note that this is not a feature of function binding, only property binding. Per usare il convertitore predefinito, la versione minima dell'SDK di destinazione dell'app deve essere 14393 o successiva.To use the built in converter, your app's minimum target SDK version must be 14393 or later. Non puoi usarlo quando l'app è destinata alle versioni precedenti di Windows 10.You can't use it when your app targets earlier versions of Windows 10. Per altre info sulle versioni di destinazione, vedi Codice adattivo per la versione.For more info about target versions, see Version adaptive code.

Suggerimento   Se devi specificare una singola parentesi graffa per un valore, come in Path o ConverterParameter, anteponi una barra rovesciata: \{.Tip   If you need to specify a single curly brace for a value, such as in Path or ConverterParameter, precede it with a backslash: \{. In alternativa, racchiudi l’intera stringa che contiene le parentesi graffe che richiedono l’escape in un set di virgolette secondario, ad esempio ConverterParameter='{Mix}'.Alternatively, enclose the entire string that contains the braces that need escaping in a secondary quotation set, for example ConverterParameter='{Mix}'.

Le proprietà Converter, ConverterLanguage e ConverterLanguage sono tutte correlate allo scenario di conversione di un valore o tipo dall’origine di binding a un tipo o valore compatibile con la proprietà di destinazione del binding.Converter, ConverterLanguage and ConverterLanguage are all related to the scenario of converting a value or type from the binding source into a type or value that is compatible with the binding target property. Per altre info ed esempi, vedi la sezione "Conversioni dati" dell'argomento Informazioni approfondite sul data binding.For more info and examples, see the "Data conversions" section of Data binding in depth.

{x:Bind} è solo un’estensione di markup e non è possibile creare o modificare tali binding a livello di codice.{x:Bind} is a markup extension only, with no way to create or manipulate such bindings programmatically. Per altre info sulle estensioni di markup, vedi Panoramica di XAML.For more info about markup extensions, see XAML overview.