【C#】C#处理文本文件(转)

 class FileAndFileInfo
    {

        private string path = "c:/test.txt";

        //C#创建目录
        //// 创建目录c:\sixAge
        //DirectoryInfo d=Directory.CreateDirectory("c:\\sixAge");
        //// d1指向c:\sixAge\sixAge1
        //DirectoryInfo d1=d.CreateSubdirectory("sixAge1");
        //// d2指向c:\sixAge\sixAge1\sixAge1_1
        //DirectoryInfo d2=d1.CreateSubdirectory("sixAge1_1");
        //// 将当前目录设为c:\sixAge
        //Directory.SetCurrentDirectory("c:\\sixAge");
        //// 创建目录c:\sixAge\sixAge2
        //Directory.CreateDirectory("sixAge2");
        //// 创建目录c:\sixAge\sixAge2\sixAge2_1
        //Directory.CreateDirectory("sixAge2\\sixAge2_1");

        public static void ListFile(string sDir)
        {
            if (Directory.Exists(sDir))
            {
                DirectoryInfo di = new DirectoryInfo(sDir);
                Console.WriteLine("文件创建时间\t\t文件名\t\t\t文件大小");
                foreach (FileInfo file in di.GetFiles())
                {
                    Console.WriteLine(string.Format("{0}\t{1}\t{2}", file.CreationTime, file.Name, file.Length));
                }
            }
            else
            {
                Console.WriteLine("文件{0}不存在", sDir);
            }

        }

        public static void CreateFile(string sFile)
        {
            FileStream fs = File.Create(sFile);
            StreamWriter sw = new StreamWriter(fs);
            Console.WriteLine("输入文本内容:");
            string str = Console.ReadLine();
            sw.WriteLine(str);
            sw.Close();
            fs.Close();
            Console.WriteLine(string.Format("创建文本文件{0}", sFile));
        }

        protected void WriteFile()
        {
            StreamWriter sw = new StreamWriter(path);
            sw.WriteLine("TextBox1.Text");
            sw.Close();
            sw.Dispose();
        }

        protected void ReadFile()
        {
            StreamReader sr = File.OpenText(path);
            string txt = "";
            while ((txt = sr.ReadLine()) != null)
            {
                Console.Write(txt);
            }
            sr.Close();
            sr.Dispose();

        }   

        public static void ReadFile(string sFile)
        {
            string str = "";
            StreamReader sr = new StreamReader(sFile);
            str = sr.ReadToEnd();
            sr.Close();
            Console.WriteLine(string.Format("读取文本文件{0}", str));
        }

        //C#追加文件
        public void AppendText()
        {
            StreamWriter sw = File.AppendText(path);
            sw.WriteLine("追逐理想");
            sw.WriteLine("kzlll");
            sw.WriteLine(".NET笔记");
            sw.Flush();
            sw.Close();
        } 

        // ======================================================
        // 实现一个静态方法将指定文件夹下面的所有内容copy到目标文件夹下面
        // 如果目标文件夹为只读属性就会报错.   
        // ======================================================
        public static void CopyDir(string srcPath, string aimPath)
        {
            try
            {
                // 检查目标目录是否以目录分割字符结束如果不是则添加之
                if (aimPath[aimPath.Length - 1] != Path.DirectorySeparatorChar)
                    aimPath += Path.DirectorySeparatorChar;
                // 判断目标目录是否存在如果不存在则新建之
                if (!Directory.Exists(aimPath)) Directory.CreateDirectory(aimPath);
                // 得到源目录的文件列表，该里面是包含文件以及目录路径的一个数组
                // 如果你指向copy目标文件下面的文件而不包含目录请使用下面的方法
                // string[] fileList = Directory.GetFiles(srcPath);
                string[] fileList = Directory.GetFileSystemEntries(srcPath);
                // 遍历所有的文件和目录
                foreach (string file in fileList)
                {
                    // 先当作目录处理如果存在这个目录就递归Copy该目录下面的文件
                    if (Directory.Exists(file))
                        CopyDir(file, aimPath + Path.GetFileName(file));
                    // 否则直接Copy文件
                    else
                        File.Copy(file, aimPath + Path.GetFileName(file), true);
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString());
            }
        }

        /**/
        /// <summary>
        /// 拷贝文件夹(包括子文件夹)到指定文件夹下,源文件夹和目标文件夹均需绝对路径. 格式: CopyFolder(源文件夹,目标文件夹);
        /// </summary>
        /// <param name="strFromPath"></param>
        /// <param name="strToPath"></param>  

        public static void CopyFolder(string strFromPath, string strToPath)
        {
            //如果源文件夹不存在，则创建
            if (!Directory.Exists(strFromPath))
            {
                Directory.CreateDirectory(strFromPath);
            }

            //取得要拷贝的文件夹名
            string strFolderName = strFromPath.Substring(strFromPath.LastIndexOf("\\") + 1, strFromPath.Length - strFromPath.LastIndexOf("\\") - 1);

            //如果目标文件夹中没有源文件夹则在目标文件夹中创建源文件夹
            if (!Directory.Exists(strToPath + "\\" + strFolderName))
            {
                Directory.CreateDirectory(strToPath + "\\" + strFolderName);
            }
            //创建数组保存源文件夹下的文件名
            string[] strFiles = Directory.GetFiles(strFromPath);

            //循环拷贝文件
            for (int i = 0; i < strFiles.Length; i++)
            {
                //取得拷贝的文件名，只取文件名，地址截掉。
                string strFileName = strFiles[i].Substring(strFiles[i].LastIndexOf("\\") + 1, strFiles[i].Length - strFiles[i].LastIndexOf("\\") - 1);
                //开始拷贝文件,true表示覆盖同名文件
                File.Copy(strFiles[i], strToPath + "\\" + strFolderName + "\\" + strFileName, true);
            }

            //创建DirectoryInfo实例
            DirectoryInfo dirInfo = new DirectoryInfo(strFromPath);
            //取得源文件夹下的所有子文件夹名称
            DirectoryInfo[] ZiPath = dirInfo.GetDirectories();
            for (int j = 0; j < ZiPath.Length; j++)
            {
                //获取所有子文件夹名
                string strZiPath = strFromPath + "\\" + ZiPath[j].ToString();
                //把得到的子文件夹当成新的源文件夹，从头开始新一轮的拷贝
                CopyFolder(strZiPath, strToPath + "\\" + strFolderName);
            }
        }

        /**/
        /// <summary>
        /// 读取日志文件
        /// </summary>
        private string ReadLogFile()
        {
            /**/
            ///从指定的目录以打开或者创建的形式读取日志文件
            FileStream fs = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Read);

            /**/
            ///定义输出字符串
            StringBuilder output = new StringBuilder();

            /**/
            ///初始化该字符串的长度为0
            output.Length = 0;

            /**/
            ///为上面创建的文件流创建读取数据流
            StreamReader read = new StreamReader(fs);

            /**/
            ///设置当前流的起始位置为文件流的起始点
            read.BaseStream.Seek(0, SeekOrigin.Begin);

            /**/
            ///读取文件
            while (read.Peek() > -1)
            {
                /**/
                ///取文件的一行内容并换行
                output.Append(read.ReadLine() + "\n");
            }

            /**/
            ///关闭释放读数据流
            read.Close();

            /**/
            ///返回读到的日志文件内容
            return output.ToString();
        }

        //四．写入日志文件

        /**/
        /// <summary>
        /// 写入日志文件
        /// </summary>
        /// <param name="input"></param>
        private void WriteLogFile(string input)
        {
            /**/
            ///指定日志文件的目录
            string fname = path;
            /**/
            ///定义文件信息对象
            FileInfo finfo = new FileInfo(fname);

            /**/
            ///判断文件是否存在以及是否大于2K
            if (finfo.Exists && finfo.Length > 2048)
            {
                /**/
                ///删除该文件
                finfo.Delete();
            }
            /**/
            ///创建只写文件流
            using (FileStream fs = finfo.OpenWrite())
            {
                /**/
                ///根据上面创建的文件流创建写数据流
                StreamWriter w = new StreamWriter(fs);

                /**/
                ///设置写数据流的起始位置为文件流的末尾
                w.BaseStream.Seek(0, SeekOrigin.End);

                /**/
                ///写入“Log Entry : ”
                w.Write("\nLog Entry : ");
                /**/
                ///写入当前系统时间并换行
                w.Write("{0} {1} \r\n", DateTime.Now.ToLongTimeString(),
                    DateTime.Now.ToLongDateString());

                /**/
                ///写入日志内容并换行
                w.Write(input + "\n");

                /**/
                ///写入------------------------------------“并换行
                w.Write("------------------------------------\n");

                /**/
                ///清空缓冲区内容，并把缓冲区内容写入基础流
                w.Flush();

                /**/
                ///关闭写数据流
                w.Close();
            }
        }

        // ======================================================
        // 实现一个静态方法将指定文件夹下面的所有内容Detele
        // 测试的时候要小心操作，删除之后无法恢复.      
        // ======================================================
        public static void DeleteDir(string aimPath)
        {
            try
            {
                // 检查目标目录是否以目录分割字符结束如果不是则添加之
                if (aimPath[aimPath.Length - 1] != Path.DirectorySeparatorChar)
                    aimPath += Path.DirectorySeparatorChar;
                // 得到源目录的文件列表，该里面是包含文件以及目录路径的一个数组
                // 如果你指向Delete目标文件下面的文件而不包含目录请使用下面的方法
                // string[] fileList = Directory.GetFiles(aimPath);
                string[] fileList = Directory.GetFileSystemEntries(aimPath);
                // 遍历所有的文件和目录
                foreach (string file in fileList)
                {
                    // 先当作目录处理如果存在这个目录就递归Delete该目录下面的文件
                    if (Directory.Exists(file))
                    {
                        DeleteDir(aimPath + Path.GetFileName(file));
                    }
                    // 否则直接Delete文件
                    else
                    {
                        File.Delete(aimPath + Path.GetFileName(file));
                    }
                }
                //删除文件夹
                System.IO.Directory.Delete(aimPath, true);
            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString());
            }
        }

        public static void DeleteFile(string sFile)
        {
            File.Delete(sFile);
            Console.WriteLine(string.Format("删除文件{0}", sFile));
        }

        //递归删除文件夹及文件  
        protected void Page_Load(Object sender, EventArgs e)
        {
            string Dir = "D:\\gbook\\11";
            DeleteFolder(Dir); //调用函数删除文件夹
        }

        public void DeleteFolder(string dir)
        {
            if (Directory.Exists(dir)) //如果存在这个文件夹删除之
            {
                foreach (string d in Directory.GetFileSystemEntries(dir))
                {
                    if (File.Exists(d))
                        File.Delete(d); //直接删除其中的文件
                    else
                        DeleteFolder(d); //递归删除子文件夹
                }
                Directory.Delete(dir); //删除已空文件夹
                Console.Write(dir + " 文件夹删除成功");
            }
            else
                Console.Write(dir + " 该文件夹不存在"); //如果文件夹不存在则提示
        }

    }

***************************************************

    public void MemoryStreamInstance()
        {
            int count;
            byte[] byteArray;
            char[] charArray;
            UnicodeEncoding uniEncoding = new UnicodeEncoding();
            byte[] firstString = uniEncoding.GetBytes("努力学习");
            byte[] secondString = uniEncoding.GetBytes("不做C#中的菜鸟");

            using (MemoryStream memStream = new MemoryStream(100))
            {

                memStream.Write(firstString, 0, firstString.Length);
                count = 0;
                while (count < secondString.Length)
                {
                    memStream.WriteByte(secondString[count++]);
                }

                Console.WriteLine("Capacity={0},Length={1},Position={2}\n",
                   memStream.Capacity.ToString(), memStream.Length.ToString(), memStream.Position.ToString());
                memStream.Seek(0, SeekOrigin.Begin);

                byteArray = new byte[memStream.Length];
                count = memStream.Read(byteArray, 0, 20);
                while (count < memStream.Length)
                {
                    byteArray[count++] = Convert.ToByte(memStream.ReadByte());
                }
                charArray = new char[uniEncoding.GetCharCount(byteArray, 0, count)];
                uniEncoding.GetDecoder().GetChars(byteArray, 0, count, charArray, 0);
                Console.WriteLine(charArray); Console.ReadKey();
            }
        }