CODEWITHSUNDEEP
wpfxamlmvvmcode-behind
Eric
Eric

Reputation: 2059

XAML without the .xaml.cs code behind files

I'm using WPF with the Model-View-ViewModel pattern. Thus, my code behind files (.xaml.cs) are all empty, except for the constructor with a call to InitializeComponent. Thus, for every .xaml file I have a matching, useless, .xaml.cs file.

I swear I read somewhere that if the code behind file is empty except for the constructor, there is a way to delete the file from the project altogether. After searching the net, it seems that the appropriate way to do this is to use the 'x:Subclass' attribute:

<UserControl
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    xmlns:toolkit="http://schemas.microsoft.com/wpf/2008/toolkit"
    x:Class="MyNamespace.MyClass"
    x:Subclass="UserControl"
    d:DesignWidth="700" d:DesignHeight="500">

This does the following in the generated .g.cs file:

  1. Removes the 'partial' class modifier on MyClass.
  2. Adds the class 'UserControl' in to its subclass list.

Seems perfect. Indeed, if you still have the .xaml.cs file in the build, it no longer compiles because of the missing partial--so I'm thinking this must be correct. However, if I remove the superfluous file from the build and run, the control does not get initialized correctly (it is blank). This is, I presume, because InitializeComponent() is not getting called. I see InitializeComponent is not virtual, so it seems there would be no way for the base class to call it (short of using reflection).

Am I missing something?

Thanks!

Eric

Upvotes: 30

Views: 12960

Answers (5)

Rohit Sharma
Rohit Sharma

Reputation: 6500

If you are using caliburn micro you can effectively remove .xaml.cs, the framework takes care of initialization (i.e. if you are going with the view-model approach).

This is discussed https://caliburnmicro.codeplex.com/discussions/444250

Upvotes: 1

Eric
Eric

Reputation: 2059

As another option, if you don't want to go all the way to using DataTemplates, here is an alternate approach for UserControls:

Use the x:Code attribute to embed the constructor call in the XAML:

<x:Code><![CDATA[ public MyClass() { InitializeComponent(); }]]></x:Code>

Eric

Upvotes: 36

Scott Whitlock
Scott Whitlock

Reputation: 13839

If you follow Josh Smith's MVVM article, he uses DataTemplates for Views rather than user controls. If you put your DataTemplates into ResourceDictionaries, they don't have a code-behind at all. If you're not using the code-behind of your user control, doesn't that mean you could use a DataTemplate approach? If you do that, WPF will take care of binding your View to your ViewModel for you.

Upvotes: 16

Doug
Doug

Reputation: 5338

Out of sheer curiosity, have you tried using this:

x:Subclass="Control"

By default, UserControls require the InitializeComponent() call, but defacto-standard Controls do not. I'd be interested to see if this works.

-Doug

Upvotes: 0

Reed Copsey
Reed Copsey

Reputation: 564851

I had a discussion with a Windows Client team member at PDC about this, and right now, was told that there is no officially supported way to completely eliminate the code behind file. As you can see, you can get it to compile, but InitializeComponent() is never called, so the control doesn't get setup properly.

The x:Subclass attribute "usage is primarily intended for languages that do not support partial class declarations." It was not intended to allow this behavior (unfortunately).

Upvotes: 2

Related Questions