public class MyCollection<T> : IEnumerable<T>
{
    private readonly List<T> _items = new List<T>();

    // 泛型版本
    public IEnumerator<T> GetEnumerator()
    {
        return _items.GetEnumerator();
    }

    // 非泛型版本（显式实现）
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator(); // 调用泛型版本
    }
}

public class MyCollection<T> : IEnumerable<T>
{
    private readonly List<T> _items = new List<T>();

    public IEnumerator<T> GetEnumerator()
    {
        foreach (var item in _items)
        {
            yield return item;
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

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

public static class EnumerableGenerator
{
    public static Type CreateEnumerableType(Type itemType)
    {
        var assemblyName = new AssemblyName("DynamicEnumerableAssembly");
        var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
        var moduleBuilder = assemblyBuilder.DefineDynamicModule("MainModule");
        
        var typeBuilder = moduleBuilder.DefineType(
            $"DynamicEnumerable`1[{itemType.Name}]",
            TypeAttributes.Public,
            typeof(object),
            new[] { typeof(IEnumerable<>).MakeGenericType(itemType), typeof(IEnumerable) });

        // 添加字段存储集合数据
        var fieldBuilder = typeBuilder.DefineField(
            "_items",
            typeof(List<>).MakeGenericType(itemType),
            FieldAttributes.Private);

        // 添加构造函数
        var ctorBuilder = typeBuilder.DefineConstructor(
            MethodAttributes.Public,
            CallingConventions.Standard,
            new[] { typeof(IEnumerable<>).MakeGenericType(itemType) });
        
        var ctorIl = ctorBuilder.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.Newobj, typeof(List<>).MakeGenericType(itemType).GetConstructor(new[] { typeof(IEnumerable<>).MakeGenericType(itemType) }));
        ctorIl.Emit(OpCodes.Stfld, fieldBuilder);
        ctorIl.Emit(OpCodes.Ret);

        // 实现泛型 GetEnumerator
        var methodBuilder = typeBuilder.DefineMethod(
            "GetEnumerator",
            MethodAttributes.Public | MethodAttributes.Virtual,
            typeof(IEnumerator<>).MakeGenericType(itemType),
            Type.EmptyTypes);
        
        var methodIl = methodBuilder.GetILGenerator();
        methodIl.Emit(OpCodes.Ldarg_0);
        methodIl.Emit(OpCodes.Ldfld, fieldBuilder);
        methodIl.Emit(OpCodes.Callvirt, typeof(List<>).MakeGenericType(itemType).GetMethod("GetEnumerator"));
        methodIl.Emit(OpCodes.Ret);

        // 实现接口的泛型 GetEnumerator
        typeBuilder.DefineMethodOverride(
            methodBuilder,
            typeof(IEnumerable<>).MakeGenericType(itemType).GetMethod("GetEnumerator"));

        // 实现非泛型 GetEnumerator
        var nonGenericMethodBuilder = typeBuilder.DefineMethod(
            "System.Collections.IEnumerable.GetEnumerator",
            MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Final,
            typeof(IEnumerator),
            Type.EmptyTypes);
        
        var nonGenericMethodIl = nonGenericMethodBuilder.GetILGenerator();
        nonGenericMethodIl.Emit(OpCodes.Ldarg_0);
        nonGenericMethodIl.Emit(OpCodes.Call, methodBuilder);
        nonGenericMethodIl.Emit(OpCodes.Ret);

        // 实现接口的非泛型 GetEnumerator
        typeBuilder.DefineMethodOverride(
            nonGenericMethodBuilder,
            typeof(IEnumerable).GetMethod("GetEnumerator"));

        return typeBuilder.CreateType();
    }
}

// 创建动态类型
var dynamicType = EnumerableGenerator.CreateEnumerableType(typeof(string));

// 创建实例
var instance = Activator.CreateInstance(dynamicType, new object[] { new List<string> { "a", "b", "c" } });

// 使用foreach迭代
foreach (var item in (IEnumerable)instance)
{
    Console.WriteLine(item);
}