通过反射将对象转化为文件，同时反向将文件还原为对象（适用配置文件读写）

最新推荐文章于 2024-05-22 12:43:45 发布
最新推荐文章于 2024-05-22 12:43:45 发布
阅读量518 收藏
点赞数
分类专栏： C# 文章标签： 反射 对象转文件 配置文件 读写 C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/koloumi/article/details/72955957
版权

文件和对象的转换

在写程序中经常会使用到配置文件，而且配置文件的内容通常还是要赋值给对象，那么每次如果都给一个特定的类去写一套读写肯定是很不方便，由于工作上的需求所以顺便写了一个通用的只要提供对象即可（ps:要保存的内容只能是基础类型，如果对象中有引用类型的将不会被保存，不过大部分配置文件的内容应该都是基础类型就OK了）

    /// <summary>
    /// 把对象转化为文件的内容
    /// </summary>
    public static class StreamClassToFile
    {
        /// <summary>
        /// 每个对象的分隔
        /// </summary>
        private static string ClassLog = "`------------------------`" + RowEndLog;
        /// <summary>
        /// 单个对象的标志
        /// </summary>
        private static string SingleHandLog = "Single\n";
        /// <summary>
        /// 多个对象的标志
        /// </summary>
        private static string MoreleHandLog = "More\n";
        /// <summary>
        /// 分隔符
        /// </summary>
        private static string CenterLog = "|~|";
        /// <summary>
        /// 行结尾符
        /// </summary>
        private static string RowEndLog = "\n";
        /// <summary>
        /// 字段开始标识
        /// </summary>
        private static string FieldStartLog = "<|Fields>";
        /// <summary>
        /// 字段结束标识
        /// </summary>
        private static string FieldEndLog = "<Fields|>";
        /// <summary>
        /// 开始对象标识
        /// </summary>
        private static string ObjectStartLog = "<|Object>";
        /// <summary>
        /// 结束对象标识
        /// </summary>
        private static string ObjectEndLog = "<Object|>";
        /// <summary>
        /// 将对象保存到文件
        /// </summary>
        /// <param name="obj"></param>
        public static void ObjectToFile(object obj, string fileName)
        {
            string saveString = SingleHandLog;
            saveString += ObjectToString(obj);
            using (Stream stream = new FileStream(fileName, FileMode.Create))
            {
                byte[] data = Encoding.UTF8.GetBytes(saveString);
                stream.Write(data, 0, data.Length);
            }
        }
        /// <summary>
        /// 将对象转换为字符串
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        private static string ObjectToString(object obj)
        {
            StringBuilder saveString = new StringBuilder();
            Type type = obj.GetType();
            saveString.Append(ObjectStartLog);
            saveString.Append(type.Name + RowEndLog);
            FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
            ///存储字段
            saveString.Append(FieldStartLog + RowEndLog);
            foreach (var item in fields)
            {
                if (IsBasisType(item.FieldType))
                    saveString.Append(item.FieldType.Name + CenterLog + item.Name + CenterLog + item.GetValue(obj).ToString() + CenterLog + RowEndLog);
            }
            saveString.Append(FieldEndLog + RowEndLog);
            saveString.Append(ObjectEndLog);
            return saveString.ToString();
        }
        /// <summary>
        /// 将文件中的数据读取并且还原为一个对象(只支持有空构造函数的对象)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public static T FileToObject<T>(string fileName)
        {
            StringBuilder readString = new StringBuilder();
            using (StreamReader stream = new StreamReader(fileName, Encoding.UTF8))
            {
                readString.Append(stream.ReadToEnd());
            }
            int logindex = readString.ToString().IndexOf(SingleHandLog);
            if (logindex == -1 || logindex > SingleHandLog.Length)
            {
                return default(T);
            }
            return GetObjectByString<T>(readString.ToString());
        }
        /// <summary>
        /// 根据类字符串组装类
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="readString"></param>
        /// <returns></returns>
        private static T GetObjectByString<T>(string readString)
        {
            try
            { 
                Type type = typeof(T);
                //type.GetConstructor( BindingFlags.Public, new );
                object readobj = Activator.CreateInstance(type);

                FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
                ListData fieldsData = GetFieldValue(readString);///解析所有字段获取值

                foreach (var item in fields)
                {
                    if (IsBasisType(item.FieldType))
                    {
                        item.SetValue(readobj, GetValue(fieldsData[item.Name], item));
                    }
                }
                return (T)readobj;
            }
            catch (Exception ex)
            {
                return default(T);
            }
        }
        /// <summary>
        /// 检测是否是基础类型，只支持基础类型
        /// </summary>
        /// <param name="typeName">类型名</param>
        /// <returns>true为是，false为否</returns>
        public static bool IsBasisType(Type type)
        {
            if (type.IsPrimitive || type.Name == "string" || type.Name == "String" || type.Name == "Guid")
                return true;
            else
                return false;
        }
        /// <summary>
        /// 获取获取字段的数据
        /// </summary>
        /// <param name="info">字段信息</param>
        /// <param name="file">总文件流</param>
        /// <returns>值</returns>
        private static ListData GetFieldValue(string file)
        {
            ListData data = new ListData();
            string fieldstring = file.ToString();
            int startIndex = fieldstring.IndexOf(FieldStartLog);
            int endIndex = fieldstring.IndexOf(FieldEndLog);
            fieldstring = fieldstring.Substring((startIndex + FieldStartLog.Length), (endIndex - startIndex - FieldStartLog.Length));
            string[] fields = fieldstring.Split(RowEndLog.ToCharArray());
            string[] values;
            foreach (var item in fields)
            {
                values = item.Split(CenterLog.ToCharArray());
                if (values.Length <= 1)
                    continue;
                data.Add(values[CenterLog.Length], values[CenterLog.Length * 2]);
            }
            return data;
        }
        /// <summary>
        /// 根据字段的类型变成对应的字段的值
        /// </summary>
        /// <param name="value">字段的值的字符串</param>
        /// <param name="type">字段的类型</param>
        /// <returns></returns>
        private static object GetValue(string value, FieldInfo type)
        {
            try
            {
                TypeCode code = GetEnumTypeByString<TypeCode>(type.FieldType.Name);
                if (code == TypeCode.Empty && type.FieldType.Name == "Guid")
                    return new Guid(value);
                return Convert.ChangeType(value, code);
            }
            catch(Exception ex)
            {
                if(type.Name == "string")
                {
                    return value;
                }
                else
                {
                    return null;
                }
            }
        }
        /// <summary>
        /// 批量读取
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="objs"></param>
        /// <param name="fileName"></param>
        public static List<T> FileToObjects<T>( string fileName)
        {
            StringBuilder readString = new StringBuilder();
            using (StreamReader stream = new StreamReader(fileName, Encoding.UTF8))
            {
                readString.Append(stream.ReadToEnd());
            }
            int logindex = readString.ToString().IndexOf(MoreleHandLog);
            if (logindex == -1 || logindex > MoreleHandLog.Length)
            {
                return default(List<T>);
            }
            List<T> objs = new List<T>();
            ////string[] classtrings = readString.ToString().Split(ClassLog.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
            string[] classtrings = Regex.Split(readString.ToString(), ClassLog);
            int index = 0;
            foreach (string item in classtrings)
            {
                //if(index ++ % ClassLog.Length ==0 && index != classtrings.Length)
                if(item.Length != 0)
                    objs.Add(GetObjectByString<T>(item));
            }
            return objs;
        }
        /// <summary>
        /// 将多个对象保存到文件
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="objs"></param>
        /// <param name="fileName"></param>
        public static void ObjectsToFile<T>(List<T> objs, string fileName)
        {
            StringBuilder saveStrings = new StringBuilder();
            saveStrings.Append(MoreleHandLog);
            foreach (object item in objs)
            {
                saveStrings.Append(ObjectToString(item));
                saveStrings.Append(ClassLog);
            }
            using (Stream stream = new FileStream(fileName, FileMode.Create))
            {
                byte[] data = Encoding.UTF8.GetBytes(saveStrings.ToString());
                stream.Write(data, 0, data.Length);
            }
        }
        /// <summary>
        /// 根据name检索对应枚举
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="name"></param>
        /// <returns></returns>
        public static T GetEnumTypeByString<T>(string name)
        {
            foreach (T item in Enum.GetValues(typeof(T)))
            {
                if(item.ToString() == name)
                {
                    return item;
                }
            }
            return default(T);
        }
        /// <summary>
        /// 线性插值
        /// </summary>
        /// <param name="start">起始值</param>
        /// <param name="end">终止值</param>
        /// <param name="lerp">插值</param>
        /// <returns></returns>
        public static double Lerp(double start, double end, double lerp)
        {
            lerp = lerp < 0 ? 0 : lerp;
            lerp = lerp > 1 ? 1 : lerp;
            return (end + start) * lerp;
        } 
        /// <summary>
        /// 根据T类型的枚举的具体V类型的值获取对应的枚举值
        /// </summary>
        /// <typeparam name="T">枚举类型</typeparam>
        /// <typeparam name="V">枚举类型继承的类型</typeparam>
        /// <param name="value">对应的值</param>
        /// <returns>对应的枚举值</returns>
        public static T GetEnumTypeByType<T, V>(V value)
        {
            try
            {
                TypeCode code = GetEnumTypeByString<TypeCode>(value.GetType().Name);
                foreach (T item in Enum.GetValues(typeof(T)))
                {
                    if (Convert.ChangeType(value, code).Equals(value))
                    {
                        return item;
                    }
                }
                return default(T);
            }
            catch (Exception)
            {
                return default(T);
            }

        }
    }

    internal class ListData
    {
        /// <summary>
        /// 数据
        /// </summary>
        private Dictionary<string, string> _data = new Dictionary<string, string>();
        /// <summary>
        /// 根据名称获取值
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public string this[string name]
        {
            get
            {
                if(_data.Keys.Contains(name))
                {
                    return _data[name];
                }
                return "";
            }
        }
        /// <summary>
        /// 数据
        /// </summary>
        public Dictionary<string, string> Data
        {
            get
            {
                return _data;
            }
        }
        /// <summary>
        /// 添加一条数据
        /// </summary>
        /// <param name="name">属性名称</param>
        /// <param name="value">属性的值</param>
        public void Add(string name, string value)
        {
            _data.Add(name, value);
        }
    }
使用的时候只要调用StreamClassToFile.ObjectToFile(对象, 文件名称包含路径和名称);
同时还有ObjectsToFile支持List<T>类型的转化。
反向的是public static T FileToObject<T>(string fileName)
同样支持返回List<T>的对象组
koloumi
关注
专栏目录
java对音频文件的频谱分析
liujunvy89的专栏
09-13 6870
MP3音频录音机MP3音频录音机是一款运行于个人计算机上的功能强大的录音、播放软件。使用它，您可将计算机内部或外部声音（如来自麦克风、线路输入、INTERNET的广播或各影音播放软件正在播放的声音）永久保存到硬盘上。 Frobis MP3 Studio 1.6该软件可以将WAV编码为MP3，或反向将MP3解码为 WAV，并可播放这两种文件格式，还可编辑MP3 Tag。 Filthy Fil...
前端面试问题（适用于面试回答思路）
yaminne的博客
03-28 5028
原型和原型链 原型：构造函数的 prototype 属性指向了一个对象，这个对象正是调用该构造函数而创建的实例的原型。也即，每个构造函数的实例都有一个原型，叫原型对象，由实例对象的内置属性_proto_指向。每个原型都有一个 constructor 属性指向关联的构造函数。 原型用法：构造函数创建的实例可以访问实例的属性和方法，也可以访问原型的属性和方法。对于原型只能访问自己的属性和方法。考虑这一特性，如果对象公有的属性和方法，我们可以添加到原型上面，对象需要的时候直接访问原型的属性和方法就可以。 当读取实
Java将对象保存到文件中/从文件中读取对象的方法
09-01
下面小编就为大家带来一篇Java将对象保存到文件中/从文件中读取对象的方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
把对象变为文件&多线程的实现
weixin_48322694的博客
03-29 147
把对象变为文件 & 多线程的实现 定义学生类Student ，属性：姓名，学号，年龄，成绩 提供：无参和全参构造器，生成get和set方法，重写toString ，equals ,hashCode 使用全参构造器创建3个学生对象，放入集合中 使用对象流将这个学生集合写入到本地 使用对象流从本地文件把学生信息读出来，并打印 //Studen类 import java.io.Serializable; import java.util.Objects; public class Student
配置文件+反射 创建对象
哎呦呵-Net的专栏
12-29 440
用户类 public class User { public User() { Console.WriteLine("User被创建"); } } 配置文件 调用 这里需要的是  1、需要添加System.configuration引用 2、需要引用System.C
使用反射机制恢复xml文件表示的对象
WitsMakeMen的专栏
04-17 1604
题目： 完成如下功能： 1)有一个(任意)对象，里面有N个properties以及getter和setter方法 2)有一个properties文件，有N个key,value来描述对象中property的值 3)有一个scheme固定的xml，用来描述这个对象 要求写一个解析器： 1)将xml中的占位符，替换为properties文件中的value 2) 将xml解析成对象，
c# 反射+自定义特性保存数据至本地
chinaherolts2008的博客
04-06 512
最近在项目过程中遇到了保存数据的需求，对实体类的部分数据进行保存，打算采用反射+自定义特性来实现数据保存，利于扩展 采用反射实现能够灵活获取要保存的数据，由于只需要保存实体类（Model）的部分数据，因此采用自定义特性标记需要保存的数据，同时数据要求以.csv格式保存，添加自定义特性有利于对表头进行描述 实现自定义特性 public class ResultAttribute : Attribute { private bool _IsSave; /// <summary>
iOS最新面试题（一）
qq_34500366的博客
11-19 1599
1.聊下HTTP post的body体使用form-urlencoded和multipart/form-data的区别。 1）application/x-www-form-urlencoded： 窗体数据被编码为名称/值对，这是标准且默认的编码格式。当action为get时候，客户端把form数据转换成一个字串append到url后面，用?分割。当action为post时候，浏览器把form数据封装到http body中，然后发送到server。 2）multipart/form-data： multipa
这个疯子整理的十万字Java面试题汇总，终于拿下40W offer！（JDK源码+微服务合集+并发编程+性能优化合集+
m0_67401134的博客
07-23 2476
Spring框架是一个为Java应用程序的开发提供了综合、广泛的基础性支持的Java平台。Spring帮助开发者解决了开发中基础性的问题,使得开发人员可以专注于应用程序的开发。Spring框架本身亦是按照设计模式精心打造,这使得我们可以在开发环境中安心的集成Spring框架,不必担心Spring是如何在后台进行工作的。Spring框架至今已集成了20多个模块。这些模块主要被分如下图所示的核心容器、数据访问/集成,、Web、AOP(面向切面编程)、工具、消息和测试模块。...
Java真实面试题
最新发布
Hardy Army的博客
05-22 1356
蓝绿部署（Blue-Green Deployment）是一种减少系统停机时间和部署风险的策略，它涉及使用两个生产环境，分别称为“蓝色环境”和“绿色环境”。每个环境都拥有自己的硬件或虚拟机资源，包括服务器、数据库、存储等，并且两个环境都是完全配置好的，可以独立运行。蓝绿部署的步骤通常包括准备阶段：开发人员对应用进行修改和测试，准备新版本的应用。与此同时，两个生产环境（蓝色和绿色）都处于活跃状态，其中之一处理所有生产流量。部署新版本。
利用流的机制，Java对象与文件的相互转换
IT技术专家-朱志广
12-07 1360
/** * 编写一个工具类 将对象转储为文件 * 以及从文件读取一个文件到对象当中 * 注意在使用本工具类的时候需要将相应的obj 进行序列化 * */ public class FileObj { /** * * @param obj 将要保存的对象 * @param filePath 对象转储文件的位置 */ ...
java通过反射给对象设置属性【工具包系列】
一不小心的程序员
05-27 2889
先上代码 public class ReflectUtil { @SuppressWarnings("rawtypes") public static Object setValue(Class classType,String[] fields,String[] values,String formart){ Map fieldsMap = new HashMap(); fo
Java反射获取对象属性并设值
小白一个
06-14 3704
Java对象： package com.sjdf.erp.common.utils; import java.math.BigDecimal; public class TypeTest { private Boolean bigBoolean; private Long bigLong; private Double bigDouble; private...
Java - 反射（读取文件，获取对象，写入文件）
qq_42999356的博客
07-22 1442
新建文件，信息内如如下； ---------------------------------直接贴代码-------------------------------------- import java.beans.PropertyDescriptor; import java.io.*; import java.lang.reflect.Field; import java.lang.reflect.Method; /** * 反射 **/ public class BeanInfoUtil {
关于怎么把文件对象转化为字节流
那缕阳光初照时的博客
03-29 1万+
//创建字节对象 byte[] buffer; File file = new File("d://文件转字节测试文档.txt"); FileInputStream fis = new FileInputStream(file); ByteArrayOutputStream baos = new ByteArrayOutputStream(fis.available()); byte[] ...
Java 反射机制（反射实例化对象）
Java软贱攻城狮
05-08 3390
范例1：利用反射实例化对象class Book { public Book() { System.out.println("*********Book类无参构造方法***********"); } @Override public String toString() { return "这是一本书"; } } public class Demo { public stati...
C#实现的CRC16位校验
热门推荐
koloumi的博客
04-09 2万+
CRC校验因工作需要所以用#写了一个CRC的16位校验，代码是参照标准的modbus协议里面的定义写的亲测都是可以正常校验的所以放心使用吧。 下面废话不说了直接上代码，代码也不多直接看就行 /// <summary> /// CRC校验 /// </summary> /// <param name="data">校验数据</param>
简单的C#串口通讯例子（附源文件）
koloumi的博客
03-07 2万+
由于公司需求所以就查了一些资料写了个串口和设备通讯的 话说现在用串口的应该比较少了吧。 先上一张程序UI图 简单串口通讯必备的东西都在这里了。个人建议使用的时候先短接2-3口进行测试以免线都不通。 下面直接上源码，注释写的还是比较详细的相信还是很容易懂的。 （PS：我这里数据接收的结束符为16）/// <summary> /// 创建串口对象
C# 调用C++ dll传入 char*参数时候的注意点
koloumi的博客
01-11 6152
C# 调用C++ dll传入 char*参数时候的注意点 在搞adb的源码的时候希望能修改一下adb.exe的源码给编译成dll给自己使用， 先说下adb的一些基本的运行原理吧。当使用adb去连接模拟器或者手机端的时候adb会先去检测自己的服务有没有开启，如果没有开启就重新启动一个adb.exe然后传入参数fork-server server来启动socket服务来和其他端通讯，也就是说你发命令的...
详解Nginx配置文件nginx.conf关键知识点
本文将深入解析 Nginx 的核心配置文件 `nginx.conf`，带你全面了解这个关键文件在 Nginx 服务器中的作用和配置细节。Nginx 是一个功能强大的 Web 服务器和反向代理服务器，它的配置文件 `nginx.conf` 对于实现高效、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值