辅助功能性代码，研究和记录代码。

C#下面能产生每秒65535个我无重复ID，但是毫无规则可言。

private static int id = 0;

        private static int serverID = 1;

        /// <summary>
        /// 下面这段代码在一秒内，只能生产 65535 个操过了生产是会重复ID 的
        /// </summary>
        /// <returns></returns>
        public static long getId()
        {
            lock (typeof(string))
            {
                id += 1;
                return (serverID & 0xFFFF) << 48 | (DateTime.Now.CurrentTimeMillis() / 1000L & 0xFFFFFFFF) << 16 | id & 0xFFFF;
            }
        }

======================

C#程序单例模式。某些非web程序，需要验证单例模式，只能开启一个客户端。

目前我晓得的方式调用win32API，

static Mutex mutex;

    /// <summary>
    /// 单例模式
    /// </summary>
    /// <param name="strMutex">系统互斥名,任意设置标识就行</param>
    static public void Singleton(string strMutex = "SzExtensions")
    {
        bool createdNew;
        //系统能够识别有名称的互斥，因此可以使用它禁止应用程序启动两次
        //第二个参数可以设置为产品的名称:Application.ProductName
        //每次启动应用程序，都会验证名称为SingletonWinAppMutex的互斥是否存在
        mutex = new Mutex(true, strMutex, out createdNew);
        //如果已运行，则在前端显示
        //createdNew == false，说明程序已运行
        if (!createdNew)
        {
            Process instance = GetExistProcess();
            //如果程序已经启动，设置为前端显示
            if (instance != null) { SetForegroud(instance); }
            //退出当前程序
            System.Environment.Exit(0);
        }
    }

    /// <summary>
    /// 查看程序是否已经运行
    /// </summary>
    /// <returns></returns>
    static Process GetExistProcess()
    {
        Process currentProcess = Process.GetCurrentProcess();
        foreach (Process process in Process.GetProcessesByName(currentProcess.ProcessName))
        {
            if ((process.Id != currentProcess.Id) &&
                (Assembly.GetExecutingAssembly().Location == currentProcess.MainModule.FileName))
            {
                return process;
            }
        }
        return null;
    }

    /// <summary>
    /// 使程序前端显示
    /// </summary>
    /// <param name="instance"></param>
    static void SetForegroud(Process instance)
    {
        IntPtr mainFormHandle = instance.MainWindowHandle;
        if (mainFormHandle != IntPtr.Zero)
        {
            ShowWindowAsync(mainFormHandle, 1);
            SetForegroundWindow(mainFormHandle);
        }
    }

程序启动的时候创建一个系统互斥量，设置一个互斥量又好名称就可以。防止程序第二次启动。

在开发WPF或者WF程序的时候，为了方便测试需要打印一些临时数据。但是打印是一个非常麻烦的事情，不像控制台程序那样可以直接输出。非常便利。那么我们WPF或者WF程序可不可以以打开控制台输出呢？

网上查询了一下可以调用win32API实现打开控制台。其实也就是打开程序的一个输入和输出流而已。

[DllImport("User32.dll")]
    private static extern bool SetForegroundWindow(IntPtr hWnd);

    [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
    public static extern IntPtr GetForegroundWindow();

    [MethodImpl(MethodImplOptions.ForwardRef), DllImport("user32.dll")]
    private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
    [MethodImpl(MethodImplOptions.ForwardRef), DllImport("kernel32.dll")]
    private static extern bool FreeConsole();
    [MethodImpl(MethodImplOptions.ForwardRef), DllImport("Kernel32.dll")]
    private static extern bool AllocConsole();
    [MethodImpl(MethodImplOptions.ForwardRef), DllImport("user32.dll")]
    private static extern IntPtr GetSystemMenu(IntPtr hWnd, IntPtr bRevert);
    [MethodImpl(MethodImplOptions.ForwardRef), DllImport("user32.dll")]
    private static extern bool ShowWindowAsync(IntPtr hwind, int cmdShow);

    [MethodImpl(MethodImplOptions.ForwardRef), DllImport("user32.dll")]
    private static extern IntPtr RemoveMenu(IntPtr hMenu, uint uPosition, uint uFlags);

    private static string ConsoleTitle = string.Empty;

    private static bool flag_console = false;

    private static System.Timers.Timer Console_Timer;

    /// <summary>
    /// 关闭/隐藏控制台 窗体
    /// </summary>
    static public void Console_Hide()
    {
        if (Console_Timer != null)
        {
            Console_Timer.Stop();
        }
        flag_console = false;
        FreeConsole();
    }

    /// <summary>
    /// 显示控制台,一旦显示就不会再调用第二次
    /// </summary>
    /// <param name="title">显示的标题</param>
    /// <param name="withCloseBox">是否移除关闭按钮，默认值：false 显示</param>
    /// <param name="isShowThreadCount">在控制台显示线程数量，默认值：true 显示</param>
    static public void Console_Show(string title, [MarshalAs(UnmanagedType.U1)] bool withCloseBox, [MarshalAs(UnmanagedType.U1)] bool isShowThreadCount)
    {
        //检测flag_console,防止调用两次
        //直接用win32api
        //顺便移除窗口
        if (!flag_console)
        {
            flag_console = true;
            AllocConsole();
            Console.Title = title;
            if (withCloseBox)
            {
                RemoveMenu();
            }
            if (isShowThreadCount) { ShowThreadCount(title); }
            else { Console.Title = title; }
        }
    }

    /// <summary>
    /// 移除关闭按钮
    /// </summary>
    static void RemoveMenu()
    {
        IntPtr mainFormHandle = GetForegroundWindow();
        RemoveMenu(GetSystemMenu(mainFormHandle, IntPtr.Zero), 0xf060, 0);
    }

    /// <summary>
    /// 在控制台title显示线程量
    /// </summary>
    /// <param name="title"></param>
    public static void ShowThreadCount(string title)
    {
        ConsoleTitle = title;
        Console_Timer = new System.Timers.Timer(200);
        Console_Timer.Elapsed += (obj, e) =>
        {
            int thrads = Process.GetCurrentProcess().Threads.Count;
            int runthreads = 0;
            foreach (ProcessThread item in Process.GetCurrentProcess().Threads) if (item.ThreadState == System.Diagnostics.ThreadState.Running) runthreads++;
            long mem = System.Environment.WorkingSet / 1024 / 1024;
            Console.Title = string.Format("{0} -> 当前内存占用 -> {3} MB -> 当前线程量 -> {1} ->  当前活动线程： -> {2}", ConsoleTitle, thrads, runthreads, mem);
        };
        Console_Timer.Start();
    }

在此加入了，控制台的打开和关闭功能性辅助代码。并且加入了控制台标题查看内存和线程使用情况。

还有一个非常方便的方式打开WPF和WF控制台输入输出流的方式。只能临时使用的办法。那就是右键项目属性，选择更改项目类型，把windows应用程序改为控制台程序。可以实现，WPF和WF程序打开控制输入输出流。

日志辅助========================================

日志辅助线程

/**
 * 
 * @author 失足程序员
 * @Blog http://www.cnblogs.com/ty408/
 * @mail 492794628@qq.com
 * @phone 13882122019
 * 
 */
namespace Sz
{
    /// <summary>
    /// 线程模型
    /// </summary>    
    internal class ThreadModel
    {
        public bool IsStop = false;
        /// <summary>
        /// ID
        /// </summary>
        public int ID;

        static int StaticID = 0;

        public ThreadModel(string name)
        {
            lock (typeof(ThreadModel))
            {
                StaticID++;
            }
            ID = StaticID;
            System.Threading.Thread thread = new System.Threading.Thread(new System.Threading.ThreadStart(Run));
            thread.Name = name;
            thread.IsBackground = true;
            thread.Start();
        }

        /// <summary>
        /// 任务队列
        /// </summary>
        protected System.Collections.Concurrent.ConcurrentQueue<TaskBase> taskQueue = new System.Collections.Concurrent.ConcurrentQueue<TaskBase>();

        /// <summary>
        /// 加入任务
        /// </summary>
        /// <param name="t"></param>
        public virtual void AddTask(TaskBase t)
        {
            taskQueue.Enqueue(t);
            ///防止线程正在阻塞时添加进入了新任务
            are.Set();
        }

        //通知一个或多个正在等待的线程已发生事件
        protected ManualResetEvent are = new ManualResetEvent(false);

        protected virtual void Run()
        {
            while (true)
            {
                while (!taskQueue.IsEmpty)
                {
                    TaskBase t = null;
                    if (!taskQueue.IsEmpty && taskQueue.TryDequeue(out t))
                    {
                        try
                        {
                            t.TaskRun();//执行任务
                            t = null;
                        }
                        catch (Exception ex)
                        {
                            Logger.Error("Thread：<" + Thread.CurrentThread.Name + "> TaskRun <" + t.Name + ">", ex);
                        }
                    }
                }
                are.Reset();
                ///队列为空等待200毫秒继续
                are.WaitOne(200);
            }
        }
    }
}

日志辅助任务执行器

/**
 * 
 * @author 失足程序员
 * @Blog http://www.cnblogs.com/ty408/
 * @mail 492794628@qq.com
 * @phone 13882122019
 * 
 */
namespace Sz
{
    internal abstract class TaskBase
    {
        
        public string Name { get; private set; }

        public TaskBase(string name)
        {
            this.Name = name;
            TempAttribute = new ObjectAttribute();
        }
        public ObjectAttribute TempAttribute { get; set; }

        public abstract void TaskRun();
    }
}

/**
 * 
 * @author 失足程序员
 * @Blog http://www.cnblogs.com/ty408/
 * @mail 492794628@qq.com
 * @phone 13882122019
 * 
 */
namespace Sz
{
    /// <summary>
    /// 日志辅助
    /// </summary>
    public class Logger
    {
        static ThreadModel logConsoleThread = new ThreadModel("Console Log Thread");
        static ThreadModel logFileThread = new ThreadModel("File Log Thread");
        static string loginfoPath = "log/info/";
        static string logErrorPath = "log/error/";

        static Logger()
        {
            if (!Directory.Exists(loginfoPath)) { Directory.CreateDirectory(loginfoPath); }
            if (!Directory.Exists(logErrorPath)) { Directory.CreateDirectory(logErrorPath); }
        }

        #region 日子写入文件辅助任务 class LogTaskFile : TaskBase
        /// <summary>
        /// 日子写入文件辅助任务
        /// </summary>
        class LogTaskFile : TaskBase
        {
            string msg, mathed;
            Exception exce;
            int lineID;
            public LogTaskFile(int lineID, string mathed, string msg, Exception exce)
                : base("File Log Task")
            {
                this.mathed = mathed;
                this.lineID = lineID;
                this.msg = msg;
                this.exce = exce;
            }

            public LogTaskFile(string msg, Exception exce)
                : base("File Log Task")
            {
                this.msg = msg;
                this.exce = exce;
            }

            public override void TaskRun()
            {
                string loginfo = "[" + DateTime.Now.NowString() + mathed.PadRight(5) + "] " + msg;
                DateTime dnow = DateTime.Now;
                string logPath = string.Format("{0}info_{1}{2}{3}.log", loginfoPath, dnow.Year, dnow.Month, dnow.Day);
                if (!mathed.Equals("Error"))
                {
                    System.IO.File.AppendAllText(logPath, loginfo, UTF8Encoding.Default);
                    System.IO.File.AppendAllText(logPath, "
", UTF8Encoding.Default);
                }
                if (exce != null)
                {
                    logPath = string.Format("{0}error_{1}{2}{3}.log", logErrorPath, dnow.Year, dnow.Month, dnow.Day);
                    StringBuilder sb = new StringBuilder();
                    sb.AppendLine(loginfo);
                    sb.AppendLine("----------------------Exception--------------------------");
                    sb.AppendLine(exce.Message);
                    sb.AppendLine(exce.StackTrace);
                    sb.AppendLine("----------------------Exception--------------------------");
                    System.IO.File.AppendAllText(logPath, sb.ToString(), UTF8Encoding.Default);
                    System.IO.File.AppendAllText(logPath, "
", UTF8Encoding.Default);
                }
            }
        }
        #endregion

        #region 日志写入控制台输出 class LogTaskConsole : TaskBase
        /// <summary>
        /// 日志写入控制台输出
        /// </summary>
        class LogTaskConsole : TaskBase
        {
            string msg, mathed;
            Exception exce;
            int lineID;
            public LogTaskConsole(int lineID, string mathed, string msg, Exception exce)
                : base("Console Log Task")
            {
                this.mathed = mathed;
                this.lineID = lineID;
                this.msg = msg;
                this.exce = exce;
            }

            public LogTaskConsole(string msg, Exception exce)
                : base("Console Log Task")
            {
                this.msg = msg;
                this.exce = exce;
            }

            public override void TaskRun()
            {
                string loginfo = "[" + DateTime.Now.NowString() + mathed.PadRight(5) + "] " + msg;
                DateTime dnow = DateTime.Now;
                Console.WriteLine(loginfo);

                if (exce != null)
                {
                    StringBuilder sb = new StringBuilder();
                    sb.AppendLine(loginfo);
                    sb.AppendLine("----------------------Exception--------------------------");
                    sb.AppendLine(exce.Message);
                    sb.AppendLine(exce.StackTrace);
                    sb.AppendLine("----------------------Exception--------------------------");
                    Console.WriteLine(sb.ToString());
                }
            }
        }
        #endregion

        string name;
        public Logger(string name)
        {
            this.name = name;
        }

        static public void Info(string msg)
        {
            AddLog(0, "Info", msg, null);
        }

        static public void Error(string msg)
        {
            Error(msg, null);
        }

        static public void Error(string msg, Exception exception)
        {
            AddLog(0, "Error", msg, exception);
        }

        static void AddLog(int lineID, string mathed, string msg, Exception exception)
        {
            LogTaskConsole logConsole = new LogTaskConsole(lineID, mathed, msg, exception);
            logConsoleThread.AddTask(logConsole);
            LogTaskFile logFile = new LogTaskFile(lineID, mathed, msg, exception);
            logFileThread.AddTask(logFile);
        }
    }
}

自己动手实现日志记录功能，，虽然不比log4net的功能强大，但是没有那么臃肿。能给满足自我需求。