Style.TargetType Proprietà

Riferimento

Definizione

Spazio dei nomi:: Microsoft.UI.Xaml

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Modifica

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 all'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

Un TargetType valore è obbligatorio per tutti i casi in cui usi o dichiari uno stile. Non è previsto alcun valore predefinito. Anche un Style oggetto utilizzato come valore inline della proprietà FrameworkElement.Style richiede un valore esplicito TargetType .

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

Per XAML, tutti i prefissi che sarebbero necessari per fare riferimento a un tipo tramite l'utilizzo di un elemento 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 di codice mappato al prefisso "local:", il TargetType valore dell'attributo per lo stile di tale tipo deve includere lo stesso prefisso che precede il 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 un TargetType oggetto non si include alcun prefisso nel valore Property 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 Setter.Property valore di attributo XAML dovrebbero esistere nel TargetType tipo o in qualsiasi classe predecessore. Ad esempio, se l'elemento TargetType specificato è Button e uno dei valori dell'attributo Setter.Property XAML in Style è "Background", che viene risolto nella proprietà Control.Background (Control è di tre livelli sopra Button nell'ereditarietà della classe e Button eredita tutte le proprietà di Control). È tipico specificare il TargetType valore come gli stessi nomi degli elementi dell'interfaccia utente usati nel markup tipico dell'interfaccia utente, in genere non si denomina una classe predecessore (anche se tecnicamente consentito).

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

Stili impliciti

Gli stili vengono 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 dichiarato 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 TargetType valore funge anche da chiave per tale stile nell'ambito della raccolta di 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 invece un valore esplicito dell'attributo x:Key e si otterrà errori di progettazione o parser che applicano questa impostazione.

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 dello TargetType 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 uno stile implicito esistente.

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

Il Windows Runtime definisce gli stili impliciti predefiniti per ogni elemento pratico dell'interfaccia utente che fa parte dell'API Windows Runtime. Questa operazione deve essere eseguita perché 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 parteciperà al layout. Tutti questi stili impliciti possono essere visualizzati nel file XAML dell'helper di progettazione denominato generic.xaml. Gli strumenti usati per modificare XAML possono copiare parti discrete di questo file nel codice XAML dell'app come punto di partenza quando modifichi copie di stili come abilitato dagli strumenti. All'interno degli stili impliciti predefiniti sono disponibili molti livelli di riferimento alle risorse, oltre al supporto dei temi usando l'estensione di markup {ThemeResource} e i pennelli specifici del tema o altre risorse. È possibile eseguire l'override di qualsiasi stile implicito che altrimenti proviene dalla Windows Runtime definisce gli stili impliciti predefiniti. Per altre info, vedi Stili XAML e modelli di controllo XAML.

Uso di TargetType nel codice

L'impostazione TargetType nel codice non è comune. Il sistema di stile XAML deve essere usato caricando XAML come risorsa e avendo tutti gli aspetti di uno stile pronti in anticipo. Ci dovrebbero essere pochissimi scenari in cui non si conoscono le informazioni su come applicare uno stile a un controllo o applicare uno stile fino al runtime, in cui sarebbe necessario impostare targetType su uno stile creato o a cui si fa riferimento nel codice.

L'acquisizione di un TargetType oggetto nel codice non è comune, ma potrebbero verificarsi altri scenari in cui è possibile eseguire questa operazione. Ad esempio, potrebbe essere presente un set di risorse denominate Style già definite nel codice XAML. Tuttavia, potrebbe essere necessario verificare che uno stile a cui si sta per applicare un controllo abbia un TargetType valore che funziona per il tipo di 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 con C#, i progetti di tipo TypeName come System.Type. Quando si esegue la programmazione con C#, in genere si usa l'operatore typeof per ottenere riferimenti all'oggetto System.Type di un tipo in base a un nome di tipo come stringa.

Note sulla migrazione

Se hai usato XAML per Windows Presentation Foundation (WPF), potresti aver usato un'estensione di markup x:Type per compilare tutti i valori XAML che accettano System.Type. Il parser XAML Windows Runtime non supporta x:Type. Devi invece fare riferimento al tipo in base al nome senza usare alcuna estensione di markup e qualsiasi conversione del tipo da XAML a supporto necessaria è già gestita dal comportamento di conversione predefinito nel parser XAML.

Si applica a

Condividi tramite