如何将派生自Y的类A转换为同结构的抽象类X？

首先明确一点：直接强制转换(X)(new A())肯定是不行的——因为在CLR类型系统里，X和Y是完全独立的两个抽象类，A只继承自Y，和X没有任何继承或实现关系，哪怕结构完全一致也跨不过类型安全的坎。下面给你几种实用的实现方案：

1. 序列化/反序列化（补充细节优化） #

你已经尝试过这个思路，这里针对internal set的属性补充适配方案：

如果用System.Text.Json，需要配置序列化器允许访问非公共成员：

using System.Text.Json;
using System.Text.Json.Serialization;

var aInstance = new A { Name = "Test" };

// 配置序列化器，适配internal属性
var options = new JsonSerializerOptions
{
    PropertyNameCaseInsensitive = true,
    // 自定义转换器处理非公共属性访问
    Converters = { new InternalPropertyConverter() }
};

// 序列化A为JSON字符串
string json = JsonSerializer.Serialize(aInstance, options);
// 反序列化为X类型
X xInstance = JsonSerializer.Deserialize<X>(json, options);
xInstance.PrintName(); // 输出 "Test"

如果用Newtonsoft.Json，配置会更简单，默认就能处理internal set属性（同程序集下无需额外配置）：

using Newtonsoft.Json;

var aInstance = new A { Name = "Test" };
string json = JsonConvert.SerializeObject(aInstance);
X xInstance = JsonConvert.DeserializeObject<X>(json);

优缺点：实现简单，几乎不用写业务代码；但序列化反序列化有性能开销，若类包含复杂类型、循环引用则可能出问题。

2. 手动映射+X的具体实现类 #

因为X是抽象类无法直接实例化，我们可以先写一个X的具体子类，再手动把A的属性映射过去：

// 定义X的具体实现类（必须，因为抽象类不能直接new）
public class XConcrete : X { }

// 写扩展方法简化转换
public static class AExtensions
{
    public static X ToX(this A a)
    {
        if (a == null) return null;
        
        var x = new XConcrete();
        // 同程序集下可直接赋值Name；跨程序集则用反射设置
        var nameProperty = typeof(X).GetProperty("Name", BindingFlags.Public | BindingFlags.Instance);
        nameProperty.SetValue(x, a.Name);
        
        return x;
    }
}

// 使用示例
var aInstance = new A { Name = "Manual Map" };
X xInstance = aInstance.ToX();
xInstance.PrintName(); // 输出 "Manual Map"

优缺点：性能最优，完全可控，适合类结构简单的场景；但如果类的属性较多，需要维护映射代码，属性变更时要同步修改。

3. TypeBuilder动态生成代理类（进阶方案） #

这个方法适合大量转换、且不想手动维护映射的场景，原理是动态生成一个继承自X的类，内部包装A的实例，把X的属性和方法调用转发给A。

以下是一个可运行的示例：

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

public static class TypeBuilderHelper
{
    public static X ConvertAtoX(A a)
    {
        if (a == null) return null;

        // 创建动态程序集和模块
        var assemblyName = new AssemblyName("DynamicXProxy");
        var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
        var moduleBuilder = assemblyBuilder.DefineDynamicModule("DynamicXProxyModule");

        // 定义代理类，继承自X
        var typeBuilder = moduleBuilder.DefineType("XProxy", TypeAttributes.Public | TypeAttributes.Class, typeof(X));

        // 添加字段保存A的实例
        var aField = typeBuilder.DefineField("_aInstance", typeof(A), FieldAttributes.Private);

        // 定义构造函数，接收A实例并赋值
        var ctorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new[] { typeof(A) });
        var ctorIl = ctorBuilder.GetILGenerator();
        ctorIl.Emit(OpCodes.Ldarg_0);
        ctorIl.Emit(OpCodes.Call, typeof(X).GetConstructor(Type.EmptyTypes)); // 调用X的无参构造
        ctorIl.Emit(OpCodes.Ldarg_0);
        ctorIl.Emit(OpCodes.Ldarg_1);
        ctorIl.Emit(OpCodes.Stfld, aField);
        ctorIl.Emit(OpCodes.Ret);

        // 重写Name属性的get/set方法
        var nameProperty = typeof(X).GetProperty("Name");
        // 重写get方法
        var getMethod = typeBuilder.DefineMethod("get_Name", MethodAttributes.Public | MethodAttributes.Virtual, typeof(string), Type.EmptyTypes);
        var getIl = getMethod.GetILGenerator();
        getIl.Emit(OpCodes.Ldarg_0);
        getIl.Emit(OpCodes.Ldfld, aField);
        getIl.Emit(OpCodes.Callvirt, typeof(A).GetProperty("Name").GetGetMethod());
        getIl.Emit(OpCodes.Ret);
        // 重写set方法
        var setMethod = typeBuilder.DefineMethod("set_Name", MethodAttributes.Public | MethodAttributes.Virtual, typeof(void), new[] { typeof(string) });
        var setIl = setMethod.GetILGenerator();
        setIl.Emit(OpCodes.Ldarg_0);
        setIl.Emit(OpCodes.Ldfld, aField);
        setIl.Emit(OpCodes.Ldarg_1);
        setIl.Emit(OpCodes.Callvirt, typeof(A).GetProperty("Name").GetSetMethod(true)); // true获取非公共set方法
        setIl.Emit(OpCodes.Ret);
        // 关联属性与重写的方法
        typeBuilder.DefineProperty("Name", PropertyAttributes.None, typeof(string), Type.EmptyTypes)
                  .SetGetMethod(getMethod)
                  .SetSetMethod(setMethod);

        // 重写PrintName方法
        var printMethod = typeBuilder.DefineMethod("PrintName", MethodAttributes.Public | MethodAttributes.Virtual, typeof(void), Type.EmptyTypes);
        var printIl = printMethod.GetILGenerator();
        printIl.Emit(OpCodes.Ldarg_0);
        printIl.Emit(OpCodes.Ldfld, aField);
        printIl.Emit(OpCodes.Callvirt, typeof(A).GetMethod("PrintName"));
        printIl.Emit(OpCodes.Ret);

        // 创建动态类型并实例化
        var proxyType = typeBuilder.CreateType();
        return (X)Activator.CreateInstance(proxyType, a);
    }
}

// 使用示例
var aInstance = new A { Name = "Dynamic Proxy" };
X xInstance = TypeBuilderHelper.ConvertAtoX(aInstance);
xInstance.PrintName(); // 输出 "Dynamic Proxy"

优缺点：一次编写后可自动适配类的属性变更（只要结构一致），性能比序列化好；但实现复杂，需要熟悉反射和IL知识，可缓存动态生成的类型提升多次调用的性能。

内容的提问来源于stack exchange，提问作者AndrewToasterr