C#记事本自定义类(保存,统计汉字,查找,TreeView调用)

自己写的一个记事本类,都是静态方法,感觉静态方法好用

至于诸君是否看得头晕目眩,小弟就无能为力了.这只是为以后方便自己找到这个类罢了.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.IO;

namespace Mxdr_NotBook
{
    ///  〖新建-打开-保存〗〖统计字数〗〖~隐藏-只读〗文档 Class 
    /// TreeView 加载、添加、删除--节点文档
    public static class MxdrSave
    {
        #region =★=*=★=*=★= 自定义全局变量 =★=*=★=*=★=
        ///  -- txtName 用于储存文件名 -- 
        private static string txtName = "";
        ///  -- txtName 用于储存文件路径 -- 
        public static string filePath = "";
        ///  -- 判断是否为打开的文件,true为真 -- 
        public static bool FbOpen = false;
        ///  -- 判断是否为第一次打开的文件,true为真 -- 
        public static bool FbOpens = false;
        ///  -- 判断文本是否未保存,true为保存 -- 
        public static bool FbSave = true;
        ///  -- 判断文本内容是否改变,true为改变 -- 
        public static bool FbRiSave = false;
        ///  设置文件或文件夹的(隐藏与只读)属性 
        //roHidDirFile roHidDirfile = new roHidDirFile();

        #endregion

        #region =★=*=★=*=★= 自定义委托事件 =★=*=★=*=★=
        /* 在主窗体中实现委托 */
        ///  清空RichTextBox内容委托事件 
        public static event NullRitxtbox Nulltxt;
        ///  加载文本内容委托事件 
        public static event Ritxtbox readFile;
        ///  保存文本文档委托事件 
        public static event SaveFileHandler FileSaves;
        /////  另存为文本文档委托事件 
        //public event SaveFileHandler FilesSaveAs;
        //public event SaveFileHandler SaveAseFile;
        #endregion

        /**=**=**=**=**=**=**=**=**=***=**=**=**=**=**/

        #region =★=*=★=*=★= 获取光标行列 =★=*=★=*=★=
        ///  获取光标行列 通过移动鼠标和
        /// 方向键获取坐标位置 注:建议用文本的 KeyUp 和
        /// MouseUp 事件调用方法 
        /// 获取坐标的 RichTextBox 文本
        /// 用于向用户显示行列
        public static void Ranks(RichTextBox rbox, ToolStripStatusLabel toolStripStatusLabel)
        {
            /* 光标行第一个字符索引 */
            int index = rbox.GetFirstCharIndexOfCurrentLine();
            /* 获取光标行的行号 (+1)索引是从0开始的 */
            int line = rbox.GetLineFromCharIndex(index) + 1;
            /* 光标位置索引 - 当前行第一个索引 = 光标所在列(+1) */
            int cols = rbox.SelectionStart - index + 1;
            toolStripStatusLabel.Text = string.Format("行 {0} 列 {1}", line, cols);
        }
        #endregion

        #region =★=*=★=*=★= 统计文本字数数量 =★=*=★=*=★=
        ///  去除空格\n\r\t等符号,统计文本字数数量 
        /// 参数1(tbox);RichTextBox 类型参数2~4 参数类型ToolStripStatusLabel
        /// 参数2(toLabel0);用于显示内容字节大小(KB/MB/GB)
        /// 参数3(toLabel1);显示内容中符号,数字,字母,汉字数量
        /// 参数4(toLabel2);内容字符数量统计(不含空格,\n\r\t等符号)
        /// 
        /// RichTextBox 类型
        /// 用于显示内容字节大小(KB/MB/GB)
        /// 显示内容中符号,数字,字母,汉字数量
        /// 内容字符数量统计(不含空格,\n\r\t等符号)
        public static void calculates(RichTextBox tbox, ToolStripStatusLabel toLabel0,
            ToolStripStatusLabel toLabel1, ToolStripStatusLabel toLabel2)
        {
            try
            {
                //RichTextBox tbox = form.RichTxtBox;
                bool skipSpace = true;
                int cn0 = 0, cn1 = 0, cn2 = 0, cn3 = 0, cn4 = 0, cn5 = 0;
                double cn6 = 0;
                if (tbox.Text.Length <= 0) FbSave = true;
                else if (tbox.Text != null)
                {
                    String sLine, ls = tbox.Text, lss = tbox.Text;
                    if (skipSpace)
                    {
                        sLine = ls.Replace(" ?", "").Replace(" ", "").Replace("\t", "").Replace("\n", "").Replace("\r", "");
                        cn0 += getWordsLength(sLine);   //字数数量(文本长度)
                        cn1 += getByteLength(sLine);    //字节数量(不含空格,\r\n\t等字符)
                        cn2 += getdigitalLength(sLine); //数字数量
                        cn3 += getcharLength(sLine);    //字母数量
                        cn4 = cn1 - cn0;                //汉字数量
                        cn5 = cn1 - cn2 - cn3 - cn4 * 2;//符号数量
                        cn6 = lss.Length + cn1 - cn0;
                        //cn6 = Math.Round(((double)(lss.Length + cn1 - cn0) / 1000), 2);
                        if (cn6 < 1000)
                        {
                            toLabel0.Text = string.Format("{0} 字节", cn6);
                        }
                        else if (cn6 >= 1000 && cn6 < 1000000)
                        {
                            double i = Math.Round(cn6 / 1000, 2);
                            toLabel0.Text = string.Format("{0} KB", i);
                        }
                        else if (cn6 >= 1000000 && cn6 < 1000000000)
                        {
                            double i = Math.Round((cn6 / (1000 * 1000)), 2);
                            toLabel0.Text = string.Format("{0} MB", i);
                        }
                        else if (cn6 >= 1000000000)
                        {
                            double i = Math.Round((cn6 / (1000 * 1000 * 1000)), 2);
                            toLabel0.Text = string.Format("{0} GB", i);
                        }
                        toLabel1.Text = string.Format("符号{0},字母{1},数字{2},汉字{3}", cn5, cn3, cn2, cn4);
                        toLabel2.Text = string.Format("{0}字", cn0);
                    }
                    //if(!FbOpens)
                    //FbSave = false;
                    //else FbSave = true;
                }
            }
            catch (Exception ex) { MessageBox.Show(ex.ToString()); }
        }
        #endregion

        #region  =★*★*★=  统计〖字符〗 函数  =★*★*★=
        #region =★*★*★= 返回数字(0~9)数量 =★*★*★=
        ///  返回数字(0~9)数量 
        /// 获得文本中所有含有数字数量 
        /// 
        /// 
        private static int getdigitalLength(string s)
        {
            int lxs = 0;
            char[] str = s.ToCharArray();
            for (int i = 0; i < str.Length; i++)
            {
                if ((int)str[i] >= 48 && (int)str[i] <= 57)
                { lxs++; }
            }
            return lxs;
        }
        #endregion

        #region =★*★*★= 统计文本中的字母(A~Za~z)数量 =★*★*★=
        ///  统计文本中的字母(A~Za~z)数量 
        /// 统计字数的文本框
        /// 
        private static int getcharLength(string s)
        {
            int lxm = 0;
            char[] str = s.ToLower().ToCharArray();
            for (int i = 0; i < str.Length; i++)
            {
                if ((int)str[i] >= 97 && (int)str[i] <= 122)
                { lxm++; }
            }
            return lxm;
        }
        #endregion

        #region =★*★*★= 返回字数(文本长度) =★*★*★=
        ///  返回字数(文本长度) 
        ///  统计字数的文本框 
        /// 
        private static int getWordsLength(string s)
        {
            if (s != null)
                return s.Length;
            else
                return 0;
        }
        #endregion

        #region =★*★*★= 返回字节数 =★*★*★=
        ///  返回字节数。 计算双字节数量. 
        /// 汉字结果+2,否则结果+1。
        ///  
        /// 统计字数的文本
        /// 
        private static int getByteLength(string s)
        {
            int lxh = 0;
            char[] str = s.ToCharArray();
            for (int i = 0; i < str.Length; i++)
            {
                if ((int)str[i] >= 0x4E00 && (int)str[i] <= 0x9FA5)
                {
                    lxh += 2;
                }
                else { lxh++; }
            }
            return lxh;
        }
        #endregion

        #region =★*★*★= 统计汉字数字 =★*★*★=
        ///  统计汉字数字 
        /// 统计字数的文本
        /// 
        private static int getByteLengths(string s)
        {
            int lxh = 0;
            char[] str = s.ToCharArray();
            for (int i = 0; i < str.Length; i++)
            {
                if ((int)str[i] >= 0x4E00 && (int)str[i] <= 0x9FA5)
                {
                    lxh += 2;
                }
            }
            return lxh;
        }

        #endregion
        #endregion


        /**=**=**=**=**=**=**=**=**=***=**=**=**=**=**/
        #region  =★*★*★= 〖新建-打开-保存〗〖复制-隐藏〗文档 =★*★*★=
        #region  =★*★*★= 新建文档 =★*★*★=
        ///  新建文档 
        /// RichTextBox 文本框
        /// 指示当前的文本是否属于打开的文档,true为打开false为新建文档
        /// 指示当前文档是否已经保存,true 为保存,false 未保存
        public static void newFile(Form form, RichTextBox rbox)
        {
            if (!FbSave)
                AskDialog(form, rbox);
            else
            {
                txtName = string.Format("新建文档 - Mxdr记事本");
                filePath = "";
                Nulltxt();
                form.Text = txtName;
                FbOpen = false; FbSave = true;
            }
        }
        #endregion

        #region  =★*★*★= 打开文件 =★*★*★=
        ///  打开文件 
        /// RichTextBox 文本框
        /// 指示当前的文本是否属于打开的文档,true为打开false为新建文档
        /// 指示当前文档是否已经保存,true 为保存,false 未保存
        public static void openFile(Form form, RichTextBox rbox)
        {
            if (FbSave)
                openthe(form);
            else
            {
                AskDialog(form, rbox);
                if (FbSave)
                    openthe(form);
            }
        }
        #endregion

        #region  =★*★*★= 为TreeView节点打开文件 =★*★*★=
        ///  为TreeView节点打开文件 
        /// 窗口
        /// 文件名(含路径)
        public static void openFiles(Form form, string path)
        {
            FileStream fs = new FileStream(path,
                FileMode.Open, FileAccess.Read, FileShare.None);
            StreamReader sr = new StreamReader(fs, Encoding.Default);
            readFile(sr.ReadToEnd());  //委托事件
            txtName = Path.GetFileName(path);           //获取文件名
            //filePath = fileInfo.FullName; //获取文件路径
            filePath = path;
            string str = Directory.GetParent(filePath).ToString();
            string strs = Path.GetExtension(filePath);
            txtName = Path.GetFileNameWithoutExtension(path);
            sr.Close();
            fs.Close();

            FbOpen = true; FbSave = true; FbOpens = false;
            form.Text = string.Format("『{0}』{2}〖Mxdr记事本〗 - 所在目录:[{1}]", txtName, str, strs);
        }
        #endregion

        #region  =★*★*★= 打开文件方法 =★*★*★=
        ///  打开文件方法 
        /// RichTextBox 文本框
        /// 指示当前的文本是否属于打开的文档,true为打开false为新建文档
        /// 指示当前文档是否已经保存,true 为保存,false 未保存
        private static void openthe(Form form)
        {
            //Mxdr_Nots form = (Mxdr_Nots)this.Owner;
            OpenFileDialog ofd = new OpenFileDialog();
            ofd.Title = "打开文本文档 - Mxdr记事本";
            ofd.Filter = "文本文档|*.txt|XML文档|*.xml|所有文档|*.*";
            if (ofd.ShowDialog() == DialogResult.OK)
            {
                FbOpen = true; FbSave = true; FbOpens = true;
                FileStream fs = new FileStream(ofd.FileName,
                    FileMode.Open, FileAccess.Read, FileShare.None);
                StreamReader sr = new StreamReader(fs, Encoding.Default);
                readFile(sr.ReadToEnd()); //委托
                txtName = ofd.SafeFileName;           //获取文件名
                //filePath = fileInfo.FullName; //获取文件路径
                filePath = ofd.FileName;
                string str = Directory.GetParent(filePath).ToString();
                string strs = Path.GetExtension(filePath);
                txtName = Path.GetFileNameWithoutExtension(ofd.FileName);
                sr.Close();
                fs.Close();

                form.Text = string.Format("『{0}』{2}〖Mxdr记事本〗 - 所在目录:[{1}]", txtName, str, strs);
            }
        }
        #endregion

        #region  =★*★*★= 保存文档 =★*★*★=
        /// 保存文档  
        /// 参数1(form):笔记本窗口
        /// 参数2(sft):用于判断控件内容是否改变  
        /// 笔记本窗口
        /// 用于判断控件内容是否改变
        public static void Save(Form form)
        {
            try
            {
                if (FbOpen || filePath != "")
                {
                    //SaveFileDialog ofg = new SaveFileDialog();
                    //rbox.SaveFile(filePath, RichTextBoxStreamType.PlainText);
                    FileSaves(filePath, RichTextBoxStreamType.PlainText);
                    //this.FilesSave(filePath);
                    FbSave = true;
                    FbRiSave = false;
                }
                else
                { SaveAs(form); }
            }
            catch (Exception e)
            { MessageBox.Show(e.ToString()); }
        }
        #endregion

        #region  =★*★*★= 另存为 =★*★*★=
        ///  另存为 
        /// 新建文档另存为其他文档
        /// RichTextBox 文本框
        /// 指示当前文档是否已经保存,true 为保存,false 未保存
        public static void SaveAs(Form form)
        {
            //Mxdr_Nots form = (Mxdr_Nots)this.Owner;
            //RichTextBox rbox = form.RichTxtBox;
            SaveFileDialog ofd = new SaveFileDialog();
            ofd.Title = "另存为 - Mxdr记事本";
            ofd.Filter = "文本文档|*.txt|XML文档|*.xml|所有文档|*.*";
            ofd.FileName = "Mxdr_" + DateTime.Now.ToString("yyMMddHHmm") + ".txt";
            if (ofd.ShowDialog() == DialogResult.OK)
            {
                //rbox.SaveFile(ofd.FileName, RichTextBoxStreamType.PlainText);

                filePath = ofd.FileName;
                txtName = Path.GetFileNameWithoutExtension(ofd.FileName);
                string str = Directory.GetParent(filePath).ToString();
                string strs = Path.GetExtension(filePath);
                FileSaves(ofd.FileName, RichTextBoxStreamType.PlainText);

                //FilesSaveAs(ofd.FileName);
                form.Text = string.Format("『{0}{2}』〖Mxdr记事本〗 已保存至:[{1}]目录", txtName, str, strs);
                FbSave = true;
            }
        }
        #endregion

        #region  =★*★*★= 保存草稿 =★*★*★=
        ///  把未保存的草稿文件保存到草稿箱中 
        /// 
        public static void SaveAse(Form form)
        {
            if (!FbSave)
            {
                string str = @"草稿箱\Mxdr_" + DateTime.Now.ToString("MMddHHmm") + "草稿.txt";
                FileInfo fi = new FileInfo(str);
                var dir = fi.Directory;
                if (!dir.Exists)
                    dir.Create();
                form.Text = txtName = Path.GetFileName(str);
                filePath = str;
                FileSaves(filePath, RichTextBoxStreamType.PlainText);
                FbSave = true;
            }
        }
        #endregion



        #region  =★*★*★= 复制指定目录的所有文件 =★*★*★=
        ///  复制指定目录的所有文件 
        /// 参数1(sourceDirectory): 原始目录 将此目录内容复制到新目录
        /// 参数2(targetDirectory):  目标目录 将原始目录内容复制到此目录下 
        /// 注意:targetDir不能包含在sourceDir中,否则无限循环文件。
        /// 原始目录 将此目录内容复制到新目录
        /// 目标目录 将原始目录内容复制到此目录下
        public static void FileCopy(string sourceDirectory, string targetDirectory)
        {
            DirectoryInfo diSource = new DirectoryInfo(sourceDirectory);
            DirectoryInfo diTarget = new DirectoryInfo(targetDirectory);

            CopyAll(diSource, diTarget);
        }

        ///  复制指定目录的所有文件 
        /// 参数1(sourceDirectory): 原始目录 将此目录内容复制到新目录
        /// 参数2(targetDirectory):  目标目录 将原始目录内容复制到此目录下
        ///  
        /// 原始目录 将此目录内容复制到新目录
        /// 目标目录 将原始目录内容复制到此目录下
        private static void CopyAll(DirectoryInfo source, DirectoryInfo target)
        {
            try
            {
                // 检查目标文件夹是否存在,如果没有,就创建。
                if (Directory.Exists(target.FullName) == false)
                    Directory.CreateDirectory(target.FullName);

                // 复制文件到新目录。
                foreach (FileInfo fi in source.GetFiles())
                {
                    string path = Path.Combine(target.ToString(), fi.Name);
                    if (File.Exists(path))
                    {
                        FileInfo fi0 = new FileInfo(path);
                        if ((fi0.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
                            roHidFileNudo(path);
                    }
                    fi.CopyTo(path, true);
                    //正在复制 fi.Name 文件
                }

                // 使用递归复制文件夹。
                foreach (DirectoryInfo diSourceSubDir in source.GetDirectories())
                {
                    DirectoryInfo nextTargetSubDir =
                        target.CreateSubdirectory(diSourceSubDir.Name);
                    CopyAll(diSourceSubDir, nextTargetSubDir);
                }
            }
            catch (Exception e) { MessageBox.Show(e.ToString()); }
        }
        #endregion

        #region =★=*=★=*=★= 设置文件或目录的隐藏与只读属性 =★=*=★=*=★=
        ///  隐藏目录(文件夹) 
        /// (文件夹)目录(包含路径)
        public static void roHidDir(string path)
        {
            DirectoryInfo dir = new DirectoryInfo(path);
            File.SetAttributes(path, dir.Attributes | FileAttributes.Hidden & ~FileAttributes.ReadOnly);
        }

        ///  设置文件隐藏 
        /// 文件名(包含路径)
        public static void roHidFiles(string path)
        {
            FileInfo fi = new FileInfo(path);
            File.SetAttributes(path, fi.Attributes | FileAttributes.Hidden);
        }

        ///  设置文件只读 
        /// 文件名(包含路径)
        public static void roHidFiless(string path)
        {
            FileInfo fi = new FileInfo(path);
            File.SetAttributes(path, fi.Attributes | FileAttributes.ReadOnly);
        }

        ///  设置文件隐藏只读 
        /// 文件名(包含路径)
        public static void roHidFile(string path)
        {
            FileInfo fi = new FileInfo(path);
            File.SetAttributes(path, fi.Attributes | FileAttributes.Hidden | FileAttributes.ReadOnly);
        }

        ///  取消目录(文件夹)的隐藏只读属性 
        /// (文件夹)目录名(包含路径)
        public static void roHidDirNudo(string path)
        {
            DirectoryInfo di = new DirectoryInfo(path);
            if (di.Exists)
            { File.SetAttributes(path, di.Attributes & ~FileAttributes.ReadOnly & ~FileAttributes.Hidden); }
        }

        ///  取消文件的只读、隐藏属性 
        /// 文件名(包含路径)
        public static void roHidFileNudo(string path)
        {
            FileInfo fi = new FileInfo(path);
            if (fi.Exists)
            { File.SetAttributes(path, fi.Attributes & ~FileAttributes.Hidden & ~FileAttributes.ReadOnly); }
            else
            {
                string str = Path.GetFileName(path);
                MessageBox.Show(string.Format("没有检测到\"{0}\"文件,\n请检查\"{0}\"文件是否存在!", str));
            }
        }
        #endregion


        #region  =★*★*★= 获取〖文件夹大小〗与〖文件信息〗 =★*★*★=
        ///  获取文件夹大小 
        /// 文件夹路径
        /// 
        public static long GetDirectoryLength(string Dirpath)
        {
            if (!Directory.Exists(Dirpath))
                return 0;
            long len = 0;
            DirectoryInfo di = new DirectoryInfo(Dirpath);
            foreach (FileInfo fi in di.GetFiles())
            {
                len += fi.Length;
            }
            DirectoryInfo[] dis = di.GetDirectories();
            if (dis.Length > 0)
            {
                for (int i = 0; i < dis.Length; i++)
                { len += GetDirectoryLength(dis[i].FullName); }
            }
            return len;
        }

        ///  获取指定文件详细信息 
        /// 文件路径
        /// 
        public static string GetFileAttibe(string filePath)
        {
            string str = string.Empty;
            System.IO.FileInfo objFI = new FileInfo(filePath);
            str = "\n详细路径:" + objFI.FullName +
                "\n文件名称:" + objFI.Name +
                "\n文件大小:" + objFI.Length.ToString() +
                "字节\n创建时间:" + objFI.CreationTime.ToString() +
                "\n最后访问时间:" + objFI.LastAccessTime.ToString() +
                "\n修改时间:" + objFI.LastWriteTime.ToString() +
                "\n所在目录:" + objFI.DirectoryName +
                "\n扩展名:" + objFI.Extension;
            return str;
        }
        #endregion



        

        #region  =★*★*★= 询问对话框 =★*★*★=
        ///  询问对话框 当用户要离开或退出当前文档时,
        /// 如果文档尚未保存,则发出询问是否保存 
        /// RichTextBox 文本框
        /// 指示当前的文本是否属于打开的文档,true为打开false为新建文档
        /// 指示当前文档是否已经保存,true 为保存,false 未保存
        public static void AskDialog(Form form, RichTextBox rbox)
        {
            if (!FbSave)
            {
                DialogResult r = MessageBox.Show("当前文件尚未保存,文档内容即将丢失!"
                    + "\n是否保存当前文件?",
                    "Mxdr温馨提示!!",
                    MessageBoxButtons.YesNoCancel,
                    MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
                if (r == DialogResult.Yes)
                { Save(form); if (FbSave)clearFile(rbox); }
                else if (r == DialogResult.No)
                { clearFile(rbox); }
            }
            else { clearFile(rbox); }
        }
        #endregion

        #region  =★*★*★= 清空文本内容 =★*★*★=
        ///  清空文本内容 
        private static void clearFile(RichTextBox rbox)
        {
            //RichTextBox rbox = this.form.RichTxtBox;
            rbox.Clear(); txtName = ""; FbSave = true; FbOpen = false;
        }
        #endregion

        #region  =★*★*★= 关闭窗体前询问 =★*★*★=
        ///  如果文本内容未保存,关闭窗体前询问是否要保存 
        /// 窗体点击关闭参数 e
        public static void FbClosSaves(FormClosingEventArgs e)
        {
            if (!FbSave) //判断文件是否为未保存
            {
                if (e.CloseReason == CloseReason.UserClosing)
                {
                    DialogResult r = MessageBox.Show(
                        "文件内容已发生改变,\n确定要退出程序?",
                        "温馨提示 - Mxdr记事本",
                        MessageBoxButtons.OKCancel,
                        MessageBoxIcon.Question);
                    if (r != DialogResult.OK)
                    {
                        e.Cancel = true; //如果对话框点击的不是"OK",取消本次退出
                    }
                }
            }
        }
        #endregion

        #region  =★*★*★= 回车多行 =★*★*★=
        ///  回车多行 RichTextBox_KeyPress 事件
        /// RichTextBox_KeyPress 参数 e 
        public static void KeyClickEnter(RichTextBox rbox, KeyPressEventArgs e)
        {
            //RichTextBox rbox = this.form.RichTxtBox;
            if (e.KeyChar == (char)13)
            {
                string s = rbox.Text;
                int ls = rbox.SelectionStart;
                s = s.Insert(ls, "\r\n    ");
                rbox.Text = s;
                rbox.SelectionStart = ls + 5;
                rbox.Focus();
                rbox.ScrollToCaret();
            }
        }
        #endregion

        #region =★=*=★=*=★= 显示文档是否已保存 =★=*=★=*=★=
        ///  在状态栏Label显示文档是否已保存 
        public static void Saves(ToolStripStatusLabel toLabel)
        {
            if (FbSave)
            {
                toLabel.Text = "已保存";
                toLabel.ForeColor = Color.Black;
            }
            else
            {
                toLabel.Text = "未保存";
                toLabel.ForeColor = Color.Purple;
            }
        }
        #endregion
        #endregion
        /**=**=**=**=**=**=**=**=**=***=**=**=**=**=**/


        ///  用 "剪贴板"的内容替换文本框中当前选定的内容 
        /// RichTextBox
        public static void Pastes(RichTextBox rbox)
        {
            // GetDataObject检索当前剪贴板上的数据 
            IDataObject iData = Clipboard.GetDataObject();

            // 将数据与指定的格式进行匹配,返回bool
            if (iData.GetDataPresent(DataFormats.UnicodeText))
                // GetData检索数据并指定一个格式 
                rbox.SelectedText = (string)iData.GetData(DataFormats.UnicodeText);
            else
                MessageBox.Show("目前剪贴板中数据不可转换为文本", "错误");
        }


        /**=**=**=**=**=**=**=**=**=***=**=**=**=**=**/
        /**=**=**=**=**=**=**=**=**=***=**=**=**=**=**/


        #region  =★*★*★= TreeView 调用项目 =★*★*★=

        #region  =★*★*★= 依据鼠标右击显示右键菜单项 =★*★*★=
        ///  根据右键点击 Node 时,确定显示哪些选项 
        /// 参数1(path):绝对路径
        /// 参数2(dirName):主文件夹路径名称(作为依据判断)
        /// 参数3(RightMenu0):右键菜单 新建书目
        /// 参数4(RightMenu1):右键菜单 新建卷章
        /// 参数5(RightMenu2):右键菜单 新建章节
        ///  
        /// 绝对路径
        /// 主文件夹名称(不含路径,作为依据判断)
        /// 右键菜单 新建书目
        /// 右键菜单 新建卷章
        /// 右键菜单 新建章节
        public static void SubDir(string path, string dirpath,
            ToolStripMenuItem RightMenu0, ToolStripMenuItem RightMenu1,
            ToolStripMenuItem RightMenu2, ToolStripMenuItem RightMenu3)
        {
            try
            {
                string Suffix = Path.GetExtension(path);
                DirectoryInfo info = new DirectoryInfo(path);

                if (!System.Text.RegularExpressions.Regex.IsMatch(path, @"(\w{1}:\\)$"))
                    if (Suffix == "" || Suffix == null)
                    {   /* 判断鼠标右键点击的节点,限定右键菜单功能 */
                        if (dirpath == path)
                        {
                            RightMenu0.Enabled = true; RightMenu1.Enabled = false;
                            RightMenu2.Enabled = true; RightMenu3.Enabled = false;
                        }

                        else if (dirpath == info.Parent.FullName)
                        {
                            RightMenu0.Enabled = true; RightMenu1.Enabled = true;
                            RightMenu2.Enabled = true; RightMenu3.Enabled = true;
                        }

                        else if (dirpath == info.Parent.Parent.FullName)
                        {
                            RightMenu0.Enabled = false; RightMenu1.Enabled = true;
                            RightMenu2.Enabled = true; RightMenu3.Enabled = true;
                        }

                        else if (dirpath == info.Parent.Parent.Parent.FullName
                            || dirpath == info.Parent.Parent.Parent.Parent.FullName)
                        {
                            RightMenu0.Enabled = false; RightMenu1.Enabled = false;
                            RightMenu2.Enabled = true; RightMenu3.Enabled = true;
                        }

                        else
                        {
                            RightMenu0.Enabled = false; RightMenu1.Enabled = false;
                            RightMenu2.Enabled = true; RightMenu3.Enabled = true;
                        }
                    }
                    else if (Suffix != "" && dirpath == info.Parent.FullName
                        || Suffix != "" && dirpath == info.Parent.Parent.FullName)
                    {
                        RightMenu0.Enabled = false; RightMenu1.Enabled = false;
                        RightMenu2.Enabled = true; RightMenu3.Enabled = true;
                    }
                    else
                    {
                        RightMenu0.Enabled = false; RightMenu1.Enabled = false;
                        RightMenu2.Enabled = true; RightMenu3.Enabled = true;
                    }
            }
            catch (Exception ex)
            { MessageBox.Show(ex.ToString()); }

        }
        #endregion

        #region  =★*★*★= 全局变量 =★*★*★=
        ///  判断是否有同名文件 false :没有同名文件, trur: 已有同名文件
        private static bool nfile = true;
        ///  判断是否已经成功创建文件用于关闭相关窗口判断
        ///  false :文件未创建, trur: 文件已创建成功
        public static bool nfilenode = false;
        #endregion

        #region  =★*★*★= 重命名〖文件〗或〖文件夹〗 =★*★*★=
        /// 重命名〖文件〗或〖文件夹〗 
        /// 参数1(path):原〖文件〗或〖文件夹〗名称及路径
        /// 参数2(target):新〖文件〗或〖文件夹〗名称(不含路径) 
        /// 原〖文件〗或〖文件夹〗名称及路径
        /// 新〖文件〗或〖文件夹〗名称(不含路径)
        public static void RenameFileDirName(string path, string target)
        {
            string Suffix = System.IO.Path.GetExtension(path);
            if (Suffix == "" || Suffix == null)
            {
                RenameDirName(path, target);
            }
            else
                RenameFileName(path, target);
        }

        ///  重命名文件 
        /// 参数1(path):原文件名称及路径
        /// 参数2(target):新文件名称(不含路径) 
        /// 原文件名称及路径
        /// 新文件名称(不含路径)
        public static void RenameFileName(string path, string target)
        {
            string Suffix = System.IO.Path.GetExtension(path);
            string Suffixx = System.IO.Path.GetExtension(target);
            string paths = target + Suffix;
            if (Suffixx == "" || Suffixx == null)
                NewFileName(path, paths);
            else
                NewFileName(path, target);
        }

        ///  重命名文件夹 
        /// 参数1(path):原文件夹名称及路径
        /// 参数2(target):新文件夹名称(不含路径) 
        /// 原文件夹名称及路径
        /// 新文件夹名称(不含路径)
        public static void RenameDirName(string path, string target)
        {
            NewDirectoryName(path, target);
        }

        ///  重命名文件 
        /// 参数1(path):原文件名称及路径
        /// 参数2(newname):新文件名称(不含路径) 
        /// 原文件名称及路径
        /// 新文件名称(不含路径)
        private static void NewFileName(string path, string newname)
        {
            string filepath = path.Remove(path.LastIndexOf('\\') + 1) + newname;
            System.IO.FileInfo fo = new System.IO.FileInfo(filepath);
            var dir = fo.Directory;
            if (dir.Exists && System.IO.File.Exists(path))
                if (!System.IO.File.Exists(filepath))
                {
                    System.IO.File.Move(path, filepath);
                }
                else
                {
                    MessageBox.Show(string.Format(
                        "〖{0}〗文件已存在,或〖{1}〗文件不存在 ," +
                        "\n请确保〖{1}〗文件存在或重新命名〖{0}〗文件",
                        newname, path), "文件重名",
                        MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                }
        }

        ///  重命名文件夹 
        /// 参数1(path):原文件夹名称及路径
        /// 参数2(newname):新文件夹名称(不含路径) 
        /// 原文件夹名称及路径
        /// 新文件夹名称(不含路径)
        private static void NewDirectoryName(string path, string newname)
        {
            string Dirpath = path.Remove(path.LastIndexOf('\\') + 1) + newname;
            if (System.IO.Directory.Exists(path))
            {
                if (!System.IO.Directory.Exists(Dirpath))
                    System.IO.Directory.Move(path, Dirpath);
                else
                    MessageBox.Show(string.Format("〖{0}〗", Dirpath) +
                     " 文件夹已存在,\n请确保文件夹正确性!", "文件夹重名",
                     MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
            }
            else
            {
                MessageBox.Show(string.Format("〖{0}〗", path) +
                      " 文件夹不存在,\n请确保文件夹正确性!", "文件夹不存在",
                      MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
            }
        }
        #endregion

        #region  =★*★*★= 删除〖文件〗或〖文件夹〗 =★*★*★=
        ///  删除〖文件或文件夹〗 
        ///  〖文件或文件夹〗名称(含路径)
        public static void DelFileFolder(string path)
        {
            string Suffix = Path.GetExtension(path);
            if (Suffix != "" && Suffix != null)
                DelFile(path);
            else
                DelFolder(path);
        }

        ///  删除文件 
        /// 文件名称(含路径)
        private static void DelFile(string path)
        {
            if (File.Exists(path)) { File.Delete(path); }
        }

        ///  删除文件夹 
        /// 文件夹名称(含路径)
        private static void DelFolder(string path)
        {
            if (Directory.Exists(path))
            {
                try
                {
                    //此方法只能删除空文件夹,如果文件夹有内容将不能删除
                    Directory.Delete(path);
                }
                catch (Exception)
                {
                    MessageBox.Show(
                      "请确保文件夹内容为空", "文件夹内容不为空",
                      MessageBoxButtons.OK, MessageBoxIcon.Asterisk
                      );
                }
            }
        }
        #endregion

        #region  =★*★*★= 创建〖文件〗或〖文件夹〗 =★*★*★=
        #region  创建新书〖文件夹〗 
        ///  创建新书〖文件夹〗 
        /// 参数1(path):父〖目录〗名称(含路径)
        /// 参数2(bookName):新书〖文件夹〗名称(不含路径)
        /// 参数3(dirName):父〖目录〗名称(不含路径) 
        /// 父〖目录〗名称(含路径)
        /// 新书〖文件夹〗名称(不含路径)
        /// 父〖目录〗名称(不含路径)
        public static void NewBook(string path, string bookName)
        {
            NewDirectiry(path, bookName);
        }
        #endregion

        #region  创建新卷〖文件夹〗 
        /// 创建新卷〖文件夹〗 
        /// 参数1(path):〖目录〗路径
        /// 参数2(bookName):新卷〖文件夹〗名称(不含路径)
        /// 参数3(dirName):上级〖目录〗名称(不含路径,作为依据判断) 
        /// 〖目录〗路径
        /// 新卷〖文件夹〗名称(不含路径)
        /// 上级〖目录〗名称(不含路径,作为依据判断)
        public static void Volumes(string path, string bookName, string dirName)
        {
            try
            {
                int len = dirName.Length;
                string fPath = path.Remove(path.LastIndexOf(dirName) + len);

                DirectoryInfo info = new DirectoryInfo(path);
                if (fPath == info.Parent.FullName)
                    NewDirectiry(path, bookName);
                else if (fPath == info.Parent.Parent.FullName)
                    NewDirectiry(info.Parent.FullName, bookName);
            }
            catch (Exception ex)
            { MessageBox.Show(ex.ToString()); }
        }
        #endregion

        #region  创建 『章节』 
        ///  创建 『章节』  
        /// 参数1(path):原文件或文件夹路径
        /// 参数2(bookName):新建『章节』文件名称(不含路径)
        /// 参数3(pathDir):主文件夹名称(含路径,作为依据判断)
        /// 参数3(Suffix):新建『章节』文件后缀(不含路径)
        /// 原文件或文件夹路径
        /// 新建『章节』文件名称(不含路径)
        /// 主文件夹名称(含路径,作为依据判断)
        /// 新建『章节』文件后缀(不含路径)
        public static void Chapter(string path, string bookName, string Suffix)
        {
            string suffix = Path.GetExtension(path);

            DirectoryInfo info = new DirectoryInfo(path);
            if (suffix != "")
            {
                string paths = info.Parent.FullName;
                NewFiles(paths, bookName, Suffix);
            }
            else
                if (!bools(path))
                    NewFiles(path, bookName, Suffix);
        }
        #endregion

        #region   创建 文件 
        ///  创建 文件 
        /// 参数1(path):原文件或文件夹路径
        /// 参数2(str):新建文件名称(不含路径)
        /// 参数3(Suffix):新建文件后缀(不含路径) 
        /// 原文件或文件夹路径
        /// 新建文件名称(不含路径)
        /// 新建文件后缀(不含路径)
        private static void NewFiles(string path, string str, string Suffix)
        {
            string pathd = System.IO.Path.Combine(path, (str + Suffix)); //合并路径
            if (str != "" && Suffix != "")
                if (!File.Exists(pathd))
                {
                    System.IO.FileStream fs;
                    fs = System.IO.File.Create(pathd);
                    fs.Close();
                    nfile = false;
                }
                else
                {
                    nfile = true;
                    MessageBox.Show(string.Format("您要创建的〖{0}{1}〗文件已存在,\n请确保文件名正确性!", str, Suffix),
                        "文件名重复 - Mxdr温馨提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            else
            {
                MessageBox.Show("文件名或后缀不能为空,\n请确保文件名正确性!",
                          "文件名重复 - Mxdr温馨提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }
        #endregion

        #region  创建 〖文件夹〗 
        ///  创建 〖文件夹〗 
        /// 参数1(path):原 〖文件 或 文件夹〗 路径
        /// 参数2(str):新建『文件夹』名称(不含路径) 
        /// 原『文件或文件夹』路径
        /// 新建『文件夹』名称(不含路径)
        private static void NewDirectiry(string path, string str)
        {
            //合并路径
            string pathd = System.IO.Path.Combine(path, str);
            Directory.CreateDirectory(pathd);
            nfilenode = true;
            //MessageBox.Show(string.Format("【{0}】文件夹创建成功!", str), "创建文件夹",
            //    MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
        #endregion
        #endregion

        /* **=**=**=**=**=**=**=**=**=**=**=**=**=**=**=**=**=**
         * **= 注意设置节点 〖图标索引〗  在下面三个地方设置 =**
         * **=    LoadDirectory、 LoadLvFile、 nodeChapter   =**
         * **=**=**=**=**=**=**=**=**=**=**=**=**=**=**=**=**=** */
        #region  =★*★*★= 加载〖节点〗 =★*★*★=
        ///  加载指定目录中的项(文件夹) 
        /// 参数1(path):目录路径名称
        /// 参数2(tNode):选定的节点
        ///  
        /// 目录路径
        /// 选定的节点
        public static void LoadDirectory(string path, TreeNode tNode)
        {
            try
            {
                string[] directorys = Directory.GetDirectories(path); //获取选中treeview节点的子目录

                foreach (string item in directorys)
                {
                    if ((File.GetAttributes(item) & FileAttributes.Hidden) != FileAttributes.Hidden)
                    {
                        TreeNode tnode = new TreeNode(Path.GetFileName(item));
                        tnode.Name = item;
                        tnode.ToolTipText = "文件夹: " + item;
                        tnode.ImageIndex = 16;
                        tnode.SelectedImageIndex = 17;
                        tNode.Nodes.Add(tnode); //选中节点添加子节点
                    }
                }
                LoadLvFile(path, tNode);  /* 加载文件节点 */
            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString());
            }
        }        

        ///  加载指定目录中的项(文件) 
        /// 参数1(path):目录路径名称
        /// 参数2(tNode):选定的节点
        ///  
        /// 目录路径
        /// 选定的节点
        public static void LoadLvFile(string path, TreeNode tNode)
        {
            try
            {
                if (path.Contains("System Volume Information"))
                {
                    return;
                }
                string[] files = Directory.GetFiles(path);  //获取目录中的文件名称
                foreach (string item in files)
                {
                    string eName = Path.GetExtension(item);
                    //string strName = Path.GetFileNameWithoutExtension(item);
                    if (eName == ".txt" && (File.GetAttributes(item) & FileAttributes.Hidden) != FileAttributes.Hidden)
                    {
                        TreeNode tnodes = new TreeNode(Path.GetFileName(item));
                        tnodes.Name = item;
                        tnodes.ToolTipText = "文件名: " + item;
                        tnodes.ImageIndex = 18;
                        tnodes.SelectedImageIndex = 20;
                        tNode.Nodes.Add(tnodes);
                    }
                }
            }
            catch (Exception e) { MessageBox.Show(e.ToString()); }
        }
        
        ///  选择加载路径 
        public static string CreateFile()
        {
            FolderBrowserDialog fbd = new FolderBrowserDialog();
            fbd.ShowDialog();
            string path = fbd.SelectedPath;
            //if (Directory.Exists(path))
            //{
                return path;
                //txtbox.Text = path; }
        }
        #endregion


        #region  =★*★*★= 创建-删除-更改〖节点〗 =★*★*★=
        ///   添加〖新书〗nodes 
        /// 参数1(tv):TreeView
        /// 参数2(path):nodes 路径
        /// 参数3(dirBookName):主目录路径
        /// 参数4(BookName):目录(文件)名
        ///  
        /// TreeView
        /// nodes 路径
        /// 主目录路径
        /// 目录(文件)名
        public static void nodeBooks(TreeView tv, string path, string dirBookName, string BookName)
        {
            if (tv.SelectedNode == null)
            {
                MessageBox.Show(
                    "请选择一个节点", "提示信息",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Information
                    );
            }
            else
            {
                DirectoryInfo dif = new DirectoryInfo(path);
                TreeNode tmp;
                tmp = new TreeNode(BookName);
                if (dirBookName == path)
                    tv.SelectedNode.Nodes.Add(tmp);
                else if (dirBookName == dif.Parent.FullName)
                    tv.SelectedNode.Parent.Nodes.Add(tmp);
                tv.SelectedNode.Expand();
            }
        }

        ///  添加 〖卷〗nodes 
        /// TreeView
        /// nodes 路径
        /// 主目录路径
        /// 目录(文件)名
        public static void nodeVolumes(TreeView tv, string path, string dirBookName, string BookName)
        {
            if (tv.SelectedNode == null)
            {
                MessageBox.Show(
                    "请选择一个节点", "提示信息",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Information
                    );
            }
            else
            {
                DirectoryInfo dif = new DirectoryInfo(path);
                TreeNode tmp;
                tmp = new TreeNode(BookName);
                if (dirBookName == dif.Parent.FullName)
                    tv.SelectedNode.Nodes.Add(tmp);
                else if (dirBookName == dif.Parent.Parent.FullName)
                    tv.SelectedNode.Parent.Nodes.Add(tmp);
                tv.SelectedNode.Expand();
            }
        }

        ///  添加 章节 nodes 
        /// TreeView
        /// nodes 路径
        ///  (文件)名 
        ///  文件后缀 
        public static void nodeChapter(TreeView tv, string path, string BookName, string Suffix)
        {
            string str = BookName + Suffix;
            if (tv.SelectedNode == null)
            {
                MessageBox.Show(
                    "请选择一个节点", "提示信息",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Information
                    );
            }
            else
            {
                TreeNode tmp;
                tmp = new TreeNode(str);
                tmp.Name = BookName;
                tmp.ImageIndex = 18;
                tmp.SelectedImageIndex = 20;

                FileInfo fo = new FileInfo(path);

                if (fo.Exists)
                {
                    tv.SelectedNode.Parent.Nodes.Add(tmp);
                }
                else
                {
                    tv.SelectedNode.Nodes.Add(tmp);
                }
            }
        }


        ///  创建或添加兄弟节点 
        /// TreeView.Name
        /// 兄弟节点名称
        public static void nodesParent(TreeView tv, string str)
        {
            //首先判断是否选定组件中节点的位置
            if (tv.SelectedNode == null)
            {
                MessageBox.Show(
                    "请选择一个节点",
                    "提示信息",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Information
                    );
            }
            else
            {
                if (tv.SelectedNode.Parent != null)
                {
                    //创建一个节点对象,并初始化
                    TreeNode tmp;
                    tmp = new TreeNode(str);
                    //在TreeView组件中加入兄弟节点 
                    tv.SelectedNode.Parent.Nodes.Add(tmp);
                }
                else
                {
                    DialogResult r = MessageBox.Show("您选择的节点为根节点,\n您确定要创建另一个根节点吗?",
                       "Mxdr温馨提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Exclamation);

                    /* 如果根节点是磁盘目录,该怎么办? */

                    //if (r == DialogResult.OK)
                    //{
                    //    TreeNode tmp;
                    //    tmp = new TreeNode(str);
                    //    tv.Nodes.Add(tmp);
                    //}
                }
            }
        }

        ///  创建或添加子节点 
        /// TreeView.Name
        /// 子节点名称
        public static void nodesSub(TreeView tv, string str)
        {
            //首先判断是否选定组件中的位置
            if (tv.SelectedNode == null)
            {
                MessageBox.Show(
                    "请选择一个节点",
                    "提示信息",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Information
                    );
            }
            else
            {
                //创建一个节点对象,并初始化
                TreeNode tmp;
                tmp = new TreeNode(str);
                //在TreeView组件中加入子节点
                tv.SelectedNode.Nodes.Add(tmp);
                tv.SelectedNode = tmp;
            }
        }

        ///  删除节点 
        /// TreeView.Name
        public static void nodesDele(TreeView tv)
        {
            string str = tv.SelectedNode.Text;
            if (System.Text.RegularExpressions.Regex.IsMatch(str, @"(\w{1}:\\)"))
                MessageBox.Show(string.Format("系统盘符({0})不能够删除", str), "Mxdr温馨提示",
                    MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            else if (tv.SelectedNode.Nodes.Count != 0)
                MessageBox.Show(
                    "请先删除此节点中的子节点!",
                    "提示信息",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Information
                    );
            else
            {
                DialogResult r = MessageBox.Show(
                     "确定要删除此节点?" + "\n如果您这样做,将会删除系统中的相对文件",
                     "删除节点以及文件 - Mxdr温馨提示!",
                     MessageBoxButtons.OKCancel,
                     MessageBoxIcon.Asterisk,
                     MessageBoxDefaultButton.Button2
                     );
                if (r == DialogResult.OK)
                {
                    tv.SelectedNode.Remove();
                    DelFileFolder(str);
                }
            }
        }

        ///  更改节点名称 
        /// TreeView.Name
        public static void nodesChange_Name(TreeView tv)
        {
            tv.SelectedNode.BeginEdit();
        }
        #endregion

        #region  =★*★*★= 创建文件与节点 =★*★*★=
        ///  创建文件与节点 
        /// 参数1(path):创建文件的路径(父目录)
        /// 参数2(str):文件名(不含路径)
        /// 参数3(Suffix):文件后缀
        /// 参数4(tv):TreeView 
        /// 创建文件的路径(父目录)
        /// 文件名(不含路径)
        /// 文件后缀
        /// TreeView
        public static void newFileNode(string path, string str, string Suffix, TreeView tv)
        {
            Chapter(path, str, Suffix);
            if (!nfile)
            {
                nodeChapter(tv, path, str, Suffix);
                nfilenode = true;
            }
        }
        #endregion

        #region  =★*★*★= 右键菜单设置 =★*★*★=
        ///  如果右键点击的是文件,把右键菜单 MenuItem 创建文件设置为〖不可用〗 
        /// Node 路径
        /// 右键菜单 MenuItem
        public static void NodeRightMenuEnab(string path, ToolStripMenuItem RightMenu0,
            ToolStripMenuItem RightMenu1, ToolStripMenuItem RightMenu2)
        {
            string Suffix = Path.GetExtension(path);
            //string dir = Directory.GetParent(path).ToString();
            if (Suffix != "" && Suffix != null)
            {
                RightMenu1.Enabled = false;
            }
            else
            {
                RightMenu1.Enabled = true;
            }
            if (System.Text.RegularExpressions.Regex.IsMatch(path, @"(\w{1}:\\)$"))
            {
                RightMenu0.Enabled = false;
                RightMenu2.Enabled = false;
            }
            else
            {
                RightMenu0.Enabled = true; RightMenu2.Enabled = true;
            }
        }
        #endregion

        #region  =★*★*★= 判断路径是否为系统磁盘 =★*★*★=
        ///  判断路径是否为系统磁盘  如果是磁盘::真 否则 假
        /// 原始路径
        /// 如果是磁盘::真 否则 假
        public static bool bools(string path)
        {
            if (System.Text.RegularExpressions.Regex.IsMatch(path, @"(\w{1}:\\)$"))
                return true;
            else
                return false;
        }
        #endregion
        #endregion


        /* =★*★*★=  〖替换〗与〖查找〗 =★*★*★=*/
        #region  =★*★*★= 〖替换〗与〖查找〗 =★*★*★=

        #region  =★*★*★= 〖查找替换〗的自定义变量 =★*★*★=
        ///  获取或设置查找起始位置 
        static int Index = 0;
        ///  查找到的字符串数量 
        static int count = 0;
        ///  查找字符是否变更
        static string strE = string.Empty;

        ///  记录原始光标位置 
        static int MemoIndex = -1;
        ///  过度字符串变量 
        static string str = string.Empty;
        ///  实例化富文本 
        static RichTextBox r = new RichTextBox();
        #endregion


        #region  =★*★*★= FindUp() 查找指定〖字符 或 字符串〗 =★*★*★=
        /// 向上查找指定〖字符 或 字符串〗(不区分大小写)   
        /// 参数1(rbox):内容文本框,指定为 RichTextBox 文本框类型  
        /// 参数2(str):用户指定要查找的字符串  
        ///    
        /// 内容文本框,指定为 RichTextBox 文本框类型  
        /// 用户指定要查找的字符串  
        public static void FindUp(RichTextBox rtxt, string str)
        {
            if (strE != str)
            {
                rtxt.SelectionStart = rtxt.Text.Length;
                strE = str;
            }

            Index = rtxt.SelectionStart;
            Index = rtxt.Find(str, 0, Index, RichTextBoxFinds.Reverse);
            if (Index >= 0)
            {
                rtxt.SelectionStart = Index;
                rtxt.SelectionLength = str.Length;
                count++;
                rtxt.Focus();
                myColor(rtxt);//设定关键字为颜色
                if (Index <= 0)
                {
                    seeks(str);
                    count = 0;
                }
            }
            else if (Index < 0)
            {
                seeks(str);
                count = 0;
            }
        }
        #endregion

        #region  =★*★*★=  FindDown() 查找指定〖字符 或 字符串〗=★*★*★=
        /// 向下 查找指定〖字符 或 字符串〗   
        /// 参数1(rbox):内容文本框,指定为 RichTextBox 文本框类型  
        /// 参数2(FindStr):用户指定要查找的字符串
        /// 参数3(TrueFales):bool 真:限定大小写 假:不分大小写
        /// 内容文本框,指定为 RichTextBox 文本框类型  
        /// 用户指定要查找的字符串  
        /// bool 真:限定大小写 假:不分大小写  
        public static void FindDown(RichTextBox rtxt, string FindStr,bool TrueFales)
        {
            if (TrueFales)
                fileFindDownMax(rtxt, FindStr);
            else
                fileFindDownMin(rtxt, FindStr);
        }
        #endregion


        #region  =★*★*★= 简单的从上到下查找 =★*★*★=
        /// 向下查找指定〖字符 或 字符串〗(限定大小写)   
        /// 参数1(rbox):内容文本框,指定为 RichTextBox 文本框类型  
        /// 参数2(FindStr):用户指定要查找的字符串  
        ///    
        /// 内容文本框,指定为 RichTextBox 文本框类型  
        /// 用户指定要查找的字符串  
        private static void FindDownmax(RichTextBox rtxt, string FindStr)
        {
            Index = rtxt.Find(FindStr, Index, RichTextBoxFinds.MatchCase);
            if (Index < 0 || Index > rtxt.Text.Length)
            {
                seeks(FindStr);
                count = 0;
                Index = 0;
            }
            else
            {
                rtxt.Select(Index, FindStr.Length);
                myColor(rtxt);//设定关键字为颜色
                Index += FindStr.Length;
                rtxt.Focus();
            }
        }

        /// 向下查找指定〖字符 或 字符串〗(不区分大小写)   
        /// 参数1(rbox):内容文本框,指定为 RichTextBox 文本框类型  
        /// 参数2(FindStr):用户指定要查找的字符串  
        ///    
        /// 内容文本框,指定为 RichTextBox 文本框类型  
        /// 用户指定要查找的字符串  
        private static void FindDownMin(RichTextBox rtxt, string FindStr)
        {
            Index = rtxt.Find(FindStr, Index, RichTextBoxFinds.None);
            if (Index < 0 || Index > rtxt.Text.Length)
            {
                seeks(FindStr);
                count = 0;
                Index = 0;
            }
            else
            {
                rtxt.Select(Index, FindStr.Length);
                myColor(rtxt);//设定关键字为颜色
                Index += FindStr.Length;
                rtxt.Focus();
            }
        }
        #endregion

        //* 类似 VS 的查找方法 */
        #region  =★*★*★= 类似 VS 的查找方法 =★*★*★=
        ///   类似 VS 的查找方法(不区分大小写向下查找) 
        /// 参数1(txt):RichTextBox文本框
        /// 参数2(FindString):查找字符串
        /// RichTextBox文本框
        /// 查找字符串
        private static void fileFindDownMax(RichTextBox rtxt, string FindString)
        {
            if (MemoIndex < 0)
            {
                MemoIndex = rtxt.SelectionStart;
                if (MemoIndex > 10 && MemoIndex + FindString.Length <= rtxt.Text.Length)
                {
                    str = rtxt.Text.Substring(0, MemoIndex + FindString.Length - 1);//截取光标位置 + 查找字符数 - 1 位数
                    Index = rtxt.SelectionStart;
                    r.Text = str;
                }
                else
                {
                    str = rtxt.Text;
                    r.Text = rtxt.Text;
                    Index = rtxt.SelectionStart;
                }
            }
            if (Index < str.Length - (FindString.Length - 1) && Index >= 0)
            {
                Index = r.Find(FindString, Index, RichTextBoxFinds.None);
                if (Index < 0 || Index > r.Text.Length)
                {
                    seeks(FindString);
                    count = 0;
                    Index = 0;
                    MemoIndex = -1;
                }
                else
                {
                    rtxt.Select(Index, FindString.Length);
                    myColor(rtxt);//设定关键字为颜色
                    rtxt.Focus();
                    count++;

                    Index += FindString.Length;
                    if (Index > str.Length - FindString.Length)
                    {
                        seeks(FindString);
                        MemoIndex = -1;
                        Index = 0;
                        count = 0;
                    }
                }
            }
            else if (Index < rtxt.Text.Length && Index >= 0)
            {
                Index = rtxt.Find(FindString, Index, RichTextBoxFinds.None);
                if (Index == -1)//(Index >= txt.Text.Length && Index <= 0)
                {
                    if (r.Text != "")
                    {
                        Index = 0; Index = r.Find(FindString, Index, RichTextBoxFinds.None);
                        if (Index < 0 || Index > r.Text.Length)
                        {
                            seeks(FindString);
                            count = 0;
                            Index = 0;
                            MemoIndex = -1;
                        }
                        else
                        {
                            rtxt.Select(Index, FindString.Length);
                            myColor(rtxt);//设定关键字为颜色
                            rtxt.Focus();
                            Index += FindString.Length;
                            count++;
                            if (Index > str.Length - FindString.Length)
                            {
                                seeks(FindString);
                                MemoIndex = -1;
                                Index = 0;
                                count = 0;
                            }
                        }
                    }
                    else
                    {
                        seeks(FindString);
                        MemoIndex = -1;
                        Index = 0;
                        count = 0;
                    }
                }
                else
                {
                    rtxt.Select(Index, FindString.Length);//在RichTextBox控件中搜索关键字
                    Index += FindString.Length;//递增标识查询关键字的初始长度
                    myColor(rtxt);//设定关键字为颜色
                    rtxt.Focus();
                    count++;
                }
            }
            else
            {
                Index = 0; Index = r.Find(FindString, Index, RichTextBoxFinds.None);
                if (Index < r.Text.Length - FindString.Length && Index >= 0)
                {
                    r.Select(Index, FindString.Length);
                    rtxt.Select(Index, FindString.Length);
                    myColor(rtxt);//设定关键字为颜色
                    Index += FindString.Length;//递增标识查询关键字的初始长度
                    rtxt.Focus();
                    count++;
                }
                else
                {
                    seeks(FindString);
                    MemoIndex = -1;
                    Index = 0;
                    count = 0;
                }
            }
        }

        ///   类似 VS 的查找方法(不区分大小写向下查找) 
        /// 参数1(txt):RichTextBox文本框
        /// 参数2(FindString):查找字符串
        /// RichTextBox文本框
        /// 查找字符串
        private static void fileFindDownMin(RichTextBox rtxt, string FindString)
        {
            if (MemoIndex < 0)
            {
                MemoIndex = rtxt.SelectionStart;
                if (MemoIndex > 10 && MemoIndex + FindString.Length <= rtxt.Text.Length)
                {
                    str = rtxt.Text.Substring(0, MemoIndex + FindString.Length - 1);
                    Index = rtxt.SelectionStart;
                    r.Text = str;
                }
                else
                {
                    str = rtxt.Text;
                    r.Text = rtxt.Text;
                    Index = rtxt.SelectionStart;
                }
            }
            if (Index < str.Length - (FindString.Length - 1) && Index >= 0)
            {
                Index = r.Find(FindString, Index, RichTextBoxFinds.MatchCase);
                if (Index < 0 || Index > r.Text.Length)
                {
                    seeks(FindString);
                    count = 0;
                    Index = 0;
                    MemoIndex = -1;
                }
                else
                {
                    rtxt.Select(Index, FindString.Length);
                    myColor(rtxt);//设定关键字为颜色
                    rtxt.Focus();
                    count++;

                    Index += FindString.Length;
                    if (Index > str.Length - FindString.Length)
                    {
                        seeks(FindString);
                        MemoIndex = -1;
                        Index = 0;
                        count = 0;
                    }
                }
            }
            else if (Index < rtxt.Text.Length && Index >= 0)
            {
                Index = rtxt.Find(FindString, Index, RichTextBoxFinds.MatchCase);
                if (Index == -1)
                {
                    if (r.Text != "")
                    {
                        Index = 0; Index = r.Find(FindString, Index, RichTextBoxFinds.MatchCase);
                        if (Index < 0 || Index > r.Text.Length)
                        {
                            seeks(FindString);
                            count = 0;
                            Index = 0;
                            MemoIndex = -1;
                        }
                        else
                        {
                            rtxt.Select(Index, FindString.Length);
                            myColor(rtxt);//设定关键字为颜色
                            rtxt.Focus();
                            Index += FindString.Length;
                            count++;
                            if (Index > str.Length - FindString.Length)
                            {
                                seeks(FindString);
                                MemoIndex = -1;
                                Index = 0;
                                count = 0;
                            }
                        }
                    }
                    else
                    {
                        seeks(FindString);
                        MemoIndex = -1;
                        Index = 0;
                        count = 0;
                    }
                }
                else
                {
                    rtxt.Select(Index, FindString.Length);//在RichTextBox控件中搜索关键字
                    Index += FindString.Length;//递增标识查询关键字的初始长度
                    myColor(rtxt);//设定关键字为颜色
                    rtxt.Focus();
                    count++;
                }
            }
            else
            {
                Index = 0; Index = r.Find(FindString, Index, RichTextBoxFinds.MatchCase);
                if (Index < r.Text.Length - FindString.Length && Index >= 0)
                {
                    r.Select(Index, FindString.Length);
                    rtxt.Select(Index, FindString.Length);
                    myColor(rtxt);//设定关键字为颜色
                    Index += FindString.Length;//递增标识查询关键字的初始长度
                    rtxt.Focus();
                    count++;
                }
                else
                {
                    seeks(FindString);
                    MemoIndex = -1;
                    Index = 0;
                    count = 0;
                }
            }
        }
        #endregion

        #region  =★*★*★= 〖替换〗与〖全部替换〗 =★*★*★=

        #region  =★*★*★= 单次替换字符串 =★*★*★=
        ///  替换 
        /// RichTextBox
        /// 查找字符串
        /// 替换字符串
        /// (bool值)区分大小写 真:区分假:不区分
        public static void replaces(RichTextBox rtxt, string FindString, string ReplString, bool TrueFalse)
        {
            string txtSt = rtxt.SelectedText;
            if (FindString.Equals(txtSt))
            {
                int fs = FindString.Length;
                int rs = ReplString.Length;
                int cs = fs - rs;
                rtxt.SelectionLength = FindString.Length;
                rtxt.SelectionColor = Color.Coral;
                rtxt.SelectedText = ReplString;//textBox2中放要替换的字符  
                rtxt.Focus();
                MemoIndex = -1;
                rtxt.SelectionStart += cs;
            }
            FindDown(rtxt, FindString, TrueFalse);
        }

        #region  =★*★*★= 单次替换字符串 =★*★*★=
        /// 单次替换字符串   
        /// 参数1(FindString):查找的内容  
        /// 参数2(ReplString):要替换的内容    
        /// 查找的内容  
        /// 要替换的内容  
        private static void replace(RichTextBox rtxt, string FindString, string ReplString)
        {
            rtxt.SelectionLength = FindString.Length;
            rtxt.SelectedText = ReplString;//textBox2中放要替换的字符  
            Index = rtxt.SelectionStart;//获取或设置光标选定位置
        }
        #endregion
        #endregion


        #region  =★*★*★= 〖全部替换〗 =★*★*★=
        ///  全部替换 
        /// 参数1(txt):RichTextBox 文本框
        /// 参数2(FindString):查找字符串
        /// 参数3(ReplString):替换字符串
        /// 参数4(trueFales):bool 真:区分大小写,假:不区分大小写
        /// RichTextBox 文本框
        /// 查找字符串
        /// 替换字符串
        /// bool 真:区分大小写,假:不区分大小写
        public static void ReplAll(RichTextBox rtxt, string FindString, string ReplString, bool trueFales)
        {
            if (trueFales)
                onDistinCase(rtxt, FindString, ReplString);
            else
                offDistinCase(rtxt, FindString, ReplString);
        }

        #region  =★*★*★= 全部替换(区分/不区分大小写) =★*★*★=
        ///  全部替换(区分大小写) 
        /// RichTextBox 文本框
        /// 查找字符串
        /// 替换字符串
        private static void onDistinCase(RichTextBox rtxt, string FindStr, string ReplStr)
        {
            while (Index >= 0 || Index <= rtxt.Text.Length)
            {
                int cot = FindStr.Length - ReplStr.Length;
                Index = rtxt.Find(FindStr, Index, RichTextBoxFinds.MatchCase);
                if (Index < 0 || Index > rtxt.Text.Length)
                {
                    DialogResult r = MessageBox.Show(string.Format("查找结束,已经为您找到{0}个结果。", count),
                          "查找结果-Mxdr温馨提示!!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    if (r == DialogResult.Yes)
                        count = 0;
                    Index = 0;
                    break;
                }
                else
                {
                    rtxt.Select(Index, FindStr.Length);
                    replace(rtxt, FindStr, ReplStr);
                    Index += FindStr.Length;
                    count++;
                }
            }
        }

        ///  全部替换(不区分大小写) 
        /// RichTextBox 文本框
        /// 查找字符串
        /// 替换字符串
        private static void offDistinCase(RichTextBox rtxt, string FindStr, string ReplStr)
        {
            while (Index >= 0 || Index <= rtxt.Text.Length)
            {
                int cot = FindStr.Length - ReplStr.Length;
                Index = rtxt.Find(FindStr, Index, RichTextBoxFinds.None);
                if (Index < 0 || Index > rtxt.Text.Length)
                {
                    DialogResult r = MessageBox.Show(string.Format("查找结束,已经为您找到{0}个结果。", count),
                          "查找结果-Mxdr温馨提示!!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    if (r == DialogResult.Yes)
                        count = 0;
                    Index = 0;
                    break;
                }
                else
                {
                    rtxt.Select(Index, FindStr.Length);
                    replace(rtxt, FindStr, ReplStr);
                    Index += FindStr.Length;
                    count++;
                }
            }
        }
        #endregion
        #endregion

        #region  =★*★*★= 消息提示,提示用户查找结果 =★*★*★=
        ///  消息提示,提示用户查找结果   
        /// 参数1(str):用户指定要查找的字符串   
        /// 用户指定要查找的字符串  
        public static void seeks(string str)
        {
            if (count != 0)
                MessageBox.Show(string.Format("已查找完毕,共〖{0}〗个 \"{1}\"!", count, str), "查找结果-Mxdr温馨提示!!");
            else MessageBox.Show(string.Format("没有查找到 \"{0}\"!", str), "查找 - 温馨提示");
        }
        #endregion

        #endregion

        #region  =★*★*★= 查找字符上色 =★*★*★=
        ///  查找字符上色 
        /// RichTextBox
        private static void myColor(RichTextBox rtxt)
        {
            rtxt.SelectionColor = Color.Coral;
        }
        #endregion

        #endregion

        #region  =★*★*★=  =★*★*★=

        #endregion


    }
}


诸君,眼花没有,揉揉眼睛吧!!!

你可能感兴趣的:(.NET/C#)