为什么MainWindow的根元素是Window而不是MainWindow？

Question

I notice that the root element in any XAML file (in WPF) seems to be one of:

• Window
• Page
• UserControl
• ResourceDictionary
• Application

I tried to change the root element to local:MainWindow , but then the project cannot compile, saying the base class of a partial class should be the same. Then I guess the root element is the base class of the actual class? What is the reason for it? Since the root element cannot be changed to the actual class, I cannot access the dependency properties written in MainWindow.xaml.cs . How can those DPs be referenced in XAML?

Besides, I also notice that some third-party themes also provide special window classes, and in that case, the root element is often changed. How is this being achieved? Eg GlowWindow from HandyControl

Answer 1

I tried to change the root element to local:MainWindow, and then the project cannot compile, saying the base class of a partial class should be the same. Then I guess the root element is the base class of the actual class?

Yes, this is correct, the root element is the base class that can , but does not necessarily have to be specified in code-behind. The connection between the partial classes (compiled from XAML markup and the code-behind file) is specified using the x:Class attribute in XAML, see Code-Behind and XAML in WPF .

The XAML language includes language-level features that make it possible to associate code files with markup files, from the markup file side. Specifically, the XAML language defines the language features x:Class Directive, x:Subclass Directive, and x:ClassModifier Directive. [...]

The partial class must derive from the type that backs the root element.

---

What is the reason for it?

A code-behind file is not mandatory if there is no custom code, see x:Class .

In existing programming models that use x:Class , x:Class is optional in the sense that it is entirely valid to have a XAML page that has no code-behind. However, that capability interacts with the build actions as implemented by frameworks that use XAML.

Even if there is one, the base class can be omitted , but then again the base class must be determined somehow and that is done through the root element type, see Code-behind, Event Handler, and Partial Class Requirements in WPF .

Note that under the default behavior of the markup compile build actions, you can leave the derivation blank in the partial class definition on the code-behind side. The compiled result will assume the page root's backing type to be the basis for the partial class, even if it not specified.

---

How can those DPs be referenced in xaml?

Simply use a Binding with a RelativeSource that specifies the MainWindow as AncestorType .

{Binding YourDependencyProperty, RelativeSource={RelativeSource AncestorType={x:Type local:MainWindow}}}

If you assign an x:Name to your window, you could alternatively use ElementName in the binding.

<Window ...
        x:Name="MyMainWindow">

{Binding YourDependencyProperty, ElementName=MyMainWindow}

---

Besides, I also notice that some third-party themes also provide special Window classes, and in that case, the root element is often changed. How is this being achieved?

No it is not. For instance, the GlowWindow is exactly defined like your MainWindow with code-behind and x:Class to refer to it and Window as root element. What you see in the link is that a new derivative of the GlowWindow is created, just like you create MainWindow from Window , they just happen to use the same name GlowWindow , unfortunately. Notice the namespaces.

Try it yourself and create a new window by specifying your MainWindow as root element. It is exactly the same scenario.

Answer 2

I will supplement the answer from @thatguy.

In WPF, it is customary to separate the logic part of the control (which is written in Sharpe) from the visual part (which is written in XAML in the theme template).

For your example, creating a template is redundant. But it could be done like this:

    public class MainWindowBase : Window
    {
        public int SomeProperty
        {
            get { return (int)GetValue(SomePropertyProperty); }
            set { SetValue(SomePropertyProperty, value); }
        }

        public static readonly DependencyProperty SomePropertyProperty =
            DependencyProperty.Register("SomeProperty", typeof(int), typeof(MainWindowBase), new PropertyMetadata(0));
    }

    public partial class MainWindow : MainWindowBase
    {
        public MainWindow()
        {
            InitializeComponent();

<local:MainWindowBase x:Class="****.MainWindow"