VS2003 下 Class 与 JSON格式数据 转换实现

最新推荐文章于 2022-02-12 22:50:49 发布
最新推荐文章于 2022-02-12 22:50:49 发布
阅读量300 收藏 1
点赞数 1
文章标签： json c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wooddy1982/article/details/106395743
版权

不考虑 JSON 数据格式有错误的情况下，可以试试以下函数。

public string Writer(Object obj)
{
    System.Text.StringBuilder builder = new StringBuilder();
    try
    {
        if(obj is String||obj is ValueType) return String.Format("{0}",obj);

        System.Type type = obj.GetType();
        if(obj is System.Collections.IList)
        {
            builder.Append(IListToJson(obj as System.Collections.IList));
        } 
        else 
        {
            if(type.IsClass&&!type.IsValueType&&!type.IsEnum)
            {
                builder.Append(ObjectToJson(obj,type.GetProperties()));
            }
        }
        return builder.ToString();
    }
    catch(System.Exception ex)
    {
        throw ex;
    }
    finally
    {
        builder = null;
    }
}

private String ObjectToJson(Object obj,System.Reflection.PropertyInfo[] properties)
{
    System.Text.StringBuilder builder = new StringBuilder();
    try
    {
        foreach(System.Reflection.PropertyInfo property in properties)
        {
            if(property.CanRead)
            {
                String key = property.Name;
                Object val = property.GetValue(obj,null);
                if(null!=val)
                {
                    builder.AppendFormat(",\"{0}\":",key);
                    if(val is String||val is ValueType)
                    {
                        if(val is String || val is Char)
                        {
                            if(val is Char&&val.Equals(Char.MinValue)) builder.AppendFormat("\"\"");
                            else builder.AppendFormat("\"{0}\"",val);
                        }
                        else 
                        {
                            builder.Append(val.ToString().ToLower());
                        }

                    } 
                    else 
                    {
                        System.Type type = val.GetType();
                        if(val is System.Collections.IList)
                        {
                            builder.Append(IListToJson(val as System.Collections.IList));
                        } 
                        else 
                        {
                            if(type.IsClass&&!type.IsValueType&&!type.IsEnum)
                            {
                                builder.Append(ObjectToJson(val,type.GetProperties()));
                            }
                        }
                    }
                }
            }
        }
        return builder.Replace(",","{",0,1) .Append("}").ToString();
    }
    catch(System.Exception ex)
    {
        throw ex;
    }
    finally
    {
        builder = null;
    }
}

private String IListToJson(System.Collections.IList list)
{
    System.Text.StringBuilder builder = new StringBuilder();
    try
    {
        System.Collections.IEnumerator enumerator = list.GetEnumerator();
        while(enumerator.MoveNext())
        {
            Object val = enumerator.Current;
            if(null==val)
            {
                builder.Append(",null");
            }
            else 
            {
                if(val is String||val is ValueType)
                {
                    if(val is String || val is Char)
                    {
                        if(val is Char&&val.Equals(Char.MinValue)) builder.AppendFormat(",\"\"");
                        else builder.AppendFormat(",\"{0}\"",val);
                    }
                    else 
                    {
                        builder.AppendFormat(",{0}",val.ToString().ToLower());
                    }

                } 
                else 
                {
                    System.Type type = val.GetType();
                    if(val is System.Collections.IList)
                    {
                        builder.AppendFormat(",{0}",IListToJson(val as System.Collections.IList));
                    } 
                    else 
                    {
                        if(type.IsClass&&!type.IsValueType&&!type.IsEnum)
                        {
                            builder.AppendFormat(",{0}",ObjectToJson(val,type.GetProperties()));
                        }
                    }
                }
            }
        }

        if(0==builder.Length) return builder.Append("[]").ToString();
        return builder.Replace(",","[",0,1) .Append("]").ToString();
    }
    catch(System.Exception ex)
    {
        throw ex;
    }
    finally
    {
        builder = null;
    }
}


public Object Reader(String json)
{
    if('{'.Equals(json[0])) return JsonToObject(json);
    else if('['.Equals(json[0])) return JsonToIList(json);
    else return null;
}

private System.Collections.Hashtable JsonToObject(String json)
{
    System.Collections.Hashtable hashTable = new Hashtable();
    System.Text.StringBuilder builder = new System.Text.StringBuilder(json);
    System.Text.RegularExpressions.Match keyMatch = null;
    do 
    {
        keyMatch = System.Text.RegularExpressions.Regex.Match(builder.ToString(),@"(?<!\\)\""(?=:):");
        if(keyMatch.Success)
        {
            Int32 index = 0;
            String key = builder.ToString(2,keyMatch.Index-2);
            String val = String.Empty;
            Int32 jsonType=0;
            switch(builder[keyMatch.Index+keyMatch.Length])
            {
                case '"':
                {
                    for(Int32 i = keyMatch.Index+keyMatch.Length+1;;i++)
                    {
                        if('"'==builder[i])
                        {
                            if('\\'!=builder[i-1]) 
                            {
                                index = i;
                                break;
                            }
                        }
                    }

                    val = builder.ToString(keyMatch.Index+keyMatch.Length+1,index-(keyMatch.Index+keyMatch.Length+1));
                    jsonType = 1;
                    builder.Remove(0,index+1);
                    break;
                }
                case '[':
                {
                    for(Int32 i = keyMatch.Index+keyMatch.Length+1;;i++)
                    {
                        if(']'==builder[i])
                        {
                            val = builder.ToString(keyMatch.Index+keyMatch.Length,i-(keyMatch.Index+keyMatch.Length)+1);
                            System.Text.RegularExpressions.MatchCollection matchesStart = System.Text.RegularExpressions.Regex.Matches(val,@"\[");
                            System.Text.RegularExpressions.MatchCollection matchesEnd = System.Text.RegularExpressions.Regex.Matches(val,@"\]");
                            if(matchesStart.Count==matchesEnd.Count)
                            {
                                index = i;
                                break;
                            }
                        }
                    }
                    jsonType = 2;
                    builder.Remove(0,index+1);
                    break;
                }
                case '{':
                {
                    for(Int32 i = keyMatch.Index+keyMatch.Length+1;;i++)
                    {
                        if('}'==builder[i])
                        {
                            val = builder.ToString(keyMatch.Index+keyMatch.Length,i-(keyMatch.Index+keyMatch.Length)+1);
                            System.Text.RegularExpressions.MatchCollection matchesStart = System.Text.RegularExpressions.Regex.Matches(val,@"\{");
                            System.Text.RegularExpressions.MatchCollection matchesEnd = System.Text.RegularExpressions.Regex.Matches(val,@"\}");
                            if(matchesStart.Count==matchesEnd.Count)
                            {
                                index = i;
                                break;
                            }
                        }
                    }
                    jsonType = 3;
                    builder.Remove(0,index+1);
                    break;
                }
                default:
                {
                    for(Int32 i = keyMatch.Index+keyMatch.Length+1;;i++)
                    {
                        if(','==builder[i])
                        {
                            index = i;
                            break;
                        }
                    }
                    val = builder.ToString(keyMatch.Index+keyMatch.Length,index-(keyMatch.Index+keyMatch.Length));
                    builder.Remove(0,index);
                    break;
                }
            }
            switch(jsonType)
            {
                case 0:
                {
                    if(System.Text.RegularExpressions.Regex.IsMatch(val,@"true|false",System.Text.RegularExpressions.RegexOptions.IgnoreCase))
                    {
                        hashTable.Add(key,Convert.ToBoolean(val));
                    } 
                    else 
                    {
                        hashTable.Add(key,Convert.ToDecimal(val));
                    }
                    break;
                }
                case 2:
                {
                    hashTable.Add(key,JsonToIList(val.ToString()));
                    break;
                }
                case 3:
                {
                    hashTable.Add(key,JsonToObject(val.ToString()));
                    break;
                }
                default:
                {
                    hashTable.Add(key,val);
                    break;
                }
            }
        }
    }while(keyMatch.Success);
    return hashTable;
}

private System.Collections.ArrayList JsonToIList(String json)
{
    System.Collections.ArrayList arrayList = new ArrayList();
    if("[]".Equals(json)) return arrayList;
    System.Text.StringBuilder builder = new System.Text.StringBuilder(json);
    for(Int32 i=1;i<builder.Length;)
    {
        Int32 index = 0;
        String val = String.Empty;
        Int32 jsonType=0;
        switch(builder[i])
        {
            case '"':
            {
                for(Int32 j = i+1;j<builder.Length;j++)
                {
                    if('"'==builder[j])
                    {
                        if('\\'!=builder[j-1]) 
                        {
                            index = j;
                            break;
                        }
                    }
                }

                val = builder.ToString(i+1,index-(i+1));
                jsonType = 1;
                break;
            }
            case '[':
            {
                for(Int32 j = i+1;j<builder.Length;j++)
                {
                    if(']'==builder[j])
                    {
                        val = builder.ToString(i,j-i+1);
                        System.Text.RegularExpressions.MatchCollection matchesStart = System.Text.RegularExpressions.Regex.Matches(val,@"\[");
                        System.Text.RegularExpressions.MatchCollection matchesEnd = System.Text.RegularExpressions.Regex.Matches(val,@"\]");
                        if(matchesStart.Count==matchesEnd.Count)
                        {
                            index = j;
                            break;
                        }
                    }
                }
                jsonType = 2;
                break;
            }
            case '{':
            {
                for(Int32 j = i+1;j<builder.Length;j++)
                {
                    if('}'==builder[j])
                    {
                        val = builder.ToString(i,j-i+1);
                        System.Text.RegularExpressions.MatchCollection matchesStart = System.Text.RegularExpressions.Regex.Matches(val,@"\{");
                        System.Text.RegularExpressions.MatchCollection matchesEnd = System.Text.RegularExpressions.Regex.Matches(val,@"\}");
                        if(matchesStart.Count==matchesEnd.Count)
                        {
                            index = j;
                            break;
                        }
                    }
                }
                jsonType = 3;
                break;
            }
            default:
            {
                for(Int32 j = i+1;j<builder.Length;j++)
                {
                    if(','==builder[j]||']'==builder[j])
                    {
                        index = j;
                        break;
                    }
                }
                val = builder.ToString(i,index-i);
                break;
            }
        }
        if(0==jsonType)i=index+1;
        else i=index+2;
        switch(jsonType)
        {
            case 0:
            {
                if("null".Equals(val))
                {
                    arrayList.Add(null);
                }
                else 
                {
                    if(System.Text.RegularExpressions.Regex.IsMatch(val,@"true|false",System.Text.RegularExpressions.RegexOptions.IgnoreCase))
                    {
                        arrayList.Add(Convert.ToBoolean(val));
                    } 
                    else 
                    {
                        arrayList.Add(Convert.ToDecimal(val));
                    }
                }
                break;
            }
            case 2:
            {
                arrayList.Add(JsonToIList(val.ToString()));
                break;
            }
            case 3:
            {
                arrayList.Add(JsonToObject(val.ToString()));
                break;
            }
            default:
            {
                arrayList.Add(val);
                break;
            }
        }
    }
    return arrayList;
}


public void Reader(String json,Object model) 
{
    if(null==model) return;
    Object obj = Reader(json);
    System.Type type = model.GetType();
    if(obj is System.Collections.ArrayList&&model is System.Collections.IList)
    {
        Reader(obj as System.Collections.ArrayList, model);
    } 
    else if(obj is System.Collections.Hashtable&&type.IsClass&&!type.IsValueType&&!type.IsEnum)
    {
        Reader(obj as System.Collections.Hashtable,  model);
    }
    
}

private void Reader(System.Collections.Hashtable hashTable, Object model) 
{
    System.Type type = model.GetType();
    System.Collections.IDictionaryEnumerator enumerator  = hashTable.GetEnumerator();
    while(enumerator.MoveNext())
    {
        String key = enumerator.Key as String;
        System.Reflection.PropertyInfo property = type.GetProperty(key);
        if(property.CanWrite)
        {
            if(enumerator.Value is Decimal||enumerator.Value is Boolean||enumerator.Value is String)
            { 
                if(property.PropertyType.IsValueType&&enumerator.Value is String)
                {
                    if(String.Empty.Equals(enumerator.Value)) property.SetValue(model,System.Char.MinValue,null);
                    else property.SetValue(model,Convert.ChangeType(enumerator.Value,property.PropertyType) ,null);
                }
                else 
                {
                    property.SetValue(model,Convert.ChangeType(enumerator.Value,property.PropertyType) ,null);
                }
            } 
            else if(enumerator.Value is System.Collections.IList)
            {
                Object arrayObject = null;
                if(property.PropertyType.IsArray) arrayObject = System.Array.CreateInstance(property.PropertyType.GetElementType(),(enumerator.Value as System.Collections.IList).Count);
                else arrayObject = System.Activator.CreateInstance(property.PropertyType);
                Reader(enumerator.Value as System.Collections.ArrayList,  arrayObject);
                property.SetValue(model,arrayObject,null);
            } 
            else 
            {
                Object modelObject = System.Activator.CreateInstance(property.PropertyType);
                Reader(enumerator.Value as System.Collections.Hashtable,  modelObject);
                property.SetValue(model,modelObject,null);
            }
        }
    }
}

private void Reader(System.Collections.ArrayList arrayList, Object model) 
{
    System.Type type = model.GetType();
    System.Collections.IList iList = model as System.Collections.IList;

    if(type.IsArray)
    {
        System.Type typeValue = type.GetElementType();
        if(typeValue.IsValueType||"String".Equals(typeValue.Name))
        {
            for(int i=0;i<arrayList.Count;i++)
            {
                iList[i]= Convert.ChangeType(arrayList[i], typeValue);
            }
        }
        else 
        {
            for(int i=0;i<arrayList.Count;i++)
            {
                Object modelValue = System.Activator.CreateInstance(typeValue);
                Reader(arrayList[i] as Hashtable,modelValue);
                iList[i]=Convert.ChangeType(modelValue, typeValue); 
            }
        }
    }
    else 
    {
        for(int i=0;i<arrayList.Count;i++)
        {
            iList[i]=arrayList[i];
        }
    }
}
 

wooddy1982
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
vs03中解析json
05-31
vs2003中没有序列化，所以解析json的时候只能截取字符串，这个类解决了截取字符串，可以直接调用，解析成json封装成Hashtable
python实现class对象转换成json/字典的方法
09-21
Python提供了`json`模块来处理JSON数据，包括将Python对象转化为JSON格式和从JSON字符串还原Python对象。 然而，`json`模块默认并不直接支持将类对象转换为JSON，因为JSON格式不包含类信息。因此，我们需要自定义...
查询SqlServer数据库char(0)特殊字符转换为JSON的问题：\u000
Expec-乐的博客
05-27 1121
问题描述 在Python通过pymssql查询SqlServer数据库数据时，如果是该列包含char(0)特殊字符时，将该字符转换为JSON时会转换为\u000导致将JSON解析插入到PG数据库时报错，如下： ### Cause: org.postgresql.util.PSQLException: ERROR: invalid byte sequence for encoding "UTF8": 0x00 解决方法 将该字段做以下处理：首先转换字符集，然后将char(0)替换为’’ REPLACE(co
C++ 结构体转json
花狗Fdog的博客
02-12 7729
????FdogSerialize???? FdogSerialize是一个用于C++序列化的开源库，采用非入侵方式，无需在原有结构体上进行修改，目前支持基础类型，基础类型数组，结构体，以及vector，list，map等数据类型的序列化，支持JSON和XML两种数据格式，支持别名，支持忽略字段，最少三行代码即可完成转换。 github地址：FdogSerialize开源库 ​ 代码中有使用到C++11特性，并且使用到了正则表达式，若是linux编译，需保证gcc版本在4.9(4.8不支持正则表达式) 该库
C++对象Json序列化最佳实践（基于Rapidjson库）：C++内存对象和Json字符串互相转换
C++ 爱好者 make_it_simple888
04-17 2万+
介绍：RapidjsonRapidjson库是C++对象序列化到Json字符串的非常好的工具，以效率著称，腾讯的人写的。官方网站：点击打开链接本文全部资源百度云这个库的缺点（个人拙见）：1 暴露的细节相对较多：容器，迭代器，类型，成员函数，序列化，反序列化，都有非常细致的操作。这个给使用者带来记忆负担较重。至少需要同时暴露Value类型和Document类型才能完整的实现Object内部包含Obj...
C语言将字符串转json
weixin_30622107的博客
12-27 1248
示例代码： #include <stdio.h> #include <string.h> #include <stdlib.h> char *strrpc(char *str,char *oldstr,char *newstr){ /* 将一个字符串中的某些字符进行替换 str 需要替换的字符串 o...
数据集标签格式转换（python脚本实现json到txt）
04-23
该py脚本从json文件中提取信息，转为yolov所需要的标签格式: class_id center_x center_y w h 并存入txt文件 转换后可直接用于yolov模型训练 （另有xml转txt和批量修改文件格式的资源见主页） 下载后按脚本中注释改...
Python中json格式数据的编码与解码方法详解
09-21
理解这些方法的工作原理和转换规则对于处理JSON数据至关重要。在实际应用中，可能还需要处理一些特殊场景，例如自定义类型的序列化和反序列化，这可以通过`default`和`object_hook`参数实现。要了解更多关于`json`...
java将XML文档转换成json格式数据的示例
10-18
这个示例展示了如何使用Java和第三方库将XML数据转换为JSON，这在处理Web服务接口或者跨平台数据交换时非常有用。需要注意的是，XML和JSON之间的转换可能无法完全对等，因为它们的数据模型和语义有所不同，例如XML...
谈谈iOS开发之JSON格式数据的生成与解析
08-31
在iOS开发中，JSON（JavaScript Object Notation）已经成为数据交换的主要格式，因为它具有简洁...通过`NSJSONSerialization`，iOS开发者可以方便地在Objective-C对象和JSON数据之间进行转换，实现应用的数据交换功能。
使用VS生成Json或XML的实体类
Enetaunt的博客
05-15 1822
期望达到的效果： 1、先将需要实体类的json数据复制； 2、在VS中新建一个class; 3、选择编辑–&gt;选择性粘贴–&gt;Json 然后检查调整一下就可以了
C++的Json解析库：jsoncpp和boost
热门推荐
hzyong_c的专栏
12-29 10万+
JSON(JavaScript Object Notation)跟xml一样也是一种数据交换格式，了解json请参考其官网http://json.org，本文不再对json做介绍，将重点介绍c++的json解析库的使用方法。json官网上列出了各种语言对应的json解析库，作者仅介绍自己使用过的两种C++的json解析库:jsoncpp(v0.5.0)和Boost(v1.34.0)。  一. 使
vs2003 序列化json
weixin_30439131的博客
05-14 68
/// <summary> /// JSON 的摘要说明。 /// </summary> public class JSON { private static readonly string Json_A = "3A3B1A16-F697-4a32-A0B0-2515BB4692F5"; pri...
VS功能之自动生成json格式类
海内存知己
06-08 1453
当我们拿到一个json格式的对象时，别急着在类中新建model，因为一个一个敲代码很是麻烦，vs提供了一个很方便的功能，如图所示： 这样是不是很方便，更重要的是，减少了失误率，共勉。
vs2013 以上的实用小功能-将xml,json自动转换为class
皮皮虾大侠的博客
07-14 2125
今天同事在处理接口的时候，为了构造出符合对方数据结构的Data，可谓是花费了大堆时间，根据json数据示例手写对应的class，无奈还总解析后数据不对，让我帮瞧瞧，这不，我立马想起了vs2013 及后续vs版本都支持的一个实用小功能-将xml,json 自动转换为class。 并且佩服微软搞的挺好用，只要将原需要反序列化成class的xml或json复制后一键就能自动生成class.      
VS快速生成JSON数据类
weixin_34087503的博客
06-27 350
1、复制Json数据 2、 转载于:https://www.cnblogs.com/ximengchj/p/5620739.html
java中将从接口得到的json格式数据转换为list
最新发布
05-24
在Java中，可以使用Jackson库将JSON格式的数据转换为List。以下是一个示例代码： ```java import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值