Procedura: modificare il comportamento di una proprietà in fase di progettazione

Articolo
09/12/2008

Aggiornamento: novembre 2007

Quando si utilizza l'estensibilità per personalizzare Progettazione Windows Presentation Foundation (WPF) per Visual Studio, spesso si creano controlli personalizzati. Talvolta è necessario fare in modo che una proprietà di un controllo si comporti in fase di progettazione diversamente da quando è in fase di esecuzione, pur lasciando all'utente la possibilità di impostare il valore della proprietà secondo la normale procedura. Ad esempio, si desidera dare all'utente la possibilità di impostare la proprietà di visibilità di un controllo su false, ma il controllo deve rimanere visibile in fase di progettazione.

In questo argomento vengono descritte le procedure per modificare il comportamento in fase di progettazione delle proprietà di controlli personalizzati. Per un esempio più dettagliato che illustra le procedure dettagliate, vedere Procedura dettagliata: modifica del comportamento di una proprietà in fase di progettazione.

Nota importante:
Quando si utilizza questa tecnica, il comportamento di una proprietà nella finestra di progettazione non corrisponde al valore della proprietà in visualizzazione XAML. In visualizzazione XAML viene visualizzato il valore che l'utente ha immesso in fase di progettazione. Il valore in visualizzazione XAML rappresenta il comportamento che la proprietà esibirà in fase di esecuzione.

Per determinare se un controllo è in fase di progettazione e impostarne le proprietà di conseguenza, vedere Procedura: determinare se un controllo personalizzato è in fase di progettazione o in fase di esecuzione.

Creazione di un DesignModeValueProvider personalizzato

In questa procedura viene creata una classe DesignModeValueProvider personalizzata. Nel metodo TranslatePropertyValue aggiungere la logica personalizzata per il nuovo comportamento delle proprietà che si desidera modificare. Queste modifiche hanno effetto solo nella finestra di progettazione. In fase di esecuzione, le proprietà si comportano come quando sono impostate dall'utente.

Per creare un DesignModeValueProvider personalizzato

Aggiungere nel progetto un riferimento all'assembly seguente.
- Microsoft.Windows.Design.Extensibility

Aggiungere una nuova classe al progetto di controllo personalizzato e modificarla per fare in modo che erediti da DesignModeValueProvider. Il risultato dovrebbe essere analogo al seguente:

Public Class YourCustomDesignModeValueProvider
    Inherits Microsoft.Windows.Design.Model.DesignModeValueProvider

End Class

class YourCustomDesignModeValueProvider : Microsoft.Windows.Design.Model.DesignModeValueProvider
{
}

Aggiungere un costruttore alla classe. Nel costruttore si identificano le proprietà che si desidera acquisire.

Public Sub New()

    'Properties.Add(<The Property To Change Goes Here>)
    'More properties can go here.

End Sub

public YourCustomDesignModeValueProvider()
{
    //Properties.Add(<The Property To Change Goes Here>);
    //More properties can go here.
}

Eseguire l'override del metodo TranslatePropertyValue nella classe. In questo punto si specifica il nuovo comportamento delle proprietà in fase di progettazione.

Public Overrides Function TranslatePropertyValue(ByVal identifier As Microsoft.Windows.Design.Model.PropertyIdentifier, ByVal value As Object) As Object

    'If identifier.DependencyProperty Is <Property To Change> Then
    '
    '    Custom logic goes here.
    'End If

    'More custom logic for more properties can go here.

    Return MyBase.TranslatePropertyValue(identifier, value)
End Function

public override object TranslatePropertyValue(Microsoft.Windows.Design.Model.PropertyIdentifier identifier, object value)
{
    //if (identifier.DependencyProperty == <The Property To Change>)
    //{
    //    Custom logic goes here.
    //}

    //More custom logic for more properties can go here.

    return base.TranslatePropertyValue(identifier, value);
}

Nota:
In questa procedura, viene creato un DesignModeValueProvider che gestisce due differenti proprietà. È anche possibile creare più oggetti DesignModeValueProvider per gestire proprietà differenti.

Aggiunta di DesignModeValueProvider al controllo personalizzato

In questa procedura, DesignModeValueProvider viene allegato al controllo personalizzato utilizzando l'attributo FeatureAttribute.

Per allegare DesignModeValueProvider al controllo personalizzato

Individuare la dichiarazione della classe per il controllo personalizzato. Il risultato dovrebbe essere analogo al seguente:
```
Public Class YourCustomControl
```
```
class YourCustomControl
```

Aggiungere un attributo FeatureAttribute alla dichiarazione della classe e specificare DesignModeValueProvider che è stato creato nella procedura precedente.

<Microsoft.Windows.Design.Features.Feature(GetType(YourCustomDesignModeValueProvider))> _
Public Class YourCustomControl

[Microsoft.Windows.Design.Features.Feature(typeof(YourCustomDesignModeValueProvider))]
class YourCustomControl

Nota:
È anche possibile allegare un DesignModeValueProvider a un controllo personalizzato utilizzando l'archivio di metadati. Per ulteriori informazioni, vedere Archivio di metadati e Procedura: utilizzare l'archivio di metadati.

Vedere anche

Altre risorse

Confronto dei comportamenti tra fase di progettazione e fase di esecuzione

Informazioni sull'estensibilità Progettazione WPF

Estensibilità di Progettazione WPF

Condividi tramite