/// <summary>クライアント生成 - ReadWriteスレッド関数</summary>
        private void ReadWriteSharedMemory(object o)
        {
            //while (this.LoopFlg)
            //{
            //// 0ミリ寝る。
            //Thread.Sleep(0);

            // 共有メモリ(サーバ)
            SharedMemory sm = null;

            // スレッドID
            int managedThreadId = Thread.CurrentThread.ManagedThreadId;

            try
            {
                // 共有メモリを生成(256バイト)
                sm = new SharedMemory("my-sm", 256, "my-mtx");

                // マップ
                sm.Map(0, 0);

                while (this.LoopFlg)
                {
                    // 0ミリ寝る。
                    Thread.Sleep(0);

                    // ロック
                    sm.Lock();

                    // 受信(バイト → int)
                    byte[] rcvByte = null;
                    sm.GetMemory(out rcvByte, 0);
                    //int i = BitConverter.ToInt32(rcvByte, 0);
                    short i = BitConverter.ToInt16(rcvByte, 0);

                    // 受信メッセージを表示
                    this.SetResult_Client(
                        string.Format("({0})受信:{1}", managedThreadId, i.ToString()));

                    // 送信(int → バイト)
                    byte[] sndByte = null;

                    // 共有メモリを初期化
                    sm.SetMemory(this.InitBuff(256), 256);

                    // (++i)を送信
                    sndByte = BitConverter.GetBytes(++i);
                    sm.SetMemory(sndByte, sndByte.Length);
                    //sm.SetMemory(sndByte, sndByte.Length);

                    // 送信メッセージを表示
                    this.SetResult_Client(
                        string.Format("({0})送信:{1}", managedThreadId, i.ToString()));

                    // アンロック
                    sm.Unlock();
                }
            }
            catch (Exception ex)
            {
                // エラーを表示
                this.SetResult_Client(
                    string.Format("({0})エラー:{1}", managedThreadId, ex.ToString()));
            }
            finally
            {
                if (sm != null)
                {
                    // 共有メモリをクローズ
                    // アンロック&マネージ・アンマネージリソースの解放
                    sm.Close();// ←コメントアウトするとGC任せになるが、ミューテックスの解放が遅れる!
                    // 二重解放となった場合の例外は内部で潰す。
                }
            }
            //}
        }
        /// <summary>クライアント生成 - Writeスレッド関数</summary>
        private void WriteSharedMemory(object o)
        {
            //while (this.LoopFlg)
            //{
            //    // 0ミリ寝る。
            //    Thread.Sleep(0);

                // 共有メモリ(サーバ)
                SharedMemory sm = null;

                // スレッドID
                int managedThreadId = Thread.CurrentThread.ManagedThreadId;

                try
                {
                    // 共有メモリを生成(256バイト)
                    sm = new SharedMemory("my-sm", 256, "my-mtx");

                    // マップ
                    sm.Map(0, 0);

                    while (this.LoopFlg)
                    {
                        // 0ミリ寝る。
                        Thread.Sleep(0);

                        // ロック
                        sm.Lock();

                        // システム時間、ローカル時間の「Manage SYSTEMTIME構造体」
                        SYSTEMTIME[] csts = new SYSTEMTIME[2];

                        // システム時間
                        CmnWin32.GetSystemTime(out csts[0]);
                        string systemTime =
                            string.Format("{0:0000}/{1:00}/{2:00} {3:00}:{4:00}:{5:00}.{6:000}",
                                csts[0].Year, csts[0].Month, csts[0].Day,
                                csts[0].Hour, csts[0].Minute, csts[0].Second, csts[0].Milliseconds);

                        // ローカル時間
                        CmnWin32.GetLocalTime(out csts[1]);
                        string localTime =
                            string.Format("{0:0000}/{1:00}/{2:00} {3:00}:{4:00}:{5:00}.{6:000}",
                                csts[1].Year, csts[1].Month, csts[1].Day,
                                csts[1].Hour, csts[1].Minute, csts[1].Second, csts[1].Milliseconds);

                        // 共有メモリを初期化
                        sm.SetMemory(CmnClass.InitBuff(256), 256);

                        // マーシャリング(「Unmanage SYSTEMTIME構造体」のバイト表現を取得)

                        //// (1)
                        //SYSTEMTIME cst = new SYSTEMTIME();
                        //int sizeCst = Marshal.SizeOf(cst);
                        //byte[] cstBytes = new byte[sizeCst];
                        //byte[] cstsBytes = new byte[sizeCst * 2];

                        //Array.Copy(CustomMarshaler.StructureToBytes(csts[0]), 0, cstsBytes, 0, sizeCst);
                        //Array.Copy(CustomMarshaler.StructureToBytes(csts[1]), 0, cstsBytes, sizeCst * 1, sizeCst);

                        // (2)
                        byte[] cstsBytes = CustomMarshaler.StructuresToBytes(new object[] { csts[0], csts[1] }, 2);

                        // 共有メモリへ書き込む。
                        sm.SetMemory(cstsBytes, cstsBytes.Length);

                        // 送信メッセージを表示
                        this.SetResult_Client(
                            string.Format("({0})送信:{1}", managedThreadId,
                            "\r\nsystemTime:" + systemTime + "\r\nlocalTime:" + localTime));

                        // アンロック
                        sm.Unlock();
                    }
                }
                catch (Exception ex)
                {
                    // エラーを表示
                    this.SetResult_Client(
                        string.Format("({0})エラー:{1}", managedThreadId, ex.ToString()));
                }
                finally
                {
                    if (sm != null)
                    {
                        // 共有メモリをクローズ
                        // アンロック&マネージ・アンマネージリソースの解放
                        sm.Close();// ←コメントアウトするとGC任せになるが、ミューテックスの解放が遅れる!
                        // 二重解放となった場合の例外は内部で潰す。
                    }
                }
            //}
        }