【C#入門】クラスの呼び出し方を初心者向けにわかりやすく解説！インスタンス化・メソッド実行まで完全理解
はじめに
C#を学び始めたばかりの方がつまずきやすいポイントのひとつに、「クラスの呼び出し方」があります。
クラスを定義したものの、どうやって使えばよいのか、newとは何なのか、メソッドやプロパティはどのように呼び出すのかがわからず、手が止まってしまうことも多いです。
C#では、クラスを使うために「インスタンス化して呼び出す方法」と、「staticを使ってクラス名から直接呼び出す方法」があります。この違いを理解すると、C#のクラス設計やプログラムの流れが一気にわかりやすくなります。
この記事では、C#におけるクラスの呼び出し方を初心者向けに、インスタンス化、メソッド実行、プロパティアクセス、staticメソッドの呼び出し、別ファイル・別クラスからの呼び出しまで順番に解説します。
1. C#の「クラスの呼び出し」とは？初心者がまず理解すべき基本
C#でクラスを呼び出すとは、簡単にいうと「定義したクラスを実際に使うこと」です。
クラスは作っただけでは処理を実行しません。クラスの中に書いたメソッドやプロパティを使うには、クラスからオブジェクトを作ったり、staticメンバーをクラス名から呼び出したりする必要があります。
まずは、クラス、オブジェクト、インスタンス、メソッド、プロパティの関係を整理しておきましょう。
1-1. クラスは「設計図」、オブジェクトは「実体」
C#のクラスは、よく「設計図」にたとえられます。
たとえば、車を表すCarクラスがあるとします。クラスには、車の名前や色などのデータ、走る・止まるといった動作を定義できます。
C#class Car
{
public string Name { get; set; }
public void Drive()
{
Console.WriteLine("車が走ります");
}
}
このCarクラスは、あくまで「車とはこういう情報や動作を持つものです」という設計図です。
実際に使うには、次のようにオブジェクトを作成します。
C#Car myCar = new Car();
このmyCarが、クラスから作られた実体です。
つまり、クラスは設計図、オブジェクトはその設計図から作られた実体と考えると理解しやすくなります。
1-2. C#でクラスを呼び出すとはどういう意味か
C#で「クラスを呼び出す」と言う場合、主に次のような操作を指します。
C#Car myCar = new Car();
myCar.Drive();
このコードでは、まずnew Car()でCarクラスのインスタンスを作成し、その後myCar.Drive()でメソッドを呼び出しています。
厳密には、クラスそのものを呼び出すというより、「クラスから作ったインスタンスを通して、メソッドやプロパティを使う」と考えると正確です。
ただし、staticメソッドの場合はインスタンス化せずに、クラス名から直接呼び出します。
C#Math.Abs(-10);
このように、C#のクラス呼び出しには「インスタンスから呼び出す方法」と「クラス名から直接呼び出す方法」があります。
1-3. クラス・インスタンス・メソッド・プロパティの関係
C#のクラスを理解するには、次の関係を押さえることが大切です。
クラスは、データや処理をまとめた設計図です。
インスタンスは、クラスから作られた実体です。
メソッドは、クラスの中に定義された処理です。
プロパティは、クラスが持つ値や状態です。
例を見てみましょう。
C#class Person
{
public string Name { get; set; }
public void SayHello()
{
Console.WriteLine($"こんにちは、{Name}です");
}
}
このPersonクラスには、Nameというプロパティと、SayHelloというメソッドがあります。
呼び出すときは次のように書きます。
C#Person person = new Person();
person.Name = "田中";
person.SayHello();
実行結果は次のようになります。
こんにちは、田中です
このように、インスタンスを作成し、そのインスタンスを通してプロパティやメソッドを呼び出します。
1-4. 初心者が混同しやすい「定義」と「呼び出し」の違い
C#初心者が混同しやすいのが、「クラスを定義すること」と「クラスを呼び出すこと」の違いです。
クラスの定義とは、クラスの中身を書くことです。
C#class Calculator
{
public int Add(int a, int b)
{
return a + b;
}
}
この時点では、Addメソッドはまだ実行されていません。
実際に処理を使うには、次のように呼び出します。
C#Calculator calculator = new Calculator();
int result = calculator.Add(3, 5);
Console.WriteLine(result);
実行結果は次のとおりです。
8
定義は「使えるように準備すること」、呼び出しは「実際に使うこと」です。
この違いを理解すると、C#のクラス呼び出しがかなりわかりやすくなります。
2. C#でクラスを呼び出す基本手順
C#でクラスを呼び出す基本的な流れは、次のとおりです。
まずクラスを定義します。次にnew演算子でインスタンス化します。そして、作成したインスタンスからメソッドやプロパティを呼び出します。
この流れは、C#のクラス操作の基本です。
2-1. クラスを定義する
最初に、呼び出したいクラスを定義します。
C#class Dog
{
public string Name { get; set; }
public void Bark()
{
Console.WriteLine($"{Name}がワンワンと鳴きました");
}
}
このDogクラスには、犬の名前を表すNameプロパティと、鳴く動作を表すBarkメソッドがあります。
クラスを定義しただけでは、まだBarkメソッドは実行されません。呼び出すためには、次の手順が必要です。
2-2. new演算子でインスタンス化する
クラスを使うには、基本的にnew演算子を使ってインスタンス化します。
C#Dog dog = new Dog();
左側のDogは変数の型、dogはインスタンスを入れる変数名、右側のnew Dog()は新しいDogオブジェクトを作成する処理です。
このように書くことで、Dogクラスを実際に使える状態になります。
2-3. インスタンスからメソッドを呼び出す
インスタンスを作成したら、ドット.を使ってメソッドを呼び出します。
C#dog.Bark();
このように、インスタンス名.メソッド名()という形で呼び出します。
メソッド名の後ろには、必ず丸かっこ()を付けます。引数がない場合でも、丸かっこは必要です。
2-4. インスタンスからプロパティにアクセスする
プロパティに値を設定したり取得したりするときも、ドット.を使います。
C#dog.Name = "ポチ";
Console.WriteLine(dog.Name);
プロパティへの代入は、通常の変数と同じように書けます。
C#インスタンス名.プロパティ名 = 値;
取得するときも同じです。
C#値 = インスタンス名.プロパティ名;
2-5. クラス呼び出しの基本コード例
ここまでの流れをまとめると、次のようになります。
C#using System;
class Dog
{
public string Name { get; set; }
public void Bark()
{
Console.WriteLine($"{Name}がワンワンと鳴きました");
}
}
class Program
{
static void Main()
{
Dog dog = new Dog();
dog.Name = "ポチ";
dog.Bark();
}
}
実行結果は次のとおりです。
ポチがワンワンと鳴きました
このコードでは、Dogクラスを定義し、Mainメソッドの中でDogクラスをインスタンス化して、プロパティとメソッドを呼び出しています。
C#でクラスを呼び出す基本は、この形を理解することから始まります。
3. インスタンス化してクラスを呼び出す方法
C#でクラスを呼び出す最も基本的な方法は、インスタンス化してから使う方法です。
インスタンス化とは、クラスという設計図から、実際に使えるオブジェクトを作成することです。
3-1. インスタンス化とは何か
インスタンス化とは、クラスから実体を作ることです。
たとえば、Personクラスを定義しただけでは、まだ具体的な人物は存在しません。
C#class Person
{
public string Name { get; set; }
}
このクラスから、具体的な人物を作るには次のように書きます。
C#Person person = new Person();
これで、personというインスタンスが作成されます。
インスタンス化することで、プロパティに値を入れたり、メソッドを呼び出したりできるようになります。
3-2. new クラス名() の基本構文
インスタンス化の基本構文は次のとおりです。
C#クラス名 変数名 = new クラス名();
具体例は次のようになります。
C#Person person = new Person();
このコードでは、Person型の変数personに、新しく作成したPersonオブジェクトを代入しています。
C#では、クラスのインスタンスを作るときにnew演算子を使うのが基本です。
3-3. インスタンス変数を使ったメソッド呼び出し
インスタンスを作成したら、その変数を使ってメソッドを呼び出します。
C#class Greeting
{
public void SayGoodMorning()
{
Console.WriteLine("おはようございます");
}
}
class Program
{
static void Main()
{
Greeting greeting = new Greeting();
greeting.SayGoodMorning();
}
}
実行結果は次のとおりです。
おはようございます
ここでは、Greetingクラスをnew Greeting()でインスタンス化し、greeting.SayGoodMorning()でメソッドを呼び出しています。
3-4. 複数のインスタンスを作成する場合の動き
同じクラスから、複数のインスタンスを作成することもできます。
C#class User
{
public string Name { get; set; }
public void ShowName()
{
Console.WriteLine($"ユーザー名: {Name}");
}
}
class Program
{
static void Main()
{
User user1 = new User();
user1.Name = "佐藤";
User user2 = new User();
user2.Name = "鈴木";
user1.ShowName();
user2.ShowName();
}
}
実行結果は次のようになります。
ユーザー名: 佐藤
ユーザー名: 鈴木
user1とuser2は、同じUserクラスから作られていますが、それぞれ別のインスタンスです。
そのため、Nameプロパティには別々の値を持たせることができます。
3-5. インスタンス化が必要なケース
インスタンス化が必要になるのは、オブジェクトごとに異なる状態を持たせたい場合です。
たとえば、ユーザー、商品、注文、社員、車などは、それぞれ異なる名前や価格、ID、状態を持ちます。
C#Product product1 = new Product();
Product product2 = new Product();
このように、同じクラスから複数のオブジェクトを作り、それぞれ違うデータを持たせる場合は、インスタンス化してクラスを呼び出すのが自然です。
一方で、共通の計算処理や便利な変換処理のように、個別の状態を持たなくてもよい処理は、staticメソッドとして定義することがあります。
4. staticクラス・staticメソッドを呼び出す方法
C#では、インスタンス化せずにクラスを呼び出す方法もあります。それがstaticを使った呼び出しです。
staticを使うと、newでインスタンスを作らずに、クラス名から直接メソッドやプロパティを呼び出せます。
4-1. staticとは何か
staticとは、インスタンスではなくクラスそのものに属することを表すキーワードです。
通常のメソッドは、インスタンスを作成してから呼び出します。
C#Sample sample = new Sample();
sample.Show();
一方、staticメソッドは、クラス名から直接呼び出します。
C#Sample.Show();
つまり、staticメンバーは「オブジェクトごとのデータ」ではなく、「クラス共通の処理や値」として扱われます。
4-2. インスタンス化せずにクラス名から呼び出す方法
staticメソッドの呼び出し構文は次のとおりです。
C#クラス名.メソッド名();
具体例を見てみましょう。
C#class Message
{
public static void Show()
{
Console.WriteLine("staticメソッドを呼び出しました");
}
}
class Program
{
static void Main()
{
Message.Show();
}
}
実行結果は次のとおりです。
staticメソッドを呼び出しました
このコードでは、new Message()を書いていません。Message.Show()のように、クラス名から直接メソッドを呼び出しています。
4-3. staticメソッドの基本コード例
staticメソッドは、計算処理や共通処理でよく使われます。
C#class Calculator
{
public static int Add(int a, int b)
{
return a + b;
}
}
class Program
{
static void Main()
{
int result = Calculator.Add(10, 20);
Console.WriteLine(result);
}
}
実行結果は次のようになります。
30
Calculator.Add(10, 20)のように、インスタンス化せずに呼び出せるため、単純な計算処理に向いています。
C#に用意されているMathクラスも、staticメソッドを多く持つ代表的なクラスです。
C#double result = Math.Sqrt(16);
Console.WriteLine(result);
実行結果は次のとおりです。
4
4-4. インスタンスメソッドとの違い
インスタンスメソッドとstaticメソッドの違いは、呼び出し方と扱うデータにあります。
インスタンスメソッドは、オブジェクトごとの状態を使う処理に向いています。
C#class Student
{
public string Name { get; set; }
public void ShowName()
{
Console.WriteLine(Name);
}
}
この場合、Nameはインスタンスごとに異なる値を持ちます。
C#Student student = new Student();
student.Name = "山田";
student.ShowName();
一方、staticメソッドは、個別のインスタンス状態に依存しない処理に向いています。
C#class Tax
{
public static int AddTax(int price)
{
return (int)(price * 1.1);
}
}
呼び出しは次のようになります。
C#int price = Tax.AddTax(1000);
個別の状態が必要ならインスタンスメソッド、共通処理ならstaticメソッドと考えるとわかりやすいです。
4-5. staticを使うべき場面と注意点
staticを使うべき場面は、主に次のようなケースです。
共通の計算処理をまとめたい場合、文字列変換などのユーティリティ処理を作りたい場合、インスタンスごとの状態を持つ必要がない場合です。
たとえば、次のような処理はstaticに向いています。
C#class StringUtil
{
public static bool IsEmpty(string text)
{
return string.IsNullOrEmpty(text);
}
}
呼び出しは次のようになります。
C#bool result = StringUtil.IsEmpty("");
ただし、何でもstaticにすればよいわけではありません。
staticはプログラム全体で共通のものとして扱われるため、状態を持たせすぎると管理が難しくなることがあります。
初心者のうちは、「データを持つものはインスタンス化する」「単純な共通処理はstaticにする」と考えるとよいでしょう。
5. 別ファイル・別クラスからクラスを呼び出す方法
C#では、クラスを別ファイルに分けて管理することがよくあります。
ファイルが分かれていても、同じプロジェクト内にあり、名前空間やアクセス修飾子が正しく設定されていれば、別ファイルのクラスを呼び出せます。
5-1. 同じ名前空間内のクラスを呼び出す
同じnamespace内にあるクラスは、基本的にそのまま呼び出せます。
たとえば、Person.csに次のクラスがあるとします。
C#namespace SampleApp
{
public class Person
{
public void SayHello()
{
Console.WriteLine("こんにちは");
}
}
}
Program.csも同じnamespaceであれば、次のように呼び出せます。
C#namespace SampleApp
{
class Program
{
static void Main()
{
Person person = new Person();
person.SayHello();
}
}
}
同じ名前空間内であれば、usingを書かなくてもクラス名だけで呼び出せます。
5-2. namespaceが異なる場合の呼び出し方
namespaceが異なる場合は、完全修飾名で呼び出すことができます。
たとえば、次のようなクラスがあるとします。
C#namespace SampleApp.Models
{
public class Customer
{
public void Show()
{
Console.WriteLine("顧客情報を表示します");
}
}
}
別のnamespaceから呼び出す場合は、次のように書けます。
C#class Program
{
static void Main()
{
SampleApp.Models.Customer customer = new SampleApp.Models.Customer();
customer.Show();
}
}
ただし、毎回長い名前を書くのは大変です。そのため、通常はusingを使います。
5-3. usingを使ってクラスを呼び出す
usingを使うと、namespaceを省略してクラス名だけで呼び出せます。
C#using SampleApp.Models;
class Program
{
static void Main()
{
Customer customer = new Customer();
customer.Show();
}
}
using SampleApp.Models;を書くことで、Customerクラスをそのまま呼び出せるようになります。
C#で別ファイル・別クラスからクラスを呼び出せない場合は、まずnamespaceとusingの指定を確認しましょう。
5-4. アクセス修飾子 public / private / internal の違い
クラスやメソッドを別の場所から呼び出すには、アクセス修飾子も重要です。
publicは、他のクラスからアクセスできます。
C#public class User
{
public void Show()
{
Console.WriteLine("ユーザーを表示します");
}
}
privateは、同じクラス内からしかアクセスできません。
C#class User
{
private void ShowSecret()
{
Console.WriteLine("秘密の処理です");
}
}
internalは、同じプロジェクト内からアクセスできます。
C#internal class Order
{
public void Show()
{
Console.WriteLine("注文を表示します");
}
}
別ファイルからクラスを呼び出したい場合は、クラスやメソッドがpublicになっているかを確認することが大切です。
5-5. 呼び出せないときに確認すべきポイント
別ファイルや別クラスから呼び出せないときは、次の点を確認しましょう。
クラス名やnamespaceのスペルが正しいか、usingが不足していないか、クラスやメソッドのアクセス修飾子がpublicになっているか、同じプロジェクトにファイルが含まれているかを確認します。
また、staticメソッドをインスタンスから呼び出そうとしていないか、逆にインスタンスメソッドをクラス名から呼び出そうとしていないかも確認しましょう。
たとえば、次のコードはエラーになります。
C#class Person
{
public void SayHello()
{
Console.WriteLine("こんにちは");
}
}
class Program
{
static void Main()
{
Person.SayHello();
}
}
SayHelloはインスタンスメソッドなので、正しくは次のように呼び出します。
C#Person person = new Person();
person.SayHello();
6. コンストラクタを使ったクラスの呼び出し方
C#では、クラスをインスタンス化するときにコンストラクタが呼び出されます。
コンストラクタを使うと、オブジェクト作成時に初期値を設定できます。
6-1. コンストラクタとは何か
コンストラクタとは、クラスからインスタンスが作成されるときに自動的に呼び出される特別なメソッドです。
コンストラクタはクラス名と同じ名前で定義します。
C#class Person
{
public Person()
{
Console.WriteLine("Personクラスのインスタンスが作成されました");
}
}
このクラスを呼び出すと、コンストラクタが自動で実行されます。
C#Person person = new Person();
実行結果は次のとおりです。
Personクラスのインスタンスが作成されました
6-2. 引数なしコンストラクタの呼び出し
引数なしコンストラクタは、次のように定義します。
C#class Animal
{
public Animal()
{
Console.WriteLine("Animalが作成されました");
}
}
呼び出し方は次のとおりです。
C#Animal animal = new Animal();
new Animal()と書いたタイミングで、引数なしコンストラクタが呼び出されます。
6-3. 引数ありコンストラクタの呼び出し
コンストラクタには引数を持たせることもできます。
C#class Person
{
public string Name { get; set; }
public Person(string name)
{
Name = name;
}
public void ShowName()
{
Console.WriteLine($"名前: {Name}");
}
}
呼び出すときは、newの丸かっこの中に値を渡します。
C#Person person = new Person("田中");
person.ShowName();
実行結果は次のとおりです。
名前: 田中
このように、引数ありコンストラクタを使うと、インスタンス作成と同時に値を設定できます。
6-4. コンストラクタで初期値を設定する方法
コンストラクタを使うと、プロパティに初期値を設定できます。
C#class Product
{
public string Name { get; set; }
public int Price { get; set; }
public Product(string name, int price)
{
Name = name;
Price = price;
}
public void Show()
{
Console.WriteLine($"{Name}: {Price}円");
}
}
呼び出しは次のようになります。
C#Product product = new Product("ノートPC", 120000);
product.Show();
実行結果は次のとおりです。
ノートPC: 120000円
このように、コンストラクタを使うと、必要な値を持った状態でクラスを呼び出せます。
6-5. コンストラクタ呼び出し時のよくあるエラー
コンストラクタでよくあるエラーは、引数の数や型が合っていないケースです。
たとえば、次のクラスを見てください。
C#class User
{
public User(string name)
{
Console.WriteLine(name);
}
}
このクラスは、文字列の引数が必要です。
そのため、次の呼び出しはエラーになります。
C#User user = new User();
正しくは次のように書きます。
C#User user = new User("佐藤");
また、引数の型が違っていてもエラーになります。
C#User user = new User(100);
Userコンストラクタはstring型を受け取るため、int型の値は渡せません。
コンストラクタ呼び出しでエラーが出た場合は、引数の数、順番、型を確認しましょう。
7. クラスのメソッド・プロパティを呼び出す実践例
ここからは、C#でクラスを呼び出し、メソッドやプロパティを使う実践的な例を見ていきます。
実際の開発では、クラスをインスタンス化し、値を設定し、メソッドを呼び出して処理を実行する流れがよく使われます。
7-1. メソッドを呼び出して処理を実行する
まずは、戻り値のないメソッドを呼び出す例です。
C#class Printer
{
public void PrintMessage()
{
Console.WriteLine("メッセージを表示します");
}
}
class Program
{
static void Main()
{
Printer printer = new Printer();
printer.PrintMessage();
}
}
実行結果は次のとおりです。
メッセージを表示します
戻り値がないメソッドは、処理を実行する目的で呼び出します。
7-2. 戻り値のあるメソッドを呼び出す
戻り値のあるメソッドは、呼び出した結果を変数に代入できます。
C#class Calculator
{
public int Add(int a, int b)
{
return a + b;
}
}
class Program
{
static void Main()
{
Calculator calculator = new Calculator();
int result = calculator.Add(5, 7);
Console.WriteLine(result);
}
}
実行結果は次のようになります。
12
calculator.Add(5, 7)を呼び出すと、計算結果の12が返されます。
戻り値のあるメソッドを呼び出すときは、その結果を変数に代入したり、別の処理に使ったりできます。
7-3. 引数を渡してメソッドを呼び出す
メソッドには、処理に必要な値を引数として渡せます。
C#class Greeter
{
public void SayHello(string name)
{
Console.WriteLine($"こんにちは、{name}さん");
}
}
class Program
{
static void Main()
{
Greeter greeter = new Greeter();
greeter.SayHello("田中");
}
}
実行結果は次のとおりです。
こんにちは、田中さん
この例では、SayHelloメソッドに"田中"という文字列を渡しています。
引数を使うことで、呼び出すたびに異なる値を使って処理を実行できます。
7-4. プロパティに値を代入・取得する
プロパティは、クラスが持つ値を扱うために使います。
C#class Book
{
public string Title { get; set; }
public int Price { get; set; }
}
class Program
{
static void Main()
{
Book book = new Book();
book.Title = "C#入門";
book.Price = 2500;
Console.WriteLine(book.Title);
Console.WriteLine(book.Price);
}
}
実行結果は次のようになります。
C#入門
2500
プロパティに値を代入するときは、book.Title = "C#入門";のように書きます。
取得するときは、book.Titleのように参照します。
7-5. サンプルコードで一連の流れを確認する
最後に、クラスの定義、インスタンス化、プロパティ設定、メソッド呼び出し、戻り値の取得までをまとめたサンプルを見てみましょう。
C#using System;
class Employee
{
public string Name { get; set; }
public int Salary { get; set; }
public Employee(string name, int salary)
{
Name = name;
Salary = salary;
}
public void ShowInfo()
{
Console.WriteLine($"社員名: {Name}");
Console.WriteLine($"給与: {Salary}円");
}
public int GetAnnualSalary()
{
return Salary * 12;
}
}
class Program
{
static void Main()
{
Employee employee = new Employee("山田", 300000);
employee.ShowInfo();
int annualSalary = employee.GetAnnualSalary();
Console.WriteLine($"年収: {annualSalary}円");
}
}
実行結果は次のとおりです。
社員名: 山田
給与: 300000円
年収: 3600000円
このコードでは、Employeeクラスを呼び出すために、まずnew Employee("山田", 300000)でインスタンス化しています。
その後、employee.ShowInfo()でメソッドを呼び出し、employee.GetAnnualSalary()で戻り値のあるメソッドを呼び出しています。
この流れを理解できれば、C#のクラス呼び出しの基本はかなり身についたといえます。
8. C#でクラスを呼び出せないときの原因と解決策
C#でクラスを呼び出そうとしたとき、コンパイルエラーが出ることがあります。
特に初心者の場合、原因はある程度パターン化されています。よくある原因と解決策を順番に確認しましょう。
8-1. クラス名やメソッド名のスペルミス
最も多い原因のひとつが、クラス名やメソッド名のスペルミスです。
C#は大文字と小文字を区別します。
C#class Person
{
public void SayHello()
{
Console.WriteLine("こんにちは");
}
}
このクラスに対して、次のように呼び出すとエラーになります。
C#person.sayhello();
正しくは次のように書きます。
C#person.SayHello();
SayHelloとsayhelloは別の名前として扱われるため、メソッド名の大文字・小文字を正確に合わせる必要があります。
8-2. インスタンス化していない
インスタンスメソッドを呼び出すには、先にインスタンス化が必要です。
次のコードはエラーになります。
C#class Person
{
public void SayHello()
{
Console.WriteLine("こんにちは");
}
}
class Program
{
static void Main()
{
Person.SayHello();
}
}
SayHelloはstaticメソッドではないため、クラス名から直接呼び出せません。
正しくは次のように書きます。
C#Person person = new Person();
person.SayHello();
インスタンスメソッドを呼び出すときは、newでオブジェクトを作成してから呼び出しましょう。
8-3. staticとインスタンスメンバーを混同している
staticメンバーとインスタンスメンバーの呼び出し方を混同すると、エラーになります。
staticメソッドはクラス名から呼び出します。
C#class Utility
{
public static void Show()
{
Console.WriteLine("staticメソッドです");
}
}
正しい呼び出し方は次のとおりです。
C#Utility.Show();
一方、インスタンスメソッドはインスタンスから呼び出します。
C#class User
{
public void Show()
{
Console.WriteLine("インスタンスメソッドです");
}
}
正しい呼び出し方は次のとおりです。
C#User user = new User();
user.Show();
「staticはクラス名から」「インスタンスメンバーはインスタンスから」と覚えると、混乱しにくくなります。
8-4. アクセス修飾子が原因で呼び出せない
アクセス修飾子がprivateになっていると、別のクラスから呼び出せません。
C#class User
{
private void Show()
{
Console.WriteLine("ユーザー情報");
}
}
このShowメソッドはprivateなので、次のように別クラスから呼び出すことはできません。
C#User user = new User();
user.Show();
別のクラスから呼び出したい場合は、publicにします。
C#class User
{
public void Show()
{
Console.WriteLine("ユーザー情報");
}
}
クラスやメソッドを外部から呼び出す必要がある場合は、アクセス修飾子を確認しましょう。
8-5. namespaceやusingの指定が不足している
別のnamespaceにあるクラスを呼び出す場合、usingが不足しているとクラス名を認識できないことがあります。
たとえば、次のようなクラスがあるとします。
C#namespace MyApp.Models
{
public class Product
{
}
}
別のファイルでProductを使う場合、次のようにusingを追加します。
C#using MyApp.Models;
class Program
{
static void Main()
{
Product product = new Product();
}
}
または、完全修飾名で呼び出すこともできます。
C#MyApp.Models.Product product = new MyApp.Models.Product();
クラスが見つからないエラーが出た場合は、namespaceとusingを確認しましょう。
8-6. コンパイルエラー別の対処法
C#でクラスを呼び出せないときによく見るエラーには、次のようなものがあります。
型または名前空間の名前が見つかりませんと表示された場合は、クラス名のスペル、namespace、using、ファイルがプロジェクトに含まれているかを確認します。
現在のコンテキストに存在しませんと表示された場合は、変数名やメソッド名が正しいか、宣言した場所から参照できるかを確認します。
オブジェクト参照がオブジェクト インスタンスに設定されていませんと表示された場合は、インスタンスがnullになっていないか確認します。
C#Person person = null;
person.SayHello();
このようなコードでは、personが実体を持っていないためエラーになります。
正しくは、インスタンス化してから呼び出します。
C#Person person = new Person();
person.SayHello();
エラーが出たときは、エラーメッセージをよく読み、「クラスが見つからないのか」「インスタンス化していないのか」「アクセスできないのか」を切り分けることが大切です。
9. 初心者が覚えておきたいクラス呼び出しの使い分け
C#のクラス呼び出しでは、インスタンス化して呼び出す方法と、staticで呼び出す方法を使い分けることが重要です。
どちらを使うべきか迷ったときは、「オブジェクトごとに状態を持つ必要があるか」を基準に考えると判断しやすくなります。
9-1. インスタンス化して呼び出す場合
インスタンス化して呼び出すのは、オブジェクトごとに異なるデータを持たせたい場合です。
たとえば、ユーザーごとに名前や年齢が違う場合は、インスタンス化して扱います。
C#class User
{
public string Name { get; set; }
public void ShowName()
{
Console.WriteLine(Name);
}
}
呼び出し例は次のとおりです。
C#User user1 = new User();
user1.Name = "田中";
User user2 = new User();
user2.Name = "佐藤";
user1.ShowName();
user2.ShowName();
それぞれのインスタンスが別々のNameを持てるため、ユーザーや商品、注文などのデータを表現するのに向いています。
9-2. staticで呼び出す場合
staticで呼び出すのは、個別の状態を持つ必要がない共通処理の場合です。
たとえば、消費税を計算する処理や、文字列をチェックする処理などです。
C#class PriceCalculator
{
public static int AddTax(int price)
{
return (int)(price * 1.1);
}
}
呼び出しは次のようになります。
C#int result = PriceCalculator.AddTax(1000);
Console.WriteLine(result);
staticメソッドはインスタンス化せずに呼び出せるため、便利な共通処理をまとめるときに役立ちます。
ただし、オブジェクトごとの状態を扱いたい場合には向いていません。
9-3. クラス設計で意識すべきポイント
クラスを設計するときは、そのクラスが「データを持つもの」なのか、「処理だけをまとめるもの」なのかを意識しましょう。
たとえば、User、Product、Orderのようなクラスは、データを持つためインスタンス化して使うことが多いです。
C#Product product = new Product();
一方、Calculator、StringUtil、DateUtilのようなクラスは、共通処理をまとめる目的でstaticにすることがあります。
C#int result = Calculator.Add(1, 2);
初心者のうちは、まずインスタンス化して呼び出す基本をしっかり理解し、その後でstaticの使いどころを覚えるとよいでしょう。
9-4. 実務でよく使うクラス呼び出しのパターン
実務では、クラスの呼び出しはさまざまな形で使われます。
たとえば、サービスクラスをインスタンス化して処理を実行するパターンがあります。
C#UserService userService = new UserService();
userService.CreateUser("田中");
また、データを表すクラスに値を設定して使うパターンもあります。
C#User user = new User();
user.Name = "佐藤";
user.Age = 30;
さらに、共通処理をstaticメソッドとして呼び出すパターンもあります。
C#bool isEmpty = string.IsNullOrEmpty(user.Name);
C#の開発では、これらの呼び出し方を組み合わせてプログラムを作っていきます。
最初は難しく感じるかもしれませんが、「インスタンス化するのか」「クラス名から直接呼び出すのか」を意識すれば、コードの意味が読み取りやすくなります。
まとめ
C#でクラスを呼び出す基本は、クラスを定義し、new演算子でインスタンス化し、作成したインスタンスからメソッドやプロパティを呼び出すことです。
C#Person person = new Person();
person.SayHello();
インスタンスメソッドは、オブジェクトごとの状態を扱うときに使います。ユーザー、商品、注文など、個別にデータを持つものはインスタンス化して呼び出すのが基本です。
一方、staticメソッドは、インスタンス化せずにクラス名から直接呼び出します。
C#Calculator.Add(1, 2);
共通の計算処理やユーティリティ処理など、個別の状態を持たない処理に向いています。
また、別ファイルや別クラスからクラスを呼び出す場合は、namespace、using、アクセス修飾子を確認することが大切です。呼び出せないときは、クラス名やメソッド名のスペル、インスタンス化の有無、staticとインスタンスメンバーの違いを見直しましょう。
C#のクラス呼び出しは、オブジェクト指向プログラミングの土台です。まずはnew クラス名()でインスタンス化し、インスタンス名.メソッド名()やインスタンス名.プロパティ名で呼び出す基本形をしっかり覚えることが、C#を理解する第一歩になります。