data binding ASP.NET Core Blazor

Questo articolo illustra le funzionalità di data binding per Razor i componenti e gli elementi DOM nelle Blazor app.

Funzionalità di associazione

Razor i componenti forniscono funzionalità di data binding con l'attributo @bindRazor di direttiva con un campo, una proprietà o Razor un valore di espressione.

Nell'esempio seguente viene associato:

• Valore <input> dell'elemento per il campo C# inputValue .
• <input> Secondo valore dell'elemento per la proprietà C#InputValue.

Quando un <input> elemento perde lo stato attivo, viene aggiornato il relativo campo o proprietà associata.

Bind.razor:

@page "/bind"

<PageTitle>Bind</PageTitle>

<h1>Bind Example</h1>

<p>
    <label>
        inputValue: 
        <input @bind="inputValue" />
    </label>
</p>

<p>
    <label>
        InputValue: 
        <input @bind="InputValue" />
    </label>
</p>

<ul>
    <li><code>inputValue</code>: @inputValue</li>
    <li><code>InputValue</code>: @InputValue</li>
</ul>

@code {
    private string? inputValue;

    private string? InputValue { get; set; }
}

La casella di testo viene aggiornata nell'interfaccia utente solo quando viene eseguito il rendering del componente, non in risposta alla modifica del valore del campo o della proprietà. Poiché i componenti vengono visualizzati dopo l'esecuzione del codice del gestore eventi, gli aggiornamenti dei campi e delle proprietà vengono in genere riflessi nell'interfaccia utente immediatamente dopo l'attivazione di un gestore eventi.

Come dimostrazione della composizione del data binding in HTML, nell'esempio seguente la InputValue proprietà viene associata agli attributi e onchange del value secondo <input> elemento (change). Il secondo <input> elemento nell'esempio seguente è una dimostrazione di concetto e non è progettato per suggerire come associare i dati nei Razor componenti.

BindTheory.razor:

@page "/bind-theory"

<PageTitle>Bind Theory</PageTitle>

<h1>Bind Theory Example</h1>

<p>
    <label>
        Normal Blazor binding: 
        <input @bind="InputValue" />
    </label>
</p>

<p>
    <label>
        Demonstration of equivalent HTML binding: 
        <input value="@InputValue" @onchange="@((ChangeEventArgs __e) =>
            InputValue = __e?.Value?.ToString())" />
    </label>
</p>

<p>
    <code>InputValue</code>: @InputValue
</p>

@code {
    private string? InputValue { get; set; }
}

Quando viene eseguito il rendering del BindTheory componente, l'oggetto value dell'elemento dimostrativo <input> HTML proviene dalla InputValue proprietà . Quando l'utente immette un valore nella casella di testo e cambia lo stato attivo dell'elemento, l'evento onchange viene generato e la InputValue proprietà viene impostata sul valore modificato. In realtà, l'esecuzione del codice è più complessa perché @bind gestisce i casi in cui vengono eseguite le conversioni dei tipi. In generale, @bind associa il valore corrente di un'espressione all'attributo value di <input> e gestisce le modifiche usando il gestore registrato.

Associare una proprietà o un campo in altri eventi DOM includendo un @bind:event="{EVENT}" attributo con un evento DOM per il {EVENT} segnaposto. Nell'esempio seguente la InputValue proprietà viene associata al <input> valore dell'elemento quando viene attivato l'evento dell'elemento oninput (input). A differenza dell'evento onchange (change), che viene generato quando l'elemento perde lo stato attivo, oninput (input) viene attivato quando il valore della casella di testo cambia.

Page/BindEvent.razor:

@page "/bind-event"

<PageTitle>Bind Event</PageTitle>

<h1>Bind Event Example</h1>

<p>
    <label>
        InputValue: 
        <input @bind="InputValue" @bind:event="oninput" />
    </label>
    
</p>

<p>
    <code>InputValue</code>: @InputValue
</p>

@code {
    private string? InputValue { get; set; }
}

Per eseguire la logica asincrona dopo l'associazione, usare @bind:after="{EVENT}" con un evento DOM per il {EVENT} segnaposto. Un metodo C# assegnato non viene eseguito finché il valore associato non viene assegnato in modo sincrono.

L'uso di un parametro di callback evento (EventCallbackEventCallback<T>/) con @bind:after non è supportato. Passare invece un metodo che restituisce un oggetto Action o Task a @bind:after.

Nell'esempio seguente :

• Ogni <input> elemento value è associato in modo sincrono al searchText campo.
• Il PerformSearch metodo viene eseguito in modo asincrono:
  • Quando la prima casella perde lo stato attivo (onchange evento) dopo la modifica del valore.
  • Dopo ogni sequenza di tasti (oninput evento) nella seconda casella.
• PerformSearch chiama un servizio con un metodo asincrono (FetchAsync) per restituire i risultati della ricerca.

@inject ISearchService SearchService

<input @bind="searchText" @bind:after="PerformSearch" />
<input @bind="searchText" @bind:event="oninput" @bind:after="PerformSearch" />

@code {
    private string? searchText;
    private string[]? searchResult;

    private async Task PerformSearch() => 
        searchResult = await SearchService.FetchAsync(searchText);
}

Esempi aggiuntivi

BindAfter.razor:

@page "/bind-after"
@using Microsoft.AspNetCore.Components.Forms

<h1>Bind After Examples</h1>

<h2>Elements</h2>

<input type="text" @bind="text" @bind:after="() => { }" />

<input type="text" @bind="text" @bind:after="After" />

<input type="text" @bind="text" @bind:after="AfterAsync" />

<h2>Components</h2>

<InputText @bind-Value="text" @bind-Value:after="() => { }" />

<InputText @bind-Value="text" @bind-Value:after="After" />

<InputText @bind-Value="text" @bind-Value:after="AfterAsync" />

@code {
    private string text = "";

    private void After() {}
    private Task AfterAsync() { return Task.CompletedTask; }
}

Per altre informazioni sul InputText componente, vedere ASP.NET Componenti di input principaliBlazor.

I componenti supportano il data binding bidirezionale definendo una coppia di parametri:

• @bind:get: specifica il valore da associare.
• @bind:set: specifica un callback per quando il valore cambia.

I @bind:get modificatori e @bind:set vengono sempre usati insieme.

Esempi

BindGetSet.razor:

@page "/bind-get-set"
@using Microsoft.AspNetCore.Components.Forms

<h1>Bind Get Set Examples</h1>

<h2>Elements</h2>

<input type="text" @bind:get="text" @bind:set="(value) => { text = value; }" />
<input type="text" @bind:get="text" @bind:set="Set" />
<input type="text" @bind:get="text" @bind:set="SetAsync" />

<h2>Components</h2>

<InputText @bind-Value:get="text" @bind-Value:set="(value) => { text = value; }" />
<InputText @bind-Value:get="text" @bind-Value:set="Set" />
<InputText @bind-Value:get="text" @bind-Value:set="SetAsync" />

@code {
    private string text = "";

    private void Set(string value)
    {
        text = value;
    }

    private Task SetAsync(string value)
    {
        text = value;
        return Task.CompletedTask;
    }
}

Per altre informazioni sul InputText componente, vedere ASP.NET Componenti di input principaliBlazor.

Per un altro esempio di utilizzo di @bind:get e @bind:set, vedere la sezione Eseguire l'associazione tra più di due componenti più avanti in questo articolo.

Razor l'associazione di attributi fa distinzione tra maiuscole e minuscole:

• @bind, @bind:evente @bind:after sono validi.
• @Bind/@bind:Event/@bind:aftEr(lettere maiuscole) o @BIND/@BIND:EVENT@BIND:AFTER/(tutte le lettere maiuscole) non sono valide.

Usare @bind:get/@bind:set i modificatori ed evitare gestori eventi per il data binding bidirezionale

Il data binding bidirezionale non è possibile implementare con un gestore eventi. Usare @bind:get/@bind:set i modificatori per il data binding bidirezionale.

❌Si consideri l'approccio disfunzionale seguente per il data binding bidirezionale usando un gestore eventi:

<p>
    <input value="@inputValue" @oninput="OnInput" />
</p>

<p>
    <code>inputValue</code>: @inputValue
</p>

@code {
    private string? inputValue;

    private void OnInput(ChangeEventArgs args)
    {
        var newValue = args.Value?.ToString() ?? string.Empty;

        inputValue = newValue.Length > 4 ? "Long!" : newValue;
    }
}

Il OnInput gestore eventi aggiorna il valore di inputValue a Long! dopo che viene fornito un quarto carattere. Tuttavia, l'utente può continuare ad aggiungere caratteri al valore dell'elemento nell'interfaccia utente. Il valore di inputValue non è associato al valore dell'elemento con ogni sequenza di tasti. L'esempio precedente è in grado di eseguire solo il data binding unidirezionale.

Il motivo di questo comportamento è che Blazor non è consapevole che il codice intende modificare il valore di inputValue nel gestore eventi. Blazor non tenta di forzare la corrispondenza dei valori degli elementi DOM e delle variabili .NET, a meno che non siano associati alla @bind sintassi. Nelle versioni precedenti di Blazor, il data binding bidirezionale viene implementato associando l'elemento a una proprietà e controllando il valore della proprietà con il relativo setter. In ASP.NET Core in .NET 7 o versione successiva viene @bind:get/@bind:set usata la sintassi del modificatore per implementare il data binding bidirezionale, come illustrato nell'esempio seguente.

✔️ Si consideri l'approccio corretto seguente usando @bind:get/@bind:set per il data binding bidirezionale:

<p>
    <input @bind:event="oninput" @bind:get="inputValue" @bind:set="OnInput" />
</p>

<p>
    <code>inputValue</code>: @inputValue
</p>

@code {
    private string? inputValue;

    private void OnInput(string value)
    {
        var newValue = value ?? string.Empty;

        inputValue = newValue.Length > 4 ? "Long!" : newValue;
    }
}

L'uso dei modificatori controlla sia il valore sottostante di inputValue via @bind:set che associa il valore di inputValue al valore dell'elemento tramite @bind:get.@bind:get/@bind:set L'esempio precedente illustra l'approccio corretto per l'implementazione del data binding bidirezionale.

Associazione a una proprietà con C# get e set funzioni di accesso

Le funzioni di accesso e set C# get possono essere usate per creare un comportamento di formato di associazione personalizzato, come illustrato nel componente seguenteDecimalBinding. Il componente associa un decimale positivo o negativo con un massimo di tre posizioni decimali a un <input> elemento tramite una string proprietà (DecimalValue).

DecimalBinding.razor:

@page "/decimal-binding"
@using System.Globalization

<PageTitle>Decimal Binding</PageTitle>

<h1>Decimal Binding Example</h1>

<p>
    <label>
        Decimal value (±0.000 format):
        <input @bind="DecimalValue" />
    </label>
</p>

<p>
    <code>decimalValue</code>: @decimalValue
</p>

@code {
    private decimal decimalValue = 1.1M;
    private NumberStyles style = 
        NumberStyles.AllowDecimalPoint | NumberStyles.AllowLeadingSign;
    private CultureInfo culture = CultureInfo.CreateSpecificCulture("en-US");

    private string DecimalValue
    {
        get => decimalValue.ToString("0.000", culture);
        set
        {
            if (Decimal.TryParse(value, style, culture, out var number))
            {
                decimalValue = Math.Round(number, 3);
            }
        }
    }
}

Nota

L'associazione bidirezionale a una proprietà con get/set funzioni di accesso richiede l'eliminazione dell'oggetto Task restituito da .EventCallback.InvokeAsync Per il data binding bidirezionale, è consigliabile usare @bind:get/@bind:set modificatori. Per altre informazioni, vedere le @bind:get/@bind:set indicazioni riportate in precedenza in questo articolo.

Selezione di più opzioni con <select> elementi

L'associazione supporta la multiple selezione di opzioni con <select> elementi. L'evento @onchange fornisce una matrice degli elementi selezionati tramite argomenti evento (ChangeEventArgs). Il valore deve essere associato a un tipo di matrice.

BindMultipleInput.razor:

@page "/bind-multiple-input"

<h1>Bind Multiple <code>input</code>Example</h1>

<p>
    <label>
        Select one or more cars: 
        <select @onchange="SelectedCarsChanged" multiple>
            <option value="audi">Audi</option>
            <option value="jeep">Jeep</option>
            <option value="opel">Opel</option>
            <option value="saab">Saab</option>
            <option value="volvo">Volvo</option>
        </select>
    </label>
</p>

<p>
    Selected Cars: @string.Join(", ", SelectedCars)
</p>

<p>
    <label>
        Select one or more cities: 
        <select @bind="SelectedCities" multiple>
            <option value="bal">Baltimore</option>
            <option value="la">Los Angeles</option>
            <option value="pdx">Portland</option>
            <option value="sf">San Francisco</option>
            <option value="sea">Seattle</option>
        </select>
    </label>
</p>

<span>
    Selected Cities: @string.Join(", ", SelectedCities)
</span>

@code {
    public string[] SelectedCars { get; set; } = new string[] { };
    public string[] SelectedCities { get; set; } = new[] { "bal", "sea" };

    private void SelectedCarsChanged(ChangeEventArgs e)
    {
        if (e.Value is not null)
        {
            SelectedCars = (string[])e.Value;
        }
    }
}

Per informazioni sulla modalità di gestione delle stringhe vuote e null dei valori nel data binding, vedere la sezione Binding <select> element options to C# object values (Opzioni degli elementi binding ai valori degli oggetti null C#).

Opzioni degli elementi di <select> associazione ai valori degli oggetti null C#

Non esiste un modo ragionevole per rappresentare un <select> valore di opzione dell'elemento come valore dell'oggetto null C#, perché:

• Gli attributi HTML non possono avere null valori. L'equivalente più vicino a null in HTML è l'assenza dell'attributo HTML value dall'elemento <option> .
• Quando si seleziona un oggetto <option> senza value attributo, il browser considera il valore come contenuto di testo dell'elemento <option>.

Il Blazor framework non tenta di eliminare il comportamento predefinito perché comporta:

• Creazione di una catena di soluzioni alternative speciali nel framework.
• Modifiche di rilievo al comportamento corrente del framework.

L'equivalente più plausibile null in HTML è una stringa valuevuota. Il Blazor framework gestisce null le conversioni di stringhe vuote per l'associazione bidirezionale al valore di un <select>oggetto .

Valori non analizzabili

Quando un utente fornisce un valore non verificabile a un elemento associato a dati, il valore non verificabile viene ripristinato automaticamente al valore precedente quando viene attivato l'evento bind.

Si consideri il componente seguente, in cui un <input> elemento è associato a un int tipo con un valore iniziale di 123.

UnparsableValues.razor:

@page "/unparsable-values"

<PageTitle>Unparsable Values</PageTitle>

<h1>Unparsable Values Example</h1>

<p>
    <label>
        inputValue: 
        <input @bind="inputValue" />
    </label>
    
</p>

<p>
    <code>inputValue</code>: @inputValue
</p>

@code {
    private int inputValue = 123;
}

L'associazione si applica all'evento dell'elemento onchange . Se l'utente aggiorna il valore della voce della casella di testo in 123.45 e modifica lo stato attivo, il valore dell'elemento viene ripristinato 123 quando onchange viene attivato. Quando il valore 123.45 viene rifiutato a favore del valore originale di 123, l'utente riconosce che il valore non è stato accettato.

Per l'evento oninput (@bind:event="oninput"), si verifica una riversione del valore dopo qualsiasi sequenza di tasti che introduce un valore non verificabile. Quando l'evento oninput è destinato a un tipo associato a , intun utente non può digitare un carattere punto (.). Un carattere punto (.) viene rimosso immediatamente, quindi l'utente riceve un feedback immediato che è consentito solo per numeri interi. Esistono scenari in cui il ripristino del valore dell'evento oninput non è ideale, ad esempio quando l'utente deve essere autorizzato a cancellare un valore non verificabile <input> . Le alternative includono:

• Non usare l'evento oninput . Usa l'evento predefinito onchange , in cui un valore non valido non viene ripristinato fino a quando l'elemento non perde lo stato attivo.
• Eseguire il binding a un tipo nullable, ad esempio int? o string e usare/@bind:get@bind:set modificatori (descritti in precedenza in questo articolo) oppure eseguire l'associazione a una proprietà con logica personalizzata get e set della funzione di accesso per gestire voci non valide.
• Usare un componente di input, ad esempio InputNumber<TValue> o InputDate<TValue>, con la convalida del modulo. I componenti di input insieme ai componenti di convalida dei moduli forniscono il supporto predefinito per gestire gli input non validi:
  • Consentire all'utente di fornire input non valido e ricevere errori di convalida nell'oggetto associato EditContext.
  • Visualizzare gli errori di convalida nell'interfaccia utente senza interferire con l'utente immettendo dati webform aggiuntivi.

Stringhe di formato

Il data binding funziona con una singola DateTime stringa di formato usando @bind:format="{FORMAT STRING}", dove il {FORMAT STRING} segnaposto è la stringa di formato. Altre espressioni di formato, ad esempio i formati di valuta o numero, non sono attualmente disponibili, ma potrebbero essere aggiunte in una versione futura.

DateBinding.razor:

@page "/date-binding"

<PageTitle>Date Binding</PageTitle>

<h1>Date Binding Example</h1>

<p>
    <label>
        <code>yyyy-MM-dd</code> format:
        <input @bind="startDate" @bind:format="yyyy-MM-dd" />
    </label>
</p>

<p>
    <code>startDate</code>: @startDate
</p>

@code {
    private DateTime startDate = new(2020, 1, 1);
}

Nel codice precedente il <input> tipo di campo dell'elemento (type attributo) viene impostato per impostazione predefinita su text.

Nullable System.DateTime e System.DateTimeOffset sono supportati:

private DateTime? date;
private DateTimeOffset? dateOffset;

Non è consigliabile specificare un formato per il date tipo di campo perché Blazor include il supporto predefinito per formattare le date. Nonostante la raccomandazione, usare il formato della data per il yyyy-MM-dd corretto funzionamento dell'associazione se viene fornito un formato con il date tipo di campo:

<input type="date" @bind="startDate" @bind:format="yyyy-MM-dd">

Associazione con parametri del componente

Uno scenario comune è l'associazione di una proprietà di un componente figlio a una proprietà nel relativo componente padre. Questo scenario è denominato binding concatenato perché si verificano più livelli di associazione contemporaneamente.

Non è possibile implementare associazioni concatenati con @bind sintassi in un componente figlio. Un gestore eventi e un valore devono essere specificati separatamente per supportare l'aggiornamento della proprietà nell'elemento padre dal componente figlio. Il componente padre usa ancora la @bind sintassi per configurare il data binding con il componente figlio.

Il componente seguente ChildBind ha un Year parametro componente e un oggetto EventCallback<TValue>. Per convenzione, per EventCallback<TValue> il parametro deve essere denominato come nome del parametro del componente con un suffisso "Changed". La sintassi di denominazione è {PARAMETER NAME}Changed, dove il {PARAMETER NAME} segnaposto è il nome del parametro. Nell'esempio seguente l'oggetto EventCallback<TValue> è denominato YearChanged.

EventCallback.InvokeAsync richiama il delegato associato all'associazione con l'argomento specificato e invia una notifica di evento per la proprietà modificata.

ChildBind.razor:

<div class="card bg-light mt-3" style="width:18rem ">
    <div class="card-body">
        <h3 class="card-title">ChildBind Component</h3>
        <p class="card-text">
            Child <code>Year</code>: @Year
        </p>
        <button @onclick="UpdateYearFromChild">Update Year from Child</button>
    </div>
</div>

@code {
    [Parameter]
    public int Year { get; set; }

    [Parameter]
    public EventCallback<int> YearChanged { get; set; }

    private async Task UpdateYearFromChild() => 
        await YearChanged.InvokeAsync(Random.Shared.Next(1950, 2021));
}

Per altre informazioni sugli eventi e EventCallback<TValue>, vedere la sezione EventCallback dell'articolo sulla gestione degli eventi di ASP.NET CoreBlazor.

Nel componente seguente Parent1 il year campo è associato al Year parametro del componente figlio. Il Year parametro è associabile perché ha un evento complementare YearChanged che corrisponde al tipo del Year parametro.

Parent1.razor:

@page "/parent-1"

<PageTitle>Parent 1</PageTitle>

<h1>Parent Example 1</h1>

<p>Parent <code>year</code>: @year</p>

<button @onclick="UpdateYear">Update Parent <code>year</code></button>

<ChildBind @bind-Year="year" />

@code {
    private int year = 1979;

    private void UpdateYear() => year = Random.Shared.Next(1950, 2021);
}

L'associazione di parametri del componente può anche attivare @bind:after eventi. Nell'esempio seguente il YearUpdated metodo viene eseguito in modo asincrono dopo l'associazione del parametro del Year componente.

<ChildBind @bind-Year="year" @bind-Year:after="YearUpdated" />

@code {
    ...

    private async Task YearUpdated()
    {
        ... = await ...;
    }
}

Per convenzione, una proprietà può essere associata a un gestore eventi corrispondente includendo un @bind-{PROPERTY}:event attributo assegnato al gestore, dove il {PROPERTY} segnaposto è la proprietà . <ChildBind @bind-Year="year" /> equivale alla scrittura:

<ChildBind @bind-Year="year" @bind-Year:event="YearChanged" />

In un esempio più sofisticato e reale, il componente seguente PasswordEntry :

• Imposta il valore di un <input> elemento su un password campo.
• Espone le modifiche di una Password proprietà a un componente padre con un oggetto EventCallback che passa il valore corrente del campo del password figlio come argomento.
• Usa l'evento onclick per attivare il ToggleShowPassword metodo . Per altre informazioni, vedere ASP.NET Gestione degli eventi CoreBlazor.

PasswordEntry.razor:

<div class="card bg-light mt-3" style="width:22rem ">
    <div class="card-body">
        <h3 class="card-title">Password Component</h3>
        <p class="card-text">
            <label>
                Password:
                <input @oninput="OnPasswordChanged"
                       required
                       type="@(showPassword ? "text" : "password")"
                       value="@password" />
            </label>
        </p>
        <button class="btn btn-primary" @onclick="ToggleShowPassword">
            Show password
        </button>
    </div>
</div>

@code {
    private bool showPassword;
    private string? password;

    [Parameter]
    public string? Password { get; set; }

    [Parameter]
    public EventCallback<string> PasswordChanged { get; set; }

    private async Task OnPasswordChanged(ChangeEventArgs e)
    {
        password = e?.Value?.ToString();

        await PasswordChanged.InvokeAsync(password);
    }

    private void ToggleShowPassword() => showPassword = !showPassword;
}

Il PasswordEntry componente viene usato in un altro componente, ad esempio l'esempio di componente seguente PasswordBinding .

PasswordBinding.razor:

@page "/password-binding"

<PageTitle>Password Binding</PageTitle>

<h1>Password Binding Example</h1>

<PasswordEntry @bind-Password="password" />

<p>
    <code>password</code>: @password
</p>

@code {
    private string password = "Not set";
}

Quando viene inizialmente eseguito il rendering del PasswordBinding componente, il password valore di Not set viene visualizzato nell'interfaccia utente. Dopo il rendering iniziale, il valore di password riflette le modifiche apportate al valore del Password parametro del componente nel PasswordEntry componente.

Nota

L'esempio precedente associa la password unidirezionale dal componente figlio PasswordEntry al componente padre PasswordBinding . L'associazione bidirezionale non è un requisito in questo scenario se l'obiettivo è che l'app abbia un componente di immissione della password condivisa per il riutilizzo nell'app che passa semplicemente la password all'elemento padre. Per un approccio che consente l'associazione bidirezionale senza scrivere direttamente nel parametro del componente figlio, vedere l'esempio NestedChild di componente nella sezione Bind in più di due componenti di questo articolo.

Eseguire controlli o errori di intercettazione nel gestore. Il componente modificato PasswordEntry seguente fornisce un feedback immediato all'utente se viene usato uno spazio nel valore della password.

PasswordEntry.razor:

<div class="card bg-light mt-3" style="width:22rem ">
    <div class="card-body">
        <h3 class="card-title">Password Component</h3>
        <p class="card-text">
            <label>
                Password:
                <input @oninput="OnPasswordChanged"
                       required
                       type="@(showPassword ? "text" : "password")"
                       value="@password" />
            </label>
            <span class="text-danger">@validationMessage</span>
        </p>
        <button class="btn btn-primary" @onclick="ToggleShowPassword">
            Show password
        </button>
    </div>
</div>

@code {
    private bool showPassword;
    private string? password;
    private string? validationMessage;

    [Parameter]
    public string? Password { get; set; }

    [Parameter]
    public EventCallback<string> PasswordChanged { get; set; }

    private Task OnPasswordChanged(ChangeEventArgs e)
    {
        password = e?.Value?.ToString();

        if (password != null && password.Contains(' '))
        {
            validationMessage = "Spaces not allowed!";

            return Task.CompletedTask;
        }
        else
        {
            validationMessage = string.Empty;

            return PasswordChanged.InvokeAsync(password);
        }
    }

    private void ToggleShowPassword() => showPassword = !showPassword;
}

Eseguire l'associazione tra più di due componenti

È possibile associare i parametri tramite un numero qualsiasi di componenti annidati, ma è necessario rispettare il flusso unidirezionale dei dati:

• Le notifiche di modifica passano all'alto nella gerarchia.
• I nuovi valori dei parametri passano verso il basso nella gerarchia.

Un approccio comune e consigliato consiste nell'archiviare solo i dati sottostanti nel componente padre per evitare confusione sullo stato da aggiornare, come illustrato nell'esempio seguente.

Parent2.razor:

@page "/parent-2"

<PageTitle>Parent 2</PageTitle>

<h1>Parent Example 2</h1>

<p>Parent Message: <b>@parentMessage</b></p>

<p>
    <button @onclick="ChangeValue">Change from Parent</button>
</p>

<NestedChild @bind-ChildMessage="parentMessage" />

@code {
    private string parentMessage = "Initial value set in Parent";

    private void ChangeValue() => parentMessage = $"Set in Parent {DateTime.Now}";
}

Nel componente seguente NestedChild il NestedGrandchild componente :

• Assegna il valore di ChildMessage a GrandchildMessage con @bind:get la sintassi.
• Aggiorna GrandchildMessage quando ChildMessageChanged viene eseguito con @bind:set la sintassi.

NestedChild.razor:

<div class="border rounded m-1 p-1">
    <h2>Child Component</h2>

    <p>Child Message: <b>@ChildMessage</b></p>

    <p>
        <button @onclick="ChangeValue">Change from Child</button>
    </p>

    <NestedGrandchild @bind-GrandchildMessage:get="ChildMessage" 
        @bind-GrandchildMessage:set="ChildMessageChanged" />
</div>

@code {
    [Parameter]
    public string? ChildMessage { get; set; }

    [Parameter]
    public EventCallback<string?> ChildMessageChanged { get; set; }

    private async Task ChangeValue() => 
        await ChildMessageChanged.InvokeAsync($"Set in Child {DateTime.Now}");
}

NestedGrandchild.razor:

<div class="border rounded m-1 p-1">
    <h3>Grandchild Component</h3>

    <p>Grandchild Message: <b>@GrandchildMessage</b></p>

    <p>
        <button @onclick="ChangeValue">Change from Grandchild</button>
    </p>
</div>

@code {
    [Parameter]
    public string? GrandchildMessage { get; set; }

    [Parameter]
    public EventCallback<string> GrandchildMessageChanged { get; set; }

    private async Task ChangeValue() => 
        await GrandchildMessageChanged.InvokeAsync(
            $"Set in Grandchild {DateTime.Now}");
}

Per un approccio alternativo adatto alla condivisione dei dati in memoria e tra componenti che non sono necessariamente annidati, vedere ASP.NET gestione dello stato CoreBlazor.

Albero delle espressioni di campo o proprietà associato

Per facilitare interazioni più approfondite con un'associazione, Blazor consente di acquisire l'albero delle espressioni di un campo o di una proprietà associata. A tale scopo, definire una proprietà con il nome del campo o della proprietà suffisso con Expression. Per qualsiasi campo o proprietà specificata denominata {FIELD OR PROPERTY NAME}, la proprietà dell'albero delle espressioni corrispondente è denominata {FIELD OR PROPERTY NAME}Expression.

Il componente seguente ChildParameterExpression identifica il modello e il Year nome del campo dell'espressione. Oggetto FieldIdentifier, utilizzato per ottenere il modello e il nome del campo, identifica in modo univoco un singolo campo che può essere modificato. Questo può corrispondere a una proprietà in un oggetto modello o può essere qualsiasi altro valore denominato. L'uso dell'espressione di un parametro è utile quando si creano componenti di convalida personalizzati, che non sono coperti dalla documentazione Microsoft Blazor , ma sono indirizzati da numerose risorse di terze parti.

ChildParameterExpression.razor:

@using System.Linq.Expressions

<ul>
    <li>Year model: @yearField.Model</li>
    <li>Year field name: @yearField.FieldName</li>
</ul>

@code {
    private FieldIdentifier yearField;

    [Parameter]
    public int Year { get; set; }

    [Parameter]
    public EventCallback<int> YearChanged { get; set; }

    [Parameter]
    public Expression<Func<int>> YearExpression { get; set; } = default!;

    protected override void OnInitialized() => 
        yearField = FieldIdentifier.Create(YearExpression);
}

Parent3.razor:

@page "/parent-3"

<PageTitle>Parent 3</PageTitle>

<h1>Parent Example 3</h1>

<p>Parent <code>year</code>: @year</p>

<ChildParameterExpression @bind-Year="year" />

@code {
    private int year = 1979;
}

Risorse aggiuntive

• Rilevamento delle modifiche dei parametri e indicazioni aggiuntive sul rendering dei Razor componenti
• Panoramica dei moduli di Blazor base di ASP.NET
• Associazione ai pulsanti di opzione in un modulo
• Opzioni di associazione InputSelect ai valori dell'oggetto null C#
• ASP.NET gestione degli eventi core Blazor : EventCallback sezione
• Blazorrepository GitHub di esempi () (dotnet/blazor-samplescome scaricare)