【C#】なぜpublicなメンバではなくプロパティを使うのか

# この記事の経緯
[Effective C#4.0](https://www.amazon.co.jp/dp/B01AAIN7UQ/ref=dp-kindle-redirect?_encoding=UTF8&btkr=1) の項目１「アクセス可能なデータメンバの代わりに常にプロパティを使用すること」を読んだ。
読んで得た知識をアウトプットすることで、理解度を高める。

# 結論
publicなメンバよりもプロパティのほうが、**挙動の変更が容易にできる**からだ。

# なぜ挙動の変更が容易になるのか
アカウント作成を例になぜ変更が容易になるのか考えてみる。

### publicなメンバを使う
まずはプロパティを使わない、以下のようなクラスを定義したとする。

```cs:Account.cs
public class Account
{
    public int Id;
    public string Password;
}
```
```cs:Program.cs
class Program
{
    static void Main(string[] args)
    {
        var account = new Account();
        account.Id = 1;
        account.Password = "1234567";

        var account2 = new Account();
        account2.Id = 2;
        account2.Password = "12345";
    }
}
```

現状、何の問題もない。
ただ`Account`クラスにIDとパスワードを設定するだけの処理だ。

ここで、パスワードを強化するために、パスワードの長さに制限を加えたい。
という仕様変更があったとしよう。

```cs:Account.cs
public class Account
{
    public int Id;
    public string Password;

    // 追加
    public void Validate()
    {
        if (Password.Length < 7)
        {
            throw new InvalidPasswordException("パスワードは7文字以上で設定してください。");
        }
    }

    public class InvalidPasswordException : Exception
    {
        public InvalidPasswordException() : base() { }
        public InvalidPasswordException(string message) : base(message) { }
        public InvalidPasswordException(string message, Exception inner) : base(message, inner) { }
    }
}
```

```cs:Program.cs
class Program
{
    static void Main(string[] args)
    {
        var account = new Account();
        account.Id = 1;
        account.Password = "1234567";
        account.Validate();  // 追加

        var account2 = new Account();
        account2.Id = 2;
        account2.Password = "12345";
        account.Validate();  // 追加
    }
}
```

`Validate`という検証用のメソッドを追加し、メソッドを呼び出すように変更を加えた。
ここで、重要なのは**検証用のメソッドを利用する側が必ず呼び出さなければならない**ということだ。
つまり、**パスワードを設定している箇所すべてにおいて、この検証メソッドを追加しなければならない。**
バグ混入の可能性が大きくなることは容易に想像できる。

### プロパティを使う
プロパティを使った例を見ていこう。

```cs:Account.cs
public class Account
{
    public int Id { get; set; }
    public string Password { get; set; }
}
```
```cs:Program.cs
class Program
{
    static void Main(string[] args)
    {
        var account = new Account();
        account.Id = 1;
        account.Password = "1234567";

        var account2 = new Account();
        account2.Id = 2;
        account2.Password = "12345";
    }
}
```

この時点では何も大差はない。
`Account`クラスのIDとパスワードをプロパティに変更しただけだ。

ここに先程と同様の仕様変更を行う場合どうなるか。

```cs:Account.cs
public class Account
{
    public int Id { get; set; }
    private string _password;
    public string Password {
        get
        {
            return _password;
        }
        set
        {
            if(value.Length < 7)
            {
                throw new InvalidPasswordException("パスワードは7文字以上で設定してください。");
            }
            _password = value;
        }
    }

    public class InvalidPasswordException : Exception
    {
        public InvalidPasswordException() : base() { }
        public InvalidPasswordException(string message) : base(message) { }
        public InvalidPasswordException(string message, Exception inner) : base(message, inner) { }
    }
}
```
```cs:Program.cs
class Program
{
    static void Main(string[] args)
    {
        var account = new Account();
        account.Id = 1;
        account.Password = "1234567";

        var account2 = new Account();
        account2.Id = 2;
        account2.Password = "12345";
    }
}
```

プロパティのsetアクセサに対し、検証ロジックを追加した。
ここで重要なのは**利用する側は一切変更していない**ということだ。
つまり、**修正箇所がクラス内に限定される**ため、バグが混入するリスクは少なくなり、挙動の変更も容易となる。


# publicなメンバからプロパティに変更する際の注意点
プロパティを使ったほうが、挙動の変更が容易にできることは分かった。
それではすぐにpublicのメンバをプロパティに変更してしまおう。と思うかもしれないがそこは注意が必要だ。
なぜなら、publicなメンバへのアクセスとプロパティを介したアクセスでは**ソース上では互換性があるかもしれないが、バイナリ上では互換性がないため、必ず再コンパイルする必要性が生じる**からだ。

先程のコードが以下の構成で作られているとして、実験してみよう。
![1.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/68663/ef77b1ff-252c-3b1c-b729-cbe6d9eebb2e.png)

まずは、publicなメンバを持つ状態で実行してみる。

```cs:Account.cs
public class Account
{
    public int Id;
    public string Password;
}
```
```cs:Program.cs
class Program
{
    static void Main(string[] args)
    {
        var account = new Account();
        account.Id = 1;
        account.Password = "1234567";

        var account2 = new Account();
        account2.Id = 2;
        account2.Password = "12345";

        Console.WriteLine($"Account1 Id:{account.Id} Password:{account.Password}");
        Console.WriteLine($"Account2 Id:{account2.Id} Password:{account2.Password}");
        Console.ReadLine();
    }
}
```

```text:実行結果
Account1 Id:1 Password:1234567
Account2 Id:2 Password:12345
```

何の問題もなく、実行できることが確認できた。
次に、publicのメンバであろうが、プロパティを使おうが利用する側のコードは変わらないため、実行ファイルはそのまま利用し、dll側をプロパティに変更して実行してみよう。

```cs:Account.cs
public class Account
{
    public int Id { get; set; }
    public string Password { get; set; }
}
```
```text:実行結果
ハンドルされていない例外: System.MissingFieldException: フィールドが見つかりません: 'SampleLib.Account.Id'
...
```

`MissingFieldException`が発生し、実行できなくなってしまった。
なぜこのような自体になってしまうのか、プロパティを使用した場合、実際どのようなコードを書いたことになるのか見てみよう。[^1]

```cs:ILからのデコンパイル結果
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
public class Account
{
    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private int <Id>k__BackingField;

    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private string <Password>k__BackingField;

    public int Id
    {
        [CompilerGenerated]
        get
        {
            return <Id>k__BackingField;
        }
        [CompilerGenerated]
        set
        {
            <Id>k__BackingField = value;
        }
    }

    public string Password
    {
        [CompilerGenerated]
        get
        {
            return <Password>k__BackingField;
        }
        [CompilerGenerated]
        set
        {
            <Password>k__BackingField = value;
        }
    }
}
```

`<○○>k__BackingField`というprivateなメンバが自動的に生成され、それにアクセスするためのsetアクセサ、getアクセサが定義されている。
つまり、**プロパティはpublicなメンバを作成するのではなく、privateなメンバとそのアクセサを提供してくれるということだ。**
そのため、再コンパイルせずに実行すると、publicなメンバである`Id`が存在しないという自体が生じることになる。

このような自体が起こる可能性があるため、別アセンブリから参照されているメンバをプロパティに変える際は十分に注意が必要だ。

# まとめ
[Effective C#4.0](https://www.amazon.co.jp/dp/B01AAIN7UQ/ref=dp-kindle-redirect?_encoding=UTF8&btkr=1) の項目１「アクセス可能なデータメンバの代わりに常にプロパティを使用すること」を読んで得た知識をまとめてみた。
publicなメンバよりもプロパティを使うことのメリットが少しでも伝われば幸いだ。

それではまた。
TomoProg

[^1]: [SharpLab](https://sharplab.io/)を利用した。IL（Intermediate Language：中間言語）からC#へのデコンパイルがブラウザ上で簡単にできる。