Style.TargetType Proprietà

Definizione

Spazio dei nomi:

Windows.UI.Xaml

Ottiene o imposta il tipo per il quale è previsto lo stile. TargetType può essere usato per dichiarare una risorsa di stile implicita se non è specificata alcuna chiave di risorsa.

public:
 property TypeName TargetType { TypeName get(); void set(TypeName value); };

TypeName TargetType();

void TargetType(TypeName value);

public System.Type TargetType { get; set; }

var typeName = style.targetType;
style.targetType = typeName;

Public Property TargetType As Type

<Style TargetType="typeName"/>

Valore della proprietà

TypeName Type

Tipo di oggetto a cui viene applicato lo stile. Questo valore viene in genere impostato in XAML, non nel codice. Vedere la sezione Osservazioni.

Esempio

In questo esempio vengono creati due stili: uno per TextBlock e uno per un controllo TextBox. Ogni stile viene applicato a due istanze di un controllo per creare un aspetto uniforme per ogni TextBlock e TextBox. Nell'esempio viene impostata la proprietà FrameworkElement.Style di ogni controllo facendo riferimento allo stile come estensione di markup {StaticResource}.

<StackPanel x:Name="rootPanel">
  <StackPanel.Resources>
    <!--Create a Style for a TextBlock to specify that the
              Foreground equals Navy, FontSize equals 14, and
              VerticalAlignment equals Botton.-->
    <Style TargetType="TextBlock" x:Key="TextBlockStyle">
      <Setter Property="Foreground" Value="Navy"/>
      <Setter Property="FontSize" Value="14"/>
      <Setter Property="VerticalAlignment" Value="Bottom"/>
    </Style>

    <!--Create a Style for a TextBox that specifies that
              the Width is 200, Height is 30, Margin is 4,
              Background is LightBlue, and FontSize is 14.-->
    <Style TargetType="TextBox" x:Key="TextBoxStyle">
      <Setter Property="Width" Value="200"/>
      <Setter Property="Height" Value="30"/>
      <Setter Property="Margin" Value="4"/>
      <Setter Property="FontSize" Value="14"/>
      <Setter Property="Background">
        <Setter.Value>
          <LinearGradientBrush StartPoint="0,0.5" EndPoint="1,0.5">
            <GradientStop Color="White" Offset="0.0"/>
            <GradientStop Color="LightBlue" Offset="0.5"/>
            <GradientStop Color="Navy" Offset="1"/>
          </LinearGradientBrush>
        </Setter.Value>
      </Setter>
    </Style>
  </StackPanel.Resources>

  <!--Apply the TextBlockStyle and TextBoxStyle to each 
      TextBlock and TextBox, respectively.-->
  <StackPanel Orientation="Horizontal">
    <TextBlock Text="First Name:" Style="{StaticResource TextBlockStyle}"/>
    <TextBox Style="{StaticResource TextBoxStyle}"/>
  </StackPanel>
  <StackPanel Orientation="Horizontal">
    <TextBlock Text="Last Name:" Style="{StaticResource TextBlockStyle}"/>
    <TextBox Style="{StaticResource TextBoxStyle}"
             Margin="6,4,4,4"/>
  </StackPanel>
  <StackPanel x:Name="emailAddressPanel" Orientation="Horizontal"/>
</StackPanel>

Commenti

Per tutti i casi in cui si usa o dichiara uno stile, è necessario un valore TargetType. Non è previsto alcun valore predefinito. Anche uno stile usato come valore inline della proprietà FrameworkElement.Style richiede un valore TargetType esplicito.

Il modo tipico per specificare un valore TargetType è tramite un attributo XAML nell'elemento Style . Se impostato in XAML, il significato di TargetType e i valori forniti vengono impostati su alcuni aspetti del modo in cui i tipi vengono rappresentati in XAML.

Per XAML, tutti i prefissi necessari per fare riferimento a un tipo tramite un utilizzo degli elementi XAML devono essere inclusi nel valore dell'attributo TargetType. Ad esempio, se uno stile è destinato a un tipo personalizzato, definito in uno spazio dei nomi del codice mappato al prefisso "local:", il valore dell'attributo TargetType per tale tipo deve includere lo stesso prefisso precedente al nome del tipo. Questo comportamento è abilitato dal comportamento di conversione di tipo stringa predefinito nel parser XAML Windows Runtime.

Quando si definiscono gli stili per i tipi personalizzati, dopo aver incluso un prefisso di mapping per targetType, non si include alcun prefisso nel valore Proprietà di qualsiasi setter all'interno di tale stile.

Il valore specificato per TargetType modifica il comportamento di ricerca per qualsiasi valore Setter.Property specificato nello stile. In particolare, le proprietà di dipendenza a cui si fa riferimento per nome per un valore di attributo XAML Setter.Property devono esistere nel tipo TargetType o in qualsiasi classe predecessore. Ad esempio, se targetType specificato è Button e uno dei valori dell'attributo XAML Setter.Property in Style è "Background", che risolve la proprietà Control.Background (Control è tre livelli sopra Button nell'ereditarietà della classe e Button eredita tutte le proprietà di Control). È tipico specificare il valore TargetType come gli stessi nomi di elementi dell'interfaccia utente usati nel markup tipico dell'interfaccia utente, non si potrebbe in genere assegnare un nome a una classe predecessore (anche se è tecnicamente consentita).

Se Style include un Setter che dichiara un modello di controllo (un valore per la proprietà Template ), il valore TargetType dello stile padre deve corrispondere al valore TargetType dell'elemento ControlTemplate contenuto.

Stili impliciti

Gli stili sono quasi sempre dichiarati come risorse XAML condivise e applicate a ogni elemento dell'interfaccia utente nell'app che fa riferimento a tale stile. Per essere dichiarati come risorsa, tutti gli elementi XAML inclusi gli elementi Style devono avere una chiave all'interno della raccolta di risorse che distingue ogni risorsa per la ricerca in fase di esecuzione. L'elemento Style (e anche i vari elementi del modello, ad esempio ControlTemplate) supportano una funzionalità denominata stili impliciti. Per uno stile implicito, il valore specificato per il valore TargetType funge anche da chiave per tale stile nell'ambito della raccolta risorse e non è necessario specificare il valore dell'attributo x:Key . La maggior parte degli altri elementi dichiarati all'interno di una raccolta di risorse richiede un valore esplicito dell'attributo x:Key e si otterrà errori di progettazione o parser che applicano questa operazione.

Uno stile dichiarato usando lo stile implicito viene quindi usato come valore style per qualsiasi istanza dell'elemento dell'interfaccia utente che corrisponde in modo specifico al tipo targetType dello stile implicito. I controlli non devono fare riferimento a uno stile con un valore di attributo Style e un riferimento all'estensione di markup {StaticResource} a una chiave per ottenere questo comportamento, è un comportamento implicito se questi controlli corrispondono al tipo di stile implicito esistente.

Gli stili impliciti non si applicano agli elementi che sono sottotipi del tipo a cui fa riferimento il valore TargetType. Ad esempio, se si dichiara uno stile implicito per i controlli ToggleButton e l'app dispone di controlli CheckBox (CheckBox deriva da ToggleButton), lo stile si applica in modo specifico ai controlli ToggleButton, ma non ai controlli CheckBox.

Il Windows Runtime definisce gli stili impliciti predefiniti per ogni elemento pratico dell'interfaccia utente che fa parte dell'API Windows Runtime. A tale scopo, questi stili definiscono gli oggetti visivi per gli elementi (in particolare i modelli) e un elemento senza oggetti visivi non verrà nemmeno visualizzato nell'interfaccia utente o partecipa al layout. Tutti questi stili impliciti possono essere visualizzati nel file XAML di progettazione-helper denominato generic.xaml. Gli strumenti usati per modificare XAML possono copiare parti discrete di questo file nel codice XAML dell'app come punto iniziale quando si modificano copie di stili come abilitati dagli strumenti. All'interno degli stili impliciti predefiniti, sono disponibili molti livelli di riferimento alle risorse, nonché il supporto del tema usando l'estensione di markup {ThemeResource} e pennelli specifici del tema o altre risorse. È possibile eseguire l'override di qualsiasi stile implicito altrimenti proveniente dalla Windows Runtime definisce gli stili impliciti predefiniti. Per altre informazioni, vedere Avvio rapido: Controlli di stile e Guida introduttiva: Modelli di controllo.

Uso di TargetType nel codice

L'impostazione di TargetType nel codice non è comune. Il sistema di stile XAML è destinato a essere usato caricando XAML come risorsa e avendo tutti gli aspetti di uno stile pronti in anticipo. Esistono alcuni scenari in cui non si conoscerebbero informazioni su come assegnare uno stile a un controllo o applicare uno stile fino a quando non è necessario impostare targetType in uno stile creato o a cui si fa riferimento nel codice.

Il recupero di un oggetto TargetType nel codice è anche insolito, ma potrebbero verificarsi alcuni altri scenari in cui si potrebbe eseguire questa operazione. Ad esempio, potrebbe essere presente un set di risorse di stile denominate già definite nel codice XAML. Tuttavia, potrebbe essere necessario verificare che uno stile che si sta per applicare a un controllo abbia un valore TargetType che funziona per il tipo del controllo a cui si sta applicando. È quindi possibile che il codice sia simile al seguente:

private bool VerifyStyle(FrameworkElement scope, String styleKey, Control applyTo)
{
    Style styleToCheck = scope.Resources[styleKey] as Style;
    if (styleToCheck != null)
    {
        if (styleToCheck.TargetType == applyTo.GetType())
        {
            // applyTo.Style = styleToCheck;
            return true;
        }
    }
    return false;
}

Suggerimento

Se si esegue la programmazione usando un linguaggio Microsoft .NET (C# o Microsoft Visual Basic), i progetti di tipo TypeName come System.Type. Quando si usa C#C#, in genere si usa l'operatore typeof per ottenere riferimenti al tipo System.Type di un tipo basato su un nome di tipo come stringa. In Microsoft Visual Basic usare GetType.

Note sulla migrazione

• Se è stato usato XAML per Windows Presentation Foundation (WPF), potrebbe essere stato usato un'estensione di markup x:Type per compilare i valori XAML che accettano un system.type. Il parser XAML Windows Runtime non supporta x:Type. È invece consigliabile fare riferimento al tipo in base al nome senza usare alcuna estensione di markup e qualsiasi conversione del tipo xaml-to-backing necessaria è già gestita dal comportamento di conversione predefinito nel parser XAML.