《吐血整理》C#一些常用的帮助类

常用类总结

简介:此文章总结了很多的帮助类，求推荐

1.简化Excel操作帮助类

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Configuration;
using System.Data.OleDb;
using System.IO;
using NPOI.SS.UserModel;
using NPOI.XSSF.UserModel;
using NPOI.HSSF.UserModel;

namespace Utilities
{
    /// <summary>
    /// 简化Excel操作
    /// </summary>
    public class ExcelHelper
    {
        /// <summary>
        /// 从指定的Excell文件中获取数据，要求必须是规范的二维表数据且excel文件的首行为字段名
        /// </summary>
        /// <param name="fileUrl">服务器上的文件路径</param>
        /// <param name="head">获取哪些字段的值(例如：编号,姓名,入学时间),不提供时返回所有列</param>
        /// <returns>承载数据的DataSet(内存数据库)</returns>
        public static DataSet ImportDataFromExcell(string fileUrl, string head = "")
        {
            //string connExcel = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + fileUrl + ";Extended Properties=Excel 8.0";//07之前版本使用
            string connExcel = "Provider=Microsoft.Ace.OleDb.12.0;" + "data source=" + fileUrl + ";Extended Properties='Excel 12.0; HDR=Yes; IMEX=1'"; //此连接可以操作.xls与.xlsx文件 (支持Excel2003 和 Excel2007 的连接字符串)
            using (OleDbConnection oleDbConnection = new OleDbConnection(connExcel))
            {
                oleDbConnection.Open();
                //获得Excel的每页上的信息
                DataTable dataTable = oleDbConnection.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, null);
                //获得Excel中的页数
                int pages = dataTable.Rows.Count;
                string tableName = "";
                string query = "";
                DataSet ds = new DataSet();
                OleDbDataAdapter oleAdapter = null;
                for (int i = 0; i < pages; i++)
                {
                    //获得每一页的名称
                    tableName = dataTable.Rows[i][2].ToString().Trim();
                    string tn = tableName.Remove(tableName.Length - 1);
                    tableName = "[" + tableName.Replace("'", "") + "]";
                    if (string.IsNullOrEmpty(head))
                        query = "SELECT * FROM " + tableName;
                    else
                        query = "SELECT " + head + " FROM " + tableName;
                    oleAdapter = new OleDbDataAdapter(query, connExcel);
                    //表示每页上的内容
                    DataTable dt = new DataTable(tn);
                    oleAdapter.Fill(dt);
                    ds.Tables.Add(dt);
                }
                return ds;
            }
        }
        /// <summary>
        /// 从Excel中读取数据
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="sheetName"></param>
        /// <param name="isFirstRowColumn"></param>
        /// <returns></returns>
        public DataTable GetDataToExcel(string fileName, string sheetName, bool isFirstRowColumn)
        {
            IWorkbook workbook = null;
            ISheet sheet = null;
            FileStream fs = null;
            DataTable dt = new DataTable();
            int startRow = 0;
            try
            {
                fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
                if (fileName.IndexOf(".xlsx") > 0)
                {
                    workbook = new XSSFWorkbook(fs);
                }
                else if (fileName.IndexOf(".xls") > 0)
                {
                    workbook = new HSSFWorkbook(fs);
                }

                if (sheetName != null)
                {
                    sheet = workbook.GetSheet(sheetName);
                    if (sheet == null)
                    {
                        sheet = workbook.GetSheetAt(0);
                    }
                }
                else
                {
                    sheet = workbook.GetSheetAt(0);
                }

                if (sheet != null)
                {
                    IRow firstRow = sheet.GetRow(sheet.FirstRowNum);
                    int cellCount = firstRow.LastCellNum;
                    if (isFirstRowColumn)
                    {
                        for (int i = firstRow.FirstCellNum; i < cellCount; i++)
                        {
                            ICell cell = firstRow.GetCell(i);
                            if (cell != null)
                            {
                                string cellValue = cell.StringCellValue;
                                if (cellValue != null)
                                {
                                    DataColumn column = new DataColumn(cellValue);
                                    dt.Columns.Add(column);
                                }
                            }
                        }
                        startRow = sheet.FirstRowNum + 1;
                    }
                    else
                    {
                        startRow = sheet.FirstRowNum;
                    }
                    //取行
                    int rowCount = sheet.LastRowNum;
                    for (int i = startRow; i <= rowCount; i++)
                    {
                        IRow row = sheet.GetRow(i);
                        if (row == null)
                        {
                            continue;
                        }
                        DataRow dr = dt.NewRow();
                        int r = 0;
                        for (int j = row.FirstCellNum; j < cellCount; j++)
                        {
                            dr[r++] = row.GetCell(j).ToString();
                        }
                        dt.Rows.Add(dr);
                    }
                }
                return dt;
            }
            catch (Exception)
            {
                return null;
            }
        }
        /// <summary>
        /// 将数据从DataTable中导入到Excel
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="data">要导入的数据</param>
        /// <param name="sheetName">sheet名称</param>
        /// <param name="isColumnWritten">是否将表格的列名写入</param>
        /// <returns></returns>
        public int DataTableToExcel(string fileName, DataTable data, string sheetName, bool isColumnWritten) 
        {
            int count = 0;//最终写入的记录条数
            IWorkbook workbook = null;
            ISheet sheet = null;
            FileStream fs = null;

            try
            {
                fs = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite);
                if (fileName.IndexOf(".xlsx") > 0)
                {
                    workbook = new XSSFWorkbook();
                }
                else if (fileName.IndexOf(".xls") > 0)
                {
                    workbook = new HSSFWorkbook();
                }

                //将列名写入第一行
                if (workbook != null)
                {
                    sheet = workbook.CreateSheet(sheetName);
                }
                else
                {
                    return -1;
                }

                if (isColumnWritten)
                {//写入DataTable的列名
                    IRow row = sheet.CreateRow(0);
                    for (int j = 0; j < data.Columns.Count; j++)
                    {
                        row.CreateCell(j).SetCellValue(data.Columns[j].ColumnName);
                    }
                    count = 1;
                }
                else
                {
                    count = 0;
                }

                for (int i = 0; i < data.Rows.Count; i++)
                {
                    IRow row = sheet.CreateRow(count);
                    for (int j = 0; j < data.Columns.Count; j++)
                    {
                        row.CreateCell(j).SetCellValue(data.Rows[i][j].ToString());
                    }
                    count++;
                }

                workbook.Write(fs);//将内容写入到对应的文件
                return count;
            }
            catch (Exception)
            {
                return -1;
            }
        }
    }
}

2.扩展代码之用帮助类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Runtime.Serialization.Json;
using Newtonsoft.Json;

namespace Utilities
{
    /// <summary>
    /// 扩展代码之用
    /// </summary>
    public static class Extensions
    {
        /// <summary>
        /// 将2-1 中的“DataTable 对象转字符串”封装到 Extensions 中。
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static string ToHtml(this DataTable dt)
        {
            StringBuilder sb = new StringBuilder("<table><thead>");
            foreach (DataColumn c in dt.Columns)
            {
                sb.AppendFormat($"<th>{c.ColumnName}</th>");
            }
            sb.Append("</thead><tbody>");
            foreach (DataRow r in dt.Rows)
            {
                sb.Append("<tr>");
                for (int i = 0; i < dt.Columns.Count; i++)
                {
                    sb.AppendFormat($"<td>{r[i]}</td>");
                }
                sb.Append("</tr>");
            }
            sb.Append("</tbody></table>");
            return sb.ToString();
        }
        /// <summary>
        /// 为List集合扩展1个获取json字符串的方法，此方法可用于LayUI的数据表格组件
        /// </summary>
        /// <typeparam name="T">集合的类型</typeparam>
        /// <param name="list">数据集合</param>
        /// <param name="count">满足条件的数据的条数</param>
        /// <param name="dateTimeFormat">统一的日期时间格式</param>
        /// <returns>layui数据表格组件可用的json格式字符串</returns>
        public static String ToJsonForLayUITable<T>(this IList<T> list, int count, String dateTimeFormat = "yyyy-MM-dd HH:mm:ss")
        {
            StringBuilder strJson = new StringBuilder();
            JsonSerializerSettings settings = new JsonSerializerSettings();
            settings.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat;
            settings.DateFormatString = dateTimeFormat;
            settings.MaxDepth = 1; //设置序列化的最大层数  
            settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
            settings.NullValueHandling = NullValueHandling.Ignore;
            foreach (var item in list)
            {
                strJson.Append(JsonConvert.SerializeObject(item, settings) + ",");
            }
            return "{\"code\":0,\"msg\":\"\",\"count\":" + count + ",\"data\":[" + strJson.ToString().TrimEnd(',') + "]}";
        }
        /// <summary>
        /// 系统中统一禁用DataSet自己的WriteXml，使用下边定义的格式，在客户端便于解析
        /// </summary>
        /// <param name="ds"></param>
        /// <returns></returns>
        public static string ToXml(this DataSet ds)
        {
            StringBuilder sb = new StringBuilder("<DataSet>  <Tables>");
            foreach (DataTable dt in ds.Tables)
                sb.Append(dt.ToXml());
            sb.Append("</Tables></DataSet>");
            return sb.ToString();
        }
        /// <summary>
        /// 系统中统一禁用DataTable自己的WriteXml，使用下边定义的格式，在客户端便于解析。
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static string ToXml(this DataTable dt)
        {
            StringBuilder sb = new StringBuilder(String.Format("<DataTable Name='{0}'>  <Columns>", dt.TableName));
            int colCount = dt.Columns.Count, rowCount = dt.Rows.Count;
            for (int i = 0; i < colCount; i++)
            {
                sb.Append("<").Append(dt.Columns[i].ColumnName).Append(" DataType='").Append(dt.Columns[i].DataType).Append("'/>");
            }
            sb.Append("  </Columns> <Rows>");

            for (int j = 0; j < rowCount; j++)
            {
                sb.Append("<Row ");
                for (int i = 0; i < colCount; i++)
                    sb.Append(dt.Columns[i].ColumnName + "='").Append(dt.Rows[j][i].ToString() + "' ");
                sb.Append("/>");
            }
            sb.Append(" </Rows> </DataTable>");
            return sb.ToString();
        }

        static string GetJsonStr(string obj, DataContractJsonSerializer ser, System.IO.MemoryStream ms)
        {
            ms.Flush();
            ser.WriteObject(ms, obj);
            return System.Text.Encoding.UTF8.GetString(ms.ToArray());
        }
        /// <summary>
        /// 将DataTable转为字符串
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static string ToJson(this DataTable dt)
        {
            StringBuilder sb = new StringBuilder("[");
            int colCount = dt.Columns.Count, rowCount = dt.Rows.Count;
            for (int j = 0; j < rowCount; j++)
            {
                if (j == 0)
                    sb.Append("{");
                else
                    sb.Append(",{");

                for (int i = 0; i < colCount; i++)
                {
                    if (i == 0)
                        sb.Append(string.Format(@"""{0}"":{1}", dt.Columns[i].ColumnName, IoHelper.SerializeJson(dt.Rows[j][i].ToString())));
                    else
                        sb.Append(string.Format(@",""{0}"":{1}", dt.Columns[i].ColumnName, IoHelper.SerializeJson(dt.Rows[j][i].ToString())));
                }
                sb.Append("}");
            }
            sb.Append("]");
            return sb.ToString();
        }
        /// <summary>
        /// 返回可以直接用于EasyUI的分页数据
        /// </summary>
        /// <param name="dt">DataTable 对象</param>
        /// <param name="rowCount">本次分页查询条件符合记录的总数</param>
        /// <returns></returns>
        public static string ToJsonForEasyUI(this DataTable dt, int rowCount)
        {
            return "{" + string.Format(@"""total"":{0},""rows"":{1}", rowCount, dt.ToJson()) + "}";
        }


        /// <summary>
        /// 将字符串转换为字节数组
        /// </summary>
        /// <remarks>
        /// 在WebService服务端客户端的数据传输过程中，调用加密方法或者字符串中含有特殊符号，可能造成数据传输或解析错误
        /// 调用此法使用字节数组传输，避免此类问题。
        /// </remarks>
        /// <param name="str">源字符串</param>
        /// <returns>字节数组</returns>
        public static byte[] ToPDSBytes(this string str)
        {
            System.Text.UTF8Encoding u = new System.Text.UTF8Encoding();
            return u.GetBytes(str);
        }
        /// <summary>
        /// 转换为字符串
        /// </summary>
        /// <remarks>
        /// 这是ToPDSBytes方法的反向方法
        /// </remarks>
        /// <seealso cref="ToPDSBytes()"/>
        /// <param name="bs">源字节数组</param>
        /// <returns>字符串</returns>
        public static string ToPDSString(this byte[] bs)
        {
            System.Text.UTF8Encoding u = new System.Text.UTF8Encoding();
            return u.GetString(bs);
        }

    }
}

3.对图片的所有处理操作帮助类

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;

namespace Utilities
{
    /// <summary>
    /// 对图片的所有处理操作
    /// </summary>
    public static class ImageHelper
    {
        /// <summary>
        /// 生成网页验证码数据
        /// </summary>
        /// <param name="randomCode">验证码上显示的内容</param>
        /// <param name="imgWdith">宽度</param>
        /// <param name="imgHeight">高度</param>
        /// <returns></returns>
        public static byte[] CreateImage(string randomCode, int imgWdith = 70, int imgHeight = 28)
        {
            Bitmap map = new Bitmap(imgWdith, imgHeight);//创建图片背景  
            Graphics graph = Graphics.FromImage(map);
            graph.Clear(Color.AliceBlue);//清除画面，填充背景 
            Random rand = new Random();
            //背景噪点生成
            Brush blackPen = new SolidBrush(Color.LightGray);
            for (int i = 0; i < 50; i++)
            {
                int x = rand.Next(0, map.Width);
                int y = rand.Next(0, map.Height);
                graph.FillRectangle(blackPen, x, y, 2, 2);
            }
            var chars = randomCode.ToCharArray();
            Color[] c = { Color.Black, Color.Red, Color.DarkBlue, Color.Green, Color.Orange, Color.Brown, Color.DarkCyan, Color.Purple };
            string[] font = { "Verdana", "Microsoft Sans Serif", "Comic Sans MS", "Arial", "宋体" };
            float[] fontSize = { 10f, 12f, 14f, 16f };
            var offset = 5f;
            var sf = new StringFormat { LineAlignment = StringAlignment.Center };
            foreach (var t in chars)
            {
                var cindex = rand.Next(7);
                var findex = rand.Next(5);
                var f = new Font(font[findex], fontSize[rand.Next(0, 4)], FontStyle.Bold);
                Brush b = new SolidBrush(c[cindex]);
                var s = t.ToString();
                graph.DrawString(s, f, b, new RectangleF(offset, 0, map.Width, map.Height), sf);
                offset += graph.MeasureString(s, f).Width;

                b.Dispose();
                f.Dispose();
            }
            sf.Dispose();
            var ms = new MemoryStream();
            map.Save(ms, ImageFormat.Jpeg);
            var buffer = ms.ToArray();

            ms.Dispose();
            graph.Dispose();
            map.Dispose();

            return buffer;
        }

        /// <summary>
        /// 获取指定路径的位图对象
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public static Bitmap GetImage(string path)
        {
            byte[] bs = GetImageData(path);
            return bs.ToImage();
        }
        /// <summary>
        /// 获取指定字节数组的位图
        /// </summary>
        /// <param name="bs"></param>
        /// <returns></returns>
        public static Bitmap ToImage(this byte[] bs)
        {
            if (bs != null && bs.Length > 50)
            {
                MemoryStream ms = new MemoryStream(bs);
                return new Bitmap(ms);
            }
            else
                return null;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public static byte[] GetImageData(string fileName)
        {
            FileStream fs = null;
            try
            {
                if (File.Exists(fileName))
                {
                    fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
                    byte[] bs = new byte[fs.Length];
                    fs.Read(bs, 0, bs.Length);
                    return bs;
                }
                return null;
            }
            catch (Exception ex)
            {
                Console.WriteLine("读取【{0}】时出错:{1}", fileName, ex.Message);
                return new byte[1];
            }
            finally
            {
                if (fs != null)
                    fs.Close();
            }
        }
        /// <summary>
        /// 将Image图像保存为png格式的文件
        /// </summary>
        /// <param name="img"></param>
        /// <param name="path"></param>
        public static void SavePng(Image img, string path)
        {
            img.Save(path, ImageFormat.Png);
        }
        /// <summary>
        /// 将Image图像保存为bmp格式的文件
        /// </summary>
        /// <param name="img"></param>
        /// <param name="path"></param>
        public static void SaveBmp(Image img, string path)
        {
            img.Save(path, ImageFormat.Bmp);
        }
        /// <summary>
        /// 将Image图像保存为jpg格式的文件
        /// </summary>
        /// <param name="img">Image对象</param>
        /// <param name="path">要保存的图片路径</param>
        /// <param name="quality">质量(0~100)</param>
        public static void SaveJpg(Image img, string path, long quality = 75)
        {
            using (EncoderParameters paras = new EncoderParameters(1))
            {
                paras.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)quality);
                img.Save(path, GetEncoderInfo("image/jpeg"), paras);
            }
        }
        /// <summary>
        /// 获取ImageCodecInfo信息
        /// </summary>
        /// <param name="mimeType"></param>
        /// <returns></returns>
        private static ImageCodecInfo GetEncoderInfo(String mimeType)
        {
            int j;
            ImageCodecInfo[] encoders;
            encoders = ImageCodecInfo.GetImageEncoders();
            for (j = 0; j < encoders.Length; ++j)
            {
                if (encoders[j].MimeType == mimeType)
                    return encoders[j];
            }
            return null;
        }
        /// <summary>
        /// 正方型裁剪
        /// 以图片中心为轴心，截取正方型，然后等比缩放(常用于web开发中的头像截取)
        /// </summary>
        /// <param name="fromFile">原图Stream对象</param>
        /// <param name="fileSaveUrl">缩略图存放地址</param>
        /// <param name="side">指定的边长（正方型）</param>
        /// <param name="quality">质量（范围0-100）</param>
        public static void CutForSquare(System.IO.Stream fromFile, string fileSaveUrl, int side, int quality)
        {
            //创建目录
            string dir = Path.GetDirectoryName(fileSaveUrl);
            if (!Directory.Exists(dir))
                Directory.CreateDirectory(dir);
            //原始图片（获取原始图片创建对象，并使用流中嵌入的颜色管理信息）
            System.Drawing.Image initImage = System.Drawing.Image.FromStream(fromFile, true);
            //原图宽高均小于模版，不作处理，直接保存
            if (initImage.Width <= side && initImage.Height <= side)
                initImage.Save(fileSaveUrl, System.Drawing.Imaging.ImageFormat.Jpeg);
            else
            {
                //原始图片的宽、高
                int initWidth = initImage.Width;
                int initHeight = initImage.Height;
                //非正方型先裁剪为正方型
                if (initWidth != initHeight)
                {
                    //截图对象
                    System.Drawing.Image pickedImage = null;
                    System.Drawing.Graphics pickedG = null;
                    //宽大于高的横图
                    if (initWidth > initHeight)
                    {
                        //对象实例化
                        pickedImage = new System.Drawing.Bitmap(initHeight, initHeight);
                        pickedG = System.Drawing.Graphics.FromImage(pickedImage);
                        //设置质量
                        pickedG.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                        pickedG.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
                        //定位
                        Rectangle fromR = new Rectangle((initWidth - initHeight) / 2, 0, initHeight, initHeight);
                        Rectangle toR = new Rectangle(0, 0, initHeight, initHeight);
                        //画图
                        pickedG.DrawImage(initImage, toR, fromR, System.Drawing.GraphicsUnit.Pixel);
                        //重置宽
                        initWidth = initHeight;
                    }
                    else//高大于宽的竖图
                    {
                        //对象实例化
                        pickedImage = new System.Drawing.Bitmap(initWidth, initWidth);
                        pickedG = System.Drawing.Graphics.FromImage(pickedImage);
                        //设置质量
                        pickedG.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                        pickedG.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
                        //定位
                        Rectangle fromR = new Rectangle(0, (initHeight - initWidth) / 2, initWidth, initWidth);
                        Rectangle toR = new Rectangle(0, 0, initWidth, initWidth);
                        //画图
                        pickedG.DrawImage(initImage, toR, fromR, System.Drawing.GraphicsUnit.Pixel);
                        //重置高
                        initHeight = initWidth;
                    }
                    //将截图对象赋给原图
                    initImage = (System.Drawing.Image)pickedImage.Clone();
                    //释放截图资源
                    pickedG.Dispose();
                    pickedImage.Dispose();
                }
                //缩略图对象
                using (System.Drawing.Image resultImage = new System.Drawing.Bitmap(side, side))
                {
                    using (System.Drawing.Graphics resultG = System.Drawing.Graphics.FromImage(resultImage))
                    {
                        //设置质量
                        resultG.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                        resultG.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
                        //用指定背景色清空画布
                        resultG.Clear(Color.White);
                        //绘制缩略图
                        resultG.DrawImage(initImage, new System.Drawing.Rectangle(0, 0, side, side), new System.Drawing.Rectangle(0, 0, initWidth, initHeight), System.Drawing.GraphicsUnit.Pixel);
                        //关键质量控制
                        //获取系统编码类型数组,包含了jpeg,bmp,png,gif,tiff
                        ImageCodecInfo[] icis = ImageCodecInfo.GetImageEncoders();
                        ImageCodecInfo ici = null;
                        foreach (ImageCodecInfo i in icis)
                        {
                            if (i.MimeType == "image/jpeg" || i.MimeType == "image/bmp" || i.MimeType == "image/png" || i.MimeType == "image/gif")
                            {
                                ici = i;
                            }
                        }
                        using (EncoderParameters ep = new EncoderParameters(1))
                        {
                            ep.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)quality);
                            //保存缩略图
                            resultImage.Save(fileSaveUrl, ici, ep);
                            //释放关键质量控制所用资源
                            ep.Dispose();
                        }
                        //释放缩略图资源
                        resultG.Dispose();
                    }
                    resultImage.Dispose();
                }
                //释放原始图片资源
                initImage.Dispose();
            }
        }
        /// <summary>
        /// 指定长宽裁剪(按模版比例最大范围的裁剪图片并缩放至模版尺寸)
        /// </summary>
        /// <param name="fromFile">原图Stream对象</param>
        /// <param name="fileSaveUrl">保存路径</param>
        /// <param name="maxWidth">最大宽(单位:px)</param>
        /// <param name="maxHeight">最大高(单位:px)</param>
        /// <param name="quality">质量（范围0-100）</param>
        public static void CutForCustom(System.IO.Stream fromFile, string fileSaveUrl, int maxWidth, int maxHeight, int quality)
        {
            //从文件获取原始图片，并使用流中嵌入的颜色管理信息
            using (System.Drawing.Image initImage = System.Drawing.Image.FromStream(fromFile, true))
            {
                CutForCustom(initImage, fileSaveUrl, maxWidth, maxHeight, quality);
            }
        }

        /// <summary>
        /// 按模版比例最大范围的裁剪图片并缩放至模版尺寸
        /// </summary>
        /// <param name="initImage">原始图片</param>
        /// <param name="fileSaveUrl">要保存的路径</param>
        /// <param name="maxWidth">最大宽度px</param>
        /// <param name="maxHeight">最大高度px</param>
        /// <param name="quality">图片质量（范围0-100）</param>
        public static void CutForCustom(System.Drawing.Image initImage, string fileSaveUrl, int maxWidth, int maxHeight, int quality, float dpi = 96)
        {
            //原图宽高均小于模版，不作处理，直接保存
            if (initImage.Width <= maxWidth && initImage.Height <= maxHeight)
                initImage.Save(fileSaveUrl, System.Drawing.Imaging.ImageFormat.Jpeg);
            else
            {
                //模版的宽高比例
                double templateRate = (double)maxWidth / maxHeight;
                //原图片的宽高比例
                double initRate = (double)initImage.Width / initImage.Height;
                Bitmap templateImage = new System.Drawing.Bitmap(maxWidth, maxHeight); //按模版大小生成最终图片
                templateImage.SetResolution(dpi, dpi);
                //原图与模版比例相等，直接缩放
                if (templateRate == initRate)
                {
                    System.Drawing.Graphics templateG = System.Drawing.Graphics.FromImage(templateImage);
                    templateG.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.High;
                    templateG.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
                    templateG.Clear(Color.White);
                    templateG.DrawImage(initImage, new System.Drawing.Rectangle(0, 0, maxWidth, maxHeight), new System.Drawing.Rectangle(0, 0, initImage.Width, initImage.Height), System.Drawing.GraphicsUnit.Pixel);
                    templateImage.Save(fileSaveUrl, System.Drawing.Imaging.ImageFormat.Jpeg);
                }
                //原图与模版比例不等，裁剪后缩放
                else
                {
                    //裁剪对象
                    System.Drawing.Image pickedImage = null;
                    System.Drawing.Graphics pickedG = null;
                    //定位
                    Rectangle fromR = new Rectangle(0, 0, 0, 0);//原图裁剪定位
                    Rectangle toR = new Rectangle(0, 0, 0, 0);//目标定位
                                                              //宽为标准进行裁剪
                    if (templateRate > initRate)
                    {
                        //裁剪对象实例化
                        pickedImage = new System.Drawing.Bitmap(initImage.Width, (int)System.Math.Floor(initImage.Width / templateRate));
                        pickedG = System.Drawing.Graphics.FromImage(pickedImage);
                        //裁剪源定位
                        fromR.X = 0;
                        fromR.Y = (int)System.Math.Floor((initImage.Height - initImage.Width / templateRate) / 2);
                        fromR.Width = initImage.Width;
                        fromR.Height = (int)System.Math.Floor(initImage.Width / templateRate);
                        //裁剪目标定位
                        toR.X = 0;
                        toR.Y = 0;
                        toR.Width = initImage.Width;
                        toR.Height = (int)System.Math.Floor(initImage.Width / templateRate);
                    }
                    //高为标准进行裁剪
                    else
                    {
                        pickedImage = new System.Drawing.Bitmap((int)System.Math.Floor(initImage.Height * templateRate), initImage.Height);
                        pickedG = System.Drawing.Graphics.FromImage(pickedImage);
                        fromR.X = (int)System.Math.Floor((initImage.Width - initImage.Height * templateRate) / 2);
                        fromR.Y = 0;
                        fromR.Width = (int)System.Math.Floor(initImage.Height * templateRate);
                        fromR.Height = initImage.Height;
                        toR.X = 0;
                        toR.Y = 0;
                        toR.Width = (int)System.Math.Floor(initImage.Height * templateRate);
                        toR.Height = initImage.Height;
                    }

                    //设置质量
                    pickedG.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                    pickedG.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
                    //裁剪
                    pickedG.DrawImage(initImage, toR, fromR, System.Drawing.GraphicsUnit.Pixel);

                    System.Drawing.Graphics templateG = System.Drawing.Graphics.FromImage(templateImage);
                    templateG.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.High;
                    templateG.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
                    templateG.Clear(Color.White);
                    templateG.DrawImage(pickedImage, new System.Drawing.Rectangle(0, 0, maxWidth, maxHeight), new System.Drawing.Rectangle(0, 0, pickedImage.Width, pickedImage.Height), System.Drawing.GraphicsUnit.Pixel);
                    ////保存缩略图
                    //templateImage.Save(fileSaveUrl, ici, ep);
                    EncoderParameters paras = new EncoderParameters(1);
                    paras.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)quality);
                    templateImage.Save(fileSaveUrl, GetEncoderInfo("image/jpeg"), paras);
                    //释放资源
                    templateG.Dispose();
                    templateImage.Dispose();
                    pickedG.Dispose();
                    pickedImage.Dispose();
                }
            }
        }
        /// <summary>
        /// 图片等比缩放并设置水印
        /// <param name="fromFile">原图Stream对象</param>
        /// <param name="savePath">缩略图存放地址</param>
        /// <param name="targetWidth">指定的最大宽度</param>
        /// <param name="targetHeight">指定的最大高度</param>
        /// <param name="watermarkText">水印文字(为""表示不使用水印)</param>
        /// <param name="watermarkImage">水印图片路径(为""表示不使用水印)</param>
        ///  </summary>
        public static void ZoomAuto(System.IO.Stream fromFile, string savePath, System.Double targetWidth, System.Double targetHeight, string watermarkText, string watermarkImage)
        {
            //创建目录
            string dir = Path.GetDirectoryName(savePath);
            if (!Directory.Exists(dir))
                Directory.CreateDirectory(dir);
            //原始图片（获取原始图片创建对象，并使用流中嵌入的颜色管理信息）
            System.Drawing.Image initImage = System.Drawing.Image.FromStream(fromFile, true);

            //原图宽高均小于模版，不作处理，直接保存
            if (initImage.Width <= targetWidth && initImage.Height <= targetHeight)
            {
                //文字水印
                if (watermarkText != "")
                {
                    using (System.Drawing.Graphics gWater = System.Drawing.Graphics.FromImage(initImage))
                    {
                        System.Drawing.Font fontWater = new Font("黑体", 10);
                        System.Drawing.Brush brushWater = new SolidBrush(Color.White);
                        gWater.DrawString(watermarkText, fontWater, brushWater, 10, 10);
                        gWater.Dispose();
                    }
                }
                //透明图片水印
                if (watermarkImage != "")
                {
                    if (File.Exists(watermarkImage))
                    {
                        //获取水印图片
                        using (System.Drawing.Image wrImage = System.Drawing.Image.FromFile(watermarkImage))
                        {
                            //水印绘制条件：原始图片宽高均大于或等于水印图片
                            if (initImage.Width >= wrImage.Width && initImage.Height >= wrImage.Height)
                            {
                                Graphics gWater = Graphics.FromImage(initImage);

                                //透明属性
                                ImageAttributes imgAttributes = new ImageAttributes();
                                ColorMap colorMap = new ColorMap();
                                colorMap.OldColor = Color.FromArgb(255, 0, 255, 0);
                                colorMap.NewColor = Color.FromArgb(0, 0, 0, 0);
                                ColorMap[] remapTable = { colorMap };
                                imgAttributes.SetRemapTable(remapTable, ColorAdjustType.Bitmap);

                                float[][] colorMatrixElements = {
                            new float[] {1.0f,  0.0f,  0.0f,  0.0f, 0.0f},
                            new float[] {0.0f,  1.0f,  0.0f,  0.0f, 0.0f},
                            new float[] {0.0f,  0.0f,  1.0f,  0.0f, 0.0f},
                            new float[] {0.0f,  0.0f,  0.0f,  0.5f, 0.0f},//透明度:0.5
                            new float[] {0.0f,  0.0f,  0.0f,  0.0f, 1.0f}
                        };

                                ColorMatrix wmColorMatrix = new ColorMatrix(colorMatrixElements);
                                imgAttributes.SetColorMatrix(wmColorMatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
                                gWater.DrawImage(wrImage, new Rectangle(initImage.Width - wrImage.Width, initImage.Height - wrImage.Height, wrImage.Width, wrImage.Height), 0, 0, wrImage.Width, wrImage.Height, GraphicsUnit.Pixel, imgAttributes);

                                gWater.Dispose();
                            }
                            wrImage.Dispose();
                        }
                    }
                }

                //保存
                initImage.Save(savePath, System.Drawing.Imaging.ImageFormat.Jpeg);
            }
            else
            {
                //缩略图宽、高计算
                double newWidth = initImage.Width;
                double newHeight = initImage.Height;
                //宽大于高或宽等于高（横图或正方）
                if (initImage.Width > initImage.Height || initImage.Width == initImage.Height)
                {
                    //如果宽大于模版
                    if (initImage.Width > targetWidth)
                    {
                        //宽按模版，高按比例缩放
                        newWidth = targetWidth;
                        newHeight = initImage.Height * (targetWidth / initImage.Width);
                    }
                }
                //高大于宽（竖图）
                else
                {
                    //如果高大于模版
                    if (initImage.Height > targetHeight)
                    {
                        //高按模版，宽按比例缩放
                        newHeight = targetHeight;
                        newWidth = initImage.Width * (targetHeight / initImage.Height);
                    }
                }
                //生成新图
                //新建一个bmp图片
                System.Drawing.Image newImage = new System.Drawing.Bitmap((int)newWidth, (int)newHeight);
                //新建一个画板
                System.Drawing.Graphics newG = System.Drawing.Graphics.FromImage(newImage);
                //设置质量
                newG.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                newG.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
                //置背景色
                newG.Clear(Color.White);
                //画图
                newG.DrawImage(initImage, new System.Drawing.Rectangle(0, 0, newImage.Width, newImage.Height), new System.Drawing.Rectangle(0, 0, initImage.Width, initImage.Height), System.Drawing.GraphicsUnit.Pixel);

                //文字水印
                if (watermarkText != "")
                {
                    using (System.Drawing.Graphics gWater = System.Drawing.Graphics.FromImage(newImage))
                    {
                        System.Drawing.Font fontWater = new Font("宋体", 10);
                        System.Drawing.Brush brushWater = new SolidBrush(Color.White);
                        gWater.DrawString(watermarkText, fontWater, brushWater, 10, 10);
                        gWater.Dispose();
                    }
                }

                //透明图片水印
                if (watermarkImage != "")
                {
                    if (File.Exists(watermarkImage))
                    {
                        //获取水印图片
                        using (System.Drawing.Image wrImage = System.Drawing.Image.FromFile(watermarkImage))
                        {
                            //水印绘制条件：原始图片宽高均大于或等于水印图片
                            if (newImage.Width >= wrImage.Width && newImage.Height >= wrImage.Height)
                            {
                                Graphics gWater = Graphics.FromImage(newImage);

                                //透明属性
                                ImageAttributes imgAttributes = new ImageAttributes();
                                ColorMap colorMap = new ColorMap();
                                colorMap.OldColor = Color.FromArgb(255, 0, 255, 0);
                                colorMap.NewColor = Color.FromArgb(0, 0, 0, 0);
                                ColorMap[] remapTable = { colorMap };
                                imgAttributes.SetRemapTable(remapTable, ColorAdjustType.Bitmap);

                                float[][] colorMatrixElements = {
                            new float[] {1.0f,  0.0f,  0.0f,  0.0f, 0.0f},
                            new float[] {0.0f,  1.0f,  0.0f,  0.0f, 0.0f},
                            new float[] {0.0f,  0.0f,  1.0f,  0.0f, 0.0f},
                            new float[] {0.0f,  0.0f,  0.0f,  0.5f, 0.0f},//透明度:0.5
                            new float[] {0.0f,  0.0f,  0.0f,  0.0f, 1.0f}
                        };

                                ColorMatrix wmColorMatrix = new ColorMatrix(colorMatrixElements);
                                imgAttributes.SetColorMatrix(wmColorMatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
                                gWater.DrawImage(wrImage, new Rectangle(newImage.Width - wrImage.Width, newImage.Height - wrImage.Height, wrImage.Width, wrImage.Height), 0, 0, wrImage.Width, wrImage.Height, GraphicsUnit.Pixel, imgAttributes);
                                gWater.Dispose();
                            }
                            wrImage.Dispose();
                        }
                    }
                }
                //保存缩略图
                newImage.Save(savePath, System.Drawing.Imaging.ImageFormat.Jpeg);
                //释放资源
                newG.Dispose();
                newImage.Dispose();
                initImage.Dispose();
            }
        }
        /// <summary>
        /// 截取源图中指定部分区域的图片，并存储为指定的文件。
        /// </summary>
        /// <param name="sourceFileName">源图地址</param>
        /// <param name="saveFilePath">区域图的地址</param>
        /// <param name="width">截取图片的宽度</param>
        /// <param name="height">截取图片的高度</param>
        /// <param name="offsetX">开始截取图片的X坐标</param>
        /// <param name="offsetY">开始截取图片的Y坐标</param>
        /// <param name="qu">保存质量</param>
        /// <param name="xdpi">横向dpi值</param>
        /// <param name="ydpi">纵向dpi值</param>
        public static void SavePartOfImageRec(string sourceFileName, string saveFilePath, int width, int height, int offsetX, int offsetY, int qu = 100, int xdpi = 96, int ydpi = 96)
        {
            using (Bitmap sourceBitmap = new Bitmap(sourceFileName))
            {
                using (Bitmap resultBitmap = new Bitmap(width, height))
                {
                    resultBitmap.SetResolution(xdpi, ydpi);
                    using (Graphics g = Graphics.FromImage(resultBitmap))
                    {
                        Rectangle resultRectangle = new Rectangle(0, 0, width, height);
                        Rectangle sourceRectangle = new Rectangle(0 + offsetX, 0 + offsetY, sourceBitmap.Width, sourceBitmap.Height);
                        g.DrawImage(sourceBitmap, resultRectangle, sourceRectangle, GraphicsUnit.Pixel);
                    }
                    EncoderParameters paras = new EncoderParameters(1);
                    paras.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)qu);
                    resultBitmap.Save(saveFilePath, GetEncoderInfo("image/jpeg"), paras);
                }
            }
        }
        /// <summary>
        /// 获取一张图片的指定部分，在一个指定位置画一个要截取的图像       
        /// </summary>
        /// <param name="sourceFileName">原始图片路径名称</param>
        /// <param name="width">截取图片的宽度</param>
        /// <param name="height">截取图片的高度</param>
        /// <param name="offsetX">开始截取图片的X坐标</param>
        /// <param name="offsetY">开始截取图片的Y坐标</param>
        /// <returns>指定部分转换成的字节数组</returns>
        /// <param name="qu">保存质量</param>
        /// <param name="xdpi">横向dpi值</param>
        /// <param name="ydpi">纵向dpi值</param>
        public static byte[] GetPartOfImageRec(string sourceFileName, int width, int height, int offsetX, int offsetY, int qu = 100, int xdpi = 96, int ydpi = 96)
        {
            MemoryStream ms = new MemoryStream();
            using (Bitmap sourceBitmap = new Bitmap(sourceFileName))
            {
                using (Bitmap resultBitmap = new Bitmap(width, height))
                {
                    resultBitmap.SetResolution(xdpi, ydpi);
                    using (Graphics g = Graphics.FromImage(resultBitmap))
                    {
                        Rectangle resultRectangle = new Rectangle(0, 0, width, height);
                        Rectangle sourceRectangle = new Rectangle(0 + offsetX, 0 + offsetY, sourceBitmap.Width, sourceBitmap.Height);
                        g.DrawImage(sourceBitmap, resultRectangle, sourceRectangle, GraphicsUnit.Pixel);
                    }
                    EncoderParameters paras = new EncoderParameters(1);
                    paras.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)qu);
                    resultBitmap.Save(ms, GetEncoderInfo("image/jpeg"), paras);
                }
            }
            return ms.ToArray();
        }

        /// <summary>
        /// 设置图形颜色  边缘的色彩更换成新的颜色
        /// </summary>
        /// <param name="p_Image">图片</param>
        /// <param name="p_OldColor">老的边缘色彩</param>
        /// <param name="p_NewColor">新的边缘色彩</param>
        /// <param name="p_Float">溶差</param>
        /// <returns>清理后的图形</returns>
        public static Image SetImageColorBrim(Image p_Image, Color p_OldColor, Color p_NewColor, int p_Float)
        {
            int _Width = p_Image.Width;
            int _Height = p_Image.Height;

            Bitmap _NewBmp = new Bitmap(_Width, _Height, PixelFormat.Format32bppArgb);
            Graphics _Graphics = Graphics.FromImage(_NewBmp);
            _Graphics.DrawImage(p_Image, new Rectangle(0, 0, _Width, _Height));
            _Graphics.Dispose();

            BitmapData _Data = _NewBmp.LockBits(new Rectangle(0, 0, _Width, _Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
            _Data.PixelFormat = PixelFormat.Format32bppArgb;
            int _ByteSize = _Data.Stride * _Height;
            byte[] _DataBytes = new byte[_ByteSize];
            Marshal.Copy(_Data.Scan0, _DataBytes, 0, _ByteSize);

            int _Index = 0;
            #region 列
            for (int z = 0; z != _Height; z++)
            {
                _Index = z * _Data.Stride;
                for (int i = 0; i != _Width; i++)
                {
                    Color _Color = Color.FromArgb(_DataBytes[_Index + 3], _DataBytes[_Index + 2], _DataBytes[_Index + 1], _DataBytes[_Index]);

                    if (ScanColor(_Color, p_OldColor, p_Float))
                    {
                        _DataBytes[_Index + 3] = (byte)p_NewColor.A;
                        _DataBytes[_Index + 2] = (byte)p_NewColor.R;
                        _DataBytes[_Index + 1] = (byte)p_NewColor.G;
                        _DataBytes[_Index] = (byte)p_NewColor.B;
                        _Index += 4;
                    }
                    else
                    {
                        break;
                    }
                }
                _Index = (z + 1) * _Data.Stride;
                for (int i = 0; i != _Width; i++)
                {
                    Color _Color = Color.FromArgb(_DataBytes[_Index - 1], _DataBytes[_Index - 2], _DataBytes[_Index - 3], _DataBytes[_Index - 4]);

                    if (ScanColor(_Color, p_OldColor, p_Float))
                    {
                        _DataBytes[_Index - 1] = (byte)p_NewColor.A;
                        _DataBytes[_Index - 2] = (byte)p_NewColor.R;
                        _DataBytes[_Index - 3] = (byte)p_NewColor.G;
                        _DataBytes[_Index - 4] = (byte)p_NewColor.B;
                        _Index -= 4;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            #endregion

            #region 行

            for (int i = 0; i != _Width; i++)
            {
                _Index = i * 4;
                for (int z = 0; z != _Height; z++)
                {
                    Color _Color = Color.FromArgb(_DataBytes[_Index + 3], _DataBytes[_Index + 2], _DataBytes[_Index + 1], _DataBytes[_Index]);
                    if (ScanColor(_Color, p_OldColor, p_Float))
                    {
                        _DataBytes[_Index + 3] = (byte)p_NewColor.A;
                        _DataBytes[_Index + 2] = (byte)p_NewColor.R;
                        _DataBytes[_Index + 1] = (byte)p_NewColor.G;
                        _DataBytes[_Index] = (byte)p_NewColor.B;
                        _Index += _Data.Stride;
                    }
                    else
                    {
                        break;
                    }
                }
                _Index = (i * 4) + ((_Height - 1) * _Data.Stride);
                for (int z = 0; z != _Height; z++)
                {
                    Color _Color = Color.FromArgb(_DataBytes[_Index + 3], _DataBytes[_Index + 2], _DataBytes[_Index + 1], _DataBytes[_Index]);
                    if (ScanColor(_Color, p_OldColor, p_Float))
                    {
                        _DataBytes[_Index + 3] = (byte)p_NewColor.A;
                        _DataBytes[_Index + 2] = (byte)p_NewColor.R;
                        _DataBytes[_Index + 1] = (byte)p_NewColor.G;
                        _DataBytes[_Index] = (byte)p_NewColor.B;
                        _Index -= _Data.Stride;
                    }
                    else
                    {
                        break;
                    }
                }
            }


            #endregion
            Marshal.Copy(_DataBytes, 0, _Data.Scan0, _ByteSize);
            _NewBmp.UnlockBits(_Data);
            return _NewBmp;
        }
        /// <summary>
        /// 设置图形颜色  所有的色彩更换成新的颜色
        /// </summary>
        /// <param name="p_Image">图片</param>
        /// <param name="p_OdlColor">老的颜色</param>
        /// <param name="p_NewColor">新的颜色</param>
        /// <param name="p_Float">溶差</param>
        /// <returns>清理后的图形</returns>
        public static Image SetImageColorAll(Image p_Image, Color p_OdlColor, Color p_NewColor, int p_Float)
        {
            int _Width = p_Image.Width;
            int _Height = p_Image.Height;

            Bitmap _NewBmp = new Bitmap(_Width, _Height, PixelFormat.Format32bppArgb);
            Graphics _Graphics = Graphics.FromImage(_NewBmp);
            _Graphics.DrawImage(p_Image, new Rectangle(0, 0, _Width, _Height));
            _Graphics.Dispose();

            BitmapData _Data = _NewBmp.LockBits(new Rectangle(0, 0, _Width, _Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
            _Data.PixelFormat = PixelFormat.Format32bppArgb;
            int _ByteSize = _Data.Stride * _Height;
            byte[] _DataBytes = new byte[_ByteSize];
            Marshal.Copy(_Data.Scan0, _DataBytes, 0, _ByteSize);

            int _WhileCount = _Width * _Height;
            int _Index = 0;
            for (int i = 0; i != _WhileCount; i++)
            {
                Color _Color = Color.FromArgb(_DataBytes[_Index + 3], _DataBytes[_Index + 2], _DataBytes[_Index + 1], _DataBytes[_Index]);
                if (ScanColor(_Color, p_OdlColor, p_Float))
                {
                    _DataBytes[_Index + 3] = (byte)p_NewColor.A;
                    _DataBytes[_Index + 2] = (byte)p_NewColor.R;
                    _DataBytes[_Index + 1] = (byte)p_NewColor.G;
                    _DataBytes[_Index] = (byte)p_NewColor.B;
                }
                _Index += 4;
            }
            Marshal.Copy(_DataBytes, 0, _Data.Scan0, _ByteSize);
            _NewBmp.UnlockBits(_Data);
            return _NewBmp;
        }
        /// <summary>
        /// 设置图形颜色  坐标的颜色更换成新的色彩 （漏斗）
        /// </summary>
        /// <param name="p_Image">新图形</param>
        /// <param name="p_Point">位置</param>
        /// <param name="p_NewColor">新的色彩</param>
        /// <param name="p_Float">溶差</param>
        /// <returns>清理后的图形</returns>
        public static Image SetImageColorPoint(Image p_Image, Point p_Point, Color p_NewColor, int p_Float)
        {
            int _Width = p_Image.Width;
            int _Height = p_Image.Height;

            if (p_Point.X > _Width - 1) return p_Image;
            if (p_Point.Y > _Height - 1) return p_Image;

            Bitmap _SS = (Bitmap)p_Image;
            Color _Scolor = _SS.GetPixel(p_Point.X, p_Point.Y);//获取指定坐标的颜色
                                                               //创建一个空位图，将源图绘制到此位图中
            Bitmap _NewBmp = new Bitmap(_Width, _Height, PixelFormat.Format32bppArgb);
            Graphics _Graphics = Graphics.FromImage(_NewBmp);
            _Graphics.DrawImage(p_Image, new Rectangle(0, 0, _Width, _Height));
            _Graphics.Dispose();

            BitmapData _Data = _NewBmp.LockBits(new Rectangle(0, 0, _Width, _Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
            _Data.PixelFormat = PixelFormat.Format32bppArgb;
            int _ByteSize = _Data.Stride * _Height;
            byte[] _DataBytes = new byte[_ByteSize];
            Marshal.Copy(_Data.Scan0, _DataBytes, 0, _ByteSize);


            int _Index = (p_Point.Y * _Data.Stride) + (p_Point.X * 4);

            Color _OldColor = Color.FromArgb(_DataBytes[_Index + 3], _DataBytes[_Index + 2], _DataBytes[_Index + 1], _DataBytes[_Index]);

            if (_OldColor.Equals(p_NewColor)) return p_Image;
            Stack<Point> _ColorStack = new Stack<Point>(1000);
            _ColorStack.Push(p_Point);

            _DataBytes[_Index + 3] = (byte)p_NewColor.A;
            _DataBytes[_Index + 2] = (byte)p_NewColor.R;
            _DataBytes[_Index + 1] = (byte)p_NewColor.G;
            _DataBytes[_Index] = (byte)p_NewColor.B;

            do
            {
                Point _NewPoint = (Point)_ColorStack.Pop();

                if (_NewPoint.X > 0) SetImageColorPoint(_DataBytes, _Data.Stride, _ColorStack, _NewPoint.X - 1, _NewPoint.Y, _OldColor, p_NewColor, p_Float);
                if (_NewPoint.Y > 0) SetImageColorPoint(_DataBytes, _Data.Stride, _ColorStack, _NewPoint.X, _NewPoint.Y - 1, _OldColor, p_NewColor, p_Float);

                if (_NewPoint.X < _Width - 1) SetImageColorPoint(_DataBytes, _Data.Stride, _ColorStack, _NewPoint.X + 1, _NewPoint.Y, _OldColor, p_NewColor, p_Float);
                if (_NewPoint.Y < _Height - 1) SetImageColorPoint(_DataBytes, _Data.Stride, _ColorStack, _NewPoint.X, _NewPoint.Y + 1, _OldColor, p_NewColor, p_Float);

            }
            while (_ColorStack.Count > 0);

            Marshal.Copy(_DataBytes, 0, _Data.Scan0, _ByteSize);
            _NewBmp.UnlockBits(_Data);
            return _NewBmp;
        }
        /// <summary>
        /// SetImageColorPoint 循环调用 检查新的坐标是否符合条件 符合条件会写入栈p_ColorStack 并更改颜色
        /// </summary>
        /// <param name="p_DataBytes">数据区</param>
        /// <param name="p_Stride">行扫描字节数</param>
        /// <param name="p_ColorStack">需要检查的位置栈</param>
        /// <param name="p_X">位置X</param>
        /// <param name="p_Y">位置Y</param>
        /// <param name="p_OldColor">老色彩</param>
        /// <param name="p_NewColor">新色彩</param>
        /// <param name="p_Float">溶差</param>
        private static void SetImageColorPoint(byte[] p_DataBytes, int p_Stride, Stack<Point> p_ColorStack, int p_X, int p_Y, Color p_OldColor, Color p_NewColor, int p_Float)
        {

            int _Index = (p_Y * p_Stride) + (p_X * 4);
            Color _OldColor = Color.FromArgb(p_DataBytes[_Index + 3], p_DataBytes[_Index + 2], p_DataBytes[_Index + 1], p_DataBytes[_Index]);

            if (ScanColor(_OldColor, p_OldColor, p_Float))
            {
                p_ColorStack.Push(new Point(p_X, p_Y));

                p_DataBytes[_Index + 3] = (byte)p_NewColor.A;
                p_DataBytes[_Index + 2] = (byte)p_NewColor.R;
                p_DataBytes[_Index + 1] = (byte)p_NewColor.G;
                p_DataBytes[_Index] = (byte)p_NewColor.B;
            }
        }

        /// <summary>
        /// 检查色彩(可以根据这个更改比较方式
        /// </summary>
        /// <param name="p_CurrentlyColor">当前色彩</param>
        /// <param name="p_CompareColor">比较色彩</param>
        /// <param name="p_Float">溶差</param>
        /// <returns></returns>
        private static bool ScanColor(Color p_CurrentlyColor, Color p_CompareColor, int p_Float)
        {
            int _R = p_CurrentlyColor.R;
            int _G = p_CurrentlyColor.G;
            int _B = p_CurrentlyColor.B;
            return (_R <= p_CompareColor.R + p_Float && _R >= p_CompareColor.R - p_Float) && (_G <= p_CompareColor.G + p_Float && _G >= p_CompareColor.G - p_Float) && (_B <= p_CompareColor.B + p_Float && _B >= p_CompareColor.B - p_Float);
        }
    }
}

4.序列化工具类

using System;
using System.Collections.Generic;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using System.Xml.Serialization;

namespace Utilities
{
    /// <summary>
    /// 序列化工具类
    /// </summary>
    public static class IoHelper
    {
        //是否已经加载了JPEG编码解码器
        private static bool _isloadjpegcodec = false;
        //当前系统安装的JPEG编码解码器
        private static ImageCodecInfo _jpegcodec = null;

        /// <summary>
        /// 获得文件物理路径
        /// </summary>
        /// <returns></returns>
        public static string GetMapPath(string path)
        {
            if (HttpContext.Current != null)
            {
                return HttpContext.Current.Server.MapPath(path);
            }
            return System.Web.Hosting.HostingEnvironment.MapPath(path);
        }

        #region Xml部分
        /// <summary>
        /// 序列化任意对象（XML）
        /// </summary>
        /// <param name="obj">要序列化的对象</param>
        /// <returns>序列化后的 XML 字符串</returns>
        public static string SerializeXml(object obj)
        {
            XmlSerializer xml = new XmlSerializer(obj.GetType());
            MemoryStream ms = new MemoryStream();
            xml.Serialize(ms, obj);
            byte[] tmpBytes = ms.ToArray();
            ms.Close();
            return System.Text.Encoding.UTF8.GetString(tmpBytes);
        }
        /// <summary>
        /// 反序列化任意对象（XML）
        /// </summary>
        /// <param name="xmlString">XML字符串</param>
        /// <returns>反序列化后的对象</returns>
        public static T DeSerializeXml<T>(string xmlString)
        {
            byte[] tmpBytes = System.Text.Encoding.Default.GetBytes(xmlString);
            MemoryStream ms = new MemoryStream(tmpBytes);
            ms.Position = 0;
            XmlSerializer xml = new XmlSerializer(typeof(T));
            T obj = (T)xml.Deserialize(ms);
            ms.Close();
            return obj;
        }
        #endregion

        #region Json部分
        /// <summary>
        /// 将obj对象序列化成JSON字符串
        /// </summary>
        /// <param name="obj">对象</param>
        /// <returns>JSON字符串</returns>
        public static string SerializeJson(Object obj)
        {
            string json = "";
            DataContractJsonSerializer ser = new DataContractJsonSerializer(obj.GetType());
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
            {
                ser.WriteObject(ms, obj);
                json = System.Text.Encoding.UTF8.GetString(ms.ToArray());
            }
            return json;
        }
        /// <summary>
        /// 将JSON字符串序反列化为指定T型的对象
        /// </summary>
        /// <typeparam name="T">目标类型</typeparam>
        /// <param name="json">json字符串</param>
        /// <returns>T类型的对象</returns>
        public static T DeSerializeJson<T>(string json)
        {
            System.Text.UTF8Encoding utf = new System.Text.UTF8Encoding();

            DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
            using (System.IO.MemoryStream s = new System.IO.MemoryStream(utf.GetBytes(json)))
            {
                return (T)ser.ReadObject(s);
            }
        }
        #endregion

        #region IO部分
        /// <summary>
        /// 将指定对象obj序列化到文件fn中
        /// </summary>
        /// <param name="fn">文件路径</param>
        /// <param name="obj">对象</param>
        public static void Serialize(string fn, object obj)
        {
            BinaryFormatter bf = new BinaryFormatter();
            using (FileStream fs = new FileStream(fn, FileMode.OpenOrCreate, FileAccess.Write))
            {
                bf.Serialize(fs, obj);
            }
        }
        /// <summary>
        /// 从文件fn中反序列出类型为T的对象
        /// </summary>
        /// <typeparam name="T">返回的对象类型</typeparam>
        /// <param name="fn">文件名称</param>
        /// <returns>对象</returns>
        public static T DeSerialize<T>(string fn)
        {
            BinaryFormatter bf = new BinaryFormatter();
            using (FileStream fs = new FileStream(fn, FileMode.OpenOrCreate, FileAccess.Read))
            {
                return (T)bf.Deserialize(fs);
            }
        }
        /// <summary>
        /// 获取指定对象的深度克隆对象
        /// </summary>
        /// <typeparam name="T">被克隆者类型</typeparam>
        /// <param name="obj">被克隆者</param>
        /// <returns>克隆出来的对象</returns>
        public static T Clone<T>(T obj)
        {
            BinaryFormatter bf = new BinaryFormatter();
            using (MemoryStream ms = new MemoryStream())
            {
                bf.Serialize(ms, obj);
                ms.Position = 0;
                return (T)bf.Deserialize(ms);
            }
        }
        #endregion
    }
}

5.封装NLog组件进行日志管理类

using NLog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Utilities
{
    /// <summary>
    /// 封装NLog组件进行日志管理
    /// </summary>
    public class LogHelper
    {
        NLog.Logger logger;
        /// <summary>
        /// 私有构造方法，只给当前类的其他构造方法调用
        /// </summary>
        /// <param name="logger"></param>
        private LogHelper(NLog.Logger logger)
        {
            this.logger = logger;
        }
        /// <summary>
        /// 通过指定的名称来创建日志对象
        /// </summary>
        /// <param name="name"></param>
        public LogHelper(string name): this(NLog.LogManager.GetLogger(name)){ }
        /// <summary>
        /// 提供1个默认的静态使用方式，例如：LogHelper.Default.Info("info");
        /// </summary>
        public static LogHelper Default { get; private set; }
        /// <summary>
        /// 私有的静态构造方法，初始化Default对象
        /// </summary>
        static LogHelper()
        {
            Default = new LogHelper(NLog.LogManager.GetCurrentClassLogger());
        }
        /// <summary>
        /// Trace等级写日志
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="args">其他参数</param>
        public void Trace(string msg, params object[] args)
        {
            logger.Trace(msg, args);
        }
        /// <summary>
        /// Trace等级写日志
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="err">需要记录的异常信息</param>
        public void Trace(string msg, Exception err)
        {
            logger.Trace(err, msg);
        }
        /// <summary>
        /// Debug等级写日志
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="args">其他参数</param>
        public void Debug(string msg, params object[] args)
        {
            logger.Debug(msg, args);
        }
        /// <summary>
        /// Debug等级写日志
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="err">需要记录的异常信息</param>
        public void Debug(string msg, Exception err)
        {
            logger.Debug( err, msg);
        }
        /// <summary>
        /// Info等级写日志
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="args">其他参数</param>
        public void Info(string msg, params object[] args)
        {
            logger.Info(msg, args);
        }
        /// <summary>
        /// Info等级写日志
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="err">需要记录的异常信息</param>
        public void Info(string msg, Exception err)
        {
            logger.Info(err, msg);
        }
        /// <summary>
        /// Warn等级写日志
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="args">其他参数</param>
        public void Warn(string msg, params object[] args)
        {
            logger.Warn(msg, args);
        }
        /// <summary>
        /// Warn等级写日志
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="err">需要记录的异常信息</param>
        public void Warn(string msg, Exception err)
        {
            logger.Warn(err, msg);
        }
        /// <summary>
        /// Error等级写日志
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="args">其他参数</param>
        public void Error(string msg, params object[] args)
        {
            logger.Error(msg, args);
        }
        /// <summary>
        /// Error等级写日志
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="err">需要记录的异常信息</param>
        public void Error(string msg, Exception err)
        {
            logger.Error(err, msg);
        }
        /// <summary>
        /// Fatal等级写日志
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="args">其他参数</param>
        public void Fatal(string msg, params object[] args)
        {
            logger.Fatal(msg, args);
        }
        /// <summary>
        /// Fatal等级写日志
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="err">需要记录的异常信息</param>
        public void Fatal(string msg, Exception err)
        {
            logger.Fatal(err, msg);
        }
    }
}

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.nlog-project.org/schemas/NLog.xsd NLog.xsd"
      autoReload="true"
      throwExceptions="false"
      internalLogLevel="Off" internalLogFile="c:\temp\nlog-internal.log">

  <!-- optional, add some variables
  https://github.com/nlog/NLog/wiki/Configuration-file#variables
  -->
  <variable name="myvar" value="myvalue"/>

  <!--
  See https://github.com/nlog/nlog/wiki/Configuration-file
  for information on customizing logging rules and outputs.
   -->
  <targets>
    <!--
    add your targets here
    See https://github.com/nlog/NLog/wiki/Targets for possible targets.
    See https://github.com/nlog/NLog/wiki/Layout-Renderers for the possible layout renderers.
    -->
    <!--
    Write events to a file with the date in the filename. -->
    <target name="debugger" xsi:type="Debugger" layout="${date:format=HH\:mm\:ss.fff}: ${message}" />
    <target name="error_file" xsi:type="File" fileName="${basedir}/logs/${shortdate}.log"
            layout="时间：${longdate} 级别：${uppercase:${level}} 信息：${message} 异常：${exception}" 
            encoding="UTF-8"/>
    <target name="f" xsi:type="File" fileName="${basedir}/logs/${shortdate}.txt"
            layout="时间：${longdate} 级别：${uppercase:${level}} 信息：${message} 异常：${exception}" 
            encoding="UTF-8" />
  </targets>
  <rules>
    <!-- add your logging rules here -->    
    <!--Write all events with minimal level of Debug (So Debug, Info, Warn, 
        Error and Fatal, but not Trace)  to "f"-->
    <logger name="logAll" writeTo="f" minlevel="Debug" />
    <logger name="*" writeTo="debugger" />
    <logger name="*" minlevel="Error" writeTo="error_file" />
  </rules>
</nlog>

<?xml version="1.0" encoding="utf-8"?>
<xs:schema id="NLog" targetNamespace="http://www.nlog-project.org/schemas/NLog.xsd" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://www.nlog-project.org/schemas/NLog.xsd">
  <xs:element name="nlog" type="NLogConfiguration" />
  <xs:complexType name="NLogConfiguration">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="extensions" type="NLogExtensions" />
      <xs:element name="include" type="NLogInclude" />
      <xs:element name="variable" type="NLogVariable" />
      <xs:element name="targets" type="NLogTargets" />
      <xs:element name="rules" type="NLogRules" />
      <xs:element name="time" type="TimeSource" />
    </xs:choice>
    <xs:attribute name="autoReload" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Watch config file for changes and reload automatically.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="internalLogToConsole" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Print internal NLog messages to the console. Default value is: false</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="internalLogToConsoleError" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Print internal NLog messages to the console error output. Default value is: false</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="internalLogFile" type="xs:string">
      <xs:annotation>
        <xs:documentation>Write internal NLog messages to the specified file.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="internalLogLevel" type="NLogLevel">
      <xs:annotation>
        <xs:documentation>Log level threshold for internal log messages. Default value is: Info.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="globalThreshold" type="NLogLevel">
      <xs:annotation>
        <xs:documentation>Global log level threshold for application log messages. Messages below this level won't be logged..</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="throwExceptions" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Throw an exception when there is an internal error. Default value is: false.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="throwConfigExceptions" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Throw an exception when there is a configuration error. If not set, determined by throwExceptions.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="keepVariablesOnReload" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Gets or sets a value indicating whether Variables should be kept on configuration reload. Default value is: false.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="internalLogToTrace" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Write internal NLog messages to the System.Diagnostics.Trace. Default value is: false.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="internalLogIncludeTimestamp" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Write timestamps for internal NLog messages. Default value is: true.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="useInvariantCulture" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Use InvariantCulture as default culture instead of CurrentCulture.  Default value is: false.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="parseMessageTemplates" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Perform mesage template parsing and formatting of LogEvent messages (true = Always, false = Never, empty = Auto Detect). Default value is: empty.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="NLogTargets">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="default-wrapper" type="WrapperTargetBase" />
      <xs:element name="default-target-parameters" type="Target" />
      <xs:element name="target" type="Target" />
      <xs:element name="wrapper-target" type="WrapperTargetBase" />
      <xs:element name="compound-target" type="CompoundTargetBase" />
    </xs:choice>
    <xs:attribute name="async" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Make all targets within this section asynchronous (creates additional threads but the calling thread isn't blocked by any target writes).</xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="NLogRules">
    <xs:sequence minOccurs="0" maxOccurs="unbounded">
      <xs:element name="logger" type="NLogLoggerRule" />
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="NLogExtensions">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="add" type="NLogExtensionsAdd" />
    </xs:choice>
  </xs:complexType>
  <xs:complexType name="NLogExtensionsAdd">
    <xs:attribute name="prefix" type="xs:string">
      <xs:annotation>
        <xs:documentation>Prefix for targets/layout renderers/filters/conditions loaded from this assembly.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="assemblyFile" type="xs:string">
      <xs:annotation>
        <xs:documentation>Load NLog extensions from the specified file (*.dll)</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="assembly" type="xs:string">
      <xs:annotation>
        <xs:documentation>Load NLog extensions from the specified assembly. Assembly name should be fully qualified.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="NLogLoggerRule">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="filters" type="NLogFilters" />
    </xs:choice>
    <xs:attribute name="name" use="optional">
      <xs:annotation>
        <xs:documentation>Name of the logger. May include '*' character which acts like a wildcard. Allowed forms are: *, Name, *Name, Name* and *Name*</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="levels" type="NLogLevelList">
      <xs:annotation>
        <xs:documentation>Comma separated list of levels that this rule matches.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="minlevel" type="NLogLevel">
      <xs:annotation>
        <xs:documentation>Minimum level that this rule matches.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="maxlevel" type="NLogLevel">
      <xs:annotation>
        <xs:documentation>Maximum level that this rule matches.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="level" type="NLogLevel">
      <xs:annotation>
        <xs:documentation>Level that this rule matches.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="writeTo" type="NLogTargetIDList">
      <xs:annotation>
        <xs:documentation>Comma separated list of target names.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="final" type="xs:boolean" default="false">
      <xs:annotation>
        <xs:documentation>Ignore further rules if this one matches.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="enabled" type="xs:boolean" default="true">
      <xs:annotation>
        <xs:documentation>Enable or disable logging rule. Disabled rules are ignored.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="NLogFilters">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="when" type="when" />
      <xs:element name="whenContains" type="whenContains" />
      <xs:element name="whenEqual" type="whenEqual" />
      <xs:element name="whenNotContains" type="whenNotContains" />
      <xs:element name="whenNotEqual" type="whenNotEqual" />
      <xs:element name="whenRepeated" type="whenRepeated" />
    </xs:choice>
  </xs:complexType>
  <xs:simpleType name="NLogLevel">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Off" />
      <xs:enumeration value="Trace" />
      <xs:enumeration value="Debug" />
      <xs:enumeration value="Info" />
      <xs:enumeration value="Warn" />
      <xs:enumeration value="Error" />
      <xs:enumeration value="Fatal" />
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="LineEndingMode">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Default" />
      <xs:enumeration value="CRLF" />
      <xs:enumeration value="CR" />
      <xs:enumeration value="LF" />
      <xs:enumeration value="None" />
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="NLogLevelList">
    <xs:restriction base="xs:string">
      <xs:pattern value="(|Trace|Debug|Info|Warn|Error|Fatal)(,(Trace|Debug|Info|Warn|Error|Fatal))*" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="NLogInclude">
    <xs:attribute name="file" type="SimpleLayoutAttribute" use="required">
      <xs:annotation>
        <xs:documentation>Name of the file to be included. You could use * wildcard. The name is relative to the name of the current config file.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="ignoreErrors" type="xs:boolean" use="optional" default="false">
      <xs:annotation>
        <xs:documentation>Ignore any errors in the include file.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="NLogVariable">
    <xs:attribute name="name" type="xs:string" use="required">
      <xs:annotation>
        <xs:documentation>Variable name.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="value" type="SimpleLayoutAttribute" use="required">
      <xs:annotation>
        <xs:documentation>Variable value.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:simpleType name="NLogTargetIDList">
    <xs:restriction base="xs:string">
      <xs:pattern value="(|([a-zA-Z][a-zA-Z0-9_\-]*))(,([a-zA-Z][a-zA-Z0-9_\-]*))*" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="Target" abstract="true"></xs:complexType>
  <xs:complexType name="TargetRef">
    <xs:attribute name="name" type="xs:string" use="required" />
  </xs:complexType>
  <xs:complexType name="WrapperTargetBase" abstract="true">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="target" type="Target" minOccurs="1" maxOccurs="1" />
          <xs:element name="wrapper-target" type="WrapperTargetBase" minOccurs="1" maxOccurs="1" />
          <xs:element name="compound-target" type="CompoundTargetBase" minOccurs="1" maxOccurs="1" />
          <xs:element name="target-ref" type="TargetRef" minOccurs="1" maxOccurs="1" />
          <xs:element name="wrapper-target-ref" type="TargetRef" minOccurs="1" maxOccurs="1" />
          <xs:element name="compound-target-ref" type="TargetRef" minOccurs="1" maxOccurs="1" />
        </xs:choice>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="CompoundTargetBase" abstract="true">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="target" type="Target" minOccurs="1" maxOccurs="unbounded" />
          <xs:element name="wrapper-target" type="WrapperTargetBase" minOccurs="1" maxOccurs="1" />
          <xs:element name="compound-target" type="CompoundTargetBase" minOccurs="1" maxOccurs="1" />
          <xs:element name="target-ref" type="TargetRef" minOccurs="1" maxOccurs="1" />
          <xs:element name="wrapper-target-ref" type="TargetRef" minOccurs="1" maxOccurs="1" />
          <xs:element name="compound-target-ref" type="TargetRef" minOccurs="1" maxOccurs="1" />
        </xs:choice>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="Filter" abstract="true"></xs:complexType>
  <xs:complexType name="TimeSource" abstract="true"></xs:complexType>
  <xs:simpleType name="SimpleLayoutAttribute">
    <xs:restriction base="xs:string">
      <xs:pattern value=".*" />
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="Condition">
    <xs:restriction base="xs:string">
      <xs:minLength value="1" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="AsyncWrapper">
    <xs:complexContent>
      <xs:extension base="WrapperTargetBase">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="batchSize" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="fullBatchSizeWriteLimit" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="overflowAction" minOccurs="0" maxOccurs="1" type="NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction" />
          <xs:element name="queueLimit" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="timeToSleepBetweenBatches" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="batchSize" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Number of log events that should be processed in a batch by the lazy writer thread.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="fullBatchSizeWriteLimit" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Limit of full s to write before yielding into  Performance is better when writing many small batches, than writing a single large batch</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="overflowAction" type="NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction">
          <xs:annotation>
            <xs:documentation>Action to be taken when the lazy writer thread request queue count exceeds the set limit.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="queueLimit" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Limit on the number of requests in the lazy writer thread request queue.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="timeToSleepBetweenBatches" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Time in milliseconds to sleep between batches.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:simpleType name="NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Grow" />
      <xs:enumeration value="Discard" />
      <xs:enumeration value="Block" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="AutoFlushWrapper">
    <xs:complexContent>
      <xs:extension base="WrapperTargetBase">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="asyncFlush" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="condition" minOccurs="0" maxOccurs="1" type="Condition" />
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="asyncFlush" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Delay the flush until the LogEvent has been confirmed as written</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="condition" type="Condition">
          <xs:annotation>
            <xs:documentation>Condition expression. Log events who meet this condition will cause a flush on the wrapped target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="BufferingWrapper">
    <xs:complexContent>
      <xs:extension base="WrapperTargetBase">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="bufferSize" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="flushTimeout" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="overflowAction" minOccurs="0" maxOccurs="1" type="NLog.Targets.Wrappers.BufferingTargetWrapperOverflowAction" />
          <xs:element name="slidingTimeout" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="bufferSize" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Number of log events to be buffered.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="flushTimeout" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Timeout (in milliseconds) after which the contents of buffer will be flushed if there's no write in the specified period of time. Use -1 to disable timed flushes.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="overflowAction" type="NLog.Targets.Wrappers.BufferingTargetWrapperOverflowAction">
          <xs:annotation>
            <xs:documentation>Action to take if the buffer overflows.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="slidingTimeout" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to use sliding timeout.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:simpleType name="NLog.Targets.Wrappers.BufferingTargetWrapperOverflowAction">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Flush" />
      <xs:enumeration value="Discard" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="Chainsaw">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="encoding" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="lineEnding" minOccurs="0" maxOccurs="1" type="LineEndingMode" />
          <xs:element name="maxMessageSize" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="newLine" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="onConnectionOverflow" minOccurs="0" maxOccurs="1" type="NLog.Targets.NetworkTargetConnectionsOverflowAction" />
          <xs:element name="maxQueueSize" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="maxConnections" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="keepConnection" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="connectionCacheSize" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="address" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="onOverflow" minOccurs="0" maxOccurs="1" type="NLog.Targets.NetworkTargetOverflowAction" />
          <xs:element name="parameter" minOccurs="0" maxOccurs="unbounded" type="NLog.Targets.NLogViewerParameterInfo" />
          <xs:element name="ndlcItemSeparator" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="ndcItemSeparator" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="includeNLogData" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeSourceInfo" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeNdlc" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeNdc" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeMdlc" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeMdc" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeCallSite" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeAllProperties" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="appInfo" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="loggerName" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="encoding" type="xs:string">
          <xs:annotation>
            <xs:documentation>Encoding to be used.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Instance of  that is used to format log messages.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="lineEnding" type="LineEndingMode">
          <xs:annotation>
            <xs:documentation>End of line value if a newline is appended at the end of log message .</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxMessageSize" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Maximum message size in bytes.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="newLine" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to append newline at the end of log message.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="onConnectionOverflow" type="NLog.Targets.NetworkTargetConnectionsOverflowAction">
          <xs:annotation>
            <xs:documentation>Action that should be taken if the will be more connections than .</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxQueueSize" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Maximum queue size.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxConnections" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Maximum current connections. 0 = no maximum.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="keepConnection" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to keep connection open whenever possible.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="connectionCacheSize" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Size of the connection cache (number of connections which are kept alive).</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="address" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Network address.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="onOverflow" type="NLog.Targets.NetworkTargetOverflowAction">
          <xs:annotation>
            <xs:documentation>Action that should be taken if the message is larger than maxMessageSize.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="ndlcItemSeparator" type="xs:string">
          <xs:annotation>
            <xs:documentation>NDLC item separator.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="ndcItemSeparator" type="xs:string">
          <xs:annotation>
            <xs:documentation>NDC item separator.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeNLogData" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include NLog-specific extensions to log4j schema.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeSourceInfo" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include source info (file name and line number) in the information sent over the network.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeNdlc" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include contents of the  stack.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeNdc" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include  stack contents.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeMdlc" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include  dictionary contents.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeMdc" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include  dictionary contents.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeCallSite" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include call site (class and method name) in the information sent over the network.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeAllProperties" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Option to include all properties from the log events</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="appInfo" type="xs:string">
          <xs:annotation>
            <xs:documentation>AppInfo field. By default it's the friendly name of the current AppDomain.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="loggerName" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Renderer for log4j:event logger-xml-attribute (Default ${logger})</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:simpleType name="NLog.Targets.NetworkTargetConnectionsOverflowAction">
    <xs:restriction base="xs:string">
      <xs:enumeration value="AllowNewConnnection" />
      <xs:enumeration value="DiscardMessage" />
      <xs:enumeration value="Block" />
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="NLog.Targets.NetworkTargetOverflowAction">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Error" />
      <xs:enumeration value="Split" />
      <xs:enumeration value="Discard" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="NLog.Targets.NLogViewerParameterInfo">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
      <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
    </xs:choice>
    <xs:attribute name="layout" type="SimpleLayoutAttribute">
      <xs:annotation>
        <xs:documentation>Layout that should be use to calcuate the value for the parameter.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="name" type="xs:string">
      <xs:annotation>
        <xs:documentation>Viewer parameter name.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="ColoredConsole">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="header" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="footer" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="detectConsoleAvailable" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="encoding" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="errorStream" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="useDefaultRowHighlightingRules" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="highlight-row" minOccurs="0" maxOccurs="unbounded" type="NLog.Targets.ConsoleRowHighlightingRule" />
          <xs:element name="highlight-word" minOccurs="0" maxOccurs="unbounded" type="NLog.Targets.ConsoleWordHighlightingRule" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Text to be rendered.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="header" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Header.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="footer" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Footer.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="detectConsoleAvailable" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to auto-check if the console is available. - Disables console writing if Environment.UserInteractive = False (Windows Service) - Disables console writing if Console Standard Input is not available (Non-Console-App)</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="encoding" type="xs:string">
          <xs:annotation>
            <xs:documentation>The encoding for writing messages to the .</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="errorStream" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether the error stream (stderr) should be used instead of the output stream (stdout).</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="useDefaultRowHighlightingRules" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to use default row highlighting rules.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:simpleType name="NLog.Targets.ConsoleOutputColor">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Black" />
      <xs:enumeration value="DarkBlue" />
      <xs:enumeration value="DarkGreen" />
      <xs:enumeration value="DarkCyan" />
      <xs:enumeration value="DarkRed" />
      <xs:enumeration value="DarkMagenta" />
      <xs:enumeration value="DarkYellow" />
      <xs:enumeration value="Gray" />
      <xs:enumeration value="DarkGray" />
      <xs:enumeration value="Blue" />
      <xs:enumeration value="Green" />
      <xs:enumeration value="Cyan" />
      <xs:enumeration value="Red" />
      <xs:enumeration value="Magenta" />
      <xs:enumeration value="Yellow" />
      <xs:enumeration value="White" />
      <xs:enumeration value="NoChange" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="NLog.Targets.ConsoleRowHighlightingRule">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="condition" minOccurs="0" maxOccurs="1" type="Condition" />
      <xs:element name="backgroundColor" minOccurs="0" maxOccurs="1" type="NLog.Targets.ConsoleOutputColor" />
      <xs:element name="foregroundColor" minOccurs="0" maxOccurs="1" type="NLog.Targets.ConsoleOutputColor" />
    </xs:choice>
    <xs:attribute name="condition" type="Condition">
      <xs:annotation>
        <xs:documentation>Condition that must be met in order to set the specified foreground and background color.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="backgroundColor" type="NLog.Targets.ConsoleOutputColor">
      <xs:annotation>
        <xs:documentation>Background color.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="foregroundColor" type="NLog.Targets.ConsoleOutputColor">
      <xs:annotation>
        <xs:documentation>Foreground color.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="NLog.Targets.ConsoleWordHighlightingRule">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="compileRegex" minOccurs="0" maxOccurs="1" type="xs:boolean" />
      <xs:element name="ignoreCase" minOccurs="0" maxOccurs="1" type="xs:boolean" />
      <xs:element name="regex" minOccurs="0" maxOccurs="1" type="xs:string" />
      <xs:element name="text" minOccurs="0" maxOccurs="1" type="xs:string" />
      <xs:element name="wholeWords" minOccurs="0" maxOccurs="1" type="xs:boolean" />
      <xs:element name="backgroundColor" minOccurs="0" maxOccurs="1" type="NLog.Targets.ConsoleOutputColor" />
      <xs:element name="foregroundColor" minOccurs="0" maxOccurs="1" type="NLog.Targets.ConsoleOutputColor" />
    </xs:choice>
    <xs:attribute name="compileRegex" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Compile the ? This can improve the performance, but at the costs of more memory usage. If false, the Regex Cache is used.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="ignoreCase" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Indicates whether to ignore case when comparing texts.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="regex" type="xs:string">
      <xs:annotation>
        <xs:documentation>Regular expression to be matched. You must specify either text or regex.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="text" type="xs:string">
      <xs:annotation>
        <xs:documentation>Text to be matched. You must specify either text or regex.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="wholeWords" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Indicates whether to match whole words only.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="backgroundColor" type="NLog.Targets.ConsoleOutputColor">
      <xs:annotation>
        <xs:documentation>Background color.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="foregroundColor" type="NLog.Targets.ConsoleOutputColor">
      <xs:annotation>
        <xs:documentation>Foreground color.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="Console">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="header" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="footer" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="detectConsoleAvailable" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="encoding" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="error" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Text to be rendered.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="header" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Header.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="footer" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Footer.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="detectConsoleAvailable" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to auto-check if the console is available - Disables console writing if Environment.UserInteractive = False (Windows Service) - Disables console writing if Console Standard Input is not available (Non-Console-App)</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="encoding" type="xs:string">
          <xs:annotation>
            <xs:documentation>The encoding for writing messages to the .</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="error" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to send the log messages to the standard error instead of the standard output.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="Database">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="useTransactions" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="dbUserName" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="dbProvider" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="dbPassword" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="keepConnection" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="dbDatabase" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="connectionStringName" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="connectionString" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="dbHost" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="installConnectionString" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="install-command" minOccurs="0" maxOccurs="unbounded" type="NLog.Targets.DatabaseCommandInfo" />
          <xs:element name="uninstall-command" minOccurs="0" maxOccurs="unbounded" type="NLog.Targets.DatabaseCommandInfo" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="parameter" minOccurs="0" maxOccurs="unbounded" type="NLog.Targets.DatabaseParameterInfo" />
          <xs:element name="commandText" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="commandType" minOccurs="0" maxOccurs="1" type="System.Data.CommandType" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="useTransactions" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Obsolete - value will be ignored! The logging code always runs outside of transaction. Gets or sets a value indicating whether to use database transactions. Some data providers require this.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="dbUserName" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Database user name. If the ConnectionString is not provided this value will be used to construct the "User ID=" part of the connection string.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="dbProvider" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the database provider.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="dbPassword" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Database password. If the ConnectionString is not provided this value will be used to construct the "Password=" part of the connection string.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="keepConnection" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to keep the database connection open between the log events.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="dbDatabase" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Database name. If the ConnectionString is not provided this value will be used to construct the "Database=" part of the connection string.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="connectionStringName" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the connection string (as specified in &lt;connectionStrings&gt; configuration section.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="connectionString" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Connection string. When provided, it overrides the values specified in DBHost, DBUserName, DBPassword, DBDatabase.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="dbHost" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Database host name. If the ConnectionString is not provided this value will be used to construct the "Server=" part of the connection string.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="installConnectionString" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Connection string using for installation and uninstallation. If not provided, regular ConnectionString is being used.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="commandText" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Text of the SQL command to be run on each log level.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="commandType" type="System.Data.CommandType">
          <xs:annotation>
            <xs:documentation>Type of the SQL command to be run on each log level.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:simpleType name="System.Data.CommandType">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Text" />
      <xs:enumeration value="StoredProcedure" />
      <xs:enumeration value="TableDirect" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="NLog.Targets.DatabaseCommandInfo">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="commandType" minOccurs="0" maxOccurs="1" type="System.Data.CommandType" />
      <xs:element name="connectionString" minOccurs="0" maxOccurs="1" type="Layout" />
      <xs:element name="ignoreFailures" minOccurs="0" maxOccurs="1" type="xs:boolean" />
      <xs:element name="parameter" minOccurs="0" maxOccurs="unbounded" type="NLog.Targets.DatabaseParameterInfo" />
      <xs:element name="text" minOccurs="0" maxOccurs="1" type="Layout" />
    </xs:choice>
    <xs:attribute name="commandType" type="System.Data.CommandType">
      <xs:annotation>
        <xs:documentation>Type of the command.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="connectionString" type="SimpleLayoutAttribute">
      <xs:annotation>
        <xs:documentation>Connection string to run the command against. If not provided, connection string from the target is used.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="ignoreFailures" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Indicates whether to ignore failures.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="text" type="SimpleLayoutAttribute">
      <xs:annotation>
        <xs:documentation>Command text.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="NLog.Targets.DatabaseParameterInfo">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
      <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
      <xs:element name="precision" minOccurs="0" maxOccurs="1" type="xs:byte" />
      <xs:element name="scale" minOccurs="0" maxOccurs="1" type="xs:byte" />
      <xs:element name="size" minOccurs="0" maxOccurs="1" type="xs:integer" />
    </xs:choice>
    <xs:attribute name="layout" type="SimpleLayoutAttribute">
      <xs:annotation>
        <xs:documentation>Layout that should be use to calcuate the value for the parameter.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="name" type="xs:string">
      <xs:annotation>
        <xs:documentation>Database parameter name.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="precision" type="xs:byte">
      <xs:annotation>
        <xs:documentation>Database parameter precision.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="scale" type="xs:byte">
      <xs:annotation>
        <xs:documentation>Database parameter scale.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="size" type="xs:integer">
      <xs:annotation>
        <xs:documentation>Database parameter size.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="Debugger">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="header" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="footer" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Text to be rendered.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="header" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Header.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="footer" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Footer.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="Debug">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Layout used to format log messages.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="EventLog">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="category" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="entryType" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="eventId" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="log" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="machineName" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="maxKilobytes" minOccurs="0" maxOccurs="1" type="xs:long" />
          <xs:element name="maxMessageLength" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="source" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="onOverflow" minOccurs="0" maxOccurs="1" type="NLog.Targets.EventLogTargetOverflowAction" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Layout used to format log messages.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="category" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Layout that renders event Category.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="entryType" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Optional entrytype. When not set, or when not convertable to  then determined by </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="eventId" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Layout that renders event ID.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="log" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the Event Log to write to. This can be System, Application or any user-defined name.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="machineName" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the machine on which Event Log service is running.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxKilobytes" type="xs:long">
          <xs:annotation>
            <xs:documentation>Maximum Event log size in kilobytes. If null, the value won't be set. Default is 512 Kilobytes as specified by Eventlog API</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxMessageLength" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Message length limit to write to the Event Log.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="source" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Value to be used as the event Source.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="onOverflow" type="NLog.Targets.EventLogTargetOverflowAction">
          <xs:annotation>
            <xs:documentation>Action to take if the message is larger than the  option.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:simpleType name="NLog.Targets.EventLogTargetOverflowAction">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Truncate" />
      <xs:enumeration value="Split" />
      <xs:enumeration value="Discard" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="FallbackGroup">
    <xs:complexContent>
      <xs:extension base="CompoundTargetBase">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="returnToFirstOnSuccess" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="returnToFirstOnSuccess" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to return to the first target after any successful write.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="File">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="header" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="footer" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="encoding" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="lineEnding" minOccurs="0" maxOccurs="1" type="LineEndingMode" />
          <xs:element name="enableArchiveFileCompression" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="archiveNumbering" minOccurs="0" maxOccurs="1" type="NLog.Targets.ArchiveNumberingMode" />
          <xs:element name="archiveFileName" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="archiveFileKind" minOccurs="0" maxOccurs="1" type="NLog.Targets.FilePathKind" />
          <xs:element name="archiveEvery" minOccurs="0" maxOccurs="1" type="NLog.Targets.FileArchivePeriod" />
          <xs:element name="archiveAboveSize" minOccurs="0" maxOccurs="1" type="xs:long" />
          <xs:element name="maxArchiveFiles" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="writeFooterOnArchivingOnly" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="maxLogFilenames" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="fileNameKind" minOccurs="0" maxOccurs="1" type="NLog.Targets.FilePathKind" />
          <xs:element name="forceManaged" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="forceMutexConcurrentWrites" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="replaceFileContentsOnEachWrite" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="writeBom" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="enableFileDelete" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="fileName" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="archiveDateFormat" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="archiveOldFileOnStartup" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="cleanupFileName" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="createDirs" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="deleteOldFileOnStartup" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="fileAttributes" minOccurs="0" maxOccurs="1" type="NLog.Targets.Win32FileAttributes" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="networkWrites" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="openFileCacheTimeout" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="openFileCacheSize" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="keepFileOpen" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="discardAll" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="concurrentWrites" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="concurrentWriteAttempts" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="concurrentWriteAttemptDelay" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="bufferSize" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="openFileFlushTimeout" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="autoFlush" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Text to be rendered.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="header" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Header.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="footer" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Footer.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="encoding" type="xs:string">
          <xs:annotation>
            <xs:documentation>File encoding.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="lineEnding" type="LineEndingMode">
          <xs:annotation>
            <xs:documentation>Line ending mode.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="enableArchiveFileCompression" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to compress archive files into the zip archive format.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="archiveNumbering" type="NLog.Targets.ArchiveNumberingMode">
          <xs:annotation>
            <xs:documentation>Way file archives are numbered.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="archiveFileName" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Name of the file to be used for an archive.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="archiveFileKind" type="NLog.Targets.FilePathKind">
          <xs:annotation>
            <xs:documentation>Is the  an absolute or relative path?</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="archiveEvery" type="NLog.Targets.FileArchivePeriod">
          <xs:annotation>
            <xs:documentation>Indicates whether to automatically archive log files every time the specified time passes.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="archiveAboveSize" type="xs:long">
          <xs:annotation>
            <xs:documentation>Size in bytes above which log files will be automatically archived. Warning: combining this with  isn't supported. We cannot create multiple archive files, if they should have the same name. Choose: </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxArchiveFiles" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Maximum number of archive files that should be kept.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="writeFooterOnArchivingOnly" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether the footer should be written only when the file is archived.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxLogFilenames" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Maximum number of log filenames that should be stored as existing.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="fileNameKind" type="NLog.Targets.FilePathKind">
          <xs:annotation>
            <xs:documentation>Is the  an absolute or relative path?</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="forceManaged" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Gets or set a value indicating whether a managed file stream is forced, instead of using the native implementation.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="forceMutexConcurrentWrites" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Value indicationg whether file creation calls should be synchronized by a system global mutex.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="replaceFileContentsOnEachWrite" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to replace file contents on each write instead of appending log message at the end.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="writeBom" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to write BOM (byte order mark) in created files</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="enableFileDelete" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to enable log file(s) to be deleted.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="fileName" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Name of the file to write to.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="archiveDateFormat" type="xs:string">
          <xs:annotation>
            <xs:documentation>Value specifying the date format to use when archiving files.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="archiveOldFileOnStartup" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to archive old log file on startup.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="cleanupFileName" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Cleanup invalid values in a filename, e.g. slashes in a filename. If set to true, this can impact the performance of massive writes. If set to false, nothing gets written when the filename is wrong.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="createDirs" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to create directories if they do not exist.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="deleteOldFileOnStartup" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to delete old log file on startup.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="fileAttributes" type="NLog.Targets.Win32FileAttributes">
          <xs:annotation>
            <xs:documentation>File attributes (Windows only).</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="networkWrites" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether concurrent writes to the log file by multiple processes on different network hosts.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="openFileCacheTimeout" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Maximum number of seconds that files are kept open. If this number is negative the files are not automatically closed after a period of inactivity.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="openFileCacheSize" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Number of files to be kept open. Setting this to a higher value may improve performance in a situation where a single File target is writing to many files (such as splitting by level or by logger).</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="keepFileOpen" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to keep log file open instead of opening and closing it on each logging event.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="discardAll" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Whether or not this target should just discard all data that its asked to write. Mostly used for when testing NLog Stack except final write</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="concurrentWrites" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether concurrent writes to the log file by multiple processes on the same host.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="concurrentWriteAttempts" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Number of times the write is appended on the file before NLog discards the log message.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="concurrentWriteAttemptDelay" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Delay in milliseconds to wait before attempting to write to the file again.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="bufferSize" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Log file buffer size in bytes.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="openFileFlushTimeout" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Maximum number of seconds before open files are flushed. If this number is negative or zero the files are not flushed by timer.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="autoFlush" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to automatically flush the file buffers after each log message.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:simpleType name="NLog.Targets.ArchiveNumberingMode">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Sequence" />
      <xs:enumeration value="Rolling" />
      <xs:enumeration value="Date" />
      <xs:enumeration value="DateAndSequence" />
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="NLog.Targets.FilePathKind">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Unknown" />
      <xs:enumeration value="Relative" />
      <xs:enumeration value="Absolute" />
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="NLog.Targets.FileArchivePeriod">
    <xs:restriction base="xs:string">
      <xs:enumeration value="None" />
      <xs:enumeration value="Year" />
      <xs:enumeration value="Month" />
      <xs:enumeration value="Day" />
      <xs:enumeration value="Hour" />
      <xs:enumeration value="Minute" />
      <xs:enumeration value="Sunday" />
      <xs:enumeration value="Monday" />
      <xs:enumeration value="Tuesday" />
      <xs:enumeration value="Wednesday" />
      <xs:enumeration value="Thursday" />
      <xs:enumeration value="Friday" />
      <xs:enumeration value="Saturday" />
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="NLog.Targets.Win32FileAttributes">
    <xs:restriction base="xs:string">
      <xs:enumeration value="ReadOnly" />
      <xs:enumeration value="Hidden" />
      <xs:enumeration value="System" />
      <xs:enumeration value="Archive" />
      <xs:enumeration value="Device" />
      <xs:enumeration value="Normal" />
      <xs:enumeration value="Temporary" />
      <xs:enumeration value="SparseFile" />
      <xs:enumeration value="ReparsePoint" />
      <xs:enumeration value="Compressed" />
      <xs:enumeration value="NotContentIndexed" />
      <xs:enumeration value="Encrypted" />
      <xs:enumeration value="WriteThrough" />
      <xs:enumeration value="NoBuffering" />
      <xs:enumeration value="DeleteOnClose" />
      <xs:enumeration value="PosixSemantics" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="FilteringWrapper">
    <xs:complexContent>
      <xs:extension base="WrapperTargetBase">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="condition" minOccurs="0" maxOccurs="1" type="Condition" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="condition" type="Condition">
          <xs:annotation>
            <xs:documentation>Condition expression. Log events who meet this condition will be forwarded to the wrapped target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="ImpersonatingWrapper">
    <xs:complexContent>
      <xs:extension base="WrapperTargetBase">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="domain" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="impersonationLevel" minOccurs="0" maxOccurs="1" type="NLog.Targets.Wrappers.SecurityImpersonationLevel" />
          <xs:element name="logOnProvider" minOccurs="0" maxOccurs="1" type="NLog.Targets.Wrappers.LogOnProviderType" />
          <xs:element name="logOnType" minOccurs="0" maxOccurs="1" type="NLog.Targets.Wrappers.SecurityLogOnType" />
          <xs:element name="password" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="revertToSelf" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="userName" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="domain" type="xs:string">
          <xs:annotation>
            <xs:documentation>Windows domain name to change context to.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="impersonationLevel" type="NLog.Targets.Wrappers.SecurityImpersonationLevel">
          <xs:annotation>
            <xs:documentation>Required impersonation level.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="logOnProvider" type="NLog.Targets.Wrappers.LogOnProviderType">
          <xs:annotation>
            <xs:documentation>Type of the logon provider.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="logOnType" type="NLog.Targets.Wrappers.SecurityLogOnType">
          <xs:annotation>
            <xs:documentation>Logon Type.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="password" type="xs:string">
          <xs:annotation>
            <xs:documentation>User account password.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="revertToSelf" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to revert to the credentials of the process instead of impersonating another user.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="userName" type="xs:string">
          <xs:annotation>
            <xs:documentation>Username to change context to.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:simpleType name="NLog.Targets.Wrappers.SecurityImpersonationLevel">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Anonymous" />
      <xs:enumeration value="Identification" />
      <xs:enumeration value="Impersonation" />
      <xs:enumeration value="Delegation" />
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="NLog.Targets.Wrappers.LogOnProviderType">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Default" />
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="NLog.Targets.Wrappers.SecurityLogOnType">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Interactive" />
      <xs:enumeration value="Network" />
      <xs:enumeration value="Batch" />
      <xs:enumeration value="Service" />
      <xs:enumeration value="NetworkClearText" />
      <xs:enumeration value="NewCredentials" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="LimitingWrapper">
    <xs:complexContent>
      <xs:extension base="WrapperTargetBase">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="interval" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="messageLimit" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="interval" type="xs:string">
          <xs:annotation>
            <xs:documentation>Interval in which messages will be written up to the  number of messages.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="messageLimit" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Maximum allowed number of messages written per .</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="LogReceiverService">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="endpointAddress" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="endpointConfigurationName" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="useOneWayContract" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="clientId" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="includeEventProperties" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="parameter" minOccurs="0" maxOccurs="unbounded" type="NLog.Targets.MethodCallParameter" />
          <xs:element name="useBinaryEncoding" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="endpointAddress" type="xs:string">
          <xs:annotation>
            <xs:documentation>Endpoint address.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="endpointConfigurationName" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the endpoint configuration in WCF configuration file.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="useOneWayContract" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to use a WCF service contract that is one way (fire and forget) or two way (request-reply)</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="clientId" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Client ID.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeEventProperties" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include per-event properties in the payload sent to the server.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="useBinaryEncoding" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to use binary message encoding.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="NLog.Targets.MethodCallParameter">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
      <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
      <xs:element name="parameterType" minOccurs="0" maxOccurs="1" type="xs:string" />
      <xs:element name="type" minOccurs="0" maxOccurs="1" type="xs:string" />
    </xs:choice>
    <xs:attribute name="layout" type="SimpleLayoutAttribute">
      <xs:annotation>
        <xs:documentation>Layout that should be use to calculate the value for the parameter.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="name" type="xs:string">
      <xs:annotation>
        <xs:documentation>Name of the parameter.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="parameterType" type="xs:string">
      <xs:annotation>
        <xs:documentation>Type of the parameter.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="type" type="xs:string">
      <xs:annotation>
        <xs:documentation>Type of the parameter. Obsolete alias for </xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="Mail">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="header" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="footer" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="replaceNewlineWithBrTagInHtml" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="priority" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="encoding" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="bcc" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="cc" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="addNewLines" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="html" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="from" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="body" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="subject" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="to" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="timeout" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="smtpServer" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="smtpAuthentication" minOccurs="0" maxOccurs="1" type="NLog.Targets.SmtpAuthenticationMode" />
          <xs:element name="smtpUserName" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="smtpPassword" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="enableSsl" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="smtpPort" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="useSystemNetMailSettings" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="pickupDirectoryLocation" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="deliveryMethod" minOccurs="0" maxOccurs="1" type="System.Net.Mail.SmtpDeliveryMethod" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Text to be rendered.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="header" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Header.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="footer" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Footer.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="replaceNewlineWithBrTagInHtml" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether NewLine characters in the body should be replaced with  tags.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="priority" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Priority used for sending mails.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="encoding" type="xs:string">
          <xs:annotation>
            <xs:documentation>Encoding to be used for sending e-mail.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="bcc" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>BCC email addresses separated by semicolons (e.g. john@domain.com;jane@domain.com).</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="cc" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>CC email addresses separated by semicolons (e.g. john@domain.com;jane@domain.com).</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="addNewLines" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to add new lines between log entries.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="html" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to send message as HTML instead of plain text.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="from" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Sender's email address (e.g. joe@domain.com).</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="body" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Mail message body (repeated for each log message send in one mail).</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="subject" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Mail subject.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="to" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Recipients' email addresses separated by semicolons (e.g. john@domain.com;jane@domain.com).</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="timeout" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Indicates the SMTP client timeout.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="smtpServer" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>SMTP Server to be used for sending.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="smtpAuthentication" type="NLog.Targets.SmtpAuthenticationMode">
          <xs:annotation>
            <xs:documentation>SMTP Authentication mode.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="smtpUserName" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Username used to connect to SMTP server (used when SmtpAuthentication is set to "basic").</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="smtpPassword" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Password used to authenticate against SMTP server (used when SmtpAuthentication is set to "basic").</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="enableSsl" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether SSL (secure sockets layer) should be used when communicating with SMTP server.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="smtpPort" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Port number that SMTP Server is listening on.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="useSystemNetMailSettings" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether the default Settings from System.Net.MailSettings should be used.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="pickupDirectoryLocation" type="xs:string">
          <xs:annotation>
            <xs:documentation>Folder where applications save mail messages to be processed by the local SMTP server.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="deliveryMethod" type="System.Net.Mail.SmtpDeliveryMethod">
          <xs:annotation>
            <xs:documentation>Specifies how outgoing email messages will be handled.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:simpleType name="NLog.Targets.SmtpAuthenticationMode">
    <xs:restriction base="xs:string">
      <xs:enumeration value="None" />
      <xs:enumeration value="Basic" />
      <xs:enumeration value="Ntlm" />
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="System.Net.Mail.SmtpDeliveryMethod">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Network" />
      <xs:enumeration value="SpecifiedPickupDirectory" />
      <xs:enumeration value="PickupDirectoryFromIis" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="Memory">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Layout used to format log messages.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="MethodCall">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="className" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="methodName" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="parameter" minOccurs="0" maxOccurs="unbounded" type="NLog.Targets.MethodCallParameter" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="className" type="xs:string">
          <xs:annotation>
            <xs:documentation>Class name.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="methodName" type="xs:string">
          <xs:annotation>
            <xs:documentation>Method name. The method must be public and static. Use the AssemblyQualifiedName , https://msdn.microsoft.com/en-us/library/system.type.assemblyqualifiedname(v=vs.110).aspx e.g.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="Network">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="encoding" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="lineEnding" minOccurs="0" maxOccurs="1" type="LineEndingMode" />
          <xs:element name="maxMessageSize" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="newLine" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="address" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="connectionCacheSize" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="keepConnection" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="maxConnections" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="maxQueueSize" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="onConnectionOverflow" minOccurs="0" maxOccurs="1" type="NLog.Targets.NetworkTargetConnectionsOverflowAction" />
          <xs:element name="onOverflow" minOccurs="0" maxOccurs="1" type="NLog.Targets.NetworkTargetOverflowAction" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Layout used to format log messages.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="encoding" type="xs:string">
          <xs:annotation>
            <xs:documentation>Encoding to be used.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="lineEnding" type="LineEndingMode">
          <xs:annotation>
            <xs:documentation>End of line value if a newline is appended at the end of log message .</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxMessageSize" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Maximum message size in bytes.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="newLine" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to append newline at the end of log message.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="address" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Network address.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="connectionCacheSize" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Size of the connection cache (number of connections which are kept alive).</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="keepConnection" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to keep connection open whenever possible.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxConnections" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Maximum current connections. 0 = no maximum.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxQueueSize" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Maximum queue size.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="onConnectionOverflow" type="NLog.Targets.NetworkTargetConnectionsOverflowAction">
          <xs:annotation>
            <xs:documentation>Action that should be taken if the will be more connections than .</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="onOverflow" type="NLog.Targets.NetworkTargetOverflowAction">
          <xs:annotation>
            <xs:documentation>Action that should be taken if the message is larger than maxMessageSize.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="NLogViewer">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="encoding" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="lineEnding" minOccurs="0" maxOccurs="1" type="LineEndingMode" />
          <xs:element name="maxMessageSize" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="newLine" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="onConnectionOverflow" minOccurs="0" maxOccurs="1" type="NLog.Targets.NetworkTargetConnectionsOverflowAction" />
          <xs:element name="maxQueueSize" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="maxConnections" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="keepConnection" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="connectionCacheSize" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="address" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="onOverflow" minOccurs="0" maxOccurs="1" type="NLog.Targets.NetworkTargetOverflowAction" />
          <xs:element name="parameter" minOccurs="0" maxOccurs="unbounded" type="NLog.Targets.NLogViewerParameterInfo" />
          <xs:element name="ndlcItemSeparator" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="ndcItemSeparator" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="includeNLogData" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeSourceInfo" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeNdlc" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeNdc" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeMdlc" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeMdc" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeCallSite" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeAllProperties" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="appInfo" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="loggerName" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="encoding" type="xs:string">
          <xs:annotation>
            <xs:documentation>Encoding to be used.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Instance of  that is used to format log messages.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="lineEnding" type="LineEndingMode">
          <xs:annotation>
            <xs:documentation>End of line value if a newline is appended at the end of log message .</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxMessageSize" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Maximum message size in bytes.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="newLine" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to append newline at the end of log message.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="onConnectionOverflow" type="NLog.Targets.NetworkTargetConnectionsOverflowAction">
          <xs:annotation>
            <xs:documentation>Action that should be taken if the will be more connections than .</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxQueueSize" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Maximum queue size.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxConnections" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Maximum current connections. 0 = no maximum.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="keepConnection" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to keep connection open whenever possible.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="connectionCacheSize" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Size of the connection cache (number of connections which are kept alive).</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="address" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Network address.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="onOverflow" type="NLog.Targets.NetworkTargetOverflowAction">
          <xs:annotation>
            <xs:documentation>Action that should be taken if the message is larger than maxMessageSize.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="ndlcItemSeparator" type="xs:string">
          <xs:annotation>
            <xs:documentation>NDLC item separator.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="ndcItemSeparator" type="xs:string">
          <xs:annotation>
            <xs:documentation>NDC item separator.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeNLogData" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include NLog-specific extensions to log4j schema.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeSourceInfo" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include source info (file name and line number) in the information sent over the network.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeNdlc" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include contents of the  stack.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeNdc" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include  stack contents.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeMdlc" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include  dictionary contents.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeMdc" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include  dictionary contents.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeCallSite" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include call site (class and method name) in the information sent over the network.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeAllProperties" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Option to include all properties from the log events</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="appInfo" type="xs:string">
          <xs:annotation>
            <xs:documentation>AppInfo field. By default it's the friendly name of the current AppDomain.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="loggerName" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Renderer for log4j:event logger-xml-attribute (Default ${logger})</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="Null">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="formatMessage" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Layout used to format log messages.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="formatMessage" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to perform layout calculation.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="OutputDebugString">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Layout used to format log messages.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="PerfCounter">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="autoCreate" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="categoryName" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="counterHelp" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="counterName" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="counterType" minOccurs="0" maxOccurs="1" type="System.Diagnostics.PerformanceCounterType" />
          <xs:element name="incrementValue" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="instanceName" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="autoCreate" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether performance counter should be automatically created.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="categoryName" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the performance counter category.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="counterHelp" type="xs:string">
          <xs:annotation>
            <xs:documentation>Counter help text.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="counterName" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the performance counter.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="counterType" type="System.Diagnostics.PerformanceCounterType">
          <xs:annotation>
            <xs:documentation>Performance counter type.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="incrementValue" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>The value by which to increment the counter.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="instanceName" type="xs:string">
          <xs:annotation>
            <xs:documentation>Performance counter instance name.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:simpleType name="System.Diagnostics.PerformanceCounterType">
    <xs:restriction base="xs:string">
      <xs:enumeration value="NumberOfItems32" />
      <xs:enumeration value="NumberOfItems64" />
      <xs:enumeration value="NumberOfItemsHEX32" />
      <xs:enumeration value="NumberOfItemsHEX64" />
      <xs:enumeration value="RateOfCountsPerSecond32" />
      <xs:enumeration value="RateOfCountsPerSecond64" />
      <xs:enumeration value="CountPerTimeInterval32" />
      <xs:enumeration value="CountPerTimeInterval64" />
      <xs:enumeration value="RawFraction" />
      <xs:enumeration value="RawBase" />
      <xs:enumeration value="AverageTimer32" />
      <xs:enumeration value="AverageBase" />
      <xs:enumeration value="AverageCount64" />
      <xs:enumeration value="SampleFraction" />
      <xs:enumeration value="SampleCounter" />
      <xs:enumeration value="SampleBase" />
      <xs:enumeration value="CounterTimer" />
      <xs:enumeration value="CounterTimerInverse" />
      <xs:enumeration value="Timer100Ns" />
      <xs:enumeration value="Timer100NsInverse" />
      <xs:enumeration value="ElapsedTime" />
      <xs:enumeration value="CounterMultiTimer" />
      <xs:enumeration value="CounterMultiTimerInverse" />
      <xs:enumeration value="CounterMultiTimer100Ns" />
      <xs:enumeration value="CounterMultiTimer100NsInverse" />
      <xs:enumeration value="CounterMultiBase" />
      <xs:enumeration value="CounterDelta32" />
      <xs:enumeration value="CounterDelta64" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="PostFilteringWrapper">
    <xs:complexContent>
      <xs:extension base="WrapperTargetBase">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="defaultFilter" minOccurs="0" maxOccurs="1" type="Condition" />
          <xs:element name="when" minOccurs="0" maxOccurs="unbounded" type="NLog.Targets.Wrappers.FilteringRule" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="defaultFilter" type="Condition">
          <xs:annotation>
            <xs:documentation>Default filter to be applied when no specific rule matches.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="NLog.Targets.Wrappers.FilteringRule">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="exists" minOccurs="0" maxOccurs="1" type="Condition" />
      <xs:element name="filter" minOccurs="0" maxOccurs="1" type="Condition" />
    </xs:choice>
    <xs:attribute name="exists" type="Condition">
      <xs:annotation>
        <xs:documentation>Condition to be tested.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="filter" type="Condition">
      <xs:annotation>
        <xs:documentation>Resulting filter to be applied when the condition matches.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="RandomizeGroup">
    <xs:complexContent>
      <xs:extension base="CompoundTargetBase">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="RepeatingWrapper">
    <xs:complexContent>
      <xs:extension base="WrapperTargetBase">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="repeatCount" minOccurs="0" maxOccurs="1" type="xs:integer" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="repeatCount" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Number of times to repeat each log message.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="RetryingWrapper">
    <xs:complexContent>
      <xs:extension base="WrapperTargetBase">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="retryCount" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="retryDelayMilliseconds" minOccurs="0" maxOccurs="1" type="xs:integer" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="retryCount" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Number of retries that should be attempted on the wrapped target in case of a failure.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="retryDelayMilliseconds" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Time to wait between retries in milliseconds.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="RoundRobinGroup">
    <xs:complexContent>
      <xs:extension base="CompoundTargetBase">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="SplitGroup">
    <xs:complexContent>
      <xs:extension base="CompoundTargetBase">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="Trace">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="rawWrite" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Layout used to format log messages.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="rawWrite" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Always use  independent of </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="WebService">
    <xs:complexContent>
      <xs:extension base="Target">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="parameter" minOccurs="0" maxOccurs="unbounded" type="NLog.Targets.MethodCallParameter" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeBOM" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="methodName" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="namespace" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="protocol" minOccurs="0" maxOccurs="1" type="NLog.Targets.WebServiceProtocol" />
          <xs:element name="proxyAddress" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="encoding" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="url" minOccurs="0" maxOccurs="1" type="xs:anyURI" />
          <xs:element name="escapeDataNLogLegacy" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="escapeDataRfc3986" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="preAuthenticate" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="xmlRoot" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="xmlRootNamespace" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="header" minOccurs="0" maxOccurs="unbounded" type="NLog.Targets.MethodCallParameter" />
          <xs:element name="proxyType" minOccurs="0" maxOccurs="1" type="NLog.Targets.WebServiceProxyType" />
        </xs:choice>
        <xs:attribute name="name" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the target.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeBOM" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Should we include the BOM (Byte-order-mark) for UTF? Influences the  property. This will only work for UTF-8.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="methodName" type="xs:string">
          <xs:annotation>
            <xs:documentation>Web service method name. Only used with Soap.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="namespace" type="xs:string">
          <xs:annotation>
            <xs:documentation>Web service namespace. Only used with Soap.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="protocol" type="NLog.Targets.WebServiceProtocol">
          <xs:annotation>
            <xs:documentation>Protocol to be used when calling web service.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="proxyAddress" type="xs:string">
          <xs:annotation>
            <xs:documentation>Custom proxy address, include port separated by a colon</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="encoding" type="xs:string">
          <xs:annotation>
            <xs:documentation>Encoding.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="url" type="xs:anyURI">
          <xs:annotation>
            <xs:documentation>Web service URL.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="escapeDataNLogLegacy" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Value whether escaping be done according to the old NLog style (Very non-standard)</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="escapeDataRfc3986" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Value whether escaping be done according to Rfc3986 (Supports Internationalized Resource Identifiers - IRIs)</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="preAuthenticate" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to pre-authenticate the HttpWebRequest (Requires 'Authorization' in  parameters)</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="xmlRoot" type="xs:string">
          <xs:annotation>
            <xs:documentation>Name of the root XML element, if POST of XML document chosen. If so, this property must not be null. (see  and ).</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="xmlRootNamespace" type="xs:string">
          <xs:annotation>
            <xs:documentation>(optional) root namespace of the XML document, if POST of XML document chosen. (see  and ).</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="proxyType" type="NLog.Targets.WebServiceProxyType">
          <xs:annotation>
            <xs:documentation>Proxy configuration when calling web service</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:simpleType name="NLog.Targets.WebServiceProtocol">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Soap11" />
      <xs:enumeration value="Soap12" />
      <xs:enumeration value="HttpPost" />
      <xs:enumeration value="HttpGet" />
      <xs:enumeration value="JsonPost" />
      <xs:enumeration value="XmlPost" />
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="NLog.Targets.WebServiceProxyType">
    <xs:restriction base="xs:string">
      <xs:enumeration value="DefaultWebProxy" />
      <xs:enumeration value="AutoProxy" />
      <xs:enumeration value="NoProxy" />
      <xs:enumeration value="ProxyAddress" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="CompoundLayout">
    <xs:complexContent>
      <xs:extension base="Layout">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="layout" minOccurs="0" maxOccurs="unbounded" type="Layout" />
        </xs:choice>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="Layout">
    <xs:choice minOccurs="0" maxOccurs="unbounded" />
  </xs:complexType>
  <xs:complexType name="CsvLayout">
    <xs:complexContent>
      <xs:extension base="Layout">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="footer" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="header" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="column" minOccurs="0" maxOccurs="unbounded" type="NLog.Layouts.CsvColumn" />
          <xs:element name="customColumnDelimiter" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="delimiter" minOccurs="0" maxOccurs="1" type="NLog.Layouts.CsvColumnDelimiterMode" />
          <xs:element name="quoteChar" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="quoting" minOccurs="0" maxOccurs="1" type="NLog.Layouts.CsvQuotingMode" />
          <xs:element name="withHeader" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="footer" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Footer layout.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="header" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Header layout.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Body layout (can be repeated multiple times).</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="customColumnDelimiter" type="xs:string">
          <xs:annotation>
            <xs:documentation>Custom column delimiter value (valid when ColumnDelimiter is set to 'Custom').</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="delimiter" type="NLog.Layouts.CsvColumnDelimiterMode">
          <xs:annotation>
            <xs:documentation>Column delimiter.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="quoteChar" type="xs:string">
          <xs:annotation>
            <xs:documentation>Quote Character.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="quoting" type="NLog.Layouts.CsvQuotingMode">
          <xs:annotation>
            <xs:documentation>Quoting mode.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="withHeader" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether CVS should include header.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:simpleType name="NLog.Layouts.CsvColumnDelimiterMode">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Auto" />
      <xs:enumeration value="Comma" />
      <xs:enumeration value="Semicolon" />
      <xs:enumeration value="Tab" />
      <xs:enumeration value="Pipe" />
      <xs:enumeration value="Space" />
      <xs:enumeration value="Custom" />
    </xs:restriction>
  </xs:simpleType>
  <xs:simpleType name="NLog.Layouts.CsvQuotingMode">
    <xs:restriction base="xs:string">
      <xs:enumeration value="All" />
      <xs:enumeration value="Nothing" />
      <xs:enumeration value="Auto" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="NLog.Layouts.CsvColumn">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
      <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
    </xs:choice>
    <xs:attribute name="layout" type="SimpleLayoutAttribute">
      <xs:annotation>
        <xs:documentation>Layout of the column.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="name" type="xs:string">
      <xs:annotation>
        <xs:documentation>Name of the column.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="JsonLayout">
    <xs:complexContent>
      <xs:extension base="Layout">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="attribute" minOccurs="0" maxOccurs="unbounded" type="NLog.Layouts.JsonAttribute" />
          <xs:element name="excludeProperties" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="includeAllProperties" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeMdc" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeMdlc" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="renderEmptyObject" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="suppressSpaces" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="maxRecursionLimit" minOccurs="0" maxOccurs="1" type="xs:integer" />
        </xs:choice>
        <xs:attribute name="excludeProperties" type="xs:string">
          <xs:annotation>
            <xs:documentation>List of property names to exclude when  is true</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeAllProperties" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Option to include all properties from the log event (as JSON)</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeMdc" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include contents of the  dictionary.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeMdlc" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include contents of the  dictionary.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="renderEmptyObject" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Option to render the empty object value {}</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="suppressSpaces" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Option to suppress the extra spaces in the output json</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxRecursionLimit" type="xs:integer">
          <xs:annotation>
            <xs:documentation>How far should the JSON serializer follow object references before backing off</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="NLog.Layouts.JsonAttribute">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
      <xs:element name="name" minOccurs="0" maxOccurs="1" type="xs:string" />
      <xs:element name="encode" minOccurs="0" maxOccurs="1" type="xs:boolean" />
      <xs:element name="escapeUnicode" minOccurs="0" maxOccurs="1" type="xs:boolean" />
      <xs:element name="includeEmptyValue" minOccurs="0" maxOccurs="1" type="xs:boolean" />
    </xs:choice>
    <xs:attribute name="layout" type="SimpleLayoutAttribute">
      <xs:annotation>
        <xs:documentation>Layout that will be rendered as the attribute's value.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="name" type="xs:string">
      <xs:annotation>
        <xs:documentation>Name of the attribute.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="encode" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Determines wether or not this attribute will be Json encoded.</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="escapeUnicode" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Indicates whether to escape non-ascii characters</xs:documentation>
      </xs:annotation>
    </xs:attribute>
    <xs:attribute name="includeEmptyValue" type="xs:boolean">
      <xs:annotation>
        <xs:documentation>Whether an attribute with empty value should be included in the output</xs:documentation>
      </xs:annotation>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="LayoutWithHeaderAndFooter">
    <xs:complexContent>
      <xs:extension base="Layout">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="footer" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="header" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
        </xs:choice>
        <xs:attribute name="footer" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Footer layout.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="header" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Header layout.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Body layout (can be repeated multiple times).</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="Log4JXmlEventLayout">
    <xs:complexContent>
      <xs:extension base="Layout">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="includeAllProperties" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeMdc" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeMdlc" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeNdc" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="includeNdlc" minOccurs="0" maxOccurs="1" type="xs:boolean" />
        </xs:choice>
        <xs:attribute name="includeAllProperties" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Option to include all properties from the log events</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeMdc" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include contents of the  dictionary.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeMdlc" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include contents of the  dictionary.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeNdc" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include contents of the  stack.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeNdlc" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to include contents of the  stack.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="SimpleLayout">
    <xs:complexContent>
      <xs:extension base="Layout">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="text" minOccurs="0" maxOccurs="1" type="xs:string" />
        </xs:choice>
        <xs:attribute name="text" type="xs:string">
          <xs:annotation>
            <xs:documentation>Layout text.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="when">
    <xs:complexContent>
      <xs:extension base="Filter">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="action" minOccurs="0" maxOccurs="1" type="FilterResult" />
          <xs:element name="condition" minOccurs="0" maxOccurs="1" type="Condition" />
        </xs:choice>
        <xs:attribute name="action" type="FilterResult">
          <xs:annotation>
            <xs:documentation>Action to be taken when filter matches.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="condition" type="Condition">
          <xs:annotation>
            <xs:documentation>Condition expression.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:simpleType name="FilterResult">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Neutral" />
      <xs:enumeration value="Log" />
      <xs:enumeration value="Ignore" />
      <xs:enumeration value="LogFinal" />
      <xs:enumeration value="IgnoreFinal" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="whenContains">
    <xs:complexContent>
      <xs:extension base="Filter">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="action" minOccurs="0" maxOccurs="1" type="FilterResult" />
          <xs:element name="ignoreCase" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="substring" minOccurs="0" maxOccurs="1" type="xs:string" />
        </xs:choice>
        <xs:attribute name="action" type="FilterResult">
          <xs:annotation>
            <xs:documentation>Action to be taken when filter matches.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="ignoreCase" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to ignore case when comparing strings.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Layout to be used to filter log messages.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="substring" type="xs:string">
          <xs:annotation>
            <xs:documentation>Substring to be matched.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="whenEqual">
    <xs:complexContent>
      <xs:extension base="Filter">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="action" minOccurs="0" maxOccurs="1" type="FilterResult" />
          <xs:element name="compareTo" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="ignoreCase" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
        </xs:choice>
        <xs:attribute name="action" type="FilterResult">
          <xs:annotation>
            <xs:documentation>Action to be taken when filter matches.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="compareTo" type="xs:string">
          <xs:annotation>
            <xs:documentation>String to compare the layout to.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="ignoreCase" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to ignore case when comparing strings.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Layout to be used to filter log messages.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="whenNotContains">
    <xs:complexContent>
      <xs:extension base="Filter">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="action" minOccurs="0" maxOccurs="1" type="FilterResult" />
          <xs:element name="ignoreCase" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="substring" minOccurs="0" maxOccurs="1" type="xs:string" />
        </xs:choice>
        <xs:attribute name="action" type="FilterResult">
          <xs:annotation>
            <xs:documentation>Action to be taken when filter matches.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="ignoreCase" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to ignore case when comparing strings.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Layout to be used to filter log messages.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="substring" type="xs:string">
          <xs:annotation>
            <xs:documentation>Substring to be matched.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="whenNotEqual">
    <xs:complexContent>
      <xs:extension base="Filter">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="action" minOccurs="0" maxOccurs="1" type="FilterResult" />
          <xs:element name="compareTo" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="ignoreCase" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
        </xs:choice>
        <xs:attribute name="action" type="FilterResult">
          <xs:annotation>
            <xs:documentation>Action to be taken when filter matches.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="compareTo" type="xs:string">
          <xs:annotation>
            <xs:documentation>String to compare the layout to.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="ignoreCase" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Indicates whether to ignore case when comparing strings.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Layout to be used to filter log messages.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="whenRepeated">
    <xs:complexContent>
      <xs:extension base="Filter">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element name="action" minOccurs="0" maxOccurs="1" type="FilterResult" />
          <xs:element name="defaultFilterCacheSize" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="includeFirst" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="layout" minOccurs="0" maxOccurs="1" type="Layout" />
          <xs:element name="maxFilterCacheSize" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="maxLength" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="timeoutSeconds" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="optimizeBufferDefaultLength" minOccurs="0" maxOccurs="1" type="xs:integer" />
          <xs:element name="optimizeBufferReuse" minOccurs="0" maxOccurs="1" type="xs:boolean" />
          <xs:element name="filterCountMessageAppendFormat" minOccurs="0" maxOccurs="1" type="xs:string" />
          <xs:element name="filterCountPropertyName" minOccurs="0" maxOccurs="1" type="xs:string" />
        </xs:choice>
        <xs:attribute name="action" type="FilterResult">
          <xs:annotation>
            <xs:documentation>Action to be taken when filter matches.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="defaultFilterCacheSize" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Default number of unique filter values to expect, will automatically increase if needed</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="includeFirst" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Applies the configured action to the initial logevent that starts the timeout period. Used to configure that it should ignore all events until timeout.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="layout" type="SimpleLayoutAttribute">
          <xs:annotation>
            <xs:documentation>Layout to be used to filter log messages.</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxFilterCacheSize" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Max number of unique filter values to expect simultaneously</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="maxLength" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Max length of filter values, will truncate if above limit</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="timeoutSeconds" type="xs:integer">
          <xs:annotation>
            <xs:documentation>How long before a filter expires, and logging is accepted again</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferDefaultLength" type="xs:integer">
          <xs:annotation>
            <xs:documentation>Default buffer size for the internal buffers</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="optimizeBufferReuse" type="xs:boolean">
          <xs:annotation>
            <xs:documentation>Reuse internal buffers, and doesn't have to constantly allocate new buffers</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="filterCountMessageAppendFormat" type="xs:string">
          <xs:annotation>
            <xs:documentation>Append FilterCount to the  when an event is no longer filtered</xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="filterCountPropertyName" type="xs:string">
          <xs:annotation>
            <xs:documentation>Insert FilterCount value into  when an event is no longer filtered</xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="AccurateLocal">
    <xs:complexContent>
      <xs:extension base="TimeSource">
        <xs:choice minOccurs="0" maxOccurs="unbounded" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="AccurateUTC">
    <xs:complexContent>
      <xs:extension base="TimeSource">
        <xs:choice minOccurs="0" maxOccurs="unbounded" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="FastLocal">
    <xs:complexContent>
      <xs:extension base="TimeSource">
        <xs:choice minOccurs="0" maxOccurs="unbounded" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
  <xs:complexType name="FastUTC">
    <xs:complexContent>
      <xs:extension base="TimeSource">
        <xs:choice minOccurs="0" maxOccurs="unbounded" />
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
</xs:schema>

6.此类实现金额的阿拉伯数字到大写汉字的转换

using System;
using System.Collections.Generic;
using System.Text;

namespace Utilities
{
    /// <summary>
    /// 此类实现金额的阿拉伯数字到大写汉字的转换
    /// </summary>
    public static class MoneyHelper
    {
        /// <summary>
        /// 转换数字金额主函数（包括小数）
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string ConvertSum(string str)
        {
            if (!IsPositveDecimal(str))
            {
                return "零";
            }

            if (Double.Parse(str) > 999999999999.99)
            {
                return "数字太大，无法换算，请输入一万亿元以下的金额";
            }

            char[] ch = new char[1];

            //小数点
            ch[0] = '.';

            //定义按小数点分割后的字符串数组 

            //按小数点分割字符串 
            string[] splitstr = str.Split(ch[0]);

            //只有整数部分 
            if (splitstr.Length == 1)
            {
                return ConvertData(str) + "圆整";
            }

            //转换整数部分 
            string rstr = ConvertData(splitstr[0]) + "圆";

            //转换小数部分 
            rstr += ConvertXiaoShu(splitstr[1]);

            //rstr = rstr.Replace("零万", "万");

            return rstr;
        }
        /// <summary>
        /// 需要转换的小数部分数字字符串
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private static string ConvertXiaoShu(string str)
        {
            int strlen = str.Length;
            string rstr;
            if (strlen == 1)
            {
                rstr = ConvertChinese(str) + "角";
                return rstr;
            }

            string tmpstr = str.Substring(0, 1);
            rstr = ConvertChinese(tmpstr) + "角";
            tmpstr = str.Substring(1, 1);
            rstr += ConvertChinese(tmpstr) + "分";
            rstr = rstr.Replace("零分", "");
            rstr = rstr.Replace("零角", "");

            return rstr;
        }
        /// <summary>
        /// 判断是否是正数字字符串 
        /// </summary>
        /// <param name="str"></param>
        /// <returns>如果是数字，返回true，否则返回false </returns>
        private static bool IsPositveDecimal(string str)
        {
            Decimal d;
            if (Decimal.TryParse(str, out d))
                return d > 0;
            else
                return false;
        }
        /// 转换数字（整数） 
        /// 需要转换的整数数字字符串 
        /// 转换成中文大写后的字符串 
        private static string ConvertData(string str)
        {
            string rstr = "";
            int strlen = str.Length;

            //数字长度小于四位
            if (strlen <= 4)
            {
                rstr = ConvertDigit(str);

            }
            else
            {
                string tmpstr;

                //数字长度大于四位，小于八位 
                if (strlen <= 8)
                {
                    //先截取最后四位数字
                    tmpstr = str.Substring(strlen - 4, 4);

                    //转换最后四位数字
                    rstr = ConvertDigit(tmpstr);

                    //截取其余数字 
                    tmpstr = str.Substring(0, strlen - 4);

                    //将两次转换的数字加上万后相连接 
                    rstr = String.Concat(ConvertDigit(tmpstr) + "万", rstr);
                    rstr = rstr.Replace("零万", "万");
                    rstr = rstr.Replace("零零", "零");
                }
                else
                {
                    //数字长度大于八位，小于十二位 
                    if (strlen <= 12)
                    {
                        //先截取最后四位数字 
                        tmpstr = str.Substring(strlen - 4, 4);

                        //转换最后四位数字 
                        rstr = ConvertDigit(tmpstr);

                        //再截取四位数字 
                        tmpstr = str.Substring(strlen - 8, 4);
                        rstr = String.Concat(ConvertDigit(tmpstr) + "万", rstr);
                        tmpstr = str.Substring(0, strlen - 8);
                        rstr = String.Concat(ConvertDigit(tmpstr) + "亿", rstr);
                        rstr = rstr.Replace("零亿", "亿");
                        rstr = rstr.Replace("零万", "万");
                        rstr = rstr.Replace("零零", "零");
                        rstr = rstr.Replace("零零", "零");
                    }
                }
            }

            strlen = rstr.Length;
            if (strlen >= 2)
            {
                switch (rstr.Substring(strlen - 2, 2))
                {
                    case "佰零": rstr = rstr.Substring(0, strlen - 2) + "佰"; break;
                    case "仟零": rstr = rstr.Substring(0, strlen - 2) + "仟"; break;
                    case "万零": rstr = rstr.Substring(0, strlen - 2) + "万"; break;
                    case "亿零": rstr = rstr.Substring(0, strlen - 2) + "亿"; break;
                }
            }
            return rstr;
        }
        /// <summary>
        /// 转换的字符串（四位以内）
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private static string ConvertDigit(string str)
        {
            int strlen = str.Length;
            string rstr = "";
            switch (strlen)
            {
                case 1: rstr = ConvertChinese(str); break;
                case 2: rstr = Convert2Digit(str); break;
                case 3: rstr = Convert3Digit(str); break;
                case 4: rstr = Convert4Digit(str); break;
            }
            rstr = rstr.Replace("拾零", "拾");
            return rstr;
        }
        /// <summary>
        /// 转换四位数字
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private static string Convert4Digit(string str)
        {
            string str1 = str.Substring(0, 1);
            string str2 = str.Substring(1, 1);
            string str3 = str.Substring(2, 1);
            string str4 = str.Substring(3, 1);
            string rstring = "";
            rstring += ConvertChinese(str1) + "仟";
            rstring += ConvertChinese(str2) + "佰";
            rstring += ConvertChinese(str3) + "拾";
            rstring += ConvertChinese(str4);
            rstring = rstring.Replace("零仟", "零");
            rstring = rstring.Replace("零佰", "零");
            rstring = rstring.Replace("零拾", "零");
            rstring = rstring.Replace("零零", "零");
            rstring = rstring.Replace("零零", "零");
            rstring = rstring.Replace("零零", "零");
            return rstring;
        }
        /// <summary>
        /// 转换三位数字
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private static string Convert3Digit(string str)
        {
            string str1 = str.Substring(0, 1);
            string str2 = str.Substring(1, 1);
            string str3 = str.Substring(2, 1);
            string rstring = "";
            rstring += ConvertChinese(str1) + "佰";
            rstring += ConvertChinese(str2) + "拾";
            rstring += ConvertChinese(str3);
            rstring = rstring.Replace("零佰", "零");
            rstring = rstring.Replace("零拾", "零");
            rstring = rstring.Replace("零零", "零");
            rstring = rstring.Replace("零零", "零");
            return rstring;
        }
        /// <summary>
        /// 转换二位数字
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private static string Convert2Digit(string str)
        {
            string str1 = str.Substring(0, 1);
            string str2 = str.Substring(1, 1);
            string rstring = "";
            rstring += ConvertChinese(str1) + "拾";
            rstring += ConvertChinese(str2);
            rstring = rstring.Replace("零拾", "零");
            rstring = rstring.Replace("零零", "零");
            return rstring;
        }
        /// <summary>
        /// 将一位数字转换成中文大写数字 
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private static string ConvertChinese(string str)
        {
            //"零壹贰叁肆伍陆柒捌玖拾佰仟万亿圆整角分" 
            string cstr = "";
            switch (str)
            {
                case "0":
                    cstr = "零";
                    break;
                case "1":
                    cstr = "壹";
                    break;
                case "2":
                    cstr = "贰";
                    break;
                case "3":
                    cstr = "叁";
                    break;
                case "4":
                    cstr = "肆";
                    break;
                case "5":
                    cstr = "伍";
                    break;
                case "6":
                    cstr = "陆";
                    break;
                case "7":
                    cstr = "柒";
                    break;
                case "8":
                    cstr = "捌";
                    break;
                case "9":
                    cstr = "玖";
                    break;
            }

            return (cstr);
        }
    }
}

7.邮件发送的帮助类

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Mail;
using System.Text;

namespace Utilities
{
    /// <summary>
    /// 邮件发送的帮助类
    /// </summary>
    public class NetHelper
    {      

        #region 下载公开网页资源
        /// <summary>
        /// 下载指定路径的网页内容
        /// </summary>
        /// <param name="url">网页路径，可以是html、css、js等</param>
        /// <returns></returns>
        public static string DownContent(string url)
        {
            try
            {
                WebClient client = new WebClient();
                Stream strm = client.OpenRead(url);
                using (StreamReader sr = new StreamReader(strm))
                {
                    return sr.ReadToEnd();
                }
            }
            catch (Exception exp)
            {
                LogHelper.Default.Error("{ time:'" + DateTime.Now + "',msg:'" + exp.Message + exp.StackTrace + "'}");
            }
            return "";
        }
        #endregion

        #region 发送电子邮件

        /// <summary> 
        /// 发送邮件程序 
        /// </summary> 
        /// <param name="from">发送人邮件地址</param> 
        /// <param name="fromName">发送人显示名称</param> 
        /// <param name="to">发送给谁（邮件地址）</param> 
        /// <param name="subject">标题</param> 
        /// <param name="body">内容</param> 
        /// <param name="username">邮件登录名</param> 
        /// <param name="password">邮件密码</param> 
        /// <param name="server">邮件服务器,例如：smtp.126.com </param> 
        /// <param name="fujian">附件,例如： C:\\a.txt;D:\\b.rar</param> 
        /// <param name="port">端口,例如：25</param> 
        /// <returns>是否发送成功</returns> 
        public static bool SendEMail(string from, string fromName, string to, string subject, string body,
            string username, string password, string server, string fujian, int port = 25)
        {
            try
            {
                MailMessage mail = new MailMessage(); //创建邮件信息对象                
                mail.From = new MailAddress(from, fromName); //是谁发送的邮件 
                mail.To.Add(to);//发送给谁
                mail.Subject = subject;//标题               
                mail.BodyEncoding = Encoding.UTF8;//内容编码
                mail.Priority = MailPriority.High;//发送优先级
                mail.Body = body;//邮件内容 
                mail.IsBodyHtml = false;//是否HTML形式发送 
                //附件 
                string[] fjs = fujian.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
                if(fjs !=null && fjs.Length > 0)
                {
                    for (int i = 0; i < fjs.Length; i++)
                        mail.Attachments.Add(new Attachment(fjs[i]));
                }
                SmtpClient smtp = new SmtpClient(server, port); //smtp邮件服务器和端口                
                smtp.UseDefaultCredentials = true;
                smtp.DeliveryMethod = SmtpDeliveryMethod.Network;//指定发送方式 
                smtp.Credentials = new System.Net.NetworkCredential(username, password);//指定登录名和密码 
                smtp.Timeout = 10000;//超时时间 
                smtp.Send(mail);
                return true;
            }
            catch (SmtpException exp)
            {
                LogHelper.Default.Error("{ time:'" + DateTime.Now + "',msg:'" + exp.Message + exp.StackTrace + "'}");
                return false;
            }
            catch (Exception exp)
            {
                LogHelper.Default.Error("{ time:'"+ DateTime.Now+"',msg:'" + exp.Message+exp.StackTrace+"'}");
                return false;
            }
        }

        #endregion
    }
}

8.在Silverlight中，微软并没有提供DataSet，DataTable对象，但当进行非常灵活的设计时，又是非常必要的
这里提供一个简易型的PDataSet对象,作为在客户端使用还是非常方便的。

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Linq;
using System.Xml.Linq;

namespace Utilities
{

    /// <summary>
    /// 在Silverlight中，微软并没有提供DataSet，DataTable对象，但当进行非常灵活的设计时，又是非常必要的
    /// 这里提供一个简易型的PDataSet对象,作为在客户端使用还是非常方便的。
    /// <example>
    /// PDataSet pds = new PDataSet(res);
    /// ObservableCollection<DetailModel> list = new ObservableCollection<DetailModel>();
    /// foreach (PDataRow v in pds.Tables[0].Rows)
    /// {
    ///     DetailModel dm = new DetailModel { FileName = v["FileName"], Path = _siteUrl + "/" + v["FilePath"], Size = Convert.ToInt64(v["FileSize"]) };
    ///     list.Add(dm);
    /// }
    /// this.fileView.ItemSource = list;   
    /// </example>
    /// </summary>
    public class PDataSet
    {
        /// <summary>
        /// 从指定格式的xml字符串中，生成自定义的PDataSet对象
        /// </summary>
        /// <seealso cref="TransferConvert.ToXml(this DataSet ds)"/>
        /// <param name="xml">由TransferConvert.ToXml方法生成的xml字符串</param>
        public PDataSet(string xml)
        {
            var xDoc = XDocument.Parse(xml);
            var root = xDoc.Root.Element("Tables").Elements();
            var index = 0;
            this.Result = xml;
            this.Tables = new List<PDataTable>(root.Count());

            foreach (XElement elem in root)
            {
                var columns = elem.Element("Columns").Nodes();
                var rows = elem.Element("Rows").Nodes();
                this.Tables.Add(new PDataTable(columns.Count()));
                this.Tables[index].Name = elem.Attribute("Name").Value;
                //初始化列
                foreach (XElement firstNode in columns)
                    this.Tables[index].Columns.Add(new PDataColumn { Name = firstNode.Name.LocalName, DataType = firstNode.Attribute("DataType").Value });
                //填充行数据
                foreach (XElement lastNode in rows)
                {
                    var atts = lastNode.Attributes();
                    PDataRow row = this.Tables[index].NewRow();
                    this.Tables[index].Rows.Add(row);
                    int i = 0;
                    foreach (XAttribute att in atts)
                        row[i++] = att.Value;
                }
                index++;
            }
        }

        /// <summary>
        /// 获取数据集中的所有表
        /// </summary>
        public List<PDataTable> Tables { get; private set; }
        /// <summary>
        /// 获取指定名称的数据表
        /// </summary>
        /// <param name="tableName"></param>
        /// <returns></returns>
        public PDataTable GetTable(string tableName)
        {
            foreach (PDataTable dt in Tables)
            {
                if (dt.Name == tableName.ToLower())
                    return dt;
            }
            return null;
        }
        /// <summary>
        /// 获取原始的构造字符串
        /// </summary>
        public string Result { get; private set; }
    }
    /// <summary>
    /// PDataSet中表的定义
    /// </summary>
    public class PDataTable
    {
        /// <summary>
        /// 创建表对象
        /// </summary>
        public PDataTable() { }
        /// <summary>
        /// 创建指定列数的表对象
        /// </summary>
        /// <param name="columnCount"></param>
        public PDataTable(int columnCount)
        {
            this.Columns = new List<PDataColumn>(columnCount);
            this.Rows = new List<PDataRow>();
        }
        /// <summary>
        /// 获取或设置表名称
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// 获取或设置列集合
        /// </summary>
        public List<PDataColumn> Columns { get; set; }
        /// <summary>
        /// 获取此表的数据行
        /// </summary>
        public List<PDataRow> Rows { get; private set; }

        /// <summary>
        /// 创建一个新数据行
        /// </summary>
        public PDataRow NewRow()
        {
            return new PDataRow(this, Columns.Count);
        }
        /// <summary>
        /// 向表中添加列
        /// </summary>
        /// <param name="columnName">列名</param>
        public void NewColumn(string columnName)
        {
            NewColumn(columnName, "");
        }
        /// <summary>
        /// 向表中添加列
        /// </summary>
        /// <param name="columnName">列名</param>
        /// <param name="defValue">该列的默认值</param>
        /// <returns>true：添加成功 false:已经存在同名列</returns>
        public void NewColumn(string columnName, string defValue)
        {
            NewColumn(columnName, defValue, "System.String");
        }
        /// <summary>
        /// 向表中添加列
        /// </summary>
        /// <param name="columnName">列名</param>
        /// <param name="defValue">默认值</param>
        /// <param name="columnType">列类型</param>
        public void NewColumn(string columnName, string defValue, string columnType)
        {
            if (this.Columns.Where(p => p.Name.ToLower() == columnName.ToLower()).Count() > 0)
                throw new Exception("不能添加同名的列(注意:列名不区分大小写)");
            else
            {
                this.Columns.Add(new PDataColumn { Name = columnName, DataType = columnType });
                foreach (var r in this.Rows)
                    r._values.Add(defValue);
            }
        }

        //public override string ToString()
        //{
        //    StringBuilder sb = new StringBuilder();
        //    int colNum = this.Columns.Count;
        //    for (int j = 0; j < colNum; ++j)
        //    {
        //        if (j == 0)
        //            sb.Append(this.Columns[j].Name);
        //        else
        //            sb.Append("#" + this.Columns[j].Name);
        //    }
        //    sb.Append("\r\n");
        //    //加载展示数据
        //    int i = 0;
        //    foreach (var c in this.Rows)
        //    {
        //        for (i = 0; i < colNum; i++)
        //        {
        //            if (i == 0)
        //                sb.Append(c[i]);
        //            else
        //                sb.Append("#" + c[i]);
        //        }
        //        sb.Append("\r\n");
        //    }
        //    return sb.ToString();
        //}
    }

    /// <summary>
    /// PDataSet中行的定义
    /// </summary>
    public class PDataRow
    {
        public PDataRow(PDataTable parentTable, int columnCount)
        {
            this._table = parentTable;
            this._values = new List<string>(columnCount);
            for (int i = 0; i < columnCount; i++)
                this._values.Add("");
        }
        /// <summary>
        /// 为进行Id比较专门留的一个构造方法
        /// </summary>
        /// <example>
        /// pds.Tables[0].Rows.BinarySearch(new PDataRow("3"), new IdComparer())//IdComparer是一个实现了IComparer<PDataRow>接口的类        /// 
        /// </example>
        /// <param name="id"></param>
        public PDataRow(string id)
        {
            this._values = new List<string>(1);
            this._values.Add(id);
        }
        public PDataTable _table;
        internal List<string> _values;
        /// <summary>
        /// 获取隶属表的列名
        /// </summary>
        internal List<string> _columnNames
        {
            get
            {
                return _table.Columns.Select(p => p.Name).ToList<string>();
            }
        }

        public string this[int index]
        {
            get
            {
                if (index < 0 || index >= _values.Capacity)
                    throw new IndexOutOfRangeException("超出了取值范围");
                else
                    return _values[index];
            }
            set
            {
                if (index < 0 || index > _values.Capacity)
                    throw new IndexOutOfRangeException();
                else
                {
                    _values[index] = value;
                }
            }
        }

        public string this[string key]
        {
            get
            {
                int i = 0;
                foreach (string str in _columnNames)
                {
                    if (str.ToLower() == key.ToLower())
                        return _values[i];
                    i++;
                }
                throw new Exception("您提供的列名不存在");
            }
            set
            {
                for (int i = 0; i < _columnNames.Count; i++)
                {
                    if (_columnNames[i] == key)
                    {
                        _values[i] = value;
                        return;
                    }
                }
            }
        }
    }

    /// <summary>
    /// PDataSet中列的定义
    /// </summary>
    public class PDataColumn
    {
        /// <summary>
        /// 列名
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// 类型名称
        /// </summary>
        public string DataType { get; set; }
    }
}

9.需要使用nuget获取itextsharp

 1 using System;
 2 using System.Collections.Generic;
 3 using System.IO;
 4 using System.Linq;
 5 using System.Text;
 6 using iTextSharp.text;
 7 using iTextSharp.text.pdf;
 8 using iTextSharp.tool.xml;
 9 
10 
11 namespace Utilities
12 {
13     /// <summary>
14     /// 需要使用nuget获取itextsharp
15     /// </summary>
16     public class PdfHelper
17     {
18         /// <summary>
19         /// 注意事项
20         /// 1:html标签必须闭合，符合规范
21         /// 2:目前暂不支持link样式导入，只能写style
22         /// 使用示例：
23         /// WebClient wc = new WebClient();
24         /// 从网址下载Html字串
25         /// string htmlText = wc.DownloadString("http://localhost:6953/test.html");
26         /// byte[] pdfFile = PdfHelper.ConvertHtmlTextToPdf(htmlText);
27         /// return File(pdfFile, "application/pdf", "测试.pdf");
28         /// </summary>
29         /// <param name="htmlText">html格式的字符串</param>
30         /// <returns></returns>
31         public static byte[] ConvertHtmlTextToPdf(string htmlText)
32         {
33             if (string.IsNullOrEmpty(htmlText))
34             {
35                 return null;
36             }
37             //避免当htmlText无任何html tag标签的纯文字时，转PDF时会挂掉，所以一律加上<p>标签
38             htmlText = "<p>" + htmlText + "</p>";
39 
40             MemoryStream outputStream = new MemoryStream();//要把PDF写到哪个串流
41             byte[] data = Encoding.UTF8.GetBytes(htmlText);//字串转成byte[]
42             MemoryStream msInput = new MemoryStream(data);
43             Document doc = new Document();//要写PDF的文件，建构子没填的话预设直式A4
44             PdfWriter writer = PdfWriter.GetInstance(doc, outputStream);
45             //指定文件预设开档时的缩放为100%
46             PdfDestination pdfDest = new PdfDestination(PdfDestination.XYZ, 0, doc.PageSize.Height, 1f);
47             //开启Document文件 
48             doc.Open();
49             
50             //使用XMLWorkerHelper把Html parse到PDF档里
51             XMLWorkerHelper.GetInstance().ParseXHtml(writer, doc, msInput, null, Encoding.UTF8, new UnicodeFontFactory());
52             //将pdfDest设定的资料写到PDF档
53             PdfAction action = PdfAction.GotoLocalPage(1, pdfDest, writer);
54             writer.SetOpenAction(action);
55             doc.Close();
56             msInput.Close();
57             outputStream.Close();
58             //回传PDF档案 
59             return outputStream.ToArray();
60         }
61     }
62     /// <summary>
63     /// 字体工厂类
64     /// </summary>
65     public class UnicodeFontFactory : FontFactoryImp
66     {
67         /// <summary>
68         /// 定义一个pdf使用的字体，这里选择的是微软雅黑
69         /// </summary>
70         private static readonly string yh = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Fonts),
71           "msyh.ttc,0");
72         /// <summary>
73         /// 定义一个pdf使用的字体，这里选择的是楷体
74         /// </summary>
75         private static readonly string 标楷体Path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Fonts),
76           "simkai.ttf"); 
77 
78         /// <summary>
79         /// 
80         /// </summary>
81         /// <param name="fontname"></param>
82         /// <param name="encoding"></param>
83         /// <param name="embedded"></param>
84         /// <param name="size"></param>
85         /// <param name="style"></param>
86         /// <param name="color"></param>
87         /// <param name="cached"></param>
88         /// <returns></returns>
89         public override Font GetFont(string fontname, string encoding, bool embedded, float size, int style, BaseColor color,
90           bool cached)
91         {
92             //可用雅黑字体或标楷体，自己选一个
93             BaseFont baseFont = BaseFont.CreateFont(yh, BaseFont.IDENTITY_H, BaseFont.EMBEDDED);
94             return new Font(baseFont, size, style, color);
95         }
96     }
97 }

10.汉字拼音转换类

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

namespace Utilities
{
    /// <summary>
    /// 汉字拼音转换类
    /// </summary>
    public class PinYinConverter
    {
        #region 数组信息

        private static int[] pyValue = new int[] 

        {
            -20319, -20317, -20304, -20295, -20292, -20283, -20265, -20257, -20242, 

            -20230, -20051, -20036, -20032, -20026, -20002, -19990, -19986, -19982,

            -19976, -19805, -19784, -19775, -19774, -19763, -19756, -19751, -19746, 

            -19741, -19739, -19728, -19725, -19715, -19540, -19531, -19525, -19515, 

            -19500, -19484, -19479, -19467, -19289, -19288, -19281, -19275, -19270, 

            -19263, -19261, -19249, -19243, -19242, -19238, -19235, -19227, -19224, 

            -19218, -19212, -19038, -19023, -19018, -19006, -19003, -18996, -18977,

            -18961, -18952, -18783, -18774, -18773, -18763, -18756, -18741, -18735, 

            -18731, -18722, -18710, -18697, -18696, -18526, -18518, -18501, -18490,

            -18478, -18463, -18448, -18447, -18446, -18239, -18237, -18231, -18220,

            -18211, -18201, -18184, -18183, -18181, -18012, -17997, -17988, -17970, 

            -17964, -17961, -17950, -17947, -17931, -17928, -17922, -17759, -17752, 

            -17733, -17730, -17721, -17703, -17701, -17697, -17692, -17683, -17676,

            -17496, -17487, -17482, -17468, -17454, -17433, -17427, -17417, -17202, 

            -17185, -16983, -16970, -16942, -16915, -16733, -16708, -16706, -16689, 

            -16664, -16657, -16647, -16474, -16470, -16465, -16459, -16452, -16448, 

            -16433, -16429, -16427, -16423, -16419, -16412, -16407, -16403, -16401, 

            -16393, -16220, -16216, -16212, -16205, -16202, -16187, -16180, -16171,

            -16169, -16158, -16155, -15959, -15958, -15944, -15933, -15920, -15915, 

            -15903, -15889, -15878, -15707, -15701, -15681, -15667, -15661, -15659, 

            -15652, -15640, -15631, -15625, -15454, -15448, -15436, -15435, -15419,

            -15416, -15408, -15394, -15385, -15377, -15375, -15369, -15363, -15362, 

            -15183, -15180, -15165, -15158, -15153, -15150, -15149, -15144, -15143, 

            -15141, -15140, -15139, -15128, -15121, -15119, -15117, -15110, -15109, 

            -14941, -14937, -14933, -14930, -14929, -14928, -14926, -14922, -14921,

            -14914, -14908, -14902, -14894, -14889, -14882, -14873, -14871, -14857, 

            -14678, -14674, -14670, -14668, -14663, -14654, -14645, -14630, -14594,

            -14429, -14407, -14399, -14384, -14379, -14368, -14355, -14353, -14345,

            -14170, -14159, -14151, -14149, -14145, -14140, -14137, -14135, -14125, 

            -14123, -14122, -14112, -14109, -14099, -14097, -14094, -14092, -14090, 

            -14087, -14083, -13917, -13914, -13910, -13907, -13906, -13905, -13896, 

            -13894, -13878, -13870, -13859, -13847, -13831, -13658, -13611, -13601,

            -13406, -13404, -13400, -13398, -13395, -13391, -13387, -13383, -13367, 

            -13359, -13356, -13343, -13340, -13329, -13326, -13318, -13147, -13138, 

            -13120, -13107, -13096, -13095, -13091, -13076, -13068, -13063, -13060, 

            -12888, -12875, -12871, -12860, -12858, -12852, -12849, -12838, -12831,

            -12829, -12812, -12802, -12607, -12597, -12594, -12585, -12556, -12359,

            -12346, -12320, -12300, -12120, -12099, -12089, -12074, -12067, -12058,

            -12039, -11867, -11861, -11847, -11831, -11798, -11781, -11604, -11589, 

            -11536, -11358, -11340, -11339, -11324, -11303, -11097, -11077, -11067,

            -11055, -11052, -11045, -11041, -11038, -11024, -11020, -11019, -11018,

            -11014, -10838, -10832, -10815, -10800, -10790, -10780, -10764, -10587,

            -10544, -10533, -10519, -10331, -10329, -10328, -10322, -10315, -10309, 

            -10307, -10296, -10281, -10274, -10270, -10262, -10260, -10256, -10254 

        };

        private static string[] pyName = new string[]

         { 
             "A", "Ai", "An", "Ang", "Ao", "Ba", "Bai", "Ban", "Bang", "Bao", "Bei", 

             "Ben", "Beng", "Bi", "Bian", "Biao", "Bie", "Bin", "Bing", "Bo", "Bu",

             "Ba", "Cai", "Can", "Cang", "Cao", "Ce", "Ceng", "Cha", "Chai", "Chan",

             "Chang", "Chao", "Che", "Chen", "Cheng", "Chi", "Chong", "Chou", "Chu",

             "Chuai", "Chuan", "Chuang", "Chui", "Chun", "Chuo", "Ci", "Cong", "Cou",

             "Cu", "Cuan", "Cui", "Cun", "Cuo", "Da", "Dai", "Dan", "Dang", "Dao", "De", 

             "Deng", "Di", "Dian", "Diao", "Die", "Ding", "Diu", "Dong", "Dou", "Du", 

             "Duan", "Dui", "Dun", "Duo", "E", "En", "Er", "Fa", "Fan", "Fang", "Fei", 

             "Fen", "Feng", "Fo", "Fou", "Fu", "Ga", "Gai", "Gan", "Gang", "Gao", "Ge", 

             "Gei", "Gen", "Geng", "Gong", "Gou", "Gu", "Gua", "Guai", "Guan", "Guang", 

             "Gui", "Gun", "Guo", "Ha", "Hai", "Han", "Hang", "Hao", "He", "Hei", "Hen", 

             "Heng", "Hong", "Hou", "Hu", "Hua", "Huai", "Huan", "Huang", "Hui", "Hun",

             "Huo", "Ji", "Jia", "Jian", "Jiang", "Jiao", "Jie", "Jin", "Jing", "Jiong", 

             "Jiu", "Ju", "Juan", "Jue", "Jun", "Ka", "Kai", "Kan", "Kang", "Kao", "Ke",

             "Ken", "Keng", "Kong", "Kou", "Ku", "Kua", "Kuai", "Kuan", "Kuang", "Kui", 

             "Kun", "Kuo", "La", "Lai", "Lan", "Lang", "Lao", "Le", "Lei", "Leng", "Li",

             "Lia", "Lian", "Liang", "Liao", "Lie", "Lin", "Ling", "Liu", "Long", "Lou", 

             "Lu", "Lv", "Luan", "Lue", "Lun", "Luo", "Ma", "Mai", "Man", "Mang", "Mao",

             "Me", "Mei", "Men", "Meng", "Mi", "Mian", "Miao", "Mie", "Min", "Ming", "Miu",

             "Mo", "Mou", "Mu", "Na", "Nai", "Nan", "Nang", "Nao", "Ne", "Nei", "Nen", 

             "Neng", "Ni", "Nian", "Niang", "Niao", "Nie", "Nin", "Ning", "Niu", "Nong", 

             "Nu", "Nv", "Nuan", "Nue", "Nuo", "O", "Ou", "Pa", "Pai", "Pan", "Pang",

             "Pao", "Pei", "Pen", "Peng", "Pi", "Pian", "Piao", "Pie", "Pin", "Ping", 

             "Po", "Pu", "Qi", "Qia", "Qian", "Qiang", "Qiao", "Qie", "Qin", "Qing",

             "Qiong", "Qiu", "Qu", "Quan", "Que", "Qun", "Ran", "Rang", "Rao", "Re",

             "Ren", "Reng", "Ri", "Rong", "Rou", "Ru", "Ruan", "Rui", "Run", "Ruo", 

             "Sa", "Sai", "San", "Sang", "Sao", "Se", "Sen", "Seng", "Sha", "Shai", 

             "Shan", "Shang", "Shao", "She", "Shen", "Sheng", "Shi", "Shou", "Shu", 

             "Shua", "Shuai", "Shuan", "Shuang", "Shui", "Shun", "Shuo", "Si", "Song", 

             "Sou", "Su", "Suan", "Sui", "Sun", "Suo", "Ta", "Tai", "Tan", "Tang", 

             "Tao", "Te", "Teng", "Ti", "Tian", "Tiao", "Tie", "Ting", "Tong", "Tou",

             "Tu", "Tuan", "Tui", "Tun", "Tuo", "Wa", "Wai", "Wan", "Wang", "Wei",

             "Wen", "Weng", "Wo", "Wu", "Xi", "Xia", "Xian", "Xiang", "Xiao", "Xie",

             "Xin", "Xing", "Xiong", "Xiu", "Xu", "Xuan", "Xue", "Xun", "Ya", "Yan",

             "Yang", "Yao", "Ye", "Yi", "Yin", "Ying", "Yo", "Yong", "You", "Yu", 

             "Yuan", "Yue", "Yun", "Za", "Zai", "Zan", "Zang", "Zao", "Ze", "Zei",

             "Zen", "Zeng", "Zha", "Zhai", "Zhan", "Zhang", "Zhao", "Zhe", "Zhen", 

             "Zheng", "Zhi", "Zhong", "Zhou", "Zhu", "Zhua", "Zhuai", "Zhuan", 

             "Zhuang", "Zhui", "Zhun", "Zhuo", "Zi", "Zong", "Zou", "Zu", "Zuan",

             "Zui", "Zun", "Zuo" 
         };

        #region 二级汉字
        /// <summary>
        /// 二级汉字数组
        /// </summary>
        private static string[] otherChinese = new string[]
        {
            "亍","丌","兀","丐","廿","卅","丕","亘","丞","鬲","孬","噩","丨","禺","丿"
            ,"匕","乇","夭","爻","卮","氐","囟","胤","馗","毓","睾","鼗","丶","亟","鼐","乜"
            ,"乩","亓","芈","孛","啬","嘏","仄","厍","厝","厣","厥","厮","靥","赝","匚","叵"
            ,"匦","匮","匾","赜","卦","卣","刂","刈","刎","刭","刳","刿","剀","剌","剞","剡"
            ,"剜","蒯","剽","劂","劁","劐","劓","冂","罔","亻","仃","仉","仂","仨","仡","仫"
            ,"仞","伛","仳","伢","佤","仵","伥","伧","伉","伫","佞","佧","攸","佚","佝"
            ,"佟","佗","伲","伽","佶","佴","侑","侉","侃","侏","佾","佻","侪","佼","侬"
            ,"侔","俦","俨","俪","俅","俚","俣","俜","俑","俟","俸","倩","偌","俳","倬","倏"
            ,"倮","倭","俾","倜","倌","倥","倨","偾","偃","偕","偈","偎","偬","偻","傥","傧"
            ,"傩","傺","僖","儆","僭","僬","僦","僮","儇","儋","仝","氽","佘","佥","俎","龠"
            ,"汆","籴","兮","巽","黉","馘","冁","夔","勹","匍","訇","匐","凫","夙","兕","亠"
            ,"兖","亳","衮","袤","亵","脔","裒","禀","嬴","蠃","羸","冫","冱","冽","冼"
            ,"凇","冖","冢","冥","讠","讦","讧","讪","讴","讵","讷","诂","诃","诋","诏"
            ,"诎","诒","诓","诔","诖","诘","诙","诜","诟","诠","诤","诨","诩","诮","诰","诳"
            ,"诶","诹","诼","诿","谀","谂","谄","谇","谌","谏","谑","谒","谔","谕","谖","谙"
            ,"谛","谘","谝","谟","谠","谡","谥","谧","谪","谫","谮","谯","谲","谳","谵","谶"
            ,"卩","卺","阝","阢","阡","阱","阪","阽","阼","陂","陉","陔","陟","陧","陬","陲"
            ,"陴","隈","隍","隗","隰","邗","邛","邝","邙","邬","邡","邴","邳","邶","邺"
            ,"邸","邰","郏","郅","邾","郐","郄","郇","郓","郦","郢","郜","郗","郛","郫"
            ,"郯","郾","鄄","鄢","鄞","鄣","鄱","鄯","鄹","酃","酆","刍","奂","劢","劬","劭"
            ,"劾","哿","勐","勖","勰","叟","燮","矍","廴","凵","凼","鬯","厶","弁","畚","巯"
            ,"坌","垩","垡","塾","墼","壅","壑","圩","圬","圪","圳","圹","圮","圯","坜","圻"
            ,"坂","坩","垅","坫","垆","坼","坻","坨","坭","坶","坳","垭","垤","垌","垲","埏"
            ,"垧","垴","垓","垠","埕","埘","埚","埙","埒","垸","埴","埯","埸","埤","埝"
            ,"堋","堍","埽","埭","堀","堞","堙","塄","堠","塥","塬","墁","墉","墚","墀"
            ,"馨","鼙","懿","艹","艽","艿","芏","芊","芨","芄","芎","芑","芗","芙","芫","芸"
            ,"芾","芰","苈","苊","苣","芘","芷","芮","苋","苌","苁","芩","芴","芡","芪","芟"
            ,"苄","苎","芤","苡","茉","苷","苤","茏","茇","苜","苴","苒","苘","茌","苻","苓"
            ,"茑","茚","茆","茔","茕","苠","苕","茜","荑","荛","荜","茈","莒","茼","茴","茱"
            ,"莛","荞","茯","荏","荇","荃","荟","荀","茗","荠","茭","茺","茳","荦","荥"
            ,"荨","茛","荩","荬","荪","荭","荮","莰","荸","莳","莴","莠","莪","莓","莜"
            ,"莅","荼","莶","莩","荽","莸","荻","莘","莞","莨","莺","莼","菁","萁","菥","菘"
            ,"堇","萘","萋","菝","菽","菖","萜","萸","萑","萆","菔","菟","萏","萃","菸","菹"
            ,"菪","菅","菀","萦","菰","菡","葜","葑","葚","葙","葳","蒇","蒈","葺","蒉","葸"
            ,"萼","葆","葩","葶","蒌","蒎","萱","葭","蓁","蓍","蓐","蓦","蒽","蓓","蓊","蒿"
            ,"蒺","蓠","蒡","蒹","蒴","蒗","蓥","蓣","蔌","甍","蔸","蓰","蔹","蔟","蔺"
            ,"蕖","蔻","蓿","蓼","蕙","蕈","蕨","蕤","蕞","蕺","瞢","蕃","蕲","蕻","薤"
            ,"薨","薇","薏","蕹","薮","薜","薅","薹","薷","薰","藓","藁","藜","藿","蘧","蘅"
            ,"蘩","蘖","蘼","廾","弈","夼","奁","耷","奕","奚","奘","匏","尢","尥","尬","尴"
            ,"扌","扪","抟","抻","拊","拚","拗","拮","挢","拶","挹","捋","捃","掭","揶","捱"
            ,"捺","掎","掴","捭","掬","掊","捩","掮","掼","揲","揸","揠","揿","揄","揞","揎"
            ,"摒","揆","掾","摅","摁","搋","搛","搠","搌","搦","搡","摞","撄","摭","撖"
            ,"摺","撷","撸","撙","撺","擀","擐","擗","擤","擢","攉","攥","攮","弋","忒"
            ,"甙","弑","卟","叱","叽","叩","叨","叻","吒","吖","吆","呋","呒","呓","呔","呖"
            ,"呃","吡","呗","呙","吣","吲","咂","咔","呷","呱","呤","咚","咛","咄","呶","呦"
            ,"咝","哐","咭","哂","咴","哒","咧","咦","哓","哔","呲","咣","哕","咻","咿","哌"
            ,"哙","哚","哜","咩","咪","咤","哝","哏","哞","唛","哧","唠","哽","唔","哳","唢"
            ,"唣","唏","唑","唧","唪","啧","喏","喵","啉","啭","啁","啕","唿","啐","唼"
            ,"唷","啖","啵","啶","啷","唳","唰","啜","喋","嗒","喃","喱","喹","喈","喁"
            ,"喟","啾","嗖","喑","啻","嗟","喽","喾","喔","喙","嗪","嗷","嗉","嘟","嗑","嗫"
            ,"嗬","嗔","嗦","嗝","嗄","嗯","嗥","嗲","嗳","嗌","嗍","嗨","嗵","嗤","辔","嘞"
            ,"嘈","嘌","嘁","嘤","嘣","嗾","嘀","嘧","嘭","噘","嘹","噗","嘬","噍","噢","噙"
            ,"噜","噌","噔","嚆","噤","噱","噫","噻","噼","嚅","嚓","嚯","囔","囗","囝","囡"
            ,"囵","囫","囹","囿","圄","圊","圉","圜","帏","帙","帔","帑","帱","帻","帼"
            ,"帷","幄","幔","幛","幞","幡","岌","屺","岍","岐","岖","岈","岘","岙","岑"
            ,"岚","岜","岵","岢","岽","岬","岫","岱","岣","峁","岷","峄","峒","峤","峋","峥"
            ,"崂","崃","崧","崦","崮","崤","崞","崆","崛","嵘","崾","崴","崽","嵬","嵛","嵯"
            ,"嵝","嵫","嵋","嵊","嵩","嵴","嶂","嶙","嶝","豳","嶷","巅","彳","彷","徂","徇"
            ,"徉","後","徕","徙","徜","徨","徭","徵","徼","衢","彡","犭","犰","犴","犷","犸"
            ,"狃","狁","狎","狍","狒","狨","狯","狩","狲","狴","狷","猁","狳","猃","狺"
            ,"狻","猗","猓","猡","猊","猞","猝","猕","猢","猹","猥","猬","猸","猱","獐"
            ,"獍","獗","獠","獬","獯","獾","舛","夥","飧","夤","夂","饣","饧","饨","饩","饪"
            ,"饫","饬","饴","饷","饽","馀","馄","馇","馊","馍","馐","馑","馓","馔","馕","庀"
            ,"庑","庋","庖","庥","庠","庹","庵","庾","庳","赓","廒","廑","廛","廨","廪","膺"
            ,"忄","忉","忖","忏","怃","忮","怄","忡","忤","忾","怅","怆","忪","忭","忸","怙"
            ,"怵","怦","怛","怏","怍","怩","怫","怊","怿","怡","恸","恹","恻","恺","恂"
            ,"恪","恽","悖","悚","悭","悝","悃","悒","悌","悛","惬","悻","悱","惝","惘"
            ,"惆","惚","悴","愠","愦","愕","愣","惴","愀","愎","愫","慊","慵","憬","憔","憧"
            ,"憷","懔","懵","忝","隳","闩","闫","闱","闳","闵","闶","闼","闾","阃","阄","阆"
            ,"阈","阊","阋","阌","阍","阏","阒","阕","阖","阗","阙","阚","丬","爿","戕","氵"
            ,"汔","汜","汊","沣","沅","沐","沔","沌","汨","汩","汴","汶","沆","沩","泐","泔"
            ,"沭","泷","泸","泱","泗","沲","泠","泖","泺","泫","泮","沱","泓","泯","泾"
            ,"洹","洧","洌","浃","浈","洇","洄","洙","洎","洫","浍","洮","洵","洚","浏"
            ,"浒","浔","洳","涑","浯","涞","涠","浞","涓","涔","浜","浠","浼","浣","渚","淇"
            ,"淅","淞","渎","涿","淠","渑","淦","淝","淙","渖","涫","渌","涮","渫","湮","湎"
            ,"湫","溲","湟","溆","湓","湔","渲","渥","湄","滟","溱","溘","滠","漭","滢","溥"
            ,"溧","溽","溻","溷","滗","溴","滏","溏","滂","溟","潢","潆","潇","漤","漕","滹"
            ,"漯","漶","潋","潴","漪","漉","漩","澉","澍","澌","潸","潲","潼","潺","濑"
            ,"濉","澧","澹","澶","濂","濡","濮","濞","濠","濯","瀚","瀣","瀛","瀹","瀵"
            ,"灏","灞","宀","宄","宕","宓","宥","宸","甯","骞","搴","寤","寮","褰","寰","蹇"
            ,"謇","辶","迓","迕","迥","迮","迤","迩","迦","迳","迨","逅","逄","逋","逦","逑"
            ,"逍","逖","逡","逵","逶","逭","逯","遄","遑","遒","遐","遨","遘","遢","遛","暹"
            ,"遴","遽","邂","邈","邃","邋","彐","彗","彖","彘","尻","咫","屐","屙","孱","屣"
            ,"屦","羼","弪","弩","弭","艴","弼","鬻","屮","妁","妃","妍","妩","妪","妣"
            ,"妗","姊","妫","妞","妤","姒","妲","妯","姗","妾","娅","娆","姝","娈","姣"
            ,"姘","姹","娌","娉","娲","娴","娑","娣","娓","婀","婧","婊","婕","娼","婢","婵"
            ,"胬","媪","媛","婷","婺","媾","嫫","媲","嫒","嫔","媸","嫠","嫣","嫱","嫖","嫦"
            ,"嫘","嫜","嬉","嬗","嬖","嬲","嬷","孀","尕","尜","孚","孥","孳","孑","孓","孢"
            ,"驵","驷","驸","驺","驿","驽","骀","骁","骅","骈","骊","骐","骒","骓","骖","骘"
            ,"骛","骜","骝","骟","骠","骢","骣","骥","骧","纟","纡","纣","纥","纨","纩"
            ,"纭","纰","纾","绀","绁","绂","绉","绋","绌","绐","绔","绗","绛","绠","绡"
            ,"绨","绫","绮","绯","绱","绲","缍","绶","绺","绻","绾","缁","缂","缃","缇","缈"
            ,"缋","缌","缏","缑","缒","缗","缙","缜","缛","缟","缡","缢","缣","缤","缥","缦"
            ,"缧","缪","缫","缬","缭","缯","缰","缱","缲","缳","缵","幺","畿","巛","甾","邕"
            ,"玎","玑","玮","玢","玟","珏","珂","珑","玷","玳","珀","珉","珈","珥","珙","顼"
            ,"琊","珩","珧","珞","玺","珲","琏","琪","瑛","琦","琥","琨","琰","琮","琬"
            ,"琛","琚","瑁","瑜","瑗","瑕","瑙","瑷","瑭","瑾","璜","璎","璀","璁","璇"
            ,"璋","璞","璨","璩","璐","璧","瓒","璺","韪","韫","韬","杌","杓","杞","杈","杩"
            ,"枥","枇","杪","杳","枘","枧","杵","枨","枞","枭","枋","杷","杼","柰","栉","柘"
            ,"栊","柩","枰","栌","柙","枵","柚","枳","柝","栀","柃","枸","柢","栎","柁","柽"
            ,"栲","栳","桠","桡","桎","桢","桄","桤","梃","栝","桕","桦","桁","桧","桀","栾"
            ,"桊","桉","栩","梵","梏","桴","桷","梓","桫","棂","楮","棼","椟","椠","棹"
            ,"椤","棰","椋","椁","楗","棣","椐","楱","椹","楠","楂","楝","榄","楫","榀"
            ,"榘","楸","椴","槌","榇","榈","槎","榉","楦","楣","楹","榛","榧","榻","榫","榭"
            ,"槔","榱","槁","槊","槟","榕","槠","榍","槿","樯","槭","樗","樘","橥","槲","橄"
            ,"樾","檠","橐","橛","樵","檎","橹","樽","樨","橘","橼","檑","檐","檩","檗","檫"
            ,"猷","獒","殁","殂","殇","殄","殒","殓","殍","殚","殛","殡","殪","轫","轭","轱"
            ,"轲","轳","轵","轶","轸","轷","轹","轺","轼","轾","辁","辂","辄","辇","辋"
            ,"辍","辎","辏","辘","辚","軎","戋","戗","戛","戟","戢","戡","戥","戤","戬"
            ,"臧","瓯","瓴","瓿","甏","甑","甓","攴","旮","旯","旰","昊","昙","杲","昃","昕"
            ,"昀","炅","曷","昝","昴","昱","昶","昵","耆","晟","晔","晁","晏","晖","晡","晗"
            ,"晷","暄","暌","暧","暝","暾","曛","曜","曦","曩","贲","贳","贶","贻","贽","赀"
            ,"赅","赆","赈","赉","赇","赍","赕","赙","觇","觊","觋","觌","觎","觏","觐","觑"
            ,"牮","犟","牝","牦","牯","牾","牿","犄","犋","犍","犏","犒","挈","挲","掰"
            ,"搿","擘","耄","毪","毳","毽","毵","毹","氅","氇","氆","氍","氕","氘","氙"
            ,"氚","氡","氩","氤","氪","氲","攵","敕","敫","牍","牒","牖","爰","虢","刖","肟"
            ,"肜","肓","肼","朊","肽","肱","肫","肭","肴","肷","胧","胨","胩","胪","胛","胂"
            ,"胄","胙","胍","胗","朐","胝","胫","胱","胴","胭","脍","脎","胲","胼","朕","脒"
            ,"豚","脶","脞","脬","脘","脲","腈","腌","腓","腴","腙","腚","腱","腠","腩","腼"
            ,"腽","腭","腧","塍","媵","膈","膂","膑","滕","膣","膪","臌","朦","臊","膻"
            ,"臁","膦","欤","欷","欹","歃","歆","歙","飑","飒","飓","飕","飙","飚","殳"
            ,"彀","毂","觳","斐","齑","斓","於","旆","旄","旃","旌","旎","旒","旖","炀","炜"
            ,"炖","炝","炻","烀","炷","炫","炱","烨","烊","焐","焓","焖","焯","焱","煳","煜"
            ,"煨","煅","煲","煊","煸","煺","熘","熳","熵","熨","熠","燠","燔","燧","燹","爝"
            ,"爨","灬","焘","煦","熹","戾","戽","扃","扈","扉","礻","祀","祆","祉","祛","祜"
            ,"祓","祚","祢","祗","祠","祯","祧","祺","禅","禊","禚","禧","禳","忑","忐"
            ,"怼","恝","恚","恧","恁","恙","恣","悫","愆","愍","慝","憩","憝","懋","懑"
            ,"戆","肀","聿","沓","泶","淼","矶","矸","砀","砉","砗","砘","砑","斫","砭","砜"
            ,"砝","砹","砺","砻","砟","砼","砥","砬","砣","砩","硎","硭","硖","硗","砦","硐"
            ,"硇","硌","硪","碛","碓","碚","碇","碜","碡","碣","碲","碹","碥","磔","磙","磉"
            ,"磬","磲","礅","磴","礓","礤","礞","礴","龛","黹","黻","黼","盱","眄","眍","盹"
            ,"眇","眈","眚","眢","眙","眭","眦","眵","眸","睐","睑","睇","睃","睚","睨"
            ,"睢","睥","睿","瞍","睽","瞀","瞌","瞑","瞟","瞠","瞰","瞵","瞽","町","畀"
            ,"畎","畋","畈","畛","畲","畹","疃","罘","罡","罟","詈","罨","罴","罱","罹","羁"
            ,"罾","盍","盥","蠲","钅","钆","钇","钋","钊","钌","钍","钏","钐","钔","钗","钕"
            ,"钚","钛","钜","钣","钤","钫","钪","钭","钬","钯","钰","钲","钴","钶","钷","钸"
            ,"钹","钺","钼","钽","钿","铄","铈","铉","铊","铋","铌","铍","铎","铐","铑","铒"
            ,"铕","铖","铗","铙","铘","铛","铞","铟","铠","铢","铤","铥","铧","铨","铪"
            ,"铩","铫","铮","铯","铳","铴","铵","铷","铹","铼","铽","铿","锃","锂","锆"
            ,"锇","锉","锊","锍","锎","锏","锒","锓","锔","锕","锖","锘","锛","锝","锞","锟"
            ,"锢","锪","锫","锩","锬","锱","锲","锴","锶","锷","锸","锼","锾","锿","镂","锵"
            ,"镄","镅","镆","镉","镌","镎","镏","镒","镓","镔","镖","镗","镘","镙","镛","镞"
            ,"镟","镝","镡","镢","镤","镥","镦","镧","镨","镩","镪","镫","镬","镯","镱","镲"
            ,"镳","锺","矧","矬","雉","秕","秭","秣","秫","稆","嵇","稃","稂","稞","稔"
            ,"稹","稷","穑","黏","馥","穰","皈","皎","皓","皙","皤","瓞","瓠","甬","鸠"
            ,"鸢","鸨","鸩","鸪","鸫","鸬","鸲","鸱","鸶","鸸","鸷","鸹","鸺","鸾","鹁","鹂"
            ,"鹄","鹆","鹇","鹈","鹉","鹋","鹌","鹎","鹑","鹕","鹗","鹚","鹛","鹜","鹞","鹣"
            ,"鹦","鹧","鹨","鹩","鹪","鹫","鹬","鹱","鹭","鹳","疒","疔","疖","疠","疝","疬"
            ,"疣","疳","疴","疸","痄","疱","疰","痃","痂","痖","痍","痣","痨","痦","痤","痫"
            ,"痧","瘃","痱","痼","痿","瘐","瘀","瘅","瘌","瘗","瘊","瘥","瘘","瘕","瘙"
            ,"瘛","瘼","瘢","瘠","癀","瘭","瘰","瘿","瘵","癃","瘾","瘳","癍","癞","癔"
            ,"癜","癖","癫","癯","翊","竦","穸","穹","窀","窆","窈","窕","窦","窠","窬","窨"
            ,"窭","窳","衤","衩","衲","衽","衿","袂","袢","裆","袷","袼","裉","裢","裎","裣"
            ,"裥","裱","褚","裼","裨","裾","裰","褡","褙","褓","褛","褊","褴","褫","褶","襁"
            ,"襦","襻","疋","胥","皲","皴","矜","耒","耔","耖","耜","耠","耢","耥","耦","耧"
            ,"耩","耨","耱","耋","耵","聃","聆","聍","聒","聩","聱","覃","顸","颀","颃"
            ,"颉","颌","颍","颏","颔","颚","颛","颞","颟","颡","颢","颥","颦","虍","虔"
            ,"虬","虮","虿","虺","虼","虻","蚨","蚍","蚋","蚬","蚝","蚧","蚣","蚪","蚓","蚩"
            ,"蚶","蛄","蚵","蛎","蚰","蚺","蚱","蚯","蛉","蛏","蚴","蛩","蛱","蛲","蛭","蛳"
            ,"蛐","蜓","蛞","蛴","蛟","蛘","蛑","蜃","蜇","蛸","蜈","蜊","蜍","蜉","蜣","蜻"
            ,"蜞","蜥","蜮","蜚","蜾","蝈","蜴","蜱","蜩","蜷","蜿","螂","蜢","蝽","蝾","蝻"
            ,"蝠","蝰","蝌","蝮","螋","蝓","蝣","蝼","蝤","蝙","蝥","螓","螯","螨","蟒"
            ,"蟆","螈","螅","螭","螗","螃","螫","蟥","螬","螵","螳","蟋","蟓","螽","蟑"
            ,"蟀","蟊","蟛","蟪","蟠","蟮","蠖","蠓","蟾","蠊","蠛","蠡","蠹","蠼","缶","罂"
            ,"罄","罅","舐","竺","竽","笈","笃","笄","笕","笊","笫","笏","筇","笸","笪","笙"
            ,"笮","笱","笠","笥","笤","笳","笾","笞","筘","筚","筅","筵","筌","筝","筠","筮"
            ,"筻","筢","筲","筱","箐","箦","箧","箸","箬","箝","箨","箅","箪","箜","箢","箫"
            ,"箴","篑","篁","篌","篝","篚","篥","篦","篪","簌","篾","篼","簏","簖","簋"
            ,"簟","簪","簦","簸","籁","籀","臾","舁","舂","舄","臬","衄","舡","舢","舣"
            ,"舭","舯","舨","舫","舸","舻","舳","舴","舾","艄","艉","艋","艏","艚","艟","艨"
            ,"衾","袅","袈","裘","裟","襞","羝","羟","羧","羯","羰","羲","籼","敉","粑","粝"
            ,"粜","粞","粢","粲","粼","粽","糁","糇","糌","糍","糈","糅","糗","糨","艮","暨"
            ,"羿","翎","翕","翥","翡","翦","翩","翮","翳","糸","絷","綦","綮","繇","纛","麸"
            ,"麴","赳","趄","趔","趑","趱","赧","赭","豇","豉","酊","酐","酎","酏","酤"
            ,"酢","酡","酰","酩","酯","酽","酾","酲","酴","酹","醌","醅","醐","醍","醑"
            ,"醢","醣","醪","醭","醮","醯","醵","醴","醺","豕","鹾","趸","跫","踅","蹙","蹩"
            ,"趵","趿","趼","趺","跄","跖","跗","跚","跞","跎","跏","跛","跆","跬","跷","跸"
            ,"跣","跹","跻","跤","踉","跽","踔","踝","踟","踬","踮","踣","踯","踺","蹀","踹"
            ,"踵","踽","踱","蹉","蹁","蹂","蹑","蹒","蹊","蹰","蹶","蹼","蹯","蹴","躅","躏"
            ,"躔","躐","躜","躞","豸","貂","貊","貅","貘","貔","斛","觖","觞","觚","觜"
            ,"觥","觫","觯","訾","謦","靓","雩","雳","雯","霆","霁","霈","霏","霎","霪"
            ,"霭","霰","霾","龀","龃","龅","龆","龇","龈","龉","龊","龌","黾","鼋","鼍","隹"
            ,"隼","隽","雎","雒","瞿","雠","銎","銮","鋈","錾","鍪","鏊","鎏","鐾","鑫","鱿"
            ,"鲂","鲅","鲆","鲇","鲈","稣","鲋","鲎","鲐","鲑","鲒","鲔","鲕","鲚","鲛","鲞"
            ,"鲟","鲠","鲡","鲢","鲣","鲥","鲦","鲧","鲨","鲩","鲫","鲭","鲮","鲰","鲱","鲲"
            ,"鲳","鲴","鲵","鲶","鲷","鲺","鲻","鲼","鲽","鳄","鳅","鳆","鳇","鳊","鳋"
            ,"鳌","鳍","鳎","鳏","鳐","鳓","鳔","鳕","鳗","鳘","鳙","鳜","鳝","鳟","鳢"
            ,"靼","鞅","鞑","鞒","鞔","鞯","鞫","鞣","鞲","鞴","骱","骰","骷","鹘","骶","骺"
            ,"骼","髁","髀","髅","髂","髋","髌","髑","魅","魃","魇","魉","魈","魍","魑","飨"
            ,"餍","餮","饕","饔","髟","髡","髦","髯","髫","髻","髭","髹","鬈","鬏","鬓","鬟"
            ,"鬣","麽","麾","縻","麂","麇","麈","麋","麒","鏖","麝","麟","黛","黜","黝","黠"
            ,"黟","黢","黩","黧","黥","黪","黯","鼢","鼬","鼯","鼹","鼷","鼽","鼾","齄"
        };

        /// <summary>
        /// 二级汉字对应拼音数组
        /// </summary>
        private static string[] otherPinYin = new string[]
           {                         
               "Chu","Ji","Wu","Gai","Nian","Sa","Pi","Gen","Cheng","Ge","Nao","E","Shu","Yu","Pie","Bi",
                "Tuo","Yao","Yao","Zhi","Di","Xin","Yin","Kui","Yu","Gao","Tao","Dian","Ji","Nai","Nie","Ji",
                "Qi","Mi","Bei","Se","Gu","Ze","She","Cuo","Yan","Jue","Si","Ye","Yan","Fang","Po","Gui",
                "Kui","Bian","Ze","Gua","You","Ce","Yi","Wen","Jing","Ku","Gui","Kai","La","Ji","Yan","Wan",
                "Kuai","Piao","Jue","Qiao","Huo","Yi","Tong","Wang","Dan","Ding","Zhang","Le","Sa","Yi","Mu","Ren",
                "Yu","Pi","Ya","Wa","Wu","Chang","Cang","Kang","Zhu","Ning","Ka","You","Yi","Gou","Tong","Tuo",
                "Ni","Ga","Ji","Er","You","Kua","Kan","Zhu","Yi","Tiao","Chai","Jiao","Nong","Mou","Chou","Yan",
                "Li","Qiu","Li","Yu","Ping","Yong","Si","Feng","Qian","Ruo","Pai","Zhuo","Shu","Luo","Wo","Bi",
                "Ti","Guan","Kong","Ju","Fen","Yan","Xie","Ji","Wei","Zong","Lou","Tang","Bin","Nuo","Chi","Xi",
                "Jing","Jian","Jiao","Jiu","Tong","Xuan","Dan","Tong","Tun","She","Qian","Zu","Yue","Cuan","Di","Xi",
                "Xun","Hong","Guo","Chan","Kui","Bao","Pu","Hong","Fu","Fu","Su","Si","Wen","Yan","Bo","Gun",
                "Mao","Xie","Luan","Pou","Bing","Ying","Luo","Lei","Liang","Hu","Lie","Xian","Song","Ping","Zhong","Ming",
                "Yan","Jie","Hong","Shan","Ou","Ju","Ne","Gu","He","Di","Zhao","Qu","Dai","Kuang","Lei","Gua",
                "Jie","Hui","Shen","Gou","Quan","Zheng","Hun","Xu","Qiao","Gao","Kuang","Ei","Zou","Zhuo","Wei","Yu",
                "Shen","Chan","Sui","Chen","Jian","Xue","Ye","E","Yu","Xuan","An","Di","Zi","Pian","Mo","Dang",
                "Su","Shi","Mi","Zhe","Jian","Zen","Qiao","Jue","Yan","Zhan","Chen","Dan","Jin","Zuo","Wu","Qian",
                "Jing","Ban","Yan","Zuo","Bei","Jing","Gai","Zhi","Nie","Zou","Chui","Pi","Wei","Huang","Wei","Xi",
                "Han","Qiong","Kuang","Mang","Wu","Fang","Bing","Pi","Bei","Ye","Di","Tai","Jia","Zhi","Zhu","Kuai",
                "Qie","Xun","Yun","Li","Ying","Gao","Xi","Fu","Pi","Tan","Yan","Juan","Yan","Yin","Zhang","Po",
                "Shan","Zou","Ling","Feng","Chu","Huan","Mai","Qu","Shao","He","Ge","Meng","Xu","Xie","Sou","Xie",
                "Jue","Jian","Qian","Dang","Chang","Si","Bian","Ben","Qiu","Ben","E","Fa","Shu","Ji","Yong","He",
                "Wei","Wu","Ge","Zhen","Kuang","Pi","Yi","Li","Qi","Ban","Gan","Long","Dian","Lu","Che","Di",
                "Tuo","Ni","Mu","Ao","Ya","Die","Dong","Kai","Shan","Shang","Nao","Gai","Yin","Cheng","Shi","Guo",
                "Xun","Lie","Yuan","Zhi","An","Yi","Pi","Nian","Peng","Tu","Sao","Dai","Ku","Die","Yin","Leng",
                "Hou","Ge","Yuan","Man","Yong","Liang","Chi","Xin","Pi","Yi","Cao","Jiao","Nai","Du","Qian","Ji",
                "Wan","Xiong","Qi","Xiang","Fu","Yuan","Yun","Fei","Ji","Li","E","Ju","Pi","Zhi","Rui","Xian",
                "Chang","Cong","Qin","Wu","Qian","Qi","Shan","Bian","Zhu","Kou","Yi","Mo","Gan","Pie","Long","Ba",
                "Mu","Ju","Ran","Qing","Chi","Fu","Ling","Niao","Yin","Mao","Ying","Qiong","Min","Tiao","Qian","Yi",
                "Rao","Bi","Zi","Ju","Tong","Hui","Zhu","Ting","Qiao","Fu","Ren","Xing","Quan","Hui","Xun","Ming",
                "Qi","Jiao","Chong","Jiang","Luo","Ying","Qian","Gen","Jin","Mai","Sun","Hong","Zhou","Kan","Bi","Shi",
                "Wo","You","E","Mei","You","Li","Tu","Xian","Fu","Sui","You","Di","Shen","Guan","Lang","Ying",
                "Chun","Jing","Qi","Xi","Song","Jin","Nai","Qi","Ba","Shu","Chang","Tie","Yu","Huan","Bi","Fu",
                "Tu","Dan","Cui","Yan","Zu","Dang","Jian","Wan","Ying","Gu","Han","Qia","Feng","Shen","Xiang","Wei",
                "Chan","Kai","Qi","Kui","Xi","E","Bao","Pa","Ting","Lou","Pai","Xuan","Jia","Zhen","Shi","Ru",
                "Mo","En","Bei","Weng","Hao","Ji","Li","Bang","Jian","Shuo","Lang","Ying","Yu","Su","Meng","Dou",
                "Xi","Lian","Cu","Lin","Qu","Kou","Xu","Liao","Hui","Xun","Jue","Rui","Zui","Ji","Meng","Fan",
                "Qi","Hong","Xie","Hong","Wei","Yi","Weng","Sou","Bi","Hao","Tai","Ru","Xun","Xian","Gao","Li",
                "Huo","Qu","Heng","Fan","Nie","Mi","Gong","Yi","Kuang","Lian","Da","Yi","Xi","Zang","Pao","You",
                "Liao","Ga","Gan","Ti","Men","Tuan","Chen","Fu","Pin","Niu","Jie","Jiao","Za","Yi","Lv","Jun",
                "Tian","Ye","Ai","Na","Ji","Guo","Bai","Ju","Pou","Lie","Qian","Guan","Die","Zha","Ya","Qin",
                "Yu","An","Xuan","Bing","Kui","Yuan","Shu","En","Chuai","Jian","Shuo","Zhan","Nuo","Sang","Luo","Ying",
                "Zhi","Han","Zhe","Xie","Lu","Zun","Cuan","Gan","Huan","Pi","Xing","Zhuo","Huo","Zuan","Nang","Yi",
                "Te","Dai","Shi","Bu","Chi","Ji","Kou","Dao","Le","Zha","A","Yao","Fu","Mu","Yi","Tai",
                "Li","E","Bi","Bei","Guo","Qin","Yin","Za","Ka","Ga","Gua","Ling","Dong","Ning","Duo","Nao",
                "You","Si","Kuang","Ji","Shen","Hui","Da","Lie","Yi","Xiao","Bi","Ci","Guang","Yue","Xiu","Yi",
                "Pai","Kuai","Duo","Ji","Mie","Mi","Zha","Nong","Gen","Mou","Mai","Chi","Lao","Geng","En","Zha",
                "Suo","Zao","Xi","Zuo","Ji","Feng","Ze","Nuo","Miao","Lin","Zhuan","Zhou","Tao","Hu","Cui","Sha",
                "Yo","Dan","Bo","Ding","Lang","Li","Shua","Chuo","Die","Da","Nan","Li","Kui","Jie","Yong","Kui",
                "Jiu","Sou","Yin","Chi","Jie","Lou","Ku","Wo","Hui","Qin","Ao","Su","Du","Ke","Nie","He",
                "Chen","Suo","Ge","A","En","Hao","Dia","Ai","Ai","Suo","Hei","Tong","Chi","Pei","Lei","Cao",
                "Piao","Qi","Ying","Beng","Sou","Di","Mi","Peng","Jue","Liao","Pu","Chuai","Jiao","O","Qin","Lu",
                "Ceng","Deng","Hao","Jin","Jue","Yi","Sai","Pi","Ru","Cha","Huo","Nang","Wei","Jian","Nan","Lun",
                "Hu","Ling","You","Yu","Qing","Yu","Huan","Wei","Zhi","Pei","Tang","Dao","Ze","Guo","Wei","Wo",
                "Man","Zhang","Fu","Fan","Ji","Qi","Qian","Qi","Qu","Ya","Xian","Ao","Cen","Lan","Ba","Hu",
                "Ke","Dong","Jia","Xiu","Dai","Gou","Mao","Min","Yi","Dong","Qiao","Xun","Zheng","Lao","Lai","Song",
                "Yan","Gu","Xiao","Guo","Kong","Jue","Rong","Yao","Wai","Zai","Wei","Yu","Cuo","Lou","Zi","Mei",
                "Sheng","Song","Ji","Zhang","Lin","Deng","Bin","Yi","Dian","Chi","Pang","Cu","Xun","Yang","Hou","Lai",
                "Xi","Chang","Huang","Yao","Zheng","Jiao","Qu","San","Fan","Qiu","An","Guang","Ma","Niu","Yun","Xia",
                "Pao","Fei","Rong","Kuai","Shou","Sun","Bi","Juan","Li","Yu","Xian","Yin","Suan","Yi","Guo","Luo",
                "Ni","She","Cu","Mi","Hu","Cha","Wei","Wei","Mei","Nao","Zhang","Jing","Jue","Liao","Xie","Xun",
                "Huan","Chuan","Huo","Sun","Yin","Dong","Shi","Tang","Tun","Xi","Ren","Yu","Chi","Yi","Xiang","Bo",
                "Yu","Hun","Zha","Sou","Mo","Xiu","Jin","San","Zhuan","Nang","Pi","Wu","Gui","Pao","Xiu","Xiang",
                "Tuo","An","Yu","Bi","Geng","Ao","Jin","Chan","Xie","Lin","Ying","Shu","Dao","Cun","Chan","Wu",
                "Zhi","Ou","Chong","Wu","Kai","Chang","Chuang","Song","Bian","Niu","Hu","Chu","Peng","Da","Yang","Zuo",
                "Ni","Fu","Chao","Yi","Yi","Tong","Yan","Ce","Kai","Xun","Ke","Yun","Bei","Song","Qian","Kui",
                "Kun","Yi","Ti","Quan","Qie","Xing","Fei","Chang","Wang","Chou","Hu","Cui","Yun","Kui","E","Leng",
                "Zhui","Qiao","Bi","Su","Qie","Yong","Jing","Qiao","Chong","Chu","Lin","Meng","Tian","Hui","Shuan","Yan",
                "Wei","Hong","Min","Kang","Ta","Lv","Kun","Jiu","Lang","Yu","Chang","Xi","Wen","Hun","E","Qu",
                "Que","He","Tian","Que","Kan","Jiang","Pan","Qiang","San","Qi","Si","Cha","Feng","Yuan","Mu","Mian",
                "Dun","Mi","Gu","Bian","Wen","Hang","Wei","Le","Gan","Shu","Long","Lu","Yang","Si","Duo","Ling",
                "Mao","Luo","Xuan","Pan","Duo","Hong","Min","Jing","Huan","Wei","Lie","Jia","Zhen","Yin","Hui","Zhu",
                "Ji","Xu","Hui","Tao","Xun","Jiang","Liu","Hu","Xun","Ru","Su","Wu","Lai","Wei","Zhuo","Juan",
                "Cen","Bang","Xi","Mei","Huan","Zhu","Qi","Xi","Song","Du","Zhuo","Pei","Mian","Gan","Fei","Cong",
                "Shen","Guan","Lu","Shuan","Xie","Yan","Mian","Qiu","Sou","Huang","Xu","Pen","Jian","Xuan","Wo","Mei",
                "Yan","Qin","Ke","She","Mang","Ying","Pu","Li","Ru","Ta","Hun","Bi","Xiu","Fu","Tang","Pang",
                "Ming","Huang","Ying","Xiao","Lan","Cao","Hu","Luo","Huan","Lian","Zhu","Yi","Lu","Xuan","Gan","Shu",
                "Si","Shan","Shao","Tong","Chan","Lai","Sui","Li","Dan","Chan","Lian","Ru","Pu","Bi","Hao","Zhuo",
                "Han","Xie","Ying","Yue","Fen","Hao","Ba","Bao","Gui","Dang","Mi","You","Chen","Ning","Jian","Qian",
                "Wu","Liao","Qian","Huan","Jian","Jian","Zou","Ya","Wu","Jiong","Ze","Yi","Er","Jia","Jing","Dai",
                "Hou","Pang","Bu","Li","Qiu","Xiao","Ti","Qun","Kui","Wei","Huan","Lu","Chuan","Huang","Qiu","Xia",
                "Ao","Gou","Ta","Liu","Xian","Lin","Ju","Xie","Miao","Sui","La","Ji","Hui","Tuan","Zhi","Kao",
                "Zhi","Ji","E","Chan","Xi","Ju","Chan","Jing","Nu","Mi","Fu","Bi","Yu","Che","Shuo","Fei",
                "Yan","Wu","Yu","Bi","Jin","Zi","Gui","Niu","Yu","Si","Da","Zhou","Shan","Qie","Ya","Rao",
                "Shu","Luan","Jiao","Pin","Cha","Li","Ping","Wa","Xian","Suo","Di","Wei","E","Jing","Biao","Jie",
                "Chang","Bi","Chan","Nu","Ao","Yuan","Ting","Wu","Gou","Mo","Pi","Ai","Pin","Chi","Li","Yan",
                "Qiang","Piao","Chang","Lei","Zhang","Xi","Shan","Bi","Niao","Mo","Shuang","Ga","Ga","Fu","Nu","Zi",
                "Jie","Jue","Bao","Zang","Si","Fu","Zou","Yi","Nu","Dai","Xiao","Hua","Pian","Li","Qi","Ke",
                "Zhui","Can","Zhi","Wu","Ao","Liu","Shan","Biao","Cong","Chan","Ji","Xiang","Jiao","Yu","Zhou","Ge",
                "Wan","Kuang","Yun","Pi","Shu","Gan","Xie","Fu","Zhou","Fu","Chu","Dai","Ku","Hang","Jiang","Geng",
                "Xiao","Ti","Ling","Qi","Fei","Shang","Gun","Duo","Shou","Liu","Quan","Wan","Zi","Ke","Xiang","Ti",
                "Miao","Hui","Si","Bian","Gou","Zhui","Min","Jin","Zhen","Ru","Gao","Li","Yi","Jian","Bin","Piao",
                "Man","Lei","Miao","Sao","Xie","Liao","Zeng","Jiang","Qian","Qiao","Huan","Zuan","Yao","Ji","Chuan","Zai",
                "Yong","Ding","Ji","Wei","Bin","Min","Jue","Ke","Long","Dian","Dai","Po","Min","Jia","Er","Gong",
                "Xu","Ya","Heng","Yao","Luo","Xi","Hui","Lian","Qi","Ying","Qi","Hu","Kun","Yan","Cong","Wan",
                "Chen","Ju","Mao","Yu","Yuan","Xia","Nao","Ai","Tang","Jin","Huang","Ying","Cui","Cong","Xuan","Zhang",
                "Pu","Can","Qu","Lu","Bi","Zan","Wen","Wei","Yun","Tao","Wu","Shao","Qi","Cha","Ma","Li",
                "Pi","Miao","Yao","Rui","Jian","Chu","Cheng","Cong","Xiao","Fang","Pa","Zhu","Nai","Zhi","Zhe","Long",
                "Jiu","Ping","Lu","Xia","Xiao","You","Zhi","Tuo","Zhi","Ling","Gou","Di","Li","Tuo","Cheng","Kao",
                "Lao","Ya","Rao","Zhi","Zhen","Guang","Qi","Ting","Gua","Jiu","Hua","Heng","Gui","Jie","Luan","Juan",
                "An","Xu","Fan","Gu","Fu","Jue","Zi","Suo","Ling","Chu","Fen","Du","Qian","Zhao","Luo","Chui",
                "Liang","Guo","Jian","Di","Ju","Cou","Zhen","Nan","Zha","Lian","Lan","Ji","Pin","Ju","Qiu","Duan",
                "Chui","Chen","Lv","Cha","Ju","Xuan","Mei","Ying","Zhen","Fei","Ta","Sun","Xie","Gao","Cui","Gao",
                "Shuo","Bin","Rong","Zhu","Xie","Jin","Qiang","Qi","Chu","Tang","Zhu","Hu","Gan","Yue","Qing","Tuo",
                "Jue","Qiao","Qin","Lu","Zun","Xi","Ju","Yuan","Lei","Yan","Lin","Bo","Cha","You","Ao","Mo",
                "Cu","Shang","Tian","Yun","Lian","Piao","Dan","Ji","Bin","Yi","Ren","E","Gu","Ke","Lu","Zhi",
                "Yi","Zhen","Hu","Li","Yao","Shi","Zhi","Quan","Lu","Zhe","Nian","Wang","Chuo","Zi","Cou","Lu",
                "Lin","Wei","Jian","Qiang","Jia","Ji","Ji","Kan","Deng","Gai","Jian","Zang","Ou","Ling","Bu","Beng",
                "Zeng","Pi","Po","Ga","La","Gan","Hao","Tan","Gao","Ze","Xin","Yun","Gui","He","Zan","Mao",
                "Yu","Chang","Ni","Qi","Sheng","Ye","Chao","Yan","Hui","Bu","Han","Gui","Xuan","Kui","Ai","Ming",
                "Tun","Xun","Yao","Xi","Nang","Ben","Shi","Kuang","Yi","Zhi","Zi","Gai","Jin","Zhen","Lai","Qiu",
                "Ji","Dan","Fu","Chan","Ji","Xi","Di","Yu","Gou","Jin","Qu","Jian","Jiang","Pin","Mao","Gu",
                "Wu","Gu","Ji","Ju","Jian","Pian","Kao","Qie","Suo","Bai","Ge","Bo","Mao","Mu","Cui","Jian",
                "San","Shu","Chang","Lu","Pu","Qu","Pie","Dao","Xian","Chuan","Dong","Ya","Yin","Ke","Yun","Fan",
                "Chi","Jiao","Du","Die","You","Yuan","Guo","Yue","Wo","Rong","Huang","Jing","Ruan","Tai","Gong","Zhun",
                "Na","Yao","Qian","Long","Dong","Ka","Lu","Jia","Shen","Zhou","Zuo","Gua","Zhen","Qu","Zhi","Jing",
                "Guang","Dong","Yan","Kuai","Sa","Hai","Pian","Zhen","Mi","Tun","Luo","Cuo","Pao","Wan","Niao","Jing",
                "Yan","Fei","Yu","Zong","Ding","Jian","Cou","Nan","Mian","Wa","E","Shu","Cheng","Ying","Ge","Lv",
                "Bin","Teng","Zhi","Chuai","Gu","Meng","Sao","Shan","Lian","Lin","Yu","Xi","Qi","Sha","Xin","Xi",
                "Biao","Sa","Ju","Sou","Biao","Biao","Shu","Gou","Gu","Hu","Fei","Ji","Lan","Yu","Pei","Mao",
                "Zhan","Jing","Ni","Liu","Yi","Yang","Wei","Dun","Qiang","Shi","Hu","Zhu","Xuan","Tai","Ye","Yang",
                "Wu","Han","Men","Chao","Yan","Hu","Yu","Wei","Duan","Bao","Xuan","Bian","Tui","Liu","Man","Shang",
                "Yun","Yi","Yu","Fan","Sui","Xian","Jue","Cuan","Huo","Tao","Xu","Xi","Li","Hu","Jiong","Hu",
                "Fei","Shi","Si","Xian","Zhi","Qu","Hu","Fu","Zuo","Mi","Zhi","Ci","Zhen","Tiao","Qi","Chan",
                "Xi","Zhuo","Xi","Rang","Te","Tan","Dui","Jia","Hui","Nv","Nin","Yang","Zi","Que","Qian","Min",
                "Te","Qi","Dui","Mao","Men","Gang","Yu","Yu","Ta","Xue","Miao","Ji","Gan","Dang","Hua","Che",
                "Dun","Ya","Zhuo","Bian","Feng","Fa","Ai","Li","Long","Zha","Tong","Di","La","Tuo","Fu","Xing",
                "Mang","Xia","Qiao","Zhai","Dong","Nao","Ge","Wo","Qi","Dui","Bei","Ding","Chen","Zhou","Jie","Di",
                "Xuan","Bian","Zhe","Gun","Sang","Qing","Qu","Dun","Deng","Jiang","Ca","Meng","Bo","Kan","Zhi","Fu",
                "Fu","Xu","Mian","Kou","Dun","Miao","Dan","Sheng","Yuan","Yi","Sui","Zi","Chi","Mou","Lai","Jian",
                "Di","Suo","Ya","Ni","Sui","Pi","Rui","Sou","Kui","Mao","Ke","Ming","Piao","Cheng","Kan","Lin",
                "Gu","Ding","Bi","Quan","Tian","Fan","Zhen","She","Wan","Tuan","Fu","Gang","Gu","Li","Yan","Pi",
                "Lan","Li","Ji","Zeng","He","Guan","Juan","Jin","Ga","Yi","Po","Zhao","Liao","Tu","Chuan","Shan",
                "Men","Chai","Nv","Bu","Tai","Ju","Ban","Qian","Fang","Kang","Dou","Huo","Ba","Yu","Zheng","Gu",
                "Ke","Po","Bu","Bo","Yue","Mu","Tan","Dian","Shuo","Shi","Xuan","Ta","Bi","Ni","Pi","Duo",
                "Kao","Lao","Er","You","Cheng","Jia","Nao","Ye","Cheng","Diao","Yin","Kai","Zhu","Ding","Diu","Hua",
                "Quan","Ha","Sha","Diao","Zheng","Se","Chong","Tang","An","Ru","Lao","Lai","Te","Keng","Zeng","Li",
                "Gao","E","Cuo","Lve","Liu","Kai","Jian","Lang","Qin","Ju","A","Qiang","Nuo","Ben","De","Ke",
                "Kun","Gu","Huo","Pei","Juan","Tan","Zi","Qie","Kai","Si","E","Cha","Sou","Huan","Ai","Lou",
                "Qiang","Fei","Mei","Mo","Ge","Juan","Na","Liu","Yi","Jia","Bin","Biao","Tang","Man","Luo","Yong",
                "Chuo","Xuan","Di","Tan","Jue","Pu","Lu","Dui","Lan","Pu","Cuan","Qiang","Deng","Huo","Zhuo","Yi",
                "Cha","Biao","Zhong","Shen","Cuo","Zhi","Bi","Zi","Mo","Shu","Lv","Ji","Fu","Lang","Ke","Ren",
                "Zhen","Ji","Se","Nian","Fu","Rang","Gui","Jiao","Hao","Xi","Po","Die","Hu","Yong","Jiu","Yuan",
                "Bao","Zhen","Gu","Dong","Lu","Qu","Chi","Si","Er","Zhi","Gua","Xiu","Luan","Bo","Li","Hu",
                "Yu","Xian","Ti","Wu","Miao","An","Bei","Chun","Hu","E","Ci","Mei","Wu","Yao","Jian","Ying",
                "Zhe","Liu","Liao","Jiao","Jiu","Yu","Hu","Lu","Guan","Bing","Ding","Jie","Li","Shan","Li","You",
                "Gan","Ke","Da","Zha","Pao","Zhu","Xuan","Jia","Ya","Yi","Zhi","Lao","Wu","Cuo","Xian","Sha",
                "Zhu","Fei","Gu","Wei","Yu","Yu","Dan","La","Yi","Hou","Chai","Lou","Jia","Sao","Chi","Mo",
                "Ban","Ji","Huang","Biao","Luo","Ying","Zhai","Long","Yin","Chou","Ban","Lai","Yi","Dian","Pi","Dian",
                "Qu","Yi","Song","Xi","Qiong","Zhun","Bian","Yao","Tiao","Dou","Ke","Yu","Xun","Ju","Yu","Yi",
                "Cha","Na","Ren","Jin","Mei","Pan","Dang","Jia","Ge","Ken","Lian","Cheng","Lian","Jian","Biao","Chu",
                "Ti","Bi","Ju","Duo","Da","Bei","Bao","Lv","Bian","Lan","Chi","Zhe","Qiang","Ru","Pan","Ya",
                "Xu","Jun","Cun","Jin","Lei","Zi","Chao","Si","Huo","Lao","Tang","Ou","Lou","Jiang","Nou","Mo",
                "Die","Ding","Dan","Ling","Ning","Guo","Kui","Ao","Qin","Han","Qi","Hang","Jie","He","Ying","Ke",
                "Han","E","Zhuan","Nie","Man","Sang","Hao","Ru","Pin","Hu","Qian","Qiu","Ji","Chai","Hui","Ge",
                "Meng","Fu","Pi","Rui","Xian","Hao","Jie","Gong","Dou","Yin","Chi","Han","Gu","Ke","Li","You",
                "Ran","Zha","Qiu","Ling","Cheng","You","Qiong","Jia","Nao","Zhi","Si","Qu","Ting","Kuo","Qi","Jiao",
                "Yang","Mou","Shen","Zhe","Shao","Wu","Li","Chu","Fu","Qiang","Qing","Qi","Xi","Yu","Fei","Guo",
                "Guo","Yi","Pi","Tiao","Quan","Wan","Lang","Meng","Chun","Rong","Nan","Fu","Kui","Ke","Fu","Sou",
                "Yu","You","Lou","You","Bian","Mou","Qin","Ao","Man","Mang","Ma","Yuan","Xi","Chi","Tang","Pang",
                "Shi","Huang","Cao","Piao","Tang","Xi","Xiang","Zhong","Zhang","Shuai","Mao","Peng","Hui","Pan","Shan","Huo",
                "Meng","Chan","Lian","Mie","Li","Du","Qu","Fou","Ying","Qing","Xia","Shi","Zhu","Yu","Ji","Du",
                "Ji","Jian","Zhao","Zi","Hu","Qiong","Po","Da","Sheng","Ze","Gou","Li","Si","Tiao","Jia","Bian",
                "Chi","Kou","Bi","Xian","Yan","Quan","Zheng","Jun","Shi","Gang","Pa","Shao","Xiao","Qing","Ze","Qie",
                "Zhu","Ruo","Qian","Tuo","Bi","Dan","Kong","Wan","Xiao","Zhen","Kui","Huang","Hou","Gou","Fei","Li",
                "Bi","Chi","Su","Mie","Dou","Lu","Duan","Gui","Dian","Zan","Deng","Bo","Lai","Zhou","Yu","Yu",
                "Chong","Xi","Nie","Nv","Chuan","Shan","Yi","Bi","Zhong","Ban","Fang","Ge","Lu","Zhu","Ze","Xi",
                "Shao","Wei","Meng","Shou","Cao","Chong","Meng","Qin","Niao","Jia","Qiu","Sha","Bi","Di","Qiang","Suo",
                "Jie","Tang","Xi","Xian","Mi","Ba","Li","Tiao","Xi","Zi","Can","Lin","Zong","San","Hou","Zan",
                "Ci","Xu","Rou","Qiu","Jiang","Gen","Ji","Yi","Ling","Xi","Zhu","Fei","Jian","Pian","He","Yi",
                "Jiao","Zhi","Qi","Qi","Yao","Dao","Fu","Qu","Jiu","Ju","Lie","Zi","Zan","Nan","Zhe","Jiang",
                "Chi","Ding","Gan","Zhou","Yi","Gu","Zuo","Tuo","Xian","Ming","Zhi","Yan","Shai","Cheng","Tu","Lei",
                "Kun","Pei","Hu","Ti","Xu","Hai","Tang","Lao","Bu","Jiao","Xi","Ju","Li","Xun","Shi","Cuo",
                "Dun","Qiong","Xue","Cu","Bie","Bo","Ta","Jian","Fu","Qiang","Zhi","Fu","Shan","Li","Tuo","Jia",
                "Bo","Tai","Kui","Qiao","Bi","Xian","Xian","Ji","Jiao","Liang","Ji","Chuo","Huai","Chi","Zhi","Dian",
                "Bo","Zhi","Jian","Die","Chuai","Zhong","Ju","Duo","Cuo","Pian","Rou","Nie","Pan","Qi","Chu","Jue",
                "Pu","Fan","Cu","Zhu","Lin","Chan","Lie","Zuan","Xie","Zhi","Diao","Mo","Xiu","Mo","Pi","Hu",
                "Jue","Shang","Gu","Zi","Gong","Su","Zhi","Zi","Qing","Liang","Yu","Li","Wen","Ting","Ji","Pei",
                "Fei","Sha","Yin","Ai","Xian","Mai","Chen","Ju","Bao","Tiao","Zi","Yin","Yu","Chuo","Wo","Mian",
                "Yuan","Tuo","Zhui","Sun","Jun","Ju","Luo","Qu","Chou","Qiong","Luan","Wu","Zan","Mou","Ao","Liu",
                "Bei","Xin","You","Fang","Ba","Ping","Nian","Lu","Su","Fu","Hou","Tai","Gui","Jie","Wei","Er",
                "Ji","Jiao","Xiang","Xun","Geng","Li","Lian","Jian","Shi","Tiao","Gun","Sha","Huan","Ji","Qing","Ling",
                "Zou","Fei","Kun","Chang","Gu","Ni","Nian","Diao","Shi","Zi","Fen","Die","E","Qiu","Fu","Huang",
                "Bian","Sao","Ao","Qi","Ta","Guan","Yao","Le","Biao","Xue","Man","Min","Yong","Gui","Shan","Zun",
                "Li","Da","Yang","Da","Qiao","Man","Jian","Ju","Rou","Gou","Bei","Jie","Tou","Ku","Gu","Di",
                "Hou","Ge","Ke","Bi","Lou","Qia","Kuan","Bin","Du","Mei","Ba","Yan","Liang","Xiao","Wang","Chi",
                "Xiang","Yan","Tie","Tao","Yong","Biao","Kun","Mao","Ran","Tiao","Ji","Zi","Xiu","Quan","Jiu","Bin",
                "Huan","Lie","Me","Hui","Mi","Ji","Jun","Zhu","Mi","Qi","Ao","She","Lin","Dai","Chu","You",
                "Xia","Yi","Qu","Du","Li","Qing","Can","An","Fen","You","Wu","Yan","Xi","Qiu","Han","Zha"
           };
        #endregion 二级汉字
        #region 变量定义
        // GB2312-80 标准规范中第一个汉字的机内码.即"啊"的机内码
        private const int firstChCode = -20319;
        // GB2312-80 标准规范中最后一个汉字的机内码.即"齄"的机内码
        private const int lastChCode = -2050;
        // GB2312-80 标准规范中最后一个一级汉字的机内码.即"座"的机内码
        private const int lastOfOneLevelChCode = -10247;
        // 配置中文字符
        //static Regex regex = new Regex("[\u4e00-\u9fa5]$");

        #endregion
        #endregion

        /// <summary>
        /// 取拼音第一个字段
        /// </summary>        
        /// <param name="ch"></param>        
        /// <returns></returns>        
        public static String GetFirst(Char ch)
        {
            var rs = Get(ch);
            if (!String.IsNullOrEmpty(rs)) rs = rs.Substring(0, 1);

            return rs;
        }

        /// <summary>
        /// 取拼音第一个字段
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static String GetFirst(String str)
        {
            if (String.IsNullOrEmpty(str)) return String.Empty;

            var sb = new StringBuilder(str.Length + 1);
            var chs = str.ToCharArray();

            for (var i = 0; i < chs.Length; i++)
            {
                sb.Append(GetFirst(chs[i]));
            }

            return sb.ToString();
        }

        /// <summary>
        /// 获取单字拼音
        /// </summary>
        /// <param name="ch"></param>
        /// <returns></returns>
        public static String Get(Char ch)
        {
            // 拉丁字符            
            if (ch <= '\x00FF') return ch.ToString();

            // 标点符号、分隔符            
            if (Char.IsPunctuation(ch) || Char.IsSeparator(ch)) return ch.ToString();

            // 非中文字符            
            if (ch < '\x4E00' || ch > '\x9FA5') return ch.ToString();

            var arr = Encoding.GetEncoding("gb2312").GetBytes(ch.ToString());
            //Encoding.Default默认在中文环境里虽是GB2312，但在多变的环境可能是其它
            //var arr = Encoding.Default.GetBytes(ch.ToString()); 
            var chr = (Int16)arr[0] * 256 + (Int16)arr[1] - 65536;

            //***// 单字符--英文或半角字符  
            if (chr > 0 && chr < 160) return ch.ToString();
            #region 中文字符处理

            // 判断是否超过GB2312-80标准中的汉字范围
            if (chr > lastChCode || chr < firstChCode)
            {
                return ch.ToString(); ;
            }
            // 如果是在一级汉字中
            else if (chr <= lastOfOneLevelChCode)
            {
                // 将一级汉字分为12块,每块33个汉字.
                for (int aPos = 11; aPos >= 0; aPos--)
                {
                    int aboutPos = aPos * 33;
                    // 从最后的块开始扫描,如果机内码大于块的第一个机内码,说明在此块中
                    if (chr >= pyValue[aboutPos])
                    {
                        // Console.WriteLine("存在于第 " + aPos.ToString() + " 块,此块的第一个机内码是: " + pyValue[aPos * 33].ToString());
                        // 遍历块中的每个音节机内码,从最后的音节机内码开始扫描,
                        // 如果音节内码小于机内码,则取此音节
                        for (int i = aboutPos + 32; i >= aboutPos; i--)
                        {
                            if (pyValue[i] <= chr)
                            {
                                // Console.WriteLine("找到第一个小于要查找机内码的机内码: " + pyValue[i].ToString());
                                return pyName[i];
                            }
                        }
                        break;
                    }
                }
            }
            // 如果是在二级汉字中
            else
            {
                int pos = Array.IndexOf(otherChinese, ch.ToString());
                if (pos != decimal.MinusOne)
                {
                    return otherPinYin[pos];
                }
            }
            #endregion 中文字符处理

            //if (chr < -20319 || chr > -10247) { // 不知道的字符  
            //    return null;  

            //for (var i = pyValue.Length - 1; i >= 0; i--)
            //{                
            //    if (pyValue[i] <= chr) return pyName[i];//这只能对应数组已经定义的           
            //}             

            return String.Empty;
        }

        /// <summary>
        /// 把汉字转换成拼音(全拼)
        /// </summary>
        /// <param name="str">汉字字符串</param>
        /// <returns>转换后的拼音(全拼)字符串</returns>
        public static String Get(String str)
        {
            if (String.IsNullOrEmpty(str)) return String.Empty;

            var sb = new StringBuilder(str.Length * 10);
            var chs = str.ToCharArray();

            for (var j = 0; j < chs.Length; j++)
            {
                sb.Append(Get(chs[j]));
            }

            return sb.ToString();
        }
    }

}

11.安全加密帮助类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
using System.IO;

namespace Utilities
{
    /// <summary>
    /// 安全加密帮助类
    /// </summary>
    public class SecurityHelper
    {
        /// <summary> 
        /// DES加解密工具类
        /// </summary> 
        public class DESEncrypt
        {
            //默认密钥向量
            private static byte[] Keys = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
            /// <summary>
            /// DES加密字符串
            /// </summary>
            /// <param name="encryptString">待加密的字符串</param>
            /// <param name="encryptKey">加密密钥,要求为8位</param>
            /// <returns>加密成功返回加密后的字符串,失败返回源串</returns>
            public static string Encode(string encryptString, string encryptKey)
            {                
                encryptKey = StringHelper.GetSubString(encryptKey, 8, "");
                encryptKey = encryptKey.PadRight(8, ' ');
                byte[] rgbKey = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 8));
                byte[] rgbIV = Keys;
                byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);
                DESCryptoServiceProvider dCSP = new DESCryptoServiceProvider();
                MemoryStream mStream = new MemoryStream();
                CryptoStream cStream = new CryptoStream(mStream, dCSP.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
                cStream.Write(inputByteArray, 0, inputByteArray.Length);
                cStream.FlushFinalBlock();
                return Convert.ToBase64String(mStream.ToArray());

            }
            /// <summary>
            /// DES解密字符串
            /// </summary>
            /// <param name="decryptString">待解密的字符串</param>
            /// <param name="decryptKey">解密密钥,要求为8位,和加密密钥相同</param>
            /// <returns>解密成功返回解密后的字符串,失败返源串</returns>
            public static string Decode(string decryptString, string decryptKey)
            {
                try
                {
                    decryptKey = StringHelper.GetSubString(decryptKey, 8, "");
                    decryptKey = decryptKey.PadRight(8, ' ');
                    byte[] rgbKey = Encoding.UTF8.GetBytes(decryptKey);
                    byte[] rgbIV = Keys;
                    byte[] inputByteArray = Convert.FromBase64String(decryptString);
                    DESCryptoServiceProvider DCSP = new DESCryptoServiceProvider();

                    MemoryStream mStream = new MemoryStream();
                    CryptoStream cStream = new CryptoStream(mStream, DCSP.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
                    cStream.Write(inputByteArray, 0, inputByteArray.Length);
                    cStream.FlushFinalBlock();
                    return Encoding.UTF8.GetString(mStream.ToArray());
                }
                catch
                {
                    return null;
                }
            }
        }
        /// <summary> 
        /// AES加解密工具类
        /// </summary> 
        public class AESEncrypt
        {
            private static byte[] Keys = { 0x41, 0x72, 0x65, 0x79, 0x6F, 0x75, 0x6D, 0x79, 0x53, 0x6E, 0x6F, 0x77, 0x6D, 0x61, 0x6E, 0x3F };
            /// <summary>
            /// 加密指定字符串
            /// </summary>
            /// <param name="encryptString">要加密的字符串</param>
            /// <param name="encryptKey">密钥</param>
            /// <returns>加密后的字符串</returns>
            public static string Encode(string encryptString, string encryptKey)
            {
                encryptKey = StringHelper.GetSubString(encryptKey, 32, "");
                encryptKey = encryptKey.PadRight(32, ' ');

                RijndaelManaged rijndaelProvider = new RijndaelManaged();
                rijndaelProvider.Key = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 32));
                rijndaelProvider.IV = Keys;
                ICryptoTransform rijndaelEncrypt = rijndaelProvider.CreateEncryptor();

                byte[] inputData = Encoding.UTF8.GetBytes(encryptString);
                byte[] encryptedData = rijndaelEncrypt.TransformFinalBlock(inputData, 0, inputData.Length);

                return Convert.ToBase64String(encryptedData);
            }
            /// <summary>
            /// 解密指定的字符串
            /// </summary>
            /// <param name="decryptString">调用Encode加密方法加密过的字符串</param>
            /// <param name="decryptKey">密钥</param>
            /// <returns>解密后的字符串</returns>
            public static string Decode(string decryptString, string decryptKey)
            {
                try
                {
                    decryptKey = StringHelper.GetSubString(decryptKey, 32, "");
                    decryptKey = decryptKey.PadRight(32, ' ');

                    RijndaelManaged rijndaelProvider = new RijndaelManaged();
                    rijndaelProvider.Key = Encoding.UTF8.GetBytes(decryptKey);
                    rijndaelProvider.IV = Keys;
                    ICryptoTransform rijndaelDecrypt = rijndaelProvider.CreateDecryptor();

                    byte[] inputData = Convert.FromBase64String(decryptString);
                    byte[] decryptedData = rijndaelDecrypt.TransformFinalBlock(inputData, 0, inputData.Length);

                    return Encoding.UTF8.GetString(decryptedData);
                }
                catch
                {
                    return "";
                }

            }
        }
        /// <summary>
        /// 
        /// </summary>
        public class MD5
        {
            /// <summary>
            /// 加密字符串
            /// </summary>
            /// <param name="sourceString"></param>
            /// <returns></returns>
            public static string Encrypt(string sourceString)
            {
                if (string.IsNullOrEmpty(sourceString))
                {
                    throw new Exception("<Encrypt Error>sourceString is null");
                }

                var md5 = new MD5CryptoServiceProvider();
                var buffer = md5.ComputeHash(Encoding.UTF8.GetBytes(sourceString));
                var sb = new StringBuilder(32);
                foreach (var t in buffer)
                {
                    sb.Append(t.ToString("X2"));
                }

                md5.Dispose();
                return sb.ToString();
            }

            /// <summary>
            /// 16位MD5加密
            /// </summary>
            /// <param name="sourceString"></param>
            /// <returns></returns>
            public static string Encrypt16(string sourceString)
            {
                var md5 = new MD5CryptoServiceProvider();
                string t2 = BitConverter.ToString(md5.ComputeHash(Encoding.Default.GetBytes(sourceString)), 4, 8);
                t2 = t2.Replace("-", "");
                return t2;
            }
        } 
        
    }
}

12.SqlServer连接帮助类

using System;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Collections;

namespace Utilities
{
    /// <summary>
    /// SqlHelper 的摘要说明。
    /// </summary>
    public class SqlHelper
    {    
        public static readonly string ImgConnectionString = ConfigurationManager.ConnectionStrings["ResConnectionString"].ConnectionString;
        public static readonly string AppConnectionString = ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;//@"Data Source=.\SeanDB;Initial Catalog=YSD;Persist Security Info=True;User ID=sa;Password=123@qwe";//
        // Hashtable to store cached parameters
        private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());

        /// <summary>
        /// 数据分页取的是全部列
        /// </summary>
        /// <param name="objName">您要查询的表或试图</param>
        /// <param name="colNames">您要取得列名例如：Id,Name</param>
        /// <param name="whereSql">条件语句例如:"where price>10"</param>
        /// <param name="orderSql">排序语句例如:"order by price desc,BTime"</param>
        /// <param name="pageSize">每页记录数</param>
        /// <param name="pageNum">当前页码</param>
        /// <param name="recordCount">满足条件的记录总数量</param>
        /// <returns>承载数据的DataTable对象</returns>
        public static DataTable GetObjectsPaged(string objName,string colNames,string whereSql, string orderSql, int pageSize, int pageNum, out int recordCount)
        {
            DataSet ds = new DataSet();
            SqlCommand cmd = new SqlCommand("proc_Data_Paged",new SqlConnection(SqlHelper.AppConnectionString));
            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Parameters.Add("@objName", SqlDbType.VarChar).Value = objName;
            cmd.Parameters.Add("@colNames", SqlDbType.VarChar).Value = colNames;
            cmd.Parameters.Add("@WhereSql", SqlDbType.VarChar).Value = whereSql;
            cmd.Parameters.Add("@OrderSql", SqlDbType.VarChar).Value = orderSql;
            cmd.Parameters.Add("@PageSize", SqlDbType.Int).Value = pageSize;
            cmd.Parameters.Add("@PageNum", SqlDbType.Int).Value = pageNum;
            SqlParameter pa = cmd.Parameters.Add("@RowCount", SqlDbType.Int);
            pa.Direction = ParameterDirection.Output;
            SqlDataAdapter ada = new SqlDataAdapter(cmd);
            ada.Fill(ds);
            recordCount = Convert.ToInt32(pa.Value);
            return ds.Tables[0];
        }       

        /// <summary>
        /// Execute a SqlCommand (that returns no resultset) against the database specified in the connection string 
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:
        ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connectionString">a valid connection string for a SqlConnection</param>
        /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">the stored procedure name or T-SQL command</param>
        /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
        /// <returns>an int representing the number of rows affected by the command</returns>
        public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();

            using (SqlConnection conn = new SqlConnection(connectionString))
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                int val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                return val;
            }
        }
        /// <summary>
        /// 在一个事物中执行一组Sql语句
        /// </summary>
        /// <param name="connectionString">连接字符串</param>
        /// <param name="cmdTexts">sql语句数组</param>
        /// <returns></returns>
        public static string ExecuteSqlsInTransaction(string connectionString, string[] cmdTexts)
        {
            SqlConnection conn = new SqlConnection(connectionString);
            conn.Open();
            SqlTransaction tran = conn.BeginTransaction();
            try
            {
                foreach (string sql in cmdTexts)
                {
                    if(sql !="")
                        ExecuteNonQuery(tran, CommandType.Text, sql, null);
                }
                tran.Commit();
                return "True";
            }
            catch (SqlException ex)
            {
                tran.Rollback();
                return "False:"+ex.Message;
            }
            finally
            {
                conn.Close();
            }
        }


        /// <summary>
        /// Execute a SqlCommand (that returns no resultset) against an existing database connection 
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="conn">an existing database connection</param>
        /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">the stored procedure name or T-SQL command</param>
        /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
        /// <returns>an int representing the number of rows affected by the command</returns>
        public static int ExecuteNonQuery(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {

            SqlCommand cmd = new SqlCommand();

            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
            int val = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return val;
        }
        /// <summary>
        /// Execute a SqlCommand (that returns no resultset) using an existing SQL Transaction 
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="trans">an existing sql transaction</param>
        /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">the stored procedure name or T-SQL command</param>
        /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
        /// <returns>an int representing the number of rows affected by the command</returns>
        public static int ExecuteNonQuery(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
            int val = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return val;
        }
        /// <summary>
        ///  Get a DataSet
        /// </summary>
        /// <param name="connectionString"></param>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <param name="tableName"></param>
        /// <param name="commandParameters"></param>
        /// <returns></returns>
        public static DataSet ExecuteDataSet(string connectionString, CommandType cmdType, string cmdText, string tableName, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            SqlDataAdapter sda = new SqlDataAdapter(cmd);
            DataSet ds = new DataSet();
            using (SqlConnection conn = new SqlConnection(connectionString))
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                sda.Fill(ds, tableName);
                cmd.Parameters.Clear();
                return ds;
            }
        }
        public static DataSet ExecuteDataSet(string connectionString, CommandType cmdType, string cmdText,params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            SqlDataAdapter sda = new SqlDataAdapter(cmd);
            DataSet ds = new DataSet();
            using (SqlConnection conn = new SqlConnection(connectionString))
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                sda.Fill(ds);
                cmd.Parameters.Clear();
                return ds;
            }
        }
        /// <summary>
        /// Get a DataSet
        /// </summary>
        /// <param name="connectionString"></param>
        /// <param name="trans"></param>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <param name="tableName"></param>
        /// <param name="commandParameters"></param>
        /// <returns></returns>
        public static DataSet ExecuteDataSet(string connectionString, SqlTransaction trans, CommandType cmdType, string cmdText, string tableName, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            SqlDataAdapter sda = new SqlDataAdapter(cmd);
            DataSet ds = new DataSet();
            using (SqlConnection conn = new SqlConnection(connectionString))
            {
                PrepareCommand(cmd, conn, trans, cmdType, cmdText, commandParameters);
                sda.Fill(ds, tableName);
                cmd.Parameters.Clear();
                return ds;
            }
        }
       

        /// <summary>
        /// Execute a SqlCommand that returns a resultset against the database specified in the connection string 
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  SqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connectionString">a valid connection string for a SqlConnection</param>
        /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">the stored procedure name or T-SQL command</param>
        /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
        /// <returns>A SqlDataReader containing the results</returns>
        public static SqlDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            SqlConnection conn = new SqlConnection(connectionString);

            // we use a try/catch here because if the method throws an exception we want to 
            // close the connection throw code, because no datareader will exist, hence the 
            // commandBehaviour.CloseConnection will not work
            try
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
                return rdr;
            }
            catch
            {
                conn.Close();
                throw;
            }
        }

        /// <summary>
        /// Execute a SqlCommand that returns the first column of the first record against the database specified in the connection string 
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connectionString">a valid connection string for a SqlConnection</param>
        /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">the stored procedure name or T-SQL command</param>
        /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
        /// <returns>An object that should be converted to the expected type using Convert.To{Type}</returns>
        public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();

            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
                object val = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                return val;
            }
        }

        /// <summary>
        /// Execute a SqlCommand that returns the first column of the first record against an existing database connection 
        /// using the provided parameters.
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="conn">an existing database connection</param>
        /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>
        /// <param name="commandText">the stored procedure name or T-SQL command</param>
        /// <param name="commandParameters">an array of SqlParamters used to execute the command</param>
        /// <returns>An object that should be converted to the expected type using Convert.To{Type}</returns>
        public static object ExecuteScalar(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {

            SqlCommand cmd = new SqlCommand();

            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
            object val = cmd.ExecuteScalar();
            cmd.Parameters.Clear();
            return val;
        }

        /// <summary>
        /// add parameter array to the cache
        /// </summary>
        /// <param name="cacheKey">Key to the parameter cache</param>
        /// <param name="cmdParms">an array of SqlParamters to be cached</param>
        public static void CacheParameters(string cacheKey, params SqlParameter[] commandParameters)
        {
            parmCache[cacheKey] = commandParameters;
        }

        /// <summary>
        /// Retrieve cached parameters
        /// </summary>
        /// <param name="cacheKey">key used to lookup parameters</param>
        /// <returns>Cached SqlParamters array</returns>
        public static SqlParameter[] GetCachedParameters(string cacheKey)
        {
            SqlParameter[] cachedParms = (SqlParameter[])parmCache[cacheKey];

            if (cachedParms == null)
                return null;

            SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];

            for (int i = 0, j = cachedParms.Length; i < j; i++)
                clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();

            return clonedParms;
        }

        /// <summary>
        /// Prepare a command for execution
        /// </summary>
        /// <param name="cmd">SqlCommand object</param>
        /// <param name="conn">SqlConnection object</param>
        /// <param name="trans">SqlTransaction object</param>
        /// <param name="cmdType">Cmd type e.g. stored procedure or text</param>
        /// <param name="cmdText">Command text, e.g. Select * from Products</param>
        /// <param name="cmdParms">SqlParameters to use in the command</param>
        private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
        {

            if (conn.State != ConnectionState.Open)
                conn.Open();

            cmd.Connection = conn;
            cmd.CommandText = cmdText;

            if (trans != null)
                cmd.Transaction = trans;

            cmd.CommandType = cmdType;

            if (cmdParms != null)
            {
                foreach (SqlParameter parm in cmdParms)
                    cmd.Parameters.Add(parm);
            }
        }
        public static int ChangeErrorNum(int num)
        {
            if (num == 2601)
                return -1;
            if (num == 547)
                return -2;
            return 0;
        }
    }
}

13.SQLite连接帮助类

//说明：本类是对文件型数据库进行访问的工具类，需要引入System.Data.SQLite.dll

//using System;
//using System.Collections.Generic;
//using System.Data;
//using System.Data.Common;
//using System.Linq;
//using System.Text;
//using System.Data.SQLite;

//namespace Quiz
//{
//    public class SQLiteHelper
//    {
//        SQLiteConnection _connection;
//        /// <summary>
//        /// SQLite连接
//        /// </summary>
//        public SQLiteConnection MyConnection
//        {
//            get
//            {                
//                if (_connection == null)
//                {
//                    _connection = new SQLiteConnection(string.Format("Data Source={0}Content/DB;Version=3;", AppDomain.CurrentDomain.SetupInformation.ApplicationBase));
//                }
//                return _connection;
//            }
//        }

//        /// <summary>
//        /// SQLite增删改
//        /// </summary>
//        /// <param name="sql">要执行的sql语句</param>
//        /// <param name="parameters">所需参数</param>
//        /// <returns>所受影响的行数</returns>
//        public int ExecuteNonQuery(string sql, SQLiteParameter[] parameters)
//        {
//            SQLiteTransaction transaction = null;
//            try
//            {
//                int affectedRows = 0;
//                MyConnection.Open();
//                transaction = MyConnection.BeginTransaction();
//                SQLiteCommand command = new SQLiteCommand(sql, MyConnection);
//                command.CommandText = sql;
//                if (parameters != null)
//                {
//                    for (int i = 0; i < parameters.Length; i++)
//                    {
//                        command.Parameters.Add(parameters[i]);
//                    }
//                }
//                affectedRows = command.ExecuteNonQuery();
//                transaction.Commit();

//                return affectedRows;
//            }
//            catch (SQLiteException ex) {
//                if(transaction !=null)
//                    transaction.Rollback();
//                return 0;
//            }
//            finally
//            {
//                if (_connection.State != ConnectionState.Closed)
//                    _connection.Close();
//            }
//        }
//        public int ExecuteNonQuery(List<String> sqls)
//        {
//            SQLiteTransaction transaction = null;
//            try
//            {
//                int affectedRows = 0;
//                MyConnection.Open();
//                transaction = MyConnection.BeginTransaction();
//                SQLiteCommand command = new SQLiteCommand(MyConnection);
//                foreach (String sql in sqls)
//                {
//                    command.CommandText = sql;
//                    affectedRows += command.ExecuteNonQuery();
//                }                
//                transaction.Commit();
//                return affectedRows;
//            }
//            catch (SQLiteException ex)
//            {
//                if (transaction != null)
//                    transaction.Rollback();
//                return 0;
//            }
//            finally
//            {
//                if (_connection.State != ConnectionState.Closed)
//                    _connection.Close();
//            }
//        }

//        /// <summary>
//        /// SQLite查询
//        /// </summary>
//        /// <param name="sql">要执行的sql语句</param>
//        /// <param name="parameters">所需参数</param>
//        /// <returns>结果DataTable</returns>
//        public DataTable ExecuteDataTable(string sql, SQLiteParameter[] parameters)
//        {
//            DataTable data = new DataTable();
//            SQLiteCommand command = new SQLiteCommand(sql, MyConnection);
//            if (parameters != null)
//            {
//                for (int i = 0; i < parameters.Length; i++)
//                {
//                    command.Parameters.Add(parameters[i]);
//                }                
//            }
//            SQLiteDataAdapter adapter = new SQLiteDataAdapter(command);
//            adapter.Fill(data);

//            return data;
//        }

//        ///// <summary>
//        ///// 查询数据库表信息
//        ///// </summary>
//        ///// <returns>数据库表信息DataTable</returns>
//        //DataTable GetSchema()
//        //{
//        //    DataTable data = new DataTable();

//        //    data = connection.GetSchema("TABLES");

//        //    return data;
//        //}
//    }
//}

14.字符串帮助类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Security.Cryptography;
using System.IO;
using System.Data;

namespace Utilities
{
    /// <summary>
    /// 字符串帮助类
    /// </summary>
    public static class StringHelper
    {
        /// <summary>
        /// 邮箱地址正则表达式
        /// </summary>
        public static Regex RegexEamil = new Regex(@"^[a-z]([a-z0-9]*[-_]?[a-z0-9]+)*@([a-z0-9]*[-_]?[a-z0-9]+)+[\.][a-z]{2,3}([\.][a-z]{2})?$", RegexOptions.IgnoreCase);
        /// <summary>
        /// 手机号正则表达式
        /// </summary>
        public static Regex RegexMobilePhone = new Regex("^[1][0-9]{10}$");
        /// <summary>
        /// 固话号正则表达式
        /// </summary>
        public static Regex RegexPhone = new Regex(@"^(\d{3,4}-?)?\d{7,8}$");
        /// <summary>
        /// IP正则表达式
        /// </summary>
        public static Regex RegexIP = new Regex(@"^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$");
        /// <summary>
        /// 日期正则表达式 yyyy-MM-dd,不是很准确
        /// </summary>
        public static Regex RegexDate = new Regex(@"[12](\d{3})-[01]?\d-[0123]?\d");
        /// <summary>
        /// 数值(包括整数和小数)正则表达式
        /// </summary>
        public static Regex RegexNumeric = new Regex(@"^[-]?[0-9]+(\.[0-9]+)?$");
        /// <summary>
        /// 邮政编码正则表达式
        /// </summary>
        public static Regex RegexZipcoder = new Regex(@"^\d{6}$");

        /// <summary>
        /// 将字符串数组拼接成用单引号括起来的字符串。
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        public static string ToSqlIdString(this String[] ids)
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < ids.Length; i++)
            {
                if (i == 0)
                    sb.Append("'").Append(ids[i]).Append("'");
                else
                    sb.Append(",'").Append(ids[i]).Append("'");
            }
            return sb.ToString();
        }
        /// <summary>
        /// 处理答案
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        public static string ToChoiceAnswer(this string s)
        {
            string da = "ABCDEFGHIGKLMN";
            List<char> nd = new List<char>();
            foreach (var c in s)
            {
                var cx = c.ToString().ToUpper();
                if (da.Contains(cx))
                    nd.Add(cx[0]);
            }
            nd.Sort();
            var ans = "";
            foreach (var c in nd)
                ans += c;
            return ans.ToString();
        }

        static Dictionary<int, string> dic = new Dictionary<int, string>();
        static Regex OutWebURL = new Regex("://[\\s\\S]*?/", RegexOptions.IgnoreCase);
        static StringHelper()
        {
            dic.Add(0, "零");
            dic.Add(1, "一");
            dic.Add(2, "二");
            dic.Add(3, "三");
            dic.Add(4, "四");
            dic.Add(5, "五");
            dic.Add(6, "六");
            dic.Add(7, "七");
            dic.Add(8, "八");
            dic.Add(9, "九");
        }

        /// <summary>
        /// 将 Stream 转化成 string
        /// </summary>
        /// <param name="s">Stream流</param>
        /// <returns>string</returns>
        public static string ConvertStreamToString(Stream s)
        {
            string strResult = "";
            StreamReader sr = new StreamReader(s, Encoding.UTF8);

            Char[] read = new Char[256];
            // Read 256 charcters at a time.    
            int count = sr.Read(read, 0, 256);
            while (count > 0)
            {
                // Dump the 256 characters on a string and display the string onto the console.
                string str = new String(read, 0, count);
                strResult += str;
                count = sr.Read(read, 0, 256);
            }
            // 释放资源
            sr.Close();
            return strResult;
        }

        /// <summary>
        /// 输出由同一字符组成的指定长度的字符串
        /// </summary>
        /// <param name="Char">输出字符，如：A</param>
        /// <param name="i">指定长度</param>
        /// <returns></returns>
        public static string Strings(char Char, int i)
        {
            string strResult = null;

            for (int j = 0; j < i; j++)
            {
                strResult += Char;
            }
            return strResult;
        }

        /// <summary>
        /// 返回字符串的字节长度
        /// </summary>
        /// <param name="str">指定字符串</param>
        /// <returns>字节个数</returns>
        public static int GetLen(string str)
        {
            int intResult = 0;
            Encoding gb2312 = Encoding.GetEncoding("gb2312");
            byte[] bytes = gb2312.GetBytes(str);
            intResult = bytes.Length;
            return intResult;
        }
        #region 随机数
        /// <summary>
        /// 获取指定长度的纯数字随机数字串
        /// </summary>
        /// <param name="intLong">数字串长度</param>
        /// <returns>字符串</returns>
        public static string GetRandomNum(int intLong)
        {
            string strResult = "";

            Random r = new Random(DateTime.Now.Millisecond);
            for (int i = 0; i < intLong; i++)
            {
                strResult = strResult + r.Next(10);
            }

            return strResult;
        }

        /// <summary>
        /// 获取一个由26个小写字母组成的指定长度的随即字符串
        /// </summary>
        /// <param name="intLong">指定长度</param>
        /// <returns></returns>
        public static string GetRandomLetters(int intLong)
        {
            string strResult = "";
            string[] array = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" };

            Random r = new Random();

            for (int i = 0; i < intLong; i++)
            {
                strResult += array[r.Next(26)];
            }

            return strResult;
        }

        /// <summary>
        /// 获取一个由数字和26个小写字母组成的指定长度的随即字符串
        /// </summary>
        /// <param name="intLong">指定长度</param>
        /// <returns></returns>
        public static string GetRandomNumAndLetters(int intLong)
        {
            string strResult = "";
            string[] array = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" };

            Random r = new Random();

            for (int i = 0; i < intLong; i++)
            {
                strResult += array[r.Next(36)];
            }

            return strResult;
        }
        #endregion

        #region 正则表达式的使用

        /// <summary>
        /// 判断字符串是否为有效的邮件地址
        /// </summary>
        /// <param name="email"></param>
        /// <returns></returns>
        public static bool IsValidEmail(string email)
        {
            return Regex.IsMatch(email, @"^.+\@(\[?)[a-zA-Z0-9\-\.]+\.([a-zA-Z]{2,3}|[0-9]{1,3})(\]?)$");
        }
        /// <summary>
        /// 判断字符串是否为有效的URL地址
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        public static bool IsValidURL(string url)
        {
            return Regex.IsMatch(url, @"^(http|https|ftp)\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(:[a-zA-Z0-9]*)?/?([a-zA-Z0-9\-\._\?\,\'/\\\+&%\$#\=~])*[^\.\,\)\(\s]$");
        }

        /// <summary>
        /// 判断字符串是否为Int类型的
        /// </summary>
        /// <param name="val"></param>
        /// <returns></returns>
        public static bool IsValidInt(string val)
        {
            return Regex.IsMatch(val, @"^[1-9]\d*\.?[0]*$");
        }

        /// <summary>
        /// 检测字符串是否全为正整数
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static bool IsNum(string str)
        {
            bool blResult = true;//默认状态下是数字

            if (str == "")
                blResult = false;
            else
            {
                foreach (char Char in str)
                {
                    if (!char.IsNumber(Char))
                    {
                        blResult = false;
                        break;
                    }
                }
                if (blResult)
                {
                    if (int.Parse(str) == 0)
                        blResult = false;
                }
            }
            return blResult;
        }
        /// <summary>
        /// 检测字符串是否全为数字型
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static bool IsDouble(string str)
        {
            bool blResult = true;//默认状态下是数字

            if (str == "")
                blResult = false;
            else
            {
                foreach (char Char in str)
                {
                    if (!char.IsNumber(Char) && Char.ToString() != "-")
                    {
                        blResult = false;
                        break;
                    }
                }
            }
            return blResult;
        }
        /// <summary>
        /// 判断输入的字符串是否完全匹配正则
        /// </summary>
        /// <param name="RegexExpression">正则表达式</param>
        /// <param name="str">待判断的字符串</param>
        /// <returns></returns>
        public static bool IsValiable(string RegexExpression, string str)
        {
            bool blResult = false;

            Regex rep = new Regex(RegexExpression, RegexOptions.IgnoreCase);

            //blResult = rep.IsMatch(str);
            Match mc = rep.Match(str);

            if (mc.Success)
            {
                if (mc.Value == str) blResult = true;
            }
            return blResult;
        }

        /// <summary>
        /// 转换代码中的URL路径为绝对URL路径
        /// </summary>
        /// <param name="sourceString">源代码</param>
        /// <param name="replaceURL">替换要添加的URL</param>
        /// <returns>string</returns>
        public static string ConvertURL(string sourceString, string replaceURL)
        {
            Regex rep = new Regex(" (src|href|background|value)=('|\"|)([^('|\"|)http://].*?)('|\"| |>)");
            sourceString = rep.Replace(sourceString, " $1=$2" + replaceURL + "$3$4");
            return sourceString;
        }

        /// <summary>
        /// 获取代码中所有图片的以HTTP开头的URL地址
        /// </summary>
        /// <param name="sourceString">代码内容</param>
        /// <returns>ArrayList</returns>
        public static List<string> GetImgFileUrl(string sourceString)
        {
            List<string> imgArray = new List<string>();
            Regex r = new Regex("<IMG(.*?)src=('|\"|)(http://.*?)('|\"| |>)", RegexOptions.IgnoreCase | RegexOptions.Compiled);
            MatchCollection mc = r.Matches(sourceString);
            for (int i = 0; i < mc.Count; i++)
            {
                if (!imgArray.Contains(mc[i].Result("$3")))
                {
                    imgArray.Add(mc[i].Result("$3"));
                }
            }
            return imgArray;
        }

        /// <summary>
        /// 获取代码中所有文件的以HTTP开头的URL地址
        /// </summary>
        /// <param name="sourceString">代码内容</param>
        /// <returns>ArrayList</returns>
        public static Dictionary<int, string> GetFileUrlPath(string sourceString)
        {
            Dictionary<int, string> url = new Dictionary<int, string>();
            Regex r = new Regex(" (src|href|background|value)=('|\"|)(http://.*?)('|\"| |>)",
                RegexOptions.IgnoreCase | RegexOptions.Compiled);
            MatchCollection mc = r.Matches(sourceString);
            for (int i = 0; i < mc.Count; i++)
            {
                if (!url.ContainsValue(mc[i].Result("$3")))
                {
                    url.Add(i, mc[i].Result("$3"));
                }
            }
            return url;
        }

        /// <summary>
        /// 获取一条SQL语句中的所参数
        /// </summary>
        /// <param name="sql">SQL语句</param>
        /// <returns></returns>
        public static List<string> SqlParame(string sql)
        {
            List<string> list = new List<string>();
            Regex r = new Regex(@"@(?<x>[0-9a-zA-Z]*)", RegexOptions.IgnoreCase | RegexOptions.Compiled);
            MatchCollection mc = r.Matches(sql);
            for (int i = 0; i < mc.Count; i++)
            {
                list.Add(mc[i].Result("$1"));
            }
            return list;
        }

        /// <summary>
        /// 获取一条SQL语句中的所参数
        /// </summary>
        /// <param name="sql">SQL语句</param>
        /// <returns></returns>
        public static List<string> OracleParame(string sql)
        {
            List<string> list = new List<string>();
            Regex r = new Regex(@":(?<x>[0-9a-zA-Z]*)", RegexOptions.IgnoreCase | RegexOptions.Compiled);
            MatchCollection mc = r.Matches(sql);
            for (int i = 0; i < mc.Count; i++)
            {
                list.Add(mc[i].Result("$1"));
            }

            return list;
        }

        /// <summary>
        /// 将HTML代码转化成纯文本
        /// </summary>
        /// <param name="sourceHTML">HTML代码</param>
        /// <returns></returns>
        public static string ConvertText(string sourceHTML)
        {
            string strResult = "";
            Regex r = new Regex("<(.*?)>", RegexOptions.IgnoreCase | RegexOptions.Compiled);
            MatchCollection mc = r.Matches(sourceHTML);

            if (mc.Count == 0)
            {
                strResult = sourceHTML;
            }
            else
            {
                strResult = sourceHTML;
                for (int i = 0; i < mc.Count; i++)
                {
                    strResult = strResult.Replace(mc[i].ToString(), "");
                }
            }
            return strResult.Replace("&nbsp;", "");
        }
        #endregion

        /// <summary>
        /// 封装XML数据串
        /// </summary>
        /// <param name="str"></param>
        /// <returns>string</returns>
        public static string ConvertXmlString(string str)
        {
            return "<![CDATA[" + str + "]]>";
        }

        /// <summary>
        /// 对字符串进行 HTML 编码操作，用于无法使用Server类的场景。
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns></returns>
        public static string HtmlEncode(string str)
        {
            str = str.Replace("&", "&amp;");
            str = str.Replace("'", "''");
            str = str.Replace("\"", "&quot;");
            str = str.Replace(" ", "&nbsp;");
            str = str.Replace("<", "&lt;");
            str = str.Replace(">", "&gt;");
            str = str.Replace("\n", "<br>");
            return str;
        }
        /// <summary>
        /// 对 HTML 字符串进行解码操作，用于无法使用Server类的场景。
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns></returns>
        public static string HtmlDecode(string str)
        {
            str = str.Replace("<br>", "\n");
            str = str.Replace("&gt;", ">");
            str = str.Replace("&lt;", "<");
            str = str.Replace("&nbsp;", " ");
            str = str.Replace("&quot;", "\"");
            return str;
        }

        /// <summary>
        /// 对脚本程序进行处理
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string ConvertScript(string str)
        {
            string strResult = "";
            if (str != "")
            {
                StringReader sr = new StringReader(str);
                string rl;
                do
                {
                    strResult += sr.ReadLine();
                } while ((rl = sr.ReadLine()) != null);
            }

            strResult = strResult.Replace("\"", "&quot;");
            return strResult;
        }

        /// <summary>
        /// 过滤屏蔽的字符串
        /// </summary>
        /// <param name="source"></param>
        /// <param name="filter"></param>
        /// <returns></returns>
        public static string FilterString(string source, string[] filter)
        {
            StringBuilder sb = new StringBuilder(source);

            foreach (String str in filter)
            {
                sb.Replace(str, "*");
            }

            return sb.ToString();
        }
        /// <summary>
        /// 随机产生一个Color字符串。例如 ffee99
        /// </summary>
        /// <returns></returns>
        public static string GetColorString()
        {
            Guid uid = Guid.NewGuid();
            string sid = uid.ToString().Replace("-", "");
            Random r = new Random(DateTime.Now.Millisecond);
            return uid.ToString().Substring(r.Next(24), 6);
        }
        /// <summary>
        /// 对source，按照“＃”进行分割，获取第num个字符串的值
        /// </summary>
        /// <param name="source"></param>
        /// <param name="num"></param>
        /// <returns></returns>
        public static string GetSplitString(string source, int num)
        {
            return GetSplitString(source, "#", num);
        }
        /// <summary>
        /// 对source，按照指定的字符串以split进行分割，获取第num个字符串的值
        /// </summary>
        /// <param name="source"></param>
        /// <param name="split"></param>
        /// <param name="num"></param>
        /// <returns></returns>
        public static string GetSplitString(string source, string split, int num)
        {
            try
            {
                string[] strs = source.Split(new string[] { split }, StringSplitOptions.RemoveEmptyEntries);
                return strs[num];
            }
            catch
            {
                return "Empty";
            }
        }
        /// <summary>
        /// 获取一个唯一值
        /// </summary>
        /// <returns></returns>
        public static string GetUniqueString()
        {
            string str = DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString() + DateTime.Now.Day.ToString() + DateTime.Now.Hour.ToString() + DateTime.Now.Minute.ToString() + DateTime.Now.Second.ToString() + DateTime.Now.Millisecond.ToString() + (new Random()).Next();
            return str;
        }


        /// <summary>
        /// 格式化占用空间大小的输出
        /// </summary>
        /// <param name="size">大小</param>
        /// <returns>返回 String</returns>
        public static string FormatNUM(long size)
        {
            decimal NUM;
            string strResult;

            if (size > 1073741824)
            {
                NUM = (Convert.ToDecimal(size) / Convert.ToDecimal(1073741824));
                strResult = NUM.ToString("N") + " G";
            }
            else if (size > 1048576)
            {
                NUM = (Convert.ToDecimal(size) / Convert.ToDecimal(1048576));
                strResult = NUM.ToString("N") + " M";
            }
            else if (size > 1024)
            {
                NUM = (Convert.ToDecimal(size) / Convert.ToDecimal(1024));
                strResult = NUM.ToString("N") + " KB";
            }
            else
            {
                strResult = size + " 字节";
            }

            return strResult;
        }
        /// <summary>
        /// 获取指定汉字拼音的首字母
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string GetFirstLetter(string str)
        {
            int i = 0;
            ushort key = 0;
            string strResult = string.Empty;

            //创建两个不同的encoding对象
            Encoding unicode = Encoding.Unicode;
            //创建GBK码对象
            Encoding gbk = Encoding.GetEncoding(936);
            //将unicode字符串转换为字节
            byte[] unicodeBytes = unicode.GetBytes(str);
            //再转化为GBK码
            byte[] gbkBytes = Encoding.Convert(unicode, gbk, unicodeBytes);
            while (i < gbkBytes.Length)
            {
                //如果为数字\字母\其他ASCII符号
                if (gbkBytes[i] <= 127)
                {
                    strResult = strResult + (char)gbkBytes[i];
                    i++;
                }
                #region 否则生成汉字拼音简码,取拼音首字母
                else
                {

                    key = (ushort)(gbkBytes[i] * 256 + gbkBytes[i + 1]);
                    if (key >= '\uB0A1' && key <= '\uB0C4')
                    {
                        strResult = strResult + "A";
                    }
                    else if (key >= '\uB0C5' && key <= '\uB2C0')
                    {
                        strResult = strResult + "B";
                    }
                    else if (key >= '\uB2C1' && key <= '\uB4ED')
                    {
                        strResult = strResult + "C";
                    }
                    else if (key >= '\uB4EE' && key <= '\uB6E9')
                    {
                        strResult = strResult + "D";
                    }
                    else if (key >= '\uB6EA' && key <= '\uB7A1')
                    {
                        strResult = strResult + "E";
                    }
                    else if (key >= '\uB7A2' && key <= '\uB8C0')
                    {
                        strResult = strResult + "F";
                    }
                    else if (key >= '\uB8C1' && key <= '\uB9FD')
                    {
                        strResult = strResult + "G";
                    }
                    else if (key >= '\uB9FE' && key <= '\uBBF6')
                    {
                        strResult = strResult + "H";
                    }
                    else if (key >= '\uBBF7' && key <= '\uBFA5')
                    {
                        strResult = strResult + "J";
                    }
                    else if (key >= '\uBFA6' && key <= '\uC0AB')
                    {
                        strResult = strResult + "K";
                    }
                    else if (key >= '\uC0AC' && key <= '\uC2E7')
                    {
                        strResult = strResult + "L";
                    }
                    else if (key >= '\uC2E8' && key <= '\uC4C2')
                    {
                        strResult = strResult + "M";
                    }
                    else if (key >= '\uC4C3' && key <= '\uC5B5')
                    {
                        strResult = strResult + "N";
                    }
                    else if (key >= '\uC5B6' && key <= '\uC5BD')
                    {
                        strResult = strResult + "O";
                    }
                    else if (key >= '\uC5BE' && key <= '\uC6D9')
                    {
                        strResult = strResult + "P";
                    }
                    else if (key >= '\uC6DA' && key <= '\uC8BA')
                    {
                        strResult = strResult + "Q";
                    }
                    else if (key >= '\uC8BB' && key <= '\uC8F5')
                    {
                        strResult = strResult + "R";
                    }
                    else if (key >= '\uC8F6' && key <= '\uCBF9')
                    {
                        strResult = strResult + "S";
                    }
                    else if (key >= '\uCBFA' && key <= '\uCDD9')
                    {
                        strResult = strResult + "T";
                    }
                    else if (key >= '\uCDDA' && key <= '\uCEF3')
                    {
                        strResult = strResult + "W";
                    }
                    else if (key >= '\uCEF4' && key <= '\uD188')
                    {
                        strResult = strResult + "X";
                    }
                    else if (key >= '\uD1B9' && key <= '\uD4D0')
                    {
                        strResult = strResult + "Y";
                    }
                    else if (key >= '\uD4D1' && key <= '\uD7F9')
                    {
                        strResult = strResult + "Z";
                    }
                    else
                    {
                        strResult = strResult + "?";
                    }
                    i = i + 2;
                }
                #endregion
            }//end while

            return strResult;
        }
        /// <summary>
        /// 获取文件名
        /// </summary>
        /// <param name="filePath">包含有文件名的字符串</param>
        /// <returns></returns>
        public static string GetFileName(string filePath)
        {
            if (filePath.IndexOf("\\") > 0)
            {
                return filePath.Substring(filePath.LastIndexOf("\\") + 1);
            }
            else
                return filePath.Substring(filePath.LastIndexOf("/") + 1);
        }
        /// <summary>
        /// 获取fileName的扩展名
        /// </summary>
        /// <param name="fileName">文件名称</param>
        /// <returns></returns>
        public static string GetExtName(string fileName)
        {
            string fileExt = fileName.Substring(fileName.LastIndexOf(".") + 1).ToLower();
            if (fileExt == "jpeg")
                fileExt = "jpg";
            return fileExt;
        }
        /// <summary>
        /// 获取指定data中前len个字符构成的字符串
        /// </summary>
        /// <param name="data"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        public static string GetSubstring(string data, int len)
        {
            if (data.Length > len)
                return data.Substring(0, len) + "...";
            else
                return data;
        }
        /// <summary>
        /// 获取指定data的指定类型的字符编号
        /// </summary>
        /// <param name="data">从1到999</param>
        /// <param name="type">从1到8</param>
        /// <returns></returns>
        public static string ToNum(this int data, int type)
        {
            switch (type)
            {
                case 1://汉字显示
                    return string.Format("{0}:", GetCh(data));
                case 2:
                    return string.Format("{0}、", data);
                case 3:
                    return string.Format("({0})、", data);
                case 4:
                    return string.Format("({0})、", GetZM(data, true));
                case 5:
                    return string.Format("({0})、", GetZM(data, false));
                case 6:
                    return "●";
                case 7:
                    return "★";
                default:
                    return "◆";
            }
        }
        static string GetCh(int data)
        {
            int b = data / 100;
            int s = (data - 100 * b) / 10;
            int g = data % 10;
            string ret = dic[b] + dic[s] + dic[g];
            if (ret[0] == '零')
                ret = ret.Substring(1);
            if (ret[0] == '零')
                ret = ret.Substring(1);
            return ret;
        }
        static string GetZM(int data, bool isBig)
        {
            int s = data / 26;
            int y = data % 26;
            string ret = "";
            char A = 'a';
            if (isBig)
                A = 'A';
            if (s > 0)
                ret = ((char)(A + s)).ToString();
            if (y > 0)
                ret += ((char)(A + y)).ToString();
            if (y == 0)
                ret += "Z";
            return ret;
        }

        #region 安全性

        /// <summary>
        /// 对传递的参数字符串进行处理，防止注入式攻击
        /// </summary>
        /// <param name="str">传递的参数字符串</param>
        /// <returns>String</returns>
        public static string ConvertSql(string str)
        {
            str = str.Trim();
            str = str.Replace("'", "''");
            str = str.Replace(";--", "");
            str = str.Replace("=", "");
            str = str.Replace(" or ", "");
            str = str.Replace(" and ", "");
            return str;
        }
        /// <summary>
        /// 移除不安全代码,防止页面攻击
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string GetSafeCode(string str)
        {
            StringBuilder builder = new StringBuilder(str);
            Regex regex = new Regex(@"<script[\s\S]*?>[\s\S]*?</script>", RegexOptions.IgnoreCase);
            foreach (Match match in regex.Matches(builder.ToString()))
            {
                builder.Replace(match.Value, "");
            }
            regex = new Regex(@"<script[\s\S]*?/>", RegexOptions.IgnoreCase);
            foreach (Match match2 in regex.Matches(builder.ToString()))
            {
                builder.Replace(match2.Value, "");
            }
            regex = new Regex(@"<iframe[\s\S]*?/>", RegexOptions.IgnoreCase);
            foreach (Match match3 in regex.Matches(builder.ToString()))
            {
                builder.Replace(match3.Value, "");
            }
            regex = new Regex(@"<iframe[\s\S]*?>[\s\S]*?</iframe>", RegexOptions.IgnoreCase);
            foreach (Match match4 in regex.Matches(builder.ToString()))
            {
                builder.Replace(match4.Value, "");
            }
            return builder.ToString();
        }
        #endregion

        #region Html源代码处理
        /// <summary>
        /// 移除HTML标记
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string RemoveHtmlCode(string str)
        {
            StringBuilder builder = new StringBuilder(str);
            Regex regex = new Regex(@"<[\s\S]*?>", RegexOptions.IgnoreCase);
            foreach (Match match in regex.Matches(builder.ToString()))
            {
                builder.Replace(match.Value, "");
            }
            builder.Replace("&nbsp;", " ");
            return builder.ToString().Trim();
        }

        /// <summary>
        /// 移除HTML代码的某些标记
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string RemoveHtmlCode(string str, params String[] labels)
        {
            StringBuilder builder = new StringBuilder(str);

            foreach (String tempstr in labels)
            {
                Regex regex = new Regex(@"<\/{0,1}" + tempstr + @"[\s\S]*?>", RegexOptions.IgnoreCase);
                foreach (Match match in regex.Matches(builder.ToString()))
                {
                    builder.Replace(match.Value, "");
                }
            }

            builder.Replace("&nbsp;", " ");
            return builder.ToString().Trim();
        }

        /// <summary>
        /// 移除所有标签的某些属性
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string RemoveHtmlAttributeCode(string str, params String[] attributes)
        {
            StringBuilder builder = new StringBuilder(str);

            Regex regexHtmlLabel = new Regex(@"<[\s\S]*?>", RegexOptions.IgnoreCase);

            foreach (Match match in regexHtmlLabel.Matches(builder.ToString()))
            {   //原始标签赋值给os临时变量
                String tempLable = match.Value;
                //最外层需要替换掉的标签字符串
                String replaceLabel = tempLable;
                foreach (string attribute in attributes)
                {
                    Regex regexAttribute = new Regex(attribute + @"=\S*?( |>)", RegexOptions.IgnoreCase);
                    //找到标签中对应的属性
                    foreach (Match matchTemp in regexAttribute.Matches(replaceLabel))
                    {
                        //找到替换后的临时变量
                        tempLable = tempLable.Replace(matchTemp.Value.TrimEnd('>'), "");
                        //最外层替换
                        builder.Replace(replaceLabel, tempLable);
                        //替换掉的标签字符串修改
                        replaceLabel = tempLable;
                    }
                }

            }

            return builder.ToString().Trim();

        }

        /// <summary>
        /// 移除指定标签的某些属性
        /// </summary>
        /// <param name="htmlStr">html格式的字符串</param>
        /// <param name="label">指定的标签</param>
        /// <param name="attributes">属性名称集合</param>
        /// <returns>移除后的新字符串</returns>
        public static string RemoveHtmlAttributeCode(string htmlStr, String label, params String[] attributes)
        {
            StringBuilder builder = new StringBuilder(htmlStr);

            Regex regexHtmlLabel = new Regex(@"<\/{0,1}" + label + @"[\s\S]*?>", RegexOptions.IgnoreCase);

            foreach (Match match in regexHtmlLabel.Matches(builder.ToString()))
            {   //原始标签赋值给os临时变量
                String tempLable = match.Value;

                //最外层需要替换掉的标签字符串
                String replaceLabel = tempLable;
                foreach (string attribute in attributes)
                {

                    Regex regexAttribute = new Regex(attribute + @"=\S*?( |>)", RegexOptions.IgnoreCase);


                    //找到标签中对应的属性
                    foreach (Match matchTemp in regexAttribute.Matches(replaceLabel))
                    {

                        //找到替换后的临时变量
                        tempLable = tempLable.Replace(matchTemp.Value.TrimEnd('>'), "");

                        //最外层替换
                        builder.Replace(replaceLabel, tempLable);

                        //替换掉的标签字符串修改
                        replaceLabel = tempLable;
                    }

                }

            }

            return builder.ToString().Trim();

        }

        /// <summary>
        /// 移除指定标签的某个属性
        /// </summary>
        /// <param name="htmlStr">html格式的字符串</param>
        /// <param name="label">指定的标签</param>
        /// <param name="attribute">属性名称</param>
        /// <returns>移除后的新字符串</returns>
        public static string RemoveHtmlAttributeCode(string htmlStr, String label, String attribute)
        {
            StringBuilder builder = new StringBuilder(htmlStr);

            Regex regex = new Regex(@"<\/{0,1}" + label + @"[\s\S]*?>", RegexOptions.IgnoreCase);

            Regex regexAttribute = new Regex(attribute + @"=\S*?( |>)", RegexOptions.IgnoreCase);

            //找到匹配到标签
            foreach (Match match in regex.Matches(builder.ToString()))
            {
                //原始标签赋值给os临时变量
                String tempLable = match.Value;

                //最外层需要替换掉的标签字符串
                String replaceLabel = tempLable;

                //找到标签中对应的属性
                foreach (Match matchTemp in regexAttribute.Matches(replaceLabel))
                {

                    //找到替换后的临时变量
                    tempLable = tempLable.Replace(matchTemp.Value.TrimEnd('>'), "");

                    //最外层替换
                    builder.Replace(replaceLabel, tempLable);

                    //替换掉的标签字符串修改
                    replaceLabel = tempLable;
                }
            }

            return builder.ToString();
        }
        /// <summary>
        /// 移除除了指定域名的其他URL
        /// </summary>
        /// <param name="str">Html字符串</param>
        /// <param name="myDomain">自己的域名，如：fund123.cn</param>
        /// <returns>结果字符串</returns>
        public static string RemoveUrlLink(String str, String myDomain)
        {
            StringBuilder builder = new StringBuilder(str);

            //找到所有的href连接
            Regex regex = new Regex(@" href=[\s\S]*?( |>)", RegexOptions.IgnoreCase);

            foreach (Match match in regex.Matches(builder.ToString()))
            {
                //如果连接中存在域名则替换
                if (match.Value.ToLower().IndexOf(myDomain.ToLower()) == -1)
                {
                    String replaceStr = match.Value.TrimEnd('>');
                    builder.Replace(replaceStr, " ");
                }
            }

            return builder.ToString().Trim();
        }
        #endregion


        /// <summary>
        /// 判断是否存在别人的连接
        /// </summary>
        /// <param name="str"></param>
        /// <param name="myDomain"></param>
        /// <returns></returns>
        public static Boolean HasUrlLink(String str, String myDomain)
        {

            //找到所有的href连接
            Regex regex = new Regex(@" href=[\s\S]*?( |>)", RegexOptions.IgnoreCase);

            foreach (Match match in regex.Matches(str))
            {
                //如果连接中存在域名则返回true
                if (match.Value.ToLower().IndexOf(myDomain.ToLower()) == -1)
                {
                    return true;
                }

            }

            return false;
        }

        /// <summary>
        /// 处理外网连接替换
        /// </summary>
        /// <param name="str"></param>
        /// <param name="myDomain"></param>
        public static String DealOutSiteURL(String str, String myDomain)
        {
            StringBuilder sb = new StringBuilder(str);

            foreach (Match match in OutWebURL.Matches(str))
            {
                if (match.Value.ToLower().IndexOf(myDomain) == -1)
                {
                    sb.Replace(match.Value, "");
                }
            }

            return sb.ToString();
        }


        #region 老式Sql分页
        /// <summary>
        /// 获取分页操作SQL语句(对于排序的字段必须建立索引，优化分页提取方式)
        /// </summary>
        /// <param name="tblName">操作表名称</param>
        /// <param name="fldName">排序的索引字段</param>
        /// <param name="PageIndex">当前页</param>
        /// <param name="PageSize">每页显示记录数</param>
        /// <param name="totalRecord">总记录数</param>
        /// <param name="OrderType">排序方式(0升序，1为降序)</param>
        /// <param name="strWhere">检索的条件语句，不需要再加WHERE关键字</param>
        /// <returns></returns>
        public static string ConstructSplitSQL(string tblName,
                                                string fldName,
                                                int PageIndex,
                                                int PageSize,
                                                int totalRecord,
                                                int OrderType,
                                                string strWhere)
        {
            string strSQL = "";
            string strOldWhere = "";
            string rtnFields = "*";

            // 构造检索条件语句字符串
            if (strWhere != "")
            {
                // 去除不合法的字符，防止SQL注入式攻击
                strWhere = strWhere.Replace("'", "''");
                strWhere = strWhere.Replace("--", "");
                strWhere = strWhere.Replace(";", "");

                strOldWhere = " AND " + strWhere + " ";

                strWhere = " WHERE " + strWhere + " ";
            }

            // 升序操作
            if (OrderType == 0)
            {
                if (PageIndex == 1)
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    //strSQL += "WHERE (" + fldName + " >= ( SELECT MAX(" + fldName + ") FROM (SELECT TOP 1 " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " ASC ) AS T )) ";

                    //strSQL += strOldWhere + "ORDER BY " + fldName + " ASC";
                    strSQL += strWhere + "ORDER BY " + fldName + " ASC";
                }
                else
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    strSQL += "WHERE (" + fldName + " > ( SELECT MAX(" + fldName + ") FROM (SELECT TOP " + ((PageIndex - 1) * PageSize) + " " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " ASC ) AS T )) ";

                    strSQL += strOldWhere + "ORDER BY " + fldName + " ASC";
                }
            }
            // 降序操作
            else if (OrderType == 1)
            {
                if (PageIndex == 1)
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    //strSQL += "WHERE (" + fldName + " <= ( SELECT MIN(" + fldName + ") FROM (SELECT TOP 1 " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " DESC ) AS T )) ";

                    //strSQL += strOldWhere + "ORDER BY " + fldName + " DESC";
                    strSQL += strWhere + "ORDER BY " + fldName + " DESC";
                }
                else
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    strSQL += "WHERE (" + fldName + " < ( SELECT MIN(" + fldName + ") FROM (SELECT TOP " + ((PageIndex - 1) * PageSize) + " " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " DESC ) AS T )) ";

                    strSQL += strOldWhere + "ORDER BY " + fldName + " DESC";
                }
            }
            else // 异常处理
            {
                throw new DataException("未指定任何排序类型。0升序，1为降序");
            }

            return strSQL;
        }


        /// <summary>
        /// 获取分页操作SQL语句(对于排序的字段必须建立索引)
        /// </summary>
        /// <param name="tblName">操作表名</param>
        /// <param name="fldName">操作索引字段名称</param>
        /// <param name="PageIndex">当前页</param>
        /// <param name="PageSize">每页显示记录数</param>
        /// <param name="rtnFields">返回字段集合，中间用逗号格开。返回全部用“*”</param>
        /// <param name="OrderType">排序方式(0升序，1为降序)</param>
        /// <param name="strWhere">检索的条件语句，不需要再加WHERE关键字</param>
        /// <returns></returns>
        public static string ConstructSplitSQL(string tblName,
                                                string fldName,
                                                int PageIndex,
                                                int PageSize,
                                                string rtnFields,
                                                int OrderType,
                                                string strWhere)
        {
            string strSQL = "";
            string strOldWhere = "";

            // 构造检索条件语句字符串
            if (strWhere != "")
            {
                // 去除不合法的字符，防止SQL注入式攻击
                strWhere = strWhere.Replace("'", "''");
                strWhere = strWhere.Replace("--", "");
                strWhere = strWhere.Replace(";", "");

                strOldWhere = " AND " + strWhere + " ";

                strWhere = " WHERE " + strWhere + " ";
            }

            // 升序操作
            if (OrderType == 0)
            {
                if (PageIndex == 1)
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    //strSQL += "WHERE (" + fldName + " >= ( SELECT MAX(" + fldName + ") FROM (SELECT TOP 1 " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " ASC ) AS T )) ";

                    //strSQL += strOldWhere + "ORDER BY " + fldName + " ASC";
                    strSQL += strWhere + "ORDER BY " + fldName + " ASC";
                }
                else
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    strSQL += "WHERE (" + fldName + " > ( SELECT MAX(" + fldName + ") FROM (SELECT TOP " + ((PageIndex - 1) * PageSize) + " " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " ASC ) AS T )) ";

                    strSQL += strOldWhere + "ORDER BY " + fldName + " ASC";
                }
            }
            // 降序操作
            else if (OrderType == 1)
            {
                if (PageIndex == 1)
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    //strSQL += "WHERE (" + fldName + " <= ( SELECT MIN(" + fldName + ") FROM (SELECT TOP 1 " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " DESC ) AS T )) ";

                    //strSQL += strOldWhere + "ORDER BY " + fldName + " DESC";
                    strSQL += strWhere + "ORDER BY " + fldName + " DESC";
                }
                else
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    strSQL += "WHERE (" + fldName + " < ( SELECT MIN(" + fldName + ") FROM (SELECT TOP " + ((PageIndex - 1) * PageSize) + " " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " DESC ) AS T )) ";

                    strSQL += strOldWhere + "ORDER BY " + fldName + " DESC";
                }
            }
            else // 异常处理
            {
                throw new DataException("未指定任何排序类型。0升序，1为降序");
            }

            return strSQL;
        }


        /// <summary>
        /// 获取分页操作SQL语句(对于排序的字段必须建立索引)
        /// </summary>
        /// <param name="tblName">操作表名</param>
        /// <param name="fldName">操作索引字段名称</param>
        /// <param name="unionCondition">用于连接的条件，例如: LEFT JOIN UserInfo u ON (u.UserID = b.UserID)</param>
        /// <param name="PageIndex">当前页</param>
        /// <param name="PageSize">每页显示记录数</param>
        /// <param name="rtnFields">返回字段集合，中间用逗号格开。返回全部用“*”</param>
        /// <param name="OrderType">排序方式，0升序，1为降序</param>
        /// <param name="strWhere">检索的条件语句，不需要再加WHERE关键字</param>
        /// <returns></returns>
        public static string ConstructSplitSQL(string tblName,
            string fldName,
            string unionCondition,
            int PageIndex,
            int PageSize,
            string rtnFields,
            int OrderType,
            string strWhere)
        {
            string strSQL = "";
            string strOldWhere = "";

            // 构造检索条件语句字符串
            if (strWhere != "")
            {
                // 去除不合法的字符，防止SQL注入式攻击
                strWhere = strWhere.Replace("'", "''");
                strWhere = strWhere.Replace("--", "");
                strWhere = strWhere.Replace(";", "");

                strOldWhere = " AND " + strWhere + " ";

                strWhere = " WHERE " + strWhere + " ";
            }

            // 升序操作
            if (OrderType == 0)
            {
                if (PageIndex == 1)
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + unionCondition + " ";

                    //strSQL += "WHERE (" + fldName + " >= ( SELECT MAX(" + fldName + ") FROM (SELECT TOP 1 " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " ASC ) AS T )) ";

                    //strSQL += strOldWhere + "ORDER BY " + fldName + " ASC";
                    strSQL += strWhere + "ORDER BY " + fldName + " ASC";
                }
                else
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + unionCondition + " ";

                    strSQL += "WHERE (" + fldName + " > ( SELECT MAX(" + fldName + ") FROM (SELECT TOP " + ((PageIndex - 1) * PageSize) + " " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " ASC ) AS T )) ";

                    strSQL += strOldWhere + "ORDER BY " + fldName + " ASC";
                }
            }
            // 降序操作
            else if (OrderType == 1)
            {
                if (PageIndex == 1)
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + unionCondition + " ";

                    //strSQL += "WHERE (" + fldName + " <= ( SELECT MIN(" + fldName + ") FROM (SELECT TOP 1 " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " DESC ) AS T )) ";

                    //strSQL += strOldWhere + "ORDER BY " + fldName + " DESC";
                    strSQL += strWhere + "ORDER BY " + fldName + " DESC";
                }
                else
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + unionCondition + " ";

                    strSQL += "WHERE (" + fldName + " < ( SELECT MIN(" + fldName + ") FROM (SELECT TOP " + ((PageIndex - 1) * PageSize) + " " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " DESC ) AS T )) ";

                    strSQL += strOldWhere + "ORDER BY " + fldName + " DESC";
                }
            }
            else // 异常处理
            {
                throw new DataException("未指定任何排序类型。0升序，1为降序");
            }

            return strSQL;
        }


        /// <summary>
        /// 获取分页操作SQL语句(对于排序的字段必须建立索引)
        /// </summary>
        /// <param name="tblName">操作表名</param>
        /// <param name="fldName">操作索引字段名称</param>
        /// <param name="PageIndex">当前页</param>
        /// <param name="PageSize">每页显示记录数</param>
        /// <param name="rtnFields">返回字段集合，中间用逗号格开。返回全部用“*”</param>
        /// <param name="OrderType">排序方式(0升序，1为降序)</param>
        /// <param name="strWhere">检索的条件语句，不需要再加WHERE关键字</param>
        /// <returns></returns>
        public static string ConstructSplitSQL_TOP(string tblName,
                                                    string fldName,
                                                    int PageIndex,
                                                    int PageSize,
                                                    string rtnFields,
                                                    int OrderType,
                                                    string strWhere)
        {
            string strSQL = "";
            string strOldWhere = "";

            // 构造检索条件语句字符串
            if (strWhere != "")
            {
                // 去除不合法的字符，防止SQL注入式攻击
                strWhere = strWhere.Replace("'", "''");
                strWhere = strWhere.Replace("--", "");
                strWhere = strWhere.Replace(";", "");

                strOldWhere = " AND " + strWhere + " ";

                strWhere = " WHERE " + strWhere + " ";
            }

            // 升序操作
            if (OrderType == 0)
            {
                if (PageIndex == 1)
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    strSQL += strWhere + " ORDER BY " + fldName + " ASC";
                }
                else
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    strSQL += "WHERE (" + fldName + " > ( SELECT MAX(" + fldName + ") FROM (SELECT TOP " + ((PageIndex - 1) * PageSize) + " " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " ASC ) AS T )) ";

                    strSQL += strOldWhere + "ORDER BY " + fldName + " ASC";
                }
            }
            // 降序操作
            else if (OrderType == 1)
            {
                if (PageIndex == 1)
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    strSQL += strWhere + " ORDER BY " + fldName + " DESC";
                }
                else
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    strSQL += "WHERE (" + fldName + " < ( SELECT MIN(" + fldName + ") FROM (SELECT TOP " + ((PageIndex - 1) * PageSize) + " " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " DESC ) AS T )) ";

                    strSQL += strOldWhere + "ORDER BY " + fldName + " DESC";
                }
            }
            else // 异常处理
            {
                throw new DataException("未指定任何排序类型。0升序，1为降序");
            }

            return strSQL;
        }

        /// <summary>
        /// 获取分页操作SQL语句(对于排序的字段必须建立索引)
        /// </summary>
        /// <param name="tblName">操作表名</param>
        /// <param name="fldName">操作索引字段名称</param>
        /// <param name="PageIndex">当前页</param>
        /// <param name="PageSize">每页显示记录数</param>
        /// <param name="rtnFields">返回字段集合，中间用逗号格开。返回全部用“*”</param>
        /// <param name="OrderType">排序方式(0升序，1为降序)</param>
        /// <param name="sort">排序表达式</param>
        /// <param name="strWhere">检索的条件语句，不需要再加WHERE关键字</param>
        /// <returns></returns>
        public static string ConstructSplitSQL_sort(string tblName,
            string fldName,
            int PageIndex,
            int PageSize,
            string rtnFields,
            int OrderType,
            string sort,
            string strWhere)
        {
            string strSQL = "";
            string strOldWhere = "";

            // 构造检索条件语句字符串
            if (strWhere != "")
            {
                // 去除不合法的字符，防止SQL注入式攻击
                strWhere = strWhere.Replace("'", "''");
                strWhere = strWhere.Replace("--", "");
                strWhere = strWhere.Replace(";", "");

                strOldWhere = " AND " + strWhere + " ";

                strWhere = " WHERE " + strWhere + " ";
            }

            if (sort != "") sort = " ORDER BY " + sort;

            // 升序操作
            if (OrderType == 0)
            {
                if (PageIndex == 1)
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    //strSQL += "WHERE (" + fldName + " >= ( SELECT MAX(" + fldName + ") FROM (SELECT TOP 1 " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " ASC ) AS T )) ";

                    //strSQL += strOldWhere + "ORDER BY " + fldName + " ASC";
                    strSQL += strWhere + sort;
                }
                else
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    strSQL += "WHERE (" + fldName + " > ( SELECT MAX(" + fldName + ") FROM (SELECT TOP " + ((PageIndex - 1) * PageSize) + " " + fldName + " FROM " + tblName + strWhere + sort + " ) AS T )) ";

                    strSQL += strOldWhere + sort;
                }
            }
            // 降序操作
            else if (OrderType == 1)
            {
                if (PageIndex == 1)
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    //strSQL += "WHERE (" + fldName + " <= ( SELECT MIN(" + fldName + ") FROM (SELECT TOP 1 " + fldName + " FROM " + tblName + strWhere + " ORDER BY " + fldName + " DESC ) AS T )) ";

                    //strSQL += strOldWhere + "ORDER BY " + fldName + " DESC";
                    strSQL += strWhere + sort;
                }
                else
                {
                    strSQL += "SELECT TOP " + PageSize + " " + rtnFields + " FROM " + tblName + " ";

                    strSQL += "WHERE (" + fldName + " < ( SELECT MIN(" + fldName + ") FROM (SELECT TOP " + ((PageIndex - 1) * PageSize) + " " + fldName + " FROM " + tblName + strWhere + sort + " ) AS T )) ";

                    strSQL += strOldWhere + sort;
                }
            }
            else // 异常处理
            {
                throw new DataException("未指定主索引排序类型。0升序，1为降序");
            }

            return strSQL;
        }

        #endregion

        /// <summary>
        /// 服务于AES/DES加解密类的方法
        /// </summary>
        /// <param name="p_SrcString"></param>
        /// <param name="p_Length"></param>
        /// <param name="p_TailString"></param>
        /// <returns></returns>
        public static string GetSubString(string p_SrcString, int p_Length, string p_TailString)
        {
            string text = p_SrcString;
            if (p_Length < 0)
            {
                return text;
            }
            byte[] sourceArray = Encoding.Default.GetBytes(p_SrcString);
            if (sourceArray.Length <= p_Length)
            {
                return text;
            }
            int length = p_Length;
            int[] numArray = new int[p_Length];
            byte[] destinationArray = null;
            int num2 = 0;
            for (int i = 0; i < p_Length; i++)
            {
                if (sourceArray[i] > 0x7f)
                {
                    num2++;
                    if (num2 == 3)
                    {
                        num2 = 1;
                    }
                }
                else
                {
                    num2 = 0;
                }
                numArray[i] = num2;
            }
            if ((sourceArray[p_Length - 1] > 0x7f) && (numArray[p_Length - 1] == 1))
            {
                length = p_Length + 1;
            }
            destinationArray = new byte[length];
            Array.Copy(sourceArray, destinationArray, length);
            return (Encoding.Default.GetString(destinationArray) + p_TailString);
        }
    }
}

15.时间日期管理类，主要用来进行年月日与周的换算

using System;
using System.Collections.Generic;
using System.Text;

namespace Utilities
{
    /// <summary>
    /// 时间日期管理类，主要用来进行年月日与周的换算。
    /// YCL 20080810
    /// </summary>
    public class TimeUtility
    {
       

        public static DateTime DefaultTime
        {
            get
            {
                return DateTime.Parse("1900/1/1");
            }
        }
        public static DateTime ChangQi
        {
            get
            {
                return DateTime.Parse("2900/1/1");
            }
        }

        public static DateTime GetBirthday(string pid)
        {
            int year = Convert.ToInt32( pid.Substring(6, 4));
            int month = Convert.ToInt32(pid.Substring(10, 2));
            int day = Convert.ToInt32(pid.Substring(12,2));
            return new DateTime(year, month, day);
        }

        #region 阳历处理区 
        public static DateTime GetBegin( DateTime dt)
        {
            return new DateTime(dt.Year, dt.Month, dt.Day);
        }
        public static DateTime GetEnd(DateTime dt)
        {
            return new DateTime(dt.Year, dt.Month, dt.Day,23,59,59);
        }
        /// <summary>
        /// 获取一个月的开始和结束时间
        /// </summary>
        /// <param name="year"></param>
        /// <param name="month"></param>
        /// <param name="begin"></param>
        /// <param name="end"></param>
        /// <param name="sp"></param>
        /// </summary>
        public static void GetBeginAndEnd(int year, int month, out DateTime begin, out DateTime end,string sp="-")
        {
            begin = Convert.ToDateTime(year + sp + month + sp + 1);
            switch (month)
            {
                case 1:
                case 3:
                case 5:
                case 7:
                case 8:
                case 10:
                case 12:
                    end = Convert.ToDateTime(year + sp + month + sp + 31 + " 23:00:00");
                    break;
                case 4:
                case 6:
                case 9:
                case 11:
                    end = Convert.ToDateTime(year + sp + month + sp + 30 + " 23:00:00");
                    break;
                case 2:
                    if (year % 4 == 0)
                        end = Convert.ToDateTime(year + sp + month + sp + 29 + " 23:00:00");
                    else
                        end = Convert.ToDateTime(year + sp + month + sp + 28 + " 23:00:00");
                    break;
                default:
                    end = end = Convert.ToDateTime(year + sp + month + sp + 30 + " 23:00:00");
                    break;
            }
        }
        /// <summary>
        /// 获取如：“2009-01-01”格式的日期字符串
        /// </summary>
        /// <param name="year">年份</param>
        /// <param name="month">月份</param>
        /// <param name="day">日期</param>
        /// <returns></returns>
        public static string Get8CTime(int year, int month, int day)
        {
            string m = month.ToString();
            string d = day.ToString();
            if (month <= 9)
                m = "0" + month.ToString();
            if (day <= 9)
                d = "0" + day.ToString();
            return year + "-" + m + "-" + d;
        }
        /// <summary>
        /// 获取如：“2009-01-01”格式的日期字符串
        /// </summary>
        /// <param name="time">日期</param>
        /// <returns>满足8个字符的日期</returns>
        public static string Get8CTime(DateTime time)
        {
            return Get8CTime(time.Year, time.Month, time.Day);
        }
        /// <summary>
        /// 设置指定日期所对应的开始和终止时分秒
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="b"></param>
        /// <param name="e"></param>
        public static void SetDayRange(DateTime dt, out DateTime b, out DateTime e)
        {
            int y = dt.Year;
            int m = dt.Month;
            int d = dt.Day;
            b = new DateTime(y, m, d, 0, 0, 0);
            e = new DateTime(y, m, d, 23, 59, 59);
        }
        /// <summary>
        /// 计算指定日期所在周的开始时间和终止时间
        /// </summary>
        /// <param name="time">指定的日期</param>
        /// <param name="begin">本周的开始时间</param>
        /// <param name="end">本周的截止时间</param>
        /// <returns>指定日期在当前月中是第几周(本月有几个周六，就有几周)</returns>
        public static int SetWeekRange(DateTime time, out DateTime begin, out DateTime end)
        {
            DayOfWeek w = time.DayOfWeek;            
            int a = (int)w;
            begin = time.AddDays(-a);
            if (a != 6)
            {
                end = time.AddDays(7 - a);
                end = DateTime.Parse(end.ToShortDateString()).AddMinutes(-1);//本周的最后一天至23时59分59秒
            }
            else
            {
                end = time;
                end = DateTime.Parse(end.ToShortDateString()).AddDays(1).AddSeconds(-1);

            }
            begin = DateTime.Parse(begin.ToShortDateString());//本周的第一天从0时0分0秒算起
            //
            int weeks = GetWeeks(time.Year, time.Month);
            DateTime st = GetFirstSaturday(time.Year, time.Month);
            st = DateTime.Parse(st.ToShortDateString()).AddDays(1).AddMinutes(-1);
            for (int i = 0; i < weeks; i++)
            {
                if (time <= st)
                {
                    return i + 1;
                }
                st = st.AddDays(7);
            }
            return 1;
        }
        /// <summary>
        /// 天数
        /// </summary>
        /// <param name="time"></param>
        /// <returns></returns>
        public static int GetWeekNum(DateTime time)
        {
            DateTime begin, end;
            return SetWeekRange(time, out begin, out end);
        }
        /// <summary>
        /// 计算指定年，月，周的开始时间和终止时间
        /// </summary>
        /// <param name="year">年份</param>
        /// <param name="month">月份</param>
        /// <param name="weeks">周</param>
        /// <param name="begin">计算得出的开始时间</param>
        /// <param name="end">计算得出的截止时间</param>
        public static void SetWeekRange(int year, int month, int weeks, out DateTime begin, out DateTime end)
        {
            if (weeks <= GetWeeks(year, month))
            {
                DateTime time = GetFirstSaturday(year, month);
                while (true)
                {
                    int i = SetWeekRange(time, out begin, out end);
                    if (i == weeks)
                        return;
                    time = time.AddDays(7);
                }
            }
            else
                throw new Exception("您指定的周不存在！");
        }

        /// <summary>
        /// 获取指定年的月共有几周(指定月份有几个周六就是有几周)
        /// </summary>
        /// <param name="year">年份</param>
        /// <param name="month">月份</param>
        /// <returns>共几周</returns>
        public static int GetWeeks(int year, int month)
        {
            DateTime time = GetFirstSaturday(year, month);
            int m = time.AddDays(28).Month;//加完4周，看月份
            if (m == month)
                return 5;
            else
                return 4;
        }
        /// <summary>
        /// 找到指定年月分的第一个周六
        /// </summary>
        /// <param name="year"></param>
        /// <param name="month"></param>
        /// <returns></returns>
        public static DateTime GetFirstSaturday(int year, int month)
        {
            //找到第一个周六，然后加7，看是否是本月，如果是再加7，直到不是即可。
            int days = DateTime.DaysInMonth(year, month);
            DateTime time = DateTime.Parse(year + "-" + month + "-1");
            //找到第一个星期六
            for (int i = 0; i < 7; i++)
            {
                if (time.DayOfWeek == DayOfWeek.Saturday)
                    break;
                else
                    time = time.AddDays(1);
            }
            return time;
        }
        /// <summary>
        /// 查询星期几
        /// </summary>
        /// <param name="day"></param>
        /// <returns></returns>
        public static string GetXingQi(DateTime day)
        {
            int beginSeg, endSeg;
            return GetXingQi(day, out beginSeg,out endSeg);
        }
        /// <summary>
        /// 获取指定日期的星期
        /// </summary>
        /// <param name="day">指定的日期</param>
        /// <param name="beginSeg">起始时间段</param>
        /// <param name="endSeg">终止时间段</param>
        /// <returns></returns>
        public static string GetXingQi(DateTime day, out int beginSeg, out int endSeg)
        {
            switch (day.DayOfWeek)
            {
                case DayOfWeek.Monday:
                    beginSeg = 6;
                    endSeg = 10;
                    return "一";
                case DayOfWeek.Tuesday:
                    beginSeg = 11;
                    endSeg = 15;
                    return "二";
                case DayOfWeek.Wednesday:
                    beginSeg = 16;
                    endSeg = 20;
                    return "三";
                case DayOfWeek.Thursday:
                    beginSeg = 21;
                    endSeg = 25;
                    return "四";
                case DayOfWeek.Friday:
                    beginSeg = 26;
                    endSeg = 30;
                    return "五";
                case DayOfWeek.Saturday:
                    beginSeg = 31;
                    endSeg = 35;
                    return "六";
                default:
                    beginSeg = 1;
                    endSeg = 5;
                    return "日";
            }
        }

        #endregion

        #region 农历部分
        //天干 
        private static string[] TianGan = { "甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸" };
        //地支 
        private static string[] DiZhi = { "子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥" };
        //十二生肖 
        private static string[] ShengXiao = { "鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊", "猴", "鸡", "狗", "猪" };
        //农历日期 
        private static string[] DayName = {"*","初一","初二","初三","初四","初五", 

"初六","初七","初八","初九","初十", 

"十一","十二","十三","十四","十五", 

"十六","十七","十八","十九","二十", 

"廿一","廿二","廿三","廿四","廿五", 

"廿六","廿七","廿八","廿九","三十"};

        //农历月份 
        private static string[] MonthName = { "*", "正", "二", "三", "四", "五", "六", "七", "八", "九", "十", "十一", "腊" };

        //公历月计数天 
        private static int[] MonthAdd = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };

        //农历数据 
        private static int[] LunarData = {2635,333387,1701,1748,267701,694,2391,133423,1175,396438 

,3402,3749,331177,1453,694,201326,2350,465197,3221,3402 

,400202,2901,1386,267611,605,2349,137515,2709,464533,1738 

,2901,330421,1242,2651,199255,1323,529706,3733,1706,398762 

,2741,1206,267438,2647,1318,204070,3477,461653,1386,2413 

,330077,1197,2637,268877,3365,531109,2900,2922,398042,2395 

,1179,267415,2635,661067,1701,1748,398772,2742,2391,330031 

,1175,1611,200010,3749,527717,1452,2742,332397,2350,3222 

,268949,3402,3493,133973,1386,464219,605,2349,334123,2709 

,2890,267946,2773,592565,1210,2651,395863,1323,2707,265877};
        /// <summary>
        ///  获取对应日期的农历,并带回天干地支生肖 
        /// </summary>
        /// <param name="dtDay">公历日期</param>
        /// <param name="td">天干地支</param>
        /// <param name="sx">生肖</param>
        /// <returns>农历日期</returns>
        public static string GetLunarCalendar(DateTime dtDay, out string td, out string sx)
        {
            string sYear = dtDay.Year.ToString();
            string sMonth = dtDay.Month.ToString();
            string sDay = dtDay.Day.ToString();
            int year;
            int month;
            int day;
            try
            {
                year = int.Parse(sYear);
                month = int.Parse(sMonth);
                day = int.Parse(sDay);
            }
            catch
            {
                year = DateTime.Now.Year;
                month = DateTime.Now.Month;
                day = DateTime.Now.Day;
            }



            int nTheDate;
            int nIsEnd;
            int k, m, n, nBit, i;
            string calendar = string.Empty;
            //计算到初始时间1921年2月8日的天数：1921-2-8(正月初一) 
            nTheDate = (year - 1921) * 365 + (year - 1921) / 4 + day + MonthAdd[month - 1] - 38;
            if ((year % 4 == 0) && (month > 2))
                nTheDate += 1;
            //计算天干，地支，月，日 
            nIsEnd = 0;
            m = 0;
            k = 0;
            n = 0;
            while (nIsEnd != 1)
            {
                if (LunarData[m] < 4095)
                    k = 11;
                else
                    k = 12;
                n = k;

                while (n >= 0)
                {
                    //获取LunarData[m]的第n个二进制位的值 
                    nBit = LunarData[m];
                    for (i = 1; i < n + 1; i++)
                        nBit = nBit / 2;
                    nBit = nBit % 2;
                    if (nTheDate <= (29 + nBit))
                    {
                        nIsEnd = 1;
                        break;
                    }
                    nTheDate = nTheDate - 29 - nBit;
                    n = n - 1;
                }

                if (nIsEnd == 1)
                    break;
                m = m + 1;
            }

            year = 1921 + m;
            month = k - n + 1;
            day = nTheDate;
            // return year + "-" + month + "-" + day;

            // #region 格式化日期显示为三月廿四 

            if (k == 12)
            {
                if (month == LunarData[m] / 65536 + 1)
                    month = 1 - month;
                else if (month > LunarData[m] / 65536 + 1)
                    month = month - 1;
            }
            //生肖 
            sx = ShengXiao[(year - 4) % 60 % 12].ToString() + "年 ";

            // //天干地支
            td = TianGan[(year - 4) % 60 % 10].ToString() + DiZhi[(year - 4) % 60 % 12].ToString();


            //农历月 
            if (month < 1)
                calendar += "闰" + MonthName[-1 * month].ToString() + "月";
            else
                calendar += MonthName[month].ToString() + "月";
            //农历日 
            calendar += DayName[day].ToString() + "日";
            return calendar;

            // #endregion 

        }
        /// <summary> 
        /// 获取对应日期的农历 
        /// </summary> 
        /// <param name="dtDay">公历日期</param> 
        /// <returns>农历日期</returns> 
        public static string GetLunarCalendar(DateTime dtDay)
        {
            string sYear = dtDay.Year.ToString();
            string sMonth = dtDay.Month.ToString();
            string sDay = dtDay.Day.ToString();
            int year;
            int month;
            int day;
            try
            {
                year = int.Parse(sYear);
                month = int.Parse(sMonth);
                day = int.Parse(sDay);
            }
            catch
            {
                year = DateTime.Now.Year;
                month = DateTime.Now.Month;
                day = DateTime.Now.Day;
            }
            int nTheDate;
            int nIsEnd;
            int k, m, n, nBit, i;
            string calendar = string.Empty;
            //计算到初始时间1921年2月8日的天数：1921-2-8(正月初一) 
            nTheDate = (year - 1921) * 365 + (year - 1921) / 4 + day + MonthAdd[month - 1] - 38;
            if ((year % 4 == 0) && (month > 2))
                nTheDate += 1;
            //计算天干，地支，月，日 
            nIsEnd = 0;
            m = 0;
            k = 0;
            n = 0;
            while (nIsEnd != 1)
            {
                if (LunarData[m] < 4095)
                    k = 11;
                else
                    k = 12;
                n = k;

                while (n >= 0)
                {
                    //获取LunarData[m]的第n个二进制位的值 
                    nBit = LunarData[m];
                    for (i = 1; i < n + 1; i++)
                        nBit = nBit / 2;
                    nBit = nBit % 2;
                    if (nTheDate <= (29 + nBit))
                    {
                        nIsEnd = 1;
                        break;
                    }
                    nTheDate = nTheDate - 29 - nBit;
                    n = n - 1;
                }

                if (nIsEnd == 1)
                    break;
                m = m + 1;
            }

            year = 1921 + m;
            month = k - n + 1;
            day = nTheDate;

            if (k == 12)
            {
                if (month == LunarData[m] / 65536 + 1)
                    month = 1 - month;
                else if (month > LunarData[m] / 65536 + 1)
                    month = month - 1;
            }
            //农历月 
            if (month < 1)
                calendar += "闰" + MonthName[-1 * month].ToString() + "月";
            else
                calendar += MonthName[month].ToString() + "月";
            //农历日 
            calendar += DayName[day].ToString() + "日";
            return calendar;
        }
        #endregion

        #region 节气部分——支持1901-2050
        static string[] SolarTerms = 
            { 
                "小寒", "大寒", "立春", "雨水", 
                "惊蛰", "春分", "清明", "谷雨", 
                "立夏", "小满", "芒种", "夏至", 
                "小暑", "大暑", "立秋", "处暑", 
                "白露", "秋分", "寒露", "霜降", 
                "立冬", "小雪", "大雪", "冬至"};
        //数组gLanarHoliDay存放每年的二十四节气对应的阳历日期 
        //每年的二十四节气对应的阳历日期几乎固定，平均分布于十二个月中 
        // 1月 2月 3月 4月 5月 6月 
        //小寒 大寒 立春 雨水 惊蛰 春分 清明 谷雨 立夏 小满 芒种 夏至 
        // 7月 8月 9月 10月 11月 12月 
        //小暑 大暑 立秋 处暑 白露 秋分 寒露 霜降 立冬 小雪 大雪 冬至 
        //********************************************************************************* 
        // 节气无任何确定规律,所以只好存表,要节省空间,所以. 
        //**********************************************************************************} 
        //数据格式说明: 
        //如1901年的节气为 
        // 1月 2月 3月 4月 5月 6月 7月 8月 9月 10月 11月 12月 
        // 6, 21, 4, 19, 6, 21, 5, 21, 6,22, 6,22, 8, 23, 8, 24, 8, 24, 8, 24, 8, 23, 8, 22 
        // 9, 6, 11,4, 9, 6, 10,6, 9,7, 9,7, 7, 8, 7, 9, 7, 9, 7, 9, 7, 8, 7, 15 
        //上面第一行数据为每月节气对应日期,15减去每月第一个节气,每月第二个节气减去15得第二行 
        // 这样每月两个节气对应数据都小于16,每月用一个字节存放,高位存放第一个节气数据,低位存放 
        //第二个节气的数据,可得下表 
        static byte[] gLunarHolDay =
            { 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x79, 0x69, 0x78, 0x77, //1901 
                0x96, 0xA4, 0x96, 0x96, 0x97, 0x87, 0x79, 0x79, 0x79, 0x69, 0x78, 0x78, //1902 
                0x96, 0xA5, 0x87, 0x96, 0x87, 0x87, 0x79, 0x69, 0x69, 0x69, 0x78, 0x78, //1903 
                0x86, 0xA5, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x79, 0x78, 0x87, //1904 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x79, 0x69, 0x78, 0x77, //1905 
                0x96, 0xA4, 0x96, 0x96, 0x97, 0x97, 0x79, 0x79, 0x79, 0x69, 0x78, 0x78, //1906 
                0x96, 0xA5, 0x87, 0x96, 0x87, 0x87, 0x79, 0x69, 0x69, 0x69, 0x78, 0x78, //1907 
                0x86, 0xA5, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x69, 0x78, 0x87, //1908 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x79, 0x69, 0x78, 0x77, //1909 
                0x96, 0xA4, 0x96, 0x96, 0x97, 0x97, 0x79, 0x79, 0x79, 0x69, 0x78, 0x78, //1910 
                0x96, 0xA5, 0x87, 0x96, 0x87, 0x87, 0x79, 0x69, 0x69, 0x69, 0x78, 0x78, //1911 
                0x86, 0xA5, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x69, 0x78, 0x87, //1912 
                0x95, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x79, 0x69, 0x78, 0x77, //1913 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x79, 0x79, 0x79, 0x69, 0x78, 0x78, //1914 
                0x96, 0xA5, 0x97, 0x96, 0x97, 0x87, 0x79, 0x79, 0x69, 0x69, 0x78, 0x78, //1915 
                0x96, 0xA5, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x79, 0x77, 0x87, //1916 
                0x95, 0xB4, 0x96, 0xA6, 0x96, 0x97, 0x78, 0x79, 0x78, 0x69, 0x78, 0x87, //1917 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x79, 0x79, 0x79, 0x69, 0x78, 0x77, //1918 
                0x96, 0xA5, 0x97, 0x96, 0x97, 0x87, 0x79, 0x79, 0x69, 0x69, 0x78, 0x78, //1919 
                0x96, 0xA5, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x79, 0x77, 0x87, //1920            

                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x78, 0x79, 0x78, 0x69, 0x78, 0x87, //1921 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x79, 0x79, 0x79, 0x69, 0x78, 0x77, //1922 
                0x96, 0xA4, 0x96, 0x96, 0x97, 0x87, 0x79, 0x79, 0x69, 0x69, 0x78, 0x78, //1923 
                0x96, 0xA5, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x79, 0x77, 0x87, //1924 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x78, 0x79, 0x78, 0x69, 0x78, 0x87, //1925 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x79, 0x69, 0x78, 0x77, //1926 
                0x96, 0xA4, 0x96, 0x96, 0x97, 0x87, 0x79, 0x79, 0x79, 0x69, 0x78, 0x78, //1927 
                0x96, 0xA5, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x78, 0x78, 0x78, 0x87, 0x87, //1928 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x79, 0x77, 0x87, //1929 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x79, 0x69, 0x78, 0x77, //1930 
                0x96, 0xA4, 0x96, 0x96, 0x97, 0x87, 0x79, 0x79, 0x79, 0x69, 0x78, 0x78, //1931 
                0x96, 0xA5, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x78, 0x78, 0x78, 0x87, 0x87, //1932 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x69, 0x78, 0x87, //1933 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x79, 0x69, 0x78, 0x77, //1934 
                0x96, 0xA4, 0x96, 0x96, 0x97, 0x97, 0x79, 0x79, 0x79, 0x69, 0x78, 0x78, //1935 
                0x96, 0xA5, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x78, 0x78, 0x78, 0x87, 0x87, //1936 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x69, 0x78, 0x87, //1937 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x79, 0x69, 0x78, 0x77, //1938 
                0x96, 0xA4, 0x96, 0x96, 0x97, 0x97, 0x79, 0x79, 0x79, 0x69, 0x78, 0x78, //1939 
                0x96, 0xA5, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x78, 0x78, 0x78, 0x87, 0x87, //1940 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x69, 0x78, 0x87, //1941 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x79, 0x69, 0x78, 0x77, //1942 
                0x96, 0xA4, 0x96, 0x96, 0x97, 0x97, 0x79, 0x79, 0x79, 0x69, 0x78, 0x78, //1943 
                0x96, 0xA5, 0x96, 0xA5, 0xA6, 0x96, 0x88, 0x78, 0x78, 0x78, 0x87, 0x87, //1944 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x79, 0x77, 0x87, //1945 
                0x95, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x78, 0x69, 0x78, 0x77, //1946 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x79, 0x79, 0x79, 0x69, 0x78, 0x78, //1947 
                0x96, 0xA5, 0xA6, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x78, 0x78, 0x87, 0x87, //1948 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x79, 0x78, 0x79, 0x77, 0x87, //1949 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x78, 0x79, 0x78, 0x69, 0x78, 0x77, //1950 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x79, 0x79, 0x79, 0x69, 0x78, 0x78, //1951 
                0x96, 0xA5, 0xA6, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x78, 0x78, 0x87, 0x87, //1952 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x79, 0x77, 0x87, //1953 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x78, 0x79, 0x78, 0x68, 0x78, 0x87, //1954 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x79, 0x69, 0x78, 0x77, //1955 
                0x96, 0xA5, 0xA5, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x78, 0x78, 0x87, 0x87, //1956 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x79, 0x77, 0x87, //1957 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x69, 0x78, 0x87, //1958 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x79, 0x69, 0x78, 0x77, //1959 
                0x96, 0xA4, 0xA5, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //1960 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x78, 0x78, 0x78, 0x87, 0x87, //1961 
                0x96, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x69, 0x78, 0x87, //1962 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x79, 0x69, 0x78, 0x77, //1963 
                0x96, 0xA4, 0xA5, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //1964 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x78, 0x78, 0x78, 0x87, 0x87, //1965 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x69, 0x78, 0x87, //1966 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x79, 0x69, 0x78, 0x77, //1967 
                0x96, 0xA4, 0xA5, 0xA5, 0xA6, 0xA6, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //1968 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x78, 0x78, 0x78, 0x87, 0x87, //1969 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x69, 0x78, 0x87, //1970 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x79, 0x69, 0x78, 0x77, //1971 
                0x96, 0xA4, 0xA5, 0xA5, 0xA6, 0xA6, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //1972 
                0xA5, 0xB5, 0x96, 0xA5, 0xA6, 0x96, 0x88, 0x78, 0x78, 0x78, 0x87, 0x87, //1973 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x69, 0x78, 0x87, //1974 
                0x96, 0xB4, 0x96, 0xA6, 0x97, 0x97, 0x78, 0x79, 0x78, 0x69, 0x78, 0x77, //1975 
                0x96, 0xA4, 0xA5, 0xB5, 0xA6, 0xA6, 0x88, 0x89, 0x88, 0x78, 0x87, 0x87, //1976 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x88, 0x78, 0x78, 0x87, 0x87, //1977 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x79, 0x78, 0x87, //1978 
                0x96, 0xB4, 0x96, 0xA6, 0x96, 0x97, 0x78, 0x79, 0x78, 0x69, 0x78, 0x77, //1979 
                0x96, 0xA4, 0xA5, 0xB5, 0xA6, 0xA6, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //1980 
                0xA5, 0xB4, 0x96, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x78, 0x78, 0x77, 0x87, //1981 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x79, 0x77, 0x87, //1982 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x78, 0x79, 0x78, 0x69, 0x78, 0x77, //1983 
                0x96, 0xB4, 0xA5, 0xB5, 0xA6, 0xA6, 0x87, 0x88, 0x88, 0x78, 0x87, 0x87, //1984 
                0xA5, 0xB4, 0xA6, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x78, 0x78, 0x87, 0x87, //1985 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x79, 0x77, 0x87, //1986 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x79, 0x78, 0x69, 0x78, 0x87, //1987 
                0x96, 0xB4, 0xA5, 0xB5, 0xA6, 0xA6, 0x87, 0x88, 0x88, 0x78, 0x87, 0x86, //1988 
                0xA5, 0xB4, 0xA5, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //1989 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x78, 0x78, 0x79, 0x77, 0x87, //1990 
                0x95, 0xB4, 0x96, 0xA5, 0x86, 0x97, 0x88, 0x78, 0x78, 0x69, 0x78, 0x87, //1991 
                0x96, 0xB4, 0xA5, 0xB5, 0xA6, 0xA6, 0x87, 0x88, 0x88, 0x78, 0x87, 0x86, //1992 
                0xA5, 0xB3, 0xA5, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //1993 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x78, 0x78, 0x78, 0x87, 0x87, //1994 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x76, 0x78, 0x69, 0x78, 0x87, //1995 
                0x96, 0xB4, 0xA5, 0xB5, 0xA6, 0xA6, 0x87, 0x88, 0x88, 0x78, 0x87, 0x86, //1996 
                0xA5, 0xB3, 0xA5, 0xA5, 0xA6, 0xA6, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //1997 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x78, 0x78, 0x78, 0x87, 0x87, //1998 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x69, 0x78, 0x87, //1999 
                0x96, 0xB4, 0xA5, 0xB5, 0xA6, 0xA6, 0x87, 0x88, 0x88, 0x78, 0x87, 0x86, //2000 
                0xA5, 0xB3, 0xA5, 0xA5, 0xA6, 0xA6, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //2001 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x78, 0x78, 0x78, 0x87, 0x87, //2002 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x69, 0x78, 0x87, //2003 
                0x96, 0xB4, 0xA5, 0xB5, 0xA6, 0xA6, 0x87, 0x88, 0x88, 0x78, 0x87, 0x86, //2004 
                0xA5, 0xB3, 0xA5, 0xA5, 0xA6, 0xA6, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //2005 
                0xA5, 0xB4, 0x96, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x78, 0x78, 0x87, 0x87, //2006 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x69, 0x78, 0x87, //2007 
                0x96, 0xB4, 0xA5, 0xB5, 0xA6, 0xA6, 0x87, 0x88, 0x87, 0x78, 0x87, 0x86, //2008 
                0xA5, 0xB3, 0xA5, 0xB5, 0xA6, 0xA6, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //2009 
                0xA5, 0xB4, 0x96, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x78, 0x78, 0x87, 0x87, //2010 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x79, 0x78, 0x87, //2011 
                0x96, 0xB4, 0xA5, 0xB5, 0xA5, 0xA6, 0x87, 0x88, 0x87, 0x78, 0x87, 0x86, //2012 
                0xA5, 0xB3, 0xA5, 0xB5, 0xA6, 0xA6, 0x87, 0x88, 0x88, 0x78, 0x87, 0x87, //2013 
                0xA5, 0xB4, 0x96, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x78, 0x78, 0x87, 0x87, //2014 
                0x95, 0xB4, 0x96, 0xA5, 0x96, 0x97, 0x88, 0x78, 0x78, 0x79, 0x77, 0x87, //2015 
                0x95, 0xB4, 0xA5, 0xB4, 0xA5, 0xA6, 0x87, 0x88, 0x87, 0x78, 0x87, 0x86, //2016 
                0xA5, 0xC3, 0xA5, 0xB5, 0xA6, 0xA6, 0x87, 0x88, 0x88, 0x78, 0x87, 0x87, //2017 
                0xA5, 0xB4, 0xA6, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x78, 0x78, 0x87, 0x87, //2018 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x78, 0x78, 0x79, 0x77, 0x87, //2019 
                0x95, 0xB4, 0xA5, 0xB4, 0xA5, 0xA6, 0x97, 0x87, 0x87, 0x78, 0x87, 0x86, //2020 
                0xA5, 0xC3, 0xA5, 0xB5, 0xA6, 0xA6, 0x87, 0x88, 0x88, 0x78, 0x87, 0x86, //2021 
                0xA5, 0xB4, 0xA5, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //2022 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x78, 0x78, 0x79, 0x77, 0x87, //2023 
                0x95, 0xB4, 0xA5, 0xB4, 0xA5, 0xA6, 0x97, 0x87, 0x87, 0x78, 0x87, 0x96, //2024 
                0xA5, 0xC3, 0xA5, 0xB5, 0xA6, 0xA6, 0x87, 0x88, 0x88, 0x78, 0x87, 0x86, //2025 
                0xA5, 0xB3, 0xA5, 0xA5, 0xA6, 0xA6, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //2026 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x78, 0x78, 0x78, 0x87, 0x87, //2027 
                0x95, 0xB4, 0xA5, 0xB4, 0xA5, 0xA6, 0x97, 0x87, 0x87, 0x78, 0x87, 0x96, //2028 
                0xA5, 0xC3, 0xA5, 0xB5, 0xA6, 0xA6, 0x87, 0x88, 0x88, 0x78, 0x87, 0x86, //2029 
                0xA5, 0xB3, 0xA5, 0xA5, 0xA6, 0xA6, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //2030 
                0xA5, 0xB4, 0x96, 0xA5, 0x96, 0x96, 0x88, 0x78, 0x78, 0x78, 0x87, 0x87, //2031 
                0x95, 0xB4, 0xA5, 0xB4, 0xA5, 0xA6, 0x97, 0x87, 0x87, 0x78, 0x87, 0x96, //2032 
                0xA5, 0xC3, 0xA5, 0xB5, 0xA6, 0xA6, 0x88, 0x88, 0x88, 0x78, 0x87, 0x86, //2033 
                0xA5, 0xB3, 0xA5, 0xA5, 0xA6, 0xA6, 0x88, 0x78, 0x88, 0x78, 0x87, 0x87, //2034 
                0xA5, 0xB4, 0x96, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x78, 0x78, 0x87, 0x87, //2035 
                0x95, 0xB4, 0xA5, 0xB4, 0xA5, 0xA6, 0x97, 0x87, 0x87, 0x78, 0x87, 0x96, //2036 
                0xA5, 0xC3, 0xA5, 0xB5, 0xA6, 0xA6, 0x87, 0x88, 0x88, 0x78, 0x87, 0x86, //2037 
                0xA5, 0xB3, 0xA5, 0xA5, 0xA6, 0xA6, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //2038 
                0xA5, 0xB4, 0x96, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x78, 0x78, 0x87, 0x87, //2039 
                0x95, 0xB4, 0xA5, 0xB4, 0xA5, 0xA6, 0x97, 0x87, 0x87, 0x78, 0x87, 0x96, //2040 
                0xA5, 0xC3, 0xA5, 0xB5, 0xA5, 0xA6, 0x87, 0x88, 0x87, 0x78, 0x87, 0x86, //2041 
                0xA5, 0xB3, 0xA5, 0xB5, 0xA6, 0xA6, 0x88, 0x88, 0x88, 0x78, 0x87, 0x87, //2042 
                0xA5, 0xB4, 0x96, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x78, 0x78, 0x87, 0x87, //2043 
                0x95, 0xB4, 0xA5, 0xB4, 0xA5, 0xA6, 0x97, 0x87, 0x87, 0x88, 0x87, 0x96, //2044 
                0xA5, 0xC3, 0xA5, 0xB4, 0xA5, 0xA6, 0x87, 0x88, 0x87, 0x78, 0x87, 0x86, //2045 
                0xA5, 0xB3, 0xA5, 0xB5, 0xA6, 0xA6, 0x87, 0x88, 0x88, 0x78, 0x87, 0x87, //2046 
                0xA5, 0xB4, 0x96, 0xA5, 0xA6, 0x96, 0x88, 0x88, 0x78, 0x78, 0x87, 0x87, //2047 
                0x95, 0xB4, 0xA5, 0xB4, 0xA5, 0xA5, 0x97, 0x87, 0x87, 0x88, 0x86, 0x96, //2048 
                0xA4, 0xC3, 0xA5, 0xA5, 0xA5, 0xA6, 0x97, 0x87, 0x87, 0x78, 0x87, 0x86, //2049 
                0xA5, 0xC3, 0xA5, 0xB5, 0xA6, 0xA6, 0x87, 0x88, 0x78, 0x78, 0x87, 0x87}; //2050 

        /// <summary>
        /// 获取指定时间的节气 
        /// </summary>
        /// <param name="time">公历日期</param>
        /// <returns>节气名称</returns>
        public static string GetSolarTerm(DateTime time)
        {
            byte Flag;
            int Day, iYear, iMonth, iDay;
            iYear = time.Year;
            if ((iYear < 1901) || (iYear > 2050))
            { return ""; };
            iMonth = time.Month;
            iDay = time.Day;
            Flag = gLunarHolDay[(iYear - 1901) * 12 + iMonth - 1];
            if (iDay < 15)
            { Day = 15 - ((Flag >> 4) & 0x0f); }
            else
            { Day = (Flag & 0x0f) + 15; };
            if (iDay == Day)
            {
                if (iDay > 15)
                {
                    return SolarTerms[(iMonth - 1) * 2 + 1];
                }
                else
                {
                    return SolarTerms[(iMonth - 1) * 2];
                }
            }
            else
            { return ""; };
        }
        #endregion

        #region 星座部分
        private static string[] ConstellationName = 
            { 
                "白羊座", "金牛座", "双子座", 
                "巨蟹座", "狮子座", "处女座", 
                "天秤座", "天蝎座", "射手座", 
                "摩羯座", "水瓶座", "双鱼座"};
        //计算指定日期的星座序号 
        static int GetConstellation(DateTime time)
        {
            int Y, M, D;
            Y = time.Year;
            M = time.Month;
            D = time.Day;
            Y = M * 100 + D;
            if (((Y >= 321) && (Y <= 419))) { return 0; }
            else if ((Y >= 420) && (Y <= 520)) { return 1; }
            else if ((Y >= 521) && (Y <= 620)) { return 2; }
            else if ((Y >= 621) && (Y <= 722)) { return 3; }
            else if ((Y >= 723) && (Y <= 822)) { return 4; }
            else if ((Y >= 823) && (Y <= 922)) { return 5; }
            else if ((Y >= 923) && (Y <= 1022)) { return 6; }
            else if ((Y >= 1023) && (Y <= 1121)) { return 7; }
            else if ((Y >= 1122) && (Y <= 1221)) { return 8; }
            else if ((Y >= 1222) || (Y <= 119)) { return 9; }
            else if ((Y >= 120) && (Y <= 218)) { return 10; }
            else if ((Y >= 219) && (Y <= 320)) { return 11; }
            else { return -1; };
        }
        /// <summary>
        /// 计算指定日期的星座名称 
        /// </summary>
        /// <param name="time">公历日期</param>
        /// <returns>星座名称</returns>
        public static string GetConstellationName(DateTime time)
        {
            int Constellation;
            Constellation = GetConstellation(time);
            if ((Constellation >= 0) && (Constellation <= 11))
            { return ConstellationName[Constellation]; }
            else
            { return ""; };
        }

        #endregion
    }
}

16.WebHelper帮助类

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;
using HttpCookie = System.Web.HttpCookie;
using Newtonsoft.Json;
using RestSharp;//Nuget使用104.5.0版本


namespace Utilities
{
    /// <summary>
    /// 
    /// </summary>
    public class WebHelper
    {
        //浏览器列表
        private static readonly string[] Browserlist = { "ie", "chrome", "mozilla", "netscape", "firefox", "opera", "konqueror" };
        //搜索引擎列表
        private static readonly string[] Searchenginelist = { "baidu", "google", "360", "sogou", "bing", "msn", "sohu", "soso", "sina", "163", "yahoo", "jikeu" };
        //meta正则表达式
        private static readonly Regex Metaregex = new Regex("<meta([^<]*)charset=([^<]*)[\"']", RegexOptions.IgnoreCase | RegexOptions.Multiline);

        #region 编码

        /// <summary>
        /// HTML解码
        /// </summary>
        /// <returns></returns>
        public static string HtmlDecode(string s)
        {
            return HttpUtility.HtmlDecode(s);
        }

        /// <summary>
        /// HTML编码
        /// </summary>
        /// <returns></returns>
        public static string HtmlEncode(string s)
        {
            return HttpUtility.HtmlEncode(s);
        }

        /// <summary>
        /// URL解码
        /// </summary>
        /// <returns></returns>
        public static string UrlDecode(string s)
        {
            return HttpUtility.UrlDecode(s);
        }

        /// <summary>
        /// URL编码
        /// </summary>
        /// <returns></returns>
        public static string UrlEncode(string s)
        {
            return HttpUtility.UrlEncode(s);
        }

        #endregion

        #region Cookie

        /// <summary>
        /// 删除指定名称的Cookie
        /// </summary>
        /// <param name="name">Cookie名称</param>
        public static void DeleteCookie(string name)
        {
            HttpCookie cookie = new HttpCookie(name);
            cookie.Expires = DateTime.Now.AddYears(-1);
            HttpContext.Current.Response.AppendCookie(cookie);
        }

        /// <summary>
        /// 获得指定名称的Cookie值
        /// </summary>
        /// <param name="name">Cookie名称</param>
        /// <returns></returns>
        public static string GetCookie(string name)
        {
            HttpCookie cookie = HttpContext.Current.Request.Cookies[name];
            if (cookie != null)
                return cookie.Value;

            return string.Empty;
        }

        /// <summary>
        /// 获得指定名称的Cookie中特定键的值
        /// </summary>
        /// <param name="name">Cookie名称</param>
        /// <param name="key">键</param>
        /// <returns></returns>
        public static string GetCookie(string name, string key)
        {
            HttpCookie cookie = HttpContext.Current.Request.Cookies[name];
            if (cookie != null && cookie.HasKeys)
            {
                string v = cookie[key];
                if (v != null)
                    return v;
            }

            return string.Empty;
        }

        /// <summary>
        /// 设置指定名称的Cookie的值
        /// </summary>
        /// <param name="name">Cookie名称</param>
        /// <param name="value">值</param>
        public static void SetCookie(string name, string value)
        {
            HttpCookie cookie = HttpContext.Current.Request.Cookies[name];
            if (cookie != null)
                cookie.Value = value;
            else
                cookie = new HttpCookie(name, value);

            HttpContext.Current.Response.AppendCookie(cookie);
        }

        /// <summary>
        /// 设置指定名称的Cookie的值
        /// </summary>
        /// <param name="name">Cookie名称</param>
        /// <param name="value">值</param>
        /// <param name="expires">过期时间</param>
        public static void SetCookie(string name, string value, double expires)
        {
            HttpCookie cookie = HttpContext.Current.Request.Cookies[name];
            if (cookie == null)
                cookie = new HttpCookie(name);

            cookie.Value = value;
            cookie.Expires = DateTime.Now.AddMinutes(expires);
            HttpContext.Current.Response.AppendCookie(cookie);
        }

        /// <summary>
        /// 设置指定名称的Cookie特定键的值
        /// </summary>
        /// <param name="name">Cookie名称</param>
        /// <param name="key">键</param>
        /// <param name="value">值</param>
        public static void SetCookie(string name, string key, string value)
        {
            HttpCookie cookie = HttpContext.Current.Request.Cookies[name];
            if (cookie == null)
                cookie = new HttpCookie(name);

            cookie[key] = value;
            HttpContext.Current.Response.AppendCookie(cookie);
        }

        /// <summary>
        /// 设置指定名称的Cookie特定键的值
        /// </summary>
        /// <param name="name">Cookie名称</param>
        /// <param name="key">键</param>
        /// <param name="value">值</param>
        /// <param name="expires">过期时间</param>
        public static void SetCookie(string name, string key, string value, double expires)
        {
            HttpCookie cookie = HttpContext.Current.Request.Cookies[name];
            if (cookie == null)
                cookie = new HttpCookie(name);

            cookie[key] = value;
            cookie.Expires = DateTime.Now.AddMinutes(expires);
            HttpContext.Current.Response.AppendCookie(cookie);
        }

        #endregion

        #region 客户端信息

        /// <summary>
        /// 是否是get请求
        /// </summary>
        /// <returns></returns>
        public static bool IsGet()
        {
            return HttpContext.Current.Request.HttpMethod == "GET";
        }

        /// <summary>
        /// 是否是post请求
        /// </summary>
        /// <returns></returns>
        public static bool IsPost()
        {
            return HttpContext.Current.Request.HttpMethod == "POST";
        }

        /// <summary>
        /// 是否是Ajax请求
        /// </summary>
        /// <returns></returns>
        public static bool IsAjax()
        {
            return HttpContext.Current.Request.Headers["X-Requested-With"] == "XMLHttpRequest";
        }

        /// <summary>
        /// 获得查询字符串中的值
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static string GetQueryString(string key, string defaultValue)
        {
            string value = HttpContext.Current.Request.QueryString[key];
            return !string.IsNullOrWhiteSpace(value) ? value : defaultValue;
        }

        /// <summary>
        /// 获得查询字符串中的值
        /// </summary>
        /// <param name="key">键</param>
        /// <returns></returns>
        public static string GetQueryString(string key)
        {
            return GetQueryString(key, "");
        }

        /// <summary>
        /// 获得查询字符串中的值
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static int GetQueryInt(string key, int defaultValue)
        {
            return TypeHelper.StringToInt(HttpContext.Current.Request.QueryString[key], defaultValue);
        }

        /// <summary>
        /// 获得查询字符串中的值
        /// </summary>
        /// <param name="key">键</param>
        /// <returns></returns>
        public static int GetQueryInt(string key)
        {
            return GetQueryInt(key, 0);
        }

        /// <summary>
        /// 获得表单中的值
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static string GetFormString(string key, string defaultValue)
        {
            string value = HttpContext.Current.Request.Form[key];
            if (!string.IsNullOrWhiteSpace(value))
                return value;
            else
                return defaultValue;
        }

        /// <summary>
        /// 获得表单中的值
        /// </summary>
        /// <param name="key">键</param>
        /// <returns></returns>
        public static string GetFormString(string key)
        {
            return GetFormString(key, "");
        }

        /// <summary>
        /// 获得表单中的值
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static int GetFormInt(string key, int defaultValue)
        {
            return TypeHelper.StringToInt(HttpContext.Current.Request.Form[key], defaultValue);
        }

        /// <summary>
        /// 获得表单中的值
        /// </summary>
        /// <param name="key">键</param>
        /// <returns></returns>
        public static int GetFormInt(string key)
        {
            return GetFormInt(key, 0);
        }

        /// <summary>
        /// 获得请求中的值
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static string GetRequestString(string key, string defaultValue)
        {
            if (HttpContext.Current.Request.Form[key] != null)
                return GetFormString(key, defaultValue);
            else
                return GetQueryString(key, defaultValue);
        }

        /// <summary>
        /// 获得请求中的值
        /// </summary>
        /// <param name="key">键</param>
        /// <returns></returns>
        public static string GetRequestString(string key)
        {
            if (HttpContext.Current.Request.Form[key] != null)
                return GetFormString(key);
            else
                return GetQueryString(key);
        }

        /// <summary>
        /// 获得请求中的值
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static int GetRequestInt(string key, int defaultValue)
        {
            if (HttpContext.Current.Request.Form[key] != null)
                return GetFormInt(key, defaultValue);
            else
                return GetQueryInt(key, defaultValue);
        }

        /// <summary>
        /// 获得请求中的值
        /// </summary>
        /// <param name="key">键</param>
        /// <returns></returns>
        public static int GetRequestInt(string key)
        {
            if (HttpContext.Current.Request.Form[key] != null)
                return GetFormInt(key);
            else
                return GetQueryInt(key);
        }

        /// <summary>
        /// 获得上次请求的url
        /// </summary>
        /// <returns></returns>
        public static string GetUrlReferrer()
        {
            Uri uri = HttpContext.Current.Request.UrlReferrer;
            if (uri == null)
                return string.Empty;

            return uri.ToString();
        }

        /// <summary>
        /// 获得请求的主机部分
        /// </summary>
        /// <returns></returns>
        public static string GetHost()
        {
            return HttpContext.Current.Request.Url.Host;
        }

        /// <summary>
        /// 获得请求的url
        /// </summary>
        /// <returns></returns>
        public static string GetUrl()
        {
            return HttpContext.Current.Request.Url.ToString();
        }

        /// <summary>
        /// 获得请求的原始url
        /// </summary>
        /// <returns></returns>
        public static string GetRawUrl()
        {
            return HttpContext.Current.Request.RawUrl;
        }

        /// <summary>
        /// 获得请求的ip
        /// </summary>
        /// <returns></returns>
        public static string GetIP()
        {
            string ip = string.Empty;
            if (HttpContext.Current.Request.ServerVariables["HTTP_VIA"] != null)
                ip = HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"].ToString();
            else
                ip = HttpContext.Current.Request.ServerVariables["REMOTE_ADDR"].ToString();

            if (string.IsNullOrEmpty(ip) || ! StringHelper.RegexIP.IsMatch(ip))
                ip = "127.0.0.1";
            return ip;
        }

        /// <summary>
        /// 获得请求的浏览器类型
        /// </summary>
        /// <returns></returns>
        public static string GetBrowserType()
        {
            string type = HttpContext.Current.Request.Browser.Type;
            if (string.IsNullOrEmpty(type) || type == "unknown")
                return "未知";
            return type.ToLower();
        }

        /// <summary>
        /// 获得请求的浏览器名称
        /// </summary>
        /// <returns></returns>
        public static string GetBrowserName()
        {
            string name = HttpContext.Current.Request.Browser.Browser;
            if (string.IsNullOrEmpty(name) || name == "unknown")
                return "未知";

            return name.ToLower();
        }

        /// <summary>
        /// 获得请求的浏览器版本
        /// </summary>
        /// <returns></returns>
        public static string GetBrowserVersion()
        {
            string version = HttpContext.Current.Request.Browser.Version;
            if (string.IsNullOrEmpty(version) || version == "unknown")
                return "未知";

            return version;
        }

        /// <summary>
        /// 获得请求客户端的操作系统类型
        /// </summary>
        /// <returns></returns>
        public static string GetOSType()
        {
            string type = "未知";
            string userAgent = HttpContext.Current.Request.UserAgent;

            if (userAgent.Contains("NT 6.1"))
            {
                type = "Windows 7";
            }
            else if (userAgent.Contains("NT 5.1"))
            {
                type = "Windows XP";
            }
            else if (userAgent.Contains("NT 6.2"))
            {
                type = "Windows 8";
            }
            else if (userAgent.Contains("android"))
            {
                type = "Android";
            }
            else if (userAgent.Contains("iphone"))
            {
                type = "IPhone";
            }
            else if (userAgent.Contains("Mac"))
            {
                type = "Mac";
            }
            else if (userAgent.Contains("NT 6.0"))
            {
                type = "Windows Vista";
            }
            else if (userAgent.Contains("NT 5.2"))
            {
                type = "Windows 2003";
            }
            else if (userAgent.Contains("NT 5.0"))
            {
                type = "Windows 2000";
            }
            else if (userAgent.Contains("98"))
            {
                type = "Windows 98";
            }
            else if (userAgent.Contains("95"))
            {
                type = "Windows 95";
            }
            else if (userAgent.Contains("Me"))
            {
                type = "Windows Me";
            }
            else if (userAgent.Contains("NT 4"))
            {
                type = "Windows NT4";
            }
            else if (userAgent.Contains("Unix"))
            {
                type = "UNIX";
            }
            else if (userAgent.Contains("Linux"))
            {
                type = "Linux";
            }
            else if (userAgent.Contains("SunOS"))
            {
                type = "SunOS";
            }

            return type;
        }

        /// <summary>
        /// 获得请求客户端的操作系统名称
        /// </summary>
        /// <returns></returns>
        public static string GetOSName()
        {
            string name = HttpContext.Current.Request.Browser.Platform;
            if (string.IsNullOrEmpty(name))
                return "未知";

            return name;
        }

        /// <summary>
        /// 判断是否是浏览器请求
        /// </summary>
        /// <returns></returns>
        public static bool IsBrowser()
        {
            string name = GetBrowserName();
            foreach (string item in Browserlist)
            {
                if (name.Contains(item))
                    return true;
            }
            return false;
        }

        /// <summary>
        /// 是否是移动设备请求
        /// </summary>
        /// <returns></returns>
        public static bool IsMobile()
        {
            if (HttpContext.Current.Request.Browser.IsMobileDevice)
                return true;

            bool isTablet = false;
            if (bool.TryParse(HttpContext.Current.Request.Browser["IsTablet"], out isTablet) && isTablet)
                return true;

            return false;
        }

        /// <summary>
        /// 判断是否是搜索引擎爬虫请求
        /// </summary>
        /// <returns></returns>
        public static bool IsCrawler()
        {
            bool result = HttpContext.Current.Request.Browser.Crawler;
            if (!result)
            {
                string referrer = GetUrlReferrer();
                if (referrer.Length > 0)
                {
                    foreach (string item in Searchenginelist)
                    {
                        if (referrer.Contains(item))
                            return true;
                    }
                }
            }
            return result;
        }

        #endregion

        #region Http

        /// <summary>
        /// 获得参数列表
        /// </summary>
        /// <param name="data">数据</param>
        /// <returns></returns>
        public static NameValueCollection GetParmList(string data)
        {
            NameValueCollection parmList = new NameValueCollection(StringComparer.OrdinalIgnoreCase);
            if (!string.IsNullOrEmpty(data))
            {
                int length = data.Length;
                for (int i = 0; i < length; i++)
                {
                    int startIndex = i;
                    int endIndex = -1;
                    while (i < length)
                    {
                        char c = data[i];
                        if (c == '=')
                        {
                            if (endIndex < 0)
                                endIndex = i;
                        }
                        else if (c == '&')
                        {
                            break;
                        }
                        i++;
                    }
                    string key;
                    string value;
                    if (endIndex >= 0)
                    {
                        key = data.Substring(startIndex, endIndex - startIndex);
                        value = data.Substring(endIndex + 1, (i - endIndex) - 1);
                    }
                    else
                    {
                        key = data.Substring(startIndex, i - startIndex);
                        value = string.Empty;
                    }
                    parmList[key] = value;
                    if ((i == (length - 1)) && (data[i] == '&'))
                        parmList[key] = string.Empty;
                }
            }
            return parmList;
        }

        /// <summary>
        /// 获得http请求数据
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="postData">发送数据</param>
        /// <returns></returns>
        public static string GetRequestData(SortedDictionary<string, string> postData, string url)
        {
            return GetRequestData(url, Method.POST, postData);
        }

        /// <summary>
        /// 获得http请求数据
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="method">请求方式</param>
        /// <param name="postData">发送数据</param>
        /// <returns></returns>
        public static string GetRequestData(string url, Method method, SortedDictionary<string, string> postData)
        {
            return GetRequestData(url, method, postData, Encoding.UTF8);
        }

        /// <summary>
        /// 获得http请求数据
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="method">请求方式</param>
        /// <param name="postData">发送数据</param>
        /// <param name="encoding">编码</param>
        /// <returns></returns>
        public static string GetRequestData(string url, Method method, SortedDictionary<string, string> postData, Encoding encoding)
        {
            return GetRequestData(url, method, postData, encoding, 20000);
        }

        /// <summary>
        /// 获得http请求数据
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="method">请求方式</param>
        /// <param name="postData">发送数据</param>
        /// <param name="encoding">编码</param>
        /// <param name="timeout">超时值</param>
        /// <returns></returns>
        public static string GetRequestData(string url, Method method, SortedDictionary<string, string> postData, Encoding encoding, int timeout)
        {

            if (!(url.Contains("http://") || url.Contains("https://")))
                url = "http://" + url;

            var client = new RestClient(url);
            var request = new RestRequest(method) { Timeout = timeout };

            //将参数 加入请求
            if (postData != null && postData.Any())
            {
                foreach (var item in postData.Keys)
                {
                    request.AddParameter(item, postData[item], ParameterType.GetOrPost);
                }
            }
            //执行
            var response = client.Execute(request);

            return response.StatusCode == HttpStatusCode.OK ? response.Content : "";


            //if (!(url.Contains("http://") || url.Contains("https://")))
            //    url = "http://" + url;

            ////var request = (HttpWebRequest)WebRequest.Create(url);
            //request.Method = method.Trim().ToLower();
            //request.Timeout = timeout;
            //request.AllowAutoRedirect = true;
            //request.ContentType = "text/html";
            //request.Accept = "text/html, application/xhtml+xml, */*,zh-CN";
            ////request.UserAgent = "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)";
            //request.CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore);

            //try
            //{
            //    if (!string.IsNullOrEmpty(postData) && request.Method == "post")
            //    {
            //        byte[] buffer = encoding.GetBytes(postData);
            //        request.ContentLength = buffer.Length;
            //        request.GetRequestStream().Write(buffer, 0, buffer.Length);
            //    }

            //    using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
            //    {
            //        if (encoding == null)
            //        {
            //            MemoryStream stream = new MemoryStream();
            //            if (response.ContentEncoding != null && response.ContentEncoding.Equals("gzip", StringComparison.InvariantCultureIgnoreCase))
            //                new GZipStream(response.GetResponseStream(), CompressionMode.Decompress).CopyTo(stream, 10240);
            //            else
            //                response.GetResponseStream().CopyTo(stream, 10240);

            //            byte[] RawResponse = stream.ToArray();
            //            string temp = Encoding.Default.GetString(RawResponse, 0, RawResponse.Length);
            //            Match meta = Metaregex.Match(temp);
            //            string charter = (meta.Groups.Count > 2) ? meta.Groups[2].Value : string.Empty;
            //            charter = charter.Replace("\"", string.Empty).Replace("'", string.Empty).Replace(";", string.Empty);
            //            if (charter.Length > 0)
            //            {
            //                charter = charter.ToLower().Replace("iso-8859-1", "gbk");
            //                encoding = Encoding.GetEncoding(charter);
            //            }
            //            else
            //            {
            //                if (response.CharacterSet.ToLower().Trim() == "iso-8859-1")
            //                {
            //                    encoding = Encoding.GetEncoding("gbk");
            //                }
            //                else
            //                {
            //                    if (string.IsNullOrEmpty(response.CharacterSet.Trim()))
            //                    {
            //                        encoding = Encoding.UTF8;
            //                    }
            //                    else
            //                    {
            //                        encoding = Encoding.GetEncoding(response.CharacterSet);
            //                    }
            //                }
            //            }
            //            return encoding.GetString(RawResponse);
            //        }
            //        StreamReader reader = null;
            //        if (response.ContentEncoding != null && response.ContentEncoding.Equals("gzip", StringComparison.InvariantCultureIgnoreCase))
            //        {
            //            using (reader = new StreamReader(new GZipStream(response.GetResponseStream(), CompressionMode.Decompress), encoding))
            //            {
            //                return reader.ReadToEnd();
            //            }
            //        }
            //        using (reader = new StreamReader(response.GetResponseStream(), encoding))
            //        {
            //            try
            //            {
            //                return reader.ReadToEnd();
            //            }
            //            catch
            //            {
            //                return "close";
            //            }

            //        }
            //    }

            //}
            //catch
            //{
            //    return "error";
            //}
        }

        #endregion

        #region .NET

        /// <summary>
        /// 获得当前应用程序的信任级别
        /// </summary>
        /// <returns></returns>
        public static AspNetHostingPermissionLevel GetTrustLevel()
        {
            AspNetHostingPermissionLevel trustLevel = AspNetHostingPermissionLevel.None;
            //权限列表
            AspNetHostingPermissionLevel[] levelList = new AspNetHostingPermissionLevel[] {
                                                                                            AspNetHostingPermissionLevel.Unrestricted,
                                                                                            AspNetHostingPermissionLevel.High,
                                                                                            AspNetHostingPermissionLevel.Medium,
                                                                                            AspNetHostingPermissionLevel.Low,
                                                                                            AspNetHostingPermissionLevel.Minimal
                                                                                            };

            foreach (AspNetHostingPermissionLevel level in levelList)
            {
                try
                {
                    //通过执行Demand方法检测是否抛出SecurityException异常来设置当前应用程序的信任级别
                    new AspNetHostingPermission(level).Demand();
                    trustLevel = level;
                    break;
                }
                catch//(SecurityException ex)
                {
                    continue;
                }
            }
            return trustLevel;
        }

        /// <summary>
        /// 修改web.config文件
        /// </summary>
        /// <returns></returns>
        private static bool TryWriteWebConfig()
        {
            try
            {
                File.SetLastWriteTimeUtc(IoHelper.GetMapPath("~/web.config"), DateTime.UtcNow);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 修改global.asax文件
        /// </summary>
        /// <returns></returns>
        private static bool TryWriteGlobalAsax()
        {
            try
            {
                File.SetLastWriteTimeUtc(IoHelper.GetMapPath("~/global.asax"), DateTime.UtcNow);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 重启应用程序
        /// </summary>
        public static void RestartAppDomain()
        {
            if (GetTrustLevel() > AspNetHostingPermissionLevel.Medium)//如果当前信任级别大于Medium，则通过卸载应用程序域的方式重启
            {
                HttpRuntime.UnloadAppDomain();
                TryWriteGlobalAsax();
            }
            else//通过修改web.config方式重启应用程序
            {
                bool success = TryWriteWebConfig();
                if (!success)
                {
                    throw new Exception("修改web.config文件重启应用程序");
                }

                success = TryWriteGlobalAsax();
                if (!success)
                {
                    throw new Exception("修改global.asax文件重启应用程序");
                }
            }

        }

        #endregion

    }
    /// <summary>
    /// 类型帮助类
    /// </summary>
    public class TypeHelper
    {
        #region 转Int

        /// <summary>
        /// 将string类型转换成int类型
        /// </summary>
        /// <param name="s">目标字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static int StringToInt(string s, int defaultValue)
        {
            if (!string.IsNullOrWhiteSpace(s))
            {
                int result;
                if (int.TryParse(s, out result))
                    return result;
            }

            return defaultValue;
        }

        /// <summary>
        /// 将string类型转换成int类型
        /// </summary>
        /// <param name="s">目标字符串</param>
        /// <returns></returns>
        public static int StringToInt(string s)
        {
            return StringToInt(s, 0);
        }

        /// <summary>
        /// 将object类型转换成int类型
        /// </summary>
        /// <param name="o">目标对象</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static int ObjectToInt(object o, int defaultValue)
        {
            if (o != null)
                return StringToInt(o.ToString(), defaultValue);

            return defaultValue;
        }

        /// <summary>
        /// 将object类型转换成int类型
        /// </summary>
        /// <param name="o">目标对象</param>
        /// <returns></returns>
        public static int ObjectToInt(object o)
        {
            return ObjectToInt(o, 0);
        }

        #endregion

        #region 转Long

        /// <summary>
        /// 将string类型转换成int类型
        /// </summary>
        /// <param name="s">目标字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static long StringToLong(string s, long defaultValue)
        {
            if (!string.IsNullOrWhiteSpace(s))
            {
                long result;
                if (long.TryParse(s, out result))
                    return result;
            }

            return defaultValue;
        }

        /// <summary>
        /// 将string类型转换成int类型
        /// </summary>
        /// <param name="s">目标字符串</param>
        /// <returns></returns>
        public static long StringToLong(string s)
        {
            return StringToLong(s, 0);
        }

        /// <summary>
        /// 将object类型转换成int类型
        /// </summary>
        /// <param name="o">目标对象</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static long ObjectToLong(object o, long defaultValue)
        {
            if (o != null)
                return StringToLong(o.ToString(), defaultValue);

            return defaultValue;
        }

        /// <summary>
        /// 将object类型转换成int类型
        /// </summary>
        /// <param name="o">目标对象</param>
        /// <returns></returns>
        public static long ObjectToLong(object o)
        {
            return ObjectToLong(o, 0);
        }

        #endregion

        #region 转Bool

        /// <summary>
        /// 将string类型转换成bool类型
        /// </summary>
        /// <param name="s">目标字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static bool StringToBool(string s, bool defaultValue)
        {
            if (s == "false")
                return false;
            else if (s == "true")
                return true;

            return defaultValue;
        }

        /// <summary>
        /// 将string类型转换成bool类型
        /// </summary>
        /// <param name="s">目标字符串</param>
        /// <returns></returns>
        public static bool ToBool(string s)
        {
            return StringToBool(s, false);
        }

        /// <summary>
        /// 将object类型转换成bool类型
        /// </summary>
        /// <param name="o">目标对象</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static bool ObjectToBool(object o, bool defaultValue)
        {
            if (o != null)
                return StringToBool(o.ToString(), defaultValue);

            return defaultValue;
        }

        /// <summary>
        /// 将object类型转换成bool类型
        /// </summary>
        /// <param name="o">目标对象</param>
        /// <returns></returns>
        public static bool ObjectToBool(object o)
        {
            return ObjectToBool(o, false);
        }

        #endregion

        #region 转DateTime

        /// <summary>
        /// 将string类型转换成datetime类型
        /// </summary>
        /// <param name="s">目标字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static DateTime StringToDateTime(string s, DateTime defaultValue)
        {
            if (!string.IsNullOrWhiteSpace(s))
            {
                DateTime result;
                if (DateTime.TryParse(s, out result))
                    return result;
            }
            return defaultValue;
        }

        /// <summary>
        /// 将string类型转换成datetime类型
        /// </summary>
        /// <param name="s">目标字符串</param>
        /// <returns></returns>
        public static DateTime StringToDateTime(string s)
        {
            return StringToDateTime(s, DateTime.Now);
        }

        /// <summary>
        /// 将object类型转换成datetime类型
        /// </summary>
        /// <param name="o">目标对象</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static DateTime ObjectToDateTime(object o, DateTime defaultValue)
        {
            if (o != null)
                return StringToDateTime(o.ToString(), defaultValue);

            return defaultValue;
        }

        /// <summary>
        /// 将object类型转换成datetime类型
        /// </summary>
        /// <param name="o">目标对象</param>
        /// <returns></returns>
        public static DateTime ObjectToDateTime(object o)
        {
            return ObjectToDateTime(o, DateTime.Now);
        }

        #endregion

        #region 转Decimal

        /// <summary>
        /// 将string类型转换成decimal类型
        /// </summary>
        /// <param name="s">目标字符串</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static decimal StringToDecimal(string s, decimal defaultValue)
        {
            if (!string.IsNullOrWhiteSpace(s))
            {
                decimal result;
                if (decimal.TryParse(s, out result))
                    return result;
            }

            return defaultValue;
        }

        /// <summary>
        /// 将string类型转换成decimal类型
        /// </summary>
        /// <param name="s">目标字符串</param>
        /// <returns></returns>
        public static decimal StringToDecimal(string s)
        {
            return StringToDecimal(s, 0m);
        }

        /// <summary>
        /// 将object类型转换成decimal类型
        /// </summary>
        /// <param name="o">目标对象</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static decimal ObjectToDecimal(object o, decimal defaultValue)
        {
            if (o != null)
                return StringToDecimal(o.ToString(), defaultValue);

            return defaultValue;
        }

        /// <summary>
        /// 将object类型转换成decimal类型
        /// </summary>
        /// <param name="o">目标对象</param>
        /// <returns></returns>
        public static decimal ObjectToDecimal(object o)
        {
            return ObjectToDecimal(o, 0m);
        }

        #endregion
    }
}

17.文件操作帮助类

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

namespace CrackPlateform.Models
{
    public class FileHelper
    {
        static ReaderWriterLockSlim LogWriteLock = new ReaderWriterLockSlim();
        public static string ReadFile(string Path, Encoding encode)
        {
            Dictionary<int, string> dic = new Dictionary<int, string>();
            StringBuilder sb = new StringBuilder();
            try
            {
                LogWriteLock.EnterReadLock();
                if (!System.IO.File.Exists(Path))
                {
                    sb = null;
                }
                else
                {
                    StreamReader f2 = new StreamReader(Path, encode);
                    String line;
                    int i = 0;
                    while ((line = f2.ReadLine()) != null)//按行读取 line为每行的数据
                    {
                        i++;
                        dic.Add(i, line);
                    }
                    foreach (var item in dic)
                    {
                        sb.Append(item.Value + "\n");
                    }
                    //s = f2.ReadToEnd();
                    f2.Close();
                    f2.Dispose();
                }
            }
            catch (Exception ex)
            {

            }
            finally
            {
                LogWriteLock.ExitReadLock();
            }
            return sb?.ToString();
        }
        /// <summary>
        /// 文件base64解码
        /// </summary>
        /// <param name="base64Str">文件base64编码</param>
        /// <param name="outPath">生成文件路径</param>
        public static void Base64ToOriFile(string base64Str, string outPath)
        {
            var contents = Convert.FromBase64String(base64Str);
            using (var fs = new FileStream(outPath, FileMode.Create, FileAccess.Write))
            {
                fs.Write(contents, 0, contents.Length);
                fs.Flush();
            }
        }
        /// <summary>
        /// 文件转为base64编码
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public static string FileToBase64Str(string filePath)
        {
            string base64Str = string.Empty;
            try
            {
                using (FileStream filestream = new FileStream(filePath, FileMode.Open))
                {
                    byte[] bt = new byte[filestream.Length];

                    //调用read读取方法
                    filestream.Read(bt, 0, bt.Length);
                    base64Str = Convert.ToBase64String(bt);
                    filestream.Close();
                }

                return base64Str;
            }
            catch (Exception ex)
            {
                return base64Str;
            }
        }

        /// <summary>
        /// 将字典转换成name=value这种字符串格式
        /// </summary>
        /// <param name="dic"></param>
        /// <returns></returns>
        public static string DictionaryToStr(IDictionary<string, string> dic)
        {
            string strTemp = string.Empty;
            foreach (KeyValuePair<string, string> item in dic)
            {
                if (!string.IsNullOrEmpty(item.Key) && !string.IsNullOrEmpty(item.Value))
                {
                    strTemp += item.Key + ":" + item.Value + "\r\n";
                }
            }
            return strTemp;
        }
    }
}

18.Redis帮助类

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

namespace CrackPlateform.Models
{
    public class RedisManager : IDisposable
    {
        public RedisManager() : this("127.0.0.1:6379")
        {
        }
        public RedisManager(string ipAndPort)
        {
            var csredis = new CSRedis.CSRedisClient(ipAndPort + ",poolsize=100,preheat=true,writeBuffer=102400,tryit=3");
            RedisHelper.Initialization(csredis);
        }
        private readonly object locker = new object();
        public CSRedisClient Instance
        {
            get { return RedisHelper.Instance; }
        }
        public void Dispose()
        {
            lock (locker)
            {
                RedisHelper.Instance.Dispose();
            }
        }
    }
}

19.RSAHelper帮助类

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace CrackPlateform.Models
{
    public class RSAHelper
    {
        private readonly RSA _privateKeyRsaProvider;
        private readonly RSA _publicKeyRsaProvider;
        private readonly HashAlgorithmName _hashAlgorithmName;
        private readonly Encoding _encoding;

        /// <summary>
        /// 实例化RSAHelper
        /// </summary>
        /// <param name="rsaType">加密算法类型 RSA SHA1;RSA2 SHA256 密钥长度至少为2048</param>
        /// <param name="encoding">编码类型</param>
        /// <param name="privateKey">私钥</param>
        /// <param name="publicKey">公钥</param>
        public RSAHelper(RSAType rsaType, Encoding encoding, string privateKey, string publicKey = null)
        {
            _encoding = encoding;
            if (!string.IsNullOrEmpty(privateKey))
            {
                _privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey);
            }

            if (!string.IsNullOrEmpty(publicKey))
            {
                _publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey);
            }

            _hashAlgorithmName = rsaType == RSAType.RSA ? HashAlgorithmName.SHA1 : HashAlgorithmName.SHA256;
        }

        #region 使用私钥签名

        /// <summary>
        /// 使用私钥签名
        /// </summary>
        /// <param name="data">原始数据</param>
        /// <returns></returns>
        public string Sign(string data)
        {
            byte[] dataBytes = _encoding.GetBytes(data);

            var signatureBytes = _privateKeyRsaProvider.SignData(dataBytes, _hashAlgorithmName, RSASignaturePadding.Pkcs1);

            return Convert.ToBase64String(signatureBytes);
        }

        #endregion

        #region 使用公钥验证签名

        /// <summary>
        /// 使用公钥验证签名
        /// </summary>
        /// <param name="data">原始数据</param>
        /// <param name="sign">签名</param>
        /// <returns></returns>
        public bool Verify(string data, string sign)
        {
            byte[] dataBytes = _encoding.GetBytes(data);
            byte[] signBytes = Convert.FromBase64String(sign);

            var verify = _publicKeyRsaProvider.VerifyData(dataBytes, signBytes, _hashAlgorithmName, RSASignaturePadding.Pkcs1);

            return verify;
        }

        #endregion

        #region 解密

        public string Decrypt(string cipherText)
        {
            if (_privateKeyRsaProvider == null)
            {
                throw new Exception("_privateKeyRsaProvider is null");
            }
            return Encoding.UTF8.GetString(_privateKeyRsaProvider.Decrypt(Convert.FromBase64String(cipherText), RSAEncryptionPadding.Pkcs1));
        }

        #endregion

        #region 加密

        public string Encrypt(string text)
        {
            if (_publicKeyRsaProvider == null)
            {
                throw new Exception("_publicKeyRsaProvider is null");
            }
            return Convert.ToBase64String(_publicKeyRsaProvider.Encrypt(Encoding.UTF8.GetBytes(text), RSAEncryptionPadding.Pkcs1));
        }

        #endregion

        #region 使用私钥创建RSA实例

        public RSA CreateRsaProviderFromPrivateKey(string privateKey)
        {
            var privateKeyBits = Convert.FromBase64String(privateKey);

            var rsa = RSA.Create();
            var rsaParameters = new RSAParameters();

            using (BinaryReader binr = new BinaryReader(new MemoryStream(privateKeyBits)))
            {
                byte bt = 0;
                ushort twobytes = 0;
                twobytes = binr.ReadUInt16();
                if (twobytes == 0x8130)
                    binr.ReadByte();
                else if (twobytes == 0x8230)
                    binr.ReadInt16();
                else
                    throw new Exception("Unexpected value read binr.ReadUInt16()");

                twobytes = binr.ReadUInt16();
                if (twobytes != 0x0102)
                    throw new Exception("Unexpected version");

                bt = binr.ReadByte();
                if (bt != 0x00)
                    throw new Exception("Unexpected value read binr.ReadByte()");

                rsaParameters.Modulus = binr.ReadBytes(GetIntegerSize(binr));
                rsaParameters.Exponent = binr.ReadBytes(GetIntegerSize(binr));
                rsaParameters.D = binr.ReadBytes(GetIntegerSize(binr));
                rsaParameters.P = binr.ReadBytes(GetIntegerSize(binr));
                rsaParameters.Q = binr.ReadBytes(GetIntegerSize(binr));
                rsaParameters.DP = binr.ReadBytes(GetIntegerSize(binr));
                rsaParameters.DQ = binr.ReadBytes(GetIntegerSize(binr));
                rsaParameters.InverseQ = binr.ReadBytes(GetIntegerSize(binr));
            }

            rsa.ImportParameters(rsaParameters);
            return rsa;
        }

        #endregion

        #region 使用公钥创建RSA实例

        public RSA CreateRsaProviderFromPublicKey(string publicKeyString)
        {
            // encoded OID sequence for  PKCS #1 rsaEncryption szOID_RSA_RSA = "1.2.840.113549.1.1.1"
            byte[] seqOid = { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 };
            byte[] seq = new byte[15];

            var x509Key = Convert.FromBase64String(publicKeyString);

            // ---------  Set up stream to read the asn.1 encoded SubjectPublicKeyInfo blob  ------
            using (MemoryStream mem = new MemoryStream(x509Key))
            {
                using (BinaryReader binr = new BinaryReader(mem))  //wrap Memory Stream with BinaryReader for easy reading
                {
                    byte bt = 0;
                    ushort twobytes = 0;

                    twobytes = binr.ReadUInt16();
                    if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
                        binr.ReadByte();    //advance 1 byte
                    else if (twobytes == 0x8230)
                        binr.ReadInt16();   //advance 2 bytes
                    else
                        return null;

                    seq = binr.ReadBytes(15);       //read the Sequence OID
                    if (!CompareBytearrays(seq, seqOid))    //make sure Sequence for OID is correct
                        return null;

                    twobytes = binr.ReadUInt16();
                    if (twobytes == 0x8103) //data read as little endian order (actual data order for Bit String is 03 81)
                        binr.ReadByte();    //advance 1 byte
                    else if (twobytes == 0x8203)
                        binr.ReadInt16();   //advance 2 bytes
                    else
                        return null;

                    bt = binr.ReadByte();
                    if (bt != 0x00)     //expect null byte next
                        return null;

                    twobytes = binr.ReadUInt16();
                    if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
                        binr.ReadByte();    //advance 1 byte
                    else if (twobytes == 0x8230)
                        binr.ReadInt16();   //advance 2 bytes
                    else
                        return null;

                    twobytes = binr.ReadUInt16();
                    byte lowbyte = 0x00;
                    byte highbyte = 0x00;

                    if (twobytes == 0x8102) //data read as little endian order (actual data order for Integer is 02 81)
                        lowbyte = binr.ReadByte();  // read next bytes which is bytes in modulus
                    else if (twobytes == 0x8202)
                    {
                        highbyte = binr.ReadByte(); //advance 2 bytes
                        lowbyte = binr.ReadByte();
                    }
                    else
                        return null;
                    byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };   //reverse byte order since asn.1 key uses big endian order
                    int modsize = BitConverter.ToInt32(modint, 0);

                    int firstbyte = binr.PeekChar();
                    if (firstbyte == 0x00)
                    {   //if first byte (highest order) of modulus is zero, don't include it
                        binr.ReadByte();    //skip this null byte
                        modsize -= 1;   //reduce modulus buffer size by 1
                    }

                    byte[] modulus = binr.ReadBytes(modsize);   //read the modulus bytes

                    if (binr.ReadByte() != 0x02)            //expect an Integer for the exponent data
                        return null;
                    int expbytes = (int)binr.ReadByte();        // should only need one byte for actual exponent data (for all useful values)
                    byte[] exponent = binr.ReadBytes(expbytes);

                    // ------- create RSACryptoServiceProvider instance and initialize with public key -----
                    var rsa = RSA.Create();
                    RSAParameters rsaKeyInfo = new RSAParameters
                    {
                        Modulus = modulus,
                        Exponent = exponent
                    };
                    rsa.ImportParameters(rsaKeyInfo);

                    return rsa;
                }

            }
        }

        #endregion

        #region 导入密钥算法

        private int GetIntegerSize(BinaryReader binr)
        {
            byte bt = 0;
            int count = 0;
            bt = binr.ReadByte();
            if (bt != 0x02)
                return 0;
            bt = binr.ReadByte();

            if (bt == 0x81)
                count = binr.ReadByte();
            else
            if (bt == 0x82)
            {
                var highbyte = binr.ReadByte();
                var lowbyte = binr.ReadByte();
                byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };
                count = BitConverter.ToInt32(modint, 0);
            }
            else
            {
                count = bt;
            }

            while (binr.ReadByte() == 0x00)
            {
                count -= 1;
            }
            binr.BaseStream.Seek(-1, SeekOrigin.Current);
            return count;
        }

        private bool CompareBytearrays(byte[] a, byte[] b)
        {
            if (a.Length != b.Length)
                return false;
            int i = 0;
            foreach (byte c in a)
            {
                if (c != b[i])
                    return false;
                i++;
            }
            return true;
        }

        #endregion

    }

    /// <summary>
    /// RSA算法类型
    /// </summary>
    public enum RSAType
    {
        /// <summary>
        /// SHA1
        /// </summary>
        RSA = 0,
        /// <summary>
        /// RSA2 密钥长度至少为2048
        /// SHA256
        /// </summary>
        RSA2
    }
}

20.SmtpHelper发送邮件

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

namespace CrackPlateform.Models
{
    public class SmtpHelper
    {
        // <summary>
        /// SMTP发送邮件
        /// </summary>
        /// <param name="fromEmail">发送邮件地址</param>
        /// <param name="toEmail">收件箱</param>
        /// <param name="subject">邮箱主题</param>

        /// <param name="contentAttachment"></param>
        /// <param name="fromEmailPwd">发送邮件密码</param>

        /// <returns></returns>


        public static bool SendMailBySMTP(string fromEmail, string toEmail, string subject, string fromEmailPwd)
        {
            bool rr = true;
            System.Net.Mail.MailMessage mail = new System.Net.Mail.MailMessage(fromEmail, toEmail);

            mail.SubjectEncoding = Encoding.UTF8;
            mail.Subject = subject;
            mail.IsBodyHtml = true; //是否允许内容为 HTML 格式
            mail.BodyEncoding = Encoding.UTF8;
            string emailContent = "邮件内容";

            mail.Body = emailContent;

          //  mail.Attachments.Add(contentAttachment); //添加一个附件

            SmtpClient smtp = new SmtpClient("smtp.qiye.163.com");//serviceFlag > 14 ? "smtp.qiye.163.com" : 
            smtp.Port = 25;
            smtp.EnableSsl = true;
            smtp.Credentials = new NetworkCredential(fromEmail, fromEmailPwd); //SMTP 验证
                                                                               //smtp.DeliveryMethod = SmtpDeliveryMethod.PickupDirectoryFromIis;
            smtp.DeliveryMethod = SmtpDeliveryMethod.Network;


            smtp.Send(mail);



            return rr;
        }
    }
}