public async Task <HttpResponse <T> > DeleteAsync <T>(HttpDeleteRequest request)
        {
            try
            {
                HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(request.Url);
                switch (request.RequestType)
                {
                case RequestType.XML:
                    httpWebRequest.ContentType = "application/xml; charset=utf-8";
                    break;

                case RequestType.APPLICATION:
                    httpWebRequest.ContentType = "application /x-www-form-urlencoded";
                    break;

                default:
                    httpWebRequest.ContentType = "application/json";
                    break;
                }

                httpWebRequest.Method = "DELETE";

                if (IpAddress != null)
                {
                }

                if (request.Headers != null)
                {
                    foreach (string key in request.Headers.Keys)
                    {
                        httpWebRequest.Headers.Add(key, request.Headers[key]);
                    }
                }

                if (request.AuthType == AuthorizationTypes.BASIC)
                {
                    string encodedBasicCredentials =
                        Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes(request.BasicAuthCredentials.UserName + ":" + request.BasicAuthCredentials.Password));

                    httpWebRequest.Headers.Add("Authorization", "Basic " + encodedBasicCredentials);
                }

                HttpWebResponse httpWebResponse = (HttpWebResponse)await httpWebRequest.GetResponseAsync();

                Encoding encoding = null;

                if (request.AuthType != AuthorizationTypes.BASIC)
                {
                    string charSet = httpWebResponse.CharacterSet;
                    encoding = Encoding.GetEncoding(charSet);
                }

                using (Stream responseStream = httpWebResponse.GetResponseStream())
                {
                    HttpResponse <T> response = new HttpResponse <T>();

                    Type type = typeof(T);
                    if (type == typeof(NoBodyType))
                    {
                        response.Body       = (T)Convert.ChangeType(NoBodyType.Body, typeof(T));
                        response.StatusCode = HttpStatusCode.OK;
                        return(response);
                    }

                    StreamReader streamReader = new StreamReader(responseStream, encoding);

                    string stream = await streamReader.ReadToEndAsync();

                    if (type != typeof(string))
                    {
                        response.Body = DeserializeJson <T>(stream);
                    }
                    else
                    {
                        response.Body = (T)Convert.ChangeType(stream, typeof(T));
                    }
                    response.StatusCode = HttpStatusCode.OK;
                    return(response);
                }
            }
            catch (WebException e)
            {
                using (WebResponse webResponse = e.Response)
                {
                    HttpWebResponse httpResponse = (HttpWebResponse)webResponse;
                    Console.WriteLine("Error code: {0}", httpResponse.StatusCode);

                    using (Stream data = webResponse.GetResponseStream())
                        using (var reader = new StreamReader(data))
                        {
                            HttpResponse <T> response = new HttpResponse <T>();
                            response.ErrorMessage = reader.ReadToEnd();
                            response.StatusCode   = httpResponse.StatusCode;
                            return(response);
                        }
                }
            }
        }
 /// <summary>
 /// Sends a HTTP DELETE message and returns the non parsed HttpResponse recieved for it.
 /// </summary>
 /// <param name="request">The HTTP request's parameters.</param>
 /// <param name="cancellationToken">A CancellationToken that can be used to cancel this operation.</param>
 /// <returns>The non-parsed HttpResponse.</returns>
 public Task <HttpResponse> SendDeleteRequestAsync(HttpDeleteRequest request, CancellationToken cancellationToken = default)
 => SendRequestCoreAsync(request, cancellationToken);