2 // System.Net.WebClient
5 // Lawrence Pit (loz@cable.a2000.nl)
6 // Gonzalo Paniagua Javier (gonzalo@ximian.com)
7 // Atsushi Enomoto (atsushi@ximian.com)
8 // Miguel de Icaza (miguel@ximian.com)
9 // Stephane Delcroix (sdelcroix@novell.com)
11 // Copyright 2003 Ximian, Inc. (http://www.ximian.com)
12 // Copyright 2006, 2008 Novell, Inc. (http://www.novell.com)
15 // Permission is hereby granted, free of charge, to any person obtaining
16 // a copy of this software and associated documentation files (the
17 // "Software"), to deal in the Software without restriction, including
18 // without limitation the rights to use, copy, modify, merge, publish,
19 // distribute, sublicense, and/or sell copies of the Software, and to
20 // permit persons to whom the Software is furnished to do so, subject to
21 // the following conditions:
23 // The above copyright notice and this permission notice shall be
24 // included in all copies or substantial portions of the Software.
26 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
30 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
31 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
32 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35 // Notes on CancelAsync and Async methods:
37 // WebClient.CancelAsync is implemented by calling Thread.Interrupt
38 // in our helper thread. The various async methods have to cancel
39 // any ongoing requests by calling request.Abort () at that point.
40 // In a few places (UploadDataCore, UploadValuesCore,
41 // UploadFileCore) we catch the ThreadInterruptedException and
42 // abort the request there.
44 // Higher level routines (the async callbacks) also need to catch
45 // the exception and raise the OnXXXXCompleted events there with
46 // the "canceled" flag set to true.
48 // In a few other places where these helper routines are not used
49 // (OpenReadAsync for example) catching the ThreadAbortException
50 // also must abort the request.
52 // The Async methods currently differ in their implementation from
53 // the .NET implementation in that we manually catch any other
54 // exceptions and correctly raise the OnXXXXCompleted passing the
55 // Exception that caused the problem. The .NET implementation
56 // does not seem to have a mechanism to flag errors that happen
57 // during downloads though. We do this because we still need to
58 // catch the exception on these helper threads, or we would
59 // otherwise kill the application (on the 2.x profile, uncaught
60 // exceptions in threads terminate the application).
63 using System.Security;
64 using System.Collections.Specialized;
65 using System.ComponentModel;
67 using System.Runtime.InteropServices;
68 using System.Runtime.Serialization;
70 using System.Threading;
71 using System.Net.Cache;
76 public class WebClient
78 private delegate void ProgressChangedDelegate (long read, long length, object state);
80 // static readonly string urlEncodedCType = "application/x-www-form-urlencoded";
81 // static byte [] hexBytes;
82 // ICredentials credentials;
83 // WebHeaderCollection headers;
84 // WebHeaderCollection responseHeaders;
87 // NameValueCollection queryString;
90 Encoding encoding = Encoding.UTF8;
94 // static WebClient ()
96 // hexBytes = new byte [16];
98 // for (int i = '0'; i <= '9'; i++, index++)
99 // hexBytes [index] = (byte) i;
101 // for (int i = 'A'; i <= 'F'; i++, index++)
102 // hexBytes [index] = (byte) i;
105 // public WebClient ()
111 public string BaseAddress {
113 if (baseString == null) {
114 if (baseAddress == null)
118 baseString = baseAddress.ToString ();
123 if (value == null || value == "") {
126 baseAddress = new Uri (value);
132 // static Exception GetMustImplement ()
134 // return new NotImplementedException ();
138 // public RequestCachePolicy CachePolicy
141 // throw GetMustImplement ();
144 // throw GetMustImplement ();
149 // public bool UseDefaultCredentials
152 // throw GetMustImplement ();
155 // throw GetMustImplement ();
160 // public ICredentials Credentials {
161 // get { return credentials; }
162 // set { credentials = value; }
165 // public WebHeaderCollection Headers {
167 // if (headers == null)
168 // headers = new WebHeaderCollection ();
172 // set { headers = value; }
175 // public NameValueCollection QueryString {
177 // if (queryString == null)
178 // queryString = new NameValueCollection ();
180 // return queryString;
182 // set { queryString = value; }
185 // public WebHeaderCollection ResponseHeaders {
186 // get { return responseHeaders; }
190 // public Encoding Encoding {
191 // get { return encoding; }
193 // if (value == null)
194 // throw new ArgumentNullException ("value");
199 // public IWebProxy Proxy {
200 // get { return proxy; }
201 // set { proxy = value; }
206 get { return is_busy; }
214 throw new NotSupportedException ("WebClient does not support conccurent I/O operations.");
227 // public byte [] DownloadData (string address)
230 // if (address == null)
231 // throw new ArgumentNullException ("address");
234 // return DownloadData (CreateUri (address));
240 // byte [] DownloadData (Uri address)
243 // if (address == null)
244 // throw new ArgumentNullException ("address");
250 // return DownloadDataCore (address, null);
256 Stream DownloadDataCore (Uri address, object userToken)
258 WebRequest request = null;
261 request = SetupRequest (address, "GET");
262 //WebResponse response = request.GetResponse ();
263 IAsyncResult asyncresult = request.BeginGetResponse (null, userToken);
264 asyncresult.AsyncWaitHandle.WaitOne ();
265 WebResponse response = request.EndGetResponse (asyncresult);
266 Stream st = ProcessResponse (response);
267 return ReadAll (st, (int) st.Length, userToken);
268 } catch (ThreadInterruptedException){
272 } catch (Exception ex) {
273 throw new WebException ("An error occurred " +
274 "performing a WebClient request.", ex);
280 // public void DownloadFile (string address, string fileName)
283 // if (address == null)
284 // throw new ArgumentNullException ("address");
287 // DownloadFile (CreateUri (address), fileName);
293 // void DownloadFile (Uri address, string fileName)
296 // if (address == null)
297 // throw new ArgumentNullException ("address");
298 // if (fileName == null)
299 // throw new ArgumentNullException ("fileName");
305 // DownloadFileCore (address, fileName, null);
306 // } catch (Exception ex) {
307 // throw new WebException ("An error occurred " +
308 // "performing a WebClient request.", ex);
314 // void DownloadFileCore (Uri address, string fileName, object userToken)
316 // WebRequest request = null;
318 // using (FileStream f = new FileStream (fileName, FileMode.Create)) {
320 // request = SetupRequest (address);
321 // WebResponse response = request.GetResponse ();
322 // Stream st = ProcessResponse (response);
324 // int cLength = (int) response.ContentLength;
325 // int length = (cLength <= -1 || cLength > 32*1024) ? 32*1024 : cLength;
326 // byte [] buffer = new byte [length];
330 // long notify_total = 0;
332 // while ((nread = st.Read (buffer, 0, length)) != 0){
335 // notify_total += nread;
336 // OnDownloadProgressChanged (
337 // new DownloadProgressChangedEventArgs (notify_total, response.ContentLength, userToken));
341 // f.Write (buffer, 0, nread);
343 // } catch (ThreadInterruptedException){
344 // if (request != null)
353 // public Stream OpenRead (string address)
356 // if (address == null)
357 // throw new ArgumentNullException ("address");
360 // return OpenRead (CreateUri (address));
366 // Stream OpenRead (Uri address)
369 // if (address == null)
370 // throw new ArgumentNullException ("address");
373 // WebRequest request = null;
377 // request = SetupRequest (address);
378 // WebResponse response = request.GetResponse ();
379 // return ProcessResponse (response);
380 // } catch (Exception ex) {
381 // throw new WebException ("An error occurred " +
382 // "performing a WebClient request.", ex);
390 // public Stream OpenWrite (string address)
393 // if (address == null)
394 // throw new ArgumentNullException ("address");
397 // return OpenWrite (CreateUri (address));
400 // public Stream OpenWrite (string address, string method)
403 // if (address == null)
404 // throw new ArgumentNullException ("address");
407 // return OpenWrite (CreateUri (address), method);
413 // Stream OpenWrite (Uri address)
415 // return OpenWrite (address, (string) null);
421 // Stream OpenWrite (Uri address, string method)
424 // if (address == null)
425 // throw new ArgumentNullException ("address");
431 // WebRequest request = SetupRequest (address, method);
432 // return request.GetRequestStream ();
433 // } catch (Exception ex) {
434 // throw new WebException ("An error occurred " +
435 // "performing a WebClient request.", ex);
441 private string DetermineMethod (Uri address, string method)
446 if (address.Scheme == Uri.UriSchemeFtp)
453 // public byte [] UploadData (string address, byte [] data)
456 // if (address == null)
457 // throw new ArgumentNullException ("address");
460 // return UploadData (CreateUri (address), data);
463 // public byte [] UploadData (string address, string method, byte [] data)
466 // if (address == null)
467 // throw new ArgumentNullException ("address");
470 // return UploadData (CreateUri (address), method, data);
476 // byte [] UploadData (Uri address, byte [] data)
478 // return UploadData (address, (string) null, data);
484 // byte [] UploadData (Uri address, string method, byte [] data)
487 // if (address == null)
488 // throw new ArgumentNullException ("address");
490 // throw new ArgumentNullException ("data");
496 // return UploadDataCore (address, method, data, null);
497 // } catch (Exception ex) {
498 // throw new WebException ("An error occurred " +
499 // "performing a WebClient request.", ex);
505 // byte [] UploadDataCore (Uri address, string method, byte [] data, object userToken)
508 // if (address == null)
509 // throw new ArgumentNullException ("address");
511 // throw new ArgumentNullException ("data");
514 // WebRequest request = SetupRequest (address, method);
516 // int contentLength = data.Length;
517 // request.ContentLength = contentLength;
518 // using (Stream stream = request.GetRequestStream ()) {
519 // stream.Write (data, 0, contentLength);
522 // WebResponse response = request.GetResponse ();
523 // Stream st = ProcessResponse (response);
524 // return ReadAll (st, (int) response.ContentLength, userToken);
525 // } catch (ThreadInterruptedException){
526 // if (request != null)
534 // public byte [] UploadFile (string address, string fileName)
537 // if (address == null)
538 // throw new ArgumentNullException ("address");
541 // return UploadFile (CreateUri (address), fileName);
547 // byte [] UploadFile (Uri address, string fileName)
549 // return UploadFile (address, (string) null, fileName);
552 // public byte [] UploadFile (string address, string method, string fileName)
554 // return UploadFile (CreateUri (address), method, fileName);
560 // byte [] UploadFile (Uri address, string method, string fileName)
563 // if (address == null)
564 // throw new ArgumentNullException ("address");
565 // if (fileName == null)
566 // throw new ArgumentNullException ("fileName");
572 // return UploadFileCore (address, method, fileName, null);
573 // } catch (Exception ex) {
574 // throw new WebException ("An error occurred " +
575 // "performing a WebClient request.", ex);
581 // byte [] UploadFileCore (Uri address, string method, string fileName, object userToken)
584 // if (address == null)
585 // throw new ArgumentNullException ("address");
588 // string fileCType = Headers ["Content-Type"];
589 // if (fileCType != null) {
590 // string lower = fileCType.ToLower ();
591 // if (lower.StartsWith ("multipart/"))
592 // throw new WebException ("Content-Type cannot be set to a multipart" +
593 // " type for this request.");
595 // fileCType = "application/octet-stream";
598 // string boundary = "------------" + DateTime.Now.Ticks.ToString ("x");
599 // Headers ["Content-Type"] = String.Format ("multipart/form-data; boundary={0}", boundary);
600 // Stream reqStream = null;
601 // Stream fStream = null;
602 // byte [] resultBytes = null;
604 // fileName = Path.GetFullPath (fileName);
606 // WebRequest request = null;
608 // fStream = File.OpenRead (fileName);
609 // request = SetupRequest (address, method);
610 // reqStream = request.GetRequestStream ();
611 // byte [] realBoundary = Encoding.ASCII.GetBytes ("--" + boundary + "\r\n");
612 // reqStream.Write (realBoundary, 0, realBoundary.Length);
613 // string partHeaders = String.Format ("Content-Disposition: form-data; " +
614 // "name=\"file\"; filename=\"{0}\"\r\n" +
615 // "Content-Type: {1}\r\n\r\n",
616 // Path.GetFileName (fileName), fileCType);
618 // byte [] partHeadersBytes = Encoding.UTF8.GetBytes (partHeaders);
619 // reqStream.Write (partHeadersBytes, 0, partHeadersBytes.Length);
621 // byte [] buffer = new byte [4096];
622 // while ((nread = fStream.Read (buffer, 0, 4096)) != 0)
623 // reqStream.Write (buffer, 0, nread);
625 // reqStream.WriteByte ((byte) '\r');
626 // reqStream.WriteByte ((byte) '\n');
627 // reqStream.Write (realBoundary, 0, realBoundary.Length);
628 // reqStream.Close ();
630 // WebResponse response = request.GetResponse ();
631 // Stream st = ProcessResponse (response);
632 // resultBytes = ReadAll (st, (int) response.ContentLength, userToken);
633 // } catch (ThreadInterruptedException){
634 // if (request != null)
638 // if (fStream != null)
641 // if (reqStream != null)
642 // reqStream.Close ();
645 // return resultBytes;
648 // public byte[] UploadValues (string address, NameValueCollection data)
651 // if (address == null)
652 // throw new ArgumentNullException ("address");
655 // return UploadValues (CreateUri (address), data);
658 // public byte[] UploadValues (string address, string method, NameValueCollection data)
661 // if (address == null)
662 // throw new ArgumentNullException ("address");
665 // return UploadValues (CreateUri (address), method, data);
671 // byte[] UploadValues (Uri address, NameValueCollection data)
673 // return UploadValues (address, (string) null, data);
679 // byte[] UploadValues (Uri address, string method, NameValueCollection data)
682 // if (address == null)
683 // throw new ArgumentNullException ("address");
685 // throw new ArgumentNullException ("data");
691 // return UploadValuesCore (address, method, data, null);
692 // } catch (Exception ex) {
693 // throw new WebException ("An error occurred " +
694 // "performing a WebClient request.", ex);
700 // byte[] UploadValuesCore (Uri uri, string method, NameValueCollection data, object userToken)
704 // throw new ArgumentNullException ("data");
707 // string cType = Headers ["Content-Type"];
708 // if (cType != null && String.Compare (cType, urlEncodedCType, true) != 0)
709 // throw new WebException ("Content-Type header cannot be changed from its default " +
710 // "value for this request.");
712 // Headers ["Content-Type"] = urlEncodedCType;
713 // WebRequest request = SetupRequest (uri, method);
715 // Stream rqStream = request.GetRequestStream ();
716 // MemoryStream tmpStream = new MemoryStream ();
717 // foreach (string key in data) {
718 // byte [] bytes = Encoding.ASCII.GetBytes (key);
719 // UrlEncodeAndWrite (tmpStream, bytes);
720 // tmpStream.WriteByte ((byte) '=');
721 // bytes = Encoding.ASCII.GetBytes (data [key]);
722 // UrlEncodeAndWrite (tmpStream, bytes);
723 // tmpStream.WriteByte ((byte) '&');
726 // int length = (int) tmpStream.Length;
728 // tmpStream.SetLength (--length); // remove trailing '&'
730 // byte [] buf = tmpStream.GetBuffer ();
731 // rqStream.Write (buf, 0, length);
732 // rqStream.Close ();
733 // tmpStream.Close ();
735 // WebResponse response = request.GetResponse ();
736 // Stream st = ProcessResponse (response);
737 // return ReadAll (st, (int) response.ContentLength, userToken);
738 // } catch (ThreadInterruptedException) {
745 // public string DownloadString (string address)
747 // return encoding.GetString (DownloadData (address));
750 // public string DownloadString (Uri address)
752 // return encoding.GetString (DownloadData (address));
755 // public string UploadString (string address, string data)
757 // if (address == null)
758 // throw new ArgumentNullException ("address");
760 // throw new ArgumentNullException ("data");
762 // byte [] resp = UploadData (address, encoding.GetBytes (data));
763 // return encoding.GetString (resp);
766 // public string UploadString (string address, string method, string data)
768 // if (address == null)
769 // throw new ArgumentNullException ("address");
771 // throw new ArgumentNullException ("data");
773 // byte [] resp = UploadData (address, method, encoding.GetBytes (data));
774 // return encoding.GetString (resp);
777 // public string UploadString (Uri address, string data)
779 // if (address == null)
780 // throw new ArgumentNullException ("address");
782 // throw new ArgumentNullException ("data");
784 // byte [] resp = UploadData (address, encoding.GetBytes (data));
785 // return encoding.GetString (resp);
788 // public string UploadString (Uri address, string method, string data)
790 // if (address == null)
791 // throw new ArgumentNullException ("address");
793 // throw new ArgumentNullException ("data");
795 // byte [] resp = UploadData (address, method, encoding.GetBytes (data));
796 // return encoding.GetString (resp);
799 // public event DownloadDataCompletedEventHandler DownloadDataCompleted;
800 // public event AsyncCompletedEventHandler DownloadFileCompleted;
801 public event DownloadProgressChangedEventHandler DownloadProgressChanged;
802 public event DownloadStringCompletedEventHandler DownloadStringCompleted;
803 public event OpenReadCompletedEventHandler OpenReadCompleted;
804 // public event OpenWriteCompletedEventHandler OpenWriteCompleted;
805 // public event UploadDataCompletedEventHandler UploadDataCompleted;
806 // public event UploadFileCompletedEventHandler UploadFileCompleted;
807 // public event UploadProgressChangedEventHandler UploadProgressChanged;
808 // public event UploadStringCompletedEventHandler UploadStringCompleted;
809 // public event UploadValuesCompletedEventHandler UploadValuesCompleted;
812 // Uri CreateUri (string address)
816 // return MakeUri (address);
817 // } catch (Exception ex) {
818 // throw new WebException ("An error occurred " +
819 // "performing a WebClient request.", ex);
822 // return MakeUri (address);
826 // Uri MakeUri (string path)
828 // string query = null;
829 // if (queryString != null && queryString.Count != 0) {
830 // // This is not the same as UploadValues, because these 'keys' are not
831 // // urlencoded here.
832 // StringBuilder sb = new StringBuilder ();
834 // foreach (string key in queryString)
835 // sb.AppendFormat ("{0}={1}&", key, UrlEncode (queryString [key]));
837 // if (sb.Length != 0) {
838 // sb.Length--; // remove trailing '&'
839 // query = sb.ToString ();
843 // if (baseAddress == null && query == null) {
845 // return new Uri (path);
847 // } catch (ArgumentNullException) {
848 // path = Path.GetFullPath (path);
849 // return new Uri ("file://" + path);
851 // } catch (UriFormatException) {
852 // path = Path.GetFullPath (path);
853 // return new Uri ("file://" + path);
857 // if (baseAddress == null)
858 // return new Uri (path + query, (query != null));
860 // if (query == null)
861 // return new Uri (baseAddress, path);
863 // return new Uri (baseAddress, path + query, (query != null));
866 WebRequest SetupRequest (Uri uri)
868 WebRequest request = WebRequest.Create (baseAddress != null ? new Uri (baseAddress, uri) : uri);
869 // if (Proxy != null)
870 // request.Proxy = Proxy;
871 // request.Credentials = credentials;
873 // Special headers. These are properties of HttpWebRequest.
874 // What do we do with other requests differnt from HttpWebRequest?
875 // if (headers != null && headers.Count != 0 && (request is HttpWebRequest)) {
876 // HttpWebRequest req = (HttpWebRequest) request;
877 // string expect = headers ["Expect"];
878 // string contentType = headers ["Content-Type"];
879 // string accept = headers ["Accept"];
880 // string connection = headers ["Connection"];
881 // string userAgent = headers ["User-Agent"];
882 // string referer = headers ["Referer"];
883 // headers.RemoveInternal ("Expect");
884 // headers.RemoveInternal ("Content-Type");
885 // headers.RemoveInternal ("Accept");
886 // headers.RemoveInternal ("Connection");
887 // headers.RemoveInternal ("Referer");
888 // headers.RemoveInternal ("User-Agent");
889 // request.Headers = headers;
891 // if (expect != null && expect.Length > 0)
892 // req.Expect = expect;
894 // if (accept != null && accept.Length > 0)
895 // req.Accept = accept;
897 // if (contentType != null && contentType.Length > 0)
898 // req.ContentType = contentType;
900 // if (connection != null && connection.Length > 0)
901 // req.Connection = connection;
903 // if (userAgent != null && userAgent.Length > 0)
904 // req.UserAgent = userAgent;
906 // if (referer != null && referer.Length > 0)
907 // req.Referer = referer;
910 // responseHeaders = null;
911 request.SetupProgressDelegate ((ProgressChangedDelegate) delegate (long read, long length, object state) {
912 OnDownloadProgressChanged (new DownloadProgressChangedEventArgs (read, length, state));
917 WebRequest SetupRequest (Uri uri, string method)
919 WebRequest request = SetupRequest (uri);
920 request.Method = DetermineMethod (uri, method);
924 Stream ProcessResponse (WebResponse response)
926 // responseHeaders = response.Headers;
927 return response.GetResponseStream ();
930 Stream ReadAll (Stream stream, int length, object userToken)
932 MemoryStream ms = null;
934 bool nolength = (length == -1);
935 int size = ((nolength) ? 8192 : length);
936 ms = new MemoryStream (size);
939 byte [] buffer = new byte [size];
940 while ((nread = stream.Read (buffer, 0, buffer.Length)) != 0) {
941 ms.Write (buffer, 0, nread);
943 OnDownloadProgressChanged (new DownloadProgressChangedEventArgs (nread, length, userToken));
945 if (!nolength && ms.Length == length) {
954 // string UrlEncode (string str)
956 // StringBuilder result = new StringBuilder ();
958 // int len = str.Length;
959 // for (int i = 0; i < len; i++) {
962 // result.Append ('+');
963 // else if ((c < '0' && c != '-' && c != '.') ||
964 // (c < 'A' && c > '9') ||
965 // (c > 'Z' && c < 'a' && c != '_') ||
967 // result.Append ('%');
968 // int idx = ((int) c) >> 4;
969 // result.Append ((char) hexBytes [idx]);
970 // idx = ((int) c) & 0x0F;
971 // result.Append ((char) hexBytes [idx]);
973 // result.Append (c);
977 // return result.ToString ();
980 // static void UrlEncodeAndWrite (Stream stream, byte [] bytes)
982 // if (bytes == null)
985 // int len = bytes.Length;
989 // for (int i = 0; i < len; i++) {
990 // char c = (char) bytes [i];
992 // stream.WriteByte ((byte) '+');
993 // else if ((c < '0' && c != '-' && c != '.') ||
994 // (c < 'A' && c > '9') ||
995 // (c > 'Z' && c < 'a' && c != '_') ||
997 // stream.WriteByte ((byte) '%');
998 // int idx = ((int) c) >> 4;
999 // stream.WriteByte (hexBytes [idx]);
1000 // idx = ((int) c) & 0x0F;
1001 // stream.WriteByte (hexBytes [idx]);
1003 // stream.WriteByte ((byte) c);
1009 [SecuritySafeCritical]
1010 public void CancelAsync ()
1013 if (async_thread == null)
1017 // We first flag things as done, in case the Interrupt hangs
1018 // or the thread decides to hang in some other way inside the
1019 // event handlers, or if we are stuck somewhere else. This
1020 // ensures that the WebClient object is reusable immediately
1022 Thread t = async_thread;
1028 void CompleteAsync ()
1032 async_thread = null;
1036 // // DownloadDataAsync
1038 // public void DownloadDataAsync (Uri address)
1040 // DownloadDataAsync (address, null);
1043 // public void DownloadDataAsync (Uri address, object userToken)
1045 // if (address == null)
1046 // throw new ArgumentNullException ("address");
1052 // async_thread = new Thread (delegate (object state) {
1053 // object [] args = (object []) state;
1055 // byte [] data = DownloadDataCore ((Uri) args [0], args [1]);
1056 // OnDownloadDataCompleted (
1057 // new DownloadDataCompletedEventArgs (data, null, false, args [1]));
1058 // } catch (ThreadInterruptedException){
1059 // OnDownloadDataCompleted (
1060 // new DownloadDataCompletedEventArgs (null, null, true, args [1]));
1062 // } catch (Exception e){
1063 // OnDownloadDataCompleted (
1064 // new DownloadDataCompletedEventArgs (null, e, false, args [1]));
1067 // object [] cb_args = new object [] {address, userToken};
1068 // async_thread.Start (cb_args);
1072 // // DownloadFileAsync
1074 // public void DownloadFileAsync (Uri address, string fileName)
1076 // DownloadFileAsync (address, fileName, null);
1079 // public void DownloadFileAsync (Uri address, string fileName, object userToken)
1081 // if (address == null)
1082 // throw new ArgumentNullException ("address");
1083 // if (fileName == null)
1084 // throw new ArgumentNullException ("fileName");
1090 // async_thread = new Thread (delegate (object state) {
1091 // object [] args = (object []) state;
1093 // DownloadFileCore ((Uri) args [0], (string) args [1], args [2]);
1094 // OnDownloadFileCompleted (
1095 // new AsyncCompletedEventArgs (null, false, args [2]));
1096 // } catch (ThreadInterruptedException){
1097 // OnDownloadFileCompleted (
1098 // new AsyncCompletedEventArgs (null, true, args [2]));
1099 // } catch (Exception e){
1100 // OnDownloadFileCompleted (
1101 // new AsyncCompletedEventArgs (e, false, args [2]));
1103 // object [] cb_args = new object [] {address, fileName, userToken};
1104 // async_thread.Start (cb_args);
1108 // // DownloadStringAsync
1110 public void DownloadStringAsync (Uri address)
1112 DownloadStringAsync (address, null);
1115 public void DownloadStringAsync (Uri address, object userToken)
1117 if (address == null)
1118 throw new ArgumentNullException ("address");
1124 async_thread = new Thread (delegate (object state) {
1125 object [] args = (object []) state;
1127 Stream bdata = DownloadDataCore ((Uri) args [0], args [1]);
1129 using (StreamReader stream = new StreamReader (bdata, encoding, true))
1130 data = stream.ReadToEnd ();
1132 OnDownloadStringCompleted (
1133 new DownloadStringCompletedEventArgs (data, null, false, args [1]));
1134 } catch (ThreadInterruptedException){
1135 OnDownloadStringCompleted (
1136 new DownloadStringCompletedEventArgs (null, null, true, args [1]));
1137 } catch (Exception e){
1138 OnDownloadStringCompleted (
1139 new DownloadStringCompletedEventArgs (null, e, false, args [1]));
1141 object [] cb_args = new object [] {address, userToken};
1142 async_thread.Start (cb_args);
1148 public void OpenReadAsync (Uri address)
1150 OpenReadAsync (address, null);
1153 public void OpenReadAsync (Uri address, object userToken)
1155 if (address == null)
1156 throw new ArgumentNullException ("address");
1162 async_thread = new Thread (delegate (object state) {
1163 object [] args = (object []) state;
1164 WebRequest request = null;
1166 request = SetupRequest ((Uri) args [0]);
1167 //WebResponse response = request.GetResponse ();
1168 IAsyncResult asyncresult = request.BeginGetResponse (null, userToken);
1169 asyncresult.AsyncWaitHandle.WaitOne ();
1170 WebResponse response = request.EndGetResponse (asyncresult);
1171 Stream stream = ProcessResponse (response);
1172 OnOpenReadCompleted (
1173 new OpenReadCompletedEventArgs (stream, address, null, false, args [1]));
1174 } catch (ThreadInterruptedException){
1175 if (request != null)
1178 OnOpenReadCompleted (new OpenReadCompletedEventArgs (null, null, null, true, args [1]));
1179 } catch (Exception e){
1180 OnOpenReadCompleted (new OpenReadCompletedEventArgs (null, null, e, false, args [1]));
1182 object [] cb_args = new object [] {address, userToken};
1183 async_thread.Start (cb_args);
1187 // // OpenWriteAsync
1189 // public void OpenWriteAsync (Uri address)
1191 // OpenWriteAsync (address, null);
1194 // public void OpenWriteAsync (Uri address, string method)
1196 // OpenWriteAsync (address, method, null);
1199 // public void OpenWriteAsync (Uri address, string method, object userToken)
1201 // if (address == null)
1202 // throw new ArgumentNullException ("address");
1208 // async_thread = new Thread (delegate (object state) {
1209 // object [] args = (object []) state;
1210 // WebRequest request = null;
1212 // request = SetupRequest ((Uri) args [0], (string) args [1]);
1213 // Stream stream = request.GetRequestStream ();
1214 // OnOpenWriteCompleted (
1215 // new OpenWriteCompletedEventArgs (stream, null, false, args [2]));
1216 // } catch (ThreadInterruptedException){
1217 // if (request != null)
1218 // request.Abort ();
1219 // OnOpenWriteCompleted (
1220 // new OpenWriteCompletedEventArgs (null, null, true, args [2]));
1221 // } catch (Exception e){
1222 // OnOpenWriteCompleted (
1223 // new OpenWriteCompletedEventArgs (null, e, false, args [2]));
1225 // object [] cb_args = new object [] {address, method, userToken};
1226 // async_thread.Start (cb_args);
1230 // // UploadDataAsync
1232 // public void UploadDataAsync (Uri address, byte [] data)
1234 // UploadDataAsync (address, null, data);
1237 // public void UploadDataAsync (Uri address, string method, byte [] data)
1239 // UploadDataAsync (address, method, data, null);
1242 // public void UploadDataAsync (Uri address, string method, byte [] data, object userToken)
1244 // if (address == null)
1245 // throw new ArgumentNullException ("address");
1246 // if (data == null)
1247 // throw new ArgumentNullException ("data");
1253 // async_thread = new Thread (delegate (object state) {
1254 // object [] args = (object []) state;
1258 // data2 = UploadDataCore ((Uri) args [0], (string) args [1], (byte []) args [2], args [3]);
1260 // OnUploadDataCompleted (
1261 // new UploadDataCompletedEventArgs (data2, null, false, args [3]));
1262 // } catch (ThreadInterruptedException){
1263 // OnUploadDataCompleted (
1264 // new UploadDataCompletedEventArgs (null, null, true, args [3]));
1265 // } catch (Exception e){
1266 // OnUploadDataCompleted (
1267 // new UploadDataCompletedEventArgs (null, e, false, args [3]));
1269 // object [] cb_args = new object [] {address, method, data, userToken};
1270 // async_thread.Start (cb_args);
1274 // // UploadFileAsync
1276 // public void UploadFileAsync (Uri address, string fileName)
1278 // UploadFileAsync (address, null, fileName);
1281 // public void UploadFileAsync (Uri address, string method, string fileName)
1283 // UploadFileAsync (address, method, fileName, null);
1286 // public void UploadFileAsync (Uri address, string method, string fileName, object userToken)
1288 // if (address == null)
1289 // throw new ArgumentNullException ("address");
1290 // if (fileName == null)
1291 // throw new ArgumentNullException ("fileName");
1297 // async_thread = new Thread (delegate (object state) {
1298 // object [] args = (object []) state;
1302 // data = UploadFileCore ((Uri) args [0], (string) args [1], (string) args [2], args [3]);
1303 // OnUploadFileCompleted (
1304 // new UploadFileCompletedEventArgs (data, null, false, args [3]));
1305 // } catch (ThreadInterruptedException){
1306 // OnUploadFileCompleted (
1307 // new UploadFileCompletedEventArgs (null, null, true, args [3]));
1308 // } catch (Exception e){
1309 // OnUploadFileCompleted (
1310 // new UploadFileCompletedEventArgs (null, e, false, args [3]));
1312 // object [] cb_args = new object [] {address, method, fileName, userToken};
1313 // async_thread.Start (cb_args);
1317 // // UploadStringAsync
1319 // public void UploadStringAsync (Uri address, string data)
1321 // UploadStringAsync (address, null, data);
1324 // public void UploadStringAsync (Uri address, string method, string data)
1326 // UploadStringAsync (address, method, data, null);
1329 // public void UploadStringAsync (Uri address, string method, string data, object userToken)
1331 // if (address == null)
1332 // throw new ArgumentNullException ("address");
1333 // if (data == null)
1334 // throw new ArgumentNullException ("data");
1340 // async_thread = new Thread (delegate (object state) {
1341 // object [] args = (object []) state;
1344 // string data2 = UploadString ((Uri) args [0], (string) args [1], (string) args [2]);
1345 // OnUploadStringCompleted (
1346 // new UploadStringCompletedEventArgs (data2, null, false, args [3]));
1347 // } catch (ThreadInterruptedException){
1348 // OnUploadStringCompleted (
1349 // new UploadStringCompletedEventArgs (null, null, true, args [3]));
1350 // } catch (Exception e){
1351 // OnUploadStringCompleted (
1352 // new UploadStringCompletedEventArgs (null, e, false, args [3]));
1354 // object [] cb_args = new object [] {address, method, data, userToken};
1355 // async_thread.Start (cb_args);
1359 // // UploadValuesAsync
1361 // public void UploadValuesAsync (Uri address, NameValueCollection values)
1363 // UploadValuesAsync (address, null, values);
1366 // public void UploadValuesAsync (Uri address, string method, NameValueCollection values)
1368 // UploadValuesAsync (address, method, values, null);
1371 // public void UploadValuesAsync (Uri address, string method, NameValueCollection values, object userToken)
1373 // if (address == null)
1374 // throw new ArgumentNullException ("address");
1375 // if (values == null)
1376 // throw new ArgumentNullException ("values");
1382 // async_thread = new Thread (delegate (object state) {
1383 // object [] args = (object []) state;
1385 // byte [] data = UploadValuesCore ((Uri) args [0], (string) args [1], (NameValueCollection) args [2], args [3]);
1386 // OnUploadValuesCompleted (
1387 // new UploadValuesCompletedEventArgs (data, null, false, args [3]));
1388 // } catch (ThreadInterruptedException){
1389 // OnUploadValuesCompleted (
1390 // new UploadValuesCompletedEventArgs (null, null, true, args [3]));
1391 // } catch (Exception e){
1392 // OnUploadValuesCompleted (
1393 // new UploadValuesCompletedEventArgs (null, e, false, args [3]));
1395 // object [] cb_args = new object [] {address, method, values, userToken};
1396 // async_thread.Start (cb_args);
1400 // protected virtual void OnDownloadDataCompleted (DownloadDataCompletedEventArgs args)
1402 // CompleteAsync ();
1403 // if (DownloadDataCompleted != null)
1404 // DownloadDataCompleted (this, args);
1407 // protected virtual void OnDownloadFileCompleted (AsyncCompletedEventArgs args)
1409 // CompleteAsync ();
1410 // if (DownloadFileCompleted != null)
1411 // DownloadFileCompleted (this, args);
1414 protected virtual void OnDownloadProgressChanged (DownloadProgressChangedEventArgs e)
1416 if (DownloadProgressChanged != null) {
1417 DownloadProgressChanged (this, e);
1421 private object callback_args;
1423 protected virtual void OnOpenReadCompleted (OpenReadCompletedEventArgs args)
1426 if (OpenReadCompleted != null) {
1427 ManualResetEvent wait_event = new ManualResetEvent (false);
1428 GSourceFunc callback = (GSourceFunc) delegate (IntPtr ctx) { OpenReadCompleted (this, (OpenReadCompletedEventArgs) callback_args); wait_event.Set (); return false; };
1429 callback_args = args;
1431 g_timeout_add (0, callback, IntPtr.Zero);
1433 wait_event.WaitOne ();
1434 GC.KeepAlive (callback);
1438 public delegate bool GSourceFunc (IntPtr data);
1440 [DllImport ("moon")]
1441 static extern uint g_timeout_add (uint delay, GSourceFunc callback, IntPtr data);
1443 protected virtual void OnDownloadStringCompleted (DownloadStringCompletedEventArgs args)
1446 if (DownloadStringCompleted != null) {
1447 ManualResetEvent wait_event = new ManualResetEvent (false);
1448 GSourceFunc callback = (GSourceFunc) delegate (IntPtr ctx)
1451 DownloadStringCompleted (this, (DownloadStringCompletedEventArgs) callback_args);
1453 } catch (Exception ex) {
1454 Console.WriteLine ("Unhandled exception: {0}", ex);
1456 Console.WriteLine ("Unhandled exception.");
1460 callback_args = args;
1462 g_timeout_add (0, callback, IntPtr.Zero);
1464 wait_event.WaitOne ();
1465 GC.KeepAlive (callback);
1470 // protected virtual void OnOpenWriteCompleted (OpenWriteCompletedEventArgs args)
1472 // CompleteAsync ();
1473 // if (OpenWriteCompleted != null)
1474 // OpenWriteCompleted (this, args);
1477 // protected virtual void OnUploadDataCompleted (UploadDataCompletedEventArgs args)
1479 // CompleteAsync ();
1480 // if (UploadDataCompleted != null)
1481 // UploadDataCompleted (this, args);
1484 // protected virtual void OnUploadFileCompleted (UploadFileCompletedEventArgs args)
1486 // CompleteAsync ();
1487 // if (UploadFileCompleted != null)
1488 // UploadFileCompleted (this, args);
1491 // protected virtual void OnUploadProgressChanged (UploadProgressChangedEventArgs e)
1493 // if (UploadProgressChanged != null)
1494 // UploadProgressChanged (this, e);
1497 // protected virtual void OnUploadStringCompleted (UploadStringCompletedEventArgs args)
1499 // CompleteAsync ();
1500 // if (UploadStringCompleted != null)
1501 // UploadStringCompleted (this, args);
1504 // protected virtual void OnUploadValuesCompleted (UploadValuesCompletedEventArgs args)
1506 // CompleteAsync ();
1507 // if (UploadValuesCompleted != null)
1508 // UploadValuesCompleted (this, args);
1511 // [MonoNotSupported("")]
1512 // protected virtual WebRequest GetWebRequest (Uri address)
1514 // throw new NotImplementedException ();
1517 // protected virtual WebResponse GetWebResponse (WebRequest request)
1519 // return request.GetResponse ();
1522 // protected virtual WebResponse GetWebResponse (WebRequest request, IAsyncResult result)
1524 // return request.EndGetResponse (result);
projects / mono.git / blob