C#のdynamicとは？動的型付け・リフレクションとの違いと使いどころを初心者向けに解説

はじめに

C#は基本的に「静的型付け言語」です。つまり、変数やオブジェクトの型はコンパイル時にチェックされ、間違った型の使い方をしていると実行前にエラーとして検出されます。

一方で、C#にはdynamicというキーワードがあります。dynamicを使うと、型のチェックをコンパイル時ではなく実行時に行えるようになります。

「C# 動的」と検索している方の中には、次のような疑問を持っている人も多いでしょう。

C#で動的に型を扱うとはどういうことか、dynamicとvarやobjectは何が違うのか、リフレクションとはどう使い分けるのか、初心者が使ってもよいのか。

この記事では、C#のdynamicについて、動的型付け・リフレクションとの違い、メリット・デメリット、使いどころ、注意点を初心者向けにわかりやすく解説します。

1. C#のdynamicとは？初心者向けにわかりやすく解説

C#のdynamicとは、変数やオブジェクトの型チェックをコンパイル時ではなく、実行時に行うための仕組みです。

通常のC#では、存在しないメソッドやプロパティを呼び出すと、コンパイルエラーになります。しかしdynamicを使うと、そのチェックは実行時まで先送りされます。

1-1. dynamicは「コンパイル時」ではなく「実行時」に型チェックする仕組み

通常のC#コードでは、次のように存在しないメソッドを呼び出すとコンパイルエラーになります。

C#
string text = "Hello";
text.SampleMethod(); // コンパイルエラー

しかし、dynamicを使うとコンパイルは通ります。

C#
dynamic text = "Hello";
text.SampleMethod(); // 実行時エラー

この場合、コンパイル時にはエラーになりませんが、実行時にSampleMethodというメソッドが存在しないためエラーになります。

つまり、dynamicは「書いた時点では型を厳密に確認せず、実行するときに確認する」仕組みです。

1-2. C#は静的型付け言語だがdynamicで一部だけ動的に扱える

C#はJavaやC++と同じく、静的型付け言語に分類されます。

静的型付け言語では、変数の型があらかじめ決まっているため、コードの安全性が高く、IDEの補完やリファクタリングも効きやすいというメリットがあります。

ただし、外部API、JSON、COM、スクリプト連携などでは、実行時まで型がはっきりしないデータを扱うことがあります。

そのような場面で、C#の一部だけを動的に扱えるようにするのがdynamicです。

1-3. dynamicを使うと何が便利になるのか

dynamicを使うと、キャストやリフレクションを使わずに、実行時に決まるメンバーへアクセスできます。

たとえば、外部から取得したデータの構造が柔軟な場合、次のように直感的にプロパティへアクセスできます。

C#
dynamic user = GetUserData();
Console.WriteLine(user.Name);
Console.WriteLine(user.Age);

このように、型が事前に明確でないオブジェクトでも、通常のオブジェクトのように書ける点が便利です。

1-4. dynamicで書ける基本コード例

C#
dynamic value = "Hello C#";

Console.WriteLine(value.Length);
Console.WriteLine(value.ToUpper());

このコードでは、valueはdynamicとして宣言されていますが、実行時の中身はstringです。そのため、LengthプロパティやToUpperメソッドを呼び出せます。

次のように、途中で別の型を代入することもできます。

C#
dynamic value = "Hello";
Console.WriteLine(value.Length);

value = 123;
Console.WriteLine(value + 10);

dynamicは実行時の値に応じて処理が決まるため、柔軟なコードを書けます。

2. C#における「動的」とは何を意味するのか

C#における「動的」とは、主に「実行時に型やメンバーを解決する」という意味です。

通常のC#では、変数の型や呼び出せるメソッドはコンパイル時に決まります。一方、dynamicを使うと、実行時に実際の値を見て、呼び出すメソッドやプロパティが決まります。

2-1. 静的型付けと動的型付けの違い

静的型付けとは、コンパイル時に型が決まる仕組みです。

C#
int number = 10;
string text = "Hello";

この場合、numberはint、textはstringとして扱われます。異なる型の使い方をすると、コンパイル時にエラーになります。

一方、動的型付けでは、実行時の値によって型が判断されます。PythonやJavaScriptなどは動的型付け言語の代表例です。

C#は静的型付け言語ですが、dynamicを使うことで一部だけ動的型付けのように扱えます。

2-2. C#の通常の型チェックの仕組み

通常のC#では、コンパイラがコードをチェックします。

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

intにはLengthプロパティがないため、このコードはコンパイルエラーになります。

この仕組みにより、実行前に多くのミスを発見できます。C#の型安全性は、バグを減らすうえで大きなメリットです。

2-3. dynamicを使った場合の型チェックの流れ

dynamicを使うと、コンパイラは細かい型チェックを行いません。

C#
dynamic number = 10;
Console.WriteLine(number.Length);

このコードはコンパイルできます。しかし、実行時にintにはLengthがないためエラーになります。

つまり、dynamicでは次のような流れになります。

コンパイル時には「その呼び出しが正しいか」を厳密に確認しません。実行時に実際の型を見て、呼び出せるメンバーかどうかを判断します。

2-4. 「C# 動的」で検索する人が混同しやすい用語

「C# 動的」という言葉で混同しやすいものには、次のようなものがあります。

dynamicは、実行時に型やメンバーを解決するためのキーワードです。

varは、コンパイル時に型推論を行うためのキーワードです。

objectは、すべての型の基底型として値を保持できる型です。

リフレクションは、型情報やメンバー情報を実行時に調べたり呼び出したりする仕組みです。

動的型付け言語は、言語全体が実行時に型を判断する言語です。

これらは似ているようで、それぞれ役割が異なります。

3. dynamic・var・objectの違い

C#でdynamicを理解するうえで、varやobjectとの違いは非常に重要です。

どれも「型を柔軟に扱う」ように見えますが、実際にはまったく違う仕組みです。

3-1. varはコンパイル時に型が決まる

varは型推論を行うためのキーワードです。

C#
var text = "Hello";

この場合、コンパイラは右辺の"Hello"を見て、textをstring型だと判断します。

つまり、varは見た目上は型を書いていないだけで、実際にはコンパイル時に型が決まっています。

C#
var text = "Hello";
text = 123; // コンパイルエラー

textはstring型として決まっているため、後からintを代入することはできません。

3-2. objectはすべての型を代入できるがメンバー呼び出しにはキャストが必要

objectはC#のすべての型の基底型です。そのため、さまざまな値を代入できます。

C#
object value = "Hello";

ただし、object型のままではstring固有のメンバーを直接呼び出せません。

C#
object value = "Hello";
Console.WriteLine(value.Length); // コンパイルエラー

Lengthを使いたい場合は、キャストが必要です。

C#
object value = "Hello";
string text = (string)value;
Console.WriteLine(text.Length);

3-3. dynamicはメンバー呼び出しも実行時に解決される

dynamicでは、メンバー呼び出しも実行時に解決されます。

C#
dynamic value = "Hello";
Console.WriteLine(value.Length);

このコードはコンパイルでき、実行時にvalueがstringであることが確認されるため、Lengthを呼び出せます。

ただし、存在しないメンバーを呼び出した場合もコンパイル時には検出できません。

C#
dynamic value = "Hello";
Console.WriteLine(value.NotExists); // 実行時エラー

3-4. dynamic・var・objectの比較表

varは型を省略するだけです。objectは何でも入れられますが、使うときにキャストが必要です。dynamicは何でも入れられ、メンバー呼び出しも実行時に解決されます。

3-5. どれを使うべきか判断する基準

基本的には、まず通常の型指定またはvarを使うのがおすすめです。

型が明確で、コンパイル時にチェックしたい場合は、通常の型やvarを使います。

複数の型を共通して保持したいだけなら、objectを使うことがあります。

型やメンバーが実行時までわからない場合、外部APIやCOM連携などで柔軟に扱いたい場合は、dynamicが候補になります。

ただし、初心者が普段のコードで安易にdynamicを使うのはおすすめしません。

4. dynamicとリフレクションの違い

dynamicとリフレクションは、どちらも実行時に型やメンバーを扱える仕組みです。

しかし、目的や書き方、向いている場面は異なります。

4-1. リフレクションとは何か

リフレクションとは、実行時に型情報を取得したり、プロパティやメソッドを調べたり、呼び出したりする機能です。

たとえば、次のように型情報を取得できます。

C#
Type type = typeof(string);
Console.WriteLine(type.Name);

また、オブジェクトのプロパティ名を文字列で指定して値を取得することもできます。

C#
var person = new Person { Name = "Taro" };

var property = typeof(Person).GetProperty("Name");
var value = property.GetValue(person);

Console.WriteLine(value);

リフレクションは、フレームワーク、ライブラリ、シリアライザ、DIコンテナなどでよく使われます。

4-2. dynamicとリフレクションの共通点

dynamicとリフレクションには、実行時に処理が決まるという共通点があります。

通常のC#ではコンパイル時に決まるメンバー呼び出しを、実行時に解決できる点が似ています。

ただし、dynamicは通常のコードに近い見た目で書けます。一方、リフレクションは型情報やメンバー情報を明示的に扱うため、コードがやや複雑になります。

4-3. dynamicのほうがコードを簡潔に書けるケース

たとえば、Nameプロパティを取得したい場合、dynamicなら次のように書けます。

C#
dynamic person = GetPerson();
Console.WriteLine(person.Name);

リフレクションでは、次のように書く必要があります。

C#
object person = GetPerson();
var property = person.GetType().GetProperty("Name");
var value = property.GetValue(person);

Console.WriteLine(value);

単純にプロパティやメソッドを呼び出したいだけなら、dynamicのほうが直感的です。

4-4. リフレクションのほうが向いているケース

リフレクションは、型の構造を調べたい場合に向いています。

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

クラスにどのプロパティがあるか調べたい場合、属性を読み取りたい場合、メソッド一覧を取得したい場合、文字列で指定されたメソッドを呼び出したい場合、汎用的なライブラリを作りたい場合。

dynamicは「存在するはずのメンバーを呼び出す」用途に向いていますが、「型情報そのものを解析する」用途にはリフレクションのほうが適しています。

4-5. dynamicとリフレクションの使い分け早見表

5. dynamicの主な使いどころ

dynamicは便利ですが、どこでも使うべきものではありません。主な使いどころは、型が実行時まで確定しない場面です。

5-1. JSONや外部APIのレスポンスを柔軟に扱いたいとき

外部APIから返ってくるJSONは、構造が柔軟なことがあります。

C#
dynamic user = GetJsonData();
Console.WriteLine(user.name);
Console.WriteLine(user.email);

このように、事前に厳密なクラスを用意しなくても値にアクセスできます。

ただし、本番コードではDTOクラスを定義して扱うほうが安全な場合が多いです。

5-2. COMやOffice連携など外部コンポーネントを操作するとき

dynamicは、ExcelやWordなどのOfficeアプリケーションをCOM経由で操作する場面でも使われます。

COMオブジェクトは型情報が扱いづらいことがあるため、dynamicを使うことでコードを簡潔に書ける場合があります。

C#
dynamic excel = Activator.CreateInstance(Type.GetTypeFromProgID("Excel.Application"));
excel.Visible = true;

このような外部コンポーネント連携では、dynamicが役立つことがあります。

5-3. 型が実行時まで確定しないオブジェクトを扱うとき

プラグイン、外部モジュール、設定ファイルから生成されるオブジェクトなど、実行時まで型が確定しないケースがあります。

そのような場合、dynamicを使うことで柔軟に処理できます。

C#
dynamic plugin = LoadPlugin();
plugin.Execute();

ただし、可能であればインターフェースを定義して扱うほうが安全です。

5-4. 動的言語やスクリプトとの連携を行うとき

C#から動的言語やスクリプト環境と連携する場合、実行時に型が決まるデータを扱うことがあります。

そのような場面では、dynamicを使うことで動的言語に近い感覚でコードを書けます。

5-5. プロトタイプや検証コードを素早く書きたいとき

まだデータ構造が固まっていない段階では、dynamicを使うと素早く試せることがあります。

ただし、検証コードでは便利でも、本番コードにそのまま残すと保守性が下がる可能性があります。

プロトタイプで使ったdynamicは、後からDTO、インターフェース、明確な型定義に置き換えることを検討しましょう。

6. dynamicのメリット

dynamicには、C#で動的にデータを扱えるという大きなメリットがあります。

6-1. キャストを減らしてコードを短くできる

objectを使う場合、具体的な型のメンバーを呼び出すにはキャストが必要です。

C#
object value = "Hello";
Console.WriteLine(((string)value).Length);

dynamicなら、キャストを書かずに呼び出せます。

C#
dynamic value = "Hello";
Console.WriteLine(value.Length);

コードが短くなり、読みやすくなる場合があります。

6-2. 型が不明なデータを柔軟に扱える

外部API、JSON、COM、スクリプトなどでは、事前に型がわからないことがあります。

dynamicを使うと、実行時の型に応じて柔軟に処理できます。

これは、静的型付けのC#に動的な柔軟性を加える仕組みだと言えます。

6-3. リフレクションより直感的に書ける場合がある

単純にプロパティやメソッドへアクセスしたいだけなら、リフレクションよりdynamicのほうが直感的です。

C#
dynamic item = GetItem();
Console.WriteLine(item.Name);

このように、通常のオブジェクト操作に近い形で書けます。

6-4. 外部ライブラリやAPIとの連携がしやすくなる

型が固定されていない外部ライブラリやAPIと連携する場合、dynamicを使うとコードが簡潔になることがあります。

特に、戻り値の構造が柔軟なAPIや、COMオブジェクトを扱う場面では便利です。

7. dynamicのデメリットと注意点

dynamicは便利ですが、使いすぎるとC#の強みである型安全性を失いやすくなります。

7-1. コンパイル時にエラーを検出しにくい

通常のC#では、存在しないメソッドやプロパティを呼び出すとコンパイルエラーになります。

しかしdynamicでは、実行するまでエラーがわかりません。

C#
dynamic user = GetUser();
Console.WriteLine(user.Nmae); // Nameのタイポでもコンパイルは通る

このようなタイプミスは、実行時に初めて問題になります。

7-2. 実行時エラーが発生しやすい

dynamicは実行時にメンバーを解決するため、想定と違う型が入っているとエラーになります。

C#
dynamic value = 10;
Console.WriteLine(value.ToUpper()); // 実行時エラー

intにはToUpperメソッドがないため、実行時に失敗します。

7-3. IDEの補完やリファクタリングが効きにくい

dynamicはコンパイル時に型が確定しないため、Visual StudioなどのIDEによる補完が効きにくくなります。

また、プロパティ名やメソッド名の変更にも追従しづらくなります。

大規模なプロジェクトでは、この点が保守性に大きく影響します。

7-4. 処理速度やパフォーマンスに注意が必要

dynamicは実行時に型やメンバーを解決するため、通常の静的型付けの呼び出しよりオーバーヘッドがあります。

小さな処理では問題にならないことも多いですが、大量ループや高頻度で呼ばれる処理では注意が必要です。

パフォーマンスが重要な箇所では、通常の型指定を使うほうが安全です。

7-5. 保守性が下がりやすい

dynamicを多用すると、コードを読んだときに「この変数には何が入っているのか」がわかりにくくなります。

型が明確でないコードは、修正やテストが難しくなります。

チーム開発では特に、dynamicを使う範囲を限定することが重要です。

8. dynamicでよくあるエラーと対処法

dynamicを使うときによく発生するのが、実行時のバインドエラーです。

8-1. RuntimeBinderExceptionが発生する原因

dynamicで存在しないメンバーを呼び出した場合、RuntimeBinderExceptionが発生します。

C#
dynamic value = "Hello";
Console.WriteLine(value.NotExists);

stringにはNotExistsというプロパティがないため、実行時に例外が発生します。

8-2. 存在しないプロパティやメソッドを呼び出した場合

よくある原因は、プロパティ名やメソッド名のタイプミスです。

C#
dynamic user = GetUser();
Console.WriteLine(user.Nmae);

本来はNameと書くべきところをNmaeと書いても、コンパイル時には検出されません。

対策としては、可能な限りDTOや明確な型を使うことです。

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

型を定義すれば、タイプミスをコンパイル時に検出できます。

8-3. 型変換に失敗する場合

dynamicの値を別の型として扱おうとしたとき、型変換に失敗することがあります。

C#
dynamic value = "abc";
int number = value; // 実行時エラー

この場合、"abc"はintに変換できないためエラーになります。

必要に応じて、TryParseなどを使いましょう。

C#
dynamic value = "123";

if (int.TryParse(value, out int number))
{
    Console.WriteLine(number);
}

8-4. nullを扱うときの注意点

dynamicにnullが入っている状態でメンバーを呼び出すと、実行時エラーになります。

C#
dynamic user = null;
Console.WriteLine(user.Name); // 実行時エラー

事前にnullチェックを行いましょう。

C#
dynamic user = GetUser();

if (user != null)
{
    Console.WriteLine(user.Name);
}

8-5. dynamicのエラーを防ぐ書き方

dynamicのエラーを防ぐには、次の点を意識しましょう。

dynamicを使う範囲を狭くすること、外部データを受け取ったら早めに型付きクラスへ変換すること、プロパティ名やメソッド名のタイプミスに注意すること、nullチェックを行うこと、例外処理を入れること。

C#
try
{
    dynamic user = GetUser();
    Console.WriteLine(user.Name);
}
catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException ex)
{
    Console.WriteLine($"dynamicの呼び出しに失敗しました: {ex.Message}");
}

ただし、例外処理に頼りすぎるより、型を明確にする設計のほうが望ましいです。

9. dynamicを使うべき場面・使わないほうがよい場面

dynamicは便利な機能ですが、使いどころを間違えるとバグの原因になります。

9-1. dynamicを使ってもよい場面

dynamicを使ってもよいのは、型が実行時まで確定しない場面です。

たとえば、COM連携、外部APIの柔軟なレスポンス、動的言語との連携、プロトタイプ作成、リフレクションを簡潔に書きたい一部の処理などです。

このような場面では、dynamicによってコードを短く、直感的に書けることがあります。

9-2. dynamicを避けたほうがよい場面

通常の業務ロジック、ドメインモデル、データベース処理、長期的に保守するコードでは、dynamicを避けたほうがよい場合が多いです。

理由は、型安全性が下がり、コンパイル時にミスを検出しづらくなるためです。

特に、チーム開発や大規模開発では、型が明確なコードのほうが読みやすく保守しやすくなります。

9-3. 型安全性を重視するなら通常の型定義を使う

型安全性を重視するなら、通常のクラスや構造体を定義しましょう。

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

このように型を定義しておけば、IDEの補完も効き、タイプミスもコンパイル時に検出できます。

9-4. DTO・ジェネリクス・インターフェースで代替できるケース

dynamicを使わなくても、DTO、ジェネリクス、インターフェースで解決できることは多いです。

外部APIのレスポンスを扱うならDTOを定義する、複数の型を共通処理したいならインターフェースを使う、型を汎用化したいならジェネリクスを使う、といった選択肢があります。

C#
public interface IExecutable
{
    void Execute();
}

C#
public void Run(IExecutable executable)
{
    executable.Execute();
}

このようにすれば、dynamicを使わずに柔軟で型安全な設計ができます。

9-5. 初心者がdynamicを使うときの判断ポイント

初心者がdynamicを使うときは、「通常の型では書けない理由があるか」を考えましょう。

単に型を書くのが面倒だからdynamicを使うのは避けるべきです。

まずは通常の型、var、DTO、インターフェース、ジェネリクスを理解し、それでも必要な場合にdynamicを使うのがおすすめです。

10. dynamicのサンプルコードで理解する実践例

ここでは、dynamicの動きをサンプルコードで確認します。

10-1. 基本的な代入とメソッド呼び出し

C#
dynamic value = "Hello C#";

Console.WriteLine(value);
Console.WriteLine(value.Length);
Console.WriteLine(value.ToUpper());

実行時のvalueはstringなので、LengthやToUpperを呼び出せます。

次に、intを代入してみます。

C#
dynamic value = 100;

Console.WriteLine(value + 50);

この場合は数値として処理されます。

10-2. objectとの違いがわかるコード例

C#
object obj = "Hello";
Console.WriteLine(obj.Length); // コンパイルエラー

object型では、Lengthを直接呼び出せません。

キャストすれば呼び出せます。

C#
object obj = "Hello";
Console.WriteLine(((string)obj).Length);

一方、dynamicなら次のように書けます。

C#
dynamic dyn = "Hello";
Console.WriteLine(dyn.Length);

dynamicでは、実行時にstringとして解決されるため、Lengthを呼び出せます。

10-3. varとの違いがわかるコード例

C#
var text = "Hello";
text = 123; // コンパイルエラー

varはコンパイル時にstring型として決まっています。そのため、後からintを代入できません。

一方、dynamicでは可能です。

C#
dynamic value = "Hello";
value = 123;
value = DateTime.Now;

Console.WriteLine(value);

dynamicは実行時に型が決まるため、さまざまな型の値を代入できます。

10-4. JSONデータをdynamicで扱う例

JSONを扱う場合、ライブラリによってはdynamicとしてアクセスできます。

C#
dynamic user = GetJsonUser();

Console.WriteLine(user.name);
Console.WriteLine(user.email);

ただし、プロパティ名を間違えてもコンパイル時には検出されません。

C#
Console.WriteLine(user.emali); // タイポでもコンパイルは通る

本番コードでは、次のようにDTOへ変換するほうが安全です。

C#
public class UserDto
{
    public string Name { get; set; }
    public string Email { get; set; }
}

10-5. dynamicで発生する実行時エラーの例

C#
dynamic value = 10;
Console.WriteLine(value.Length);

このコードはコンパイルできますが、実行時にエラーになります。

intにはLengthプロパティがないためです。

C#
dynamic value = "Hello";
Console.WriteLine(value.NotExists());

このコードも、NotExistsというメソッドが存在しないため実行時エラーになります。

dynamicを使う場合は、コンパイルが通っても安全とは限らない点に注意しましょう。

11. dynamicに関するよくある質問

11-1. dynamicは型安全ではないのか

dynamicは、通常のC#コードに比べると型安全性が低くなります。

コンパイル時に型チェックされない部分が増えるため、存在しないメンバーの呼び出しや型変換エラーが実行時までわかりません。

ただし、使いどころを限定すれば便利な機能です。

11-2. dynamicと動的型付け言語は同じなのか

同じではありません。

C#は基本的に静的型付け言語です。dynamicを使った部分だけ、動的型付けのように実行時に型やメンバーを解決します。

つまり、C#全体が動的型付け言語になるわけではありません。

11-3. dynamicは現在でも使われているのか

dynamicは現在でも使われています。

特に、COM連携、Office操作、動的データの処理、外部APIとの連携、スクリプト連携などで使われることがあります。

ただし、通常のアプリケーション開発では、DTOや明確な型定義を使うほうが一般的です。

11-4. dynamicはリフレクションより高速なのか

ケースによります。

dynamicは内部的に実行時バインディングを行います。呼び出しがキャッシュされる場合もありますが、通常の静的型付けの呼び出しよりはオーバーヘッドがあります。

リフレクションと比べた場合も、処理内容や呼び出し回数によって結果は変わります。

パフォーマンスが重要な処理では、実際に計測して判断することが大切です。

11-5. 初心者はdynamicを覚えるべきか

初心者もdynamicの存在と基本的な意味は覚えておくとよいです。

ただし、最初から多用する必要はありません。

まずは、通常の型指定、var、object、クラス、インターフェース、ジェネリクスを理解することが重要です。

そのうえで、型が実行時までわからない場面に出会ったとき、dynamicを選択肢として使えるようにしておくとよいでしょう。

まとめ

C#のdynamicは、型やメンバーのチェックをコンパイル時ではなく実行時に行うための仕組みです。

C#は基本的に静的型付け言語ですが、dynamicを使うことで一部の処理を動的に扱えます。

varはコンパイル時に型が決まる型推論、objectはすべての型を保持できる基底型、dynamicは実行時に型やメンバーを解決する仕組みです。

また、dynamicとリフレクションはどちらも実行時に型を扱えますが、dynamicは通常のコードに近く簡潔に書ける一方、リフレクションは型情報やメンバー情報を詳しく調べる用途に向いています。

dynamicは、JSONや外部API、COM連携、動的言語との連携、プロトタイプ作成などで役立ちます。

一方で、コンパイル時にエラーを検出しにくい、実行時エラーが発生しやすい、IDE補完が効きにくい、保守性が下がりやすいといった注意点もあります。

初心者は、まず通常の型定義やvar、objectとの違いを理解し、必要な場面に限定してdynamicを使うことが大切です。