IO&&Serize 利用线程Thread.Sleep实现"自动输出"

查看链接 https://github.com/jungle8884/C-.Net/tree/MyClassLibrary

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;

 namespace Jungle8884
 {
     /// <summary>
     /// 对应于SerializeHelper,必须添加可序列化特性
     /// </summary>
     [Serializable]
     public class Person
     {
         [NonSerialized]
         public int Id = ;

         public string Name { get; set; }

         public string Gender { get; set; }

     }

     [Serializable]
     public class Programmer : Person
     {
         private string Language { get; set; }

         public string Description { get; set; }

     }

     /// <summary>
     /// 数据工厂
     /// </summary>
     public class DataFactory
     {
         /// <summary>
         /// 初始化数据---用于测试
         /// </summary>
         /// <returns></returns>
         public static List<Programmer> BuildProgrammerList()
         {
             #region data-prepare
             List<Programmer> list = new List<Programmer>();
             list.Add(new Programmer()
             {
                 Id = ,
                 Description = "高级班学员",
                 Name = "SoWhat",
                 Gender = "男"
             });
             list.Add(new Programmer()
             {
                 Id = ,
                 Description = "高级班学员",
                 Name = "day",
                 Gender = "男"
             });
             list.Add(new Programmer()
             {
                 Id = ,
                 Description = "高级班学员",
                 Name = "领悟",
                 Gender = "男"
             });
             list.Add(new Programmer()
             {
                 Id = ,
                 Description = "高级班学员",
                 Name = "Sam",
                 Gender = "男"
             });
             list.Add(new Programmer()
             {
                 Id = ,
                 Description = "高级班学员",
                 Name = "AlphaGo",
                 Gender = "男"
             });
             list.Add(new Programmer()
             {
                 Id = ,
                 Description = "高级班学员",
                 Name = "折腾",
                 Gender = "男"
             });
             list.Add(new Programmer()
             {
                 Id = ,
                 Description = "高级班学员",
                 Name = "Me860",
                 Gender = "男"
             });
             list.Add(new Programmer()
             {
                 Id = ,
                 Description = "高级班学员",
                 Name = "打兔子的猎人",
                 Gender = "男"
             });
             list.Add(new Programmer()
             {
                 Id = ,
                 Description = "高级班学员",
                 Name = "Nine",
                 Gender = "女"
             });
             list.Add(new Programmer()
             {
                 Id = ,
                 Description = "高级班学员",
                 Name = "望",
                 Gender = "女"
             });
             list.Add(new Programmer()
             {
                 Id = ,
                 Description = "高级班学员",
                 Name = "微笑刺客",
                 Gender = "男"
             });
             list.Add(new Programmer()
             {
                 Id = ,
                 Description = "高级班学员",
                 Name = "waltz",
                 Gender = "男"
             });
             list.Add(new Programmer()
             {
                 Id = ,
                 Description = "高级班学员",
                 Name = "爱在昨天",
                 Gender = "男"
             });
             list.Add(new Programmer()
             {
                 Id = ,
                 Description = "高级班学员",
                 Name = "waltz",
                 Gender = "男"
             });
             #endregion

             return list;
         }
     }
 }

数据准备

IO: 97和69两行可以模拟控制台自动输出---模拟黑客。。。

 using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Configuration;
 using System.IO;
 using System.Threading;

 namespace Jungle
 {
     public class MyIO
     {
         //日志文件名
         private static string sLogFileName = Path.Combine(MyConstants.LogPathAbsolute, "Log.txt");
         /// <summary>
         /// 写日志
         /// </summary>
         /// <param name="sWriteIn"></param>
         public static void WriteLogsWriteLine(string sWriteIn)
         {
             if (!File.Exists(sLogFileName))
             {
                 //1 先创建文件夹
                 Directory.CreateDirectory(MyConstants.LogPathAbsolute);
                 //2 再创建文件
                 using (FileStream fileStream = File.Create(sLogFileName))//打开文件流 （创建文件并写入）
                 {
                     StreamWriter sw = new StreamWriter(fileStream);
                     sw.WriteLine(sWriteIn);
                     sw.Flush();
                     #region 其他方法---字节流
                     //byte[] bytes = Encoding.Default.GetBytes(sWriteIn);
                     //fileStream.Write(bytes, 0, bytes.Length);
                     //fileStream.Flush();
                     #endregion
                 }
             }
         }
         /// <summary>
         /// 写日志---追加
         /// </summary>
         public static void WriteLogsAppendText(string sWriteIn)
         {
             using (StreamWriter sw = File.AppendText(sLogFileName))
             {
                 sw.WriteLine(sWriteIn);
                 sw.Flush();
             }

         }

         /// <summary>
         /// 读取日志输出到控制台
         /// 适合小数据文件
         /// </summary>
         public static void ReadLogsToConsole()
         {
             foreach (string sResult in File.ReadAllLines(sLogFileName))
             {
                 #region 其他方法---仅供参考
                 //string sResult = File.ReadAllText(sLogFileName);//一次性读取所有的文本

                 //Byte[] byteContent = File.ReadAllBytes(sLogFileName);//字节流的方式读取
                 //string sResultByte = Encoding.UTF8.GetString(byteContent);//字节流解码为字符串
                 #endregion
                 char[] cResult = sResult.ToCharArray();
                 foreach (char c in cResult)
                 {
                     Console.Write(c);
                     Thread.Sleep(200);
                 }
                 Console.WriteLine();
             }
         }

         /// <summary>
         /// 读取大文件使用（当然小文件一样适用）
         /// 采用策略：分批读取
         /// </summary>
         public static void ReadLargeFileToConsole()
         {
             using (FileStream stream = File.OpenRead(sLogFileName))
             {
                 int iLength = ;//指定每次读取长度
                 int iResult = ;

                 do
                 {
                     byte[] bytes = new byte[iLength];
                     iResult = stream.Read(bytes,,iLength);//返回读取的字节数
                     Console.Write((Encoding.UTF8.GetString(bytes, , iResult)));//直接输出一句
                     #region 按字节输出
                     //for (int i = 0; i < iResult; i++)
                     //{
                     //    Console.Write((bytes[i].ToString()));
                     //}
                     #endregion
                     Thread.Sleep(300);
                 }
                 while (iLength == iResult);
             }
         }

         /// <summary>
         /// 通过递归获取根目录下的所有子文件夹
         /// 适用于无限集
         /// 缺点：耗内存
         /// </summary>
         /// <param name="directoryList">存放所有文件夹的集合</param>
         /// <param name="directoryParent">根目录文件夹</param>
         public static void GetChildDirectoryByRecursion(List<DirectoryInfo> directoryList, DirectoryInfo directoryParent)
         {
             DirectoryInfo[] directoryListChild = directoryParent.GetDirectories();
             directoryList.AddRange(directoryListChild);
             if (directoryListChild.Length > )//跳出条件--->出口
             {
                 foreach (var directoryChild in directoryListChild)
                 {
                     GetChildDirectoryByRecursion(directoryList, directoryChild);//相同的代码抽取出来--->递归
                 }
             }
         }
     }
 }

配置路径的新思想：

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using System.Configuration;

 namespace Jungle
 {
     public class MyConstants
     {
         /// <summary>
         /// 配置绝对路径---模板
         /// </summary>
         public static string LogPathAbsolute = ConfigurationManager.AppSettings["LogPath"];

         /// <summary>
         /// 配置相对路径---获取当前程序路径
         /// </summary>
         public static string LogPathRelative = AppDomain.CurrentDomain.BaseDirectory;

         /// <summary>
         /// 序列化数据地址
         /// </summary>
         public static string BinarySerializeDataPath = ConfigurationManager.AppSettings["BinarySerializeDataPath"]; //二进制
         public static string SoapSerializeDataPath = ConfigurationManager.AppSettings["SoapSerializeDataPath"]; //Soap
         public static string XmlSerializeDataPath = ConfigurationManager.AppSettings["XmlSerializeDataPath"]; //Soap
     }
 }

MyConstants

 <?xml version="1.0" encoding="utf-8" ?>
 <configuration>
     <startup>
         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1" />
     </startup>
     <appSettings><!-- 每台电脑的路径不一样，可自己更改 -->
       <add key="LogPath" value="D:\Coding\Project\Jungle8884\Files\Logs\"/>
       <add key="BinarySerializeDataPath" value="D:\Coding\Project\Jungle8884\Files\Serialize\"/>
       <add key="SoapSerializeDataPath" value="D:\Coding\Project\Jungle8884\Files\Soap\"/>
       <add key="XmlSerializeDataPath" value="D:\Coding\Project\Jungle8884\Files\Xml\"/>
     </appSettings>
 </configuration>

configuration

Serialize:

 using Jungle8884;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Runtime.Serialization.Formatters.Binary;
 using System.Runtime.Serialization.Formatters.Soap;
 using System.Text;
 using System.Threading.Tasks;
 using System.Xml.Serialization;

 namespace Jungle
 {
     /// <summary>
     /// 本序列化只作为一个例子
     /// 对应于Programmer类
     /// 具体情况可以更改为泛型或具体类型
     /// </summary>
     public class MySerializableHelper
     {
         /// <summary>
         /// 存放文件名称与路径
         /// </summary>
         private static string sFileNameBinary = Path.Combine(MyConstants.BinarySerializeDataPath, "BinarySerialize.txt");
         private static string sFileNameSoap = Path.Combine(MyConstants.SoapSerializeDataPath, "SoapSerialize.txt");
         private static string sFileNameXml = Path.Combine(MyConstants.XmlSerializeDataPath, "Programmer.xml");

         #region 二进制序列化

         public static void BinarySerialize(List<Programmer> pList)
         {
             using (Stream fStream = new FileStream(sFileNameBinary, FileMode.Create, FileAccess.ReadWrite))
             {
                 pList = DataFactory.BuildProgrammerList();
                 BinaryFormatter binFormat = new BinaryFormatter();//创建二进制序列化器
                 binFormat.Serialize(fStream, pList);
             }
         }

         public static List<Programmer> BinaryDeserialize()
         {
             List<Programmer> pList = null;
             using (Stream fStream = new FileStream(sFileNameBinary, FileMode.Open, FileAccess.ReadWrite))
             {
                 BinaryFormatter binFormat = new BinaryFormatter();//创建二进制序列化器
                 fStream.Position = ;
                 pList = (List<Programmer>)binFormat.Deserialize(fStream);//反序列化
             }
             return pList;
         }

         #endregion

         #region Soap序列化

         public static void SoapSerialize(List<Programmer> pList)
         {
             using (Stream fStream = new FileStream(sFileNameSoap, FileMode.Create, FileAccess.ReadWrite))
             {
                 pList = DataFactory.BuildProgrammerList();
                 SoapFormatter soapFormat = new SoapFormatter();//创建二进制序列化器
                 //soapFormat.Serialize(fStream, pList);//SOAP不能序列化泛型对象
                 soapFormat.Serialize(fStream, pList.ToArray());
             }
         }

         public static List<Programmer> SoapDeserialize()
         {
             List<Programmer> pList = null;
             using (Stream fStream = new FileStream(sFileNameSoap, FileMode.Open, FileAccess.ReadWrite))
             {
                 SoapFormatter soapFormat = new SoapFormatter();
                 fStream.Position = ;
                 pList = ((Programmer[])soapFormat.Deserialize(fStream)).ToList();
             }
             return pList;
         }

         #endregion

         //BinaryFormatter序列化自定义类的对象时，序列化之后的流中带有空字符，以致于无法反序列化，
         //反序列化时总是报错“在分析完成之前就遇到流结尾”（已经调用了stream.Seek(0, SeekOrigin.Begin);）。
         //改用XmlFormatter序列化之后，可见流中没有空字符，从而解决上述问题，但是要求类必须有无参数构造函数，
         //而且各属性必须既能读又能写，即必须同时定义getter和setter，若只定义getter，则反序列化后的得到的各个属性的值都为null。

         #region Xml序列化

         public static void XmlSerialize(List<Programmer> pList)
         {
             using (Stream fStream = new FileStream(sFileNameXml, FileMode.Create, FileAccess.ReadWrite))
             {
                 pList = DataFactory.BuildProgrammerList();
                 XmlSerializer xmlFormat = new XmlSerializer(typeof(List<Programmer>));
                 xmlFormat.Serialize(fStream, pList);
             }
         }

         public static List<Programmer> XmlDeserialize()
         {
             List<Programmer> pList = null;
             using (Stream fStream = new FileStream(sFileNameXml, FileMode.Open, FileAccess.ReadWrite))
             {
                 XmlSerializer xmlFormat = new XmlSerializer(typeof(List<Programmer>));
                 fStream.Position = ;
                 pList = (List<Programmer>)xmlFormat.Deserialize(fStream);
             }
             return pList;
         }

         #endregion

         #region Json序列化分为两种：微软的和Newtonsoft的

         //对象到Json字符串叫序列化
         public static string JsonSerialize(List<Programmer> pList)
         {
             pList = DataFactory.BuildProgrammerList();
             string sResultJson = MyJsonHelper.ObjectToString<List<Programmer>>(pList);
             return sResultJson;
         }
         public static string JsonSerializeNewtonsoft(List<Programmer> pList)
         {
             pList = DataFactory.BuildProgrammerList();
             string sResultJson = MyJsonHelper.ToJson<List<Programmer>>(pList);
             return sResultJson;
         }

         //Json字符串到对象叫反序列化
         public static List<Programmer> JsonDeserialize(string sJson)
         {
             List<Programmer> pList = MyJsonHelper.StringToObject<List<Programmer>>(sJson);
             return pList;
         }
         public static List<Programmer> JsonDeserializeNewtonsoft(string sJson)
         {
             List<Programmer> pList = MyJsonHelper.ToObject<List<Programmer>>(sJson);
             return pList;
         }
         #endregion

     }
 }

 using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using System.Web.Script.Serialization;//System.Web.Extensions

 namespace Jungle
 {
     public class MyJsonHelper
     {

         #region 微软自带Json序列化
         /// <summary>
         /// （Object到）Json的序列化
         /// </summary>
         /// <typeparam name="T">对象类型</typeparam>
         /// <param name="obj">对象实例</param>
         /// <returns>返回字符串</returns>
         public static string ObjectToString<T>(T obj)
         {
             JavaScriptSerializer jss = new JavaScriptSerializer();
             return jss.Serialize(obj);
         }
         /// <summary>
         /// Json（到Object）的反序列化
         /// </summary>
         /// <typeparam name="T">反序列化到对象类型</typeparam>
         /// <param name="sContent">待反序列化的字符串</param>
         /// <returns></returns>
         public static T StringToObject<T>(string sContent)
         {
             JavaScriptSerializer jss = new JavaScriptSerializer();
             return jss.Deserialize<T>(sContent);
         }
         #endregion

         #region Newtonsoft.Json
         /// <summary>
         /// （Object到）Json
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="obj"></param>
         /// <returns></returns>
         public static string ToJson<T>(T obj)
         {
             return JsonConvert.SerializeObject(obj);
         }

         /// <summary>
         /// （Json到）Object
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="sContent"></param>
         /// <returns></returns>
         public static T ToObject<T>(string sContent)
         {
             return JsonConvert.DeserializeObject<T>(sContent);
         }
         #endregion

     }
 }

MyJsonHelper

测试代码：

 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using Jungle;

 namespace Jungle8884
 {
     class Program
     {
         static void Main(string[] args)
         {
             MySafeInvoke.InvokeMethod(() => {
                 //MyIO.WriteLogsWriteLine("Get up to cheer up!");
                 //MyIO.WriteLogsAppendText("睡你麻痹，起来嗨!");
                 //MyIO.WriteLogsAppendText("为什么?");
                 //MyIO.WriteLogsAppendText("你很帅啊！");
                 //MyIO.WriteLogsAppendText("真的!");
                 //MyIO.WriteLogsAppendText("我不信...");
                 //MyIO.WriteLogsAppendText("这是真的!");
                 //MyIO.WriteLogsAppendText("这不是梦!");
                 //MyIO.ReadLogsToConsole();
                 //MyIO.ReadLargeFileToConsole();
                 //Process.Start(Path.Combine(MyConstants.LogPathAbsolute, "Log.txt"));//打开文本文件
                 List<Programmer> pList = null;
                 MySerializableHelper.BinarySerialize(pList);
                 MySerializableHelper.SoapSerialize(pList);
                 MySerializableHelper.XmlSerialize(pList);
             });
         }
     }
 }

下载链接：

链接：https://pan.baidu.com/s/1mjNnqQ0 密码：pco3