namespace HelloNexus
{
    public class Nexus
    {
        public static string Hello() 
        {
            return "Hello Nexus!";
        }
    }
}

double num1 = 10000000000000000d + 1d;
Console.WriteLine($"double: 10000000000000000 + 1 = {num1}");
Console.WriteLine($"double: 10000000000000000 == 10000000000000001 is {10000000000000000d == 10000000000000001d}");
double num2 = 0.1d * 0.1d;
Console.WriteLine($"double: 0.1 × 0.1 == 0.01 is {num2 == 0.01}");

// 程序运行输出：
// double: 10000000000000000 + 1 = 10000000000000000
// double: 10000000000000000 == 10000000000000001 is True
// double: 0.1 × 0.1 == 0.01 is False

decimal num1 = 10000000000000000m + 1m;
Console.WriteLine($"decimal: 10000000000000000 + 1 = {num1}");
Console.WriteLine($"decimal: 10000000000000000 == 10000000000000001 is {10000000000000000m == 10000000000000001m}");
decimal num2 = 0.1m * 0.1m;
Console.WriteLine($"decimal: 0.1 × 0.1 == 0.01 is {num2 == 0.01m}");

// 程序运行输出：
// decimal: 10000000000000000 + 1 = 10000000000000001
// decimal: 10000000000000000 == 10000000000000001 is False
// decimal: 0.1 × 0.1 == 0.01 is True

public class TestClass1 { }

public class TestClass2
{
    private TestClass2() { }
}

class Program
{
    static void Main(string[] args)
    {
        // 调用默认的无参数构造函数
        TestClass1 class1 = new TestClass1();
        // 重写了唯一的无参数构造函数，并私有化，下面实例化代码将报错
        // TestClass2 class2 = new TestClass2();
    }
}

public class TestClass
{
    static TestClass()
    {
        Console.WriteLine("调用了 TestClass 的静态构造函数");
    }
    public TestClass()
    {
        Console.WriteLine("调用了 TestClass 的实例构造函数");
    }
    public static void TestMethod1()
    {
        Console.WriteLine("调用了 TestClass 的静态方法 TestMethod1");
    }
    public void TestMethod2()
    {
        Console.WriteLine("调用了 TestClass 的实例方法 TestMethod2");
    }
}

class Program
{
    static void Main(string[] args)
    {
        TestClass.TestMethod1();
        TestClass @class = new TestClass();
        @class.TestMethod2();
        Console.ReadKey();
    }
}

// 程序运行输出：
// 调用了 TestClass 的静态构造函数
// 调用了 TestClass 的静态方法 TestMethod1
// 调用了 TestClass 的实例构造函数
// 调用了 TestClass 的实例方法 TestMethod2

public class Phone
{
    public Phone(string phoneNumber)
    {
        PhoneNumber = phoneNumber;
        Console.WriteLine($"调用 Phone 的构造函数：PhoneNumber={PhoneNumber}");
    }
    public string PhoneNumber { get; set; }
    public void Call(string phoneNumber)
    {
        Console.WriteLine($"{PhoneNumber} 向 {phoneNumber} 呼出了电话！");
    }
}

public class ApplePhone : Phone
{
    public ApplePhone(string phoneNumber, string systemVersion, int batteryCapacity) : base(phoneNumber)
    {
        SystemVersion = systemVersion;
        BatteryCapacity = batteryCapacity;
        Console.WriteLine($"调用 ApplePhone 的构造函数：PhoneNumber={PhoneNumber}, SystemVersion={SystemVersion}, BatteryCapacity={BatteryCapacity}");
    }
    public ApplePhone(string phoneNumber) : this(phoneNumber, "未知", -1)
    {
        Console.WriteLine($"调用 ApplePhone 的构造函数：PhoneNumber={PhoneNumber}");
    }
    public string SystemVersion { get; set; }
    public int BatteryCapacity { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        TestClass.TestMethod1();
        Phone phone = new ApplePhone("13888888888");
        phone.Call("119");
        Console.ReadKey();
    }
}

// 运行程序输出：
// 调用 Phone 的构造函数：PhoneNumber=13888888888
// 调用 ApplePhone 的构造函数：PhoneNumber=13888888888, SystemVersion=未知, BatteryCapacity=-1
// 调用 ApplePhone 的构造函数：PhoneNumber=13888888888
// 13888888888 向 119 呼出了电话！

public class Phone
{
    public Phone(string phoneNumber)
    {
        PhoneNumber = phoneNumber;
        Console.WriteLine($"调用 Phone 的构造函数：PhoneNumber={PhoneNumber}");
    }
    public string PhoneNumber { get; set; }
    public void Call(string phoneNumber)
    {
        Console.WriteLine($"{PhoneNumber} 向 {phoneNumber} 呼出了电话！");
    }
    ~Phone()
    {
        Console.WriteLine($"调用 Phone 的析构函数");
    }
}

public class ApplePhone : Phone
{
    public ApplePhone(string phoneNumber, string systemVersion, int batteryCapacity) : base(phoneNumber)
    {
        SystemVersion = systemVersion;
        BatteryCapacity = batteryCapacity;
        Console.WriteLine($"调用 ApplePhone 的构造函数：PhoneNumber={PhoneNumber}, SystemVersion={SystemVersion}, BatteryCapacity={BatteryCapacity}");
    }
    public ApplePhone(string phoneNumber) : this(phoneNumber, "未知", -1)
    {
        Console.WriteLine($"调用 ApplePhone 的构造函数：PhoneNumber={PhoneNumber}");
    }
    public string SystemVersion { get; set; }
    public int BatteryCapacity { get; set; }
    ~ApplePhone()
    {
        Console.WriteLine($"调用 ApplePhone 的析构函数");
    }
}

class Program
{
    static void Main(string[] args)
    {
        TakeCall();
        GC.Collect();
        Console.ReadKey();
    }

    public static void TakeCall()
    {
        Phone phone = new ApplePhone("13888888888");
        phone.Call("119");
    }
}

// 运行程序输出：
// 调用 Phone 的构造函数：PhoneNumber=13888888888
// 调用 ApplePhone 的构造函数：PhoneNumber=13888888888, SystemVersion=未知, BatteryCapacity=-1
// 调用 ApplePhone 的构造函数：PhoneNumber=13888888888
// 13888888888 向 119 呼出了电话！
// 调用 ApplePhone 的析构函数
// 调用 Phone 的析构函数

class Program
{
    static void Main(string[] args)
    {
        var (year, _, _, _, _, _) = GetDateTimeInfo("2020年2月11日");
        Console.WriteLine($"{year}年是{(DateTime.IsLeapYear(year) ? "闰年" : "平年")}");
        Console.ReadKey();
    }

    public static (int year, int month, int day, int hour, int minute, int second) GetDateTimeInfo(string datetime)
    {
        int year = 0, month = 1, day = 1, hour = 0, minute = 0, second = 0;
        var info = Regex.Split(datetime, "[^0-9]");
        if (info.Length > 0 && !string.IsNullOrEmpty(info[0])) year = int.Parse(info[0]);
        if (info.Length > 1 && !string.IsNullOrEmpty(info[1])) month = int.Parse(info[1]);
        if (info.Length > 2 && !string.IsNullOrEmpty(info[2])) day = int.Parse(info[2]);
        if (info.Length > 3 && !string.IsNullOrEmpty(info[3])) hour = int.Parse(info[3]);
        if (info.Length > 4 && !string.IsNullOrEmpty(info[4])) minute = int.Parse(info[4]);
        if (info.Length > 5 && !string.IsNullOrEmpty(info[5])) second = int.Parse(info[5]);

        return (year, month, day, hour, minute, second);
    }
}

// 运行程序输出：
// 2020年是闰年

class Program
{
    static void Main(string[] args)
    {
        // var (year, _, _, _, _, _) = GetDateTimeInfo("2020年2月11日");
        var (year, _, _) = new DateTimeInfo("2020年2月11日");
        Console.WriteLine($"{year}年是{(DateTime.IsLeapYear(year) ? "闰年" : "平年")}");
        Console.ReadKey();
    }
}

public struct DateTimeInfo
{
    public DateTimeInfo(string datetime)
    {
        Year = 0;
        Month = 1;
        Day = 1;
        Hour = 0;
        Minute = 0;
        Second = 0;
        var info = Regex.Split(datetime, "[^0-9]");
        if (info.Length > 0 && !string.IsNullOrEmpty(info[0])) Year = int.Parse(info[0]);
        if (info.Length > 1 && !string.IsNullOrEmpty(info[1])) Month = int.Parse(info[1]);
        if (info.Length > 2 && !string.IsNullOrEmpty(info[2])) Day = int.Parse(info[2]);
        if (info.Length > 3 && !string.IsNullOrEmpty(info[3])) Hour = int.Parse(info[3]);
        if (info.Length > 4 && !string.IsNullOrEmpty(info[4])) Minute = int.Parse(info[4]);
        if (info.Length > 5 && !string.IsNullOrEmpty(info[5])) Second = int.Parse(info[5]);
    }
    public int Year { get; }
    public int Month { get; }
    public int Day { get; }
    public int Hour { get; }
    public int Minute { get; }
    public int Second { get; }
    public void Deconstruct(out int year, out int month, out int day)
    {
        (year, month, day, _, _, _) = this;
    }
    public void Deconstruct(out int year, out int month, out int day, out int hour, out int minute, out int second)
    {
        year = Year;
        month = Month;
        day = Day;
        hour = Hour;
        minute = Minute;
        second = Second;
    }
}

// 运行程序输出：
// 2020年是闰年

string strNum = "2e+8";
bool isNum = decimal.TryParse("2e+8", System.Globalization.NumberStyles.Any, null, out _);
Console.WriteLine($"{strNum} 判断是否为数字的结果：{isNum}");

// 运行程序输出：
// 2e+8 判断是否为数字的结果：True

/// <summary>
/// 服务客户端
/// </summary>
public class SoapClient
{
    /// <summary>
    /// 初始化客户端（伪）
    /// </summary>
    /// <param name="name"></param>
    public SoapClient(string name)
    {
        Name = name;
    }

    /// <summary>
    /// 当前客户端名称
    /// </summary>
    public string Name { get; set; }

    private static Random Random = new Random();
    
    /// <summary>
    /// 检测服务状态
    /// </summary>
    /// <returns>服务是否可用</returns>
    public bool HelloWorld()
    {
        // 随机休眠线程 模仿服务资源检测
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}[{Thread.CurrentThread.ManagedThreadId:00}]@[{Name}]:开始连接服务");
        Thread.Sleep(Random.Next(500,5000));
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}[{Thread.CurrentThread.ManagedThreadId:00}]@[{Name}]:服务资源检测结束");

        // 随机确认客户端连接状态
        bool result = Random.NextDouble() > 0.3;
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}[{Thread.CurrentThread.ManagedThreadId:00}]@[{Name}]:服务状态为{result}");
        return result;
    }
}

SoapClient client = new SoapClient("Test");
client.HelloWorld();

string[] clientNames = new string[] { "Client1", "Client2", "Client3", "Client4", "Client5" };

SoapClient client = null;
for (int i = 0; i < clientNames.Length; i++)
{
    SoapClient testClient = new SoapClient(clientNames[i]);
    if (testClient.HelloWorld())
    {
        client = testClient;
        break;
    }
}
Console.WriteLine("服务检测结束：连接{0}{1}", client == null ? "失败" : "成功", string.IsNullOrEmpty(client?.Name) ? "" : $"服务名为{client.Name}");

string[] clientNames = new string[] { "Client1", "Client2", "Client3", "Client4", "Client5" };

List<Task<SoapClient>> clients = new List<Task<SoapClient>>();
for (int i = 0; i < clientNames.Length; i++)
{
    string name = clientNames[i];
    clients.Add(Task.Factory.StartNew(() =>
    {
        SoapClient client = new SoapClient(name);
        bool connResult = client.HelloWorld();
        return connResult ? client : null;
    }));
}

// 等待所有异步任务执行完成 打印可用的服务
Task.WaitAll(clients.ToArray());
clients.ForEach(client =>
{
    if (client.Result != null)
        Console.WriteLine($"检测到可用服务：{client.Result.Name}");
});

string[] clientNames = new string[] { "Client1", "Client2", "Client3", "Client4", "Client5" };

List<Task<SoapClient>> clients = new List<Task<SoapClient>>();
for (int i = 0; i < clientNames.Length; i++)
{
    string name = clientNames[i];
    clients.Add(Task.Factory.StartNew(() =>
    {
        SoapClient client = new SoapClient(name);
        bool connResult = client.HelloWorld();
        return connResult ? client : null;
    }));
}

// 等待任意任务执行完成，获取执行完成的任务返回
int index;
do
{
    index = Task.WaitAny(clients.ToArray());
    if (clients[index].Result != null)
    {
        Console.WriteLine($"检测到可用服务：{clients[index].Result.Name}");
        break;
    }
    else
    {
        Console.WriteLine($"检测到一个不可用的服务。");
        clients.RemoveAt(index);
    }
} while (clients.Count > 0);

// 开始的示例使用 .NET Framework 4.0 框架
using (CancellationTokenSource source = new CancellationTokenSource())
{
    Task task = Task.Factory.StartNew(() =>
    {
        Console.WriteLine("任务开始执行，需要等待 5 秒钟。");
        Thread.Sleep(5000);
        Console.WriteLine("任务执行结束。");
    }, source.Token);

    Thread.Sleep(1000);
    source.Cancel();
    task.Wait();
}

// Task.Delay() 为 .NET Framework 4.5 框架的方法
using (CancellationTokenSource source = new CancellationTokenSource())
{
    Task task = Task.Run(() =>
    {
        Console.WriteLine("任务开始执行，需要等待 5 秒钟。");
        Task.Delay(5000).Wait(source.Token);
        Console.WriteLine("任务执行结束。");
    }, source.Token);

    Thread.Sleep(1000);
    source.Cancel();
    try
    {
        task.Wait();
    }
    catch (AggregateException ae)
    {
        foreach (Exception e in ae.InnerExceptions)
        {
            if (e is TaskCanceledException)
                Console.WriteLine("执行的任务被取消！");
            else
                Console.WriteLine("其他异常：" + e.GetType().Name);
        }
    }
}

/// <summary>
/// 检测服务状态
/// </summary>
/// <returns>服务是否可用</returns>
public bool HelloWorld(CancellationToken cancellationToken)
{
    // 随机休眠线程 模仿服务资源检测
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}[{Thread.CurrentThread.ManagedThreadId:00}]@[{Name}]:开始连接服务");
    Task.Delay(Random.Next(500, 5000)).Wait(cancellationToken);
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}[{Thread.CurrentThread.ManagedThreadId:00}]@[{Name}]:服务资源检测结束");

    // 随机确认客户端连接状态
    bool result = Random.NextDouble() > 0.3;
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}[{Thread.CurrentThread.ManagedThreadId:00}]@[{Name}]:服务状态为{result}");
    return result;
}

string[] clientNames = new string[] { "Client1", "Client2", "Client3", "Client4", "Client5" };

List<Task<SoapClient>> tasks = new List<Task<SoapClient>>();
using (var cancelTokenSource = new CancellationTokenSource())
{
    for (int i = 0; i < clientNames.Length; i++)
    {
        string name = clientNames[i];
        tasks.Add(Task.Factory.StartNew(() =>
        {
            SoapClient client = new SoapClient(name);
            bool connResult = client.HelloWorld(cancelTokenSource.Token);
            return connResult ? client : null;
        }, cancelTokenSource.Token));
    }

    // 等待任意任务执行完成，获取执行完成的任务返回
    int index;
    do
    {
        index = Task.WaitAny(tasks.ToArray());
        if (tasks[index].Result != null)
        {
            cancelTokenSource.Cancel();
            Console.WriteLine($"检测到可用服务：{tasks[index].Result.Name}，取消其他测试任务的执行");
            break;
        }
        else
        {
            Console.WriteLine($"检测到一个不可用的服务。");
            tasks[index].Dispose();
            tasks.RemoveAt(index);
        }
    } while (tasks.Count > 0);

    // 等待所有任务执行结束
    try
    {
        Task.WaitAll(tasks.ToArray());
    }
    catch (AggregateException ae)
    {
        foreach (Exception e in ae.InnerExceptions)
        {
            if (e is TaskCanceledException)
                Console.WriteLine("执行的任务被取消！");
            else
                Console.WriteLine("其他异常：" + e.GetType().Name);
        }
    }
}

/// <summary>
/// 尝试建立服务连接
/// </summary>
/// <param name="urls">服务地址</param>
/// <returns>是否成功与服务建立连接</returns>
protected virtual LISWebServiceSoapClient TryConnectService(string[] urls)
{
    if (urls == null)
        throw new ArgumentNullException("服务地址不能为空", nameof(urls));
    if (urls.Length == 0)
        throw new ArgumentException("服务地址没有内容", nameof(urls));

    LISWebServiceSoapClient client = null;
    // 异步检查可用连接提高查询速度
    List<Task<LISWebServiceSoapClient>> tasks = new List<Task<LISWebServiceSoapClient>>();
    using (CancellationTokenSource source = new CancellationTokenSource())
    {
        for (int i = 0; i < urls.Length; i++)
        {
            string url = urls[i];
            tasks.Add(Task.Factory.StartNew(() =>
            {
                // 使用配置项初始化服务 并尝试调用测试连接的方法
                LISWebServiceSoapClient current = new LISWebServiceSoapClient(new BasicHttpBinding(), new EndpointAddress(url));
                current.HelloWorld();
                return current;
            }, source.Token));
        }

        // 等待任务返回 设置超时时间为 15s
        for (int i = 0; i < tasks.Count; i++)
        {
            int index = Task.WaitAny(tasks.ToArray(), 15000);

            // 超时
            if (index == -1) break;

            // 获取成功初始化的任务
            if (index > -1 && tasks[index].Status == TaskStatus.RanToCompletion)
            {
                // 有返回就取消其他任务
                source.Cancel();
                client = tasks[index].Result;
                break;
            }

            // 非成功初始化的从集合中移除
            tasks.RemoveAt(index);
        }
    }

    return client;
}

static void Main(string[] args)
{
    var obj = new { name = "hd2y", gender = "M", hobby = "coding", website = "https://hd2y.net" };
    string json = JsonConvert.SerializeObject(obj);
    Console.WriteLine(json);
    Console.ReadKey();
}

// 程序运行输入：
// {"name":"hd2y","gender":"M","hobby":"coding","website":"https://hd2y.net"}

class Program
{
    static Program()
    {
        // 添加静态构造函数 注册程序集解析失败事件 定义从嵌入资源中加载
        AppDomain.CurrentDomain.AssemblyResolve += (sender, args) =>
        {
            if (args.Name.StartsWith("Newtonsoft.Json,"))
            {
                using (Stream stream = typeof(Program).Assembly.GetManifestResourceStream("JohnSun.PackagingTest.ConsoleApp.Assets.Newtonsoft.Json.dll"))
                {
                    byte[] rawAssembly = new byte[stream.Length];
                    stream.Read(rawAssembly, 0, rawAssembly.Length);
                    return Assembly.Load(rawAssembly);
                }
            }
            return null;
        };
    }

    static void Main(string[] args)
    {
        var obj = new { name = "hd2y", gender = "M", hobby = "coding", website = "https://hd2y.net" };
        string json = JsonConvert.SerializeObject(obj);
        Console.WriteLine(json);
        Console.ReadKey();
    }
}

class Program
{
    static void Main(string[] args)
    {
        var obj = new { name = "hd2y", gender = "M", hobby = "coding", website = "https://hd2y.net" };
        string json = JsonConvert.SerializeObject(obj);
        Console.WriteLine(json);
        Console.ReadKey();
    }
}

// Costura.AssemblyLoader
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Threading;

[CompilerGenerated]
internal static class AssemblyLoader
{
	private static object nullCacheLock = new object();

	private static Dictionary<string, bool> nullCache = new Dictionary<string, bool>();

	private static Dictionary<string, string> assemblyNames = new Dictionary<string, string>();

	private static Dictionary<string, string> symbolNames = new Dictionary<string, string>();

	private static int isAttached;

	private static string CultureToString(CultureInfo culture)
	{
		if (culture == null)
		{
			return "";
		}
		return culture.Name;
	}

	private static Assembly ReadExistingAssembly(AssemblyName name)
	{
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		foreach (Assembly assembly in assemblies)
		{
			AssemblyName name2 = assembly.GetName();
			if (string.Equals(name2.Name, name.Name, StringComparison.InvariantCultureIgnoreCase) && string.Equals(CultureToString(name2.CultureInfo), CultureToString(name.CultureInfo), StringComparison.InvariantCultureIgnoreCase))
			{
				return assembly;
			}
		}
		return null;
	}

	private static void CopyTo(Stream source, Stream destination)
	{
		byte[] array = new byte[81920];
		int count;
		while ((count = source.Read(array, 0, array.Length)) != 0)
		{
			destination.Write(array, 0, count);
		}
	}

	private static Stream LoadStream(string fullName)
	{
		Assembly executingAssembly = Assembly.GetExecutingAssembly();
		if (fullName.EndsWith(".compressed"))
		{
			using (Stream stream = executingAssembly.GetManifestResourceStream(fullName))
			{
				using (DeflateStream source = new DeflateStream(stream, CompressionMode.Decompress))
				{
					MemoryStream memoryStream = new MemoryStream();
					CopyTo(source, memoryStream);
					memoryStream.Position = 0L;
					return memoryStream;
				}
			}
		}
		return executingAssembly.GetManifestResourceStream(fullName);
	}

	private static Stream LoadStream(Dictionary<string, string> resourceNames, string name)
	{
		if (resourceNames.TryGetValue(name, out string value))
		{
			return LoadStream(value);
		}
		return null;
	}

	private static byte[] ReadStream(Stream stream)
	{
		byte[] array = new byte[stream.Length];
		stream.Read(array, 0, array.Length);
		return array;
	}

	private static Assembly ReadFromEmbeddedResources(Dictionary<string, string> assemblyNames, Dictionary<string, string> symbolNames, AssemblyName requestedAssemblyName)
	{
		string text = requestedAssemblyName.Name.ToLowerInvariant();
		if (requestedAssemblyName.CultureInfo != null && !string.IsNullOrEmpty(requestedAssemblyName.CultureInfo.Name))
		{
			text = requestedAssemblyName.CultureInfo.Name + "." + text;
		}
		byte[] rawAssembly;
		using (Stream stream = LoadStream(assemblyNames, text))
		{
			if (stream == null)
			{
				return null;
			}
			rawAssembly = ReadStream(stream);
		}
		using (Stream stream2 = LoadStream(symbolNames, text))
		{
			if (stream2 != null)
			{
				byte[] rawSymbolStore = ReadStream(stream2);
				return Assembly.Load(rawAssembly, rawSymbolStore);
			}
		}
		return Assembly.Load(rawAssembly);
	}

	public static Assembly ResolveAssembly(object sender, ResolveEventArgs e)
	{
		lock (nullCacheLock)
		{
			if (nullCache.ContainsKey(e.Name))
			{
				return null;
			}
		}
		AssemblyName assemblyName = new AssemblyName(e.Name);
		Assembly assembly = ReadExistingAssembly(assemblyName);
		if (assembly != null)
		{
			return assembly;
		}
		assembly = ReadFromEmbeddedResources(assemblyNames, symbolNames, assemblyName);
		if (assembly == null)
		{
			lock (nullCacheLock)
			{
				nullCache[e.Name] = true;
			}
			if ((assemblyName.Flags & AssemblyNameFlags.Retargetable) != 0)
			{
				assembly = Assembly.Load(assemblyName);
			}
		}
		return assembly;
	}

	static AssemblyLoader()
	{
		assemblyNames.Add("costura", "costura.costura.dll.compressed");
		assemblyNames.Add("newtonsoft.json", "costura.newtonsoft.json.dll.compressed");
	}

	public static void Attach()
	{
		if (Interlocked.Exchange(ref isAttached, 1) != 1)
		{
			AppDomain.CurrentDomain.AssemblyResolve += delegate(object sender, ResolveEventArgs e)
			{
				lock (nullCacheLock)
				{
					if (nullCache.ContainsKey(e.Name))
					{
						return null;
					}
				}
				AssemblyName assemblyName = new AssemblyName(e.Name);
				Assembly assembly = ReadExistingAssembly(assemblyName);
				if (assembly != null)
				{
					return assembly;
				}
				assembly = ReadFromEmbeddedResources(assemblyNames, symbolNames, assemblyName);
				if (assembly == null)
				{
					lock (nullCacheLock)
					{
						nullCache[e.Name] = true;
					}
					if ((assemblyName.Flags & AssemblyNameFlags.Retargetable) != 0)
					{
						assembly = Assembly.Load(assemblyName);
					}
				}
				return assembly;
			};
		}
	}
}

class Program
{
    static Program()
    {
        CosturaUtility.Initialize();
    }
    static void Main(string[] args)
    {
        var obj = new { name = "hd2y", gender = "M", hobby = "coding", website = "https://hd2y.net" };
        string json = JsonConvert.SerializeObject(obj);
        Console.WriteLine(json);
        Console.ReadKey();
    }
}

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine($"开始测试：{(Environment.Is64BitProcess ? "64" : "32")} 位进程");
        int a = 100, b = 20;
        Console.WriteLine($"{a} + {b} = {SimpleMath.Addition(a, b)}");
        Console.WriteLine($"{a} - {b} = {SimpleMath.Subtraction(a, b)}");
        Console.WriteLine($"{a} * {b} = {SimpleMath.Multiplication(a, b)}");
        Console.WriteLine($"{a} / {b} = {SimpleMath.Division(a, b)}");
        Console.ReadKey();
    }
}

public class SimpleMath
{

    [DllImport("SimpleMath", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Addition(double a, double b);
    [DllImport("SimpleMath", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Subtraction(double a, double b);
    [DllImport("SimpleMath", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Multiplication(double a, double b);
    [DllImport("SimpleMath", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Division(double a, double b);
}

public class SimpleMath
{
    [DllImport("SimpleMath_x86", EntryPoint = "Addition", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Addition_x86(double a, double b);
    [DllImport("SimpleMath_x86", EntryPoint = "Subtraction", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Subtraction_x86(double a, double b);
    [DllImport("SimpleMath_x86", EntryPoint = "Multiplication", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Multiplication_x86(double a, double b);
    [DllImport("SimpleMath_x86", EntryPoint = "Division", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Division_x86(double a, double b);
    [DllImport("SimpleMath_x64", EntryPoint = "Addition", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Addition_x64(double a, double b);
    [DllImport("SimpleMath_x64", EntryPoint = "Subtraction", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Subtraction_x64(double a, double b);
    [DllImport("SimpleMath_x64", EntryPoint = "Multiplication", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Multiplication_x64(double a, double b);
    [DllImport("SimpleMath_x64", EntryPoint = "Division", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Division_x64(double a, double b);

    public static double Addition(double a, double b)
    {
        return Environment.Is64BitProcess
            ? Addition_x64(a, b)
            : Addition_x86(a, b);
    }
    public static double Subtraction(double a, double b)
    {
        return Environment.Is64BitProcess
            ? Subtraction_x64(a, b)
            : Subtraction_x86(a, b);
    }
    public static double Multiplication(double a, double b)
    {
        return Environment.Is64BitProcess
            ? Multiplication_x64(a, b)
            : Multiplication_x86(a, b);
    }
    public static double Division(double a, double b)
    {
        return Environment.Is64BitProcess
            ? Division_x64(a, b)
            : Division_x86(a, b);
    }
}

static class Kernel32
{
    [DllImport("kernel32", SetLastError = true)]
    public static extern bool FreeLibrary(IntPtr hModule);

    [DllImport("kernel32", SetLastError = true)]
    public static extern IntPtr LoadLibrary(string filename);
}

public class SimpleMath
{
    static SimpleMath()
    {
        // 只支持 Windows 平台
        if (Environment.OSVersion.Platform != PlatformID.Win32NT)
            throw new PlatformNotSupportedException($"Platform {Enum.GetName(typeof(PlatformID), Environment.OSVersion.Platform)} is not supported");

        // 读取资源名以及写出路径
        string resourceName = $"JohnSun.PackagingTest.DynamicLinkLibrary.Assets.SimpleMath_{(Environment.Is64BitProcess ? "x64" : "x86")}.dll";
        string version = $"{System.Reflection.Assembly.GetExecutingAssembly().GetName().Version}_{(Environment.Is64BitProcess ? 64 : 32)}";
        string directory = Path.Combine(Path.GetTempPath(), nameof(SimpleMath), version);
        if (!Directory.Exists(directory))
        {
            Directory.CreateDirectory(directory);
        }
        string fileName = Path.Combine(directory, "SimpleMath.dll");

        // 将需要引用的 dll 文件从资源文件写出
        using (Stream stream = typeof(SimpleMath).Assembly.GetManifestResourceStream(resourceName))
        {
            FileInfo fileInfo = new FileInfo(fileName);
            // 文件如果不存在或文件存在但是文件大小与资源中不一致 重新将文件写出
            if (!fileInfo.Exists || fileInfo.Length != stream.Length)
            {
                byte[] binary = new byte[stream.Length];
                stream.Read(binary, 0, binary.Length);
                File.WriteAllBytes(fileName, binary);
            }
        }

        // 加载写出的文件
        Kernel32.LoadLibrary(fileName);
    }

    [DllImport("SimpleMath", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Addition(double a, double b);
    [DllImport("SimpleMath", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Subtraction(double a, double b);
    [DllImport("SimpleMath", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Multiplication(double a, double b);
    [DllImport("SimpleMath", CallingConvention = CallingConvention.Cdecl)]
    public static extern double Division(double a, double b);
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;

namespace JohnSun.Utility
{
    /// <summary>
    /// 日志输出方式
    /// </summary>
    [Flags]
    public enum LogType
    {
        None = 0,
        File = 1,
        Console = 2,
        All = 3
    }

    /// <summary>
    /// 日志 严重性
    /// </summary>
    [Flags]
    public enum LogLevel
    {
        [Description("None")]
        None = 0,
        [Description("跟踪")]
        Trace = 1,
        [Description("调试")]
        Debug = 2,
        [Description("消息")]
        Info = 4,
        [Description("警告")]
        Warn = 8,
        [Description("错误")]
        Error = 16,
        [Description("致命")]
        Fatal = 32,
        [Description("All")]
        All = 63
    }

    /// <summary>
    /// 日志
    /// </summary>
    public class Logger
    {
        private static readonly Dictionary<LogLevel, string> _logLevelDescription = new Dictionary<LogLevel, string>();

        /// <summary>
        /// 日志等级的描述信息
        /// </summary>
        public static Dictionary<LogLevel, string> LogLevelDescription
        {
            get
            {
                if (_logLevelDescription.Count == 0)
                {
                    Array values = Enum.GetValues(typeof(LogLevel));
                    foreach (object value in values)
                    {
                        LogLevel level = (LogLevel)value;
                        FieldInfo info = typeof(LogLevel).GetField(level.ToString());
                        object[] attrs = info.GetCustomAttributes(false);
                        if (attrs.ToList().Find(attr => attr is DescriptionAttribute) is DescriptionAttribute attribute)
                        {
                            _logLevelDescription[level] = attribute.Description;
                        }
                        else
                        {
                            _logLevelDescription[level] = level.ToString();
                        }
                    }
                }
                return _logLevelDescription;
            }
        }

        /// <summary>
        /// 设置日志记录等级
        /// </summary>
        public static LogLevel LogLevel { get; set; } = LogLevel.All;

        /// <summary>
        /// 日志输出方式
        /// </summary>
        public static LogType LogType { get; set; } = LogType.File;

        private static void LogToConsole(string message, ConsoleColor textColor)
        {
            Console.OutputEncoding = Encoding.UTF8;
            Console.ForegroundColor = textColor;
            Console.WriteLine(message);
            Console.ResetColor();

            Console.OutputEncoding = Encoding.Default;
        }

        private static void LogToConsole(string message, ConsoleColor textColor, ConsoleColor backColor)
        {
            Console.OutputEncoding = Encoding.UTF8;
            Console.ForegroundColor = textColor;
            Console.BackgroundColor = backColor;
            Console.Write(message);
            Console.ResetColor();
            Console.WriteLine();

            Console.OutputEncoding = Encoding.Default;
        }

        static void LogToConsole(LogLevel v, string message)
        {
            switch (v)
            {
                case LogLevel.Trace:
                    LogToConsole(message, ConsoleColor.Black, ConsoleColor.DarkYellow);
                    break;
                case LogLevel.Debug:
                    LogToConsole(message, ConsoleColor.Cyan);
                    break;
                case LogLevel.Info:
                    LogToConsole(message, ConsoleColor.Yellow);
                    break;
                case LogLevel.Warn:
                    LogToConsole(message, ConsoleColor.Red);
                    break;
                case LogLevel.Error:
                    LogToConsole(message, ConsoleColor.Gray, ConsoleColor.Red);
                    break;
                case LogLevel.Fatal:
                    LogToConsole(message, ConsoleColor.Yellow, ConsoleColor.Red);
                    break;
            }
        }

        private static readonly object _sync = new object();

        static void LogToFile(LogLevel v, string message)
        {
            string directory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Logs");
            string path = Path.Combine(directory, DateTime.Now.ToString("yyyy-MM-dd") + ".txt");
            lock (_sync)
            {
                if (!Directory.Exists(directory))
                {
                    Directory.CreateDirectory(directory);
                }
                File.AppendAllText(path, message, Encoding.UTF8);
            }
        }

        static void Log(LogLevel v, string message, Exception exception = null)
        {
            if ((v & LogLevel) == 0)
                return;
            if ((LogType & LogType.Console) != 0)
                LogToConsole(v, $"{DateTime.Now.ToString("HH:mm:ss")} {LogLevelDescription[v]}: {message}{(exception == null ? "" : $"\r\n异常信息：{exception.Message} {exception.InnerException?.Message}\r\n堆栈跟踪：{exception.StackTrace}")}");
            if ((LogType & LogType.File) != 0)
                LogToFile(v, $"{DateTime.Now.ToString("HH:mm:ss")} {LogLevelDescription[v]}: {message}{(exception == null ? "" : $"\r\n异常信息：{exception.Message} {exception.InnerException?.Message}\r\n堆栈跟踪：{exception.StackTrace}")}\r\n");
            LogEvent?.Invoke(v, message, exception);
        }

        /// <summary>
        /// 跟踪
        /// </summary>
        /// <param name="message"></param>
        /// <param name="exception"></param>
        public static void Trace(string message, Exception exception = null) => Log(LogLevel.Trace, message, exception);

        /// <summary>
        /// 调试
        /// </summary>
        /// <param name="message"></param>
        /// <param name="exception"></param>
        public static void Debug(string message, Exception exception = null) => Log(LogLevel.Debug, message, exception);

        /// <summary>
        /// 消息
        /// </summary>
        /// <param name="message"></param>
        /// <param name="exception"></param>
        public static void Info(string message, Exception exception = null) => Log(LogLevel.Info, message, exception);

        /// <summary>
        /// 警告
        /// </summary>
        /// <param name="message"></param>
        /// <param name="exception"></param>
        public static void Warn(string message, Exception exception = null) => Log(LogLevel.Warn, message, exception);

        /// <summary>
        /// 错误
        /// </summary>
        /// <param name="message"></param>
        /// <param name="exception"></param>
        public static void Error(string message, Exception exception = null) => Log(LogLevel.Error, message, exception);

        /// <summary>
        /// 致命
        /// </summary>
        /// <param name="message"></param>
        /// <param name="exception"></param>
        public static void Fatal(string message, Exception exception = null) => Log(LogLevel.Fatal, message, exception);

        /// <summary>
        /// 日志记录
        /// </summary>
        /// <param name="v">日志等级</param>
        /// <param name="message">消息</param>
        public delegate void LogAction(LogLevel v, string message, Exception exception = null);

        /// <summary>
        /// 日志记录事件
        /// </summary>
        public static event LogAction LogEvent;
    }
}