Beispiel #1
0
        /// <summary>コンストラクタ</summary>
        /// <param name="dstEventClass">送信先イベント区分</param>
        /// <param name="dstFuncID">送信先機能ID(最大36文字)</param>
        /// <param name="srcEventClass">送信元イベント区分</param>
        /// <param name="srcFuncID">送信元機能ID(最大36文字)</param>
        /// <param name="srcPipeName">送信元 名前付きパイプ名(最大36文字)</param>
        /// <param name="dataLength">データ部のバイト長</param>
        public AsyncEventHeader(
            AsyncEventEnum.EventClass dstEventClass, string dstFuncID,
            AsyncEventEnum.EventClass srcEventClass, string srcFuncID,
            string srcPipeName, uint dataLength)
        {
            // 送信先イベント区分
            this.DstEventClass = (int)dstEventClass;

            // 送信先機能ID
            this.DstFuncID = new char[36];
            this.DstFuncID = dstFuncID.PadRight(36, ' ').ToCharArray(0, 36);

            // 送信元イベント区分
            this.SrcEventClass = (int)srcEventClass;

            // 送信元機能ID
            this.SrcFuncID = new char[36];
            this.SrcFuncID = srcFuncID.PadRight(36, ' ').ToCharArray(0, 36);

            // 送信元 名前付きパイプ名
            this.SrcPipeName = new char[36];
            this.SrcPipeName = srcPipeName.PadRight(36, ' ').ToCharArray(0, 36);

            // データ部のバイト長
            this.DataLength = dataLength;
        }
        /// <summary>非同期イベント通知</summary>
        /// <param name="dstEventClass">送信先イベント区分(最大36文字)</param>
        /// <param name="dstFuncID">送信先機能ID(最大36文字)</param>
        /// <param name="srcEventClass">送信元イベント区分(最大36文字)</param>
        /// <param name="srcFuncID">送信元機能ID(最大36文字)</param>
        /// <param name="dstPipeName">送信先 名前付きパイプ名</param>
        /// <param name="srcPipeName">送信元 名前付きパイプ名</param>
        /// <param name="dataLength">データ部のバイト長</param>
        /// <param name="bodyBytes">データ部のバイト表現</param>
        /// <returns>
        /// ・成功:true
        /// ・失敗:false(名前付きパイプ クライアントが見つからない)
        /// </returns>
        /// <remarks>スレッド セーフ</remarks>
        public static bool SendAsyncEvent(
            AsyncEventEnum.EventClass dstEventClass, string dstFuncID,
            AsyncEventEnum.EventClass srcEventClass, string srcFuncID,
            string dstPipeName, string srcPipeName,
            uint dataLength, byte[] bodyBytes)
        {
            lock (AsyncEventFx._lock) // staticなのでロックする。
            {
                if (AsyncEventFx.NPCS.ContainsKey(dstPipeName))
                {
                    // 名前付きパイプ クライアントを取得
                    NamedPipeClient npc = AsyncEventFx.NPCS[dstPipeName];

                    // ヘッダ部のバイト表現を生成

                    // ヘッダ部を生成
                    AsyncEventHeader aeh = new AsyncEventHeader(
                        dstEventClass, dstFuncID,
                        srcEventClass, srcFuncID,
                        srcPipeName, dataLength);

                    // ヘッダ部のマーシャリング
                    byte[] headerBytes = CustomMarshaler.StructureToBytes(aeh);

                    // ヘッダ・データ部のバイト表現をマージ
                    byte[] bytes = new byte[headerBytes.Length + bodyBytes.Length];
                    Array.Copy(headerBytes, bytes, headerBytes.Length);
                    Array.Copy(bodyBytes, 0, bytes, headerBytes.Length, bodyBytes.Length);

                    // Threadを生成してThread関数(SendData)を実行
                    Thread th = new Thread(npc.SendData);
                    th.Start(bytes);

                    return(true);
                }
                else
                {
                    return(false);
                }
            }
        }
        /// <summary>コンストラクタ</summary>
        /// <param name="eventClass">
        /// イベント区分
        /// ・スレッド関数へ    :AsyncEventEnum.EventClass.ThreadPool
        /// ・スレッドプールへ  :AsyncEventEnum.EventClass.WinForm
        /// ・WinFormの結果表示 :AsyncEventEnum.EventClass.WinForm
        /// ・WPFの結果表示     :AsyncEventEnum.EventClass.WPF
        /// </param>
        /// <param name="funcID">機能ID(最大36文字)</param>
        /// <param name="control">
        /// UIコントロール
        /// ・Control(WinForm)
        /// ・DependencyObject(WPF)
        /// </param>
        /// <param name="callback">
        /// <コールバック>
        /// ・スレッド関数へ    :System.Threading.ParameterizedThreadStart
        /// ・スレッドプールへ  :System.Threading.WaitCallback
        /// ・WinFormの結果表示 :AsyncEventFx.SetResultDelegate
        /// ・WPFの結果表示     :AsyncEventFx.SetResultDelegate
        /// </param>
        public AsyncEventEntry(
            AsyncEventEnum.EventClass eventClass, string funcID, object control, object callback)
        {
            // イベント区分のチェック
            switch (eventClass)
            {
            case AsyncEventEnum.EventClass.Thread:
                break;

            case AsyncEventEnum.EventClass.ThreadPool:
                break;

            case AsyncEventEnum.EventClass.WinForm:
                break;

            case AsyncEventEnum.EventClass.WPF:
                break;

            default:
                // イベント区分エラー
                throw new FrameworkException(
                          FrameworkExceptionMessage.ASYNC_EVENT_ENTRY_CHECK_ERROR[0],
                          FrameworkExceptionMessage.ASYNC_EVENT_ENTRY_CHECK_ERROR[1]);
            }

            // イベント区分
            this.EventClass = eventClass;

            // 機能IDのチェック(最大36文字)
            if (funcID.Length <= 36)
            {
                this.FuncID = funcID;
            }
            else
            {
                // 自動切り落とし
                this.FuncID = funcID.Substring(0, 36);
            }

            // イベント区分に対応する
            // UIコントロールであるかのチェック
            if (control != null)
            {
                if (control is Control ||
                    this.EventClass == AsyncEventEnum.EventClass.WinForm)
                {
                    // OK
                }
                else if (control is DependencyObject ||
                         this.EventClass == AsyncEventEnum.EventClass.WPF)
                {
                    // OK
                }
                else
                {
                    // エラー
                    throw new FrameworkException(
                              FrameworkExceptionMessage.ASYNC_EVENT_ENTRY_CONTROL_CHECK_ERROR[0],
                              FrameworkExceptionMessage.ASYNC_EVENT_ENTRY_CONTROL_CHECK_ERROR[1]);
                }

                // UIコントロール
                this.Control = control;
            }

            // イベント区分に対応する
            // コールバックであるかのチェック
            if (callback != null)
            {
                if (callback is System.Threading.ParameterizedThreadStart ||
                    this.EventClass == AsyncEventEnum.EventClass.Thread)
                {
                    // OK:スレッド関数
                }
                else if (callback is System.Threading.WaitCallback ||
                         this.EventClass == AsyncEventEnum.EventClass.ThreadPool)
                {
                    // OK:スレッドプール
                }
                else if (callback is AsyncEventFx.SetResultDelegate ||
                         this.EventClass == AsyncEventEnum.EventClass.WinForm)
                {
                    // OK:WinFormの結果表示
                }
                else if (callback is AsyncEventFx.SetResultDelegate ||
                         this.EventClass == AsyncEventEnum.EventClass.WPF)
                {
                    // OK:WPFの結果表示
                }
                else
                {
                    // エラー(型不正)
                    throw new FrameworkException(
                              FrameworkExceptionMessage.ASYNC_EVENT_ENTRY_CALLBACK_CHECK_ERROR[0],
                              FrameworkExceptionMessage.ASYNC_EVENT_ENTRY_CALLBACK_CHECK_ERROR[1]);
                }

                // コールバック
                this.Callback = callback;
            }
            else
            {
                // エラー(null)
                throw new FrameworkException(
                          FrameworkExceptionMessage.ASYNC_EVENT_ENTRY_CALLBACK_CHECK_ERROR[0],
                          FrameworkExceptionMessage.ASYNC_EVENT_ENTRY_CALLBACK_CHECK_ERROR[1]);
            }
        }