C# Uri.ShouldNotBeNull方法代码示例

        /// <summary>
        /// 생성자 ( System.Uri 개체의 AbsoluteUri 속성을 통해 XmlDocument를 생성합니다.
        /// </summary>
        /// <param name="uri"><c>System.Uri</c>개체</param>
        public XmlDoc(Uri uri) {
            uri.ShouldNotBeNull("uri");

            if(IsDebugEnabled)
                log.Debug("Initialize a new instance of XmlDoc with uri=[{0}]", uri);

            Load(uri.AbsolutePath);
        }

        /// <summary>
        /// <see cref="MailMessage"/> 의 본문을 지정된 <see cref="Uri.AbsoluteUri"/>의 컨텐츠로 설정한다.
        /// </summary>
        /// <param name="message">메일 메시지 인스턴스</param>
        /// <param name="uri">본문으로 설정할 내용이 있는 <see cref="Uri"/></param>
        /// <param name="bodyEncoding">본문의 인코딩 방식</param>
        public static void BuildHtmlMessageBody(this MailMessage message, Uri uri, Encoding bodyEncoding = null) {
            message.ShouldNotBeNull("message");
            uri.ShouldNotBeNull("uri");

            if(IsDebugEnabled)
                log.Debug("HTML 형식의 메시지 본문을 빌드합니다... uri=[{0}], bodyEncoding=[{1}]", uri, bodyEncoding);

            try {
                message.IsBodyHtml = true;
                message.Body = HttpTool.GetString(uri.AbsoluteUri, bodyEncoding);
            }
            catch(Exception ex) {
                if(log.IsErrorEnabled) {
                    log.Error("HTML 형식의 메시지 본문을 빌드하는데 실패했습니다!!!");
                    log.Error(ex);
                }

                throw;
            }
        }

        /// <summary>
        /// <paramref name="address"/>의 리소스를 비동기적으로 다운받아 byte array로 반환하는 Task{byte[]}를 빌드합니다.
        /// </summary>
        /// <param name="webClient"><see cref="WebClient"/> 인스턴스</param>
        /// <param name="token">작업 취소를 위한 Token</param>
        /// <param name="address">리소스 위치</param>
        /// <returns></returns>
        public static Task<byte[]> DownloadDataTask(this WebClient webClient, CancellationToken token, Uri address) {
            webClient.ShouldNotBeNull("webClient");
            token.ShouldNotBeNull("token");
            address.ShouldNotBeNull("address");

            if(IsDebugEnabled)
                log.Debug("WebClient를 이용하여 지정된 주소로부터 리소스를 비동기 방식으로 다운받습니다... address=[{0}]", address.AbsoluteUri);

            var tcs = new TaskCompletionSource<byte[]>(address);
            token.Register(webClient.CancelAsync);

            // 비동기 완료 시의 처리를 정의합니다.
            DownloadDataCompletedEventHandler handler = null;
            handler =
                (sender, args) =>
                EventAsyncPattern.HandleCompletion(tcs, args, () => args.Result, () => webClient.DownloadDataCompleted -= handler);
            webClient.DownloadDataCompleted += handler;

            try {
                webClient.DownloadDataAsync(address, tcs);
            }
            catch(Exception ex) {
                if(log.IsWarnEnabled) {
                    log.Warn("WebClient를 이용하여 리소스 Data를 비동기적으로 다운받는데 실패했습니다. address=[{0}]", address.AbsoluteUri);
                    log.Warn(ex);
                }

                webClient.DownloadDataCompleted -= handler;
                tcs.TrySetException(ex);
            }

            var result = tcs.Task;

            if(result.IsCompleted)
                result = result.ContinueWith(antecedent => DecompressByContentEncoding(webClient, antecedent.Result),
                                             TaskContinuationOptions.ExecuteSynchronously);
            return result;
        }

        /// <summary>
        /// HttpWebRequest를 빌드합니다. 압축된 응답스트림을 받을 수 있도록 요청헤더에 gzip 가능을 표시합니다.
        /// </summary>
        /// <param name="uri"></param>
        /// <returns></returns>
        protected virtual HttpWebRequest CreateHttpRequestCore(Uri uri) {
            uri.ShouldNotBeNull("uri");

            if(IsDebugEnabled)
                log.Debug("HttpWebRequest를 생성합니다. AbsoluteUri=[{0}]", uri.AbsoluteUri);

            var request = (HttpWebRequest)WebRequest.Create(uri);

#if !SILVERLIGHT
            request.Headers[HeaderAcceptEncoding] = "gzip,deflate";
            // request.Headers.Add(HeaderAcceptEncoding, "gzip,deflate");
            //request.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;
            request.AllowAutoRedirect = true;
            request.AllowWriteStreamBuffering = true;
            request.KeepAlive = true;
#endif

            // request.MaximumAutomaticRedirections = 5;
            // request.MaximumResponseHeadersLength = 4096;
            // request.ReadWriteTimeout = 1000;
            // request.Timeout = 30000;

            return request;
        }

        /// <summary>
        /// <paramref name="address"/>에 <paramref name="data"/> 문자열을 전송합니다. (HTTP나 FTP나 같습니다)
        /// </summary>
        /// <param name="webClient"><see cref="WebClient"/> 인스턴스</param>
        /// <param name="address">전송할 주소</param>
        /// <param name="method">전송 방법 (HTTP는 POST, FTP는 STOR)</param>
        /// <param name="data">전송할 문자열</param>
        /// <returns></returns>
        public static Task<string> UploadStringTask(this WebClient webClient, Uri address, string method, string data) {
            webClient.ShouldNotBeNull("webClient");
            address.ShouldNotBeNull("address");
            // data.ShouldNotBeEmpty("data");

            if(IsDebugEnabled)
                log.Debug("지정된 주소에 문자열을 비동기 Upload합니다... address=[{0}], method=[{1}], data=[{2}]",
                          address.AbsoluteUri, method, data.EllipsisChar(255));

            var tcs = new TaskCompletionSource<string>(address);

            UploadStringCompletedEventHandler handler = null;
            handler =
                (s, e) => EventAsyncPattern.HandleCompletion(tcs, e, () => e.Result, () => webClient.UploadStringCompleted -= handler);
            webClient.UploadStringCompleted += handler;

            try {
                webClient.UploadStringAsync(address, method, data, tcs);
            }
            catch(Exception ex) {
                if(log.IsWarnEnabled) {
                    log.Warn("WebClient를 이용하여 문자열을 비동기 Upload 하는데 실패했습니다. address=[{0}]", address.AbsoluteUri);
                    log.Warn(ex);
                }

                webClient.UploadStringCompleted -= handler;
                tcs.TrySetException(ex);
            }
            return tcs.Task;
        }

        /// <summary>
        /// <paramref name="address"/>에 <paramref name="filename"/>의 파일을 전송합니다. (HTTP나 FTP나 같습니다)
        /// </summary>
        /// <param name="webClient"><see cref="WebClient"/> 인스턴스</param>
        /// <param name="address">전송할 주소</param>
        /// <param name="method">전송 방법 (HTTP는 POST, FTP는 STOR)</param>
        /// <param name="filename">전송할 파일의 전체경로</param>
        /// <returns></returns>
        public static Task<byte[]> UploadFileTask(this WebClient webClient, Uri address, string method, string filename) {
            webClient.ShouldNotBeNull("webClient");
            address.ShouldNotBeNull("address");
            filename.ShouldNotBeWhiteSpace("filename");
            Guard.Assert<FileNotFoundException>(File.Exists(filename), "File not found. filename=[{0}]", filename);

            if(IsDebugEnabled)
                log.Debug("지정된 주소에 파일을 비동기 방식으로 Upload합니다... address=[{0}], method=[{1}], filename=[{2}]", address.AbsoluteUri, method,
                          filename);

            var tcs = new TaskCompletionSource<byte[]>(address);

            UploadFileCompletedEventHandler handler = null;
            handler =
                (s, e) => EventAsyncPattern.HandleCompletion(tcs, e, () => e.Result, () => webClient.UploadFileCompleted -= handler);
            webClient.UploadFileCompleted += handler;

            try {
                webClient.UploadFileAsync(address, method, filename, tcs);
            }
            catch(Exception ex) {
                if(log.IsWarnEnabled) {
                    log.Warn("WebClient를 이용하여 파일을 비동기 방식 Upload에 실패했습니다. address=[{0}]" + address.AbsoluteUri);
                    log.Warn(ex);
                }

                webClient.UploadFileCompleted -= handler;
                tcs.TrySetException(ex);
            }
            return tcs.Task;
        }

        /// <summary>
        /// <paramref name="address"/>에 <paramref name="data"/>를 비동기적으로 전송합니다.
        /// </summary>
        /// <param name="webClient"></param>
        /// <param name="address">데이타를 전송할 주소</param>
        /// <param name="method">데이타 전송 방법 (HTTP는 POST, FTP는 STOR)</param>
        /// <param name="data">전송할 데이타</param>
        /// <returns></returns>
        public static Task<byte[]> UploadDataTask(this WebClient webClient, Uri address, string method, byte[] data) {
            webClient.ShouldNotBeNull("webClient");
            address.ShouldNotBeNull("address");
            data.ShouldNotBeNull("data");

            if(IsDebugEnabled)
                log.Debug("지정된 주소에 데이타를 비동기 방식으로 전송합니다... address=[{0}], method=[{1}]", address.AbsoluteUri, method);

            var tcs = new TaskCompletionSource<byte[]>(address);

            UploadDataCompletedEventHandler handler = null;
            handler =
                (s, e) => EventAsyncPattern.HandleCompletion(tcs, e, () => e.Result, () => webClient.UploadDataCompleted -= handler);
            webClient.UploadDataCompleted += handler;

            try {
                webClient.UploadDataAsync(address, method ?? "POST", data, tcs);
            }
            catch(Exception ex) {
                if(log.IsWarnEnabled) {
                    log.Warn("WebClient를 이용하여 데이타를 비동기 전송에 실패했습니다. address=[{0}]" + address.AbsoluteUri);
                    log.Warn(ex);
                }

                webClient.UploadDataCompleted -= handler;
                tcs.TrySetException(ex);
            }
            return tcs.Task;
        }

        /// <summary>
        /// <paramref name="address"/>에 비동기적으로 data를 전송하기 위한 쓰기용 Stream을 반환합니다.
        /// </summary>
        /// <param name="webClient">WebClient 인스턴스</param>
        /// <param name="token">작업 취소를 위한 Token</param>
        /// <param name="address">리소스의 주소</param>
        /// <param name="method">전송 방법 : Http인 경우는 POST, FTP인 경우는 STOR입니다.</param>
        /// <returns></returns>
        public static Task<Stream> OpenWriteTask(this WebClient webClient, CancellationToken token, Uri address, string method) {
            webClient.ShouldNotBeNull("webClient");
            token.ShouldNotBeNull("token");
            address.ShouldNotBeNull("address");

            if(IsDebugEnabled)
                log.Debug("지정된 주소에 데이타 쓰기용 Stream을 엽니다... address=[{0}], method=[{1}]", address.AbsoluteUri, method);


            var tcs = new TaskCompletionSource<Stream>(address);
            token.Register(webClient.CancelAsync);

            OpenWriteCompletedEventHandler handler = null;
            handler =
                (s, e) => EventAsyncPattern.HandleCompletion(tcs, e, () => e.Result, () => webClient.OpenWriteCompleted -= handler);
            webClient.OpenWriteCompleted += handler;

            try {
                webClient.OpenWriteAsync(address, method, tcs);
            }
            catch(Exception ex) {
                if(log.IsWarnEnabled) {
                    log.Warn("WebClient를 이용하여 데이타를 전송하기 위해 쓰기용 Stream을 오픈하는데 실패했습니다. address=[{0}]", address.AbsoluteUri);
                    log.Warn(ex);
                }

                webClient.OpenWriteCompleted -= handler;
                tcs.TrySetException(ex);
            }

            return tcs.Task;
        }

        /// <summary>
        /// <paramref name="address"/>의 리소스 정보를 읽기 위해 <see cref="Stream"/>을 비동기적으로 엽니다.
        /// </summary>
        /// <param name="webClient">WebClient 인스턴스</param>
        /// <param name="token">작업 취소를 위한 Token</param>
        /// <param name="address">리소스의 주소</param>
        /// <returns></returns>
        public static Task<Stream> OpenReadTask(this WebClient webClient, CancellationToken token, Uri address) {
            webClient.ShouldNotBeNull("webClient");
            address.ShouldNotBeNull("address");

            if(IsDebugEnabled)
                log.Debug("지정된 주소로부터 리소스를 비동기 방식으로 다운로드 받아 Stream으로 변환합니다... address=[{0}]", address.AbsoluteUri);

            // NOTE: 압축 통신시 응답 정보가 압축되어 있을 경우, 압축해제해서 결과를 반환해야 한다. 그래서 DownloadDataTask를 사용한다.
            //
#if !SILVERLIGHT
            return
                DownloadDataTask(webClient, token, address)
                    .ContinueWith(antecedent => antecedent.Result.ToStream(),
                                  TaskContinuationOptions.ExecuteSynchronously);
#else
			return OpenReadTaskInternal(webClient, token, address);
#endif
        }

        /// <summary>
        /// 지정된 Uri로부터, 리소스를 문자열로 비동기적으로 다운 받습니다. 
        /// 인코딩 문제가 있을 때에는 <see cref="DownloadDataTask(System.Net.WebClient,System.Uri)"/>를 이용하여 Encoding을 직접 설정해 주시기 바랍니다.
        /// </summary>
        /// <param name="webClient"><see cref="WebClient"/> 인스턴스</param>
        /// <param name="token">작업 취소를 위한 Token</param>
        /// <param name="address">리소스 위치</param>
        /// <returns></returns>
        public static Task<string> DownloadStringTask(this WebClient webClient, CancellationToken token, Uri address) {
            webClient.ShouldNotBeNull("webClient");
            token.ShouldNotBeNull("token");
            address.ShouldNotBeNull("address");

            if(IsDebugEnabled)
                log.Debug("WebClient로 지정된 주소로부터 비동기적으로 문자열을 다운받습니다... address=[{0}]", address.AbsoluteUri);

            // NOTE: 압축 통신시 응답 정보가 압축되어 있을 경우, 압축해제해서 결과를 반환해야 한다. 그래서 DownloadDataTask를 사용한다.
            //
#if !SILVERLIGHT
            return
                DownloadDataTask(webClient, token, address)
                    .ContinueWith(antecedent => antecedent.Result.ToText(),
                                  TaskContinuationOptions.ExecuteSynchronously);
#else
			return DownloadStringTaskInternal(webClient, CancellationToken.None, address);
#endif
        }

        /// <summary>
        /// <paramref name="address"/>의 리소스 정보를 비동기적으로 다운받아 파일로 저장합니다.
        /// </summary>
        /// <param name="webClient"></param>
        /// <param name="token">작업 취소용 Token</param>
        /// <param name="address">다운 받을 리소스의 주소</param>
        /// <param name="filename">다운로드 리소스를 저장할 로컬 파일명</param>
        /// <returns></returns>
        public static Task DownloadFileTask(this WebClient webClient, CancellationToken token, Uri address, string filename) {
            webClient.ShouldNotBeNull("webClient");
            token.ShouldNotBeNull("token");
            address.ShouldNotBeNull("address");
            filename.ShouldNotBeWhiteSpace("filename");

            if(IsDebugEnabled)
                log.Debug("WebClient를 이용하여 지정된 주소의 리소스를 비동기적으로 다운받아 파일로 저장합니다... address=[{0}], filename=[{1}]",
                          address.AbsoluteUri, filename);


            // NOTE: 압축 통신을 대비해서, Byte 통신 후, 저장한다.
            //
            return
                DownloadDataTask(webClient, token, address)
                    .ContinueWith(antecedent => FileAsync.WriteAllBytes(filename, antecedent.Result),
                                  TaskContinuationOptions.ExecuteSynchronously);
        }