Develop Reference

Why is the root element of MainWindow Window instead of MainWindow?

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? E.g. GlowWindow from HandyControl

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.

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"

How to make a XAML view (a page) inherit from a class, that uses UserControl as generic type

I have an issue, and I don't know if I can do that, or if there is another way to do that. I have an abstract class called "BasePage", it is my .NET Standard library, so I can't access to System.Windows namespace. Its declaration is:
public abstract class BasePage<VR> where VR : new()
EDIT: The class above has a public property to access to VR
So now, for each platform (WPF, Xamarin, etc) I have to create its own implementation of the class begin VR the content control of each platform (UserControl for WPF, for example). I already did it and this is:
public class WindowsBasePage : BasePage<UserControl>
Now, every time I want to create a page to add content to a window, I have to create something like this:
public partial class UserPassPage : WindowsBasePage
{
public UserPassPage()
{
InitializeComponent();
}
}
The problem becomes when I have to set it in the XAML file (the View). I can create it and it builds:
<local:WindowsBasePage x:Class="Bitture.AppManager.Manager.UserPassPage"
[...]
xmlns:local="clr-namespace:Bitture.AppManager.Manager"
mc:Ignorable="d" >
</local:WindowsBasePage>
but I can't add components (like buttons, text, grids, stackpanels, etc). I want to know If I can do it with my current code or there is something I have to change. Because I have to access to the generic type WindowsBasePage that inherits from
class WindowsBasePage : BasePage<UserControl>

I am not sure what you are trying to do here but you can't add UIElements to a custom class of yours that doesn't inherit from any of the common WPF base classes such as for example Panel or ContentControl, and expect it to be rendered as a UserControl or some other WPF control.
This won't work. WPF knows about how to render WPF controls but it doesn't know how to render a custom BasePage<UserControl>.

WPF: use the same xaml file with different codebehinds

I'm writing a wpf program that needs several usercontrols that look exactly the same but perform different functions. With winForms, I could just extend the base control and add the functionality, but as far as I know, it's impossible to inherit xaml files. Is there any way I can have different codebehind classes that all use the same xaml file for their control?

You might be able to do this using MVVM pattern and create multiple VMs which perhaps implement the same interface. The XAML view could then be bound to any of your VMs relying on the fact they share the same interface.
In this approach you'd not use the code behind at all.

One way to do it is by using inheritance. A very simple example would be a UserControl with a single button, that should display different contents in a MessageBox.
We will have something like this:
public abstract class SomeUserControl : UserControl
{
//declared by XAML (can be made public with x:FieldModifier="public")
public Button MyButton;
//code-behind
public SomeUserControl() {
InitializeComponent();
}
}
public class MySpecialControl : SomeUserControl {
public MySpecialControl() {
MyButton.Click += (sender, e) => MessageBox.Show("Bla");
}
}
To use the MySpecialControl, just declare it in XAML like you did with your previous one:
<myNamespace:MySpecialControl />
Note that you can also create an abstract method for the button click, if the variation in behavior is not so big.

With winForms, I could just extend the base control
And one can't do similar in WPF?
Create a custom composite control with a dependency property(ies) which would set the mode of the control to fit its the target consumer's needs.
The control could be based on an existing control or controls.

Extend a WPF control in another assembly in XAML?

i am using DevExpress and i'm creating and extended TextEdit.
When i extend from a normal TextBox it's all ok. Behind the code i use simply:
public partial class AutocompleteTextBox : TextBox
And in XAML i start with:
<TextBox x:Class="...">
And all is fine. Now i want change the base class from TextBox to the DevExpress's EditText control. So i changed the class in code to inherit from the TextEdit istead of TextBox but in XAML it give me the error that partial class must have the same base class. The problem is that i don't know what to do. If i use:
<DevExpress.Xtra.Editors.TextEdit x:Class="...">
it give me error.
What i need to do?

Usercontrols that inherit from abstract class

I've got a usercontrol that inherits from an abstract class. Basically looks like this.
class SimpleSlideView : View
{
}
public abstract class View : UserControl
{
}
The project compiles and runs fine. I can take the usercontrol (from the toolbox) and drag it into a form and it is displayed in the designer correctly. However, if I try and open the SimpleSlideView control itself in the designer I receive the following error:
The designer must create an instance
of type 'Animation.View' but it cannot
because the type is declared as
abstract.
What have I missed?

You can find possible solution here: How can I get Visual Studio 2008 Windows Forms designer to render a Form that implements an abstract base class?