C#の宣言とは？変数・型・メソッドの書き方を初心者向けにわかりやすく解説

はじめに

C#を学び始めると、最初に必ず出てくるのが「宣言」という考え方です。変数を使うとき、メソッドを作るとき、クラスを書くときなど、C#ではさまざまな場面で宣言を行います。

「宣言」と聞くと難しく感じるかもしれませんが、簡単にいうと「これからこの名前のものを、このような型や役割で使います」とプログラムに伝えることです。

たとえば、数値を入れる変数を使いたい場合は、次のように書きます。

C#
int age;

これは「ageという名前の変数を、int型として使います」という宣言です。

この記事では、C#の宣言について、変数・型・メソッド・クラス・プロパティなどの基本を初心者向けにわかりやすく解説します。C#のコードを正しく読み書きするために、まずは宣言の基本をしっかり押さえていきましょう。

1. C#の宣言とは？初心者向けに基本をわかりやすく解説

C#の宣言とは、プログラムの中で使用する変数やメソッド、クラスなどの名前や型、使い方をあらかじめ示すことです。

C#は「型」を重視するプログラミング言語です。そのため、何かを使う前に「これはどのような種類のデータなのか」「どのような役割を持つものなのか」を明確にする必要があります。

1-1. 宣言とは「名前・型・使い方」をプログラムに伝えること

C#の宣言では、主に次のような情報をプログラムに伝えます。

C#
int score;

このコードでは、次のことを宣言しています。

intは整数を扱う型です。scoreは変数名です。つまり、「scoreという名前の変数を整数として使います」とC#に伝えています。

メソッドの場合は、次のように宣言します。

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

これは「ShowMessageという名前のメソッドを作り、呼び出されたらメッセージを表示します」という宣言です。

このように、宣言はC#に対して「これから使うものの情報」を知らせるための大切な書き方です。

1-2. C#で宣言が必要になる理由

C#で宣言が必要になる理由は、プログラムを安全でわかりやすくするためです。

たとえば、次のように変数を宣言します。

C#
int number;

この宣言によって、numberには整数を入れることができます。

C#
number = 10;

しかし、整数用の変数に文字列を入れようとするとエラーになります。

C#
number = "こんにちは";

これは、numberがint型として宣言されているためです。C#は型の違いをチェックしてくれるので、間違った値を入れようとしたときにエラーとして教えてくれます。

宣言があることで、プログラムの中で何がどのように使われているのかが明確になります。その結果、バグを防ぎやすくなり、コードも読みやすくなります。

1-3. 宣言と代入・初期化の違い

C#を学ぶときは、「宣言」「代入」「初期化」の違いを理解することが大切です。

宣言とは、変数などを使えるようにすることです。

C#
int age;

これは「ageという変数をint型で使います」という宣言です。

代入とは、変数に値を入れることです。

C#
age = 20;

これは、すでに宣言されたageに20を入れています。

初期化とは、宣言と同時に最初の値を入れることです。

C#
int age = 20;

このコードでは、ageを宣言すると同時に20を代入しています。つまり、宣言と代入を同時に行っている状態です。

初心者のうちは、この3つを混同しやすいですが、次のように考えるとわかりやすくなります。

宣言は「使う準備」、代入は「値を入れること」、初期化は「最初の値を入れて使う準備をすること」です。

1-4. 宣言を理解するとC#のコードが読みやすくなる

C#のコードでは、変数、メソッド、クラス、プロパティなど、さまざまなものが宣言されています。

宣言を理解できるようになると、コードを読んだときに「これは何を表しているのか」「どの型のデータなのか」「どこから使えるのか」がわかるようになります。

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

C#
string name = "田中";
int age = 25;
bool isStudent = false;

このコードでは、nameは文字列、ageは整数、isStudentは真偽値として宣言されています。宣言の意味がわかれば、それぞれの変数がどのようなデータを扱っているのかすぐに理解できます。

C#の宣言は、コードを読み解くための基本です。最初は少し難しく感じるかもしれませんが、慣れてくるとプログラム全体の構造が見えやすくなります。

2. C#でよく使う宣言の種類

C#にはさまざまな宣言があります。初心者がまず覚えておきたいのは、変数、定数、型、メソッド、クラス、プロパティの宣言です。

それぞれ役割が異なるため、順番に確認していきましょう。

2-1. 変数の宣言

変数の宣言は、C#で最も基本的な宣言です。変数とは、値を一時的に入れておくための箱のようなものです。

C#
int number;
string message;

このコードでは、numberという整数用の変数と、messageという文字列用の変数を宣言しています。

値を入れる場合は、次のように書きます。

C#
number = 100;
message = "こんにちは";

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

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

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

2-2. 定数の宣言

定数とは、一度値を入れたら変更できない値のことです。C#ではconstを使って定数を宣言します。

C#
const double TaxRate = 0.1;

このコードでは、TaxRateという定数を宣言しています。定数は途中で値を変更できません。

C#
TaxRate = 0.08;

このように書くとエラーになります。

定数は、消費税率や円周率など、プログラム中で変わらない値を扱うときに使います。

C#
const int MaxScore = 100;
const string AppName = "SampleApp";

定数を使うと、意味のある名前で値を管理できるため、コードが読みやすくなります。

2-3. 型の宣言

C#では、自分で型を宣言することもできます。型とは、データの種類や構造を表すものです。

代表的な型の宣言には、クラス、構造体、列挙型などがあります。

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

このコードでは、Personというクラス型を宣言しています。Person型には、NameとAgeというプロパティがあります。

型を宣言すると、独自のデータ構造を作ることができます。

C#
Person person = new Person();
person.Name = "佐藤";
person.Age = 30;

このように、自分で作った型を使って変数を宣言できます。

2-4. メソッドの宣言

メソッドとは、処理をまとめたものです。C#では、何度も使いたい処理をメソッドとして宣言できます。

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

このコードでは、SayHelloというメソッドを宣言しています。

値を返すメソッドの場合は、戻り値の型を指定します。

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

このメソッドは、2つの整数を受け取り、その合計を返します。

メソッドを宣言しておくと、同じ処理を何度も書かずに済みます。

2-5. クラスの宣言

クラスは、C#のプログラムを作るうえで非常に重要な宣言です。クラスは、データと処理をまとめるための設計図のようなものです。

C#
class Car
{
    public string Color;
    public void Drive()
    {
        Console.WriteLine("車が走ります");
    }
}

このコードでは、Carというクラスを宣言しています。Carクラスには、Colorというフィールドと、Driveというメソッドがあります。

クラスを使うと、関連するデータと処理をひとつにまとめて管理できます。

C#
Car car = new Car();
car.Color = "赤";
car.Drive();

C#では、プログラムの多くがクラスを中心に作られます。

2-6. プロパティの宣言

プロパティは、クラスの外から値を読み書きするための仕組みです。フィールドを直接操作する代わりに、プロパティを使うことで安全に値を扱えます。

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

このコードでは、NameとAgeというプロパティを宣言しています。

使うときは次のように書きます。

C#
Student student = new Student();
student.Name = "山田";
student.Age = 18;

getは値を取得するためのもの、setは値を設定するためのものです。C#では、このような自動実装プロパティがよく使われます。

3. C#の変数宣言の書き方

C#の変数宣言は、初心者が最初に覚えるべき重要な書き方です。変数を正しく宣言できるようになると、数値や文字列などのデータを自由に扱えるようになります。

3-1. 基本形：型 変数名;

C#の変数宣言の基本形は、次のとおりです。

C#
型 変数名;

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

C#
int number;

文字列を入れる変数なら、次のように書きます。

C#
string name;

真偽値を入れる変数なら、次のように書きます。

C#
bool isActive;

このように、C#では「どの型の変数なのか」を先に書き、そのあとに変数名を書きます。最後にはセミコロン;を付けます。

3-2. 宣言と同時に値を入れる書き方

変数は、宣言と同時に値を入れることができます。これを初期化といいます。

C#
int age = 20;
string name = "鈴木";
bool isMember = true;

このように書くと、変数を宣言した時点で値が入ります。

宣言だけした場合は、あとから値を代入します。

C#
int age;
age = 20;

ただし、ローカル変数は値を入れる前に使うとエラーになります。

C#
int age;
Console.WriteLine(age);

このコードは、ageに値が入っていないためエラーになります。初心者のうちは、変数はできるだけ宣言と同時に初期化する書き方がおすすめです。

3-3. 複数の変数を宣言する書き方

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

C#
int x, y, z;

値を同時に入れることもできます。

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

ただし、初心者の場合は、1行に複数の変数を書くと読みづらくなることがあります。そのため、最初は次のように1行ずつ書く方がわかりやすいです。

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

コードは動くだけでなく、あとから読んだときに理解しやすいことも大切です。

3-4. varを使った型推論による宣言

C#では、varを使って変数を宣言できます。

C#
var number = 10;
var name = "田中";
var isActive = true;

varを使うと、右側の値からC#が自動的に型を判断します。

上のコードは、実際には次のように解釈されます。

C#
int number = 10;
string name = "田中";
bool isActive = true;

ただし、varを使う場合は、宣言と同時に値を入れる必要があります。

C#
var number;

このように書くと、C#が型を判断できないためエラーになります。

varは便利ですが、初心者のうちは型を意識するために、まずはintやstringなどを明示して書く練習をするとよいでしょう。

3-5. 変数名を付けるときのルールと注意点

C#の変数名には、いくつかのルールがあります。

変数名には、英字、数字、アンダースコアを使えます。ただし、数字から始めることはできません。

C#
int score1;     // OK
int _count;     // OK
int 1score;     // NG

また、C#の予約語はそのまま変数名にできません。

C#
int class;      // NG
int return;     // NG

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

C#
int a;

よりも、次のように書いた方が読みやすくなります。

C#
int userAge;

C#では、ローカル変数にはキャメルケースを使うことが多いです。

C#
int totalPrice;
string userName;
bool isFinished;

変数名をわかりやすくすると、コード全体の意味も理解しやすくなります。

4. C#の型宣言とデータ型の基本

C#の宣言を理解するうえで、型の知識は欠かせません。型とは、変数に入るデータの種類を表すものです。

C#では、整数、実数、文字列、真偽値など、さまざまな型を使ってデータを扱います。

4-1. int・double・string・boolの使い方

初心者が最初に覚えるべき基本的な型には、int、double、string、boolがあります。

intは整数を扱う型です。

C#
int age = 25;
int score = 90;

doubleは小数を扱う型です。

C#
double height = 170.5;
double temperature = 36.5;

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

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

boolは真偽値を扱う型です。値はtrueまたはfalseです。

C#
bool isStudent = true;
bool isFinished = false;

C#では、変数の用途に合った型を選んで宣言することが重要です。

4-2. 値型と参照型の違い

C#の型は、大きく分けると値型と参照型があります。

値型は、値そのものを保持する型です。代表的な値型には、int、double、boolなどがあります。

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

Console.WriteLine(a);
Console.WriteLine(b);

この場合、bにaの値がコピーされます。そのため、bを変更してもaは変わりません。

参照型は、データそのものではなく、データがある場所への参照を保持する型です。代表的な参照型には、string、配列、クラス、Listなどがあります。

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

numbers2[0] = 100;

Console.WriteLine(numbers1[0]);

この場合、numbers1とnumbers2は同じ配列を参照しています。そのため、numbers2から値を変更すると、numbers1にも影響します。

値型と参照型の違いは、C#でコードを書くうえでとても重要です。

4-3. nullable型の宣言

通常、intやboolなどの値型にはnullを入れることができません。

C#
int age = null;

これはエラーになります。

しかし、値がない状態を表したい場合もあります。そのようなときは、nullable型を使います。

C#
int? age = null;
bool? isMember = null;

型名の後ろに?を付けることで、nullを入れられるようになります。

C#
int? score = 80;
score = null;

nullable型は、入力されていない数値や未設定の状態を表すときに便利です。

値があるかどうかを確認するには、次のように書けます。

C#
int? age = null;

if (age.HasValue)
{
    Console.WriteLine(age.Value);
}
else
{
    Console.WriteLine("年齢は未設定です");
}

C#の宣言では、nullを扱う可能性があるかどうかも意識することが大切です。

4-4. 配列やListの宣言

複数の値をまとめて扱いたい場合は、配列やListを使います。

配列の宣言は次のように書きます。

C#
int[] scores;

宣言と同時に値を入れる場合は、次のように書きます。

C#
int[] scores = { 80, 90, 100 };

文字列の配列も宣言できます。

C#
string[] names = { "田中", "佐藤", "鈴木" };

Listを使う場合は、次のように宣言します。

C#
List<int> numbers = new List<int>();

値を追加するには、Addメソッドを使います。

C#
numbers.Add(10);
numbers.Add(20);

文字列のListなら、次のように書きます。

C#
List<string> fruits = new List<string>();
fruits.Add("りんご");
fruits.Add("みかん");

配列は要素数が固定されるのに対して、Listはあとから要素を追加しやすいという特徴があります。

4-5. 型を明示する場合とvarを使う場合の使い分け

C#では、型を明示して宣言する書き方と、varを使って宣言する書き方があります。

型を明示する場合は、次のように書きます。

C#
int count = 10;
string userName = "山田";

varを使う場合は、次のように書きます。

C#
var count = 10;
var userName = "山田";

どちらも正しい書き方です。ただし、初心者のうちは型を明示した方が、変数にどのようなデータが入るのか理解しやすくなります。

一方で、右側を見れば型が明らかな場合は、varを使うとコードがすっきりします。

C#
var numbers = new List<int>();
var person = new Person();

型を明示するかvarを使うかは、読みやすさを基準に判断するとよいでしょう。

5. C#のメソッド宣言の書き方

メソッド宣言は、C#で処理をまとめるための基本です。同じ処理を何度も書くのではなく、メソッドとして宣言しておくことで、必要なときに呼び出せます。

5-1. メソッド宣言の基本形

C#のメソッド宣言の基本形は、次のようになります。

C#
戻り値の型 メソッド名(引数)
{
    処理;
}

たとえば、メッセージを表示するメソッドは次のように宣言できます。

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

このメソッドは、値を返さず、画面に文字を表示するだけの処理です。

呼び出すときは、次のように書きます。

C#
ShowMessage();

メソッドは、処理に名前を付けて再利用するための仕組みです。

5-2. 戻り値の型を指定する方法

メソッドが値を返す場合は、戻り値の型を指定します。

C#
int GetNumber()
{
    return 10;
}

このメソッドは、int型の値を返します。

呼び出すときは、戻り値を変数に入れることができます。

C#
int number = GetNumber();

文字列を返すメソッドなら、戻り値の型はstringにします。

C#
string GetName()
{
    return "田中";
}

boolを返すメソッドも作れます。

C#
bool IsAdult(int age)
{
    return age >= 18;
}

戻り値の型とreturnで返す値の型は一致している必要があります。

C#
int GetValue()
{
    return "こんにちは";
}

このように、int型のメソッドで文字列を返すとエラーになります。

5-3. 引数を宣言する方法

引数とは、メソッドに渡す値のことです。メソッド宣言では、引数にも型と名前を指定します。

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

このメソッドは、string型のnameという引数を受け取ります。

呼び出すときは、文字列を渡します。

C#
ShowName("佐藤");

複数の引数を宣言することもできます。

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

このメソッドは、2つの整数を受け取り、その合計を返します。

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

引数を使うことで、メソッドの外から値を受け取り、その値を使って処理できます。

5-4. voidを使うメソッドの宣言

voidは、戻り値がないことを表す型です。

C#
void PrintMessage()
{
    Console.WriteLine("処理を実行しました");
}

このメソッドは、画面にメッセージを表示しますが、値は返しません。

voidメソッドでは、基本的にreturnで値を返すことはできません。

C#
void PrintMessage()
{
    return "こんにちは";
}

このコードはエラーになります。

ただし、処理を途中で終了するために、値なしのreturnを書くことはできます。

C#
void CheckNumber(int number)
{
    if (number < 0)
    {
        return;
    }

    Console.WriteLine(number);
}

voidは、表示、保存、更新など、結果を返す必要がない処理でよく使われます。

5-5. staticメソッドの宣言

staticを付けると、クラスから直接呼び出せるメソッドになります。

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

このメソッドは、次のように呼び出せます。

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

staticメソッドは、インスタンスを作らなくても使えるメソッドです。

一方、staticを付けないメソッドは、クラスのインスタンスを作ってから呼び出します。

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

呼び出すときは次のようにします。

C#
Greeter greeter = new Greeter();
greeter.SayHello();

初心者のうちは、staticが付いているメソッドは「クラス名から直接呼び出せる」と覚えるとよいでしょう。

5-6. メソッド宣言で初心者が間違えやすいポイント

メソッド宣言で初心者がよく間違えるのは、戻り値の型とreturnの値が一致していないケースです。

C#
int GetAge()
{
    return "20";
}

この場合、intを返すはずなのに文字列を返しているためエラーになります。

次のように修正します。

C#
int GetAge()
{
    return 20;
}

また、引数の型を間違えることもあります。

C#
void ShowAge(int age)
{
    Console.WriteLine(age);
}

ShowAge("20");

この場合、int型の引数に文字列を渡しているためエラーになります。

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

C#
ShowAge(20);

メソッド名のスペルミスにも注意が必要です。

C#
ShowMessage();

と呼び出しているのに、宣言が次のようになっているとエラーになります。

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

C#では名前が正確に一致している必要があります。大文字と小文字も区別されるため、注意しましょう。

6. C#のクラス・プロパティ・フィールドの宣言

C#では、クラスを使ってデータと処理をまとめます。クラスの中には、フィールド、プロパティ、メソッドなどを宣言できます。

ここでは、クラス・フィールド・プロパティの基本的な宣言を見ていきましょう。

6-1. クラス宣言の基本

クラスを宣言するには、classキーワードを使います。

C#
class Person
{
}

このコードでは、Personというクラスを宣言しています。

クラスの中には、データや処理を書くことができます。

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

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

クラスを使うには、次のようにインスタンスを作成します。

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

クラスは、C#でオブジェクト指向プログラミングを行うための基本です。

6-2. フィールド宣言の基本

フィールドとは、クラスの中で宣言される変数のことです。

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

このコードでは、nameとageというフィールドを宣言しています。

使うときは、次のように書きます。

C#
Person person = new Person();
person.name = "佐藤";
person.age = 30;

ただし、実際のC#開発では、フィールドをpublicにして直接操作するよりも、プロパティを使うことが多いです。

フィールドは、クラスの内部で値を保持するために使われます。

C#
class Counter
{
    private int count;

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

このように、外部から直接変更されたくない値はprivateフィールドとして宣言します。

6-3. プロパティ宣言の基本

プロパティは、クラスの外から値を読み書きするための仕組みです。

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

このような書き方を自動実装プロパティといいます。

値を設定するには、次のように書きます。

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

値を取得することもできます。

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

読み取り専用にしたい場合は、setを外す、またはprivate setにします。

C#
class Product
{
    public string Name { get; private set; }

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

プロパティを使うことで、値の読み書きを安全に管理できます。

6-4. public・privateなどアクセス修飾子の使い方

アクセス修飾子は、クラスやメンバーをどこから使えるかを指定するものです。

代表的なアクセス修飾子には、publicとprivateがあります。

publicは、クラスの外からアクセスできることを表します。

C#
public string Name { get; set; }

privateは、同じクラスの中からしかアクセスできないことを表します。

C#
private int count;

たとえば、次のように使います。

C#
class Counter
{
    private int count;

    public void Increment()
    {
        count++;
    }

    public int GetCount()
    {
        return count;
    }
}

この場合、countは外部から直接変更できません。代わりに、IncrementメソッドやGetCountメソッドを通じて操作します。

アクセス修飾子を適切に使うと、意図しない変更を防ぎ、クラスを安全に使えるようになります。

6-5. クラス内で宣言を書く位置

C#では、クラスの中にフィールド、プロパティ、コンストラクター、メソッドなどを宣言できます。

一般的には、次のような順番で書くと読みやすくなります。

C#
class Person
{
    private string name;

    public string Name { get; set; }

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

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

必ずこの順番でなければならないわけではありませんが、関連する宣言を整理して書くことが大切です。

読みやすいクラスにするためには、フィールドやプロパティ、メソッドを適切に分けて配置しましょう。

7. C#の宣言でよくあるエラーと対処法

C#の宣言では、初心者がつまずきやすいエラーがいくつかあります。エラーメッセージの意味を理解できるようになると、原因を見つけやすくなります。

7-1. 「名前が現在のコンテキストに存在しません」の原因

「名前が現在のコンテキストに存在しません」というエラーは、指定した名前の変数やメソッドが見つからないときに発生します。

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

C#
Console.WriteLine(name);

この時点でnameが宣言されていないと、エラーになります。

正しくは、使う前に宣言します。

C#
string name = "田中";
Console.WriteLine(name);

また、変数を宣言した場所の外で使おうとした場合にもエラーになります。

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

Console.WriteLine(number);

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

この場合は、外側で宣言します。

C#
int number;

if (true)
{
    number = 10;
}

Console.WriteLine(number);

7-2. 「型または名前空間の名前が見つかりません」の原因

「型または名前空間の名前が見つかりません」というエラーは、指定した型や名前空間が認識されていないときに発生します。

たとえば、Listを使うときに、必要なusingを書いていない場合です。

C#
List<int> numbers = new List<int>();

このコードでエラーが出る場合は、ファイルの上部に次のように書きます。

C#
using System.Collections.Generic;

また、クラス名のスペルミスでも発生します。

C#
Persom person = new Persom();

本当はPersonと宣言しているのに、Persomと書いている場合、C#はその型を見つけられません。

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

C#
Person person = new Person();

型名や名前空間のエラーが出たときは、スペル、using、参照設定を確認しましょう。

7-3. 宣言前に変数を使ってしまうエラー

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

C#
age = 20;
int age;

このコードは、ageを宣言する前に使っているためエラーになります。

正しくは、先に宣言します。

C#
int age;
age = 20;

また、宣言はしていても値を入れる前に使うとエラーになることがあります。

C#
int age;
Console.WriteLine(age);

ローカル変数は、自動的に初期値が入るわけではありません。使う前に値を入れましょう。

C#
int age = 20;
Console.WriteLine(age);

初心者のうちは、宣言と同時に初期化する習慣を付けるとエラーを減らせます。

7-4. 型が一致しないエラー

C#は型を厳密に扱う言語です。そのため、宣言した型と違う種類の値を入れるとエラーになります。

C#
int number = "100";

このコードは、int型の変数に文字列を入れようとしているためエラーになります。

正しくは、数値として書きます。

C#
int number = 100;

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

C#
string number = "100";

また、小数を整数型に入れる場合も注意が必要です。

C#
int price = 10.5;

これはエラーになります。小数を扱うならdoubleを使います。

C#
double price = 10.5;

型が一致しないエラーが出たときは、宣言した型と代入している値の型を確認しましょう。

7-5. セミコロン忘れやスペルミスの確認方法

C#では、多くの文の最後にセミコロン;が必要です。

C#
int age = 20

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

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

C#
int age = 20;

また、変数名やメソッド名のスペルミスもよくある原因です。

C#
string userName = "田中";
Console.WriteLine(username);

C#では大文字と小文字が区別されるため、userNameとusernameは別の名前として扱われます。

正しくは、宣言した名前と同じように書きます。

C#
Console.WriteLine(userName);

エラーが出たときは、セミコロン、スペル、大文字小文字、かっこの対応を順番に確認すると原因を見つけやすくなります。

8. C#の宣言を正しく書くための実践例

ここでは、C#の宣言を実際のコードで確認していきます。変数、型、メソッド、クラスの宣言を組み合わせて、基本的な書き方に慣れていきましょう。

8-1. 変数宣言のサンプルコード

次のコードは、基本的な変数宣言の例です。

C#
int age = 20;
double height = 170.5;
string name = "田中";
bool isStudent = true;

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

それぞれの変数は、用途に合った型で宣言されています。

ageは整数なのでint、heightは小数なのでdouble、nameは文字列なのでstring、isStudentは真偽値なのでboolです。

変数を宣言するときは、どのような値を入れるのかを考えて型を選びましょう。

8-2. 型宣言のサンプルコード

次のコードは、自分でクラス型を宣言する例です。

C#
class Student
{
    public string Name { get; set; }
    public int Score { get; set; }
}

このコードでは、Studentという型を宣言しています。

使うときは、次のように書きます。

C#
Student student = new Student();
student.Name = "佐藤";
student.Score = 85;

Console.WriteLine(student.Name);
Console.WriteLine(student.Score);

自分で型を宣言すると、関連するデータをまとめて扱えるようになります。

8-3. メソッド宣言のサンプルコード

次のコードは、メソッド宣言の例です。

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

このメソッドは、2つの整数を受け取り、その合計を返します。

呼び出すときは次のように書きます。

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

文字列を表示するだけのメソッドなら、次のようにvoidを使います。

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

呼び出し例は次のとおりです。

C#
ShowGreeting("山田");

メソッド宣言では、戻り値の型、メソッド名、引数の型と名前を正しく書くことが大切です。

8-4. クラス宣言のサンプルコード

次のコードは、クラス宣言、プロパティ宣言、メソッド宣言を組み合わせた例です。

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

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

このクラスを使うには、次のように書きます。

C#
Person person = new Person();
person.Name = "鈴木";
person.Age = 28;
person.Introduce();

この例では、Personクラスの中に、NameとAgeというプロパティ、Introduceというメソッドを宣言しています。

クラスを使うと、データと処理をひとつのまとまりとして扱えます。

8-5. 初心者向け練習問題

C#の宣言に慣れるために、次の練習をしてみましょう。

まず、名前、年齢、身長、学生かどうかを表す変数を宣言します。

C#
string name = "田中";
int age = 20;
double height = 170.5;
bool isStudent = true;

次に、2つの数値を受け取って合計を返すメソッドを宣言します。

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

最後に、商品を表すクラスを宣言してみましょう。

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

    public void ShowInfo()
    {
        Console.WriteLine($"{Name}の価格は{Price}円です。");
    }
}

このような短いコードを何度も書くことで、C#の宣言に自然と慣れていきます。

9. C#の宣言に関するよくある質問

ここでは、C#の宣言について初心者が疑問に思いやすいポイントを解説します。

9-1. 宣言と定義の違いは？

宣言は、「この名前のものを使います」とプログラムに伝えることです。一方、定義は、その中身や具体的な内容を作ることです。

C#では、変数の場合、次のように型と名前を書くことで宣言します。

C#
int number;

メソッドの場合は、処理の中身まで書くことが多いため、宣言と定義を同時に行っていると考えることができます。

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

このコードでは、Addというメソッドを宣言し、その処理内容も定義しています。

初心者のうちは、宣言は「使う名前や型を示すこと」、定義は「具体的な中身を書くこと」と理解しておくとよいでしょう。

9-2. varは使ってもよい？

varは使っても問題ありません。C#では、varを使うと右側の値から型を自動的に判断してくれます。

C#
var age = 20;
var name = "田中";

この場合、ageはint型、nameはstring型として扱われます。

ただし、varを使うには、宣言と同時に値を入れる必要があります。

C#
var age;

これは型を判断できないためエラーになります。

初心者のうちは、型を理解するために最初は明示的に書くのがおすすめです。

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

慣れてきたら、読みやすさを考えながらvarを使うとよいでしょう。

9-3. 変数はどこで宣言すればよい？

変数は、できるだけ使う場所の近くで宣言するのが基本です。

C#
int total = price * count;
Console.WriteLine(total);

使う場所の近くで宣言すると、その変数が何のために使われているのかがわかりやすくなります。

一方、必要以上に広い範囲で宣言すると、どこで値が変更されるのか追いにくくなります。

C#
int total;

// たくさんの処理

total = price * count;

変数の有効範囲をできるだけ小さくすることで、コードは読みやすく、安全になります。

9-4. 宣言だけして値を入れないことはできる？

宣言だけして、あとから値を入れることはできます。

C#
int age;
age = 20;

ただし、ローカル変数は値を入れる前に使うことはできません。

C#
int age;
Console.WriteLine(age);

これはエラーになります。

フィールドの場合は、型ごとに初期値が入ります。たとえば、intは0、boolはfalse、参照型はnullになります。

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

とはいえ、初心者のうちは、変数を宣言するときにできるだけ初期化しておくと安心です。

C#
int age = 0;
string name = "";

9-5. C#初心者はまずどの宣言から覚えるべき？

C#初心者は、まず変数宣言から覚えるのがおすすめです。

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

変数宣言を理解すると、データの扱い方がわかるようになります。

次に、メソッド宣言を学びましょう。

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

そのあとで、クラスやプロパティの宣言に進むと理解しやすくなります。

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

学ぶ順番としては、変数宣言、型の基本、メソッド宣言、クラス宣言、プロパティ宣言の流れがおすすめです。

まとめ

C#の宣言とは、変数、定数、型、メソッド、クラス、プロパティなどを使うために、名前や型、役割をプログラムに伝えることです。

変数宣言では、次のように型と変数名を書きます。

C#
int number;
string name;

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

C#
int number = 10;
string name = "田中";

メソッド宣言では、戻り値の型、メソッド名、引数を指定します。

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

クラス宣言では、データや処理をまとめる設計図を作ります。

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

C#は型を重視する言語なので、宣言を正しく理解することがとても大切です。宣言を覚えると、コードの意味が読み取りやすくなり、エラーの原因も見つけやすくなります。

まずは変数宣言から始めて、少しずつメソッド、クラス、プロパティの宣言へと学習を進めていきましょう。