将JObject转换为匿名对象

Question

我正在尝试将一个对象传递到Web API应用程序中。在序列化对象时，它会将其转换为JSON字符串。但是，在Web API应用程序方面，它将对象参数作为JObject获取。

以下代码块来自Web API应用程序：

//Read web api body content into a string variable
var resultStr = Request.Content.ReadAsStringAsync().Result;
//Convert json string to object with Newtonsoft
var obj = Newtonsoft.Json.JsonConvert.DeserializeObject<object>(resultStr);

这段代码生成了一个JObject，但是我需要一个匿名对象。Web api项目不知道类型，可以接收任何对象类型。

我需要一个像这样的对象。

object anonyObj = new { Prop1 = "Lorem" };

ExpandoObject类型不符合我的要求，因此将其转换为动态类型对我来说不是解决方案。

- Baran

---

Telerik报告ObjectDataSource需要一个真实的对象，因此我正在尝试解决这个问题。 - Baran

这将会相当复杂。你可以从以下链接开始：https://dev59.com/SG865IYBdhLWcg3wWtKz 或者 https://dev59.com/QHRB5IYBdhLWcg3wgHWr#28140345 - dbc

根据文档，Telerik Reporting ObjectDataSource可以绑定到像“DataSet”、“DataTable”、“IListSource”和“IEnumerable”等对象。因此，您有一些选项，而不仅仅是尝试创建匿名对象。 - Brian Rogers

Answer 1

使用Newtonsoft的反序列化程序，我能找到的最接近的内容是：

dynamic d = JObject.Parse("{a:1000, b:'c', d: [1,2,3]}");

请参见使用Json.net将JSON对象反序列化为动态对象

干杯

- JasonX

---

抱歉，动态类型对我来说不是一个解决方案。 - Baran

我相信你必须为你的JSON对象定义一个类，动态创建你的对象类或使用动态对象。我可能错了，但我认为没有有用的第四个选项。 - JasonX

Answer 2

也许这个对话现在已经太旧了，因为现在有JsonConvert.DeserializeAnonymousType了，但是我特意看了一下这篇文章，专门针对JObject，发现一个稍微简单的选项，未来可能有人会用到 :)

我创建了下面的扩展方法，它简单地包装了标准的JObject.ToObject方法。

 public static T ToAnonymousType<T>(this JObject source, T destinationType)
 {
     return source.ToObject<T>();
 }

这样就可以像这样使用它：

JObject myJObject = new JObject(); // Something more exciting probably happens here
var myAnonymousObject = myJObject.ToAnonymousType(new { Id = default(int), Name = default(string) });

- Baguazhang

Answer 3

Json对象无法完全序列化为对象。如果您使用的是Newtonsoft，则会将未知类型转换为JObject。在这个问题中，我们尝试在运行时创建未知类型。为了在wep api侧执行此操作，我们必须将类型详细信息传递到wep api应用程序中。 Json.NET Schema库可以将类型序列化为字符串。该方法帮助我们将未知类型的模式传递到wep api应用程序中。从wep api方面需要两个参数。第一个参数是json模式字符串，第二个参数是json数据字符串。此时，通过json模式字符串的帮助，我们可以使用Reflection库在运行时生成此类型。以下是C#类。但它不能用于列表或数组。将来我可以开发它。

  public class ObjectConverter
{
    public static object Convert(string json, JSchema schema)
    {
        var type = CreateType(schema);
        var destObject = Newtonsoft.Json.JsonConvert.DeserializeObject(json, type);
        return destObject;
    }

    private static Type CreateType(JSchema schema)
    {
        Type result = null;
        var typeBuilder = GetTypeBuilder(Guid.NewGuid().ToString());
        foreach (var item in schema.Properties)
        {
            if (item.Value.Type == (Newtonsoft.Json.Schema.JSchemaType.Object | Newtonsoft.Json.Schema.JSchemaType.Null))
            {
                Type type = CreateType(item.Value);
                if (item.Value.Type != null)
                {
                    CreateProperty(typeBuilder, item.Key, type);
                }
            }
            else
            {
                if (item.Value.Type != null)
                {
                    CreateProperty(typeBuilder, item.Key, ConvertType(item.Value.Type.Value));
                }
            }
        }

        result = typeBuilder.CreateType();
        return result;
    }

    private static Type ConvertType(JSchemaType source)
    {
        Type result = null;
        switch (source)
        {
            case JSchemaType.None:

                break;
            case JSchemaType.String:
                result = typeof(string);
                break;
            case JSchemaType.Number:
                result = typeof(float);
                break;
            case JSchemaType.Integer:
                result = typeof(int);
                break;
            case JSchemaType.Boolean:
                result = typeof(bool);
                break;
            case JSchemaType.Object:
                result = typeof(object);
                break;
            case JSchemaType.Array:
                result = typeof(Array);
                break;
            case JSchemaType.Null:
                result = typeof(Nullable);
                break;
            case Newtonsoft.Json.Schema.JSchemaType.String | Newtonsoft.Json.Schema.JSchemaType.Null:
                result = typeof(string);
                break;
            default:
                break;
        }
        return result;
    }

    private static TypeBuilder GetTypeBuilder(string typeSignature)
    {
        var an = new AssemblyName(typeSignature);
        AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.Run);
        ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MainModule");
        TypeBuilder tb = moduleBuilder.DefineType(typeSignature,
                TypeAttributes.Public |
                TypeAttributes.Class |
                TypeAttributes.AutoClass |
                TypeAttributes.AnsiClass |
                TypeAttributes.BeforeFieldInit |
                TypeAttributes.AutoLayout,
                null);
        return tb;
    }

    private static void CreateProperty(TypeBuilder tb, string propertyName, Type propertyType)
    {
        FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);

        PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null);
        MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes);
        ILGenerator getIl = getPropMthdBldr.GetILGenerator();

        getIl.Emit(OpCodes.Ldarg_0);
        getIl.Emit(OpCodes.Ldfld, fieldBuilder);
        getIl.Emit(OpCodes.Ret);

        MethodBuilder setPropMthdBldr =
            tb.DefineMethod("set_" + propertyName,
              MethodAttributes.Public |
              MethodAttributes.SpecialName |
              MethodAttributes.HideBySig,
              null, new[] { propertyType });

        ILGenerator setIl = setPropMthdBldr.GetILGenerator();
        Label modifyProperty = setIl.DefineLabel();
        Label exitSet = setIl.DefineLabel();

        setIl.MarkLabel(modifyProperty);
        setIl.Emit(OpCodes.Ldarg_0);
        setIl.Emit(OpCodes.Ldarg_1);
        setIl.Emit(OpCodes.Stfld, fieldBuilder);

        setIl.Emit(OpCodes.Nop);
        setIl.MarkLabel(exitSet);
        setIl.Emit(OpCodes.Ret);

        propertyBuilder.SetGetMethod(getPropMthdBldr);
        propertyBuilder.SetSetMethod(setPropMthdBldr);
    }
}

Convert 方法通过 JSON 模式帮助生成对象。只需使用 Newtonsoft.Json.JsonConvert.DeserializeObject(json, type) 命令即可获取真实对象。它可以作为 ObjectDataSource 在 Telerik Reporting 中使用。

- Baran