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 = 1;

        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 = 1,
                Description = "高级班学员",
                Name = "SoWhat",
                Gender = "男"
            });
            list.Add(new Programmer()
            {
                Id = 1,
                Description = "高级班学员",
                Name = "day",
                Gender = "男"
            });
            list.Add(new Programmer()
            {
                Id = 1,
                Description = "高级班学员",
                Name = "领悟",
                Gender = "男"
            });
            list.Add(new Programmer()
            {
                Id = 1,
                Description = "高级班学员",
                Name = "Sam",
                Gender = "男"
            });
            list.Add(new Programmer()
            {
                Id = 1,
                Description = "高级班学员",
                Name = "AlphaGo",
                Gender = "男"
            });
            list.Add(new Programmer()
            {
                Id = 1,
                Description = "高级班学员",
                Name = "折腾",
                Gender = "男"
            });
            list.Add(new Programmer()
            {
                Id = 1,
                Description = "高级班学员",
                Name = "Me860",
                Gender = "男"
            });
            list.Add(new Programmer()
            {
                Id = 1,
                Description = "高级班学员",
                Name = "打兔子的猎人",
                Gender = "男"
            });
            list.Add(new Programmer()
            {
                Id = 1,
                Description = "高级班学员",
                Name = "Nine",
                Gender = "女"
            });
            list.Add(new Programmer()
            {
                Id = 1,
                Description = "高级班学员",
                Name = "望",
                Gender = "女"
            });
            list.Add(new Programmer()
            {
                Id = 1,
                Description = "高级班学员",
                Name = "微笑刺客",
                Gender = "男"
            });
            list.Add(new Programmer()
            {
                Id = 1,
                Description = "高级班学员",
                Name = "waltz",
                Gender = "男"
            });
            list.Add(new Programmer()
            {
                Id = 1,
                Description = "高级班学员",
                Name = "爱在昨天",
                Gender = "男"
            });
            list.Add(new Programmer()
            {
                Id = 1,
                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 = 10;//指定每次读取长度
                int iResult = 0;
                
                do
                {
                    byte[] bytes = new byte[iLength];
                    iResult = stream.Read(bytes,0,iLength);//返回读取的字节数
                    Console.Write((Encoding.UTF8.GetString(bytes, 0, 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 > 0)//跳出条件--->出口
            {
                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
    }
}

<?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:CodingProjectJungle8884FilesLogs"/>
      <add key="BinarySerializeDataPath" value="D:CodingProjectJungle8884FilesSerialize"/>
      <add key="SoapSerializeDataPath" value="D:CodingProjectJungle8884FilesSoap"/>
      <add key="XmlSerializeDataPath" value="D:CodingProjectJungle8884FilesXml"/>
    </appSettings>
</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 = 0;
                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 = 0;
                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 = 0;
                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

    }
}

测试代码：

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