C# 反序列化JSON.NET，但不知道其类型

所以我正在编写一个tcp/ip聊天，我想使用json.net来序列化消息，以便通过网络发送消息

我得到了以下两种信息：

class AlertMessage
{
    public string Client { get; set; }
    public ServerManager.Status Status { get; set; } //enum {Connect, Disconnect}
}

class TextMessage
{
    public string Client { get; set; }
    public string Message { get; set; }
}

---

要进行反序列化，我需要使用方法

JsonConvert.DeserializeObject（object）

，但在客户端，我无法真正说出到达的类型，欢迎提供任何帮助！谢谢

我不确定是否正确理解了您的问题，但您可以将其反序列化为动态对象。例如：

var converter=新的ExpandoObjectConverter（）；
dynamic obj=JsonConvert.DeserializeObject（json，converter）
如果您不知道将要接收的json，可以使用

using System.Web.Script.Serialization;

命名空间。（轻松搜索并添加此引用）

我使用以下代码将任何对象转换为有效的json对象

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Dynamic;
using System.Linq;
using System.Text;
using System.Web.Script.Serialization;

namespace MinimalMonitoringClient.Helper
{
    public sealed class DynamicJsonConverter : JavaScriptConverter
    {
        public static object ConvertToObject(string data)
        {
            var serializer = new JavaScriptSerializer();
            serializer.RegisterConverters(new[] { new DynamicJsonConverter() });
            return serializer.Deserialize(data, typeof(object));
        }

        private static string CleanJson(string data)
        {
            //Remove leading and ending whitespaces.
            data = data.Trim();

            //Java Script notation fixes
            if(data.StartsWith("["))
                data = data.Remove(0, 1);
            if(data.EndsWith("]"))
                data = data.Remove(data.Length - 1, 1);
            return data.Contains("={") ? data.Replace("={", ":{") : data;
        }

        public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            if (dictionary == null)
                throw new ArgumentNullException("dictionary");

            return type == typeof(object) ? new DynamicJsonObject(dictionary) : null;
        }

        public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
        {
            throw new NotImplementedException();
        }

        public override IEnumerable<Type> SupportedTypes
        {
            get { return new ReadOnlyCollection<Type>(new List<Type>(new[] { typeof(object) })); }
        }

        #region Nested type: DynamicJsonObject

        private sealed class DynamicJsonObject : DynamicObject
        {
            private readonly IDictionary<string, object> _dictionary;

            public DynamicJsonObject(IDictionary<string, object> dictionary)
            {
                _dictionary = dictionary ?? throw new ArgumentNullException("dictionary");
            }

            public override string ToString()
            {
                var sb = new StringBuilder("{");
                ToString(sb);
                return sb.ToString();
            }

            private void ToString(StringBuilder sb)
            {
                var firstInDictionary = true;
                foreach (var pair in _dictionary)
                {
                    if (!firstInDictionary)
                        sb.Append(",");
                    firstInDictionary = false;
                    var value = pair.Value;
                    var name = pair.Key;
                    if (value is string)
                    {
                        sb.AppendFormat("{0}:\"{1}\"", name, value);
                    }
                    else if (value is IDictionary<string, object>)
                    {
                        new DynamicJsonObject((IDictionary<string, object>)value).ToString(sb);
                    }
                    else if (value is ArrayList)
                    {
                        sb.Append(name + ":[");
                        var firstInArray = true;
                        foreach (var arrayValue in (ArrayList)value)
                        {
                            if (!firstInArray)
                                sb.Append(",");
                            firstInArray = false;
                            if (arrayValue is IDictionary<string, object>)
                                new DynamicJsonObject((IDictionary<string, object>)arrayValue).ToString(sb);
                            else if (arrayValue is string)
                                sb.AppendFormat("\"{0}\"", arrayValue);
                            else
                                sb.AppendFormat("{0}", arrayValue);

                        }
                        sb.Append("]");
                    }
                    else
                    {
                        sb.AppendFormat("{0}:{1}", name, value);
                    }
                }
                sb.Append("}");
            }

            public override bool TryGetMember(GetMemberBinder binder, out object result)
            {
                if (!_dictionary.TryGetValue(binder.Name, out result))
                {
                    // return null to avoid exception.  caller can check for null this way...
                    result = null;
                    return true;
                }

                result = WrapResultObject(result);
                return true;
            }

            public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
            {
                if (indexes.Length == 1 && indexes[0] != null)
                {
                    if (!_dictionary.TryGetValue(indexes[0].ToString(), out result))
                    {
                        // return null to avoid exception.  caller can check for null this way...
                        result = null;
                        return true;
                    }

                    result = WrapResultObject(result);
                    return true;
                }

                return base.TryGetIndex(binder, indexes, out result);
            }

            private static object WrapResultObject(object result)
            {
                var dictionary = result as IDictionary<string, object>;
                if (dictionary != null)
                    return new DynamicJsonObject(dictionary);

                var arrayList = result as ArrayList;
                if (arrayList != null && arrayList.Count > 0)
                {
                    return arrayList[0] is IDictionary<string, object>
                        ? new List<object>(arrayList.Cast<IDictionary<string, object>>().Select(x => new DynamicJsonObject(x)))
                        : new List<object>(arrayList.Cast<object>());
                }

                return result;
            }
        }

        #endregion
    }
}

希望这有助于
反序列化到更通用的类，如
类消息{public string Client{get；set；}public ServerManager.Status Status{get；set；}public string Message{get；set；}
现在您可以测试属性并使用相应的API，我想说的是，您没有从同一端点返回不同类型的API。。。如果您的目标是强类型语言，则不会。也许重新思考一下你的信息。我对c#有点陌生，所以有很多事情我不明白。对不起，我在寻找与我相同的问题，我找到了这个答案，尽管在最后一步，我仍然需要将对象转换为从json提取的数据类型。我怎么做？（classtocasto）objectToCast；或者只使用JsonConvert.Deserialize（…）；
object jsonObject = DynamicJsonConverter.ConvertToObject(Json);