mugenmvvmtoolkit Wiki Rss Feed

Updated Wiki: Design mode

VVS0205 — Fri, 04 May 2012 08:27:03 GMT

To date, the only supported NET3.5-NET4, SL4-SL5 assembly.

For work in design mode, you need add class:

    [MvvmApplication(1)]
    public class DesignApplication : MvvmDesignApplication
    {

        #region Overrides of MvvmDesignApplication

        /// <summary>
        /// Creating a main Ioc adapter for design mode.
        /// </summary>
        /// <returns/>
        protected override IocAdapterBase CreateDesignerContainer()
        {
            var mugenInjector = new MugenInjector();
            mugenInjector.Bind<string>().ToConstant("Hello design Ioc container");
            mugenInjector.Bind<IRepository>().ToConstant(new FakeRepository());
            return new MugenIocAdapter(mugenInjector);
        }

        #endregion
    }

The number in the attribute indicates the priority for loading class. If you have two classes that will be selected with the highest priority.

In the view must be added:

<Window x:Class="MugenMvvmDesignModeWpf.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:Behaviors="clr-namespace:MugenMvvmToolkit.Behaviors;assembly=MugenMvvmToolkit" Title="MainWindow" Height="350" Width="525" 
        Behaviors:DesignViewBehavior.ViewName="MugenMvvmDesignModeWpf.MainWindow">

Write the full name of the class view. If for one view exist more than once view model use this syntax FULLVIEWCLASSNAME;FULLVIEWMODELCLASSNAME, example:

<Window x:Class="MugenMvvmDesignModeWpf.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:Behaviors="clr-namespace:MugenMvvmToolkit.Behaviors;assembly=MugenMvvmToolkit" Title="MainWindow" Height="350" Width="525" 
        Behaviors:DesignViewBehavior.ViewName="MugenMvvmDesignModeWpf.MainWindow;MugenMvvmDesignModeWpf.MainWindowViewModel">

After this datacontext is equal to a given view model, and Ioc container will contain the value specified for the design mode.

Each view model supports property IsDesignMode, it indicate whether the control is in design mode (running under Blend or Visual Studio).

Example:

        public string UseProperty
        {
            get
            {
                if (IsDesignMode)
                    return "Property design mode";
                return "Property not design mode";
            }
        }

Updated Wiki: Design mode

VVS0205 — Fri, 04 May 2012 08:23:32 GMT

To date, the only supported NET3.5-NET4, SL4-SL5 assembly.

For work in design mode, you need add class:

    [MvvmApplication(1)]
    public class DesignApplication : MvvmDesignApplication
    {

        #region Overrides of MvvmDesignApplication

        /// <summary>
        /// Creating a main Ioc adapter for design mode.
        /// </summary>
        /// <returns/>
        protected override IocAdapterBase CreateDesignerContainer()
        {
            var mugenInjector = new MugenInjector();
            mugenInjector.Bind<string>().ToConstant("Hello design Ioc container");
            mugenInjector.Bind<IRepository>().ToConstant(new FakeRepository());
            return new MugenIocAdapter(mugenInjector);
        }

        #endregion
    }

The number in the attribute indicates the priority for loading class. If you have two classes that will be selected with the highest priority.

In the view must be added:

<Window x:Class="MugenMvvmDesignModeWpf.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:Behaviors="clr-namespace:MugenMvvmToolkit.Behaviors;assembly=MugenMvvmToolkit" Title="MainWindow" Height="350" Width="525" 
        Behaviors:DesingViewBehavior.ViewName="MugenMvvmDesignModeWpf.MainWindow">

Write the full name of the class view. If for one view exist more than once view model use this syntax FULLVIEWCLASSNAME;FULLVIEWMODELCLASSNAME, example:

<Window x:Class="MugenMvvmDesignModeWpf.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:Behaviors="clr-namespace:MugenMvvmToolkit.Behaviors;assembly=MugenMvvmToolkit" Title="MainWindow" Height="350" Width="525" 
        Behaviors:DesingViewBehavior.ViewName="MugenMvvmDesignModeWpf.MainWindow;MugenMvvmDesignModeWpf.MainWindowViewModel">

After this datacontext is equal to a given view model, and Ioc container will contain the value specified for the design mode.

Each view model supports property IsDesignMode, it indicate whether the control is in design mode (running under Blend or Visual Studio).

Example:

        public string UseProperty
        {
            get
            {
                if (IsDesignMode)
                    return "Property design mode";
                return "Property not design mode";
            }
        }

Updated Wiki: Design mode

VVS0205 — Fri, 04 May 2012 08:23:11 GMT

To date, the only supported NET3.5-NET4, SL4-SL5 assembly.

For work in design mode, you need add class:

    [MvvmApplication(1)]
    public class DesignApplication : MvvmDesignApplication
    {

        #region Overrides of MvvmDesignApplication

        /// <summary>
        /// Creating a main Ioc adapter for design mode.
        /// </summary>
        /// <returns/>
        protected override IocAdapterBase CreateDesignerContainer()
        {
            var mugenInjector = new MugenInjector();
            mugenInjector.Bind<string>().ToConstant("Hello design Ioc container");
            mugenInjector.Bind<IRepository>().ToConstant(new FakeRepository());
            return new MugenIocAdapter(mugenInjector);
        }

        #endregion
    }

The number in the attribute indicates the priority for loading class. If you have two classes that will be selected with the highest priority.

In the view must be added:

<Window x:Class="MugenMvvmDesignModeWpf.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:Behaviors="clr-namespace:MugenMvvmToolkit.Behaviors;assembly=MugenMvvmToolkit" Title="MainWindow" Height="350" Width="525" 
        Behaviors:DesingViewBehavior.ViewName="MugenMvvmDesignModeWpf.MainWindow">

Write the full name of the class view. If for one view exist more than once view model use this syntax FULLVIEWCLASSNAME;FULLVIEWMODELCLASSNAME, example:

<Window x:Class="MugenMvvmDesignModeWpf.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:Behaviors="clr-namespace:MugenMvvmToolkit.Behaviors;assembly=MugenMvvmToolkit" Title="MainWindow" Height="350" Width="525" 
        Behaviors:DesignViewBehavior.ViewName="MugenMvvmDesignModeWpf.MainWindow;MugenMvvmDesignModeWpf.MainWindowViewModel">

After this datacontext is equal to a given view model, and Ioc container will contain the value specified for the design mode.

Each view model supports property IsDesignMode, it indicate whether the control is in design mode (running under Blend or Visual Studio).

Example:

        public string UseProperty
        {
            get
            {
                if (IsDesignMode)
                    return "Property design mode";
                return "Property not design mode";
            }
        }

Updated Wiki: Documentation

VVS0205 — Thu, 19 Apr 2012 17:02:59 GMT

Updated Wiki: Work with Relay command

VVS0205 — Sat, 14 Apr 2012 15:46:09 GMT

For work with commands, use class RelayCommand, it implements an interface ICommand.

In the class RelaySommand identified four constructors, for Wpf requires only two (the other for backward compatibility with SL applications).

/// <summary>
/// Create new instance <see cref="RelayCommand"/>
/// </summary>
/// <param name="execute">Command action for execute.</param>
RelayCommand(Action<object> execute)

/// <summary>
/// Create new instance <see cref="RelayCommand"/>
/// </summary>
/// <param name="execute">Command action for execute.</param>
/// <param name="canExecute">Command condition.</param>
RelayCommand(Action<object> execute, Predicate<object> canExecute)

/// <summary>
/// Create new instance <see cref="RelayCommand"/>
/// </summary>
/// <param name="execute">Command action for execute.</param>
/// <param name="canExecute">Command condition.</param>
/// <param name="propertyChanged">Object implemented <see cref="INotifyPropertyChanged"/> for auto call event CanExecuteChanged. 
/// If you change the properties of the objects to be caused by an event CanExecuteChanged.</param>
[Obsolete("This is only for Silverligth. WPF will ignore the other parameters related with INotifyPropertyChanged.")]
RelayCommand(Action<object> execute, Predicate<object> canExecute, params INotifyPropertyChanged[] propertyChanged)

/// <summary>
/// Create new instance <see cref="RelayCommand"/>
/// </summary>
/// <param name="execute">Command action for execute.</param>
/// <param name="canExecute">Command condition.</param>
/// <param name="property">Specified property for execute event <see cref="CanExecuteChanged"/> </param>
/// <param name="propertyChanged">Object implemented <see cref="INotifyPropertyChanged"/> for auto call event <see cref="CanExecuteChanged"/>. 
/// If you change the properties of the objects to be caused by an event <see cref="CanExecuteChanged"/>.</param>
[Obsolete("This is only for Silverligth. WPF will ignore the other parameters related with INotifyPropertyChanged.")]
RelayCommand(Action<object> execute, Predicate<object> canExecute, IList<string> property, params INotifyPropertyChanged[] propertyChanged)

For Silverlight:

/// <summary>
/// Create new instance <see cref="RelayCommand"/>
/// </summary>
/// <param name="execute">Command action for execute.</param>
RelayCommand(Action<object> execute)

/// <summary>
/// Create new instance <see cref="RelayCommand"/>
/// </summary>
/// <param name="execute">Command action for execute.</param>
/// <param name="canExecute">Command condition.</param>
[Obsolete("This is only for WPF, in silverlight canExecute will not work use RelayCommand(Action<object> execute, Predicate<object> canExecute, params INotifyPropertyChanged[] propertyChanged).")]
public RelayCommand(Action<object> execute, Predicate<object> canExecute)
            

/// <summary>
/// Create new instance <see cref="RelayCommand"/>
/// </summary>
/// <param name="execute">Command action for execute.</param>
/// <param name="canExecute">Command condition.</param>
/// <param name="propertyChanged">Object implemented <see cref="INotifyPropertyChanged"/> for auto call event CanExecuteChanged. 
/// If you change the properties of the objects to be caused by an event CanExecuteChanged.</param>
RelayCommand(Action<object> execute, Predicate<object> canExecute, params INotifyPropertyChanged[] propertyChanged)

/// <summary>
/// Create new instance <see cref="RelayCommand"/>
/// </summary>
/// <param name="execute">Command action for execute.</param>
/// <param name="canExecute">Command condition.</param>
/// <param name="property">Specified property for execute event <see cref="CanExecuteChanged"/> </param>
/// <param name="propertyChanged">Object implemented <see cref="INotifyPropertyChanged"/> for auto call event <see cref="CanExecuteChanged"/>. 
/// If you change the properties of the objects to be caused by an event <see cref="CanExecuteChanged"/>.</param>
RelayCommand(Action<object> execute, Predicate<object> canExecute, IList<string> property, params INotifyPropertyChanged[] propertyChanged)

Updated Wiki: Work with child window

VVS0205 — Sat, 14 Apr 2012 15:45:44 GMT

To use the child window you need to create a view and view model for him.

View for child window:

    [ViewModel(typeof (MyChildWindowViewModel))]
    public partial class MyChildWindowView : IChildWindowView
    {
        public MyChildWindowView()
        {
            InitializeComponent();
        }
    }

View model for child window:

public class MyChildWindowViewModel : ChildWindowViewModel
{
}

Example of use:

private void ShowMyChildWindow()
        {
            var myChildWindowViewModel = GetViewModel<MyChildWindowViewModel>();

            //Show child window, callback executed after close child window.
            myChildWindowViewModel.Show(model => {});
        }

Updated Wiki: Work with child window

VVS0205 — Sat, 14 Apr 2012 15:45:13 GMT

To use the child window you need to create a view and view model for him.

View for child window:

    [ViewModel(typeof (MyChildWindowViewModel))]
    public partial class MyChildWindowView : IChildWindowView
    {
        public MyChildWindowView()
        {
            InitializeComponent();
        }
    }

View model for child window:

public class MyChildWindowViewModel : ChildWindowViewModel
{
}

Example of use:

private void ShowMyChildWindow()

        {
            var myChildWindowViewModel = GetViewModel<MyChildWindowViewModel>();

            //Show child window, callback executed after close child window.

            myChildWindowViewModel.Show(model => {});
        }

Updated Wiki: Work with dialog window

VVS0205 — Sat, 14 Apr 2012 15:44:20 GMT

To use the dialog window you need to create a view and view model for him.

View for dialog window:

[ViewModel(typeof (MyTestDialogViewModel))]
public partial class MyTestDialogView : IDialogView
{
        public MyTestDialogView()
        {
            InitializeComponent();
        }
}

View model for dialog window:

public class MyTestDialogViewModel : DialogViewModel
{
}

Example of use:

private void ShowMyTestDialog()
        {
            var myTestDialogViewModel = GetViewModel<MyTestDialogViewModel>();

            //Show dialog.
            myTestDialogViewModel.Show();

            //Show modal dialog.
            myTestDialogViewModel.ShowDialog();
        }

Updated Wiki: Work with dialog window

VVS0205 — Sat, 14 Apr 2012 15:43:55 GMT

To use the dialog window you need to create a view and view model for him.

View for dialog window:

[ViewModel(typeof (MyTestDialogViewModel))]
public partial class MyTestDialogView : IDialogView
{
        public MyTestDialogView()
        {
            InitializeComponent();
        }
}

View model for dialog window:

public class MyTestDialogViewModel : DialogViewModel

{
}

Example of use:

private void ShowMyTestDialog()
        {
            var myTestDialogViewModel = GetViewModel<MyTestDialogViewModel>();

            //Show dialog.
            myTestDialogViewModel.Show();

            //Show modal dialog.
            myTestDialogViewModel.ShowDialog();
        }

Updated Wiki: Documentation

VVS0205 — Sat, 14 Apr 2012 15:42:57 GMT

The concept of the Toolkit.
Getting started WPF
Getting started Silverlight
Design mode
Working with asynchronous.
Work with dialog window
Work with child window
Work with Relay command
Use view property, event, etc.
Unit testing
Data annotation validation
Silverlight navigation
Event and property manager

For more info see example.

At the moment only supports a Ioc container http://mugeninjection.codeplex.com/, in the near future I will add support for all popular containers.

Updated Wiki: Documentation

VVS0205 — Sat, 14 Apr 2012 15:42:40 GMT

The concept of the Toolkit.
Getting started WPF
Getting started Silverlight
Design mode
Working with asynchronous.
Work with dialog window
Work with child window
Work with Relay command
Use view property, event, etc.
Unit testing
Data annotation validation
Silverlight navigation
Event and property manager

For more info see example.

At the moment only supports a Ioc container Mugen Injection:http://mugeninjection.codeplex.com/, in the near future I will add support for all popular containers.

Updated Wiki: Home

VVS0205 — Sat, 14 Apr 2012 15:37:39 GMT

Project Description
Mugen MVVM Toolkit makes it easier to develop Silverlight, WPF and WP7 applications using the Model-View-ViewModel design pattern. It is very easy to use. It combines the pattern of DI (dependency injection) and MVVM (Model-View-ViewModel). See documentation and example for more detail.

Features:

Very easy to use (example wpf, silverlight).
Each ViewModel contains independent of other Ioc container (example).
Support for Silverlight, WPF and Windows Phone 7.
Support work in design mode, you can use fake bindings for your Ioc container.
Supports unit-test (example).
RelayCommand - provides for small, simple command declarations. The execution logic, and optionally can-execute logic.
Async support with transparent marshaling to the UI thread (example).
Helpers for work with Task.
Very easy work with dialogs (example) and child windows (example).
You can use any event from the view in the view model, and it is very easy to test (example).
Support data annotation validation attributes, for SL add MetadataTypeAttribute for use in partial class (example).
Closeable ViewModels (when you are using TabControl).
Simple page navigation for SL app (example).

Supported platforms:

WPF
Silverlight 3-5
Windows phone 7-7.1

Plans:

Add support for the popular Ioc containers.

Updated Wiki: Event and property manager

VVS0205 — Sat, 14 Apr 2012 15:27:58 GMT

Event manager behavior, allowing you to bind any event of any UI element to an ICommand, for example on the ViewModel, directly in XAML. This makes using Commands much easier, without writing code behind. You can even get the EventArgs of the fired event directly in the ViewModel to handle it. Example:

<Grid>
        <i:Interaction.Triggers>
            <i:EventTrigger EventName="SizeChanged">
                <Behaviors:PropertyManager Binding="{Binding Path=ActualWidth, Mode=OneWayToSource, UpdateSourceTrigger=PropertyChanged}" SourceProperty="ActualWidth"/>
            </i:EventTrigger>
        </i:Interaction.Triggers>
        
        <Button Content="DoubleClick">
            <i:Interaction.Triggers>
                <i:EventTrigger EventName="MouseDoubleClick">
                    <Behaviors:EventManager IsChangeEnabledState="True" Command="{Binding Path=DoubleClickCommand}" CommandParameter="TestParameter"/>
                </i:EventTrigger>
            </i:Interaction.Triggers>
        </Button>
</Grid>

ViewModel:

        #region Constructor

        public MainWindowViewModel()
        {
            DoubleClickCommand = new RelayCommand(Execute, CanExecute);
        }

        #endregion        

       #region Command

        public ICommand DoubleClickCommand { get; private set; }

        #endregion

        #region Method

        private bool CanExecute(object o)
        {
            return ActualWidth > 400;
        }

        private void Execute(object o)
        {
            var commandParameters = (CommandParameters)o;
            //Contain command parameter
            object commandParameter = commandParameters.CommandParameter;
            //Contain event parameter
            object eventParameter = commandParameters.EventParameter;
            MessageBox.Show(string.Format("Command parameter: {0}.\nEvent parameter: {1}.", commandParameter,
                                          eventParameter));
        }

        #endregion

Property manager behavior, allowing you to bind any property(include not self bindable) of any UI element to an your property, for example on the ViewModel, directly in XAML. Example:

<i:Interaction.Triggers>
            <i:EventTrigger EventName="SizeChanged">
                <Behaviors:PropertyManager Binding="{Binding Path=ActualWidth, Mode=OneWayToSource, UpdateSourceTrigger=PropertyChanged}" SourceProperty="ActualWidth"/>
            </i:EventTrigger>
</i:Interaction.Triggers>

ViewModel:


        private double _actualWidth;

        public double ActualWidth
        {
            get { return _actualWidth; }
            set
            {
                _actualWidth = value;
            }
        }

Updated Wiki: Home

VVS0205 — Tue, 27 Mar 2012 14:38:07 GMT

Features:

Very easy to use (example wpf, silverlight).
Each ViewModel contains independent of other Ioc container (example).
Support for Silverlight, WPF and Windows Phone 7.
Support work in design mode, you can use fake bindings for your Ioc container.
Supports unit-test (example).
RelayCommand - provides for small, simple command declarations. The execution logic, and optionally can-execute logic.
Async support with transparent marshaling to the UI thread (example).
Helpers for work with Task.
Very easy work with dialogs (example) and child windows (example).
You can use any event from the view in the view model, and it is very easy to test (example).
Support data annotation validation attributes, for SL add MetadataTypeAttribute for use in partial class (example).
Closeable ViewModels (when you are using TabControl).
Simple page navigation for SL app (example).

Supported platforms:

WPF
Silverlight 3-5
Windows phone 7-7.1

Plans:

Add support for the popular Ioc containers.
Increase productivity and capacity.

Updated Wiki: Design mode

VVS0205 — Mon, 26 Mar 2012 17:33:08 GMT

To date, the only supported NET3.5-NET4, SL4-SL5 assembly.

For work in design mode, you need add class:

    [MvvmApplication(1)]
    public class DesignApplication : MvvmDesignApplication
    {

        #region Overrides of MvvmDesignApplication

        /// <summary>
        /// Creating a main Ioc adapter for design mode.
        /// </summary>
        /// <returns/>
        protected override IocAdapterBase CreateDesignerContainer()
        {
            var mugenInjector = new MugenInjector();
            mugenInjector.Bind<string>().ToConstant("Hello design Ioc container");
            mugenInjector.Bind<IRepository>().ToConstant(new FakeRepository());
            return new MugenIocAdapter(mugenInjector);
        }

        #endregion
    }

The number in the attribute indicates the priority for loading class. If you have two classes that will be selected with the highest priority.

In the view must be added:

<Window x:Class="MugenMvvmDesignModeWpf.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:Behaviors="clr-namespace:MugenMvvmToolkit.Behaviors;assembly=MugenMvvmToolkit" Title="MainWindow" Height="350" Width="525" 
        Behaviors:DesingViewBehavior.ViewName="MugenMvvmDesignModeWpf.MainWindow">

Write the full name of the class view. If for one view exist more than once view model use this syntax FULLVIEWCLASSNAME;FULLVIEWMODELCLASSNAME, example:

<Window x:Class="MugenMvvmDesignModeWpf.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:Behaviors="clr-namespace:MugenMvvmToolkit.Behaviors;assembly=MugenMvvmToolkit" Title="MainWindow" Height="350" Width="525" 
        Behaviors:DesingViewBehavior.ViewName="MugenMvvmDesignModeWpf.MainWindow;MugenMvvmDesignModeWpf.MainWindowViewModel">

After this datacontext is equal to a given view model, and Ioc container will contain the value specified for the design mode.

Each view model supports property IsDesignMode, it indicate whether the control is in design mode (running under Blend or Visual Studio).

Example:

        public string UseProperty
        {
            get
            {
                if (IsDesignMode)
                    return "Property design mode";
                return "Property not design mode";
            }
        }

Updated Wiki: Design mode

VVS0205 — Mon, 26 Mar 2012 17:32:55 GMT

To date, the only supported NET3.5-NET4, SL4-SL5 assembly.

For work in design mode, you need add class:

    [MvvmApplication(1)]
    public class DesignApplication : MvvmDesignApplication
    {

        #region Overrides of MvvmDesignApplication

        /// <summary>
        /// Creating a main Ioc adapter for design mode.
        /// </summary>
        /// <returns/>
        protected override IocAdapterBase CreateDesignerContainer()
        {
            var mugenInjector = new MugenInjector();
            mugenInjector.Bind<string>().ToConstant("Hello design Ioc container");
            mugenInjector.Bind<IRepository>().ToConstant(new FakeRepository());
            return new MugenIocAdapter(mugenInjector);
        }

        #endregion
    }

The number in the attribute indicates the priority for loading class. If you have two classes that will be selected with the highest priority.

In the view must be added:

<Window x:Class="MugenMvvmDesignModeWpf.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:Behaviors="clr-namespace:MugenMvvmToolkit.Behaviors;assembly=MugenMvvmToolkit" Title="MainWindow" Height="350" Width="525" 
        Behaviors:DesingViewBehavior.ViewName="MugenMvvmDesignModeWpf.MainWindow">

Write the full name of the class view. If for one view exist more than once view model use this syntax FULLVIEWCLASSNAME;FULLVIEWMODELCLASSNAME, example:

<Window x:Class="MugenMvvmDesignModeWpf.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:Behaviors="clr-namespace:MugenMvvmToolkit.Behaviors;assembly=MugenMvvmToolkit" Title="MainWindow" Height="350" Width="525" 
        Behaviors:DesingViewBehavior.ViewName="MugenMvvmDesignModeWpf.MainWindow;MugenMvvmDesignModeWpf.MainWindowViewModel">

After this datacontext is equal to a given view model, and Ioc container will contain the value specified for the design mode.

Each view model supports property IsDesignMode, it indicate whether the control is in design mode (running under Blend or Visual Studio).

Example:

        public string UseProperty
        {
            get
            {
                if (IsDesignMode)
                    return "Property design mode";
                return "Property not design mode";
            }
        }

Updated Wiki: Documentation

VVS0205 — Mon, 26 Mar 2012 17:22:05 GMT

Concept

Getting started(WPF)

Getting started(Silverlight)

Design mode

Working with asynchronous

Work with dialog window

Work with child window

Work with Relay command

Use view property, event, etc.

Unit testing

Data annotation validation

Silverlight navigation

For more info see example.

At the moment only supports a Ioc container Mugen Injection, in the near future I will add support for all popular containers.

Updated Wiki: Home

VVS0205 — Mon, 26 Mar 2012 17:21:38 GMT

Features:

Very easy to use (example wpf, silverlight).
Each ViewModel contains independent of other Ioc container (example).
Support for Silverlight, WPF and Windows Phone 7.
Support work in design mode, you can use fake bindings for your Ioc container.
Supports unit-test (example).
RelayCommand - provides for small, simple command declarations. The execution logic, and optionally can-execute logic.
Async support with transparent marshaling to the UI thread (example).
Helpers for work with Task.
Very easy work with dialogs (example) and child windows (example).
You can use any event from the view in the view model, and it is very easy to test (example).
Support data annotation validation attributes, for SL add MetadataTypeAttribute for use in partial class (example).
Closeable ViewModels (when you are using TabControl).
Simple page navigation for SL app (example).

Supported platforms:

WPF
Silverlight 3-5
Windwos phone 7-7.1

Plans:

Add support for the popular Ioc containers.
Increase productivity and capacity.

Updated Wiki: Design mode

VVS0205 — Mon, 26 Mar 2012 17:16:26 GMT

To date, the only supported NET3.5-NET4, SL4-SL5 assembly.

For work in design mode, you need add class:

    [MvvmApplication(1)]
    public class DesignApplication : MvvmDesignApplication
    {

        #region Overrides of MvvmDesignApplication

        /// <summary>
        /// Creating a main Ioc adapter for design mode.
        /// </summary>
        /// <returns/>
        protected override IocAdapterBase CreateDesignerContainer()
        {
            var mugenInjector = new MugenInjector();
            mugenInjector.Bind<string>().ToConstant("Hello design Ioc container");
            mugenInjector.Bind<IRepository>().ToConstant(new FakeRepository());
            return new MugenIocAdapter(mugenInjector);
        }

        #endregion
    }

The number in the attribute indicates the priority for loading class. If you have two classes that will be selected with the highest priority.

In the view must be added:

<Window x:Class="MugenMvvmDesignModeWpf.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:Behaviors="clr-namespace:MugenMvvmToolkit.Behaviors;assembly=MugenMvvmToolkit" Title="MainWindow" Height="350" Width="525" 
        Behaviors:DesingViewBehavior.ViewName="MugenMvvmDesignModeWpf.MainWindow">

And write the full name of the class view. If for one view exist more than once view model use this syntax FULLVIEWCLASSNAME;FULLVIEWMODELCLASSNAME, example:

<Window x:Class="MugenMvvmDesignModeWpf.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:Behaviors="clr-namespace:MugenMvvmToolkit.Behaviors;assembly=MugenMvvmToolkit" Title="MainWindow" Height="350" Width="525" 
        Behaviors:DesingViewBehavior.ViewName="MugenMvvmDesignModeWpf.MainWindow;MugenMvvmDesignModeWpf.MainWindowViewModel">

After this datacontext is equal to a given view model, and Ioc container will contain the value specified for the design mode.

Each view model supports property IsDesignMode, it indicate whether the control is in design mode (running under Blend or Visual Studio).

Example:

        public string UseProperty
        {
            get
            {
                if (IsDesignMode)
                    return "Property design mode";
                return "Property not design mode";
            }
        }