Welcome to the Lounge

Super Lloyd wrote:

15 month later, it's government

lmoelleb wrote:

Web API:
An inexperience programmer can make a client in three days.... An experienced programmer can make on in ... three days. Hurray for typing client data objects manually.

public class WebQueryBuilder
{
    StringBuilder url = new StringBuilder();
    bool hasParam;

    public WebQueryBuilder(string url)
    {
        this.url = new StringBuilder(url);
        hasParam = url.Contains("?");
        Method = HttpMethod.Get;
    }

    public void SetX6509Cert(byte[] rawData, string password)
    {
        cert = new X509Certificate2(rawData, password);
    }
    X509Certificate2 cert;

    // Query parameter initialization syntax
    public string this[string key] { set { Add(key, value); } }
    public void Add(string key, string value)
    {
        if (hasParam)
        {
            url.Append("&");
        }
        else
        {
            url.Append("?");
            hasParam = true;
        }
        url.Append(WebUtility.UrlEncode(key));
        url.Append("=");
        url.Append(WebUtility.UrlEncode(value));
    }
    public void AddRange(ICollection<KeyValuePair<string, string>> headers)
    {
        if (headers != null)
            foreach (var kv in headers)
                Add(kv.Key, kv.Value);
    }

    public HttpMethod Method { get; set; }

    /// <summary>
    /// Body, serialized as JSON, for non GET query
    /// </summary>
    public object Body { get; set; }

    public WebHeaderCollection Headers
    {
        get
        {
            if (headers == null)
                headers = new WebHeaderCollection();
            return headers;
        }
    }
    WebHeaderCollection headers;

    public DecompressionMethods AutomaticDecompression { get; set; } = DecompressionMethods.None;

    public async Task<HttpWebResponse> QueryAsync()
    {
        var req = (HttpWebRequest)WebRequest.CreateHttp(url.ToString());
        req.Method = Method.Method;
        if (headers != null)
            req.Headers = Headers;
        if (cert != null)
            req.ClientCertificates.Add(cert);
        req.AutomaticDecompression = AutomaticDecompression;
        if (HttpMethod.Post.Equals(Method) || HttpMethod.Put.Equals(Method))
        {
            var tOs = new TaskCompletionSource<IAsyncResult>();
            req.BeginGetRequestStream(x => tOs.TrySetResult(x), null);
            await tOs.Task;
            using (var sOut = (Stream)req.EndGetRequestStream(tOs.Task.Result))
            {
                if (Body != null)
                {
                    using (var sw = new StreamWriter(sOut, Encoding.UTF8))
                    using (var jw = new JsonTextWriter(sw))
                    {
                        var ser = new JsonSerializer();
                        ser.Serialize(jw, Body);
                    }
                    req.ContentType = "application/json";
                }
            }
        }
        var tcs2 = new TaskCompletionSource<IAsyncResult>();
        req.BeginGetResponse(x => tcs2.TrySetResult(x), null);
        await tcs2.Task;
        var wr = (HttpWebResponse)req.EndGetResponse(tcs2.Task.Result);
        return wr;
    }

    public string Url { get { return url.ToString(); } }

    public async Task<T> QueryJsonAsync<T>()
    {
        var wr = await QueryAsync();
        ValidateResponse(wr);
        return ReadResponse<T>(wr);
    }

    public static void ValidateResponse(HttpWebResponse wr)
    {
        if (wr == null)
            throw new ArgumentNullException();
        bool success = (int)wr.StatusCode >= 200 && (int)wr.StatusCode <= 299;
        if (!success)
            throw new HttpRequestException($"Problem {wr.StatusCode}: {wr.StatusDescription}");
    }

    public static T ReadResponse<T>(HttpWebResponse wr)
    {
        var sResponse = wr.GetResponseStream();
        using (var sr = new StreamReader(wr.GetResponseStream()))
        using (var js = new JsonTextReader(sr))
        {
            var ser = new JsonSerializer();
            var result = ser.Deserialize<T>(js);
            return result;
        }
    }
    public static string ReadResponse(HttpWebResponse wr)
    {
        var sResponse = wr.GetResponseStream();
        using (var sr = new StreamReader(wr.GetResponseStream()))
            return sr.ReadToEnd();
    }
}

interface IRemote
{
  void Execute(Command cmd)
}
interface ICommandHandler<T> where T: Command
{
   void Handle(T command);
}
class Service : IRemote
{
  public void Execute(Command cmd)
  {
     IoC.GetCommandHandler(cmd.GetType()).Handle(cmd);
  }
}

class DataContractSerializerSettings 
{
  public DataContractResolver DataContractResolver { get; set; }
}