型

【C#】typeof と GetType で型名を取得する基本と応用テクニック

2025-05-16更新日: 2025-05-16

C#で型名を取得する最短手段は、静的ならtypeof(型).Name、インスタンスならobj.GetType().Nameです。

名前空間を含めたい場合はFullName、ジェネリックを正確に扱うならAssemblyQualifiedNameやToString()を使い分けると柔軟に扱えます。

目次から探す

型名取得の基本
取得できる型名のバリエーション
ジェネリック型の扱い
ネスト型・入れ子クラスの型名
- ‘+’ 記号で繋がる内部表現
- Reflection を用いた読みやすい表記への変換
Nullable 型とポインタ型の特例
- Nullable<T> の実体型取得
- ポインタや配列の識別
文字列化のカスタマイズ
- Type.ToString() のオーバーライド不可性
- 拡張メソッドでのフォーマット実装
パフォーマンスとキャッシュ
属性と型名取得
- カスタム属性内での typeof 使用
- AttributeTargets 型の識別
ジェネリック制約での typeof 応用
- where 句での型比較
- 他型との比較演算
switch 式・パターンマッチングとの連携
- 型パターンでの分岐
- is と switch の使い分け
デバッグとロギングでの活用
- ログ出力にフルネームを使う理由
- ConditionalAttribute で呼び出し制御
C# 最新バージョン動向
- nameof と typeof の併用
- マーシャリングでの型名使用
代表的な落とし穴
まとめ

C#を使った求人

読み込み中…

型名取得の基本

C#で型名を取得する際に最も基本的な方法として、typeof演算子とGetTypeメソッドがあります。

これらは似ているようで用途や動作が異なるため、まずはそれぞれの特徴を理解することが重要です。

typeof 演算子の概要

typeof演算子は、指定した型のSystem.Typeオブジェクトを取得するための構文です。

コンパイル時に型情報が決まっている場合に使います。

例えば、typeof(int)はSystem.Int32型のTypeオブジェクトを返します。

コンパイル時定数としての特性

typeofはコンパイル時に型が決定されるため、実行時のオーバーヘッドがほとんどありません。

これは、typeofで取得したTypeオブジェクトがコンパイル時に確定しているためです。

using System;
class Program
{
    static void Main()
    {
        // int型のTypeオブジェクトを取得
        Type intType = typeof(int);
        Console.WriteLine(intType.FullName); // System.Int32
    }
}

System.Int32

このように、typeofは型名を取得する際に非常に効率的です。

コンパイル時に型が決まっているため、型の指定ミスもコンパイルエラーとして検出されやすいメリットがあります。

型エイリアスと表示名の関係

C#にはintやstringなどの型エイリアスがありますが、typeofで取得した型名はCLRの正式な型名で表示されます。

例えば、typeof(int)はSystem.Int32を返し、typeof(string)はSystem.Stringを返します。

using System;
class Program
{
    static void Main()
    {
        Type intType = typeof(int);
        Type stringType = typeof(string);
        Console.WriteLine(intType.FullName);   // System.Int32
        Console.WriteLine(stringType.FullName); // System.String
    }
}

System.Int32
System.String

このように、C#のエイリアスはあくまで言語レベルの表記であり、typeofはCLRの型名を返すことを覚えておくとよいです。

GetType メソッドの概要

GetTypeメソッドは、オブジェクトの実行時の型情報を取得するために使います。

インスタンスメソッドであるため、対象のオブジェクトが存在しなければ呼び出せません。

ランタイム型情報の取得

GetTypeは実行時にオブジェクトの型を判別します。

例えば、基底クラスの変数に派生クラスのインスタンスが代入されている場合でも、実際の派生クラスの型を取得できます。

using System;
class Animal { }
class Dog : Animal { }
class Program
{
    static void Main()
    {
        Animal animal = new Dog();
        Type type = animal.GetType();
        Console.WriteLine(type.FullName); // Dogの型名が表示される
    }
}

Dog

このように、GetTypeは実行時の実際の型を取得できるため、動的な型判定に役立ちます。

null 可能性と例外回避

GetTypeはインスタンスメソッドなので、対象のオブジェクトがnullの場合はNullReferenceExceptionが発生します。

安全に型を取得したい場合は、nullチェックを必ず行う必要があります。

using System;
class Program
{
    static void Main()
    {
        object obj = null;
        if (obj != null)
        {
            Console.WriteLine(obj.GetType().FullName);
        }
        else
        {
            Console.WriteLine("オブジェクトがnullです");
        }
    }
}

オブジェクトがnullです

このように、GetTypeを使う際はnullの可能性を考慮して例外を防ぐことが大切です。

typeof と GetType の比較

typeofとGetTypeはどちらも型情報を取得しますが、使い方や用途が異なります。

ここでは両者の違いを整理します。

使い分けの指針

typeof
- コンパイル時に型が決まっている場合に使う
- 静的に型を指定してTypeオブジェクトを取得したいときに便利
- 例：属性の引数やジェネリック制約の指定など
GetType
- 実行時にオブジェクトの実際の型を知りたい場合に使う
- 動的な型判定やリフレクションでの型情報取得に適している
- 例：多態性のあるオブジェクトの型判定

静的メンバーとインスタンスメンバーの違い

typeofは型そのものに対して使うため、静的メンバーの型情報を取得するのに適しています。

一方、GetTypeはインスタンスの型を取得するため、インスタンスが必要です。

using System;
class Program
{
    static void Main()
    {
        // 静的メンバーの型取得
        Type staticType = typeof(DateTime);
        Console.WriteLine(staticType.FullName); // System.DateTime
        // インスタンスの型取得
        DateTime now = DateTime.Now;
        Type instanceType = now.GetType();
        Console.WriteLine(instanceType.FullName); // System.DateTime
    }
}

System.DateTime
System.DateTime

この例では両者とも同じ型を返しますが、GetTypeはインスタンスがなければ使えません。

コンパイル時と実行時のコスト

typeofはコンパイル時に型が決まるため、実行時のコストはほぼありません。

対してGetTypeは実行時に型情報を取得するため、わずかながらオーバーヘッドがあります。

大量の型判定を行う場合は、typeofを使える場面では積極的に使うことでパフォーマンス向上が期待できます。

以上がC#におけるtypeof演算子とGetTypeメソッドの基本的な使い方と違いです。

これらを理解することで、型名取得の場面で適切な方法を選べるようになります。

取得できる型名のバリエーション

C#のTypeオブジェクトから取得できる型名には複数のプロパティがあり、それぞれ用途や表示内容が異なります。

ここでは代表的なName、FullName、Namespace、AssemblyQualifiedNameの違いと特徴を詳しく見ていきます。

Name と FullName の違い

TypeのNameプロパティは型名のみを返し、FullNameは名前空間を含む完全修飾名を返します。

名前空間を含むかどうか

例えば、System.String型の場合、Nameは単にStringを返しますが、FullNameはSystem.Stringと名前空間を含めた完全な型名を返します。

using System;
class Program
{
    static void Main()
    {
        Type type = typeof(string);
        Console.WriteLine("Name: " + type.Name);         // String
        Console.WriteLine("FullName: " + type.FullName); // System.String
    }
}

Name: String
FullName: System.String

名前空間を含むFullNameは、同じ名前の型が異なる名前空間に存在する場合に区別するのに役立ちます。

一方、Nameは単純に型名だけが必要な場合に使います。

グローバル名前空間の扱い

名前空間が指定されていない型(グローバル名前空間に属する型)の場合、FullNameはnullを返すことがあります。

これは、名前空間が存在しないため完全修飾名が定義できないためです。

using System;
class MyClass { }
class Program
{
    static void Main()
    {
        Type type = typeof(MyClass);
        Console.WriteLine("Name: " + type.Name);         // MyClass
        Console.WriteLine("FullName: " + type.FullName); // null または MyClass
    }
}

Name: MyClass
FullName: MyClass

通常、グローバル名前空間の型はFullNameもNameと同じ値を返しますが、場合によってはnullになることもあるため注意が必要です。

Namespace プロパティで分割表示

Namespaceプロパティは型が属する名前空間を文字列で返します。

名前空間だけを取得したい場合に便利です。

using System;
class Program
{
    static void Main()
    {
        Type type = typeof(System.Text.StringBuilder);
        Console.WriteLine("Namespace: " + type.Namespace); // System.Text
        Console.WriteLine("Name: " + type.Name);           // StringBuilder
    }
}

Namespace: System.Text
Name: StringBuilder

名前空間と型名を分けて扱いたい場合は、NamespaceとNameを組み合わせて表示や処理を行うことが多いです。

AssemblyQualifiedName の活用

AssemblyQualifiedNameは型の完全修飾名に加え、その型が定義されているアセンブリの情報も含む文字列を返します。

これにより、同じ名前空間・型名でも異なるアセンブリに存在する型を区別できます。

using System;
class Program
{
    static void Main()
    {
        Type type = typeof(string);
        Console.WriteLine(type.AssemblyQualifiedName);
    }
}

System.String, System.Private.CoreLib, Version=7.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e

この文字列は、型名、アセンブリ名、バージョン、カルチャ、パブリックキーなどの情報を含みます。

バージョン番号とカルチャ情報の含意

AssemblyQualifiedNameに含まれるバージョン番号やカルチャ情報は、アセンブリの特定バージョンを識別するために重要です。

これにより、異なるバージョンの同じアセンブリに含まれる型を区別できます。

例えば、アプリケーションのバージョンアップや依存関係の管理で、特定のバージョンの型を指定したい場合に役立ちます。

AssemblyQualifiedName の短縮

AssemblyQualifiedNameは非常に長くなることが多いため、必要に応じて短縮して使うこともあります。

例えば、型名とアセンブリ名だけを取り出す方法です。

using System;
class Program
{
    static void Main()
    {
        Type type = typeof(string);
        string fullName = type.AssemblyQualifiedName;
        // 型名とアセンブリ名だけを抽出
        int commaIndex = fullName.IndexOf(',');
        string shortName = commaIndex > 0 ? fullName.Substring(0, commaIndex) : fullName;
        Console.WriteLine(shortName);
    }
}

System.String

このように、必要な情報だけを取り出して使うことで、表示や比較をシンプルにできます。

これらのプロパティを使い分けることで、用途に応じた型名の取得や表示が可能になります。

名前空間の有無やアセンブリ情報の必要性に応じて適切なプロパティを選択してください。

ジェネリック型の扱い

C#のジェネリック型は型安全性と再利用性を高めるために非常に重要ですが、型名を取得する際には特有の注意点があります。

ここではオープンジェネリックとクローズドジェネリックの違い、List<int>とList<>の型名の違い、そして型引数を展開したカスタムフォーマットの方法を詳しく説明します。

オープンジェネリックとクローズドジェネリック

ジェネリック型には「オープンジェネリック型」と「クローズドジェネリック型」があります。

オープンジェネリック型

型引数が指定されていないジェネリック型のことです。

例えば、List<>やDictionary<,>のように、型パラメータが未指定の状態を指します。

実際のインスタンスは作れません。

クローズドジェネリック型

型引数がすべて指定されたジェネリック型です。

例えば、List<int>やDictionary<string, int>など、具体的な型引数が与えられた状態です。

実際にインスタンス化可能です。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        // オープンジェネリック型の取得
        Type openGeneric = typeof(List<>);
        Console.WriteLine("オープンジェネリック型: " + openGeneric);
        // クローズドジェネリック型の取得
        Type closedGeneric = typeof(List<int>);
        Console.WriteLine("クローズドジェネリック型: " + closedGeneric);
    }
}

オープンジェネリック型: System.Collections.Generic.List`1[T]
クローズドジェネリック型: System.Collections.Generic.List`1[System.Int32]

このように、オープンジェネリック型は型パラメータ名(Tなど)が表示され、クローズドジェネリック型は具体的な型引数が表示されます。

List<int> と List<> の違い

List<int>はクローズドジェネリック型で、intという具体的な型引数が指定されています。

一方、List<>はオープンジェネリック型で、型引数が未指定のままです。

List<>のTypeオブジェクトのNameやFullNameには、バッククォート(`)と型引数の数が付加されます。

例えば、List<>はListの後に`1が付き、これは1つの型引数を持つことを示します。

using System;
using System.Collections.Generic;
class Program
{
    static void Main()
    {
        Type openType = typeof(List<>);
        Type closedType = typeof(List<int>);
        Console.WriteLine("オープンジェネリック Name: " + openType.Name);
        Console.WriteLine("クローズドジェネリック Name: " + closedType.Name);
        Console.WriteLine("オープンジェネリック FullName: " + openType.FullName);
        Console.WriteLine("クローズドジェネリック FullName: " + closedType.FullName);
    }
}

オープンジェネリック Name: List`1
クローズドジェネリック Name: List`1
オープンジェネリック FullName: System.Collections.Generic.List`1
クローズドジェネリック FullName: System.Collections.Generic.List`1[[System.Int32, System.Private.CoreLib, Version=8.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]]

NameやFullNameはどちらもバッククォートと型引数の数を含みますが、クローズドジェネリック型は型引数の具体的な型が[]内に表示されます。

型引数を展開したカスタムフォーマット

Typeの標準的な文字列表示はジェネリック型の型引数を展開してくれません。

例えば、List<int>のNameはList1のままで、int`の部分は表示されません。

これを見やすく展開するにはカスタムのフォーマット処理が必要です。

以下は、ジェネリック型の型引数を再帰的に展開して、人間にわかりやすい文字列を生成するサンプルコードです。

using System;
using System.Text;
class Program
{
    static void Main()
    {
        Type type1 = typeof(List<int>);
        Type type2 = typeof(Dictionary<string, List<double>>);
        Console.WriteLine(GetFriendlyName(type1)); // List<int>
        Console.WriteLine(GetFriendlyName(type2)); // Dictionary<string, List<double>>
    }
    static string GetFriendlyName(Type type)
    {
        if (!type.IsGenericType)
            return type.Name;
        StringBuilder sb = new StringBuilder();
        string name = type.Name;
        int backtickIndex = name.IndexOf('`');
        if (backtickIndex > 0)
        {
            sb.Append(name.Substring(0, backtickIndex));
        }
        else
        {
            sb.Append(name);
        }
        sb.Append('<');
        Type[] args = type.GetGenericArguments();
        for (int i = 0; i < args.Length; i++)
        {
            if (i > 0)
                sb.Append(", ");
            sb.Append(GetFriendlyName(args[i]));
        }
        sb.Append('>');
        return sb.ToString();
    }
}

List<Int32>
Dictionary<String, List<Double>>

このGetFriendlyNameメソッドは、型がジェネリックでなければそのままNameを返し、ジェネリック型の場合は型名からバッククォート以降を除去し、型引数を再帰的に展開して<>で囲んだ形式で返します。

この方法を使うと、複雑なネストしたジェネリック型も見やすく表示できるため、ログ出力やデバッグ時に役立ちます。

ネスト型・入れ子クラスの型名

C#ではクラスの中に別のクラスを定義する「ネスト型(入れ子クラス)」が利用できます。

こうしたネスト型の型名を取得するとき、通常の型名とは異なる表現が使われるため、理解しておくと便利です。

‘+’ 記号で繋がる内部表現

リフレクションでネスト型のFullNameを取得すると、親クラスと子クラスの名前が+記号で繋がった形式で返されます。

これはCLRの内部表現であり、C#のソースコードで使う.(ドット)とは異なります。

以下の例を見てみましょう。

using System;
class OuterClass
{
    public class InnerClass
    {
    }
}
class Program
{
    static void Main()
    {
        Type innerType = typeof(OuterClass.InnerClass);
        Console.WriteLine("Name: " + innerType.Name);
        Console.WriteLine("FullName: " + innerType.FullName);
    }
}

Name: InnerClass
FullName: OuterClass+InnerClass

このように、FullNameはOuterClass+InnerClassと表示され、+がネストの階層を示しています。

Nameは単にネストされたクラス名だけを返します。

Reflection を用いた読みやすい表記への変換

+記号を含むFullNameはそのままだと読みづらいため、ドット.に置き換えてC#のソースコードの表記に近づけることが多いです。

以下はFullNameの+を.に置換する簡単な方法です。

using System;
class OuterClass
{
    public class InnerClass
    {
    }
}
class Program
{
    static void Main()
    {
        Type innerType = typeof(OuterClass.InnerClass);
        string readableName = innerType.FullName?.Replace('+', '.');
        Console.WriteLine("読みやすい型名: " + readableName);
    }
}

読みやすい型名: OuterClass.InnerClass

さらに、ネストが深い場合でも同様に+を.に置換することで、階層構造をわかりやすく表示できます。

より汎用的にネスト型の名前を取得するには、親の型を再帰的にたどって組み立てる方法もあります。

以下はその例です。

using System;
using System.Text;
class OuterClass
{
    public class InnerClass
    {
        public class DeepInnerClass
        {
        }
    }
}
class Program
{
    static void Main()
    {
        Type type = typeof(OuterClass.InnerClass.DeepInnerClass);
        Console.WriteLine(GetReadableNestedName(type));
    }
    static string GetReadableNestedName(Type type)
    {
        if (type.DeclaringType == null)
            return type.Name;
        return GetReadableNestedName(type.DeclaringType) + "." + type.Name;
    }
}

OuterClass.InnerClass.DeepInnerClass

この方法はFullNameがnullの場合や、名前空間を含めずにネスト構造だけを表示したい場合に有効です。

ネスト型の型名は+記号で区切られる内部表現が基本ですが、読みやすさを重視するなら.に置換したり、親型を再帰的にたどって組み立てる方法を使うとよいでしょう。

これにより、ログやデバッグ時にわかりやすい型名を表示できます。

Nullable 型とポインタ型の特例

C#ではNullable<T>型やポインタ型、配列型など、特殊な型表現が存在します。

これらの型名を取得する際には、通常の型名取得とは異なる扱いが必要です。

ここではNullable<T>の実体型の取得方法と、ポインタ型や配列型の識別方法について詳しく説明します。

Nullable<T> の実体型取得

Nullable<T>は値型にnullを許容するためのラッパー型で、T?というシンタックスシュガーで表現されます。

Nullable<T>自体はジェネリック型ですが、実際に中身の型Tを取得したい場合があります。

using System;
class Program
{
    static void Main()
    {
        Type nullableType = typeof(int?);
        Console.WriteLine("Nullable型: " + nullableType);
        // Nullable<T>の中身の型を取得
        Type underlyingType = Nullable.GetUnderlyingType(nullableType);
        Console.WriteLine("実体型: " + underlyingType);
    }
}

Nullable型: System.Nullable`1[System.Int32]
実体型: System.Int32

Nullable.GetUnderlyingType(Type)メソッドを使うと、Nullable<T>の中身の型Tを取得できます。

もし引数の型がNullable<T>でなければnullを返すため、判定にも使えます。

using System;
class Program
{
    static void Main()
    {
        Type type1 = typeof(int?);
        Type type2 = typeof(int);
        Console.WriteLine(Nullable.GetUnderlyingType(type1) != null ? "Nullable型です" : "Nullable型ではありません");
        Console.WriteLine(Nullable.GetUnderlyingType(type2) != null ? "Nullable型です" : "Nullable型ではありません");
    }
}

Nullable型です
Nullable型ではありません

このように、Nullable<T>の実体型を取得したり、型がNullableかどうかを判定したりする際はNullable.GetUnderlyingTypeを活用すると便利です。

ポインタや配列の識別

C#ではポインタ型や配列型もTypeオブジェクトで表現されますが、これらは特別なプロパティで識別できます。

ポインタ型

Type.IsPointerプロパティがtrueになります。

ポインタ型はint*やchar*のようにアスタリスク*で表されます。

配列型

Type.IsArrayプロパティがtrueになります。

配列の要素型はGetElementType()で取得可能です。

using System;
class Program
{
    unsafe static void Main()
    {
        Type pointerType = typeof(int*);
        Type arrayType = typeof(int[]);
        Type normalType = typeof(int);
        Console.WriteLine("int* はポインタ型か？ " + pointerType.IsPointer);
        Console.WriteLine("int[] は配列型か？ " + arrayType.IsArray);
        Console.WriteLine("int はポインタ型か？ " + normalType.IsPointer);
        Console.WriteLine("int は配列型か？ " + normalType.IsArray);
        Console.WriteLine("int[] の要素型: " + arrayType.GetElementType());
    }
}

int* はポインタ型か？ True
int[] は配列型か？ True
int はポインタ型か？ False
int は配列型か？ False
int[] の要素型: System.Int32

ポインタ型はunsafeコンテキストでのみ扱えますが、Type情報としては通常の型と同様に取得可能です。

配列型は多次元配列やジャグ配列も存在し、GetElementType()で要素の型を取得し、Rankプロパティで次元数を知ることができます。

using System;
class Program
{
    static void Main()
    {
        Type multiArrayType = typeof(int[,]);
        Console.WriteLine("多次元配列の次元数: " + multiArrayType.GetArrayRank());
    }
}

多次元配列の次元数: 2

これらのプロパティを活用することで、型がポインタ型か配列型かを判別し、適切に処理を分けることができます。

特にリフレクションや型名のカスタム表示を行う際に役立ちます。

文字列化のカスタマイズ

C#のTypeオブジェクトはToString()メソッドで型名を文字列化できますが、このメソッドはオーバーライドできず、標準の表示形式に制限があります。

より見やすく、用途に応じた型名の文字列化を行うにはカスタマイズが必要です。

ここではType.ToString()の制約と、拡張メソッドを使ったフォーマット実装例を紹介します。

Type.ToString() のオーバーライド不可性

TypeクラスのToString()メソッドはsealed(最終)メソッドとして実装されているため、派生クラスでオーバーライドできません。

つまり、Typeの文字列化の挙動を直接変更することはできません。

using System;
class Program
{
    static void Main()
    {
        Type type = typeof(System.Collections.Generic.List<int>);
        Console.WriteLine(type.ToString());
    }
}

System.Collections.Generic.List`1[System.Int32]

この出力はジェネリック型の型引数を展開せず、バッククォートや角括弧を含むCLRの内部表現のままです。

ToString()の挙動を変えたい場合は、別の方法で文字列化処理を実装する必要があります。

拡張メソッドでのフォーマット実装

Typeの文字列化をカスタマイズするには、拡張メソッドを使うのが一般的です。

拡張メソッドなら既存のTypeクラスを変更せずに、任意のフォーマットで型名を取得できます。

以下はジェネリック型の型引数を展開し、ネスト型も考慮した見やすい型名を返す拡張メソッドの例です。

using System;
using System.Text;
static class TypeExtensions
{
    public static string ToFriendlyName(this Type type)
    {
        if (type == null)
            return string.Empty;
        if (type.IsGenericType)
        {
            var sb = new StringBuilder();
            string name = type.Name;
            int backtickIndex = name.IndexOf('`');
            if (backtickIndex > 0)
                sb.Append(name.Substring(0, backtickIndex));
            else
                sb.Append(name);
            sb.Append('<');
            Type[] args = type.GetGenericArguments();
            for (int i = 0; i < args.Length; i++)
            {
                if (i > 0)
                    sb.Append(", ");
                sb.Append(args[i].ToFriendlyName());
            }
            sb.Append('>');
            return sb.ToString();
        }
        else if (type.IsNested)
        {
            return type.DeclaringType.ToFriendlyName() + "." + type.Name;
        }
        else
        {
            return type.Name;
        }
    }
}
class Program
{
    static void Main()
    {
        Type type = typeof(System.Collections.Generic.Dictionary<string, System.Collections.Generic.List<int>>);
        Console.WriteLine(type.ToFriendlyName());
    }
}

Dictionary<String, List<Int32>>

この拡張メソッドは再帰的にジェネリック型の型引数を展開し、ネスト型も.区切りで表現します。

ToString()よりもずっと読みやすい文字列が得られます。

ジェネリック深層構造の展開例

複雑なネストや多層のジェネリック型でも、上記の拡張メソッドは再帰的に処理するため、正しく展開できます。

using System;
using System.Collections.Generic;
class Outer<T>
{
    public class Inner<U>
    {
        public class DeepInner<V> { }
    }
}
class Program
{
    static void Main()
    {
        Type type = typeof(Outer<int>.Inner<string>.DeepInner<double>);
        Console.WriteLine(type.ToFriendlyName());
    }
}

Outer<Int32>.Inner<String>.DeepInner<Double>

このように、深い階層のジェネリック型も見やすく表示できます。

コード生成による最適化案

拡張メソッドの再帰的な文字列生成は柔軟ですが、頻繁に大量の型名を処理する場合はパフォーマンスに影響が出ることがあります。

そこで、コード生成やキャッシュを活用して最適化する方法もあります。

キャッシュの利用

一度生成した型名文字列を辞書などに保存し、同じ型の再処理を避けます。

ソースジェネレーターの活用

C#のソースジェネレーター機能を使い、コンパイル時に型名の展開コードを自動生成します。

ILコード生成

System.Reflection.Emitを使い、動的に高速な型名展開メソッドを生成します。

これらの方法は実装コストが高いものの、大規模なアプリケーションやパフォーマンスが重要な場面で効果的です。

文字列化のカスタマイズは、Type.ToString()の制約を回避し、よりわかりやすい型名表示を実現するために欠かせません。

拡張メソッドを基本に、必要に応じて最適化を検討するとよいでしょう。

パフォーマンスとキャッシュ

型情報の取得はリフレクションを多用する場面で頻繁に行われるため、パフォーマンスに影響を与えることがあります。

ここでは、型情報のキャッシュ方法やReflection.Emitを使わない軽量化の工夫、さらにAOT環境やIL2CPPの影響について解説します。

一度取得した型情報のキャッシュ方法

Typeオブジェクトの取得自体は比較的軽量ですが、型名の文字列化や複雑なリフレクション処理はコストがかかります。

特に同じ型に対して何度も処理を行う場合は、結果をキャッシュすることでパフォーマンスを大幅に改善できます。

以下は型名のカスタム文字列をキャッシュする例です。

using System;
using System.Collections.Concurrent;
using System.Reflection;
static class TypeNameCache
{
    private static readonly ConcurrentDictionary<Type, string> cache = new ConcurrentDictionary<Type, string>();
    public static string GetCachedTypeName(Type type)
    {
        return cache.GetOrAdd(type, t => GenerateTypeName(t));
    }
    private static string GenerateTypeName(Type type)
    {
        if (!type.IsGenericType)
            return type.Name;
        var name = type.Name;
        int backtickIndex = name.IndexOf('`');
        if (backtickIndex > 0)
            name = name.Substring(0, backtickIndex);
        var genericArgs = type.GetGenericArguments();
        string[] argNames = new string[genericArgs.Length];
        for (int i = 0; i < genericArgs.Length; i++)
        {
            argNames[i] = GetCachedTypeName(genericArgs[i]);
        }
        return $"{name}<{string.Join(", ", argNames)}>";
    }
}
class Program
{
    static void Main()
    {
        Type type = typeof(System.Collections.Generic.Dictionary<string, int>);
        Console.WriteLine(TypeNameCache.GetCachedTypeName(type));
        // 2回目以降はキャッシュから取得されるため高速
        Console.WriteLine(TypeNameCache.GetCachedTypeName(type));
    }
}

Dictionary<String, Int32>
Dictionary<String, Int32>

このようにConcurrentDictionaryを使ってスレッドセーフにキャッシュすることで、同じ型の文字列化処理を繰り返すコストを削減できます。

Reflection.Emit を使わない軽量化

Reflection.Emitは動的にILコードを生成して高速化を図る手法ですが、環境によっては使用できなかったり、実装が複雑になったりします。

そこで、Reflection.Emitを使わずに軽量化する方法としては以下が挙げられます。

キャッシュの活用

先述のように結果をキャッシュして再利用します。

プリコンパイル済みの型名辞書

主要な型名をあらかじめ辞書に登録し、文字列化時に辞書から取得します。

シンプルな文字列操作

複雑な正規表現や再帰処理を避け、単純な文字列置換や分割で済ませます。

非同期処理やバッチ処理

型名の生成を非同期やバッチで行い、メインスレッドの負荷を軽減します。

これらの方法は環境依存性が低く、特にUnityやモバイル環境などReflection.Emitが制限されるケースで有効です。

AOT 環境と IL2CPP の影響

Ahead-Of-Time(AOT)コンパイル環境やUnityのIL2CPP環境では、リフレクションの利用に制限があったり、動的コード生成ができなかったりします。

これにより、型情報の取得や文字列化に影響が出ることがあります。

型情報の制限

AOT環境では未使用の型情報が削除されることがあり、リフレクションで取得できない場合があります。

必要な型は明示的に参照しておくか、[Preserve]属性などで保持する必要があります。

動的コード生成不可

IL2CPPではReflection.Emitが使えないため、動的にILを生成する高速化手法は使えません。

代わりに静的なコード生成やキャッシュを活用します。

型名の文字列化の工夫

AOT環境では型名の取得が制限されることがあるため、事前に型名を文字列として用意しておくか、ビルド時に生成する方法が推奨されます。

// Unity IL2CPP環境での型保持例
[UnityEngine.Scripting.Preserve]
class SomeType { }

これらの制約を踏まえ、AOTやIL2CPP環境ではリフレクションの使用を最小限に抑え、キャッシュや静的生成を積極的に活用する設計が求められます。

パフォーマンスを意識した型情報の取得と文字列化は、特に大規模アプリケーションや制約のある環境で重要です。

キャッシュの活用や環境に応じた工夫で効率的に処理を行いましょう。

属性と型名取得

C#の属性(Attribute)はメタデータとしてクラスやメソッドなどに付加され、リフレクションで情報を取得できます。

属性の定義や利用時にtypeofを使って型情報を指定することが多く、型名取得と密接に関係しています。

ここではカスタム属性内でのtypeofの使い方と、AttributeTargets型の識別方法について説明します。

カスタム属性内での typeof 使用

属性クラスのコンストラクタやプロパティの引数に型情報を渡す場合、typeof演算子を使います。

これはコンパイル時に型を指定し、属性のメタデータとして保存されるため、実行時にリフレクションで型情報を取得可能です。

以下はカスタム属性でTypeを受け取り、付与先の型に関する情報を保持する例です。

using System;
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
class InfoAttribute : Attribute
{
    public Type TargetType { get; }
    public InfoAttribute(Type targetType)
    {
        TargetType = targetType;
    }
}
[Info(typeof(string))]
class SampleClass
{
}
class Program
{
    static void Main()
    {
        var attr = (InfoAttribute)Attribute.GetCustomAttribute(typeof(SampleClass), typeof(InfoAttribute));
        if (attr != null)
        {
            Console.WriteLine("属性で指定された型名: " + attr.TargetType.FullName);
        }
    }
}

属性で指定された型名: System.String

このように、属性の引数にtypeofを使うことで、型情報を安全かつ明示的に指定できます。

実行時にはAttribute.GetCustomAttributeなどで属性を取得し、Typeプロパティから型名を取得可能です。

AttributeTargets 型の識別

AttributeTargetsは属性が適用可能なプログラム要素を指定する列挙型です。

属性クラスのAttributeUsageで使われ、どの要素に属性を付けられるかを制御します。

using System;
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
class CustomAttribute : Attribute
{
}
[Custom]
class MyClass
{
    [Custom]
    public void MyMethod() { }
}
class Program
{
    static void Main()
    {
        var classAttrs = Attribute.GetCustomAttributes(typeof(MyClass));
        var methodAttrs = Attribute.GetCustomAttributes(typeof(MyClass).GetMethod("MyMethod"));
        Console.WriteLine("MyClassに付与された属性数: " + classAttrs.Length);
        Console.WriteLine("MyMethodに付与された属性数: " + methodAttrs.Length);
    }
}

MyClassに付与された属性数: 1
MyMethodに付与された属性数: 1

AttributeTargetsはビットフラグの列挙型なので、複数の対象を組み合わせて指定できます。

リフレクションで属性の適用対象を調べる際は、AttributeUsageAttribute.ValidOnプロパティから取得可能です。

using System;
class Program
{
    static void Main()
    {
        var usage = (AttributeUsageAttribute)Attribute.GetCustomAttribute(typeof(CustomAttribute), typeof(AttributeUsageAttribute));
        if (usage != null)
        {
            Console.WriteLine("CustomAttributeの適用対象: " + usage.ValidOn);
        }
    }
}

CustomAttributeの適用対象: Class, Method

このように、属性の適用範囲を示すAttributeTargetsは型名取得と組み合わせて、属性の動作や適用範囲を動的に把握するのに役立ちます。

ジェネリック制約での typeof 応用

C#のジェネリックでは、where句を使って型パラメータに制約を設けることができます。

typeof演算子はこれらの制約や型比較の場面で応用され、型の判定や条件分岐に役立ちます。

ここではwhere句での型比較と、他の型との比較演算におけるtypeofの使い方を詳しく説明します。

where 句での型比較

where句はジェネリック型パラメータに対して、特定の型やインターフェース、クラスの継承関係などの制約を指定できます。

ただし、where句自体ではtypeofを直接使えませんが、メソッド内でtypeofを使って型パラメータの型を比較し、条件分岐を行うことが可能です。

以下は、ジェネリックメソッド内でtypeofを使い、型パラメータが特定の型かどうかを判定する例です。

using System;
class Program
{
    static void PrintTypeInfo<T>()
    {
        Type type = typeof(T);
        if (type == typeof(int))
        {
            Console.WriteLine("型パラメータはintです。");
        }
        else if (type == typeof(string))
        {
            Console.WriteLine("型パラメータはstringです。");
        }
        else
        {
            Console.WriteLine($"型パラメータは{type.Name}です。");
        }
    }
    static void Main()
    {
        PrintTypeInfo<int>();    // 型パラメータはintです。
        PrintTypeInfo<string>(); // 型パラメータはstringです。
        PrintTypeInfo<double>(); // 型パラメータはDoubleです。
    }
}

型パラメータはintです。
型パラメータはstringです。
型パラメータはDoubleです。

このように、typeofを使うことでジェネリック型パラメータの型を実行時に判定し、処理を分岐できます。

他型との比較演算

typeofで取得したTypeオブジェクトは、==演算子やEqualsメソッドで他の型と比較できます。

これにより、型の同一性を判定したり、型の互換性をチェックしたりできます。

以下は、型の比較演算を使った例です。

using System;
class Program
{
    static bool IsSameType<T, U>()
    {
        return typeof(T) == typeof(U);
    }
    static void Main()
    {
        Console.WriteLine(IsSameType<int, int>());       // True
        Console.WriteLine(IsSameType<int, string>());    // False
        Console.WriteLine(IsSameType<string, object>()); // False
    }
}

True
False
False

また、Type.IsAssignableFromメソッドを使うと、ある型が別の型に代入可能かどうか(継承関係やインターフェース実装の有無)を判定できます。

using System;
class Base { }
class Derived : Base { }
class Program
{
    static void Main()
    {
        Console.WriteLine(typeof(Base).IsAssignableFrom(typeof(Derived)));   // True
        Console.WriteLine(typeof(Derived).IsAssignableFrom(typeof(Base)));   // False
    }
}

True
False

このように、typeofで取得した型情報を比較演算に利用することで、ジェネリック型の制約や動的な型判定を柔軟に行えます。

switch 式・パターンマッチングとの連携

C#のswitch式やパターンマッチングは、型に基づく条件分岐を簡潔に記述できる強力な機能です。

typeofやGetTypeで取得した型情報と組み合わせることで、より柔軟な型判定や処理の分岐が可能になります。

ここでは型パターンを使った分岐と、is演算子とswitchの使い分けについて詳しく説明します。

型パターンでの分岐

C# 7.0以降、switch文やswitch式で型パターンを使い、オブジェクトの型に応じて処理を分岐できます。

型パターンはcase型変数名:の形式で記述し、マッチした型の変数をそのまま利用可能です。

以下は型パターンを使ったswitch文の例です。

using System;
class Program
{
    static void PrintTypeInfo(object obj)
    {
        switch (obj)
        {
            case int i:
                Console.WriteLine($"整数型: {i}");
                break;
            case string s:
                Console.WriteLine($"文字列型: {s}");
                break;
            case null:
                Console.WriteLine("nullです");
                break;
            default:
                Console.WriteLine($"その他の型: {obj.GetType().Name}");
                break;
        }
    }
    static void Main()
    {
        PrintTypeInfo(123);
        PrintTypeInfo("Hello");
        PrintTypeInfo(null);
        PrintTypeInfo(3.14);
    }
}

整数型: 123
文字列型: Hello
nullです
その他の型: Double

このように、型パターンを使うと型ごとに処理を分けつつ、マッチした型の値を直接利用できるためコードがすっきりします。

is と switch の使い分け

is演算子も型判定に使えますが、単一の条件判定に向いています。

一方、複数の型に対して分岐処理を行う場合はswitch式やswitch文の型パターンが便利です。

is 演算子の例

object obj = 42;
if (obj is int i)
{
    Console.WriteLine($"整数: {i}");
}
else if (obj is string s)
{
    Console.WriteLine($"文字列: {s}");
}
else
{
    Console.WriteLine("その他の型");
}

switch 式の例(C# 8.0以降)

object obj = "test";
string result = obj switch
{
    int i => $"整数: {i}",
    string s => $"文字列: {s}",
    null => "nullです",
    _ => "その他の型"
};
Console.WriteLine(result);

文字列: test

isは単純な型チェックや条件分岐に適し、switchは複数の型パターンを扱う場合にコードが読みやすくなります。

用途やコードの複雑さに応じて使い分けるとよいでしょう。

型パターンを活用することで、typeofやGetTypeを使った冗長な型判定コードを減らし、より直感的で保守性の高いコードを書けます。

isとswitchの特徴を理解し、適切に使い分けてください。

デバッグとロギングでの活用

プログラムのデバッグやログ出力の際に、型名を正確に取得して表示することは問題の特定や解析を効率化するうえで非常に重要です。

ここでは、ログ出力にフルネームを使う理由と、ConditionalAttributeを用いた呼び出し制御について詳しく説明します。

ログ出力にフルネームを使う理由

ログに型名を出力する際、単に型のNameだけを使うと、同じ名前の型が異なる名前空間に存在する場合に混乱を招くことがあります。

例えば、MyApp.Models.UserとMyApp.ViewModels.Userのように、同じUserという名前でも異なる型が存在するケースです。

このため、ログにはFullName(名前空間を含む完全修飾名)を使うことが推奨されます。

これにより、どの型のインスタンスかを正確に識別でき、問題の切り分けが容易になります。

using System;
class Program
{
    static void LogObjectType(object obj)
    {
        if (obj == null)
        {
            Console.WriteLine("オブジェクトはnullです");
            return;
        }
        // フルネームを取得してログ出力
        Console.WriteLine($"オブジェクトの型: {obj.GetType().FullName}");
    }
    static void Main()
    {
        var userModel = new MyApp.Models.User();
        var userViewModel = new MyApp.ViewModels.User();
        LogObjectType(userModel);
        LogObjectType(userViewModel);
    }
}
namespace MyApp.Models
{
    class User { }
}
namespace MyApp.ViewModels
{
    class User { }
}

オブジェクトの型: MyApp.Models.User
オブジェクトの型: MyApp.ViewModels.User

このようにフルネームを使うことで、ログを見ただけでどの型のインスタンスかが一目でわかり、デバッグ効率が向上します。

ConditionalAttribute で呼び出し制御

デバッグやログ出力のコードは、リリースビルドでは不要な場合が多く、パフォーマンスやログの冗長化を避けるために呼び出しを制御したいことがあります。

C#のConditionalAttributeを使うと、特定の条件付きコンパイルシンボルが定義されている場合のみメソッド呼び出しを有効にできます。

以下はDEBUGシンボルが定義されている場合のみログ出力を行う例です。

using System;
using System.Diagnostics;
class Logger
{
    [Conditional("DEBUG")]
    public static void Log(string message)
    {
        Console.WriteLine(message);
    }
}
class Program
{
    static void Main()
    {
        Logger.Log("これはデバッグ時のみ表示されます。");
        Console.WriteLine("これは常に表示されます。");
    }
}

// DEBUGシンボルが有効な場合
これはデバッグ時のみ表示されます。
これは常に表示されます。

ConditionalAttributeを付けたメソッドは、指定したシンボルが定義されていないビルドでは呼び出しコード自体がコンパイルされません。

これにより、リリースビルドでの不要なログ出力を完全に除外でき、パフォーマンスの低下を防げます。

デバッグやロギングで型名を活用する際は、フルネームを使って正確な情報を記録し、ConditionalAttributeで呼び出しを制御することで、効率的かつ安全なログ管理が可能になります。

C# 最新バージョン動向

C#はバージョンアップを重ねるごとに言語機能が拡充され、型情報の扱いもより便利かつ安全になっています。

ここでは、nameof演算子とtypeof演算子の併用例と、マーシャリング(データの変換ややり取り)における型名の活用について解説します。

nameof と typeof の併用

nameof演算子は、変数名や型名、メンバー名を文字列として取得できる機能で、コンパイル時に安全に名前を取得できるため、リファクタリングに強いコードを書くのに役立ちます。

一方、typeofは型のTypeオブジェクトを取得します。

これらを併用することで、型名の文字列を安全かつ簡潔に取得し、コードの可読性や保守性を高めることができます。

using System;
class SampleClass
{
    public int SampleProperty { get; set; }
}
class Program
{
    static void Main()
    {
        // nameofで型名を文字列として取得
        string typeName = nameof(SampleClass);
        Console.WriteLine($"nameofで取得した型名: {typeName}");
        // typeofでTypeオブジェクトを取得し、FullNameを表示
        string fullTypeName = typeof(SampleClass).FullName;
        Console.WriteLine($"typeofで取得したフルネーム: {fullTypeName}");
    }
}

nameofで取得した型名: SampleClass
typeofで取得したフルネーム: SampleClass

nameofは単純に識別子の名前を文字列化するだけなので、名前空間は含まれません。

一方、typeofのFullNameは名前空間を含む完全修飾名を返します。

用途に応じて使い分けることで、より安全で明確なコードが書けます。

また、C# 10以降ではnameofとtypeofを組み合わせて、属性の引数やログメッセージの生成に活用するケースが増えています。

例えば、属性の引数にnameofで型名を渡し、実行時にtypeofで型情報を取得するパターンです。

マーシャリングでの型名使用

マーシャリングとは、異なる環境やプロセス間でデータをやり取りする際に、データ形式を変換する処理を指します。

C#ではP/InvokeやCOM相互運用、ネットワーク通信などでマーシャリングが使われます。

マーシャリング時に型名を文字列として扱うことがあり、正確な型名の取得が重要です。

特に、ネイティブコードとの連携やシリアライズ時に型名を指定することで、データの整合性や互換性を保ちます。

using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential)]
struct MyStruct
{
    public int Id;
    public float Value;
}
class Program
{
    [DllImport("NativeLib.dll")]
    private static extern void ProcessData(string typeName, IntPtr data);
    static void Main()
    {
        MyStruct data = new MyStruct { Id = 1, Value = 3.14f };
        IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf<MyStruct>());
        try
        {
            Marshal.StructureToPtr(data, ptr, false);
            // マーシャリング先に型名を渡す
            string typeName = typeof(MyStruct).FullName;
            ProcessData(typeName, ptr);
        }
        finally
        {
            Marshal.FreeHGlobal(ptr);
        }
    }
}

この例では、ネイティブ関数に構造体の型名を文字列で渡すことで、受け側で適切な処理を行いやすくしています。

typeofのFullNameを使うことで、名前空間を含む正確な型名を取得でき、誤解や型の衝突を防げます。

また、.NET 5以降ではSystem.Runtime.InteropServices名前空間にマーシャリング関連の機能が強化されており、型情報の取得や管理がより柔軟になっています。

C#の最新バージョンでは、nameofとtypeofの併用による安全で明確な型名取得が推奨されており、マーシャリングの場面でも正確な型名の活用が重要視されています。

これらの機能を活用して、堅牢で保守性の高いコードを書くことが可能です。

代表的な落とし穴

型名取得やリフレクションを活用する際には、環境やコードの構造によって思わぬ問題が発生することがあります。

ここでは、リフレクション制限のある環境、シャドウイングされた型エイリアス、そしてジェネリック再帰によるスタック消費という代表的な落とし穴について詳しく解説します。

リフレクション制限のある環境

一部の実行環境では、セキュリティやパフォーマンスの理由からリフレクションの利用が制限されている場合があります。

特にモバイルプラットフォームやAOT(Ahead-Of-Time)コンパイル環境、UnityのIL2CPP環境などで顕著です。

これらの環境では、以下のような問題が起こりやすいです。

型情報の欠落

未使用の型やメンバーがビルド時に削除され、リフレクションで取得できなくなります。

動的コード生成の禁止

Reflection.Emitや動的メソッド生成が使えず、動的な型操作が制限されます。

アクセス制限

プライベートメンバーや内部型へのアクセスが制限されることがあります。

対策としては、必要な型やメンバーを明示的に参照してビルドに含める、[Preserve]属性を使う、リフレクションの使用を最小限に抑えるなどがあります。

// Unity IL2CPP環境での型保持例
[UnityEngine.Scripting.Preserve]
class ImportantType { }

リフレクションを多用するコードは、対象環境の制約を事前に確認し、適切な対応を行うことが重要です。

シャドウイングされた型エイリアス

C#ではusingディレクティブで型エイリアスを定義できますが、同じ名前の型エイリアスがシャドウイング(隠蔽)されると、意図しない型名が取得されることがあります。

例えば、以下のようなコードです。

using MyInt = System.Int32;
namespace MyNamespace
{
    using MyInt = System.Int64;
    class Program
    {
        static void Main()
        {
            MyInt value = 123;
            Console.WriteLine(value.GetType().FullName);
        }
    }
}

System.Int64

この例では、外側のMyIntはInt32ですが、MyNamespace内でMyIntがInt64にシャドウイングされているため、valueの型はInt64になります。

typeofやGetTypeで取得される型名は実際の型に基づくため、エイリアスの名前とは異なることに注意が必要です。

シャドウイングされたエイリアスを使う場合は、型の実体を正確に把握し、混乱を避けるために明示的な型指定や名前空間の完全修飾を検討してください。

ジェネリック再帰によるスタック消費

ジェネリック型の型引数を再帰的に展開して型名を生成する処理は便利ですが、深いネストや自己参照的なジェネリック型があると、再帰呼び出しが深くなりスタックオーバーフローを引き起こす可能性があります。

例えば、以下のような自己参照的なジェネリック型があるとします。

class Recursive<T> where T : Recursive<T>
{
}

この型の名前を再帰的に展開する処理を実装すると、無限再帰に陥る恐れがあります。

// 再帰的に型名を展開する例(注意：無限再帰の可能性あり)
string GetTypeName(Type type)
{
    if (!type.IsGenericType)
        return type.Name;
    var name = type.Name.Substring(0, type.Name.IndexOf('`'));
    var args = type.GetGenericArguments();
    return $"{name}<{string.Join(", ", args.Select(GetTypeName))}>";
}

このような場合は、再帰の深さに制限を設けるか、既に処理した型を記録してループを検出する仕組みを導入することが重要です。

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static string GetTypeNameSafe(Type type, HashSet<Type> visited = null)
    {
        visited ??= new HashSet<Type>();
        if (visited.Contains(type))
            return type.Name + " (再帰検出)";
        if (!type.IsGenericType)
            return type.Name;
        visited.Add(type);
        var name = type.Name.Substring(0, type.Name.IndexOf('`'));
        var args = type.GetGenericArguments();
        var argNames = args.Select(t => GetTypeNameSafe(t, visited)).ToArray();
        visited.Remove(type);
        return $"{name}<{string.Join(", ", argNames)}>";
    }
    static void Main()
    {
        // 使用例は省略
    }
}

このように再帰検出を行うことで、スタックオーバーフローを防ぎつつ安全に型名を展開できます。

これらの落とし穴を理解し、適切な対策を講じることで、型名取得やリフレクションを安全かつ効果的に活用できます。

特に環境依存の制約やコード構造の複雑さには注意が必要です。

まとめ

この記事では、C#のtypeofとGetTypeを使った型名取得の基本から応用までを解説しました。

型名のバリエーションやジェネリック型の扱い、ネスト型の表現方法、Nullableやポインタ型の特例、文字列化のカスタマイズ方法、パフォーマンス向上のためのキャッシュ技術、属性との連携、最新言語機能の活用、そして代表的な落とし穴まで幅広く理解できます。

これにより、型情報を正確かつ効率的に扱うスキルが身につき、堅牢で保守性の高いC#コードの作成に役立ちます。