public static class ControlCharacter
{
    /// <summary>
    /// 空字符
    /// </summary>
    public const string NUL = "\u0000";
    /// <summary>
    /// 标题开始
    /// </summary>
    public const string SOH = "\u0001";
    /// <summary>
    /// 正文开始
    /// </summary>
    public const string STX = "\u0002";
    /// <summary>
    /// 正文结束
    /// </summary>
    public const string ETX = "\u0003";
    /// <summary>
    /// 传输结束
    /// </summary>
    public const string EOT = "\u0004";
    /// <summary>
    /// 请求
    /// </summary>
    public const string ENQ = "\u0005";
    /// <summary>
    /// 收到通知
    /// </summary>
    public const string ACK = "\u0006";
    /// <summary>
    /// 响铃
    /// </summary>
    public const string BEL = "\u0007";
    /// <summary>
    /// 退格
    /// </summary>
    public const string BS = "\u0008";
    /// <summary>
    /// 水平制表符
    /// </summary>
    public const string HT = "\u0009";
    /// <summary>
    /// 换行键
    /// </summary>
    public const string LF = "\u000a";
    /// <summary>
    /// 垂直制表符
    /// </summary>
    public const string VT = "\u000b";
    /// <summary>
    /// 换页键
    /// </summary>
    public const string FF = "\u000c";
    /// <summary>
    /// 回车键
    /// </summary>
    public const string CR = "\u000d";
    /// <summary>
    /// 不用切换
    /// </summary>
    public const string SO = "\u000e";
    /// <summary>
    /// 启用切换
    /// </summary>
    public const string SI = "\u000f";
    /// <summary>
    /// 数据链路转义
    /// </summary>
    public const string DLE = "\u0010";
    /// <summary>
    /// 设备控制1
    /// </summary>
    public const string DC1 = "\u0011";
    /// <summary>
    /// 设备控制2
    /// </summary>
    public const string DC2 = "\u0012";
    /// <summary>
    /// 设备控制3
    /// </summary>
    public const string DC3 = "\u0013";
    /// <summary>
    /// 设备控制4
    /// </summary>
    public const string DC4 = "\u0014";
    /// <summary>
    /// 拒绝接收
    /// </summary>
    public const string NAK = "\u0015";
    /// <summary>
    /// 同步空闲
    /// </summary>
    public const string SYN = "\u0016";
    /// <summary>
    /// 结束传输块
    /// </summary>
    public const string ETB = "\u0017";
    /// <summary>
    /// 取消
    /// </summary>
    public const string CAN = "\u0018";
    /// <summary>
    /// 媒介结束
    /// </summary>
    public const string EM = "\u0019";
    /// <summary>
    /// 代替
    /// </summary>
    public const string SUB = "\u001a";
    /// <summary>
    /// 换码(溢出)
    /// </summary>
    public const string ESC = "\u001b";
    /// <summary>
    /// 文件分隔符
    /// </summary>
    public const string FS = "\u001c";
    /// <summary>
    /// 分组符
    /// </summary>
    public const string GS = "\u001d";
    /// <summary>
    /// 记录分隔符
    /// </summary>
    public const string RS = "\u001e";
    /// <summary>
    /// 单元分隔符
    /// </summary>
    public const string US = "\u001f";
    /// <summary>
    /// 删除
    /// </summary>
    public const string DEL = "\u007f";
}

using System;
using System.IO.Ports;

namespace SerialPortTestConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] ports = SerialPort.GetPortNames();
            foreach (string port in ports)
            {
                Console.WriteLine(port);
            }
            Console.ReadKey();
        }
    }
}

using System;
using System.IO.Ports;
using System.Text;

namespace SerialPortTestConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            //注意：以下为串口初始化常用的属性，赋值为默认值，如果没有赋值属性默认也是这些值
            SerialPort port = new SerialPort()
            {
                PortName = "COM1",//端口号
                BaudRate = 9600,//波特率
                DataBits = 8,//数据位
                Parity = Parity.None,//校验位
                StopBits = StopBits.One,//停止位
                Encoding = Encoding.ASCII,//文本转换编码
                WriteBufferSize = 2048,//输出缓存
                ReadBufferSize = 4096,//输入缓存
                WriteTimeout = -1,//写超时
                ReadTimeout = -1,//读超时
                RtsEnable = false,//RTS信号：建议启用
                DtrEnable = false,//DTR信号：建议启用
            };

            //数据接收事件 输出到控制台
            port.DataReceived += new SerialDataReceivedEventHandler((sender, e) =>
            {
                while (port.BytesToRead > 0)
                {
                    int length = port.BytesToRead;
                    byte[] buffer = new byte[length];
                    port.Read(buffer, 0, length);
                    Console.WriteLine(port.Encoding.GetString(buffer));
                }
            });

            //打开串口
            if (!port.IsOpen)
            {
                try
                {
                    port.Open();
                    Console.WriteLine($"串口打开成功：{port.PortName}");
                }
                catch (Exception exception)
                {
                    Console.WriteLine($"打开串口失败：{exception.Message}");
                }
            }


            if (port.IsOpen)
            {
                //输入串口发送内容
                string input = "";
                do
                {
                    Console.WriteLine("请输入要发送的内容：");
                    input = Console.ReadLine();
                    if (!string.IsNullOrEmpty(input))
                    {
                        byte[] buffer = port.Encoding.GetBytes(input);
                        port.Write(buffer, 0, buffer.Length);
                    }
                } while (!string.IsNullOrEmpty(input));

                //关闭串口释放资源
                port.Close();
            }
            port.Dispose();
        }
    }
}

/// <summary>
/// 字符串拓展方法
/// </summary>
public static partial class StringExtension
{
    /// <summary>
    /// 将指定字符串转换为十六进制Hex字符串形式。
    /// </summary>
    /// <param name="input">要转换的原始字符串。</param>
    /// <param name="e">编码</param>
    /// <returns>转换后的内容</returns>
    public static string ToHex(this string input, Encoding e = null)
    {
        e = e ?? Encoding.UTF8;
        byte[] byteArray = e.GetBytes(input);
        return BitConverter.ToString(byteArray).Replace('-', ' ');
    }

    /// <summary>
    /// 将十六进制Hex字符串转换为原始字符串。
    /// </summary>
    /// <param name="input">十六进制字符串内容</param>
    /// <param name="e">编码</param>
    /// <returns>原始字符串内容</returns>
    public static string ReHex(this string input, Encoding e = null)
    {
        e = e ?? Encoding.UTF8;
        input = Regex.Replace(input, "[^0-9A-F]", "");
        if (input.Length <= 0) return "";
        byte[] vBytes = new byte[input.Length / 2];
        for (int i = 0; i < vBytes.Length; i++)
            vBytes[i] = byte.Parse(input.Substring(i * 2, 2), NumberStyles.HexNumber);
        return e.GetString(vBytes);
    }

    /// <summary>
    /// 将十六进制Hex字符串转换为二进制数据。
    /// </summary>
    /// <param name="input">十六进制字符串内容</param>
    /// <returns>原始字符串内容</returns>
    public static byte[] ReHexToBuffer(this string input)
    {
        input = Regex.Replace(input, "[^0-9A-F]", "");
        if (string.IsNullOrEmpty(input)) return new byte[0];
        byte[] vBytes = new byte[input.Length / 2];
        for (int i = 0; i < vBytes.Length; i++)
            vBytes[i] = byte.Parse(input.Substring(i * 2, 2), NumberStyles.HexNumber);
        return vBytes;
    }
}

/// <summary>
/// 二进制数据拓展方法
/// </summary>
public static partial class BufferExtension
{
    /// <summary>
    /// 将指定二进制数据转换为十六进制Hex字符串形式。
    /// </summary>
    /// <param name="input">要转换的二进制数据。</param>
    /// <returns>转换后的内容</returns>
    public static string ToHex(this byte[] input)
    {
        return BitConverter.ToString(input).Replace('-', ' ');
    }
}

/// <summary>
/// 获取算术式结果
/// </summary>
/// <param name="input">原始算术式</param>
public static void Calculator(string input = null)
{
    do
    {
        //算式为空提示输入算式
        if (string.IsNullOrEmpty(input))
        {
            Console.WriteLine("请输入一个算术式(退出输入Q)：");
            input = Console.ReadLine();
        }

        //非退出该方法
        if (!string.Equals(input, "Q", StringComparison.OrdinalIgnoreCase))
        {
            try
            {
                //使用Jint执行算式
                Engine engine = new Engine();
                object result = engine.Execute(input).GetCompletionValue().ToObject();
                Console.WriteLine($"算术式：{input} 输出：{result}");
            }
            catch (Exception exc)
            {
                Console.WriteLine($"算术式：{input} 运算出现异常：{exc.Message}");
            }

            //赋值空让用户循环输入
            input = null;
        }
    } while (!string.Equals(input, "Q", StringComparison.OrdinalIgnoreCase));
}

/// <summary>
/// 获取表达式结果
/// </summary>
/// <param name="input">原始表达式</param>
public static void GetResultFromExpression(string input = null)
{
    string oldInput;
    Regex regex = new Regex(@"\[([A-Za-z0-9]+)\]");//表达式中项目由字母和数字组成
    do
    {
        //表达式为空提示输入表达式
        if (string.IsNullOrEmpty(input))
        {
            Console.WriteLine("请输入表达式(退出输入Q)：");
            input = Console.ReadLine();
        }

        //用于输出原始表达式
        oldInput = input;

        //用于判断表达式项目是否已经替换
        List<string> items = new List<string>();

        //非退出该方法
        if (!string.Equals(input, "Q", StringComparison.OrdinalIgnoreCase))
        {
            //匹配表达式中项目并替换
            MatchCollection matches = regex.Matches(input);
            foreach (Match match in matches)
            {
                //已经替换的跳过
                if (items.Contains(match.Value))
                {
                    continue;
                }
                items.Add(match.Value);
                Console.WriteLine($"请为项目：{match.Value} 赋值：");
                string item = Console.ReadLine();
                input = input.Replace(match.Value, item);
            }
            try
            {
                //使用Jint执行表达式
                Engine engine = new Engine();
                object result = engine.Execute(input).GetCompletionValue().ToObject();
                Console.WriteLine($"表达式：{oldInput} 算术式：{input} 输出：{result}");
            }
            catch (Exception exc)
            {
                Console.WriteLine($"表达式：{oldInput} 算术式：{input} 运算出现异常：{exc.Message}");
            }

            //赋值空让用户循环输入
            input = null;
            oldInput = null;
        }
    } while (!string.Equals(input, "Q", StringComparison.OrdinalIgnoreCase));
}

/// <summary>
/// 执行自定义脚本获取内容
/// </summary>
/// <param name="input">脚本</param>
public static void ExecuteCustomScript(string input = null)
{
    string oldInput;
    Regex regex1 = new Regex(@"\[([A-Za-z0-9]+)\]");//脚本中项目由字母和数字组成
    Regex regex2 = new Regex(@"\$#\*(.+)\*#", RegexOptions.Singleline);//匹配自定义脚本
    do
    {
        //脚本为空提示输入
        if (string.IsNullOrEmpty(input))
        {
            Console.WriteLine("请输入脚本(退出输入Q)：");
            input = Console.ReadLine();
        }

        //用于输出原始脚本
        oldInput = input;

        //用于判断脚本项目是否已经替换
        List<string> items = new List<string>();

        //用于判断脚本内容是否已经替换
        List<string> scripts = new List<string>();

        //非退出该方法
        if (!string.Equals(input, "Q", StringComparison.OrdinalIgnoreCase))
        {
            //匹配脚本中项目并替换
            {
                MatchCollection matches = regex1.Matches(input);
                foreach (Match match in matches)
                {
                    //已经替换的跳过
                    if (items.Contains(match.Value))
                    {
                        continue;
                    }
                    items.Add(match.Value);
                    Console.WriteLine($"请为项目：{match.Value} 赋值：");
                    string item = Console.ReadLine();
                    input = input.Replace(match.Value, item);
                }
            }

            //匹配内容中自定义脚本并执行替换
            {
                MatchCollection matches = regex2.Matches(input);
                foreach (Match match in matches)
                {
                    //已经替换的跳过
                    if (scripts.Contains(match.Value))
                    {
                        continue;
                    }

                    scripts.Add(match.Value);

                    try
                    {
                        //使用Jint执行内容中自定义脚本
                        Engine engine = new Engine();
                        object result = engine.Execute(match.Groups[1].Value).GetCompletionValue().ToObject();
                        input = input.Replace(match.Value, result.ToString());
                    }
                    catch (Exception exc)
                    {
                        Console.WriteLine($"脚本：{match.Groups[1].Value}\r\n执行出现异常：{exc.Message}");
                    }
                }
            }

            Console.WriteLine($"**********************\r\n原始脚本：{oldInput}\r\n输出内容：{input}");

            //还原公式让用户重新赋值
            input = oldInput;
        }
    } while (!string.Equals(input, "Q", StringComparison.OrdinalIgnoreCase));
}

JintTest.ExecuteCustomScript(@"[ItemName]的结果为[ResultValue]，临床意义为：$#*
var n = '[ItemName]';
var r = '[ResultValue]'.replace(/[^0-9\+\-\.]/, '');
var d = '';
if (r !== '' && !isNaN(r)) {
    if (n === 'HIV' && r >= 1) {
        d = '待复查';
    }
    else if (r >= 1) {
        d = '阳性';
    } else {
        d = '阴性';
    }
}
d;*#。");

HtmlAgilityPack.HtmlDocument document = null;
WebRequest request = WebRequest.Create("https://www.jd.com/allsort.aspx");
using (WebResponse response = request.GetResponse())
{
    using (Stream stream = response.GetResponseStream())
    {
        document = new HtmlAgilityPack.HtmlDocument();
        document.Load(stream, Encoding.UTF8);
        //MemoryStream memoryStream = (MemoryStream)stream;
        //document.LoadHtml(Encoding.UTF8.GetString(memoryStream.ToArray()));
        //memoryStream.Dispose();
    }
}

HtmlAgilityPack.HtmlDocument document = null;
using (WebClient client = new WebClient())
{
    using (Stream stream = client.OpenRead("https://www.jd.com/allsort.aspx"))
    {
        document = new HtmlAgilityPack.HtmlDocument();
        document.Load(stream, Encoding.UTF8);
    }
}

HtmlWeb web = new HtmlWeb
{
    OverrideEncoding = Encoding.UTF8
};
HtmlAgilityPack.HtmlDocument document = web.Load("https://www.jd.com/allsort.aspx");

public class Category
{
    public int Id { get; set; }
    public string JDId { get; set; }
    public string Name { get; set; }
    public string URL { get; set; }
}

List<Category> listCategory = new List<Category>();
if (document != null)
{
    int iId = 1;//编号
    Regex regex = new Regex("cat=(\\d+(\\,\\d+)*)");//匹配与提取类别ID正则
    //取出所有链接
    HtmlNodeCollection collection = document.DocumentNode.SelectNodes("//a[@href]");
    foreach (var item in collection)
    {
        //正则匹配出是商品类别的链接
        Match match = regex.Match(item.Attributes["href"].Value.ToLower());
        if (match.Success)
        {
            //提取商品类别ID 商品类别链接 商品类别名称
            listCategory.Add(new Category() { Id = iId++, JDId = match.Groups[1].Value, Name = item.InnerText, URL = item.Attributes["href"].Value.ToLower().StartsWith("http") ? item.Attributes["href"].Value : "https:" + item.Attributes["href"].Value });
        }
    }
}

public class Product
{
    public int Id { get; set; }
    public string JDId { get; set; }
    public string Name { get; set; }
    public string Price { get; set; }
    public string ImageURL { get; set; }
    public string URL { get; set; }
}

if (document != null)
{
    //获取页码信息
    string sCurrentPager = string.Empty;//当前页数
    string sAllPager = string.Empty;//总页数
    //List<Product> listProduct = new List<Product>();//商品
    //获取页数信息
    HtmlNodeCollection currentPagerNode = document.DocumentNode.SelectNodes("//*[@id=\"J_topPage\"]/span/b");
    if (currentPagerNode.Count != 1)
    {
        throw new Exception("加载当前页码失败！");
    }
    else
    {
        sCurrentPager = currentPagerNode[0].InnerText;
    }
    HtmlNodeCollection allPagersNode = document.DocumentNode.SelectNodes("//*[@id=\"J_topPage\"]/span/i");
    if (allPagersNode.Count != 1)
    {
        throw new Exception("加载总页数失败！");
    }
    else
    {
        sAllPager = allPagersNode[0].InnerText;
    }
    //获取商品信息
    int iId = 1;//编号
    HtmlNodeCollection productNode = document.DocumentNode.SelectNodes("//*[@id=\"plist\"]/ul/li");//符合条件的商品XPath语法
    foreach (var item in productNode)
    {
        Product product = new Product();
        HtmlAgilityPack.HtmlDocument tempDocument = new HtmlAgilityPack.HtmlDocument();
        tempDocument.LoadHtml(item.OuterHtml);
        //商品图片链接
        HtmlNodeCollection imageNode = tempDocument.DocumentNode.SelectNodes("//*[@class=\"p-img\"]/a/img");
        if (imageNode.Count > 0 && imageNode[0].Attributes["src"] != null && !string.IsNullOrEmpty(imageNode[0].Attributes   ["src"].Value))// 正常加载图片链接
        {
            product.ImageURL = imageNode[0].Attributes["src"].Value.ToLower().StartsWith("http") ? imageNode[0].Attributes ["src"].Value :    "https:" + imageNode[0].Attributes["src"].Value;
        }
        else if (imageNode.Count > 0 && imageNode[0].Attributes["data-lazy-img"] != null && !string.IsNullOrEmpty(imageNode [0].Attributes   ["data-lazy-img"].Value))//懒加载图片链接
        {
            product.ImageURL = imageNode[0].Attributes["data-lazy-img"].Value.ToLower().StartsWith("http") ? imageNode[0].Attributes   ["data- lazy-img"].Value : "https:" + imageNode[0].Attributes["data-lazy-img"].Value;
        }
        else
        {
            continue;
        }
        //商品ID
        HtmlNodeCollection idNode = tempDocument.DocumentNode.SelectNodes("//li/div");
        if (idNode.Count > 0 && idNode[0].Attributes["data-sku"] != null && !string.IsNullOrEmpty(idNode[0].Attributes["data-  sku"].Value))
        {
            product.JDId = idNode[0].Attributes["data-sku"].Value;
        }
        else
        {
            continue;
        }
        //商品名称
        HtmlNodeCollection nameNode = tempDocument.DocumentNode.SelectNodes("//*[@class=\"p-name\"]/a/em");
        if (nameNode.Count > 0 && !string.IsNullOrEmpty(nameNode[0].InnerText.Trim()))
        {
            product.Name = nameNode[0].InnerText.Trim();
        }
        else
        {
            continue;
        }
        //商品链接
        HtmlNodeCollection urlNode = tempDocument.DocumentNode.SelectNodes("//*[@class=\"p-name\"]/a");
        if (urlNode.Count > 0 && urlNode[0].Attributes["href"] != null && !string.IsNullOrEmpty(urlNode[0].Attributes["href"].Value))
        {
            product.URL = urlNode[0].Attributes["href"].Value.ToLower().StartsWith("http") ? urlNode[0].Attributes["href"].Value :    "https:"  + urlNode[0].Attributes["href"].Value;
        }
        else
        {
            continue;
        }
        product.Id = iId++;
        listProduct.Add(product);
    }
}

/// <summary>
/// 通过京东商品ID获取价格
/// </summary>
/// <param name="listJDId">商品ID</param>
/// <returns>商品ID对应价格的字典</returns>
private Dictionary<string, string> GetPrice(List<string> listJDId)
{
    Dictionary<string, string> dicPrice = new Dictionary<string, string>();
    if (listJDId.Count > 0)
    {
        //按照ajax请求连接格式拼接skuID
        for (int i = 0; i < listJDId.Count; i++)
        {
            listJDId[i] = "J_" + listJDId[i];
        }
        //循环每10条查询一次 避免数量过多链接过长
        for (int i = 0; i < (listJDId.Count + 9) / 10; i++)
        {
            //获取数据
            HtmlAgilityPack.HtmlDocument document = new HtmlAgilityPack.HtmlDocument();
            WebRequest request = WebRequest.Create("https://p.3.cn/prices/mgets?skuIds=" + string.Join("%2C", listJDId.Skip(i * 10).Take(10)));
            using (Stream stream = request.GetResponse().GetResponseStream())
            {
                document.Load(stream, Encoding.UTF8);
            }
            //解析数据
            if (!string.IsNullOrEmpty(document.Text))
            {
                object oPrice = Newtonsoft.Json.JsonConvert.DeserializeObject(document.Text);//转换成对象
                if (oPrice is JArray)
                {
                    foreach (var item in oPrice as JArray)
                    {
                        if (item is JObject && (item as JObject).ContainsKey("id") && (item as JObject).ContainsKey("p"))
                        {
                            //提取符合条件的数据
                            if ((item as JObject)["id"] is JValue jId && (item as JObject)["p"] is JValue jPrice && listJDId.Contains(jId.Value.ToString()) && !dicPrice.ContainsKey(jId.Value.ToString().TrimStart('J', '_')))
                            {
                                dicPrice.Add(jId.Value.ToString().TrimStart('J', '_'), jPrice.Value.ToString());
                            }
                        }
                    }
                }
            }
        }
    }
    return dicPrice;
}

/// <summary>
/// 静态构造函数
/// *该方法由CLR保证，程序第一次使用这个类型前被调用，且只调用一次
/// </summary>
public class Singleton2
{
    static Singleton2()
    {
        Thread.Sleep(1000);
        Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: {nameof(Singleton2)}\t构造成功\t线程ID为{Thread.CurrentThread.ManagedThreadId}。");
    }
	//测试
    public static void Show()
    {
        Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: {nameof(Singleton2)}\t单例模式测试开始\t线程ID为{Thread.CurrentThread.ManagedThreadId}。");
        Singleton2 singleton = null;
        for (int i = 0; i < 10; i++)
        {
            Task.Factory.StartNew(() =>
            {
                singleton = new Singleton2();
                Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: {nameof(Singleton2)}\t获取单例\t线程ID为{Thread.CurrentThread.ManagedThreadId}。");
            });
        }
    }
}
/// <summary>
/// 静态字段
/// *该方法由CLR保证，程序第一次使用这个类型前被初始化，且只初始化一次
/// </summary>
public class Singleton3
{
    private Singleton3()
    {
        Thread.Sleep(1000);
        Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: {nameof(Singleton3)}\t构造成功\t线程ID为{Thread.CurrentThread.ManagedThreadId}。");
    }
    private static Singleton3 _singleton = new Singleton3();
    public static Singleton3 CreateInstance()
    {
        return _singleton;
    }
	//测试
    public static void Show()
    {
        Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: {nameof(Singleton3)}\t单例模式测试开始\t线程ID为{Thread.CurrentThread.ManagedThreadId}。");
        Singleton3 singleton = null;
        for (int i = 0; i < 10; i++)
        {
            Task.Factory.StartNew(() =>
            {
                singleton = CreateInstance();
                Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: {nameof(Singleton3)}\t获取单例\t线程ID为{Thread.CurrentThread.ManagedThreadId}。");
            });
        }
    }
}

/// <summary>
/// 双if判断加锁
/// *内层if判断保证单例模式
/// *外层if判断避免加锁阻碍多线程运行
/// *加锁避免多线程对象被多次创建
/// </summary>
public class Singleton1
{
    private Singleton1()
    {
        Thread.Sleep(1000);
        Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: {nameof(Singleton1)}\t构造成功\t线程ID为{Thread.CurrentThread.ManagedThreadId}。");
    }
    private static volatile Singleton1 _singleton = null;
    private static object Singleton_Lock = new object();
    public static Singleton1 CreateInstance()
    {
        if (_singleton == null)//不为空才去等待锁
        {
            lock (Singleton_Lock)
            {
                Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: {nameof(Singleton1)}\t等待锁之后释放\t线程ID为{Thread.CurrentThread.ManagedThreadId}。");
                Thread.Sleep(500);
                if (_singleton == null)//保证不被重复创建
                {
                    _singleton = new Singleton1();
                }
            }
        }
        return _singleton;
    }

    //测试
    public static void Show()
    {
        Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: {nameof(Singleton1)}\t单例模式测试开始\t线程ID为{Thread.CurrentThread.ManagedThreadId}。");
        Singleton1 singleton = null;
        List<Task> listTask = new List<Task>();
        for (int i = 0; i < 10; i++)
        {
            listTask.Add(Task.Factory.StartNew(() =>
            {
                singleton = CreateInstance();
                Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: {nameof(Singleton1)}\t获取单例\t线程ID为{Thread.CurrentThread.ManagedThreadId}。");
            }));
        }
        Task.WaitAll(listTask.ToArray());
        for (int i = 0; i < 10; i++)
        {
            Task.Factory.StartNew(() =>
            {
                singleton = CreateInstance();
                Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss")}: {nameof(Singleton1)}\t获取单例\t线程ID为{Thread.CurrentThread.ManagedThreadId}。");
            });
        }
    }
}

public class Sportsman
{
    public Sportsman(string name, bool gender, int age, string country)
    {
        Name = name;
        Gender = gender;
        Age = age;
        Country = country;
    }
    public string Name { get; set; }
    public bool Gender { get; set; }
    public int Age { get; set; }
    public string Country { get; set; }
    public void PlayGame(IBall ball)
    {
        Console.WriteLine($"You're watching {ball.PlayGame()} The name of the sportsman is {Name}. {(Gender ? "He" : "She")} is a {Age} years old {(Gender ? "boy" : "girl")} from {Country}.");
    }
}
public interface IBall
{
    string PlayGame();
}
public enum BallType
{
    Basketball,
    Football,
    Baseball,
    Volleyball
}
    

public class SimpleFactory
{
    public static void Show()
    {
        Sportsman sportsman = new Sportsman("Kangkang", true, 17, "China");
        {
            Basketball basketball = new Basketball();//1.左右都是细节
            sportsman.PlayGame(basketball);
        }
        {
            IBall ball = new Football();//2.左边是抽象 右边是细节
            sportsman.PlayGame(ball);
        }
        {
            //遵循依赖倒置 但是违背了单一职责
            Console.WriteLine("********简单工厂-转移细节********");
            IBall ball = CreateBallGame(BallType.Volleyball);//3.没有细节 细节被转移
            sportsman.PlayGame(ball);
        }
        {
            //结合配置项+反射 IOC雏形
            Console.WriteLine("********简单工厂-配置项********");
            IBall ball = CreateBallFromConfiguration();
            sportsman.PlayGame(ball);
        }
    }

    /// <summary>
    /// **集中了矛盾**
    /// 细节没有消失只是转移
    /// 转移了矛盾并没有消除矛盾
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    public static IBall CreateBallGame(BallType type)
    {
        IBall ball = null;
        switch (type)
        {
            case BallType.Basketball:
                ball = new Basketball();
                break;
            case BallType.Football:
                ball = new Football();
                break;
            case BallType.Baseball:
                ball = new Baseball();
                break;
            case BallType.Volleyball:
                ball = new Volleyball();
                break;
            default:
                throw new Exception("unknown ball type.");
        }
        return ball;
    }

    /// <summary>
    /// IOC的雏形
    /// </summary>
    /// <returns></returns>
    public static IBall CreateBallFromConfiguration()
    {
        string[] aTemp = ConfigurationManager.AppSettings.Get("BallType").Split(',');
        Assembly assembly = Assembly.LoadFrom(aTemp[0]);
        Type type = assembly.GetType(aTemp[1]);
        IBall ball = Activator.CreateInstance(type) as IBall;
        return ball;
    }
}

public class Baseball : IBall
{
    public string PlayGame()
    {
        return "a baseball tv show.";
    }
}
public class Football : IBall
{
    public string PlayGame()
    {
        return "a football tv show.";
    }
}
public class Baseball : IBall
{
    public string PlayGame()
    {
        return "a baseball tv show.";
    }
}
public class Volleyball : IBall
{
    public string PlayGame()
    {
        return "a volleyball tv show.";
    }
}

public class SimpleFactory
{
    public static void Show()
    {
        Sportsman sportsman = new Sportsman("Kangkang", true, 17, "China");
        {
            Basketball basketball = new Basketball();//1.左右都是细节
            sportsman.PlayGame(basketball);
        }
        {
            IBall ball = new Football();//2.左边是抽象 右边是细节
            sportsman.PlayGame(ball);
        }
        {
            //遵循依赖倒置 但是违背了单一职责
            Console.WriteLine("********简单工厂-转移细节********");
            IBall ball = CreateBallGame(BallType.Volleyball);//3.没有细节 细节被转移
            sportsman.PlayGame(ball);
        }
        {
            //结合配置项+反射 IOC雏形
            Console.WriteLine("********简单工厂-配置项********");
            IBall ball = CreateBallFromConfiguration();
            sportsman.PlayGame(ball);
        }
    }

    /// <summary>
    /// **集中了矛盾**
    /// 细节没有消失只是转移
    /// 转移了矛盾并没有消除矛盾
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    public static IBall CreateBallGame(BallType type)
    {
        IBall ball = null;
        switch (type)
        {
            case BallType.Basketball:
                ball = new Basketball();
                break;
            case BallType.Football:
                ball = new Football();
                break;
            case BallType.Baseball:
                ball = new Baseball();
                break;
            case BallType.Volleyball:
                ball = new Volleyball();
                break;
            default:
                throw new Exception("unknown ball type.");
        }
        return ball;
    }

    /// <summary>
    /// IOC的雏形
    /// </summary>
    /// <returns></returns>
    public static IBall CreateBallFromConfiguration()
    {
        string[] aTemp = ConfigurationManager.AppSettings.Get("BallType").Split(',');
        Assembly assembly = Assembly.LoadFrom(aTemp[0]);
        Type type = assembly.GetType(aTemp[1]);
        IBall ball = Activator.CreateInstance(type) as IBall;
        return ball;
    }
}

public interface IFactory
{
    IBall CreateBall();
}
public class BaseballFactory : IFactory
{
    public IBall CreateBall()
    {
        return new Baseball();
    }
}
public class FootballFactory : IFactory
{
    public IBall CreateBall()
    {
        return new Football();
    }
}
public class BaseballFactory : IFactory
{
    public IBall CreateBall()
    {
        return new Baseball();
    }
}
public class VolleyballFactory : IFactory
{
    public IBall CreateBall()
    {
        return new Volleyball();
    }
}