C#リフレクションでメタデータを自在に操作する方法：ベストプラクティス集

C#のリフレクションは、プログラムのメタデータにアクセスし、動的に操作する強力なツールです。本記事では、リフレクションの基礎から実践的な応用例まで、メタデータ操作に関するベストプラクティスを詳しく解説します。具体的なサンプルコードやパフォーマンス最適化の方法を通じて、効率的にリフレクションを活用する方法を学びましょう。

リフレクションの基礎

リフレクションは、C#などのプログラミング言語で実行時に型情報を調査・操作する機能です。これにより、クラスやメソッド、プロパティ、フィールドなどのメタデータにアクセスできます。以下にリフレクションの基本的な使用例を示します。

リフレクションの概念

リフレクションを利用することで、以下のような操作が可能になります。

実行時に型情報を取得
オブジェクトのプロパティやメソッドにアクセス
非公開メンバーへのアクセス

リフレクションの使用例

以下のコードは、リフレクションを使用してクラスのプロパティ情報を取得する例です。

using System;
using System.Reflection;

public class SampleClass
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class Program
{
    public static void Main()
    {
        Type type = typeof(SampleClass);
        PropertyInfo[] properties = type.GetProperties();

        foreach (var property in properties)
        {
            Console.WriteLine($"Property: {property.Name}, Type: {property.PropertyType}");
        }
    }
}

このコードでは、SampleClassのプロパティ名とその型を取得し、コンソールに表示しています。リフレクションを使うことで、コードの動的な動作が可能になり、柔軟なアプリケーション開発が実現します。

メタデータとは

メタデータは、データに関する情報を表すデータです。プログラミングにおいては、クラスやメソッド、プロパティなどの型情報や属性を指します。C#でメタデータを操作することにより、アプリケーションの動作を柔軟に制御することが可能になります。

メタデータの定義

メタデータとは、データそのものではなく、そのデータに関する情報を提供するデータです。例えば、クラスの構造、メソッドのシグネチャ、プロパティのデータ型などがメタデータに含まれます。

C#でのメタデータ操作の意義

C#でメタデータを操作する主な意義は以下の通りです。

動的な型情報の取得: 実行時に型情報を取得することで、コードの柔軟性を高めることができます。
属性の操作: カスタム属性を利用して、メタデータに追加情報を持たせることができます。
コードの自動生成: メタデータを利用して、動的にコードを生成・実行することが可能です。

具体例

以下のコードは、メタデータとしての属性情報を取得する例です。

using System;
using System.Reflection;

[AttributeUsage(AttributeTargets.Class)]
public class SampleAttribute : Attribute
{
    public string Description { get; }

    public SampleAttribute(string description)
    {
        Description = description;
    }
}

[Sample("This is a sample class.")]
public class SampleClass
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class Program
{
    public static void Main()
    {
        Type type = typeof(SampleClass);
        object[] attributes = type.GetCustomAttributes(false);

        foreach (var attribute in attributes)
        {
            if (attribute is SampleAttribute sampleAttribute)
            {
                Console.WriteLine($"Description: {sampleAttribute.Description}");
            }
        }
    }
}

この例では、SampleClassに付与されたカスタム属性SampleAttributeの情報を取得し、コンソールに表示しています。メタデータを操作することで、アプリケーションの動作を細かく制御することが可能です。

リフレクションのメリットとデメリット

リフレクションは強力な機能ですが、使用には利点と欠点があります。これを理解することで、適切にリフレクションを活用できます。

メリット

動的な型情報の取得

リフレクションを使うことで、実行時に型情報を取得でき、柔軟なプログラム設計が可能です。例えば、プラグインシステムではリフレクションを用いて外部アセンブリからクラスやメソッドを動的にロードできます。

コードの自動生成

リフレクションを使用すると、メタデータに基づいてコードを自動生成し、実行できます。これにより、コードの重複を減らし、メンテナンス性が向上します。

属性の操作

リフレクションはカスタム属性の取得と操作を可能にします。これにより、メタデータを活用して、動的に振る舞いを変更することができます。

デメリット

パフォーマンスの低下

リフレクションは通常のメソッド呼び出しに比べて遅く、頻繁に使用するとアプリケーションのパフォーマンスが低下する可能性があります。

型安全性の欠如

リフレクションを使用すると、型チェックがコンパイル時ではなく実行時に行われるため、型安全性が保証されません。これにより、ランタイムエラーが発生しやすくなります。

複雑性の増加

リフレクションを用いたコードは、通常のコードに比べて理解しにくく、デバッグが難しくなります。これにより、メンテナンスが困難になることがあります。

具体例

以下に、リフレクションを使ったコードとそのパフォーマンスの違いを示します。

using System;
using System.Diagnostics;
using System.Reflection;

public class SampleClass
{
    public void SampleMethod()
    {
        Console.WriteLine("SampleMethod called");
    }
}

public class Program
{
    public static void Main()
    {
        SampleClass sample = new SampleClass();

        // 通常のメソッド呼び出し
        Stopwatch sw = Stopwatch.StartNew();
        for (int i = 0; i < 1000000; i++)
        {
            sample.SampleMethod();
        }
        sw.Stop();
        Console.WriteLine($"通常のメソッド呼び出し: {sw.ElapsedMilliseconds} ms");

        // リフレクションを使ったメソッド呼び出し
        MethodInfo methodInfo = typeof(SampleClass).GetMethod("SampleMethod");
        sw = Stopwatch.StartNew();
        for (int i = 0; i < 1000000; i++)
        {
            methodInfo.Invoke(sample, null);
        }
        sw.Stop();
        Console.WriteLine($"リフレクションを使ったメソッド呼び出し: {sw.ElapsedMilliseconds} ms");
    }
}

この例では、通常のメソッド呼び出しとリフレクションを使ったメソッド呼び出しのパフォーマンス差を測定しています。リフレクションの使用が遅いことが確認でき、頻繁に使用する場合にはパフォーマンスの最適化が必要となります。

基本的なリフレクション操作

C#でリフレクションを使うと、実行時にオブジェクトの型情報を動的に取得・操作できます。ここでは、リフレクションを使用した基本的な操作方法を紹介します。

型情報の取得

リフレクションを使って型情報を取得するには、Typeクラスを利用します。以下のコードは、SampleClassの型情報を取得する例です。

using System;

public class SampleClass
{
    public int Id { get; set; }
    public string Name { get; set; }

    public void Display()
    {
        Console.WriteLine($"Id: {Id}, Name: {Name}");
    }
}

public class Program
{
    public static void Main()
    {
        Type type = typeof(SampleClass);
        Console.WriteLine($"Class Name: {type.Name}");
        Console.WriteLine($"Namespace: {type.Namespace}");
    }
}

この例では、typeofキーワードを使用してSampleClassの型情報を取得し、クラス名と名前空間を表示しています。

メソッド情報の取得

型情報を使ってクラスのメソッド情報を取得することも可能です。以下のコードは、SampleClassのメソッド情報を取得し、表示する例です。

using System;
using System.Reflection;

public class SampleClass
{
    public int Id { get; set; }
    public string Name { get; set; }

    public void Display()
    {
        Console.WriteLine($"Id: {Id}, Name: {Name}");
    }
}

public class Program
{
    public static void Main()
    {
        Type type = typeof(SampleClass);
        MethodInfo[] methods = type.GetMethods();

        foreach (var method in methods)
        {
            Console.WriteLine($"Method: {method.Name}");
        }
    }
}

このコードでは、GetMethodsメソッドを使用して、SampleClassのすべてのメソッド情報を取得し、メソッド名を表示しています。

プロパティ情報の取得

リフレクションを使ってクラスのプロパティ情報を取得することもできます。以下にその例を示します。

using System;
using System.Reflection;

public class SampleClass
{
    public int Id { get; set; }
    public string Name { get; set; }

    public void Display()
    {
        Console.WriteLine($"Id: {Id}, Name: {Name}");
    }
}

public class Program
{
    public static void Main()
    {
        Type type = typeof(SampleClass);
        PropertyInfo[] properties = type.GetProperties();

        foreach (var property in properties)
        {
            Console.WriteLine($"Property: {property.Name}, Type: {property.PropertyType}");
        }
    }
}

この例では、GetPropertiesメソッドを使って、SampleClassのすべてのプロパティ情報を取得し、プロパティ名とその型を表示しています。

メソッドの呼び出し

リフレクションを使ってメソッドを動的に呼び出すことも可能です。以下にその例を示します。

using System;
using System.Reflection;

public class SampleClass
{
    public int Id { get; set; }
    public string Name { get; set; }

    public void Display()
    {
        Console.WriteLine($"Id: {Id}, Name: {Name}");
    }
}

public class Program
{
    public static void Main()
    {
        SampleClass sample = new SampleClass { Id = 1, Name = "Example" };
        Type type = typeof(SampleClass);
        MethodInfo methodInfo = type.GetMethod("Display");

        methodInfo.Invoke(sample, null);
    }
}

この例では、GetMethodメソッドを使ってDisplayメソッドの情報を取得し、Invokeメソッドを使用して実際にメソッドを呼び出しています。

これらの基本的なリフレクション操作を理解することで、C#のリフレクションを使った高度なメタデータ操作に備えることができます。

メタデータの取得と設定

リフレクションを使うことで、C#のクラスやメソッドのメタデータを取得したり、設定したりすることが可能です。ここでは、メタデータの取得と設定に関する具体的な手順と実例を示します。

メタデータの取得

リフレクションを用いてメタデータを取得する方法を説明します。以下の例では、SampleClassのプロパティ情報を取得します。

using System;
using System.Reflection;

public class SampleClass
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class Program
{
    public static void Main()
    {
        Type type = typeof(SampleClass);
        PropertyInfo[] properties = type.GetProperties();

        foreach (var property in properties)
        {
            Console.WriteLine($"Property: {property.Name}, Type: {property.PropertyType}");
        }
    }
}

このコードでは、GetPropertiesメソッドを使用して、SampleClassのすべてのプロパティ情報を取得し、プロパティ名とその型をコンソールに表示します。

メタデータの設定

リフレクションを使ってメタデータを動的に設定する方法を説明します。以下の例では、SampleClassのプロパティ値を設定します。

using System;
using System.Reflection;

public class SampleClass
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class Program
{
    public static void Main()
    {
        SampleClass sample = new SampleClass();
        Type type = typeof(SampleClass);

        PropertyInfo idProperty = type.GetProperty("Id");
        PropertyInfo nameProperty = type.GetProperty("Name");

        idProperty.SetValue(sample, 10);
        nameProperty.SetValue(sample, "Updated Name");

        Console.WriteLine($"Id: {sample.Id}, Name: {sample.Name}");
    }
}

この例では、GetPropertyメソッドを使用して、IdおよびNameプロパティの情報を取得し、SetValueメソッドを使ってこれらのプロパティに値を設定しています。

メソッドの動的な呼び出し

メタデータを取得して動的にメソッドを呼び出す例も示します。

using System;
using System.Reflection;

public class SampleClass
{
    public void Display(string message)
    {
        Console.WriteLine($"Message: {message}");
    }
}

public class Program
{
    public static void Main()
    {
        SampleClass sample = new SampleClass();
        Type type = typeof(SampleClass);

        MethodInfo methodInfo = type.GetMethod("Display");
        methodInfo.Invoke(sample, new object[] { "Hello, Reflection!" });
    }
}

このコードでは、GetMethodメソッドを使用してDisplayメソッドの情報を取得し、Invokeメソッドを使用して動的にメソッドを呼び出しています。

これらの手順を通じて、C#でのリフレクションを使ったメタデータの取得と設定の方法を理解することができます。リフレクションを適切に使用することで、より柔軟で強力なアプリケーションを構築できます。

パフォーマンスの最適化

リフレクションは強力な機能ですが、使用方法によってはアプリケーションのパフォーマンスに悪影響を及ぼすことがあります。ここでは、リフレクションを使用する際のパフォーマンス最適化手法について解説します。

キャッシングの利用

リフレクションの操作はコストが高いため、頻繁に使用する場合は結果をキャッシュすることが推奨されます。以下の例では、プロパティ情報をキャッシュしてパフォーマンスを向上させます。

using System;
using System.Reflection;
using System.Collections.Generic;

public class SampleClass
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class Program
{
    private static Dictionary<string, PropertyInfo> propertyCache = new Dictionary<string, PropertyInfo>();

    public static void Main()
    {
        SampleClass sample = new SampleClass();
        Type type = typeof(SampleClass);

        // プロパティ情報のキャッシング
        if (!propertyCache.ContainsKey("Id"))
        {
            propertyCache["Id"] = type.GetProperty("Id");
        }

        PropertyInfo idProperty = propertyCache["Id"];
        idProperty.SetValue(sample, 10);
        Console.WriteLine($"Id: {sample.Id}");
    }
}

この例では、プロパティ情報をキャッシュすることで、GetPropertyメソッドの呼び出しを最小限に抑え、パフォーマンスを向上させています。

コンパイル済みラムダ式の使用

リフレクション操作をコンパイル済みのラムダ式に変換することで、パフォーマンスを大幅に向上させることができます。以下の例では、プロパティ設定をコンパイル済みラムダ式に置き換えています。

using System;
using System.Linq.Expressions;
using System.Reflection;

public class SampleClass
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class Program
{
    public static void Main()
    {
        SampleClass sample = new SampleClass();
        Type type = typeof(SampleClass);

        // プロパティ情報の取得
        PropertyInfo idProperty = type.GetProperty("Id");

        // プロパティ設定用のラムダ式をコンパイル
        var parameterExpression = Expression.Parameter(typeof(SampleClass));
        var propertyExpression = Expression.Property(parameterExpression, idProperty);
        var valueExpression = Expression.Parameter(typeof(int));
        var assignExpression = Expression.Assign(propertyExpression, valueExpression);
        var setterLambda = Expression.Lambda<Action<SampleClass, int>>(assignExpression, parameterExpression, valueExpression).Compile();

        // ラムダ式を使ってプロパティに値を設定
        setterLambda(sample, 10);
        Console.WriteLine($"Id: {sample.Id}");
    }
}

この例では、プロパティ設定用のラムダ式を事前にコンパイルし、実行時に高速にプロパティに値を設定しています。

使用頻度の最小化

リフレクションを使用する操作の頻度を最小限に抑えることも重要です。頻繁に使用する必要がある場合は、キャッシングやラムダ式のコンパイルを組み合わせて最適化することを検討してください。

具体例: 性能測定

以下のコードは、リフレクションを用いたメソッド呼び出しとラムダ式を用いた呼び出しのパフォーマンスを比較する例です。

using System;
using System.Diagnostics;
using System.Linq.Expressions;
using System.Reflection;

public class SampleClass
{
    public void Display()
    {
        // No-op
    }
}

public class Program
{
    public static void Main()
    {
        SampleClass sample = new SampleClass();
        Type type = typeof(SampleClass);
        MethodInfo methodInfo = type.GetMethod("Display");

        // リフレクションによるメソッド呼び出し
        Stopwatch sw = Stopwatch.StartNew();
        for (int i = 0; i < 1000000; i++)
        {
            methodInfo.Invoke(sample, null);
        }
        sw.Stop();
        Console.WriteLine($"リフレクション: {sw.ElapsedMilliseconds} ms");

        // ラムダ式によるメソッド呼び出し
        var instanceParameter = Expression.Parameter(typeof(SampleClass));
        var callExpression = Expression.Call(instanceParameter, methodInfo);
        var lambda = Expression.Lambda<Action<SampleClass>>(callExpression, instanceParameter).Compile();

        sw = Stopwatch.StartNew();
        for (int i = 0; i < 1000000; i++)
        {
            lambda(sample);
        }
        sw.Stop();
        Console.WriteLine($"ラムダ式: {sw.ElapsedMilliseconds} ms");
    }
}

この例では、リフレクションによるメソッド呼び出しと、コンパイル済みラムダ式を用いたメソッド呼び出しのパフォーマンスを比較しています。ラムダ式を用いることで、リフレクションよりも高速にメソッドを呼び出せることが確認できます。

リフレクションの使用は慎重に行い、適切な最適化手法を用いることで、アプリケーションのパフォーマンスを維持しながら柔軟な動的動作を実現することが可能です。

応用例: ダイナミックプロキシの生成

リフレクションを使用して、動的にプロキシを生成することができます。ダイナミックプロキシは、オブジェクトのメソッド呼び出しをインターセプトし、追加のロジックを挿入するのに役立ちます。このセクションでは、ダイナミックプロキシの生成方法とその実装例を紹介します。

ダイナミックプロキシの基本概念

ダイナミックプロキシは、実行時にオブジェクトのメソッド呼び出しをインターセプトし、前後に処理を追加することができます。これにより、ロギング、トランザクション管理、キャッシングなどのクロスカッティングな関心事を処理することができます。

実装例: SimpleDynamicProxy

ここでは、シンプルなダイナミックプロキシを生成するためのコード例を示します。System.Reflection.Emit名前空間を使用して、動的にプロキシクラスを生成します。

using System;
using System.Reflection;
using System.Reflection.Emit;

public interface IExample
{
    void Execute();
}

public class Example : IExample
{
    public void Execute()
    {
        Console.WriteLine("Executing...");
    }
}

public class SimpleDynamicProxy
{
    public static T CreateProxy<T>(T instance)
    {
        Type interfaceType = typeof(T);
        string proxyName = $"{interfaceType.Name}Proxy";

        AssemblyName assemblyName = new AssemblyName(proxyName);
        AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
        ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(proxyName + "Module");

        TypeBuilder typeBuilder = moduleBuilder.DefineType(proxyName, TypeAttributes.Public, null, new[] { interfaceType });

        FieldBuilder fieldBuilder = typeBuilder.DefineField("_instance", interfaceType, FieldAttributes.Private);

        ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new[] { interfaceType });
        ILGenerator ctorIL = constructorBuilder.GetILGenerator();
        ctorIL.Emit(OpCodes.Ldarg_0);
        ctorIL.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
        ctorIL.Emit(OpCodes.Ldarg_0);
        ctorIL.Emit(OpCodes.Ldarg_1);
        ctorIL.Emit(OpCodes.Stfld, fieldBuilder);
        ctorIL.Emit(OpCodes.Ret);

        foreach (var method in interfaceType.GetMethods())
        {
            MethodBuilder methodBuilder = typeBuilder.DefineMethod(method.Name, MethodAttributes.Public | MethodAttributes.Virtual, method.ReturnType, Type.EmptyTypes);
            ILGenerator il = methodBuilder.GetILGenerator();

            // Before method execution
            il.Emit(OpCodes.Ldstr, $"Before executing {method.Name}");
            il.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new[] { typeof(string) }));

            // Execute original method
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Ldfld, fieldBuilder);
            il.Emit(OpCodes.Callvirt, method);

            // After method execution
            il.Emit(OpCodes.Ldstr, $"After executing {method.Name}");
            il.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new[] { typeof(string) }));

            il.Emit(OpCodes.Ret);
            typeBuilder.DefineMethodOverride(methodBuilder, method);
        }

        Type proxyType = typeBuilder.CreateType();
        return (T)Activator.CreateInstance(proxyType, instance);
    }
}

public class Program
{
    public static void Main()
    {
        IExample example = new Example();
        IExample proxy = SimpleDynamicProxy.CreateProxy(example);

        proxy.Execute();
    }
}

このコードでは、以下の手順でダイナミックプロキシを生成しています。

AssemblyBuilderとModuleBuilderを使用して、新しいアセンブリとモジュールを定義します。
TypeBuilderを使用して、新しいプロキシクラスを定義します。
元のインスタンスを保持するためのフィールドと、コンストラクタを定義します。
インターフェイスのメソッドごとに、メソッドの前後に追加処理を挿入するメソッドを定義します。
プロキシクラスを生成し、インスタンスを作成します。

このシンプルなダイナミックプロキシは、メソッドの実行前後にメッセージを表示する機能を持ちます。これにより、クロスカッティングな関心事を容易に処理できるようになります。

応用例: 属性の操作

リフレクションを使用することで、クラスやメソッドに付与された属性（アトリビュート）を動的に取得および操作することができます。属性は、メタデータとして追加情報を提供し、プログラムの動作を柔軟に制御するのに役立ちます。このセクションでは、属性の操作方法とその応用例を紹介します。

属性の定義

まず、カスタム属性を定義する方法を示します。以下の例では、SampleAttributeというカスタム属性を定義します。

using System;

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = false)]
public class SampleAttribute : Attribute
{
    public string Description { get; }

    public SampleAttribute(string description)
    {
        Description = description;
    }
}

このカスタム属性は、クラスやメソッドに対して説明を追加するために使用されます。

属性の適用

次に、定義したカスタム属性をクラスやメソッドに適用する方法を示します。

[Sample("This is a sample class.")]
public class SampleClass
{
    [Sample("This is a sample method.")]
    public void SampleMethod()
    {
        Console.WriteLine("SampleMethod executed.");
    }
}

ここでは、SampleClassクラスとそのSampleMethodメソッドに対してSampleAttributeを適用しています。

属性の取得

リフレクションを使用して、クラスやメソッドに付与された属性を動的に取得する方法を示します。

using System;
using System.Reflection;

public class Program
{
    public static void Main()
    {
        Type type = typeof(SampleClass);

        // クラスの属性を取得
        var classAttributes = type.GetCustomAttributes(typeof(SampleAttribute), false);
        foreach (SampleAttribute attr in classAttributes)
        {
            Console.WriteLine($"Class Attribute Description: {attr.Description}");
        }

        // メソッドの属性を取得
        MethodInfo methodInfo = type.GetMethod("SampleMethod");
        var methodAttributes = methodInfo.GetCustomAttributes(typeof(SampleAttribute), false);
        foreach (SampleAttribute attr in methodAttributes)
        {
            Console.WriteLine($"Method Attribute Description: {attr.Description}");
        }
    }
}

このコードでは、リフレクションを使用してSampleClassとそのSampleMethodに付与されたSampleAttributeを取得し、属性の説明をコンソールに表示しています。

属性を利用したロギングの実装

属性を利用して、メソッドの実行時にロギングを行う実装例を示します。

using System;
using System.Reflection;

[AttributeUsage(AttributeTargets.Method, Inherited = false)]
public class LogAttribute : Attribute
{
}

public class LoggingExample
{
    [Log]
    public void LoggedMethod()
    {
        Console.WriteLine("LoggedMethod executed.");
    }
}

public class Logger
{
    public static void InvokeWithLogging(object obj, string methodName)
    {
        Type type = obj.GetType();
        MethodInfo method = type.GetMethod(methodName);
        var logAttribute = method.GetCustomAttribute<LogAttribute>();

        if (logAttribute != null)
        {
            Console.WriteLine($"Logging: {method.Name} is about to be executed.");
        }

        method.Invoke(obj, null);

        if (logAttribute != null)
        {
            Console.WriteLine($"Logging: {method.Name} has been executed.");
        }
    }
}

public class Program
{
    public static void Main()
    {
        LoggingExample example = new LoggingExample();
        Logger.InvokeWithLogging(example, "LoggedMethod");
    }
}

この例では、LogAttributeをメソッドに適用し、Loggerクラスでメソッドの前後にロギング処理を追加しています。InvokeWithLoggingメソッドを使用して、LoggedMethodの実行前後にログメッセージが表示されるようにしています。

このように、リフレクションを使用して属性を動的に操作することで、柔軟なメタデータ管理やクロスカッティングな関心事の処理が可能となります。

演習問題

リフレクションとメタデータ操作の理解を深めるために、以下の演習問題を試してみましょう。これらの問題を通じて、リフレクションの基本操作から応用までを実践的に学びます。

演習1: クラスのプロパティ情報の取得

以下の手順に従って、指定されたクラスのプロパティ情報をリフレクションを使って取得し、コンソールに表示するプログラムを作成してください。

Personクラスを定義する。Name（string型）とAge（int型）のプロパティを持つ。
リフレクションを使ってPersonクラスのプロパティ情報を取得し、プロパティ名とその型をコンソールに表示する。

解答例

using System;
using System.Reflection;

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

public class Program
{
    public static void Main()
    {
        Type type = typeof(Person);
        PropertyInfo[] properties = type.GetProperties();

        foreach (var property in properties)
        {
            Console.WriteLine($"Property: {property.Name}, Type: {property.PropertyType}");
        }
    }
}

演習2: メソッドの動的呼び出し

以下の手順に従って、指定されたクラスのメソッドをリフレクションを使って動的に呼び出すプログラムを作成してください。

Calculatorクラスを定義する。Addメソッド（引数: int a, int b、戻り値: int）を持つ。
リフレクションを使ってAddメソッドを動的に呼び出し、その結果をコンソールに表示する。

解答例

using System;
using System.Reflection;

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

public class Program
{
    public static void Main()
    {
        Calculator calculator = new Calculator();
        Type type = typeof(Calculator);
        MethodInfo methodInfo = type.GetMethod("Add");

        object result = methodInfo.Invoke(calculator, new object[] { 5, 3 });
        Console.WriteLine($"Result: {result}");
    }
}

演習3: 属性の操作

以下の手順に従って、カスタム属性を定義し、リフレクションを使ってその属性を操作するプログラムを作成してください。

InfoAttributeを定義する。Description（string型）プロパティを持つ。
Productクラスを定義し、InfoAttributeを適用する。
リフレクションを使ってProductクラスのInfoAttributeを取得し、そのDescriptionをコンソールに表示する。

解答例

using System;
using System.Reflection;

[AttributeUsage(AttributeTargets.Class)]
public class InfoAttribute : Attribute
{
    public string Description { get; }

    public InfoAttribute(string description)
    {
        Description = description;
    }
}

[Info("This is a product class.")]
public class Product
{
    public string Name { get; set; }
    public double Price { get; set; }
}

public class Program
{
    public static void Main()
    {
        Type type = typeof(Product);
        var attributes = type.GetCustomAttributes(typeof(InfoAttribute), false);

        foreach (InfoAttribute attr in attributes)
        {
            Console.WriteLine($"Description: {attr.Description}");
        }
    }
}

これらの演習を通じて、リフレクションとメタデータ操作の基礎を実践的に学ぶことができます。リフレクションの応用範囲を理解し、より高度なメタデータ操作を実現しましょう。

まとめ

リフレクションを使ったメタデータ操作は、C#のプログラムに柔軟性と拡張性をもたらします。本記事では、リフレクションの基本から応用例までを詳しく解説しました。リフレクションのメリットとデメリットを理解し、適切に最適化することで、パフォーマンスを維持しながら高度な機能を実現できます。演習問題を通じて、リフレクションとメタデータ操作の実践力を高め、より効率的なコーディングを目指しましょう。