C#のステートメントとは？初心者向けに種類・書き方・式との違いをわかりやすく解説

はじめに

C#を学び始めると、必ず出てくるのが「ステートメント」という言葉です。日本語では「文」と訳されることが多く、プログラムの中で何らかの処理を実行するための基本単位を指します。

たとえば、変数を宣言する、値を代入する、条件によって処理を分ける、繰り返し処理を行う、メソッドから値を返すといった操作は、C#ではステートメントとして書かれます。

しかし初心者にとっては、「ステートメント」「式」「命令」「コード行」などの言葉が似ていて、違いがわかりにくいことがあります。

この記事では、C#のステートメントとは何かを初心者向けにわかりやすく解説します。基本的な書き方、式との違い、よく使うステートメントの種類、つまずきやすいポイント、練習用のサンプルコードまで順番に見ていきましょう。

1. C#のステートメントとは？

C#のステートメントとは、プログラムに対して「何を実行するか」を指示する文のことです。

C#のコードは、クラス、メソッド、式、ステートメントなど、さまざまな要素で構成されています。その中でもステートメントは、実際の処理の流れを作る重要な役割を持っています。

1-1. ステートメントは「処理の命令」を表す単位

ステートメントは、簡単に言えば「処理の命令」です。

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

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

このコードには、2つのステートメントがあります。

C#
int number = 10;

これは、numberという変数を宣言し、10を代入するステートメントです。

C#
Console.WriteLine(number);

これは、numberの値を画面に表示するステートメントです。

このように、C#では1つひとつの処理をステートメントとして記述します。

1-2. C#プログラムにおけるステートメントの役割

C#プログラムでは、ステートメントが上から順番に実行されます。

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

Console.WriteLine(total);

このコードでは、次の順番で処理が進みます。

1. priceに1000を代入する

2. taxに100を代入する

3. price + taxの結果をtotalに代入する

4. totalを画面に表示する

つまり、ステートメントはプログラムの処理手順を表すものです。

また、if文やfor文のように、処理の流れを変えるステートメントもあります。これらを使うことで、条件分岐や繰り返し処理を実現できます。

1-3. 初心者が混同しやすい「文」「命令」「コード行」の違い

ステートメントは日本語で「文」と呼ばれます。ただし、初心者のうちは「命令」や「コード行」と混同しやすいため注意が必要です。

「文」は、C#の文法上の処理単位です。多くの場合、セミコロン;で終わります。

「命令」は、プログラムに何かをさせる指示という意味で使われることが多いです。厳密な文法用語というより、説明のための言葉です。

「コード行」は、エディタ上の1行を指すことが多いです。ただし、C#では1つのステートメントを複数行に分けて書くこともできますし、1行に複数のステートメントを書くこともできます。

たとえば、次のコードは1つのステートメントを複数行に分けています。

C#
int total =
    100 +
    200;

見た目は3行ですが、ステートメントとしては1つです。

反対に、次のように1行に2つのステートメントを書くこともできます。

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

このように、「コード行」と「ステートメント」は必ずしも同じではありません。

1-4. ステートメントの基本例

C#のステートメントには、さまざまな種類があります。基本的な例を見てみましょう。

C#
int age = 20;

これは変数を宣言するステートメントです。

C#
age = 21;

これは変数に値を代入するステートメントです。

C#
Console.WriteLine(age);

これはメソッドを呼び出すステートメントです。

C#
if (age >= 20)
{
    Console.WriteLine("成人です");
}

これは条件によって処理を分けるステートメントです。

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

これは繰り返し処理を行うステートメントです。

C#では、このようなステートメントを組み合わせてプログラムを作っていきます。

2. C#のステートメントの基本的な書き方

C#のステートメントには、基本的な書き方のルールがあります。特に初心者が最初に覚えるべきポイントは、セミコロン、波かっこ、インデント、改行です。

2-1. セミコロンで終わるステートメント

C#では、多くのステートメントの最後にセミコロン;を付けます。

C#
int number = 10;
Console.WriteLine(number);
number = 20;

セミコロンは、「ここで1つの文が終わります」という目印です。

セミコロンを忘れると、コンパイルエラーになります。

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

このコードでは、int number = 10の後にセミコロンがないためエラーになります。

ただし、すべてのステートメントにセミコロンが必要なわけではありません。if文やfor文のように、波かっこでブロックを持つステートメントでは、通常ステートメント全体の最後にセミコロンは付けません。

C#
if (number > 0)
{
    Console.WriteLine("正の数です");
}

このように、セミコロンが必要な文と不要な文を区別することが大切です。

2-2. 波かっこで囲むブロック文

複数のステートメントをまとめるときは、波かっこ{ }を使います。

C#
{
    int x = 10;
    int y = 20;
    Console.WriteLine(x + y);
}

このように、波かっこで囲まれた部分をブロックと呼びます。

if文、for文、while文、try-catch文などでは、処理のまとまりをブロックとして書くことがよくあります。

C#
if (score >= 80)
{
    Console.WriteLine("合格です");
    Console.WriteLine("よくできました");
}

波かっこを使うことで、「条件が成立したときに実行する処理はここからここまで」と明確にできます。

ステートメントが1つだけの場合、波かっこを省略することもできます。

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

ただし、初心者のうちは波かっこを省略しない書き方がおすすめです。後から処理を追加したときのミスを防ぎやすくなります。

2-3. インデントと改行の考え方

C#では、改行やインデントの位置が変わっても、基本的にはプログラムの意味は変わりません。

たとえば、次の2つのコードは同じ意味です。

C#
int x = 10;
int y = 20;
Console.WriteLine(x + y);

C#
int x = 10; int y = 20; Console.WriteLine(x + y);

しかし、後者は読みにくいため、実際の開発ではおすすめされません。

読みやすいコードを書くためには、ブロックの中をインデントすることが重要です。

C#
if (x > 0)
{
    Console.WriteLine("xは正の数です");
}

インデントをそろえると、どの処理がどのブロックに属しているかがわかりやすくなります。

C#では、コンパイラがインデントを文法として判断するわけではありません。しかし、人間がコードを読むうえでは非常に重要です。

2-4. 1行に複数のステートメントを書く場合の注意点

C#では、セミコロンで区切れば1行に複数のステートメントを書くことができます。

C#
int a = 10; int b = 20; Console.WriteLine(a + b);

このコードは文法上は有効です。

しかし、1行に複数のステートメントを書くと、処理の流れがわかりにくくなります。特に初心者のうちは、1行に1つのステートメントを書くのが基本です。

C#
int a = 10;
int b = 20;
Console.WriteLine(a + b);

このように書くと、処理の順番が明確になり、エラーが起きた場所も見つけやすくなります。

3. C#のステートメントと式の違い

C#を学ぶときに混乱しやすいのが、「ステートメント」と「式」の違いです。

簡単に言うと、式は値を作るもの、ステートメントは処理を実行するものです。

3-1. 式とは「値を返すもの」

式とは、評価されると値になるものです。

たとえば、次のようなものは式です。

C#
1 + 2

この式は評価されると3になります。

C#
age >= 20

この式は評価されるとtrueまたはfalseになります。

C#
name

変数名も式として扱われます。変数に入っている値を表すからです。

C#
GetPrice()

メソッド呼び出しも、戻り値がある場合は式として扱えます。

つまり、式は「結果として何らかの値を持つもの」です。

3-2. ステートメントとは「処理を実行するもの」

ステートメントは、プログラム内で実行される処理の単位です。

C#
int total = 100 + 200;

このステートメントの中には、100 + 200という式が含まれています。

式だけを見ると、100 + 200は300という値を返します。しかし、それだけではプログラム上の処理として完結しません。

int total = 100 + 200;と書くことで、「計算結果をtotalという変数に入れる」という処理になります。

つまり、式はステートメントの一部として使われることがよくあります。

3-3. 式ステートメントとは？

C#には、式ステートメントというものがあります。

式ステートメントとは、式をステートメントとして実行する書き方です。

代表的な例は、代入、メソッド呼び出し、インクリメント、デクリメントなどです。

C#
x = 10;

これは代入式をステートメントとして実行しています。

C#
Console.WriteLine("Hello");

これはメソッド呼び出し式をステートメントとして実行しています。

C#
i++;

これはインクリメント式をステートメントとして実行しています。

式ステートメントでは、最後にセミコロンを付けます。

3-4. 具体例で見る式とステートメントの違い

次のコードを見てください。

C#
int x = 10;
int y = 20;
int result = x + y;
Console.WriteLine(result);

この中で、x + yは式です。評価されると30になります。

一方、次の1行全体はステートメントです。

C#
int result = x + y;

これは、x + yの結果をresultに代入する処理です。

また、次のコードでは、

C#
Console.WriteLine(result);

Console.WriteLine(result)はメソッド呼び出し式ですが、セミコロンを付けることで式ステートメントになっています。

このように、式とステートメントは別物ですが、実際のコードでは密接に関係しています。

3-5. 初心者が間違えやすいポイント

初心者がよく間違えるのは、「値を返すかどうか」と「文として実行できるかどうか」を混同することです。

たとえば、次のコードは式としては意味があります。

C#
1 + 2

しかし、C#ではこれだけをステートメントとして書くことはできません。

C#
1 + 2;

このようなコードは、通常エラーになります。計算結果をどこにも使っていないためです。

一方、次のように変数へ代入すればステートメントとして意味があります。

C#
int result = 1 + 2;

また、ifの条件部分には式を書きます。

C#
if (age >= 20)
{
    Console.WriteLine("成人です");
}

ここでage >= 20は式です。評価結果がtrueならブロック内のステートメントが実行されます。

4. C#でよく使うステートメントの種類

C#には多くのステートメントがあります。ここでは、初心者がよく使う代表的なステートメントを紹介します。

4-1. 宣言ステートメント

宣言ステートメントは、変数などを宣言するためのステートメントです。

C#
int age;
string name;

変数を宣言すると、その変数をプログラム内で使えるようになります。

宣言と同時に初期値を代入することもできます。

C#
int age = 20;
string name = "Taro";

C#では、変数を使う前に宣言する必要があります。

4-2. 式ステートメント

式ステートメントは、式をステートメントとして実行するものです。

C#
age = 21;
Console.WriteLine(age);
count++;

代入、メソッド呼び出し、インクリメント、デクリメントなどが代表例です。

プログラムの中で最も頻繁に使うステートメントの1つです。

4-3. 選択ステートメント

選択ステートメントは、条件によって実行する処理を選ぶためのステートメントです。

代表的なものに、if文とswitch文があります。

C#
if (score >= 80)
{
    Console.WriteLine("合格");
}
else
{
    Console.WriteLine("不合格");
}

条件によって処理を分けたいときに使います。

4-4. 反復ステートメント

反復ステートメントは、同じ処理を繰り返すためのステートメントです。

代表的なものに、for、while、do-while、foreachがあります。

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

繰り返し処理は、配列やリストの要素を順番に処理するときにもよく使います。

4-5. ジャンプステートメント

ジャンプステートメントは、処理の流れを別の場所へ移すためのステートメントです。

代表的なものに、break、continue、return、gotoがあります。

C#
return;

メソッドの処理を途中で終了したいときなどに使います。

C#
break;

ループやswitch文を抜けるときに使います。

4-6. 例外処理ステートメント

例外処理ステートメントは、エラーが発生したときの処理を書くためのステートメントです。

代表的なものに、try-catch、try-finally、throwがあります。

C#
try
{
    int number = int.Parse("abc");
}
catch (FormatException)
{
    Console.WriteLine("数値に変換できません");
}

実行中に発生する可能性のあるエラーに備えるために使います。

4-7. usingステートメント

usingステートメントは、使い終わったリソースを自動的に解放するためのステートメントです。

C#
using (var reader = new StreamReader("sample.txt"))
{
    string text = reader.ReadToEnd();
    Console.WriteLine(text);
}

ファイル、ネットワーク接続、データベース接続など、使い終わった後に解放が必要なものを扱うときに便利です。

4-8. lockステートメント

lockステートメントは、複数のスレッドから同時に処理されると困る部分を保護するためのステートメントです。

C#
lock (lockObject)
{
    count++;
}

マルチスレッド処理で、同じデータを同時に変更しないようにするために使います。

初心者が最初から深く理解する必要はありませんが、「同時実行時の競合を防ぐためのステートメント」と覚えておくとよいでしょう。

5. 選択ステートメントの書き方

選択ステートメントは、条件によって実行する処理を変えるために使います。C#で特によく使うのは、if、else、else if、switchです。

5-1. ifステートメント

ifステートメントは、条件がtrueのときだけ処理を実行します。

C#
int score = 85;

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

この例では、score >= 80がtrueなので、合格ですと表示されます。

ifの条件式には、結果がbool型、つまりtrueまたはfalseになる式を書きます。

5-2. elseステートメント

elseは、ifの条件がfalseだった場合に実行される処理を書きます。

C#
int score = 60;

if (score >= 80)
{
    Console.WriteLine("合格です");
}
else
{
    Console.WriteLine("不合格です");
}

この例では、score >= 80がfalseなので、elseのブロックが実行されます。

ifとelseを使うことで、「条件を満たす場合」と「満たさない場合」の処理を分けられます。

5-3. else ifの使い方

条件が複数ある場合は、else ifを使います。

C#
int score = 75;

if (score >= 90)
{
    Console.WriteLine("評価はAです");
}
else if (score >= 70)
{
    Console.WriteLine("評価はBです");
}
else if (score >= 50)
{
    Console.WriteLine("評価はCです");
}
else
{
    Console.WriteLine("評価はDです");
}

このコードでは、上から順番に条件がチェックされます。最初にtrueになったブロックだけが実行されます。

scoreが75の場合、score >= 90はfalseですが、score >= 70はtrueなので、評価はBですと表示されます。

5-4. switchステートメント

switchステートメントは、1つの値に応じて処理を分けたいときに使います。

C#
int day = 3;

switch (day)
{
    case 1:
        Console.WriteLine("月曜日");
        break;
    case 2:
        Console.WriteLine("火曜日");
        break;
    case 3:
        Console.WriteLine("水曜日");
        break;
    default:
        Console.WriteLine("不明な曜日");
        break;
}

switchでは、値に一致するcaseの処理が実行されます。

どのcaseにも一致しない場合は、defaultの処理が実行されます。

caseの最後には、多くの場合breakを書きます。breakを書くことで、switch文の外へ抜けます。

5-5. 条件分岐を書くときの注意点

条件分岐を書くときは、条件式の意味を明確にすることが大切です。

たとえば、次のコードは条件の順番に注意が必要です。

C#
int score = 95;

if (score >= 60)
{
    Console.WriteLine("合格");
}
else if (score >= 90)
{
    Console.WriteLine("高得点");
}

この場合、scoreが95でも最初のscore >= 60がtrueになるため、高得点は表示されません。

正しくは、より厳しい条件を先に書きます。

C#
if (score >= 90)
{
    Console.WriteLine("高得点");
}
else if (score >= 60)
{
    Console.WriteLine("合格");
}

また、条件式で=と==を間違えないようにしましょう。

C#
if (age == 20)
{
    Console.WriteLine("20歳です");
}

==は等しいかどうかを比較する演算子です。=は代入に使います。

6. 反復ステートメントの書き方

反復ステートメントは、同じ処理を繰り返し実行するために使います。C#では、for、while、do-while、foreachがよく使われます。

6-1. forステートメント

forステートメントは、繰り返し回数が決まっている場合によく使います。

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

このコードでは、iが0から4まで変化しながら、合計5回処理が実行されます。

for文は、次の3つの要素で構成されます。

C#
for (初期化; 条件式; 更新)
{
    繰り返す処理
}

たとえば、int i = 0は初期化、i < 5は条件式、i++は更新処理です。

6-2. whileステートメント

whileステートメントは、条件がtrueの間、処理を繰り返します。

C#
int count = 0;

while (count < 3)
{
    Console.WriteLine(count);
    count++;
}

このコードでは、count < 3がtrueの間、処理が繰り返されます。

while文は、繰り返し回数が事前に決まっていない場合にも使いやすいです。

ただし、条件がずっとtrueのままだと無限ループになります。

C#
while (true)
{
    Console.WriteLine("繰り返します");
}

このようなコードを書く場合は、どこかでbreakなどを使って抜ける処理が必要です。

6-3. do-whileステートメント

do-whileステートメントは、処理を実行した後に条件を判定します。

C#
int count = 0;

do
{
    Console.WriteLine(count);
    count++;
}
while (count < 3);

while文との違いは、条件が最初からfalseでも、doブロックの処理が少なくとも1回は実行されることです。

C#
int count = 10;

do
{
    Console.WriteLine(count);
}
while (count < 3);

この場合、count < 3はfalseですが、最初の1回だけは表示されます。

6-4. foreachステートメント

foreachステートメントは、配列やリストなどの要素を順番に取り出して処理するときに使います。

C#
string[] names = { "Taro", "Hanako", "Jiro" };

foreach (string name in names)
{
    Console.WriteLine(name);
}

このコードでは、配列namesの要素が1つずつnameに入り、順番に表示されます。

foreachは、要素数を意識せずに処理できるため、配列やコレクションを扱うときに便利です。

C#
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

foreach (int number in numbers)
{
    Console.WriteLine(number);
}

リストに対しても同じように使えます。

6-5. ループ処理でよくあるミス

ループ処理でよくあるミスの1つは、更新処理を忘れることです。

C#
int i = 0;

while (i < 5)
{
    Console.WriteLine(i);
}

このコードでは、iの値が変わらないため、条件がずっとtrueのままになり、無限ループになります。

正しくは、ループ内でiを更新します。

C#
int i = 0;

while (i < 5)
{
    Console.WriteLine(i);
    i++;
}

また、for文では条件式の範囲ミスにも注意が必要です。

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

このコードは0から5までの6回実行されます。5回だけ実行したい場合は、i < 5と書きます。

7. ジャンプステートメントの書き方

ジャンプステートメントは、通常の上から下への処理の流れを変えるために使います。C#では、break、continue、return、gotoなどがあります。

7-1. breakステートメント

breakステートメントは、ループやswitch文を途中で終了するときに使います。

C#
for (int i = 0; i < 10; i++)
{
    if (i == 5)
    {
        break;
    }

    Console.WriteLine(i);
}

このコードでは、iが5になった時点でbreakが実行され、ループが終了します。

表示されるのは0から4までです。

switch文でも、各caseの処理を終えるためにbreakを使います。

C#
switch (number)
{
    case 1:
        Console.WriteLine("1です");
        break;
    default:
        Console.WriteLine("その他です");
        break;
}

7-2. continueステートメント

continueステートメントは、ループ内の残りの処理をスキップして、次の繰り返しへ進むために使います。

C#
for (int i = 0; i < 5; i++)
{
    if (i == 2)
    {
        continue;
    }

    Console.WriteLine(i);
}

このコードでは、iが2のときだけConsole.WriteLine(i);が実行されません。

表示されるのは、0、1、3、4です。

breakはループ全体を終了するのに対し、continueは現在の回だけをスキップします。

7-3. returnステートメント

returnステートメントは、メソッドの処理を終了し、必要に応じて値を返します。

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

この例では、a + bの結果を呼び出し元に返します。

戻り値がないvoidメソッドでは、値を返さずにreturn;と書けます。

C#
void PrintMessage(bool show)
{
    if (!show)
    {
        return;
    }

    Console.WriteLine("メッセージを表示します");
}

このコードでは、showがfalseの場合、returnによってメソッドの処理が途中で終了します。

7-4. gotoステートメント

gotoステートメントは、指定したラベルの位置へ処理を移動します。

C#
int number = 1;

goto Label;

Console.WriteLine("ここは実行されません");

Label:
Console.WriteLine(number);

gotoを使うと、処理の流れを大きく変えることができます。

ただし、コードが読みにくくなりやすいため、通常のプログラムではあまり使いません。多くの場合、if、while、break、continueなどで代替できます。

7-5. ジャンプステートメントを使うときの注意点

ジャンプステートメントは便利ですが、使いすぎると処理の流れがわかりにくくなります。

特にreturnをメソッド内のあちこちに書くと、どこで処理が終了するのか追いにくくなる場合があります。

ただし、早期リターンはコードを読みやすくすることもあります。

C#
void PrintAge(int age)
{
    if (age < 0)
    {
        Console.WriteLine("年齢が不正です");
        return;
    }

    Console.WriteLine($"{age}歳です");
}

このように、不正な値を先にチェックして処理を終了する書き方はよく使われます。

大切なのは、ジャンプステートメントを使う目的を明確にすることです。

8. 例外処理・リソース管理に関するステートメント

プログラムでは、実行中にエラーが発生することがあります。たとえば、ファイルが存在しない、文字列を数値に変換できない、ネットワーク接続に失敗する、といったケースです。

C#では、このような問題に対応するために、例外処理のステートメントを使います。また、ファイルなどのリソースを安全に扱うために、usingステートメントやusing宣言を使います。

8-1. try-catchステートメント

try-catchステートメントは、例外が発生する可能性のある処理を安全に実行するために使います。

C#
try
{
    int number = int.Parse("abc");
    Console.WriteLine(number);
}
catch (FormatException)
{
    Console.WriteLine("数値に変換できませんでした");
}

このコードでは、"abc"を数値に変換しようとして例外が発生します。しかし、catchブロックで例外を受け取るため、プログラム全体が突然終了するのを防げます。

複数の例外に対応することもできます。

C#
try
{
    int[] numbers = { 1, 2, 3 };
    Console.WriteLine(numbers[10]);
}
catch (IndexOutOfRangeException)
{
    Console.WriteLine("配列の範囲外です");
}
catch (Exception)
{
    Console.WriteLine("予期しないエラーが発生しました");
}

より具体的な例外を先に書き、一般的なExceptionは後に書くのが基本です。

8-2. try-finallyステートメント

try-finallyステートメントは、例外が発生してもしなくても、最後に必ず実行したい処理を書くために使います。

C#
try
{
    Console.WriteLine("処理を開始します");
}
finally
{
    Console.WriteLine("最後に必ず実行されます");
}

finallyブロックは、ファイルを閉じる、接続を終了する、後片付けを行うといった処理に使われます。

catchと組み合わせることもできます。

C#
try
{
    int number = int.Parse("abc");
}
catch (FormatException)
{
    Console.WriteLine("変換に失敗しました");
}
finally
{
    Console.WriteLine("処理を終了します");
}

この場合、例外が発生してcatchが実行された後、最後にfinallyが実行されます。

8-3. throwステートメント

throwステートメントは、例外を発生させるために使います。

C#
void CheckAge(int age)
{
    if (age < 0)
    {
        throw new ArgumentException("年齢は0以上で指定してください");
    }

    Console.WriteLine($"{age}歳です");
}

このコードでは、ageが負の値だった場合に例外を発生させます。

また、catchした例外を再度投げることもできます。

C#
try
{
    int number = int.Parse("abc");
}
catch
{
    Console.WriteLine("エラーが発生しました");
    throw;
}

throw;と書くと、現在処理している例外をそのまま再スローできます。

8-4. usingステートメント

usingステートメントは、使い終わったリソースを自動的に破棄するために使います。

C#
using (var writer = new StreamWriter("sample.txt"))
{
    writer.WriteLine("Hello");
}

このコードでは、usingブロックを抜けるときにwriterが自動的に破棄されます。

ファイルやデータベース接続などは、使い終わったら適切に解放する必要があります。usingステートメントを使うことで、解放忘れを防ぎやすくなります。

8-5. using宣言との違い

C#には、usingステートメントのほかにusing宣言があります。

usingステートメントは、波かっこで囲んだブロックの終わりでリソースを破棄します。

C#
using (var reader = new StreamReader("sample.txt"))
{
    string text = reader.ReadToEnd();
    Console.WriteLine(text);
}

一方、using宣言では、変数が宣言されたスコープの終わりでリソースが破棄されます。

C#
using var reader = new StreamReader("sample.txt");

string text = reader.ReadToEnd();
Console.WriteLine(text);

この場合、現在のスコープを抜けるときにreaderが破棄されます。

初心者のうちは、まずusingステートメントの形を覚えると理解しやすいです。慣れてきたら、コードを簡潔に書けるusing宣言も使ってみるとよいでしょう。

9. C#のステートメントで初心者がつまずきやすいポイント

C#のステートメントは基本的な文法ですが、初心者がつまずきやすいポイントがいくつかあります。よくあるミスを知っておくと、エラーの原因を見つけやすくなります。

9-1. セミコロンの付け忘れ

最もよくあるミスの1つが、セミコロンの付け忘れです。

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

このコードでは、int number = 10の後にセミコロンがありません。

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

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

C#では、多くのステートメントの末尾にセミコロンが必要です。エラーが出たときは、まず直前の行にセミコロンがあるか確認しましょう。

9-2. 波かっこの対応ミス

if文やfor文では、波かっこ{ }の対応ミスもよく起こります。

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

このコードでは、閉じる波かっこ}がありません。

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

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

波かっこが増えると、どこからどこまでがブロックなのかわかりにくくなります。インデントを整えると、対応関係を確認しやすくなります。

9-3. if文やfor文の条件式ミス

if文やfor文では、条件式の書き方を間違えることがあります。

たとえば、比較したいのに代入演算子=を書いてしまうミスです。

C#
if (age = 20)
{
    Console.WriteLine("20歳です");
}

C#ではこのようなコードは通常エラーになります。比較には==を使います。

C#
if (age == 20)
{
    Console.WriteLine("20歳です");
}

また、for文では終了条件を間違えると、繰り返し回数が想定とずれることがあります。

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

このコードは0から10までの11回実行されます。10回だけ実行したい場合は、次のように書きます。

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

9-4. returnの位置による処理の違い

returnステートメントは、メソッドの処理をその場で終了します。そのため、書く位置によって実行される処理が変わります。

C#
void PrintMessage()
{
    Console.WriteLine("1つ目のメッセージ");
    return;
    Console.WriteLine("2つ目のメッセージ");
}

このコードでは、return;の後にあるConsole.WriteLineは実行されません。

returnは便利ですが、後続の処理が実行されなくなるため、位置に注意が必要です。

条件によって処理を終了したい場合は、次のように書きます。

C#
void PrintAge(int age)
{
    if (age < 0)
    {
        Console.WriteLine("年齢が不正です");
        return;
    }

    Console.WriteLine($"{age}歳です");
}

この場合、ageが負の値のときだけ途中で終了します。

9-5. 到達不能コードのエラー

到達不能コードとは、絶対に実行されないコードのことです。

たとえば、次のコードではreturnの後の処理は実行されません。

C#
int GetNumber()
{
    return 10;
    Console.WriteLine("この行は実行されません");
}

C#では、このような到達不能コードがあるとエラーになることがあります。

また、次のようなコードも注意が必要です。

C#
while (true)
{
    Console.WriteLine("ループ中");
}

Console.WriteLine("ループ後の処理");

while (true)から抜ける処理がない場合、その後のコードには到達できません。

到達不能コードのエラーが出た場合は、return、break、throw、無限ループなどによって処理が止まっていないか確認しましょう。

10. C#のステートメントを理解するための練習例

ここでは、C#のステートメントを理解するための簡単な練習例を紹介します。実際にコードを書いて動かしてみると、ステートメントの役割がより理解しやすくなります。

10-1. 変数宣言と代入の練習

まずは、変数を宣言して値を代入する練習です。

C#
int age = 25;
string name = "Taro";

Console.WriteLine(name);
Console.WriteLine(age);

このコードでは、ageとnameを宣言し、それぞれに値を代入しています。

次のように、後から値を変更することもできます。

C#
int count = 0;

count = 1;
count = 2;

Console.WriteLine(count);

最終的に表示されるのは2です。

変数宣言ステートメントと代入ステートメントは、C#の基本中の基本です。

10-2. if文を使った条件分岐の練習

次に、if文を使って条件分岐を練習しましょう。

C#
int score = 85;

if (score >= 80)
{
    Console.WriteLine("合格です");
}
else
{
    Console.WriteLine("不合格です");
}

scoreの値を変えて、表示結果がどう変わるか確認してみましょう。

複数条件の練習もできます。

C#
int score = 92;

if (score >= 90)
{
    Console.WriteLine("評価A");
}
else if (score >= 70)
{
    Console.WriteLine("評価B");
}
else
{
    Console.WriteLine("評価C");
}

条件が上から順番に判定されることを意識すると、else ifの動きが理解しやすくなります。

10-3. for文を使った繰り返し処理の練習

for文を使うと、同じ処理を決まった回数だけ繰り返せます。

C#
for (int i = 1; i <= 5; i++)
{
    Console.WriteLine(i);
}

このコードでは、1から5までが表示されます。

合計を求める練習もしてみましょう。

C#
int total = 0;

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

Console.WriteLine(total);

このコードでは、1から10までの合計である55が表示されます。

ループの中で変数の値がどのように変化するかを確認することが大切です。

10-4. try-catchを使った例外処理の練習

次は、try-catchを使った例外処理の練習です。

C#
try
{
    int number = int.Parse("abc");
    Console.WriteLine(number);
}
catch (FormatException)
{
    Console.WriteLine("数値に変換できません");
}

int.Parse("abc")は数値に変換できないため、例外が発生します。しかし、catchブロックがあるため、エラーメッセージを表示して処理を続けられます。

正しく変換できる値に変えて試してみましょう。

C#
try
{
    int number = int.Parse("123");
    Console.WriteLine(number);
}
catch (FormatException)
{
    Console.WriteLine("数値に変換できません");
}

この場合は例外が発生せず、123が表示されます。

10-5. ステートメントを組み合わせた簡単なサンプルコード

最後に、複数のステートメントを組み合わせたサンプルコードを見てみましょう。

C#
int[] scores = { 80, 55, 92, 70, 40 };

foreach (int score in scores)
{
    if (score >= 80)
    {
        Console.WriteLine($"{score}点: 優秀です");
    }
    else if (score >= 60)
    {
        Console.WriteLine($"{score}点: 合格です");
    }
    else
    {
        Console.WriteLine($"{score}点: 不合格です");
    }
}

このコードでは、次のステートメントを組み合わせています。

• 配列を宣言するステートメント

• foreachによる反復ステートメント

• if、else if、elseによる選択ステートメント

• Console.WriteLineによる式ステートメント

このように、実際のC#プログラムでは複数のステートメントを組み合わせて処理を作ります。

11. C#のステートメントに関するよくある質問

ここでは、C#のステートメントについて初心者が疑問に感じやすいポイントをQ&A形式で整理します。

11-1. C#のステートメントは必ずセミコロンが必要？

すべてのステートメントにセミコロンが必要なわけではありません。

変数宣言、代入、メソッド呼び出しなど、多くのステートメントではセミコロンが必要です。

C#
int x = 10;
x = 20;
Console.WriteLine(x);

一方、if文やfor文のようにブロックを持つステートメントでは、通常ステートメント全体の最後にセミコロンは付けません。

C#
if (x > 0)
{
    Console.WriteLine("正の数です");
}

ただし、do-while文のように最後にセミコロンが必要なものもあります。

C#
do
{
    Console.WriteLine(x);
    x--;
}
while (x > 0);

ステートメントの種類によってセミコロンの有無が異なるため、代表的な書き方を覚えていきましょう。

11-2. ステートメントとメソッドの違いは？

ステートメントは、処理を実行する文の単位です。

一方、メソッドは複数の処理をまとめた部品です。

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

この例では、SayHelloがメソッドです。

メソッドの中には、次のステートメントが含まれています。

C#
Console.WriteLine("こんにちは");

つまり、メソッドはステートメントをまとめる入れ物のようなものです。ステートメントは、メソッドの中で実際に実行される処理です。

11-3. if文やfor文もステートメントに含まれる？

はい、if文やfor文もステートメントに含まれます。

if文は選択ステートメント、for文は反復ステートメントです。

C#
if (age >= 20)
{
    Console.WriteLine("成人です");
}

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

これらは単なる構文ではなく、C#の処理の流れを制御するステートメントです。

11-4. 式ステートメントとは何？

式ステートメントとは、式をステートメントとして実行するものです。

代表的な例は、代入、メソッド呼び出し、インクリメント、デクリメントです。

C#
x = 10;

これは代入式をステートメントとして実行しています。

C#
Console.WriteLine(x);

これはメソッド呼び出し式をステートメントとして実行しています。

C#
x++;

これはインクリメント式をステートメントとして実行しています。

式ステートメントは、C#のコードで非常によく使われる基本的なステートメントです。

11-5. 初心者はどのステートメントから覚えるべき？

初心者は、まず次の順番で覚えるのがおすすめです。

1. 変数宣言ステートメント

2. 代入やメソッド呼び出しなどの式ステートメント

3. if文による選択ステートメント

4. for文やwhile文による反復ステートメント

5. returnやbreakなどのジャンプステートメント

6. try-catchによる例外処理ステートメント

7. usingステートメントによるリソース管理

最初からすべてを完璧に覚える必要はありません。まずは、変数宣言、代入、if、for、Console.WriteLineを使った簡単なコードを書けるようになることを目指しましょう。

まとめ

C#のステートメントとは、プログラムに処理を実行させるための文です。変数を宣言する、値を代入する、メソッドを呼び出す、条件分岐を行う、繰り返し処理を行うなど、C#のコードは多くのステートメントによって構成されています。

多くのステートメントはセミコロン;で終わりますが、if文やfor文のようにブロックを持つステートメントでは、通常最後にセミコロンを付けません。波かっこ{ }で処理のまとまりを作り、インデントを整えることで読みやすいコードになります。

また、C#では「式」と「ステートメント」の違いを理解することも大切です。式は値を返すもの、ステートメントは処理を実行するものです。代入やメソッド呼び出しのように、式をステートメントとして実行する式ステートメントもあります。

初心者がまず覚えるべきステートメントは、変数宣言、式ステートメント、if文、for文、while文、return、break、try-catchなどです。これらを理解すれば、C#の基本的な処理の流れを読んだり書いたりできるようになります。

C#のステートメントは、プログラムを組み立てるための土台です。サンプルコードを実際に書きながら、1つひとつのステートメントがどのような処理を行っているのかを確認していきましょう。