常連

WPF + Prism + ReactiveProperty(Rx)を使ったアプリケーションを作成しています。
MVVMパターンでViewModelの連携を取る**(連携させて良いかも含めて)**一般的な方法が知りたいです。

例えばAViewModelのプロパティの値が変更されたときに、
BViewModel、CViewModelのプロパティも変更するといったことを
みなさんがどのように実現させているか教えてください。

ViewModelは全て1つのプロジェクトで管理されていて、いずれもシングルトンです。
AViewModelのプロパティの値はViewの表示状態を管理するためだけに使用します。

私が思いつく方法を書いてみましたが、別の方法などあれば参考にさせてください。

###方法①
**EventAggrigatorを利用してイベントを発行/購読する。**
EventAggrigatorは本来モジュール同士連携させるためのもの。
このようなViewModel同士の連携での使用には違和感がある。
###方法②
**DIコンテナを利用してViewModelを注入する(BViewModel、CViewModel→AViewModel)**
AViewModelにBViewModelとCViewModelのインスタンスを注入。
AViewModelのプロパティ変更されたタイミングでBViewModelとCViewModelのプロパティを変更。
###方法③
**DIコンテナを使用してViewModel注入する(AViewModel→BViewModel、CViewModel)**
BViewModelとCViewModelにAViewModelのインスタンスを注入。
AViewModelのプロパティの変更監視してBViewModelとCViewModelのプロパティを変更。

###ViewModel同士を互いに操作させてはダメ？
[MVVMのModelにまつわる誤解](http://ugaya40.hateblo.jp/entry/model-mistake)
このサイトではViewModel同士にお互いを操作することは好ましくない旨が書かれています。
今回のようなViewModel同士を連携させることに若干違和感を覚え、なんとなくもやもやしています。

MVVMでViewModel同士の連携させるための一般的な方法が知りたい

お世話になります。
独学でC#.netでアプリを作っています。

今までは「Windowsフォームアプリ」でしか作ったことはありませんが、「WPFアプリケーション」の形式でも開発してみたくなりました。
軽くネットで調べているうちに、「WPFアプリケーション」では"MVVM"パターンで作成している例が多く見受けられました。

そこで、参考書として、
 ・デザイン面（WPF）
 ・開発手法面（MVVMパターンでの開発手法。）
が中心に載っている参考書を探しています。

ネットでWPFに関する書籍を調べ、中身を見に本屋を数店舗回りましたが、どこも扱っていなかったため、ここでの質問に至りました。

[経験]
仕事でJava4年ほど。
C#は独学で半年くらいです。

値段は特に制限はありませんが、一般的な参考書の範囲内（\3000～\5000程度？）だと助かります。
よろしくお願いいたします。

WPF、MVVMに関するオススメの参考書を探しています。

どこかにきちんと
* View
* ViewModel
* Model

に分割されたWindowsアプリのサンプルなどないでしょうか？
どこを探してもModelが省略されてて存在意義が現状理解できておりません。
一応以下は見つけましたが、SPAであることもあると思いますが
ViewModelと分割する意義が腑に落ちません。
https://logicalbeat.jp/blog/15425/



WPFとMVVMにおけるModelの役割について

### 前提・実現したいこと
ViewModel(VM)とModelの区別が未だにつきません。

以下の記事のコードの例を出しますと、
[サンプルコードを見ながら理解するMVVMの基礎的な実装](http://kaorun.hatenablog.com/entry/20141202/1417532472)

チュートリアルとして、Personクラスが最初にModelとして実装されています。
しかしこれでは更新されないので、INotifyPropertyChangedを実装してPersonViewModelにしています。

Modelとして実装したはずのPersonクラスが、Viewと結びつかせるためにVMになりました。
そうなるとModelとはいったい何なのでしょうか。
データを保持したり、その処理を書くのがModelだと聞きますが、上の例だとVMがModelのようにデータを保持しているように感じます。

###
最初は、VMとModelを完全に別にするとなると、以下のようにPersonVMクラスの中にPersonのインスタンスを作ってラップするのではないかと考えました。
```C#
PersonVM : INotifyPropertyChanged //(1)
{
    Person person = new Person();
    public int Age{
        get => person.Age;
        set {
            person.Age = value;
            NotifyPropertyChanged(nameof(Age));
        }
    }
}
```
しかしこのようにVMとMを分けると、Personに対して操作しても変更通知されません。

また、ReactivePropertyの意味や使い方がよくわからなくなってしまいます。

```C#
//こう書くのがReactivePropertyの使い方だと思っていたが、VMとModelを兼任しているためMVVMにはならない？
PersonVM : INotifyPropertyChanged //(2)
{
    public ReactiveProperty<int> Age{get;} = new ReactiveProperty<int>();
}

//Modelに代入させることはできても、結局Modelのインスタンス内の変更通知はVMにもVにも飛ばない。
//逆に、ModelからVMに変更通知が必要な設計が間違い？
PersonVM : INotifyPropertyChanged //(3)
{
    Person person = new Person();

    public PersonVM(){
        Age.Subscribe(x => person.Age = x);
    }
    public ReactiveProperty<int> Age{get;}= new ReactiveProperty<int>();
}
```

このPersonクラスをバイナリなりテキストなりでエクスポートする実装をするとして、
ViewModelのCommandの中で出力処理を書いてしまうのはNGだと聞きます。

(1)や(3)ならPersonクラスにメソッドを入れるなり、Personクラスを引数にするメソッドをどっかに作ったりとやりようがありますが、
(2)のようなパターンだとPersonVM内に作るか、PersonVMを引数にとらなくてはならなくなってしまいます。

データ出力のためにVMが必要ならば、それはVMがデータを保持している。つまりVMでもありModelでもあるという状況になっていないでしょうか。

このように、私の中でModelとVMの境目、分け方がわからなくなってしまい混乱しています。
どこかにMVVMの解釈に関して誤解がないか。また、どのような形でMVVMを実装するのが正しいのかの助言をいただきたいです。

よろしくお願いいたします。

MVVMにおける、ViewModelとModelの違い、境界線について

### 前提・実現したいこと

MVVMのアーキテクチャを使って、DataGridの操作を作っています。
一旦登録したデータを更新をかけて、反映させたいのですが、更新できません。

ObservableCollectionは作成・削除といった時の変更通知は発行されるものの、更新時には発行されないということが調査できたのですが、更新時(CollectionChanged)についての処理をどうしたらいいのか分からなくて、困っています。何卒、よろしくお願いいたします。

### 発生している問題・エラーメッセージ

ObservableCollectionは、更新時に変更通知が発行されなく、Viewに変更結果を反映させることが出来ない。

### 該当のソースコード

```XAML
<Window x:Class="WpfApp4.MainWindow"
        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"
        xmlns:local="clr-namespace:WpfApp4"
        xmlns:vm="clr-namespace:WpfApp4.VM"
        xmlns:i="http://schemas.microsoft.com/xaml/behaviors"
        xmlns:l="http://schemas.livet-mvvm.net/2011/wpf"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Window.DataContext>
        <vm:MainWindowVM/>
    </Window.DataContext>    
    <Grid>
        <TabControl>
            <TabItem Header="TabA">
                <DataGrid x:Name="dg" ItemsSource="{Binding vmDataInfo}" IsReadOnly="True" AutoGenerateColumns = "False">
                    <i:Interaction.Triggers>
                        <i:EventTrigger EventName="CurrentCellChanged">
                            <l:LivetCallMethodAction MethodTarget="{Binding}" MethodName="CurrentCellChanged" MethodParameter="{Binding ElementName=dg, Path=CurrentItem}"/>
                        </i:EventTrigger>
                    </i:Interaction.Triggers>
                    <DataGrid.Columns>
                        <DataGridTextColumn Header="選択" Width="50"
                                Binding="{Binding SelectIndex}" />
                        <DataGridTextColumn Header="項目" Width="150"
                                Binding="{Binding ParamName}" />
                        <DataGridTextColumn Header="設定値" Width="100" 
                                Binding="{Binding Param1}" />
                        <DataGridTextColumn Header="変更地" Width="100"
                                Binding="{Binding Param2}" />
                    </DataGrid.Columns>
                </DataGrid>
            </TabItem>
            <TabItem Header="TabB">
                <DataGrid>

                </DataGrid>
            </TabItem>
        </TabControl>
    </Grid>
</Window>

```
MainWindowVM
```C#
    class MainWindowVM : ViewModel
    {

        private ObservableCollection<DataInfo> _vmDataInfo;
        public ObservableCollection<DataInfo> vmDataInfo
        {
            get
            {
                return _vmDataInfo;
            }

            set
            {
                _vmDataInfo = value;
                //NotifyPropertyChange(nameof(vmNgJugement));
                RaisePropertyChanged(nameof(vmDataInfo));
            }
        }

        public MainWindowVM()
        {
            vmDataInfo = new ObservableCollection<DataInfo>();

            vmDataInfo.Add(new DataInfo { ParamName = "Parameter 1", Param1 = 100, Param2 = 0 });
            vmDataInfo.Add(new DataInfo { ParamName = "Parameter 2", Param1 = 200, Param2 = 99 });
            vmDataInfo.Add(new DataInfo { ParamName = "Parameter 3", Param1 = 300, Param2 = 199 });
            vmDataInfo.Add(new DataInfo { ParamName = "Parameter 4", Param1 = 400, Param2 = 299 });
            vmDataInfo.Add(new DataInfo { ParamName = "Parameter 5", Param1 = 500, Param2 = 399 });
        }

        //リスト選択
        public void CurrentCellChanged(object sender)
        {
            //選択された
            if (sender is DataInfo varInfo)
            {
                //Setterは動かない.CollectionChangedで処理する必要がありそう
                vmDataInfo.CollectionChanged += (sender2, e) =>
                {
                    if (sender2 is DataInfo value)
                    {
                        int selectIndex = 0;
                        foreach (var data in vmDataInfo)
                        {
                            if (value.ParamName == data.ParamName)
                            {
                                vmDataInfo[selectIndex].SelectIndex = "●";
                            }
                            else
                            {
                                vmDataInfo[selectIndex].SelectIndex = "";
                            }

                            selectIndex++;
                        }
                    }
                };

            }



        }
    }
```

Model
```C#
    public  class DataInfo
    {
        public string SelectIndex { get; set; }
        public string ParamName { get; set; }
        public int Param1 { get; set; }
        public int Param2 { get; set; }

    }
```


### 試したこと

・ObservableCollectionの更新は変更通知が発行されない.
https://teratail.com/questions/125397

### 補足情報（FW/ツールのバージョンなど）
VisualStudio2019
.Net4.5.2 / Livet使用

WPF[MVVM] DataGrid更新時、ObservableCollectionの更新がViewに反映されない

###前提・実現したいこと
MVVMで、Web検索しますと、複数の解釈とコード例が検索されますが、基本的な例が見つかりません。
そこで、MS社の資料を参考にC# Prism Unityで、MVVM構造の単純なプログラムを作成しました。

＜作成内容＞
「各テキストボックスに、ある数Aとある数Bを入力し、ボタンを押すとラベルに結果を表示する。」

![イメージ説明](013b443c3072443e6b7f6257ac679943.jpeg)

＜課題＞
素直に、そのまま作りますと、只の足し算が信じられない複雑なプログラムになりました。
簡単なプログラムにする良い方法を検討しています。

###ここに質問したいことを詳細に書いてください

C# Prism Unityで、MVVM構造プログラムを作成する場合、定石的な方法で、簡単なコードをご教授下さい。

###該当のソースコード

マイクロソフト社の解説書
CompositeWPF-June2008-JA-JP.chm
MVVM関連
https://www.microsoft.com/ja-JP/download/details.aspx?id=39042

（複雑になった基本プログラム）
![イメージ説明](78f3fa4f171e55f15d7fc1a4c24ec07a.png)

1．準備
VisualStudioCommunity2015
wpfアプリケーションのプロジェクト
NuGetパッケージ管理より
Prism、Prism.Unitをインストール

2.Composite Application Libraryを学ぶ 
2-1 App.XAML
```XAML言語
<Application x:Class="WpfMVVMPrism.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:local="clr-namespace:WpfMVVMPrism"
    Startup ="Application_Startup">
    <Application.Resources>
    </Application.Resources>
</Application>
```
2-2 App.XAML.cs
```C#言語
using System.Windows;
namespace WpfMVVMPrism
{
    /// <summary>
    /// App.xaml の相互作用ロジック
    /// </summary>
    public partial class App : Application
    {
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            var boot = new Bootstrap();
            boot.Run();
        }
    }
}
```
2-3 Bootstrap.cs Shellをコンテナに登録（最小コード）
```C#言語
using System.Windows;
using Microsoft.Practices.Unity;
using Prism.Mvvm;
namespace WpfMVVMPrism
{
    /// <summary>
    /// Unity コンテナーを使用する。
    /// </summary>
    public class Bootstrap : Prism.Unity.UnityBootstrapper
    {
        protected override DependencyObject CreateShell()
        {
            return this.Container.Resolve<Shell>();
        }

        protected override void InitializeShell()
        {
            ViewModelLocator.SetAutoWireViewModel(this.Shell, true);
            ((Shell)this.Shell).Show();
        }
    }
}
```
2-4 Shell.XAML
```XAML言語
<Window
    x:Class="WpfMVVMPrism.Shell"
    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:local="clr-namespace:WpfMVVMPrism"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    Title="MVVMの基本その１(計算 A+B=C)"
    Width="350"
    Height="200"
    mc:Ignorable="d">
    
    
    
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition />
        </Grid.ColumnDefinitions>

        <Grid.RowDefinitions>
            <RowDefinition />
            <RowDefinition />
            <RowDefinition />
            <RowDefinition />
        </Grid.RowDefinitions>
        <TextBox
            x:Name="textBoxA"
            Grid.Row="0"
            Text="{Binding DataA}" />
        <TextBox
            x:Name="textBoxB"
            Grid.Row="1"
            Text="{Binding DataB}" />
        <Button
            x:Name="button"
            Grid.Row="2"
            Content="「A+B=C」の計算をする" 
            Command="{Binding CalculationCommand}"/>
        <Label
            x:Name="labelC"
            Grid.Row="3"
            Content="{Binding ResultC}" />
    </Grid>
</Window>
```
2-5 Shell.XAML.CS
```C#言語
using System.Windows;
namespace WpfMVVMPrism
{
    /// <summary>
    /// Shell.xaml の相互作用ロジック
    /// </summary>
    public partial class Shell : Window
    {
        public Shell()
        {
            InitializeComponent();
            this.DataContext = new ViewModel();
        }
    }
}
```
2-6 VeiwModel.cs
```C#言語
using System;
using System.ComponentModel;
using System.Windows.Input;
namespace WpfMVVMPrism
{
    public class ViewModel : INotifyPropertyChanged
    {
        public int DataA { get; set; }
        public int DataB { get; set; }

        public event PropertyChangedEventHandler PropertyChanged;
        private int _resultC;
        public int ResultC
        {
            get
            {
                return _resultC;
            }
            set
            {
                _resultC = value;
                OnPropertyChanged("ResultC");
            }
        }

        protected void OnPropertyChanged(string name)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(name));
            }
        }

        private ICommand _calculationCommand;
        public ICommand CalculationCommand
        {
            get
            {
                if (_calculationCommand == null)
                {
                    _calculationCommand = new RelayCommand(ExecuteCalculationCommand);
                }
                return _calculationCommand;
            }
        }

        private void ExecuteCalculationCommand(object x)
        {
            Model m = new Model();
            m.a_val = DataA;
            m.b_val = DataB;
            ResultC = m.SumAB();
        }
    }

    internal class RelayCommand : ICommand
    {
        private Action<object> executeCalculationCommand;

        public RelayCommand(Action<object> executeCalculationCommand)
        {
            this.executeCalculationCommand = executeCalculationCommand;
        }

        public event EventHandler CanExecuteChanged;  

        public bool CanExecute(object parameter)
        {
            return true;
        }

        public void Execute(object parameter)
        {
            this.executeCalculationCommand(parameter);
        }
    }
}
```
2-7 Model.cs
```C#言語
namespace WpfMVVMPrism
{
    public class Model
    {
        public int a_val;
        public int b_val;
        public int c_val;

        public int SumAB()
        {
            return c_val = a_val + b_val; 
        }
    }
}
```
以上です。

C#を使用したMVVMの基本について

MVCなどの概念でビジネスロジックを担当する層として「Model」という層が登場しますが、なぜこの名前なのでしょうか？

個人的な印象ですがモデルは「模型」のようなニュアンスが強いと思っていて、名前だけ聞くとデータオブジェクトのような雰囲気があります

MVVMの「ViewModel」はまさにモデルっていう感じで納得できるのですが、今まで見てきたMVCやMVVMのModelはビジネスロジックを担当していたりデータストアとのやりとりを担当していることが多いように感じました

また解説書や解説サイトなどでもModelはビジネスロジックを担当する層という説明がよくでてきます

アーキテクチャ自体に疑問はないのですがなぜこの層をModelというのでしょうか？
由来をご存知の方いたら教えて下さい

なぜビジネスロジックが集まる層を「モデル（Model）」というのでしょうか？

こんにちは。 
Windows10でWPFのMVVMアプリケーションを開発しています。 
Visual Studio 2017 Communityを使っています。 

###前提・実現したいこと
CheckBoxをプロパティにバインディングしたいです。

###試したこと
下記コード。

###発生している問題・エラーメッセージ
値を入れたときに	RaisePropertyChanged("IsShopOperator");するが、画面は変化しない。
xamlをIsChecked="{Binding IsShopOperator, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"  としてもダメでした。

###該当のソースコード
```xaml
		private bool isShopOperator;
		public bool IsShopOperator
		{
			get {return User.IsShopOperator }
			set
			{
				isShopOperator = value;
				RaisePropertyChanged("IsShopOperator");
			}
		}
```C#

```xaml
                    <CheckBox Grid.Column="0" Content="ShopOperator"
                       IsChecked="{Binding IsShopOperator}"  />

```

###補足情報(言語/FW/ツール等のバージョンなど)
Microsoft Visual Studio Community 2017
Version 15.0.26228.9 D15RTWSVC
Microsoft .NET Framework
Version 4.6.01586

です。 
 よろしくお願いします。