使用Prism，MVVM，MEF在WPF中动态生成控件

Question

I am using WPF with Prism and MEF for my application. There was a need to create controls dynamically. And so here is my problem!!

As far as I know I should not be having code in my code behind (SomeFile.xaml.cs) to keep my code easily testable. And so the code should be actually moved to ViewModel.

But my code generates UI controls dynamically. And I dont think that the ViewModel should know anything about the Controls.

So where and how should I go about writing this code?? What would be the right approach? Hope I made myself clear!

Thanks

Answer 1

When working with WPF/MVVM, your data layer is your application (the DataContext ), and you use things like Templates to tell WPF how to draw your application components to the UI.

For example, suppose you're given the task to dynamically render a bunch of controls.

The WinForms way might have been to loop through your objects, create a UI control for each object, then add the UI control to the screen.

However with WPF/MVVM, you would instead create a class representing each object (a Model ), and give WPF a list of those classes to display.

There are many different controls WPF can use to draw a list of objects, but the most basic of them is probably an ItemsControl . I have some examples of a simple ItemsControl on my blog if you're interested.

Now even though you've given WPF the list of your objects to render, and told it what control to use to render the list, it still probably doesn't know how to draw your object. The usual solution for this is to include an XAML template of some kind to tell it how to draw your object.

Here's a simple example template that is used to tell WPF how to draw an object of type MyClassObject :

<DataTemplate DataType="{x:Type local:MyClassObject}">
    <StackPanel Orientation="Horizontal">
        <TextBlock Text="Name:" />
        <TextBox Text="{Binding Name}" />
    </StackPanel>
</DataTemplate>

I hope that helps get you going in the right direction :)

Answer 2

From my perspective, the view has the responsibility to render the data/model provided by the viewmodel. While it is ideal to keep as much of the model->view translation logic in the viewmodel, creation of controls adds significant complexity to move to the viewmodel, because of the coupling or infrastructure that it could add.

While you could: 1) Give the viewmodel direct access to the view, allowing it to create controls directly This adds coupling... 2) Create an interface on the view to manipulate controls This means the view must be passed (not simply bound) to the viewmodel 3) Create an abstraction of controls to bind to the view, and have the view render based on the abstraction created by the viewmodel This adds a maintenance nightmare as your control set expands.

I suggest exposing the model (either directly or wrapped in micro-viewmodels) via a property on the main viewmodel, and binding that to a property on the view via xaml, such that any PropertyChanged on the viewmodel will send an update to the view. Use the model information and your control creation logic inside the view to clear and re-create the controls and bind the model dynamically to the controls you create. This will simplify both the creation and binding of the controls, and you won't have to practice any voodoo to get information entered into the controls back into your model.

Note that even if you created an intermediary class (an attached behavior, adorner, or something else), it will still need to be able to access the view's control structure directly to attach the generated controls to the visual tree, which may cause other problems.