public static Task<ResponseMessage> Execute(this WebClient client,
                                                    RequestMessage requestMessage,
                                                    Uri uri,
                                                    string productName,
                                                    TaskCompletionSource<string> tcs) {
            client.ShouldNotBeNull("client");
            requestMessage.ShouldNotBeNull("requestMessage");

            try {
                var responseText = ResolveRequestSerializer(productName).Serialize(requestMessage).Base64Encode();

                return
                    client
                        .UploadStringTask(uri, "POST", responseText)
                        .ContinueWith(task => {
                                          var responseBytes = task.Result;
                                          return ResolveResponseSerializer(productName).Deserialize(responseBytes.Base64Decode());
                                      });
            }
            catch(Exception ex) {
                if(log.IsErrorEnabled)
                    log.ErrorException("WebClient를 통한 요청이 실패했습니다.", ex);

                throw;
            }
        }
Beispiel #2
0
        public static Task<ResponseMessage> ExecuteTask(this DataServiceClient client,
                                                        RequestMessage requestMessage,
                                                        string productName,
                                                        TaskCompletionSource<byte[]> tcs) {
            client.ShouldNotBeNull("client");
            requestMessage.ShouldNotBeNull("requestMessage");

            try {
                var requestBytes = ResolveRequestSerializer(productName).Serialize(requestMessage);

                var asyncResult = client.BeginExecute(requestBytes, productName, null, null);
                var executeTask = Task.Factory.StartNew(ar => client.EndExecute((IAsyncResult)ar),
                                                        asyncResult,
                                                        TaskCreationOptions.None);

                return
                    executeTask
                        .ContinueWith(task => {
                                          var responseBytes = executeTask.Result;
                                          return ResolveResponseSerializer(productName).Deserialize(responseBytes);
                                      });
            }
            catch(Exception ex) {
                if(log.IsErrorEnabled)
                    log.ErrorException("WCF DataServiceClient를 통한 요청이 실패했습니다.", ex);

                throw;
            }
        }
        public static Task<ResponseMessage> ExecuteTask(this DataService client,
                                                        RequestMessage requestMessage,
                                                        string productName,
                                                        TaskCompletionSource<byte[]> tcs) {
            client.ShouldNotBeNull("client");
            requestMessage.ShouldNotBeNull("requestMessage");

            try {
                var requestBytes = ResolveRequestSerializer(productName).Serialize(requestMessage);

                ExecuteCompletedEventHandler handler = null;
                handler = (sender, e) => EAPCommon.HandleCompletion(tcs, e, () => e.Result, () => client.ExecuteCompleted -= handler);
                client.ExecuteCompleted += handler;

                client.ExecuteAsync(requestBytes, productName, tcs);


                return
                    tcs.Task
                        .ContinueWith(task => ResolveResponseSerializer(productName).Deserialize(task.Result));
            }
            catch(Exception ex) {
                if(log.IsErrorEnabled)
                    log.ErrorException("웹서비스를 통한 요청이 실패했습니다.", ex);

                throw;
            }
        }
Beispiel #4
0
        public static ResponseMessage Execute(this DataServiceClient client, RequestMessage requestMessage, string productName) {
            client.ShouldNotBeNull("client");
            requestMessage.ShouldNotBeNull("requestMessage");

            try {
                var requestBytes = ResolveRequestSerializer(productName).Serialize(requestMessage);
                var responseBytes = client.Execute(requestBytes, productName);

                return ResolveResponseSerializer(productName).Deserialize(responseBytes);
            }
            catch(Exception ex) {
                if(log.IsErrorEnabled)
                    log.ErrorException("WCF DataServiceClient를 통한 요청이 실패했습니다.", ex);

                throw;
            }
        }
        public static ResponseMessage Execute(this WebClient client,
                                              RequestMessage requestMessage,
                                              Uri uri,
                                              string productName) {
            client.ShouldNotBeNull("client");
            requestMessage.ShouldNotBeNull("requestMessage");

            try {
                var responseText = ResolveRequestSerializer(productName).Serialize(requestMessage).Base64Encode();

                var responsesText = client.UploadString(uri, "POST", responseText);

                return ResolveResponseSerializer(productName).Deserialize(responsesText.Base64Decode());
            }
            catch(Exception ex) {
                if(log.IsErrorEnabled)
                    log.ErrorException("WebClient를 통한 요청이 실패했습니다.", ex);

                throw;
            }
        }
Beispiel #6
0
        /// <summary>
        /// <paramref name="requestMessage"/>의 Method 를 서버에서 관련 Query 문장으로 매핑합니다.
        /// </summary>
        public static void LoadQueryStatements(this IDataService dataService, RequestMessage requestMessage) {
            if(IsDebugEnabled)
                log.Debug("요청 메시지의 모든 요청 정보를 서버의 설정 쿼리문으로 매핑합니다... requestMessage.MessageId=[{0}]", requestMessage.MessageId);

            dataService.AssertDataService();
            requestMessage.ShouldNotBeNull("requestMessage");

            var queryProvider = dataService.AdoRepository.QueryProvider;

            // 1. 전체 메시지의 사전 작업
            foreach(var method in requestMessage.PrepareStatements)
                requestMessage.PreQueries.Add(queryProvider.GetQueryString(method, method));

            // 2. 요청 항목 별
            foreach(var requestItem in requestMessage.Items) {
                if(IsDebugEnabled)
                    log.Debug("요청 메소드에 해당하는 실제 Query 문을 로드합니다... requestItem.Method=[{0}]", requestItem.Method);

                foreach(var method in requestItem.PrepareStatements)
                    requestItem.PreQueries.Add(queryProvider.GetQueryString(method, method));

                requestItem.Query = (requestItem.RequestMethod == RequestMethodKind.Method)
                                        ? queryProvider.GetQueryString(requestItem.Method, requestItem.Method)
                                        : requestItem.Method;

                foreach(var method in requestItem.PostscriptStatements)
                    requestItem.PostQueries.Add(queryProvider.GetQueryString(method, method));
            }

            // 3. 전체 메시지의 사후 작업
            foreach(var method in requestMessage.PostscriptStatements)
                requestMessage.PostQueries.Add(queryProvider.GetQueryString(method, method));

            if(IsDebugEnabled)
                log.Debug("요청 메소드에 해당하는 실제 Query 문을 로드했습니다!!!");
        }