C#のメンバ変数とは？フィールドとの違い・書き方・使い方を初心者向けに解説

はじめに

C#を学び始めると、「メンバ変数」という言葉を目にすることがあります。クラスの中に書かれている変数のように見えるものですが、ローカル変数やプロパティとの違いがわかりにくく、初心者が混乱しやすいポイントです。

C#では、一般的に「メンバ変数」というよりも「フィールド」という呼び方がよく使われます。ただし、プログラミング学習サイトや他の言語の解説では「メンバ変数」という表現もよく登場します。

この記事では、C#のメンバ変数とは何か、フィールドとの違い、書き方、使い方、プロパティとの使い分けまで、初心者向けにわかりやすく解説します。

1. C#のメンバ変数とは？まずは意味を初心者向けに解説

1-1. メンバ変数とはクラスや構造体に属する変数のこと

メンバ変数とは、クラスや構造体の中に定義される変数のことです。

C#では、クラスの中にデータを保持するための変数を書くことができます。たとえば、人物を表すPersonクラスであれば、名前や年齢を保持する変数をクラスの中に用意します。

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

このnameやageのように、クラスに属している変数がメンバ変数です。

「メンバ」とは、クラスを構成する要素のことです。C#のクラスには、フィールド、メソッド、プロパティ、コンストラクターなど、さまざまなメンバがあります。その中で、値を保持するための変数がメンバ変数と呼ばれることがあります。

1-2. C#では「メンバ変数」より「フィールド」という呼び方が一般的

C#では、「メンバ変数」という言い方よりも「フィールド」という用語が一般的です。

たとえば、次のようなクラス内の変数は、C#ではフィールドと呼ばれます。

C#
class Product
{
    private string name;
    private int price;
}

このnameとpriceは、クラスの中に直接宣言されている変数です。C#の正式な用語としては「フィールド」と考えるとよいでしょう。

一方で、他のプログラミング言語では「メンバ変数」という言葉がよく使われます。そのため、C#の解説でも「メンバ変数」という言葉が使われることがあります。

初心者のうちは、次のように理解しておくとわかりやすいです。

C#のメンバ変数 ≒ フィールド

厳密な場面では「フィールド」と呼ぶのが適切ですが、学習中はほぼ同じ意味として扱われることが多いです。

1-3. メンバ変数が使われる場面と役割

メンバ変数は、クラス内で状態やデータを保持するために使います。

たとえば、ゲームのキャラクターを表すクラスを考えてみましょう。

C#
class Player
{
    private string name;
    private int hp;
}

この例では、nameはプレイヤー名、hpは体力を表します。これらの値は、プレイヤーというオブジェクトが持つ状態です。

メンバ変数を使うことで、オブジェクトごとに異なるデータを保持できます。たとえば、プレイヤーAはHPが100、プレイヤーBはHPが50というように、それぞれ別の値を持つことができます。

メンバ変数の主な役割は次のとおりです。

・クラス内で使うデータを保持する
・オブジェクトの状態を表す
・メソッド間で共有したい値を保持する
・インスタンスごとに異なる値を持たせる

1-4. ローカル変数との違い

メンバ変数と混同しやすいものに、ローカル変数があります。

ローカル変数は、メソッドの中で宣言される変数です。

C#
class Sample
{
    private int count; // メンバ変数

    void Show()
    {
        int number = 10; // ローカル変数
        Console.WriteLine(number);
    }
}

この例では、countがメンバ変数で、numberがローカル変数です。

メンバ変数はクラスに属しているため、クラス内の複数のメソッドから使えます。一方、ローカル変数は宣言されたメソッドの中でしか使えません。

C#
class Counter
{
    private int count;

    void Add()
    {
        count++;
    }

    void Show()
    {
        Console.WriteLine(count);
    }
}

このように、countはメンバ変数なので、AddメソッドでもShowメソッドでも使えます。

一方、メソッド内で宣言したローカル変数は、そのメソッドの処理が終わると基本的に使えなくなります。

2. C#におけるメンバ変数とフィールドの違い

2-1. フィールドとは何か

フィールドとは、クラスまたは構造体の中に直接宣言される変数のことです。

C#
class Car
{
    private string model;
    private int speed;
}

このmodelとspeedがフィールドです。

フィールドは、オブジェクトのデータを保持するために使われます。クラスの外から直接使わせることもできますが、通常はprivateにして、外部からはプロパティやメソッドを通してアクセスする設計がよく使われます。

C#
class Car
{
    private int speed;

    public void Accelerate()
    {
        speed += 10;
    }
}

このように、フィールドはクラスの内部状態を表す重要な要素です。

2-2. メンバ変数とフィールドはほぼ同じ意味で使われる

C#において、メンバ変数という言葉はフィールドを指して使われることが多いです。

C#
class User
{
    private string userName;
}

このuserNameは、C#の用語ではフィールドです。しかし、「Userクラスのメンバ変数」と説明されることもあります。

つまり、初心者向けに言えば、次のように考えて問題ありません。

メンバ変数：クラスに属する変数を広く指す言い方
フィールド：C#で正式によく使われる呼び方

C#の学習を進める場合は、「メンバ変数」という言葉を見たら「フィールドのことだな」と理解するとスムーズです。

2-3. プロパティとの違い

C#では、フィールドと似たものにプロパティがあります。

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

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

nameはフィールド、Nameはプロパティです。

フィールドは実際に値を保持する変数です。一方、プロパティは外部から値を取得したり設定したりするための窓口として使われます。

より簡潔に書くと、次のような自動実装プロパティも使えます。

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

この場合、見た目はフィールドのように使えますが、実際にはプロパティです。

C#
Person person = new Person();
person.Name = "田中";
Console.WriteLine(person.Name);

C#では、外部に公開するデータにはフィールドではなくプロパティを使うのが一般的です。

2-4. 初心者が混同しやすい用語の整理

C#のメンバ変数を理解するうえで、次の用語を整理しておきましょう。

フィールド：
クラスや構造体の中に直接宣言される変数

メンバ変数：
クラスに属する変数を指す一般的な言い方
C#では主にフィールドを意味することが多い

ローカル変数：
メソッドの中で宣言される変数

プロパティ：
外部から値を取得・設定するための仕組み

メンバ：
クラスを構成する要素の総称
フィールド、メソッド、プロパティなどが含まれる

特に重要なのは、C#では「メンバ変数」という言葉より「フィールド」という言葉を覚えておくことです。

3. C#のメンバ変数の書き方

3-1. 基本的な宣言方法

C#のメンバ変数、つまりフィールドは、クラスの中に次のように書きます。

C#
class クラス名
{
    アクセス修飾子 型 変数名;
}

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

C#
class Student
{
    private string name;
    private int score;
}

この例では、nameとscoreがメンバ変数です。

フィールドはメソッドの外、クラスの中に書きます。

C#
class Student
{
    private string name; // フィールド

    void SetName()
    {
        string localName = "佐藤"; // ローカル変数
    }
}

nameはクラス直下にあるためフィールドです。localNameはメソッド内にあるためローカル変数です。

3-2. 型・変数名・初期値の書き方

メンバ変数には、型と変数名を指定します。

C#
private int age;
private string name;
private bool isActive;

必要に応じて、宣言と同時に初期値を設定することもできます。

C#
class Player
{
    private int hp = 100;
    private string name = "名無し";
    private bool isAlive = true;
}

初期値を指定しない場合、フィールドには型に応じた既定値が入ります。

int       → 0
double    → 0
bool      → false
string    → null
参照型    → null

たとえば、次のように書いた場合、countには0が入ります。

C#
class Counter
{
    private int count;
}

ただし、初心者のうちは、意図がわかりやすいように必要な初期値を明示することをおすすめします。

3-3. アクセス修飾子を使った書き方

C#のメンバ変数には、アクセス修飾子を付けることができます。

よく使われるアクセス修飾子は次のとおりです。

private：
同じクラス内からのみアクセスできる

public：
どこからでもアクセスできる

protected：
同じクラスまたは派生クラスからアクセスできる

internal：
同じアセンブリ内からアクセスできる

基本的に、フィールドはprivateにすることが多いです。

C#
class Account
{
    private int balance;
}

publicフィールドにすると、クラスの外から直接値を変更できてしまいます。

C#
class Account
{
    public int balance;
}

この場合、外部から次のように自由に書き換えられます。

C#
Account account = new Account();
account.balance = -1000;

残高にマイナスの値が入るなど、想定外の状態を防ぎにくくなります。そのため、フィールドはprivateにし、必要に応じてプロパティやメソッドを使って操作するのが一般的です。

3-4. 命名規則とよく使われる書き方

C#では、フィールド名の付け方にも一定の慣習があります。

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

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

また、アンダースコアを付けずにcamelCaseで書く場合もあります。

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

プロパティ名はPascalCaseで書くのが一般的です。

C#
class Person
{
    private string _name;

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

このように、フィールドとプロパティを見分けやすくするために、命名規則を決めておくとコードが読みやすくなります。

変数名は、意味がわかる名前にすることも大切です。

C#
private int x;      // 何を表すかわかりにくい
private int score;  // 点数だとわかりやすい

C#のメンバ変数は、クラスの状態を表す重要なものなので、役割が伝わる名前を付けましょう。

4. C#のメンバ変数の使い方

4-1. クラス内で値を保持する

メンバ変数の基本的な使い方は、クラス内で値を保持することです。

C#
class Counter
{
    private int count = 0;

    public void Add()
    {
        count++;
    }

    public void Show()
    {
        Console.WriteLine(count);
    }
}

この例では、countがメンバ変数です。Addメソッドで値を増やし、Showメソッドで現在の値を表示しています。

C#
Counter counter = new Counter();
counter.Add();
counter.Add();
counter.Show();

実行すると、countの値は2になります。

メンバ変数は、メソッドが終わっても値を保持できます。そのため、オブジェクトの状態を管理したいときに使います。

4-2. メソッドからメンバ変数を参照・変更する

メンバ変数は、同じクラス内のメソッドから参照したり変更したりできます。

C#
class Player
{
    private int hp = 100;

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

    public void Heal(int amount)
    {
        hp += amount;
    }

    public void ShowHp()
    {
        Console.WriteLine($"HP: {hp}");
    }
}

この例では、hpというメンバ変数を、DamageメソッドとHealメソッドで変更しています。

C#
Player player = new Player();
player.Damage(30);
player.Heal(10);
player.ShowHp();

このように、メンバ変数はクラス内の複数のメソッドで共有される値として使えます。

4-3. インスタンスごとに異なる値を持たせる

通常のメンバ変数は、インスタンスごとに別々の値を持ちます。

C#
class Character
{
    private string name;

    public Character(string name)
    {
        this.name = name;
    }

    public void ShowName()
    {
        Console.WriteLine(name);
    }
}

このクラスから複数のインスタンスを作ると、それぞれが別のnameを持ちます。

C#
Character hero = new Character("勇者");
Character wizard = new Character("魔法使い");

hero.ShowName();
wizard.ShowName();

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

勇者
魔法使い

同じCharacterクラスから作られたオブジェクトでも、メンバ変数の値はインスタンスごとに異なります。

4-4. コンストラクターで初期化する

メンバ変数は、コンストラクターで初期化することがよくあります。

C#
class Book
{
    private string title;
    private int price;

    public Book(string title, int price)
    {
        this.title = title;
        this.price = price;
    }

    public void ShowInfo()
    {
        Console.WriteLine($"{title}: {price}円");
    }
}

コンストラクターを使うと、オブジェクトを作るときに必要な値を設定できます。

C#
Book book = new Book("C#入門", 2500);
book.ShowInfo();

このように、メンバ変数はクラスの状態を保持し、コンストラクターやメソッドを通して値を設定・変更していきます。

thisは、現在のインスタンス自身を表します。引数名とフィールド名が同じ場合、this.titleのように書くことで、フィールドを明確に指定できます。

5. メンバ変数の種類

5-1. インスタンスフィールド

インスタンスフィールドとは、インスタンスごとに値を持つフィールドです。

C#
class Dog
{
    private string name;

    public Dog(string name)
    {
        this.name = name;
    }

    public void Bark()
    {
        Console.WriteLine($"{name}が吠えました");
    }
}

nameはインスタンスフィールドです。

C#
Dog dog1 = new Dog("ポチ");
Dog dog2 = new Dog("タロウ");

dog1.Bark();
dog2.Bark();

dog1とdog2は、それぞれ異なるnameを持ちます。

C#のメンバ変数として最も基本的なのが、このインスタンスフィールドです。

5-2. staticフィールド

staticフィールドは、インスタンスではなくクラスに属するフィールドです。

C#
class User
{
    public static int Count = 0;

    public User()
    {
        Count++;
    }
}

この例では、CountはUserクラス全体で共有されます。

C#
User user1 = new User();
User user2 = new User();

Console.WriteLine(User.Count);

実行すると、2と表示されます。

通常のフィールドはインスタンスごとに別々ですが、staticフィールドはクラスに1つだけ存在します。そのため、全インスタンスで共有したい値に使います。

ただし、staticフィールドはどこからでも共有される値になりやすいため、使いすぎるとコードの流れが追いにくくなります。

5-3. readonlyフィールド

readonlyフィールドは、初期化後に値を変更できないフィールドです。

C#
class Employee
{
    private readonly int id;

    public Employee(int id)
    {
        this.id = id;
    }

    public void ShowId()
    {
        Console.WriteLine(id);
    }
}

readonlyフィールドは、宣言時またはコンストラクター内で値を設定できます。

C#
class Sample
{
    private readonly int value = 10;

    public Sample()
    {
        // コンストラクター内でも設定できる
    }
}

一度設定した後は変更できないため、オブジェクト作成後に変わってほしくない値を保持するのに便利です。

たとえば、社員ID、作成日時、設定値などに使われることがあります。

5-4. const定数

constは、コンパイル時に決まる定数を表します。

C#
class MathConstants
{
    public const double Pi = 3.14159;
}

constで宣言した値は、後から変更できません。

C#
Console.WriteLine(MathConstants.Pi);

constは暗黙的にstaticのように扱われ、インスタンスを作らずにクラス名からアクセスできます。

ただし、constにできるのは、コンパイル時に値が決まるものです。実行時に決まる値には使えません。

C#
public const int MaxCount = 100;

一方、コンストラクターで値を決めたい場合はreadonlyを使います。

C#
private readonly int maxCount;

初心者のうちは、固定値にはconst、インスタンス作成時に決める変更不可の値にはreadonlyと覚えるとよいでしょう。

5-5. privateフィールドとpublicフィールド

フィールドには、privateやpublicなどのアクセス修飾子を付けられます。

C#
class Sample
{
    private int privateValue;
    public int publicValue;
}

privateValueはクラスの外から直接アクセスできません。

C#
Sample sample = new Sample();
// sample.privateValue = 10; // エラー

一方、publicValueは外部から直接アクセスできます。

C#
sample.publicValue = 10;

しかし、C#ではpublicフィールドを安易に使うことはあまり推奨されません。理由は、外部から自由に値を書き換えられるためです。

基本的には、フィールドはprivateにし、必要に応じてプロパティを使って外部に公開します。

6. メンバ変数とプロパティの使い分け

6-1. 基本的にはフィールドをprivateにする

C#では、メンバ変数であるフィールドは基本的にprivateにします。

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

フィールドをprivateにすることで、クラスの外から直接変更できないようにできます。

外部から直接フィールドを変更できると、クラスが想定していない値が入る可能性があります。

C#
class Person
{
    public int age;
}

このようにpublicにすると、次のようなコードが書けてしまいます。

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

年齢がマイナスになるのは不自然です。このような不正な値を防ぐためにも、フィールドはprivateにするのが基本です。

6-2. 外部から値を扱う場合はプロパティを使う

外部から値を取得したり設定したりしたい場合は、プロパティを使います。

C#
class Person
{
    private int age;

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

この例では、Ageプロパティを通してageフィールドにアクセスしています。

C#
Person person = new Person();
person.Age = 20;
Console.WriteLine(person.Age);

プロパティを使うことで、値を設定するときにチェック処理を入れられます。

自動実装プロパティを使うこともできます。

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

単純に値を保持するだけでよい場合は、自動実装プロパティが便利です。

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

カプセル化とは、クラスの内部データを外部から直接触れないようにし、必要な操作だけを公開する考え方です。

C#では、フィールドをprivateにし、プロパティやメソッドを通して操作することでカプセル化を実現します。

C#
class BankAccount
{
    private int balance;

    public int Balance
    {
        get { return balance; }
    }

    public void Deposit(int amount)
    {
        if (amount > 0)
        {
            balance += amount;
        }
    }
}

この例では、balanceフィールドは外部から直接変更できません。残高を増やすにはDepositメソッドを使います。

C#
BankAccount account = new BankAccount();
account.Deposit(1000);
Console.WriteLine(account.Balance);

このようにすると、マイナスの入金など不正な操作を防ぎやすくなります。

6-4. get・setを使った安全な値の管理

プロパティには、値を取得するgetと、値を設定するsetがあります。

C#
class Product
{
    private int price;

    public int Price
    {
        get
        {
            return price;
        }
        set
        {
            if (value >= 0)
            {
                price = value;
            }
        }
    }
}

getは値を返す処理、setは値を設定する処理です。setの中では、設定される値をvalueという名前で受け取れます。

読み取り専用にしたい場合は、setを書かない方法もあります。

C#
class Product
{
    private int price;

    public int Price
    {
        get { return price; }
    }
}

また、外部からは読み取りだけ可能で、クラス内からだけ変更できるようにするには、private setを使います。

C#
class Product
{
    public int Price { get; private set; }

    public Product(int price)
    {
        Price = price;
    }
}

C#では、フィールドを直接公開するよりも、プロパティを使って安全に値を管理する設計がよく使われます。

7. C#のメンバ変数を使ったサンプルコード

7-1. 基本的なメンバ変数のサンプル

まずは、基本的なメンバ変数のサンプルです。

C#
using System;

class Counter
{
    private int count = 0;

    public void Add()
    {
        count++;
    }

    public void Show()
    {
        Console.WriteLine($"count = {count}");
    }
}

class Program
{
    static void Main()
    {
        Counter counter = new Counter();

        counter.Add();
        counter.Add();
        counter.Show();
    }
}

このコードでは、Counterクラスにcountというメンバ変数があります。

Addメソッドを呼び出すたびにcountの値が増え、Showメソッドで現在の値を表示します。

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

count = 2

countはローカル変数ではなくメンバ変数なので、Addメソッドの処理が終わった後も値が保持されます。

7-2. privateフィールドとpublicプロパティのサンプル

次に、privateフィールドとpublicプロパティを組み合わせたサンプルです。

C#
using System;

class Person
{
    private string name;
    private int age;

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

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

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

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

        Console.WriteLine($"{person.Name}さんは{person.Age}歳です");
    }
}

この例では、nameとageはprivateフィールドです。外部から直接アクセスするのではなく、NameとAgeプロパティを通して値を扱います。

Ageプロパティでは、0以上の値だけを設定するようにしています。このように、プロパティを使うと値のチェックができます。

7-3. staticフィールドのサンプル

次は、staticフィールドのサンプルです。

C#
using System;

class User
{
    private static int count = 0;

    public User()
    {
        count++;
    }

    public static void ShowCount()
    {
        Console.WriteLine($"ユーザー数: {count}");
    }
}

class Program
{
    static void Main()
    {
        User user1 = new User();
        User user2 = new User();
        User user3 = new User();

        User.ShowCount();
    }
}

この例では、countはstaticフィールドです。Userインスタンスが作成されるたびに、countが増えます。

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

ユーザー数: 3

staticフィールドは、インスタンスごとではなくクラス全体で共有されます。

7-4. readonlyフィールドのサンプル

最後に、readonlyフィールドのサンプルです。

C#
using System;

class Order
{
    private readonly int orderId;

    public Order(int orderId)
    {
        this.orderId = orderId;
    }

    public void ShowOrderId()
    {
        Console.WriteLine($"注文ID: {orderId}");
    }
}

class Program
{
    static void Main()
    {
        Order order = new Order(1001);
        order.ShowOrderId();
    }
}

この例では、orderIdがreadonlyフィールドです。コンストラクターで値を設定した後は、変更できません。

注文IDのように、作成後に変わってほしくない値にはreadonlyが向いています。

8. メンバ変数を使うときの注意点

8-1. publicフィールドを安易に使わない

C#でメンバ変数を使うときは、publicフィールドを安易に使わないようにしましょう。

C#
class Player
{
    public int hp;
}

このように書くと、外部から自由に値を変更できます。

C#
Player player = new Player();
player.hp = -999;

HPがマイナスになるなど、不正な状態を防ぎにくくなります。

安全に管理するには、フィールドをprivateにして、プロパティやメソッドを使います。

C#
class Player
{
    private int hp = 100;

    public int Hp
    {
        get { return hp; }
    }

    public void Damage(int amount)
    {
        if (amount > 0)
        {
            hp -= amount;
        }
    }
}

このようにすることで、外部から直接hpを書き換えられなくなります。

8-2. 初期化忘れに注意する

メンバ変数は、初期化しなくても既定値が入ります。しかし、その既定値が意図した値とは限りません。

C#
class User
{
    private string name;

    public void ShowName()
    {
        Console.WriteLine(name);
    }
}

この場合、nameには初期値としてnullが入ります。nullを想定していない処理を書くと、エラーの原因になることがあります。

必要な値は、宣言時やコンストラクターで初期化しましょう。

C#
class User
{
    private string name = "未設定";
}

または、コンストラクターで初期化します。

C#
class User
{
    private string name;

    public User(string name)
    {
        this.name = name;
    }
}

初期化忘れを防ぐことは、C#のメンバ変数を安全に使ううえで重要です。

8-3. staticフィールドの使いすぎに注意する

staticフィールドは便利ですが、使いすぎには注意が必要です。

C#
class AppSettings
{
    public static string CurrentUserName;
}

staticフィールドは、プログラム全体で共有される値になりやすいため、どこで変更されたのか追いにくくなることがあります。

特に、複数の場所から値を書き換える設計にすると、バグの原因になります。

C#
AppSettings.CurrentUserName = "田中";
AppSettings.CurrentUserName = "佐藤";

小さなサンプルでは便利に見えますが、実際の開発では状態管理が複雑になる場合があります。

staticフィールドは、定数や共有する必要が明確な値に限定して使うとよいでしょう。

8-4. 変数名は役割がわかる名前にする

メンバ変数は、クラスの状態を表すため、名前が非常に重要です。

C#
private int a;
private string b;

このような名前では、何を表しているのか分かりにくくなります。

C#
private int score;
private string userName;

このように、役割がわかる名前を付けると、コードが読みやすくなります。

また、真偽値にはisやhasを付けると意味が伝わりやすくなります。

C#
private bool isActive;
private bool hasPermission;

C#では、メンバ変数だけでなく、ローカル変数やプロパティにもわかりやすい名前を付けることが大切です。

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

9-1. C#でメンバ変数という言い方は正しい？

C#で「メンバ変数」という言い方がまったく間違いというわけではありません。

ただし、C#の用語としては「フィールド」と呼ぶのが一般的です。

C#
class Sample
{
    private int value;
}

このvalueは、C#ではフィールドです。学習サイトなどでは「メンバ変数」と説明されることもあります。

初心者のうちは、次のように理解しておけば問題ありません。

C#でメンバ変数と書かれていたら、ほとんどの場合フィールドのこと

実務や公式な説明では「フィールド」という言葉に慣れておくとよいでしょう。

9-2. メンバ変数とグローバル変数は違う？

メンバ変数とグローバル変数は違います。

メンバ変数は、クラスや構造体に属する変数です。

C#
class Sample
{
    private int value;
}

一方、グローバル変数は、プログラム全体から参照できる変数を指す言葉です。

C#では、C言語のような意味でのグローバル変数は基本的に使いません。C#では、値はクラスや構造体の中に定義します。

ただし、public staticフィールドを使うと、グローバル変数に近い使い方ができてしまいます。

C#
class GlobalData
{
    public static int Value;
}

このような書き方は便利な反面、どこからでも変更できるため注意が必要です。

9-3. フィールドと変数は何が違う？

変数は、値を入れるための入れ物全般を指す広い言葉です。

フィールドは、その中でもクラスや構造体に属する変数です。

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

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

fieldValueはフィールドであり、変数の一種です。localValueも変数ですが、メソッド内にあるためローカル変数です。

つまり、次のように整理できます。

変数：値を保持するもの全般
フィールド：クラスや構造体に属する変数
ローカル変数：メソッド内で使う変数

C#のメンバ変数を理解するには、「フィールドは変数の一種」と考えるとわかりやすいです。

9-4. メンバ変数はどこに書けばいい？

メンバ変数は、クラスの中、メソッドの外に書きます。

C#
class Sample
{
    private int count; // ここに書く

    public void Add()
    {
        count++;
    }
}

メソッドの中に書くと、それはメンバ変数ではなくローカル変数になります。

C#
class Sample
{
    public void Add()
    {
        int count = 0; // ローカル変数
        count++;
    }
}

一般的には、フィールドはクラスの上のほうにまとめて書くことが多いです。

C#
class Sample
{
    private int count;
    private string name;

    public Sample()
    {
    }

    public void Method()
    {
    }
}

ただし、チームやプロジェクトによって書き方のルールが決まっている場合もあります。その場合は、プロジェクトのコーディング規約に従いましょう。

まとめ

C#のメンバ変数とは、クラスや構造体に属する変数のことです。C#では、一般的に「メンバ変数」よりも「フィールド」という呼び方がよく使われます。

メンバ変数は、クラス内でデータや状態を保持するために使います。メソッド内で宣言するローカル変数とは異なり、クラス内の複数のメソッドから参照・変更できます。また、通常のフィールドはインスタンスごとに異なる値を持ちます。

C#のメンバ変数を書くときは、基本的にprivateフィールドとして宣言し、外部から扱う必要がある場合はプロパティを使うのが一般的です。これにより、クラスの内部状態を安全に管理できます。

重要なポイントを整理すると、次のようになります。

・C#のメンバ変数は、主にフィールドのことを指す
・フィールドはクラスや構造体の中、メソッドの外に書く
・ローカル変数はメソッドの中で使う変数
・フィールドは基本的にprivateにする
・外部から値を扱う場合はプロパティを使う
・staticフィールドはクラス全体で共有される
・readonlyは初期化後に変更できない
・constはコンパイル時に決まる定数

C#のメンバ変数を正しく理解すると、クラスの状態管理やオブジェクト指向プログラミングの理解が深まります。まずは、フィールド、ローカル変数、プロパティの違いを意識しながら、シンプルなクラスを作って練習してみましょう。