FlushAsync() public method

public FlushAsync ( ) : System.Threading.Tasks.Task
return System.Threading.Tasks.Task
 public override async Task WriteToStreamAsync(Type type, object value, Stream stream, HttpContent content, TransportContext transportContext)
 {
     using (stream)
     {
         Encoding encoding = SelectCharacterEncoding(content.Headers);
         using (var writer = new StreamWriter(stream, encoding))
         {
             var individuals = value as IEnumerable<Individual>;
             if (individuals != null)
             {
                 foreach (var individu in individuals)
                 {
                     await writer.WriteLineAsync(String.Format("{0,-10};{1,-10};{2,-10}", individu.Id, individu.FirstName, individu.LastName));
                 }
                 await writer.FlushAsync();
             }
             var individual = value as Individual;
             if (individual != null)
             {
                 await writer.WriteLineAsync(String.Format("{0,-10};{1,-10};{2,-10}", individual.Id, individual.FirstName, individual.LastName));
                 await writer.FlushAsync();
             }
         }
     }
 }
	    public async Task DoSomethingWithClientAsync()
	    {
		        try
		        {
			            using (var stream = _client.GetStream())
				            {
				                using (var sr = new StreamReader(stream))
				                using (var sw = new StreamWriter(stream))
					                {
					                    await sw.WriteLineAsync("Hi. This is x2 TCP/IP easy-to-use server").ConfigureAwait(false);
					                    await sw.FlushAsync().ConfigureAwait(false);
					                    var data = default(string);
					                    while (!((data = await sr.ReadLineAsync().ConfigureAwait(false)).Equals("exit", StringComparison.OrdinalIgnoreCase)))
		                    {
		                        await sw.WriteLineAsync(data).ConfigureAwait(false);
		                        await sw.FlushAsync().ConfigureAwait(false);
		                    }
		                }
		
		            }
		        }
		        finally
		        {
		            if (_ownsClient && _client != null)
		            {
		                (_client as IDisposable).Dispose();
		                _client = null;
		            }
		        }
		}
示例#3
0
        private async void ClientWork(object state)
        {
            int clientId = (int)state;
            using (var channel = this.connection.ConnectChannel())
            {
                using (StreamWriter writer = new StreamWriter(channel))
                {
                    using (StreamReader reader = new StreamReader(channel))
                    {
                        string request = string.Format("Hello from {0}", clientId);
                        string response;
                        await writer.WriteLineAsync(request);
                        await writer.FlushAsync();
                        response = await reader.ReadLineAsync();
                        await writer.WriteLineAsync(request);
                        await writer.FlushAsync();
                        response = await reader.ReadLineAsync();
                        await channel.StopSendingAsync();
                        await channel.FlushAsync();
                        if (reader.EndOfStream)
                        {
                            Console.WriteLine("Client feel right!");
                        }
                    }
                }
            }

            if (Interlocked.Decrement(ref pendingCount) == 0)
            {
                lock (termLock)
                {
                    Monitor.Pulse(termLock);
                }
            }
        }
示例#4
0
        private static async Task WorkAsync(Channel channel)
        {
            using (channel)
            {
                using (var reader = new StreamReader(channel))
                {
                    using (var writer = new StreamWriter(channel))
                    {
                        string request = await reader.ReadLineAsync();
                        await writer.WriteLineAsync(request);
                        await writer.FlushAsync();

                        request = await reader.ReadLineAsync();
                        await writer.WriteLineAsync(request);
                        await writer.FlushAsync();

                        Console.WriteLine("Server waiting for close");

                        if (reader.EndOfStream)
                        {
                            Console.WriteLine("Server feel right!");
                        }

                        await channel.StopSendingAsync();
                        await channel.FlushAsync();
                    }
                }
            }
        }
示例#5
0
		protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
		{
			using (var writer = new StreamWriter(stream))
			{
                await writer.WriteAsync("data: { \"Type\": \"Heartbeat\" }\r\n\r\n");
				await writer.FlushAsync();
							
				while (Connected)
				{
					try
					{
						var result = await manualResetEvent.WaitAsync(5000);
						if (Connected == false)
							return;

						if (result == false)
						{
                            await writer.WriteAsync("data: { \"Type\": \"Heartbeat\" }\r\n\r\n");
							await writer.FlushAsync();

                            if (lastMessageEnqueuedAndNotSent != null)
                            {
								await SendMessage(lastMessageEnqueuedAndNotSent, writer);
                            }
							continue;
						}

						manualResetEvent.Reset();

						object message;
						while (msgs.TryDequeue(out message))
						{
							if (CoolDownWithDataLossInMiliseconds > 0 && Environment.TickCount - lastMessageSentTick < CoolDownWithDataLossInMiliseconds)
                            {
                                lastMessageEnqueuedAndNotSent = message;
                                continue;
                            }

							await SendMessage(message, writer);
						}
					}
					catch (Exception e)
					{
						Connected = false;
						log.DebugException("Error when using events transport", e);
						Disconnected();
						try
						{
							writer.WriteLine(e.ToString());
						}
						catch (Exception)
						{
							// try to send the information to the client, okay if they don't get it
							// because they might have already disconnected
						}

					}
				}
			}
		}
		protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
		{
			using (var writer = new StreamWriter(stream))
			{
                await writer.WriteAsync("data: { \"Type\": \"Heartbeat\" }\r\n\r\n");
				await writer.FlushAsync();
							
				while (Connected)
				{
					try
					{
						var result = await manualResetEvent.WaitAsync(5000);
						if (Connected == false)
							return;

						if (result == false)
						{
                            await writer.WriteAsync("data: { \"Type\": \"Heartbeat\" }\r\n\r\n");
							await writer.FlushAsync();
							continue;
						}
						manualResetEvent.Reset();
						object message;
						while (msgs.TryDequeue(out message))
						{
							var obj = JsonConvert.SerializeObject(message, Formatting.None, new EtagJsonConverter());
							await writer.WriteAsync("data: ");
							await writer.WriteAsync(obj);
							await writer.WriteAsync("\r\n\r\n");
							await writer.FlushAsync();
						}
					}
					catch (Exception e)
					{
						Connected = false;
						log.DebugException("Error when using events transport", e);
						Disconnected();
						try
						{
							writer.WriteLine(e.ToString());
						}
						catch (Exception)
						{
							// try to send the information to the client, okay if they don't get it
							// because they might have already disconnected
						}

					}
				}
			}
		}
示例#7
0
        protected async Task Listen(Socket socket) {
            Stream ioStream = socket.GetStream();
            StreamReader reader = new StreamReader(ioStream);
            StreamWriter writer = new StreamWriter(ioStream);

            await writer.WriteLineAsync(FtpResponse.PositiveCompletionReply.ServiceReady.ToString());
            await writer.FlushAsync();
            string command;
            while (true) {
                string result = await RunCommand(await reader.ReadLineAsync());
                await writer.WriteLineAsync(result);
                await writer.FlushAsync();
            }
        }
        public HttpResponseMessage Get()
        {

            var resp = new HttpResponseMessage
            {
                Content = new PushStreamContent(async (respStream, content, context) =>
                {
                    try
                    {
                        var wordsToSend = Lipsum.Split(' ');
                        using (var writer = new StreamWriter(respStream))
                        {
                            foreach (var word in wordsToSend)
                            {
                                await writer.WriteLineAsync(word);
                                await writer.FlushAsync();
                                await Task.Delay(millisecondsDelay: 250);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        return;
                    }
                    finally
                    {
                        respStream.Close();
                    }
                }, "text/plain")
            };

            return resp;
        }
        public async Task WriteBody(StreamWriter writer)
        {
            _memoryStream.Position = 0;

            await writer.FlushAsync().ConfigureAwait(false);
            await _memoryStream.CopyToAsync(writer.BaseStream).ConfigureAwait(false);
        }
示例#10
0
        public override async Task Invoke(IOwinContext context)
        {
            // process response
            var owinResponse = new OwinResponse(context.Environment) { ContentType = "text/plain" };
            var owinRequest = new OwinRequest(context.Environment);
            var writer = new StreamWriter(owinResponse.Body);
            switch (owinRequest.Path.Value)
            {
                case "/root/10mbTest.txt":
                    writer.Write(TestHelpers.FileContent5bTest);
                    owinResponse.ContentLength = TestHelpers.FileContent5bTest.Length;
                    break;
                case "/root/simpleTest.txt":
                    writer.Write(TestHelpers.FileContentSimpleTest);
                    owinResponse.ContentLength = TestHelpers.FileContentSimpleTest.Length;
                    break;
                case "/root/index.html":
                    writer.Write(TestHelpers.FileContentIndex);
                    owinResponse.ContentLength = TestHelpers.FileContentIndex.Length;
                    break;
                case "/root/emptyFile.txt":
                    writer.Write(TestHelpers.FileContentEmptyFile);
                    owinResponse.ContentLength = TestHelpers.FileContentEmptyFile.Length;
                    break;
                default:
                    writer.Write(TestHelpers.FileContentAnyFile);
                    owinResponse.ContentLength = TestHelpers.FileContentAnyFile.Length;
                    break;
            }

            await writer.FlushAsync();
        }
		async Task<string> SendRPCAsync(string methodName, params object[] args) {
			var jsonArgs = new List<string>();
			foreach(var arg in args) {
				if(arg is string) {
					jsonArgs.Add(String.Format("\"{0}\"", arg));
				}
				else {
					jsonArgs.Add(arg.ToString());
				}
			}

			var rpc = String.Format("{{\"id\": 1, \"method\": \"{0}\", \"params\": [{1}]}}", methodName, String.Join(", ", jsonArgs));

			await ClientLock.WaitAsync();
			try {
				var writer = new StreamWriter(ClientStream);
				await writer.WriteLineAsync(rpc);
				await writer.FlushAsync();

				var reader = new StreamReader(ClientStream);
				return await reader.ReadLineAsync();
			}
			finally {
				ClientLock.Release();
			}
		}
示例#12
0
 protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
 {
     string jsonString = await JsonConvert.SerializeObjectAsync(this.JsonObject);
     StreamWriter writer = new StreamWriter(stream);
     await writer.WriteAsync(jsonString);
     await writer.FlushAsync();
 }
		public static async Task<bool> WriteTextIntoFileAsync(string text, StorageFile file)
		{
			try
			{
				if (file != null)
				{
					using (var fileStream = await file.OpenStreamForWriteAsync().ConfigureAwait(false))
					{
						using (var writer = new StreamWriter(fileStream))
						{
							fileStream.SetLength(0); // avoid leaving crap at the end if overwriting a file that was longer
							fileStream.Seek(0, SeekOrigin.Begin);
							await writer.WriteAsync(text).ConfigureAwait(false);
							await fileStream.FlushAsync();
							await writer.FlushAsync();
							return true;
						}
					}
				}
			}
			catch (Exception ex)
			{
				await Logger.AddAsync(ex.ToString(), Logger.FileErrorLogFilename).ConfigureAwait(false);
			}
			return false;
		}
示例#14
0
        private async Task SendServiceMessage(Message packet)
        {
            var command = packet.Json;
            try
            {
                using (var tcpClient = new TcpClient())
                {
                    await tcpClient.ConnectAsync(IPAddress.Loopback, 22005);
                    using (var stream = tcpClient.GetStream())
                    using (var sw = new StreamWriter(stream, Encoding.UTF8))
                    {

                        if (tcpClient.Connected)
                        {
                            await sw.WriteLineAsync(command);
                            await sw.FlushAsync();
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
        private static async Task<TokenResponse> RedeemRefreshTokenInternalAsync(OAuthAccount account)
        {
            HttpWebRequest request = WebRequest.CreateHttp(account.TokenService);
            request.ContentType = "application/x-www-form-urlencoded";
            request.Method = "POST";

            var requestStream = await request.GetRequestStreamAsync();
            var writer = new StreamWriter(requestStream);

            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("client_id={0}", Uri.EscapeDataString(account.ClientId));
            sb.AppendFormat("&redirect_uri={0}", Uri.EscapeDataString(account.RedirectUri));
            sb.AppendFormat("&client_secret={0}", Uri.EscapeDataString(account.ClientSecret));
            sb.AppendFormat("&refresh_token={0}", Uri.EscapeDataString(account.RefreshToken));
            sb.Append("&grant_type=refresh_token");
            if (null != account.Resource)
                sb.AppendFormat("&resource={0}", Uri.EscapeDataString(account.Resource));

            var content = sb.ToString();
            await writer.WriteAsync(content);
            await writer.FlushAsync();

            var response = await request.GetResponseAsync() as HttpWebResponse;
            if (null != response && response.StatusCode == HttpStatusCode.OK)
            {
                var responseStream = response.GetResponseStream();
                if (null != responseStream)
                {
                    var reader = new StreamReader(responseStream);
                    return JsonConvert.DeserializeObject<TokenResponse>(await reader.ReadToEndAsync());
                }
            }
            return null;
        }
示例#16
0
        /// <summary>
        /// Показать ошибку на экране.
        /// </summary>
        /// <param name="ex">Ошибка.</param>
        /// <returns>Результат.</returns>
        public static async Task ShowError(Exception ex)
        {
#if DEBUG
#if LOG_ERROR_DEBUG
            try
            {
                if (ex != null)
                {
                    var fld = await ApplicationData.Current.LocalFolder.CreateFolderAsync("error_log", CreationCollisionOption.OpenIfExists);
                    var f = await fld.CreateFileAsync(Guid.NewGuid() + ".error");
                    using (var str = await f.OpenStreamForWriteAsync())
                    {
                        using (var wr = new StreamWriter(str, Encoding.UTF8))
                        {
                            await wr.WriteAsync(ex.ToString());
                            await wr.FlushAsync();
                        }
                    }
                }
            }
            catch
            {
            }
#endif
#endif
            var dialog = new MessageDialog(ex?.Message ?? "", AppConstants.ErrorTitle);
            dialog.Commands.Add(new UICommand(AppConstants.OkButtonLabel, command => { }));
            dialog.Commands.Add(new UICommand(AppConstants.MoreInfoButtonLabel, async command =>
            {
                await ShowFullError(ex);
            }));
            dialog.DefaultCommandIndex = 0;
            dialog.CancelCommandIndex = 0;
            await dialog.ShowAsync();
        }
示例#17
0
 public async Task Save()
 {
     var roaming = ApplicationData.Current.RoamingFolder;
     if (Session != null)
     {
         var data = JsonConvert.SerializeObject(Session);
         var file = await roaming.CreateFileAsync("settings.json", CreationCollisionOption.ReplaceExisting);
         using (var stream = await file.OpenStreamForWriteAsync())
         using (var writer = new StreamWriter(stream))
         {
             await writer.WriteAsync(data);
             await writer.FlushAsync();
         }
     }
     else
     {
         try
         {
             var file = await roaming.GetFileAsync("settings.json");
             await file.DeleteAsync();
         }
         catch (Exception ex)
         {
             Debug.WriteLine(ex.ToString());
         }
     }
 }
        public async Task<bool> InsertOrUpdate(KeyVaultConfiguration keyVaultConfiguration)
        {
            var writeToFile = JsonConvert.SerializeObject(keyVaultConfiguration);
            var filePath = Path.Combine(
                ConfigurationPath,
                keyVaultConfiguration.VaultName,
                string.Format(ConfigurationFileFormat, keyVaultConfiguration.VaultName));
            
            var directoryPath = Path.Combine(ConfigurationPath, keyVaultConfiguration.VaultName);
            if (!Directory.Exists(directoryPath))
            {
                Directory.CreateDirectory(directoryPath);
            }

            using (var file = File.Create(filePath))
            {
                using (var streamWriter = new StreamWriter(file))
                {
                    await streamWriter.WriteAsync(writeToFile);
                    await streamWriter.FlushAsync();
                    this.allConfigurations.Remove(keyVaultConfiguration);
                    this.allConfigurations.Add(keyVaultConfiguration);
                    return true;
                }
            }
        }
示例#19
0
 public static async Task SaveFileStringContentsAsync(string path, string contents)
 {
     using (StreamWriter writer = new StreamWriter(path, false))
     {
         await writer.WriteAsync(contents);
         await writer.FlushAsync();
     }
 }
示例#20
0
 protected override async Task SerializeToStreamAsync(Stream stream,
     TransportContext context)
 {
     var json = JsonConvert.SerializeObject(_value, Formatting.Indented, new JsonSerializerSettings {NullValueHandling = NullValueHandling.Ignore});
     var writer = new StreamWriter(stream);
     writer.Write(json);
     await writer.FlushAsync();
 }
示例#21
0
		private async Task SendMessage(object message, StreamWriter writer)
		{
            var o = JsonExtensions.ToJObject(message);        
            await writer.WriteAsync("data: ");
            await writer.WriteAsync(o.ToString(Formatting.None));
            await writer.WriteAsync("\r\n\r\n");
            await writer.FlushAsync();
		}
 public static async Task WriteStringAsync(this WebSocket ws, String data, CancellationToken cancel)
 {
     using (var msg = ws.CreateMessageWriter(WebSocketMessageType.Text))
     using (var writer = new StreamWriter(msg, Encoding.UTF8))
     {
         writer.Write(data);
         await writer.FlushAsync().ConfigureAwait(false);
     }
 }
示例#23
0
        public async Task SendData(TcpClient client, string message)
        {
            NetworkStream stream = client.GetStream();
            StreamWriter writer = new StreamWriter(stream);

            await writer.WriteLineAsync(message);
            await writer.FlushAsync();
            Trace.TraceInformation("Sent data to client {0}: {1}", client.Client.RemoteEndPoint.ToString(), message);
        }
        public async override Task WriteResponseBodyAsync(OutputFormatterContext context)
        {
            var itemType = context.DeclaredType.GetElementType() ?? context.DeclaredType.GetGenericArguments()[0];

            using (var stringWriter = new StringWriter())
            {
                stringWriter.WriteLine(
                    string.Join<string>(
                        ",", itemType.GetProperties().Select(x => x.Name)
                        )
                    );

                foreach (var obj in (IEnumerable<object>) context.Object)
                {
                    var vals = obj.GetType().GetProperties().Select(
                        pi => new
                        {
                            Value = pi.GetValue(obj, null)
                        }
                        );

                    var valueLine = string.Empty;

                    string _val;
                    foreach (var val in vals)
                    {
                        if (val.Value != null)
                        {
                            _val = val.Value.ToString();
                            //Check if the value contans a comma and place it in quotes if so
                            if (_val.Contains(","))
                                _val = string.Concat("\"", _val, "\"");

                            //Replace any \r or \n special characters from a new line with a space
                            if (_val.Contains("\r"))
                                _val = _val.Replace("\r", " ");
                            if (_val.Contains("\n"))
                                _val = _val.Replace("\n", " ");

                            valueLine = string.Concat(valueLine, _val, ",");

                        }
                        else
                        {
                            valueLine = string.Concat(valueLine, ",");
                        }
                    }

                    stringWriter.WriteLine(valueLine.TrimEnd(','));
                }

                var writer = new StreamWriter(context.HttpContext.Response.Body);
                await writer.WriteAsync(stringWriter.ToString());
                await writer.FlushAsync();
            }
        }
 public override async Task WriteToStreamAsync(Type type, object value, Stream stream, HttpContent content, TransportContext transportContext, CancellationToken cancellationToken)
 {            
     var json = _formatter.GetContext(_request, value);
     var writer = new StreamWriter(stream);
     content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
     content.Headers.TryAddWithoutValidation("x-template", _view);
     await writer.WriteAsync(json);
     await writer.FlushAsync();
     return;
 }
示例#26
0
		// BCL Tcp Client
		public static async Task BclClient()
		{
			using (var client = new TcpClient()) {
				await client.ConnectAsync(Default.IPEndPoint);
				var stream = client.GetStream();
				var sw = new StreamWriter(stream);
				await sw.WriteAsync("Hello World from BCL!");
				await sw.FlushAsync();
			}
		}
示例#27
0
		public async Task<ScriptResult> EvaluateAsync(string script, TimeSpan timeoutDuration)
		{
			if (string.IsNullOrWhiteSpace(script))
				return null;

			var unusableName = _unusable.ExtractFirst(script);
			if (unusableName != null)
			{
				return new ScriptResult(
					state: ScriptState.Unusable,
					output: $"{unusableName} is unusable.");
			}

			using (var ms = new MemoryStream())
			using (var sw = new StreamWriter(ms))
			{
				Console.SetOut(sw);
				var watch = Stopwatch.StartNew();

				var state = ScriptState.Failure;

				try
				{
					var returned = await EvaluateBaseAsync(script, timeoutDuration);
					if (returned != null)
						returned.Dump();

					state = ScriptState.Success;
				}
				catch (OperationCanceledException ex)
				{
					Console.WriteLine(ex.Message);
					state = ScriptState.Timeout;
				}
				catch (Exception ex)
				{
					Console.WriteLine(ex.Message);
				}

				watch.Stop();
				await sw.FlushAsync();

				var output = Encoding.UTF8.GetString(ms.GetBuffer(), 0, (int)ms.Length).Trim();
				if (string.IsNullOrEmpty(output))
				{
					state = ScriptState.NoOutput;
					output = "Completed but no output.";
				}

				return new ScriptResult(
					state: state,
					output: output,
					elapsed: watch.Elapsed);
			}
		}
 async Task WriteIFrameDataToStreamAsync(Stream writeStream, object value)
 {
     value = value ?? new object();
     var writer = new StreamWriter(writeStream);
     await writer.WriteAsync(
         "<!DOCTYPE html>\n<html><body>" + 
         JsonConvert.SerializeObject(value) + 
         "</body></html>"
     );
     await writer.FlushAsync();
 }
示例#29
0
 static async Task IoBoundMethod(string path)
 {
     using (var stream = new FileStream(path, FileMode.OpenOrCreate))
     using (var writer = new StreamWriter(stream))
     {
         await writer.WriteLineAsync("Yehaa " + DateTime.Now);
         await writer.FlushAsync();
         writer.Close();
         stream.Close();
     }
 }
        private async void Send(string message)
        {
            if (socket == null || !socket.Connected)
            {
                return;
            }

            var writer = new StreamWriter(socket.GetStream());
            await writer.WriteLineAsync(message);
            await writer.FlushAsync();
        }
 static int FlushAsync(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 1);
         System.IO.StreamWriter      obj = (System.IO.StreamWriter)ToLua.CheckObject <System.IO.StreamWriter>(L, 1);
         System.Threading.Tasks.Task o   = obj.FlushAsync();
         ToLua.PushObject(L, o);
         return(1);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
示例#32
0
        public async Task <byte[]> ToCsvAsync()
        {
            using var memoryStream = new System.IO.MemoryStream();
            using var writer       = new System.IO.StreamWriter(memoryStream);
            using var csv          = new CsvHelper.CsvWriter(writer,
                                                             new CsvConfiguration(CultureInfo.InvariantCulture));

            await csv
            .WriteRecordsAsync(await _schoolService.GetForExportAsync());

            await csv.FlushAsync();

            await writer.FlushAsync();

            await memoryStream.FlushAsync();

            return(memoryStream.ToArray());
        }
示例#33
0
        public async Task SaveSvg(GraphicCanvas canvas, string name)
        {
            var path = GetPath(name, ".svg");

            using (var s = OpenStream(path)) {
                if (s == null)
                {
                    using (var ss = await Platforms.Current.OpenFileStreamForWritingAsync(path)) {
                        using (var w = new System.IO.StreamWriter(ss)) {
                            canvas.Graphic.WriteSvg(w);
                        }
                    }
                }
                else
                {
                    var w = new System.IO.StreamWriter(s);
                    canvas.Graphic.WriteSvg(w);
                    await w.FlushAsync();
                    await CloseStream(s);
                }
            }
        }
示例#34
0
        private static async Task <U> MakeRequestAsync <T, U, EX>(
            string method,
            AuthenticationDetails auth,
            string path,
            NameValueCollection queryArguments,
            T payload,
            string baseUri,
            string contentType)
            where T : class
            where EX : ErrorResult
        {
            try
            {
                JsonSerializerSettings serialiserSettings = new JsonSerializerSettings();
                serialiserSettings.NullValueHandling     = NullValueHandling.Ignore;
                serialiserSettings.MissingMemberHandling = MissingMemberHandling.Ignore;
                serialiserSettings.Converters.Add(new EmailAddressConverter());

                string uri = baseUri + path + NameValueCollectionExtension.ToQueryString(queryArguments);

                HttpClientHandler handler = new HttpClientHandler();
                handler.AutomaticDecompression = System.Net.DecompressionMethods.GZip;

                HttpClient client = new HttpClient(handler);

                if (auth != null)
                {
                    if (auth is OAuthAuthenticationDetails)
                    {
                        OAuthAuthenticationDetails oauthDetails = auth as OAuthAuthenticationDetails;
                        client.DefaultRequestHeaders.Add("Authorization", "Bearer " + oauthDetails.AccessToken);
                    }
                    else if (auth is ApiKeyAuthenticationDetails)
                    {
                        ApiKeyAuthenticationDetails apiKeyDetails = auth as ApiKeyAuthenticationDetails;
                        client.DefaultRequestHeaders.Add("Authorization", "Basic " + Convert.ToBase64String(
                                                             Encoding.GetEncoding(0).GetBytes(apiKeyDetails.ApiKey + ":x")));
                    }
                    else if (auth is BasicAuthAuthenticationDetails)
                    {
                        BasicAuthAuthenticationDetails basicDetails = auth as BasicAuthAuthenticationDetails;
                        client.DefaultRequestHeaders.Add("Authorization", "Basic " + Convert.ToBase64String(
                                                             Encoding.GetEncoding(0).GetBytes(basicDetails.Username + ":" + basicDetails.Password)));
                    }
                }

                HttpContent         content  = null;
                HttpResponseMessage response = null;

                if (method != "GET")
                {
                    Stream s             = new MemoryStream();
                    Stream requestStream = new MemoryStream();

                    if (payload != null)
                    {
                        using (System.IO.StreamWriter os = new System.IO.StreamWriter(s))
                        {
                            if (contentType == APPLICATION_FORM_URLENCODED_CONTENT_TYPE)
                            {
                                os.Write(payload);
                            }
                            else
                            {
                                string json = JsonConvert.SerializeObject(payload, Formatting.None, serialiserSettings);
                                os.Write(json);
                            }

                            await os.FlushAsync();

                            s.Seek(0, SeekOrigin.Begin);
                            await s.CopyToAsync(requestStream);

                            os.Dispose();
                        }

                        requestStream.Seek(0, SeekOrigin.Begin);
                        content  = new StreamContent(requestStream);
                        response = await client.PostAsync(uri, content);
                    }
                    else
                    {
                        response = await client.PostAsync(uri, null);
                    }
                }
                else
                {
                    response = await client.GetAsync(uri);
                }

                if (response.IsSuccessStatusCode)
                {
                    var resp = await response.Content.ReadAsStreamAsync();

                    if (resp == null)
                    {
                        return(default(U));
                    }

                    {
                        using (var sr = new System.IO.StreamReader(resp))
                        {
                            var type = typeof(U);
                            if (type.GetGenericTypeDefinition() == typeof(RateLimited <>))
                            {
                                var responseType = type.GenericTypeArguments[0];
                                var result       = JsonConvert.DeserializeObject(sr.ReadToEnd().Trim(), responseType, serialiserSettings);
                                var status       = new RateLimitStatus
                                {
                                    Credit    = response.Headers.Contains("X-RateLimit-Limit") ? uint.Parse(response.Headers.GetValues("X-RateLimit-Limit").First()) : 0,
                                    Remaining = response.Headers.Contains("X-RateLimit-Remaining") ? uint.Parse(response.Headers.GetValues("X-RateLimit-Remaining").First()) : 0,
                                    Reset     = response.Headers.Contains("X-RateLimit-Reset") ? uint.Parse(response.Headers.GetValues("X-RateLimit-Reset").First()) : 0
                                };
                                return((U)Activator.CreateInstance(type, result, status));
                            }
                            return(JsonConvert.DeserializeObject <U>(sr.ReadToEnd().Trim(), serialiserSettings));
                        }
                    }
                }
                else
                {
                    switch (response.StatusCode)
                    {
                    case System.Net.HttpStatusCode.BadRequest:
                    case System.Net.HttpStatusCode.Unauthorized:
                        throw ThrowReworkedCustomException <EX>(response);

                    case System.Net.HttpStatusCode.NotFound:
                    default:
                        throw new HttpRequestException(response.Content.ReadAsStringAsync().Result);
                    }
                }
            }
            catch (Exception ex)
            {
                throw;
            }
        }