通过反射调用时，返回对象不是签名声明的对象

ApiResult<T>虽然您还没有分享或IPagedList<T>或的实现，但这看起来是需要工厂转换器模式PagedList<T>的情况：

工厂模式对于开放泛型来说是必需的，因为将对象转换为字符串或从字符串转换为对象的代码对于所有类型来说都不相同。开放泛型类型的转换器（List<T>,例如）必须在后台为封闭泛型类型（例如）创建转换器List<DateTime>。必须编写代码来处理转换器可以处理的每种封闭泛型类型。

假设你的类型看起来像这样：

public abstract record ApiResult
{
    public static ApiResult<T> Create<T>(T result) => new ApiResult<T>(result);
}

public record ApiResult<T>(T Result) : ApiResult;

public interface IPagedList
{
    public IEnumerable Items { get; }
    public int PageNumber { get; }
    public int PageSize { get; }
    public int TotalItems { get; }
}

public interface IPagedList<out T> : IPagedList
{
    public new IEnumerable<T> Items { get; }
}

public class PagedList<T> : IPagedList<T>
{
    public IEnumerable<T> Items { get; }
    public int PageNumber { get; }
    public int PageSize { get; }
    public int TotalItems { get; }
    IEnumerable IPagedList.Items => Items;

    private protected PagedList(IEnumerable<T> items, int pageNumber, int pageSize, int totalItems) =>
        (this.Items, this.PageNumber, this.PageSize, this.TotalItems) = (items, pageNumber, pageSize, totalItems);

    public static IPagedList<T> Create(IEnumerable<T> items, int pageNumber, int pageSize, int totalItems) {
        //Ensure.That.IsNotNull(items);  // FIXED removed calls to undefined methods
        //Ensure.That.IsNotZeroOrNegative(pageNumber);
        //Ensure.That.IsNotZeroOrNegative(pageSize);
        return new PagedList<T>(items, pageNumber, pageSize, totalItems);
    }
}

然后，您可以定义以下工厂转换器和内部通用转换器，如下所示：

public class PagedListConverter : JsonConverterFactory
{
    public override bool CanConvert(Type typeToConvert) => typeToConvert.IsPagedList();
    
    public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options) =>
        (JsonConverter)Activator.CreateInstance(typeof(PagedListConverter<>).MakeGenericType(typeToConvert.GetPagedListItemType()!))!;
}

public class PagedListConverter<T> : JsonConverter<IPagedList<T>>
{
    record DTO(IEnumerable<T> items, int pageNumber, int pageSize, int totalItems);

    public override bool CanConvert(Type typeToConvert) => typeToConvert == typeof(IPagedList<T>) || typeToConvert == typeof(PagedList<T>);

    public override IPagedList<T> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => 
        JsonSerializer.Deserialize<DTO>(ref reader, options) switch
        {
            var dto when dto is not null => PagedList<T>.Create(dto.items, dto.pageNumber, dto.pageSize, dto.totalItems),
            _ => PagedList<T>.Create(Enumerable.Empty<T>(), 0, 0, 0), // TODO: decide what to do in case a null value was encountered in the JSON
        };
        
    public override void Write(Utf8JsonWriter writer, IPagedList<T> value, JsonSerializerOptions options) =>
        JsonSerializer.Serialize(writer, new DTO(value.Items, value.PageNumber, value.PageSize, value.TotalItems), options);
}

public static class TypeExtensions
{
    public static IEnumerable<Type> GetInterfacesAndSelf(this Type type)
        => (type ?? throw new ArgumentNullException()).IsInterface ? new[] { type }.Concat(type.GetInterfaces()) : type.GetInterfaces();

    public static bool IsPagedList(this Type type) => type.GetPagedListItemType() != null;
    
    public static Type? GetPagedListItemType(this Type type) => 
        type.GetInterfacesAndSelf()
            .Where(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IPagedList<>))
            .Select(t => t.GetGenericArguments()[0])
            .SingleOrDefault();
}

现在假设您有一些项目类别，例如如下：

public class MyItem
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}

您将能够按如下方式序列化和反序列化PagedList<MyItem>或IPagedList<MyItem>：

var result = ApiResult.Create(
    PagedList<MyItem>.Create([new () { Name = "name 1", Price = 101.1M }], 3, 1, 20)
);

var options = new JsonSerializerOptions
{
    Converters = { new PagedListConverter() },
    // Other options as required, e.g.
    WriteIndented = true,
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
};

var json = JsonSerializer.Serialize(result, options);

var newResult = JsonSerializer.Deserialize<ApiResult<IPagedList<MyItem>>>(json, options);

笔记：

• 在内部转换器中，不需要手动写入和读取每个属性，而是可以更轻松地将要序列化的类型映射到某个内部DTO，然后对 DTO 进行序列化和反序列化。

• 在本机 AOT应用中使用源生成时，工厂转换器模式可能无法工作。（例如，不能保证在这样的应用中工作。）相反，需要为所有类型手动创建内部转换器，例如：Type.MakeGenericType()MethodInfo.MakeGenericMethod()PagedListConverter<T>T

  var options = new JsonSerializerOptions
  {
      Converters = { 
          new PagedListConverter<MyItem>(),
          // Other PagedListConverter<T> converters as required
      },
      // Other options as required, e.g.
      WriteIndented = true,
      PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
  };
  

演示小提琴在这里。