C# ローカル変数とは？宣言方法・スコープ・初期化を初心者向けに徹底解説

はじめに

C#を学び始めると、かなり早い段階で登場するのが「ローカル変数」です。

ローカル変数は、メソッドの中や処理の途中で一時的に値を保存するために使う変数です。たとえば、計算結果を入れておく、ユーザー名を一時的に保持する、条件分岐の判定結果を保存する、といった場面でよく使われます。

C#のプログラムでは、変数を正しく使えないと、コンパイルエラーが発生したり、思った通りに処理が動かなかったりします。特に初心者がつまずきやすいのが、ローカル変数の「宣言」「初期化」「スコープ」です。

この記事では、C#のローカル変数とは何か、宣言方法、初期化、スコープ、よくあるエラー、ベストプラクティスまで初心者向けにわかりやすく解説します。

1. C#のローカル変数とは

1-1. ローカル変数の基本的な意味

C#のローカル変数とは、メソッドやブロックの中で宣言され、その範囲内だけで使える変数のことです。

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

C#
void ShowMessage()
{
    string message = "こんにちは";
    Console.WriteLine(message);
}

このコードでは、message がローカル変数です。

message は ShowMessage メソッドの中で宣言されているため、このメソッドの中でだけ使えます。メソッドの外から message を参照することはできません。

ローカル変数は、処理の途中で必要になる値を一時的に保存するための入れ物だと考えると理解しやすいです。

1-2. ローカル変数が使われる場面

ローカル変数は、C#のプログラムの中で非常によく使われます。

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

C#
void Calculate()
{
    int price = 1000;
    int tax = 100;
    int total = price + tax;

    Console.WriteLine(total);
}

この例では、price、tax、total がローカル変数です。

商品の価格、税額、合計金額をそれぞれ一時的に保存しています。このように、計算の途中結果をわかりやすく保持するためにローカル変数を使います。

また、条件分岐でもよく使われます。

C#
void CheckAge()
{
    int age = 20;
    bool isAdult = age >= 18;

    if (isAdult)
    {
        Console.WriteLine("成人です");
    }
}

この場合、age と isAdult がローカル変数です。

1-3. フィールド・プロパティ・引数との違い

C#には、ローカル変数以外にも値を扱う仕組みがあります。代表的なものに、フィールド、プロパティ、引数があります。

ローカル変数は、メソッドやブロックの中で一時的に使う変数です。

C#
void Method()
{
    int count = 10;
}

一方、フィールドはクラスの中に直接宣言され、複数のメソッドから使える変数です。

C#
class Sample
{
    private int count;

    void SetCount()
    {
        count = 10;
    }
}

プロパティは、外部から値を取得したり設定したりするために使われます。

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

引数は、メソッドを呼び出すときに外部から渡される値です。

C#
void ShowName(string name)
{
    Console.WriteLine(name);
}

それぞれの違いを簡単にまとめると、ローカル変数は「処理の中だけで使う一時的な値」、フィールドは「オブジェクトが持つ値」、プロパティは「外部からアクセスするための値」、引数は「メソッドに渡される値」です。

1-4. 初心者が混同しやすいポイント

初心者が混同しやすいのは、ローカル変数とフィールドの違いです。

たとえば、次のコードを見てください。

C#
class Sample
{
    int number = 10;

    void Method()
    {
        int number = 20;
        Console.WriteLine(number);
    }
}

クラスの中にある number はフィールドです。一方、Method の中にある number はローカル変数です。

この場合、Console.WriteLine(number); で表示されるのは、メソッド内で宣言されたローカル変数の 20 です。

同じ名前が使われていると混乱しやすいため、初心者のうちはフィールドとローカル変数で同じ名前を使わない方が読みやすくなります。

2. C#でローカル変数を宣言する方法

2-1. 基本的な宣言構文

C#でローカル変数を宣言する基本構文は次の通りです。

C#
データ型 変数名;

たとえば、整数を入れるローカル変数を宣言する場合は次のように書きます。

C#
int count;

文字列を入れる場合は次のように書きます。

C#
string name;

ただし、C#ではローカル変数を宣言しただけでは、まだ値が入っていない状態です。使用する前に値を代入する必要があります。

C#
int count;
count = 10;

Console.WriteLine(count);

2-2. データ型を指定して宣言する方法

C#では、ローカル変数を宣言するときにデータ型を指定します。

C#
int age = 25;
double price = 1200.5;
string name = "田中";
bool isActive = true;

それぞれの意味は次の通りです。

int は整数を扱う型です。

C#
int score = 80;

double は小数を扱う型です。

C#
double height = 170.5;

string は文字列を扱う型です。

C#
string message = "こんにちは";

bool は真偽値を扱う型です。

C#
bool isLogin = false;

このように、ローカル変数には保存したい値に合ったデータ型を指定します。

2-3. varを使って宣言する方法

C#では、var を使ってローカル変数を宣言することもできます。

C#
var age = 25;
var name = "佐藤";
var isActive = true;

var を使うと、右辺の値からコンパイラが型を推論します。

たとえば、次のコードでは age は int 型になります。

C#
var age = 25;

次のコードでは name は string 型になります。

C#
var name = "佐藤";

ただし、var は「何でも入れられる型」ではありません。一度型が決まると、別の型の値は代入できません。

C#
var number = 10;
// number = "文字列"; // エラー

var は便利ですが、初心者のうちは型がわかりにくくなる場合もあります。コードの読みやすさを考えて使うことが大切です。

2-4. 複数のローカル変数を宣言する方法

同じ型のローカル変数であれば、1行で複数宣言できます。

C#
int x, y, z;

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

C#
int x = 10, y = 20, z = 30;

ただし、初心者には次のように1行ずつ書く方法がおすすめです。

C#
int x = 10;
int y = 20;
int z = 30;

1行ずつ書いた方が、それぞれの変数の意味がわかりやすく、後から修正しやすくなります。

また、違う型の変数をまとめて宣言することはできません。

C#
// int age, string name; // エラー

型が違う場合は、それぞれ別々に宣言します。

C#
int age = 20;
string name = "山田";

2-5. 宣言時によく使うデータ型の例

C#のローカル変数でよく使うデータ型には、次のようなものがあります。

C#
int count = 10;
long population = 125000000L;
double rate = 3.14;
decimal price = 1200.50m;
char grade = 'A';
string name = "鈴木";
bool isFinished = true;

int は整数、double は小数、decimal は金額など精度が重要な数値、string は文字列、bool は条件判定によく使われます。

金額を扱う場合は、double よりも decimal が使われることがあります。

C#
decimal totalPrice = 1980.50m;

C#では、扱う値の種類に応じて適切な型を選ぶことが重要です。

3. ローカル変数の初期化とは

3-1. 初期化の意味

初期化とは、変数に最初の値を設定することです。

たとえば、次のコードでは count を宣言すると同時に 0 を代入しています。

C#
int count = 0;

この 0 を設定することが初期化です。

ローカル変数は、宣言しただけでは値が入っていません。そのため、値を使う前に必ず初期化する必要があります。

C#
int number;
number = 10;

Console.WriteLine(number);

この例では、number = 10; によって初期化されています。

3-2. 宣言と同時に初期化する方法

もっとも一般的なのは、ローカル変数を宣言すると同時に初期化する方法です。

C#
int age = 20;
string name = "田中";
bool isMember = true;

この書き方は、変数の型、名前、初期値が1行でわかるため、読みやすいコードになります。

計算結果を初期値として設定することもできます。

C#
int price = 1000;
int tax = 100;
int total = price + tax;

メソッドの戻り値を使って初期化することもできます。

C#
DateTime now = DateTime.Now;

宣言と同時に初期化できる場合は、この書き方を使うと安全です。

3-3. 宣言後に値を代入する方法

ローカル変数は、宣言した後で値を代入することもできます。

C#
int score;
score = 90;

条件によって値を変えたい場合に使われることがあります。

C#
int fee;

bool isMember = true;

if (isMember)
{
    fee = 500;
}
else
{
    fee = 1000;
}

Console.WriteLine(fee);

この例では、isMember の値によって fee に代入される値が変わります。

ただし、どの条件でも必ず値が代入されるように書く必要があります。そうしないと、未初期化のローカル変数を使おうとしてエラーになります。

3-4. 初期化しないまま使うとどうなるか

C#では、初期化されていないローカル変数を使用するとコンパイルエラーになります。

C#
int number;
Console.WriteLine(number); // エラー

このコードでは、number に値が代入されていないため、使用できません。

エラーメッセージとしては、次のような内容が表示されます。

C#
未割り当てのローカル変数 'number' が使用されました

これは、ローカル変数には自動的に初期値が入らないためです。

安全に書くには、次のように初期値を設定します。

C#
int number = 0;
Console.WriteLine(number);

3-5. デフォルト値とローカル変数の関係

C#の型には、それぞれデフォルト値があります。

たとえば、int のデフォルト値は 0、bool のデフォルト値は false、参照型のデフォルト値は null です。

C#
int number = default;
bool flag = default;
string text = default;

この場合、number は 0、flag は false、text は null になります。

ただし、ローカル変数を単に宣言しただけでは、自動的にデフォルト値が使えるわけではありません。

C#
int number;
// Console.WriteLine(number); // エラー

デフォルト値を使いたい場合は、明示的に default を代入します。

C#
int number = default;
Console.WriteLine(number);

ローカル変数では、「宣言しただけ」と「デフォルト値で初期化した」は別物だと覚えておきましょう。

4. C#のローカル変数のスコープ

4-1. スコープとは何か

スコープとは、変数を使える範囲のことです。

C#では、ローカル変数を宣言した場所によって、その変数を参照できる範囲が決まります。

C#
void Method()
{
    int number = 10;
    Console.WriteLine(number);
}

この例では、number は Method メソッドの中で宣言されています。そのため、Method の中でだけ使えます。

メソッドの外で使おうとするとエラーになります。

C#
void Method()
{
    int number = 10;
}

// Console.WriteLine(number); // エラー

スコープを理解することは、C#のローカル変数を正しく使ううえで非常に重要です。

4-2. メソッド内でのローカル変数の有効範囲

メソッド内で宣言されたローカル変数は、基本的に宣言された位置から、そのブロックの終わりまで使えます。

C#
void Method()
{
    int number = 10;

    Console.WriteLine(number);
}

この場合、number は宣言された後の行で使えます。

ただし、宣言より前では使えません。

C#
void Method()
{
    // Console.WriteLine(number); // エラー

    int number = 10;
}

C#では、ローカル変数は宣言より前に参照できません。コードは上から順に読まれるため、変数を使う前に宣言しておく必要があります。

4-3. if文・for文・while文内のスコープ

if 文の中で宣言したローカル変数は、その if ブロックの中でだけ使えます。

C#
void Method()
{
    if (true)
    {
        int number = 10;
        Console.WriteLine(number);
    }

    // Console.WriteLine(number); // エラー
}

number は { } の中で宣言されているため、ブロックの外では使えません。

for 文でも同じです。

C#
void Method()
{
    for (int i = 0; i < 3; i++)
    {
        Console.WriteLine(i);
    }

    // Console.WriteLine(i); // エラー
}

for 文の中で宣言した i は、for 文の中でだけ使えます。

while 文の中で宣言した変数も、ブロックの外からは参照できません。

C#
void Method()
{
    int count = 0;

    while (count < 3)
    {
        string message = "処理中";
        Console.WriteLine(message);

        count++;
    }

    // Console.WriteLine(message); // エラー
}

4-4. ブロック外から参照できない理由

ブロック外からローカル変数を参照できないのは、その変数がブロックの中だけで有効だからです。

C#
if (true)
{
    int result = 100;
}

// Console.WriteLine(result); // エラー

このように、result は if ブロックの中でしか存在しないものとして扱われます。

ブロックの外でも値を使いたい場合は、ブロックの外で変数を宣言します。

C#
int result;

if (true)
{
    result = 100;
}

Console.WriteLine(result);

ただし、この書き方では、すべての条件で確実に値が代入されるように注意する必要があります。

C#
int result;

bool condition = false;

if (condition)
{
    result = 100;
}

// Console.WriteLine(result); // エラーになる可能性がある

この場合、condition が false だと result に値が代入されないため、エラーになります。

4-5. 同じ名前の変数を宣言できる場合・できない場合

C#では、同じスコープ内に同じ名前のローカル変数を宣言することはできません。

C#
void Method()
{
    int number = 10;
    // int number = 20; // エラー
}

同じ名前を使うと、どちらの変数を指しているのかわかりにくくなるためです。

また、外側のスコープにあるローカル変数と同じ名前を、内側のブロックで宣言することも基本的にはできません。

C#
void Method()
{
    int number = 10;

    if (true)
    {
        // int number = 20; // エラー
    }
}

一方、別々のブロックでスコープが重ならない場合は、同じ名前を使えることがあります。

C#
void Method()
{
    if (true)
    {
        int number = 10;
        Console.WriteLine(number);
    }

    if (true)
    {
        int number = 20;
        Console.WriteLine(number);
    }
}

この場合、2つの number はそれぞれ別のブロック内で宣言されており、スコープが重ならないため使用できます。

5. ローカル変数の寿命とメモリ上の考え方

5-1. ローカル変数が作られるタイミング

ローカル変数は、その変数を含む処理が実行されるときに用意されます。

C#
void Method()
{
    int count = 0;
    Console.WriteLine(count);
}

この場合、Method が呼び出されると、count というローカル変数が使える状態になります。

ただし、厳密なメモリ上の扱いは、コンパイラや実行環境によって最適化されることがあります。初心者の段階では、「メソッドが実行される間、一時的に使われる値」と考えるとよいでしょう。

5-2. ローカル変数が使えなくなるタイミング

ローカル変数は、そのスコープを抜けると使えなくなります。

C#
void Method()
{
    int number = 10;
    Console.WriteLine(number);
}

この場合、Method の処理が終わると、number は使えなくなります。

ブロック内で宣言したローカル変数も同じです。

C#
void Method()
{
    if (true)
    {
        string message = "こんにちは";
        Console.WriteLine(message);
    }

    // message はここでは使えない
}

message は if ブロックの中でだけ使えるため、ブロックを抜けると参照できません。

5-3. 値型と参照型での扱いの違い

C#には、値型と参照型があります。

int、double、bool、struct などは値型です。

C#
int a = 10;
int b = a;

b = 20;

Console.WriteLine(a); // 10
Console.WriteLine(b); // 20

この例では、b = a; によって a の値がコピーされます。そのため、b を変更しても a は変わりません。

一方、string、配列、クラスなどは参照型です。

C#
int[] numbers1 = { 1, 2, 3 };
int[] numbers2 = numbers1;

numbers2[0] = 100;

Console.WriteLine(numbers1[0]); // 100

この例では、numbers1 と numbers2 が同じ配列を参照しています。そのため、numbers2 から配列の中身を変更すると、numbers1 から見た値も変わります。

ローカル変数であっても、値型か参照型かによって、代入時の動きが変わる点に注意しましょう。

5-4. メモリ管理を初心者向けに理解する

ローカル変数のメモリ管理について、初心者はまず難しく考えすぎる必要はありません。

基本的には、ローカル変数は必要な範囲で作られ、スコープを抜けると使えなくなると理解すれば十分です。

値型のローカル変数は、値そのものを扱うイメージです。

C#
int count = 10;

参照型のローカル変数は、実際のデータそのものではなく、データがある場所への参照を持っているイメージです。

C#
string name = "田中";

ただし、C#にはガベージコレクションという仕組みがあり、不要になったオブジェクトは自動的に回収されます。そのため、通常のアプリケーション開発では、メモリ解放を細かく手動で行う必要はありません。

初心者のうちは、「ローカル変数はスコープ内だけで使える一時的な名前」と考えると理解しやすいです。

6. ローカル変数の具体的な使用例

6-1. 数値を扱うローカル変数の例

数値を扱うローカル変数は、計算処理でよく使われます。

C#
void CalculateTotal()
{
    int price = 1500;
    int quantity = 3;
    int total = price * quantity;

    Console.WriteLine(total);
}

この例では、price に単価、quantity に数量、total に合計金額を保存しています。

ローカル変数を使うことで、計算式の意味がわかりやすくなります。

C#
int total = price * quantity;

単に 1500 * 3 と書くよりも、何を計算しているのかが明確になります。

6-2. 文字列を扱うローカル変数の例

文字列を扱う場合は、string 型のローカル変数を使います。

C#
void ShowUserName()
{
    string firstName = "太郎";
    string lastName = "山田";
    string fullName = lastName + firstName;

    Console.WriteLine(fullName);
}

この例では、名字と名前を結合してフルネームを作っています。

文字列補間を使うと、より読みやすく書けます。

C#
void ShowUserName()
{
    string firstName = "太郎";
    string lastName = "山田";
    string fullName = $"{lastName} {firstName}";

    Console.WriteLine(fullName);
}

string 型のローカル変数は、メッセージ作成や画面表示などでよく使われます。

6-3. 条件分岐で使うローカル変数の例

条件分岐では、判定結果をローカル変数に入れておくと、コードが読みやすくなります。

C#
void CheckScore()
{
    int score = 85;
    bool isPassed = score >= 60;

    if (isPassed)
    {
        Console.WriteLine("合格です");
    }
    else
    {
        Console.WriteLine("不合格です");
    }
}

この例では、score >= 60 の結果を isPassed に保存しています。

条件式を直接 if に書くこともできます。

C#
if (score >= 60)
{
    Console.WriteLine("合格です");
}

ただし、条件の意味を明確にしたい場合は、isPassed のようなローカル変数を使うと読みやすくなります。

6-4. 繰り返し処理で使うローカル変数の例

繰り返し処理では、カウンターや合計値を保存するローカル変数がよく使われます。

C#
void SumNumbers()
{
    int total = 0;

    for (int i = 1; i <= 5; i++)
    {
        total += i;
    }

    Console.WriteLine(total);
}

この例では、total が合計値を保持するローカル変数です。i は for 文の中で使われるカウンター変数です。

total += i; は、次のコードと同じ意味です。

C#
total = total + i;

繰り返し処理では、途中経過を保持するためにローカル変数を使うことが多いです。

6-5. メソッド内で計算結果を保持する例

メソッド内で計算結果を一度ローカル変数に保存してから返すこともよくあります。

C#
int CalculateTaxIncludedPrice(int price)
{
    double taxRate = 0.1;
    int tax = (int)(price * taxRate);
    int total = price + tax;

    return total;
}

この例では、taxRate、tax、total がローカル変数です。

ローカル変数を使わずに、次のように1行で書くこともできます。

C#
return price + (int)(price * 0.1);

しかし、計算の意味をわかりやすくするには、途中結果に名前を付けた方が読みやすくなります。

C#
int tax = (int)(price * taxRate);
int total = price + tax;

ローカル変数は、処理を分解して理解しやすくするためにも役立ちます。

7. ローカル変数でよくあるエラーと対処法

7-1. 「未割り当てのローカル変数が使用されました」の原因

C#初心者がよく見るエラーのひとつが、「未割り当てのローカル変数が使用されました」です。

原因は、ローカル変数に値を代入する前に使っていることです。

C#
void Method()
{
    int number;
    Console.WriteLine(number); // エラー
}

この場合、number に値が入っていないため、表示できません。

対処法は、使用する前に必ず値を代入することです。

C#
void Method()
{
    int number = 0;
    Console.WriteLine(number);
}

条件分岐で代入する場合も注意が必要です。

C#
void Method()
{
    int number;
    bool condition = false;

    if (condition)
    {
        number = 10;
    }

    // Console.WriteLine(number); // エラー
}

condition が false の場合、number に値が代入されません。

この場合は、最初に初期値を設定しておくと安全です。

C#
int number = 0;

7-2. スコープ外の変数を参照したときのエラー

スコープ外のローカル変数を参照するとエラーになります。

C#
void Method()
{
    if (true)
    {
        int value = 100;
    }

    // Console.WriteLine(value); // エラー
}

value は if ブロック内で宣言されているため、ブロックの外では使えません。

ブロックの外でも使いたい場合は、外側で宣言します。

C#
void Method()
{
    int value = 0;

    if (true)
    {
        value = 100;
    }

    Console.WriteLine(value);
}

ただし、外側で宣言するとスコープが広くなります。必要以上に広いスコープは、コードの見通しを悪くする原因になります。

7-3. 型が一致しない場合のエラー

ローカル変数には、宣言した型に合った値しか代入できません。

C#
int age = "20"; // エラー

この例では、age は int 型ですが、代入している "20" は文字列です。

正しくは次のように書きます。

C#
int age = 20;

文字列として扱いたい場合は、string 型にします。

C#
string ageText = "20";

文字列を数値に変換したい場合は、int.Parse などを使います。

C#
string text = "20";
int age = int.Parse(text);

ただし、変換できない文字列を指定すると実行時エラーになるため、実務では int.TryParse を使うことも多いです。

C#
string text = "20";

if (int.TryParse(text, out int age))
{
    Console.WriteLine(age);
}

7-4. var使用時に起こりやすいミス

var を使うと、型を明示しなくてもローカル変数を宣言できます。

C#
var number = 10;

この場合、number は int 型です。

しかし、var を使うときは、右辺から型を判断できる必要があります。

C#
// var value; // エラー

var は宣言と同時に初期化しなければなりません。

また、null だけでは型を判断できないため、次のようなコードもエラーになります。

C#
// var text = null; // エラー

この場合は、型を明示します。

C#
string? text = null;

また、var は動的に型が変わるものではありません。

C#
var value = 10;
// value = "abc"; // エラー

最初に int 型として決まったため、後から文字列は代入できません。

7-5. エラーを防ぐ書き方のコツ

ローカル変数に関するエラーを防ぐには、次のような書き方を意識しましょう。

まず、使用する前に必ず初期化します。

C#
int count = 0;

次に、変数は必要な範囲だけで宣言します。

C#
if (true)
{
    string message = "こんにちは";
    Console.WriteLine(message);
}

また、型がわかりにくい場合は var ではなく明示的な型を書きます。

C#
Dictionary<string, int> scores = new Dictionary<string, int>();

変数名も重要です。

C#
int totalPrice = 1000;

x や data のような曖昧な名前よりも、totalPrice のように意味がわかる名前を付けると、エラーや勘違いを減らせます。

8. ローカル変数を書くときのベストプラクティス

8-1. わかりやすい変数名を付ける

ローカル変数には、役割がわかる名前を付けましょう。

悪い例です。

C#
int x = 1000;
int y = 200;
int z = x + y;

これでは、x、y、z が何を表しているのかわかりにくいです。

良い例です。

C#
int price = 1000;
int tax = 200;
int totalPrice = price + tax;

こちらは、価格、税額、合計金額であることがすぐにわかります。

変数名は少し長くなっても、意味が伝わる名前にすることが大切です。

8-2. 必要な範囲だけで宣言する

ローカル変数は、必要な範囲だけで宣言するのが基本です。

たとえば、if ブロックの中だけで使う変数なら、if ブロックの中で宣言します。

C#
if (isLogin)
{
    string message = "ログイン中です";
    Console.WriteLine(message);
}

ブロックの外で使わない変数を外側で宣言すると、どこで使われるのかがわかりにくくなります。

C#
string message;

if (isLogin)
{
    message = "ログイン中です";
    Console.WriteLine(message);
}

必要以上にスコープを広げると、変数の状態を追いかけるのが難しくなります。ローカル変数は、できるだけ狭い範囲で使うのが読みやすいコードにつながります。

8-3. 使う直前に宣言する

ローカル変数は、使う直前に宣言すると読みやすくなります。

あまり良くない例です。

C#
int total;
string message;
bool isValid;

int price = 1000;
int tax = 100;

total = price + tax;
message = "合計金額を表示します";
isValid = total > 0;

Console.WriteLine(message);
Console.WriteLine(total);

昔のプログラミング言語では、変数を先頭にまとめて宣言する書き方がよく使われました。しかし、C#では使う場所の近くで宣言する方が一般的です。

改善例です。

C#
int price = 1000;
int tax = 100;
int total = price + tax;

string message = "合計金額を表示します";
Console.WriteLine(message);

bool isValid = total > 0;

if (isValid)
{
    Console.WriteLine(total);
}

使う直前に宣言すると、その変数が何のためにあるのか理解しやすくなります。

8-4. varを使うべき場面と避けるべき場面

var は便利ですが、使いどころを考える必要があります。

右辺を見れば型が明らかな場合は、var を使っても読みやすいです。

C#
var name = "田中";
var count = 10;
var user = new User();

特に、右辺で new User() のように型がはっきりわかる場合は、var を使っても問題ありません。

C#
var user = new User();

一方、右辺だけでは型がわかりにくい場合は、明示的に型を書いた方が読みやすいです。

C#
var result = GetData();

この場合、GetData() が何を返すのかすぐにはわかりません。

型を明示すると、読み手に親切です。

C#
List<string> result = GetData();

初心者のうちは、型を理解するためにも明示的に書くことをおすすめします。慣れてきたら、読みやすさを基準に var を使い分けましょう。

8-5. コードを読みやすく保つポイント

ローカル変数を使うときは、コード全体の読みやすさを意識しましょう。

まず、変数名は意味が伝わるものにします。

C#
int userCount = 5;

次に、不要なローカル変数は作らないようにします。

C#
int result = price + tax;
Console.WriteLine(result);

このように、計算結果に意味がある場合はローカル変数にすると読みやすくなります。

一方、単純に一度しか使わない値で、変数名を付けても意味が増えない場合は、直接書いてもよいことがあります。

C#
Console.WriteLine(price + tax);

また、ローカル変数のスコープはできるだけ狭くします。使わなくなった後も参照できる状態にしておくと、コードの理解が難しくなるからです。

読みやすいコードを書くためには、「この変数は何を表しているのか」「どこで使われるのか」「本当に必要なのか」を意識することが大切です。

9. C#のローカル変数に関するよくある質問

9-1. ローカル変数とメンバー変数の違いは？

ローカル変数は、メソッドやブロックの中で宣言され、その範囲内だけで使える変数です。

C#
void Method()
{
    int localNumber = 10;
}

一方、メンバー変数は、クラスのメンバーとして宣言される変数です。一般的にはフィールドのことを指す場合が多いです。

C#
class Sample
{
    private int memberNumber = 10;
}

ローカル変数は一時的な処理に使い、メンバー変数はオブジェクトの状態を保持するために使います。

9-2. ローカル変数は初期化が必須？

ローカル変数は、使用する前に必ず初期化が必要です。

宣言だけならできます。

C#
int number;

しかし、値を代入しないまま使うことはできません。

C#
int number;
// Console.WriteLine(number); // エラー

使用する前に値を代入すれば問題ありません。

C#
int number;
number = 10;

Console.WriteLine(number);

安全で読みやすくするには、宣言と同時に初期化するのがおすすめです。

C#
int number = 10;

9-3. varで宣言すると型はどう決まる？

var で宣言したローカル変数の型は、右辺の値からコンパイラが自動的に決めます。

C#
var number = 10;

この場合、number は int 型です。

C#
var text = "こんにちは";

この場合、text は string 型です。

var は型を書かなくてよいだけで、型が存在しないわけではありません。また、後から別の型に変わることもありません。

C#
var value = 100;
// value = "文字列"; // エラー

最初に int 型として決まったため、文字列は代入できません。

9-4. ローカル変数はメソッドの外で使える？

ローカル変数は、メソッドの外では使えません。

C#
void Method()
{
    int number = 10;
}

// number はここでは使えない

ローカル変数は、そのメソッドやブロックの中だけで有効です。

メソッドの外でも値を使いたい場合は、戻り値として返すか、フィールドやプロパティを使います。

C#
int GetNumber()
{
    int number = 10;
    return number;
}

このようにすれば、メソッドの外側で戻り値を受け取ることができます。

C#
int result = GetNumber();
Console.WriteLine(result);

9-5. constやreadonlyはローカル変数で使える？

ローカル変数では、const を使うことができます。

C#
void Method()
{
    const double TaxRate = 0.1;
    int price = 1000;
    int tax = (int)(price * TaxRate);

    Console.WriteLine(tax);
}

const は定数を表します。一度決めた値は変更できません。

C#
const int MaxCount = 10;
// MaxCount = 20; // エラー

一方、readonly はローカル変数には使えません。readonly は主にフィールドに対して使います。

C#
class Sample
{
    private readonly int maxCount = 10;
}

ローカル変数で変更不可の値を扱いたい場合は、const を使えるか検討します。ただし、const はコンパイル時に値が決まるものに使います。

実行時に値が決まる場合は、通常のローカル変数として宣言し、その後変更しないようにコードを書くのが一般的です。

まとめ

C#のローカル変数は、メソッドやブロックの中で一時的に値を保存するための変数です。計算結果を保持したり、条件判定の結果を保存したり、繰り返し処理の途中経過を管理したりする場面で頻繁に使われます。

ローカル変数を使うときは、まず宣言方法を理解することが大切です。

C#
int count = 0;
string name = "田中";
bool isActive = true;

C#では、ローカル変数は使用する前に必ず初期化する必要があります。宣言しただけのローカル変数をそのまま使うと、「未割り当てのローカル変数が使用されました」というエラーになります。

また、ローカル変数にはスコープがあります。メソッド内で宣言した変数はそのメソッド内で、if 文や for 文などのブロック内で宣言した変数はそのブロック内でだけ使えます。

C#
if (true)
{
    int number = 10;
    Console.WriteLine(number);
}

// number はここでは使えない

ローカル変数を書くときは、わかりやすい変数名を付け、必要な範囲だけで宣言し、使う直前に初期化することを意識しましょう。

var は便利ですが、型がわかりにくくなる場合もあります。初心者のうちは、型を明示して書き、慣れてきたら読みやすさを基準に var を使い分けるのがおすすめです。

C#のローカル変数は、プログラミングの基本であり、読みやすく安全なコードを書くために欠かせない要素です。宣言、初期化、スコープの3つをしっかり理解しておくことで、C#のコードをより正確に書けるようになります。