読み取り専用に公開するパターン

# 外部からはReadOnlyにして安全な設計を実現する
TODO:めっちゃ面白い導入部を考える

あるオブジェクトに対して「読み込みと書き込みをする」機能と「読み込みだけをする」機能をそれぞれ切り出して公開する（＝書き込みする必要のない人には読み込みする機能だけを公開する）ようにしておくと、オブジェクトの依存関係を（全部公開するのに比べて）減らすことができるようになります。

「読み込みと書き込みをする」機能というのは一種の比喩で、かっこいい言い方をすると「副作用のあるインターフェース」ということになります。

## 読み取り専用のプロパティ
単純にプロパティにアクセス権の差をつけるだけでも、何もしない（全部public）よりは効果があります。大抵のケースではこれだけで十分です。

```csharp

public class PropertyExample
{
    public Something Item { get; private set; }
}

```

## 読み取り専用のコレクション
コレクションを公開するプロパティをgetterだけに限定しても、コレクションを参照して副作用のあるインスタンスメソッドを呼ばれてしまっては元も子もないです。

### Listの場合
`List<T>`は読み取り専用のインターフェースだけをあつめた`IReadOnlyList<T>`を実装しているので、外から変更されたくないがコレクションは公開したい場合は`IReadOnlyList<T>`にキャストした状態で公開するといいです。

もちろん、呼び出し元で`List<T>`に強制的にキャストすればいじれてしまいます。プログラム的にこれを制限する方法はないように思うので、悪いプログラマがチームに紛れ込まないようにするしかないです（悪いプログラマがチームに紛れ込むと設計や言語仕様ではどうにもならないのはC#に限った話ではない…）。

```csharp
public class ListExample
{
    public IReadOnlyList<Something> Items => this.ItemsSource;
    private List<Something> ItemsSource { get; set; } = new List<Something>();
}
```

### ObservableCollectionの場合
`List<T>`はReadOnly版のinterfaceがありますが、`ObservableCollection<T>`（更新通知付きコレクション）にはありません。こちらの場合、interfaceではなく別途`ReadOnlyObservableCollection<T>`のインスタンスを作って元ネタのObservableCollectionを指定してやる、というのが必要になります。

```csharp

public class ObservableCollectionExample
{
    public ReadOnlyObservableCollection<Something> Items { get; }
    private ObservableCollection<Something> ItemsSource { get; set; } = new ObservableCollection<Something>();

    public ObservableCollectionExample()
    {
        this.Items = new ReadOnlyObservableCollection<Something>(this.ItemsSource);
    }
}
```


## 公開範囲をもっと細かく設定する

設計的に一番ごちゃごちゃしないのは「クラスの外部に副作用のあるインターフェース（プロパティ、メソッド）を公開しない」なんですが、それだと設計コストがめちゃ高くなるので徹底するのは難しいです。っていうか現実的に可能なんですかね？

経験則として、あるオブジェクトの「状態を知りたい」人と、「状態を変更したい」人では、前者の方が数が多いので、オブジェクト自体は同じでも公開先に応じて公開するものを切り替えられるようになると小回りがきいて便利です。

そういうときには、先に示した`List<T>`と`IReadOnlyList<T>`のように、同じクラスで`読み取りの操作だけを公開するinterface`と`書き込み操作も公開するinterface`の２つを実装するようにして、公開先に応じてどちらのinterfaceを見せるか切り替えればよいです。

```csharp

/// <summary>
/// 副作用のない操作だけを公開するReadOnlyなInterface
/// </summary>
public interface IReadOnlyMultistageExample
{
    /// <summary>
    /// 副作用のないプロパティ取得
    /// </summary>
    Something Item { get; }

    /// <summary>
    /// 副作用のないメソッド呼び出し
    /// </summary>
    Something GetSomething();
}

/// <summary>
/// 副作用のある操作を公開するInterface
/// </summary>
public interface IMultistageExample : IReadOnlyMultistageExample, IDisposable
{
    /// <summary>
    /// 副作用のあるプロパティ設定
    /// </summary>
    new Something Item { get; set; }

    /// <summary>
    /// 副作用のあるメソッド呼び出し
    /// </summary>
    Something DoSomething(Something arg);
}

/// <summary>
/// 実体クラス
/// </summary>
public class MultistageExample : IMultistageExample
{
    /// <summary>
    /// プロパティ
    /// </summary>
    public Something Item { get; set; }

    /// <summary>
    /// 副作用のあるメソッド呼び出し
    /// </summary>
    public Something DoSomething(Something arg)
    {
        throw new NotImplementedException();
    }

    /// <summary>
    /// 副作用のないメソッド呼び出し
    /// </summary>
    public Something GetSomething()
    {
        throw new NotImplementedException();
    }

    /// <summary>
    /// オブジェクトの破棄
    /// </summary>
    public void Dispose()
    {
        throw new NotImplementedException();
    }
}

```

どっちのinterfaceで取得したかによって、呼び出せる操作の範囲が変わります。

```csharp

MultistageExample implement = new MultistageExample();

{
    IMultistageExample ime = implement;
    ime.Item = new Something();
    var item = ime.Item;
    ime.DoSomething(new Something());
    item = ime.GetSomething();
    ime.Dispose();
}
{
    IReadOnlyMultistageExample irome = implement;
    // irome.Item = new Something(); コンパイルエラー
    var item = irome.Item;
    // irome.DoSomething(new Something()); コンパイルエラー
    item = irome.GetSomething();
    // irome.Dispose(); コンパイルエラー
}

```