C# メンバとは？フィールド・プロパティ・メソッドの違いと使い方を初心者向けに解説

はじめに

C#を学び始めると、「メンバ」「フィールド」「プロパティ」「メソッド」といった言葉がよく出てきます。どれもクラスを理解するうえで欠かせない要素ですが、初心者のうちは「結局どれが何を表しているのか」「フィールドとプロパティは何が違うのか」で混乱しやすい部分です。

C#のメンバとは、簡単にいうとクラスや構造体の中に定義される要素のことです。値を保持するフィールド、外部から値を安全に扱うためのプロパティ、処理を実行するメソッドなどがメンバに含まれます。

この記事では、C# メンバの基本を初心者向けに整理しながら、フィールド・プロパティ・メソッドの違いと使い方をコード例つきで解説します。クラスの書き方を理解したい方や、オブジェクト指向の基礎を固めたい方は、ぜひ参考にしてください。

1. C#のメンバとは？クラスを構成する要素を初心者向けに整理

C#のメンバを理解するには、まず「クラスとは何か」を簡単に押さえておく必要があります。

クラスは、データと処理をひとまとめにした設計図のようなものです。たとえば、人を表すPersonクラスであれば、名前や年齢などのデータ、自己紹介をする処理などを定義できます。

C#
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public void Introduce()
    {
        Console.WriteLine($"私は{Name}です。{Age}歳です。");
    }
}

このPersonクラスの中にあるName、Age、Introduceなどがメンバです。

1-1. メンバとはクラスや構造体の中に定義される要素のこと

C#におけるメンバとは、クラスや構造体の中に定義される変数、値、処理、初期化処理などの総称です。

たとえば次のコードを見てみましょう。

C#
class Sample
{
    private int number;

    public int Number
    {
        get { return number; }
        set { number = value; }
    }

    public void ShowNumber()
    {
        Console.WriteLine(number);
    }
}

この中では、次の要素がメンバです。

numberはフィールド、Numberはプロパティ、ShowNumberはメソッドです。つまり、メンバという言葉は特定の1種類を指すのではなく、クラスの中にある構成要素をまとめて表す言葉です。

1-2. C#の主なメンバ一覧：フィールド・プロパティ・メソッド・コンストラクターなど

C#の主なメンバには、次のようなものがあります。

初心者が最初に重点的に理解すべきなのは、フィールド、プロパティ、メソッド、コンストラクターです。この4つを理解すると、C#のクラス設計がかなり読みやすくなります。

1-3. 「メンバ変数」と「フィールド」は何が違うのか

C#では、クラスの中に定義された変数のことを正式にはフィールドと呼びます。

一方で、「メンバ変数」という言葉もよく使われます。これは他の言語や一般的な説明で使われる表現で、クラスに属する変数を意味することが多いです。

C#
class Player
{
    private int hp;
}

このhpは、C#の用語ではフィールドです。会話や記事によっては「メンバ変数」と呼ばれることもあります。

ただし、C#を正確に学ぶなら、基本的には「フィールド」という言葉で覚えるのがおすすめです。

1-4. 初心者が混乱しやすい「変数」「メンバ」「プロパティ」の関係

初心者が混乱しやすいのは、「変数」「メンバ」「プロパティ」が似たように見えることです。

変数は、値を入れておく箱のようなものです。

C#
int age = 20;

これはメソッドの中に書かれていればローカル変数です。

C#
class Person
{
    private int age;
}

一方、クラスの中に直接書かれているageはフィールドであり、メンバの一種です。

C#
class Person
{
    public int Age { get; set; }
}

このAgeはプロパティです。外からは変数のように使えますが、実際には値を取得するgetと、値を設定するsetを持つメンバです。

つまり、関係を整理すると次のようになります。

2. C#のフィールドとは？データを保持するメンバ

フィールドは、クラスや構造体の中でデータを保持するためのメンバです。オブジェクトの状態を内部に保存するときに使います。

たとえば、ゲームのキャラクターであればHPやMP、ユーザー情報であれば名前や年齢などを保持するためにフィールドを使えます。

2-1. フィールドの基本構文と書き方

フィールドの基本構文は次のとおりです。

C#
アクセス修飾子 型 フィールド名;

例を見てみましょう。

C#
class Person
{
    private string name;
    private int age;
}

このnameとageがフィールドです。

初期値を設定することもできます。

C#
class Player
{
    private int hp = 100;
    private int level = 1;
}

フィールドはクラスの中に直接定義します。メソッドの中に書いた変数はフィールドではなく、ローカル変数です。

C#
class Sample
{
    private int fieldValue; // フィールド

    public void Test()
    {
        int localValue = 10; // ローカル変数
    }
}

2-2. インスタンスフィールドとstaticフィールドの違い

フィールドには、インスタンスフィールドとstaticフィールドがあります。

インスタンスフィールドは、作成されたオブジェクトごとに別々の値を持ちます。

C#
class Player
{
    public int Hp;
}

Player player1 = new Player();
Player player2 = new Player();

player1.Hp = 100;
player2.Hp = 50;

Console.WriteLine(player1.Hp); // 100
Console.WriteLine(player2.Hp); // 50

player1とplayer2は別々のオブジェクトなので、Hpの値も別々に保持されます。

一方、staticフィールドはクラスそのものに属するフィールドです。すべてのインスタンスで共有されます。

C#
class Player
{
    public static int Count;
}

Player.Count = 1;
Console.WriteLine(Player.Count);

staticフィールドは、インスタンスではなくクラス名を使ってアクセスします。共通設定や作成数のカウントなど、全体で共有したい値に使われます。

2-3. publicフィールドを避けるべき理由

C#では、基本的にpublicフィールドは避けるべきです。

たとえば次のようなコードでは、外部からageに自由に値を設定できます。

C#
class Person
{
    public int age;
}

この場合、次のような不正な値も入れられてしまいます。

C#
Person person = new Person();
person.age = -10;

年齢がマイナスになるのは通常おかしいですが、publicフィールドではそれを防げません。

そのため、フィールドはprivateにして外部から直接触れないようにし、必要に応じてプロパティを通してアクセスさせるのが基本です。

C#
class Person
{
    private int age;

    public int Age
    {
        get { return age; }
        set
        {
            if (value >= 0)
            {
                age = value;
            }
        }
    }
}

このようにすると、値の検証を行えるため、クラスの安全性が高まります。

2-4. privateフィールドと命名規則の例

C#では、privateフィールドの名前にアンダースコアを付ける書き方がよく使われます。

C#
class Person
{
    private string _name;
    private int _age;
}

この命名規則を使うと、フィールドであることが見分けやすくなります。

プロパティと組み合わせると、次のようになります。

C#
class Person
{
    private string _name;

    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
}

_nameは内部で値を保持するフィールド、Nameは外部からアクセスするためのプロパティです。

2-5. フィールドを使う場面と注意点

フィールドは、クラス内部で状態を保持したいときに使います。

たとえば次のような場面です。

注意点は、外部に公開する目的でフィールドを使わないことです。外部から読み書きさせたい値は、基本的にプロパティを使いましょう。

3. C#のプロパティとは？フィールドへのアクセスを制御するメンバ

プロパティは、値の取得や設定を制御するためのメンバです。外から見ると変数のように使えますが、内部ではgetやsetという処理を通して値を扱います。

C#では、フィールドを直接公開するのではなく、プロパティを通して値を公開するのが一般的です。

3-1. プロパティの基本構文：getとsetの役割

プロパティの基本構文は次のとおりです。

C#
アクセス修飾子 型 プロパティ名
{
    get { return フィールド; }
    set { フィールド = value; }
}

具体例を見てみましょう。

C#
class Person
{
    private string _name;

    public string Name
    {
        get
        {
            return _name;
        }
        set
        {
            _name = value;
        }
    }
}

getは値を取得するときに実行されます。setは値を設定するときに実行されます。

C#
Person person = new Person();

person.Name = "山田";              // setが呼ばれる
Console.WriteLine(person.Name);    // getが呼ばれる

setの中で使われているvalueは、代入された値を表す特別なキーワードです。

3-2. プロパティが「外からは変数のように見える」仕組み

プロパティは、外から見るとフィールドや変数のように使えます。

C#
person.Name = "佐藤";
Console.WriteLine(person.Name);

しかし実際には、代入時にはset、読み取り時にはgetが呼び出されています。

つまり、プロパティは「変数のような見た目で使えるメソッドに近い仕組み」と考えると理解しやすいです。

たとえば、次のように値の加工もできます。

C#
class Person
{
    private string _name = "";

    public string Name
    {
        get { return _name; }
        set { _name = value.Trim(); }
    }
}

この例では、名前を設定するときに前後の空白を取り除いてから保存しています。

3-3. 自動実装プロパティとは

C#では、フィールドを明示的に書かなくてもプロパティを定義できます。これを自動実装プロパティといいます。

C#
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

この書き方では、内部的に値を保持するためのフィールドが自動的に用意されます。

値の検証や加工が不要な場合は、自動実装プロパティを使うとコードが短くなり、読みやすくなります。

C#
Person person = new Person();
person.Name = "田中";
person.Age = 25;

Console.WriteLine(person.Name);
Console.WriteLine(person.Age);

初心者のうちは、外部に公開したい値にはまず自動実装プロパティを使うと覚えておくとよいでしょう。

3-4. 読み取り専用プロパティ・private set・initの使い分け

プロパティには、読み書きの範囲を制限する書き方があります。

読み取り専用プロパティは、外部から値を変更させたくない場合に使います。

C#
class Person
{
    public string Name { get; }

    public Person(string name)
    {
        Name = name;
    }
}

この場合、Nameはコンストラクターで設定された後、外部から変更できません。

private setを使うと、外部からは読み取りだけ許可し、クラス内部からは変更できます。

C#
class Player
{
    public int Hp { get; private set; }

    public void Damage(int amount)
    {
        Hp -= amount;
    }
}

この場合、外部からHpを直接変更することはできませんが、Damageメソッドを通して内部で変更できます。

initを使うと、オブジェクトの初期化時だけ値を設定できます。

C#
class Person
{
    public string Name { get; init; }
    public int Age { get; init; }
}

使い方は次のようになります。

C#
Person person = new Person
{
    Name = "鈴木",
    Age = 30
};

初期化後に値を変えたくないデータには、initが便利です。

3-5. 値の検証や加工にプロパティを使う例

プロパティの大きな利点は、値の検証や加工を追加できることです。

たとえば、年齢にマイナス値を入れられないようにするには、次のように書けます。

C#
class Person
{
    private int _age;

    public int Age
    {
        get { return _age; }
        set
        {
            if (value < 0)
            {
                throw new ArgumentException("年齢は0以上で指定してください。");
            }

            _age = value;
        }
    }
}

このようにしておけば、外部から不正な値が渡されたときにエラーとして扱えます。

また、名前の空白を取り除くこともできます。

C#
class Person
{
    private string _name = "";

    public string Name
    {
        get { return _name; }
        set { _name = value.Trim(); }
    }
}

プロパティを使うと、単に値を入れるだけでなく、「正しい状態を保つためのルール」をクラスに持たせることができます。

3-6. フィールドではなくプロパティを使うべき理由

外部に値を公開するときは、フィールドではなくプロパティを使うのが基本です。

理由は、後から処理を追加しやすいからです。

最初は単純な自動実装プロパティで十分です。

C#
public int Age { get; set; }

後から値の検証が必要になったら、次のように変更できます。

C#
private int _age;

public int Age
{
    get { return _age; }
    set
    {
        if (value < 0)
        {
            throw new ArgumentException("年齢は0以上で指定してください。");
        }

        _age = value;
    }
}

外部からの使い方は同じです。

C#
person.Age = 20;

そのため、クラスの利用者に大きな影響を与えずに内部処理を変更できます。これがプロパティを使う大きなメリットです。

4. C#のメソッドとは？処理や振る舞いを定義するメンバ

メソッドは、クラスに処理や動作を定義するためのメンバです。

フィールドやプロパティが「値」を扱うのに対して、メソッドは「何かをする」ために使います。

たとえば、計算する、表示する、保存する、攻撃する、ログインする、といった動作はメソッドとして定義します。

4-1. メソッドの基本構文と呼び出し方

メソッドの基本構文は次のとおりです。

C#
アクセス修飾子 戻り値の型 メソッド名(引数)
{
    処理
}

例を見てみましょう。

C#
class Person
{
    public void SayHello()
    {
        Console.WriteLine("こんにちは");
    }
}

このSayHelloがメソッドです。

呼び出すときは、メソッド名の後ろに丸括弧を付けます。

C#
Person person = new Person();
person.SayHello();

プロパティはperson.Nameのように使いますが、メソッドはperson.SayHello()のように丸括弧を付けて呼び出します。

4-2. 引数と戻り値の考え方

メソッドには、引数と戻り値があります。

引数は、メソッドに渡す値です。

C#
public void SayHello(string name)
{
    Console.WriteLine($"こんにちは、{name}さん");
}

呼び出すときに値を渡します。

C#
person.SayHello("山田");

戻り値は、メソッドの処理結果として返す値です。

C#
public int Add(int a, int b)
{
    return a + b;
}

呼び出し側では、結果を受け取れます。

C#
int result = calculator.Add(3, 5);
Console.WriteLine(result); // 8

引数は「処理に必要な材料」、戻り値は「処理の結果」と考えると分かりやすいです。

4-3. voidメソッドと値を返すメソッドの違い

戻り値がないメソッドにはvoidを使います。

C#
public void ShowMessage()
{
    Console.WriteLine("メッセージを表示します");
}

このメソッドは画面に表示するだけで、呼び出し元に値を返しません。

一方、値を返すメソッドでは、戻り値の型を指定します。

C#
public int GetDouble(int number)
{
    return number * 2;
}

この場合、int型の値を返します。

C#
int value = GetDouble(10);
Console.WriteLine(value); // 20

使い分けはシンプルです。何かを実行するだけならvoid、結果を呼び出し元で使いたいなら戻り値のあるメソッドにします。

4-4. インスタンスメソッドとstaticメソッドの違い

メソッドにも、インスタンスメソッドとstaticメソッドがあります。

インスタンスメソッドは、オブジェクトを作成してから呼び出します。

C#
class Person
{
    public string Name { get; set; }

    public void Introduce()
    {
        Console.WriteLine($"私は{Name}です。");
    }
}

Person person = new Person();
person.Name = "佐藤";
person.Introduce();

このIntroduceは、個々のPersonオブジェクトが持つNameを使って処理します。

staticメソッドは、クラス名から直接呼び出します。

C#
class MathUtil
{
    public static int Add(int a, int b)
    {
        return a + b;
    }
}

int result = MathUtil.Add(3, 5);

staticメソッドは、特定のオブジェクトの状態に依存しない処理に向いています。

4-5. メソッドを使う場面と命名の考え方

メソッドは、処理や動作を表すときに使います。

たとえば次のような処理です。

メソッド名は、動作が分かるように動詞から始めるのが基本です。

C#
public void SaveUser()
{
    // ユーザーを保存する処理
}

public bool IsAdult()
{
    return Age >= 18;
}

C#では、メソッド名はPascalCaseで書くのが一般的です。sayHelloではなく、SayHelloのように書きます。

5. フィールド・プロパティ・メソッドの違いを比較

ここまで、フィールド、プロパティ、メソッドを個別に解説してきました。ここでは、それぞれの違いを整理します。

C# メンバを理解するときは、「値を持つのか」「値へのアクセスを制御するのか」「処理を実行するのか」で分けて考えると分かりやすくなります。

5-1. 役割の違い：データ保持・アクセス制御・処理実行

フィールド、プロパティ、メソッドの役割は次のように分けられます。

たとえば、Personクラスで考えると次のようになります。

C#
class Person
{
    private string _name;       // フィールド

    public string Name          // プロパティ
    {
        get { return _name; }
        set { _name = value; }
    }

    public void Introduce()     // メソッド
    {
        Console.WriteLine($"私は{Name}です。");
    }
}

_nameは内部で値を保持するためのフィールドです。Nameは外部から名前を扱うためのプロパティです。Introduceは自己紹介という処理を実行するメソッドです。

5-2. 書き方の違いをコードで比較

3つの書き方を並べて比較してみましょう。

C#
class Sample
{
    // フィールド
    private int _count;

    // プロパティ
    public int Count
    {
        get { return _count; }
        set { _count = value; }
    }

    // メソッド
    public void Increment()
    {
        _count++;
    }
}

自動実装プロパティを使うと、さらに短く書けます。

C#
class Sample
{
    public int Count { get; set; }

    public void Increment()
    {
        Count++;
    }
}

フィールドは値そのものを保持し、プロパティは値への入り口になり、メソッドは処理をまとめます。

5-3. アクセス方法の違い：変数のように使うか、呼び出すか

フィールドやプロパティは、変数のようにアクセスします。

C#
person.Name = "山田";
Console.WriteLine(person.Name);

一方、メソッドは丸括弧を付けて呼び出します。

C#
person.Introduce();

引数があるメソッドでは、丸括弧の中に値を渡します。

C#
person.SetAge(20);

初心者のうちは、「値を読む・書くならプロパティ」「何か処理を実行するならメソッド」と考えると判断しやすくなります。

5-4. 使い分け早見表

フィールド、プロパティ、メソッドの使い分けを早見表で整理します。

基本的には、内部の保存はフィールド、外部への公開はプロパティ、処理はメソッドと覚えておくとよいです。

5-5. 初心者がやりがちな間違いと正しい考え方

初心者がよくやりがちな間違いは、すべてをpublicフィールドにしてしまうことです。

C#
class Person
{
    public string name;
    public int age;
}

この書き方でも動きますが、外部から自由に値を変更できるため、安全な設計とはいえません。

よりよい書き方は、プロパティを使うことです。

C#
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

値の検証が必要な場合は、privateフィールドとプロパティを組み合わせます。

C#
class Person
{
    private int _age;

    public int Age
    {
        get { return _age; }
        set
        {
            if (value < 0)
            {
                throw new ArgumentException("年齢は0以上で指定してください。");
            }

            _age = value;
        }
    }
}

また、処理をプロパティに詰め込みすぎるのも避けましょう。重い計算、データベース保存、ファイル操作などは、プロパティではなくメソッドにするのが自然です。

6. C#メンバのアクセス修飾子を理解する

C#のメンバには、アクセス修飾子を付けられます。アクセス修飾子とは、そのメンバをどこから使えるかを決めるキーワードです。

代表的なものに、public、private、protected、internalがあります。

6-1. public・private・protected・internalの基本

主なアクセス修飾子の意味は次のとおりです。

初心者がまず覚えるべきなのは、publicとprivateです。

C#
class Person
{
    private string _name;

    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }
}

_nameはクラス内部だけで使うためprivate、Nameは外部から使いたいためpublicにしています。

6-2. フィールドはprivate、プロパティはpublicにする基本パターン

C#では、次のようなパターンがよく使われます。

C#
class Product
{
    private int _price;

    public int Price
    {
        get { return _price; }
        set
        {
            if (value < 0)
            {
                throw new ArgumentException("価格は0以上で指定してください。");
            }

            _price = value;
        }
    }
}

内部データである_priceはprivateにします。外部から読み書きする窓口であるPriceはpublicにします。

このようにすることで、外部から直接フィールドを書き換えられることを防ぎながら、必要な操作だけを許可できます。

6-3. カプセル化とは何か

カプセル化とは、オブジェクトの内部状態を外部から直接触れないようにし、決められた方法でのみ操作できるようにする考え方です。

たとえば、銀行口座を表すBankAccountクラスを考えます。

残高をpublicフィールドにすると、外部から自由に変更できてしまいます。

C#
class BankAccount
{
    public int balance;
}

これでは、次のような不自然な操作も可能です。

C#
account.balance = -100000;

安全にするには、フィールドをprivateにし、入金や出金のメソッドを通して操作します。

C#
class BankAccount
{
    private int _balance;

    public int Balance
    {
        get { return _balance; }
    }

    public void Deposit(int amount)
    {
        if (amount <= 0)
        {
            throw new ArgumentException("入金額は1以上で指定してください。");
        }

        _balance += amount;
    }
}

このように、内部の値を守りながら必要な操作だけを公開するのがカプセル化です。

6-4. アクセス修飾子を使った安全なクラス設計の例

アクセス修飾子を使った安全な設計例を見てみましょう。

C#
class BankAccount
{
    private int _balance;

    public int Balance
    {
        get { return _balance; }
    }

    public void Deposit(int amount)
    {
        if (amount <= 0)
        {
            throw new ArgumentException("入金額は1以上で指定してください。");
        }

        _balance += amount;
    }

    public void Withdraw(int amount)
    {
        if (amount <= 0)
        {
            throw new ArgumentException("出金額は1以上で指定してください。");
        }

        if (amount > _balance)
        {
            throw new InvalidOperationException("残高が不足しています。");
        }

        _balance -= amount;
    }
}

このクラスでは、残高を表す_balanceを外部から直接変更できません。外部からはDepositとWithdrawを通してのみ残高を変更できます。

このように、C# メンバに適切なアクセス修飾子を付けることで、クラスを安全に使いやすく設計できます。

7. 実例で学ぶC#メンバの使い方

ここでは、Personクラスを使って、フィールド、プロパティ、メソッドをまとめて確認します。

初心者のうちは、実際のコード全体を見ながら「どれがどのメンバなのか」を確認するのが効果的です。

7-1. Personクラスでフィールド・プロパティ・メソッドを定義する

次のクラスを作成します。

C#
class Person
{
    private string _name;
    private int _age;

    public string Name
    {
        get { return _name; }
        set
        {
            if (string.IsNullOrWhiteSpace(value))
            {
                throw new ArgumentException("名前を入力してください。");
            }

            _name = value;
        }
    }

    public int Age
    {
        get { return _age; }
        set
        {
            if (value < 0)
            {
                throw new ArgumentException("年齢は0以上で指定してください。");
            }

            _age = value;
        }
    }

    public void Introduce()
    {
        Console.WriteLine($"私の名前は{Name}です。{Age}歳です。");
    }
}

このクラスには、フィールド、プロパティ、メソッドが含まれています。

7-2. 値を保存するフィールドの例

次の部分がフィールドです。

C#
private string _name;
private int _age;

_nameは名前を保持し、_ageは年齢を保持します。

どちらもprivateなので、クラスの外から直接アクセスできません。

C#
Person person = new Person();
// person._name = "山田"; // エラー

フィールドはクラス内部でデータを保持するために使い、外部から直接操作させないのが基本です。

7-3. 外部から安全に値を読み書きするプロパティの例

次の部分がプロパティです。

C#
public string Name
{
    get { return _name; }
    set
    {
        if (string.IsNullOrWhiteSpace(value))
        {
            throw new ArgumentException("名前を入力してください。");
        }

        _name = value;
    }
}

外部からは次のように使えます。

C#
person.Name = "山田";
Console.WriteLine(person.Name);

空文字や空白だけの名前が渡された場合は、例外を発生させています。

C#
person.Name = "";

このように、プロパティを使うと外部から変数のように扱いつつ、内部で値のチェックを行えます。

7-4. オブジェクトの動作を表すメソッドの例

次の部分がメソッドです。

C#
public void Introduce()
{
    Console.WriteLine($"私の名前は{Name}です。{Age}歳です。");
}

このメソッドは、Personオブジェクトの自己紹介を表示します。

呼び出すときは、丸括弧を付けます。

C#
person.Introduce();

メソッドは、オブジェクトが行う動作や処理を表すときに使います。

7-5. サンプルコード全体と実行結果

最後に、実行できるサンプルコード全体を見てみましょう。

C#
using System;

class Person
{
    private string _name;
    private int _age;

    public string Name
    {
        get { return _name; }
        set
        {
            if (string.IsNullOrWhiteSpace(value))
            {
                throw new ArgumentException("名前を入力してください。");
            }

            _name = value;
        }
    }

    public int Age
    {
        get { return _age; }
        set
        {
            if (value < 0)
            {
                throw new ArgumentException("年齢は0以上で指定してください。");
            }

            _age = value;
        }
    }

    public void Introduce()
    {
        Console.WriteLine($"私の名前は{Name}です。{Age}歳です。");
    }
}

class Program
{
    static void Main()
    {
        Person person = new Person();

        person.Name = "山田太郎";
        person.Age = 25;

        person.Introduce();
    }
}

実行結果は次のようになります。

私の名前は山田太郎です。25歳です。

この例では、_nameと_ageがフィールド、NameとAgeがプロパティ、Introduceがメソッドです。

8. C#メンバを使い分ける判断基準

C# メンバを正しく使い分けるには、それぞれの役割を意識することが大切です。

初心者のうちは、難しく考えすぎる必要はありません。まずは「値を保存する」「値を公開する」「処理を実行する」の3つに分けて考えましょう。

8-1. 値を内部で保持したいならフィールド

クラスの内部だけで値を保持したい場合は、フィールドを使います。

C#
private int _count;
private string _message;

ただし、外部から直接アクセスさせたいからといってpublicフィールドにするのは避けましょう。

C#
public int Count; // 基本的には避ける

内部で使う値はprivateフィールドとして定義し、必要に応じてプロパティやメソッドを通して扱います。

8-2. 外部に値を公開・制御したいならプロパティ

外部から値を読み書きしたい場合は、プロパティを使います。

C#
public string Name { get; set; }
public int Age { get; set; }

値の検証が不要なら、自動実装プロパティで十分です。

値の検証が必要なら、privateフィールドと組み合わせます。

C#
private int _age;

public int Age
{
    get { return _age; }
    set
    {
        if (value < 0)
        {
            throw new ArgumentException("年齢は0以上で指定してください。");
        }

        _age = value;
    }
}

外部に見せる値は、基本的にフィールドではなくプロパティにしましょう。

8-3. 何らかの処理を実行したいならメソッド

何かの処理を実行したい場合は、メソッドを使います。

C#
public void Save()
{
    // 保存処理
}

public int CalculateTotal()
{
    // 合計計算
    return 100;
}

特に、次のような処理はメソッドにするのが自然です。

プロパティは値の取得や設定に使い、処理の実行はメソッドにするのが基本です。

8-4. staticにするべきかインスタンスメンバにするべきか

C#のメンバには、staticを付けられるものがあります。staticを付けると、そのメンバはオブジェクトではなくクラスに属します。

インスタンスごとに異なる値や動作が必要なら、インスタンスメンバにします。

C#
class Person
{
    public string Name { get; set; }

    public void Introduce()
    {
        Console.WriteLine($"私は{Name}です。");
    }
}

この場合、Nameは人ごとに異なるため、インスタンスメンバが適しています。

一方、オブジェクトの状態に依存しない共通処理なら、staticメンバが向いています。

C#
class Calculator
{
    public static int Add(int a, int b)
    {
        return a + b;
    }
}

呼び出しは次のようになります。

C#
int result = Calculator.Add(10, 20);

判断基準は、「そのメンバが個々のオブジェクトの状態を使うかどうか」です。使うならインスタンスメンバ、使わないならstaticメンバを検討します。

8-5. 初心者向けの実務的な使い分けルール

初心者向けに、実務で使いやすいルールをまとめると次のようになります。

最初は、次の形を基本パターンとして覚えるとよいです。

C#
class Sample
{
    private int _value;

    public int Value
    {
        get { return _value; }
        set { _value = value; }
    }

    public void DoSomething()
    {
        // 処理
    }
}

慣れてきたら、自動実装プロパティ、読み取り専用プロパティ、private set、initなどを使い分けていきましょう。

9. C#メンバに関するよくある質問

ここでは、C# メンバについて初心者が疑問に感じやすい点をQ&A形式で整理します。

9-1. C#のメンバには何がありますか？

C#のメンバには、フィールド、プロパティ、メソッド、コンストラクター、定数、イベント、インデクサー、演算子、入れ子型などがあります。

初心者が最初に理解すべきなのは、フィールド、プロパティ、メソッド、コンストラクターです。

フィールドは値を保持し、プロパティは値へのアクセスを制御し、メソッドは処理を実行します。コンストラクターは、オブジェクトを作成するときの初期化に使います。

9-2. メンバ変数とフィールドは同じ意味ですか？

ほぼ同じ意味で使われることがありますが、C#の正式な用語としてはフィールドと呼ぶのが適切です。

「メンバ変数」は、クラスに属する変数を表す一般的な言い方です。C#では、クラスや構造体に直接定義された変数のようなメンバをフィールドと呼びます。

C#
class Sample
{
    private int _number;
}

この_numberはフィールドです。

9-3. フィールドとプロパティはどちらを使うべきですか？

外部に公開する値には、基本的にプロパティを使うべきです。

フィールドはクラス内部で値を保持するために使います。外部から直接アクセスさせると、不正な値が入る可能性があります。

C#
private int _age;

public int Age
{
    get { return _age; }
    set
    {
        if (value < 0)
        {
            throw new ArgumentException("年齢は0以上で指定してください。");
        }

        _age = value;
    }
}

値の検証や制御が必要な場合、プロパティを使うことで安全に扱えます。

9-4. プロパティとメソッドはどう使い分けますか？

プロパティは、値の取得や設定に使います。メソッドは、何らかの処理を実行するときに使います。

C#
public string Name { get; set; } // プロパティ

public void Save()
{
    // 保存処理
}

外から見て「値」として扱いたいものはプロパティにします。動作や処理として呼び出したいものはメソッドにします。

たとえば、AgeやNameはプロパティに向いています。一方、Save()、CalculateTotal()、Introduce()などはメソッドに向いています。

9-5. staticメンバとは何ですか？

staticメンバとは、オブジェクトではなくクラスそのものに属するメンバです。

通常のインスタンスメンバは、オブジェクトを作成してから使います。

C#
Person person = new Person();
person.Name = "山田";

staticメンバは、クラス名から直接アクセスします。

C#
class Counter
{
    public static int Count;
}

Counter.Count = 10;

すべてのインスタンスで共有したい値や、オブジェクトの状態に依存しない処理にstaticを使います。

C#
class MathUtil
{
    public static int Add(int a, int b)
    {
        return a + b;
    }
}

9-6. コンストラクターはメンバに含まれますか？

はい、コンストラクターはC#のメンバに含まれます。

コンストラクターは、オブジェクトを作成するときに実行される特別なメンバです。主に初期化処理に使います。

C#
class Person
{
    public string Name { get; }

    public Person(string name)
    {
        Name = name;
    }
}

このPerson(string name)がコンストラクターです。

呼び出しは、newを使ってオブジェクトを作成するときに行われます。

C#
Person person = new Person("山田");

コンストラクターは戻り値の型を書かず、クラス名と同じ名前にするのが特徴です。

まとめ

C#のメンバとは、クラスや構造体の中に定義される要素の総称です。代表的なメンバには、フィールド、プロパティ、メソッド、コンストラクターなどがあります。

フィールドは、クラス内部でデータを保持するためのメンバです。外部から直接触らせるのではなく、基本的にはprivateにして使います。

プロパティは、値の取得や設定を制御するためのメンバです。外からは変数のように使えますが、内部ではgetやsetを通して処理できます。外部に値を公開したい場合は、フィールドではなくプロパティを使うのが基本です。

メソッドは、処理や振る舞いを定義するためのメンバです。計算する、表示する、保存する、検証するなど、何らかの動作を表す場合に使います。

C# メンバの使い分けは、次のように整理できます。

初心者のうちは、「フィールドは内部の値」「プロパティは外部との窓口」「メソッドは処理」と覚えると分かりやすいです。

C#のクラス設計では、メンバを適切に使い分けることが重要です。フィールド、プロパティ、メソッドの違いを理解できれば、読みやすく安全なコードを書けるようになります。