Question

I have a grid which I call let’s say FooHistory. Now I need plenty of functionality related to that so I go ahead and I create a FooHistory class. Now I have a FooHistory class and a control.

In my MainWindow constructor I create a new instance of this class and pass the instance of this (i.e. the MainWindow) to the FooHistory class sort of like dependency injection. Then later when the FooHistory class wants to interact with the FooHistory control, I do things like this.mainWindow.FooHistory.Items.Add(...).

My question is that is this the recommended way to write WPF applications or am I missing some fundamental approaches?

Answer 1

We use for our programs the MVVM approach. While the details may differ from program to program MVVM is usually build with 3 main parts.

Model:
This is you data object. This may be business data like

class Account
{
    string Name {get;set;}
    string Address {get;set;
}

but can also be UI data like:

class Window
{
    Point Position {get;set;}
    Size Size {get;set;}
}

These objects are for holding data, nothing more. No events, no commands no methods (Thats one point where different interpretation of MVVM differ).

ViewModel:
This is to wrap the model and provide logic around the underlying model. This class is also used to convert a business model property into a view understandable property.

class AccountViewModel
{
    public AccountViewModel(Account aWrappedModel)
    {
    }

    string Name {get {return Model.Name;} }

    AddressObject Address { get{ return new AddressObject( Model.Address ); }
}

View:

Is the wpf part this can be user controls, custom controls, windows, datatemplates etc.
Despite a common believe, its fine to have code behind for view otherwise you have to bend over backwords just because you heard that the view isn’t allowed to have code.

The usual approach now is to create a model, one or more viewmodels and set these viewmodels as DataContext in your view. Sometimes you need a DataTemplate to display the given data, like a DataTemplate for our AccountViewModel.

<DataTemplate DataType="{x:Type AccountViewModel}">
    <StackPanel>
        <TextBox Text="{Binding Name}/>
        <Button Content="Save" Command="{Binding SaveAccount}"/>
    </StackPanel>
</DataTemplate>

This design makes heavy use of Databinding which is fundamental for MVVM and works quite nicely. Of course a couple of problems can arise like: How to handle Collection with models? How to handle events in the viewmodels coming from the ui? How to store my data?

But for these you find many resources here and in the web. But this answer should give you a rough overview of how i and alot other people work with WPF.