Explicit Styles with x:Key
An explicit style is declared with an x:Key value and must be attached to a control deliberately, by setting that control's Style property to {StaticResource KeyName} or {DynamicResource KeyName}; controls that don't explicitly reference the key are completely unaffected by it. This gives fine-grained control: a page can have several button styles like PrimaryButtonStyle, DangerButtonStyle, and GhostButtonStyle all coexisting, with each individual Button choosing exactly which one it wants.
Cricket analogy: It is like a specific fielding drill labeled 'Slip Cordon Drill' that only the players a coach explicitly assigns to it will run, while every other player on the ground continues their own separate drill unaffected.
<!-- Explicit style: must be referenced by key -->
<Style x:Key="DangerButtonStyle" TargetType="Button">
<Setter Property="Background" Value="#DC2626" />
<Setter Property="Foreground" Value="White" />
</Style>
<Button Content="Delete Account" Style="{StaticResource DangerButtonStyle}" />
<Button Content="Save" /> <!-- unaffected, uses default look -->
<!-- Implicit style: applies automatically to every Button in scope -->
<Style TargetType="Button">
<Setter Property="FontFamily" Value="Segoe UI" />
<Setter Property="Cursor" Value="Hand" />
</Style>Implicit Styles by TargetType
Omitting x:Key from a Style causes WPF to key it implicitly by its TargetType, which means every control of that exact type within the style's resource scope receives the style automatically, with no Style property assignment needed on individual controls. This is how a single Style targeting TextBlock, declared once in Application.Resources, can uniformly restyle every TextBlock across an entire application without touching a single existing page's markup.
Cricket analogy: It is like a stadium's ground rule that automatically applies to every fielder on the boundary rope, such as 'no direct hit needed for a run-out from this zone,' without any fielder needing to be told individually.
Scoping Implicit Styles
Because implicit styles are keyed by Type, the same shadowing rules that apply to any resource lookup apply here too: a TextBlock inside a Page whose Page.Resources declares its own implicit TextBlock style will use that page-level style instead of an Application-level implicit TextBlock style, because the nearer scope is checked first. This lets a specific page opt out of the app-wide look for one control type simply by redeclaring an implicit style locally, without needing BasedOn or any special override syntax.
Cricket analogy: It is like how a specific venue's local ground rules (say, a shorter boundary rule at a particular stadium) override the general ICC playing conditions for matches held only at that venue, without changing the rules everywhere else.
Implicit styles are the standard technique for global, low-effort theming: define implicit TargetType styles for Button, TextBlock, and TextBox once at the Application level, and every existing and future instance of those controls picks up the look automatically, with zero markup changes on individual pages.
Choosing Between Them
Explicit styles are the right choice when a control type needs several distinct visual variants coexisting on the same page, such as PrimaryButtonStyle versus DangerButtonStyle, since implicit styling can only apply one default style per TargetType per scope. Implicit styles are better for establishing a consistent baseline look across an entire app, and the two techniques combine naturally: declare an implicit base style for TargetType Button, then define explicit variant styles that use BasedOn against that implicit style to inherit the baseline while adding their own distinguishing setters.
Cricket analogy: It is like a team having a default fielding stance every player follows implicitly, while also having explicitly named special formations like 'the umbrella field' that only get called out for a specific batter in a specific situation.
A common bug is declaring an implicit style for TargetType="TextBlock" intending to restyle body copy, only to discover it also silently restyles TextBlocks used inside other controls' templates (like a ComboBox's selected-item display) anywhere in scope, producing unexpected visual side effects that are easy to miss during review.
- Explicit styles require an x:Key and must be attached via the Style property on each control.
- Implicit styles omit x:Key and are keyed by TargetType, applying automatically to every matching control in scope.
- Implicit style lookup follows the same scope-shadowing rules as any resource: nearer scopes win.
- Explicit styles support multiple coexisting variants for the same control type.
- Implicit styles establish a consistent baseline look with zero per-control markup.
- BasedOn lets an explicit variant style build on top of an implicit base style.
- Implicit styles can unintentionally affect controls nested inside other templates sharing that TargetType.
Practice what you learned
1. What determines whether a Style is implicit or explicit?
2. How many implicit styles for the same TargetType can be simultaneously active within a single resource scope?
3. How does a Page override an Application-level implicit style for the same TargetType?
4. What is a good strategy for combining consistent baseline styling with distinct visual variants for the same control type?
5. What is a common pitfall of declaring a broad implicit style for a common type like TextBlock?
Was this page helpful?
You May Also Like
Styles and Setters
Learn how the Style element and Setter objects apply consistent property values across controls, including BasedOn inheritance and triggers.
Resource Dictionaries in XAML
Learn how ResourceDictionary stores reusable brushes, styles, and templates in XAML, and how StaticResource and DynamicResource look them up.
Theming with XAML
Learn how to structure XAML resource dictionaries to support light/dark theming, runtime theme switching, and consistent theme resource naming.
Related Reading
Related Study Notes in Microsoft Technologies
Browse all study notesWindows 10 / UWP Development Study Notes
.NET · 30 topics
Microsoft TechnologiesWindows Batch Scripting Study Notes
Batch · 30 topics
Microsoft TechnologiesMFC (Microsoft Foundation Classes) Study Notes
C++ · 30 topics
Microsoft TechnologiesSilverlight Study Notes
.NET · 30 topics
Microsoft TechnologiesWPF (Windows Presentation Foundation) Study Notes
.NET · 30 topics
Microsoft TechnologiesMVVM Design Pattern Study Notes
.NET · 30 topics