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

Articolo
08/11/2011

Quando si utilizza l'estensibilità per personalizzare WPF Designer 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.

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 quest'ultima, infatti, viene visualizzato il valore immesso dall'utente 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 item As ModelItem, _
    ByVal identifier As PropertyIdentifier, _
    ByVal value As Object) As Object

    'If identifier.Name = <Name of the property to change> Then
    '
    '    Custom logic goes here.
    'End If

    'More custom logic for more properties can go here.

    Return MyBase.TranslatePropertyValue(item, identifier, value)
End Function


public override object TranslatePropertyValue(ModelItem item, PropertyIdentifier identifier, object value)
{
    //if (identifier.Name == <Name of the property to change>)
    //{
    //    Custom logic goes here.
    //}

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

    return base.TranslatePropertyValue(item, 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

È inoltre possibile allegare DesignModeValueProvider a un controllo personalizzato fornendo una tabella di attributi. Per ulteriori informazioni, vedere Aggiunta di metadati della fase di progettazione.

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