View-Model-First Approach ?

[sigmarsson]

• 1. Can Prism attach the View to the View-Model referenced by the ContentControl in a way below ?

<Page
    x:Class="Weather.History.Mvvm.Views.ChartRelayView"
    xmlns:prismmvvm="using:Prism.Mvvm"
    xmlns:prismregion="using:Prism.Regions"
    prismmvvm:ViewModelLocator.AutowireViewModel="True"
    xmlns:inf="using:Weather.History.Prism"
    xmlns:view="using:Weather.History.Mvvm.Views"
    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"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"
    mc:Ignorable="d">

    <UserControl.Resources>
        <UniformGridLayout x:Key="RelayLayout" MaximumRowsOrColumns="1"/>

        <DataTemplate x:Key="Chart">
            <ContentControl Content="{x:Bind}" />
        </DataTemplate>
    </UserControl.Resources>

    <StackPanel>

        <ItemsRepeater ItemsSource="{x:Bind ViewModel.ContentPresenters}" Layout="{StaticResource RelayLayout}" ItemTemplate="{StaticResource Chart}"/>
    
    </StackPanel>
</Page>

I need to intialiaze View-Models and add them to ViewModel.ContentPresenters and in their respective View the AutowireViewModel="False" . This Page above is loaded into a TabView causing this error unless I change the DataTemplate above as :

        <DataTemplate x:Key="Chart">
            <view:ViewA />
        </DataTemplate>

• 2. Would it be also feasable to bind the respective View-Model to the View's DataContext or will it happen on the fly when problem 1# is resolved?

In View's code-behind DataContext is being cast.

    public sealed partial class ViewA : UserControl
    {
        public ViewA()
        {
            InitializeComponent();
        }

        internal ViewAViewModel ViewModel => DataContext as ViewAViewModel ;
    }

[brianlagunas]

If you're trying to use VM first, that's not it. You need to have an implicit style (with a target type of your VM ) which will be the View for every VM in your app. When your VM in added to the visual tree, the implicit style will be added by the WPF framework.

If you are going to use VM first, then make sure to opt-out of the ViewModelLocator.

I personally don't recommend VM first as it create more coupling, it's more difficult to maintain, more difficult to debug, and much slower.

Having said that, Prism doesn't care if you use VM first or not. Your design pattern is outside the scope of Prism.

[sigmarsson]

@brianlagunas , thanks for the guide. I admit I did not have the capacity to introduce the View-Model-First approach.

The most simply thing I could add here is a factory method in the IoC and hence did not need anymore to initialize the View-Model separately and later attach to the View. No.

I have a given set of parameters to initialize the View-Models so my factory is based on a circular list and yields the subsequent parameters. With Prism.DryIoc.Extensions delegate registration is possible.

containerRegistry.Register<ClimateConditionContext>(ContextFactory);

and with the circular list I could have the next View-Model instance fabricated. It is as simple but was so essential and did not need to overcomplicate my code with the framework. The ContextFactory revolves around the circular list and I left the AutowireViewModel=True

    public class CircularList<T> : List<T>
    {
        readonly IEnumerator<T> _enumerator;

        public CircularList()
        {
            _enumerator = GetEnumerator();
        }

        public CircularList(IEnumerable<T> source) : this()
        {
            AddRange(source);
        }

        public T Next()
        {
            T next = _enumerator.Current;

            _enumerator.MoveNext();

            return next;
        }

        public new IEnumerator<T> GetEnumerator()
        {
            return new CircularEnumerator<T>(this);
        }
    }

The Enumerator itself :

    internal class CircularEnumerator<T> : IEnumerator<T>
    {
        readonly List<T> _list;
        int _index;

        public CircularEnumerator(List<T> list)
        {
            _list = list;
        }

        public T Current => _list[_index];

        object IEnumerator.Current => Current;

        public void Dispose()
        {

        }

        public bool MoveNext()
        {
            _index = (_index + 1) % _list.Count;

            return true;
        }

        public void Reset()
        {
            _index ^= _index;
        }
    }

The View-Model-First magic was not needed after all.