http://stackoverflow.com question 7986429

    public delegate void RequestCompleteHandler(HPCRequest request);

    public class HPCRequest : BindingObjectBase
    {
        #region Events
        public RequestCompleteHandler RequestComplete;
        #endregion

        #region Protected Properties
        protected readonly RequestState State;
        private readonly string hpcServer;
        private readonly string hpcRequestString;
        protected string hpcRequestParameters = string.Empty;
        private delegate void HTTPDelegate();
        private delegate void CompletedDelegate(RequestState state);
        #endregion

        #region Public Properties
        public HPCRequestEnum HPCFunction { get; private set; }
        public string RequestPath
        {
            get
            {
                return String.Concat(hpcServer, "/", hpcRequestString, hpcRequestParameters);
            }
        }
        public int RequestTimeout = 60000;
        public bool ResponseOK { get; set; }
        public string HPCResponse { get { return State.Content; } }
        public string FormattedResponse { get; protected set; }
        #endregion

        #region Constructor
        protected HPCRequest(HPCRequestEnum functionType)
        {
            HPCFunction = functionType;
            hpcRequestString = HPCFunction.RequestString();

            State = new RequestState(this);
            hpcServer = ((MUSUI.App)App.Current).HPCServer;
        }
        #endregion

        #region Public Methods
        public void SendRequest()
        {
            string request = String.Concat(hpcServer, "/", hpcRequestString, hpcRequestParameters);
            System.Diagnostics.Debug.WriteLine("SendRequest: " + request);
            HttpModule.SendRequest(request, RequestTimeout, State);

            if( App.Current != null )
                App.Current.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new CompletedDelegate(ResponseReceived), State);
        }

        public void SendRequestAsync()
        {
            Thread thread = new Thread( new ThreadStart( new HTTPDelegate(SendRequest) ));
            thread.Start();
        }
        #endregion Public Methods

        #region Private Methods
        private void ResponseReceived(RequestState state)
        {
            ResponseOK = state.HTTPStatus == HttpStatusCode.OK;
            System.Diagnostics.Debug.WriteLine(String.Concat("ResponseReceived: ", hpcServer, "/", hpcRequestString, hpcRequestParameters));
            System.Diagnostics.Debug.WriteLine(String.Concat("HTTPStatus: ", state.HTTPStatus));
            System.Diagnostics.Debug.WriteLine(String.Concat("Content: ", state.Content));
            FormattedResponse = state.Content;
            OnRequestComplete(state);
        }

        protected virtual void OnRequestComplete(RequestState state)
        {
            if (RequestComplete != null)
            {
                RequestComplete(this);
            }
            InvokePropertyChanged("Content");
            InvokePropertyChanged("State");
        }
        #endregion Private Methods
    }


    public sealed class HPCGetConfig : HPCRequest
    {
        private string[] referencePortfolioIDs;
        private string[] simGridIDs;

        public string[] ReferencePortfolioIDs { get { return referencePortfolioIDs; } }
        public string[] SimGridIDs { get { return simGridIDs; } }

        public HPCGetConfig() : base(HPCRequestEnum.HPCGetConfig) { }

        protected sealed override void OnRequestComplete(RequestState state)
        {
            if (ResponseOK)
            {
                referencePortfolioIDs = state.extractContentValue("ReferencePortfolioIds").Split('|');
                simGridIDs = state.extractContentValue("SimGridIds").Split('|');
                InvokePropertyChanged("ReferencePortfolioIDs");
                InvokePropertyChanged("SimGridIDs");
            }
            base.OnRequestComplete(state);
        }
    }

    public class Tester
    {

        void GetConfigCommand_Execute()
        {
            HPCGetConfig request = new HPCGetConfig();
            request.RequestComplete += new RequestCompleteHandler(HPCGetConfig_RequestComplete);
            request.SendRequestAsync();
        }

        void HPCGetConfig_RequestComplete(HPCRequest req)
        {
            HPCGetConfig request = (HPCGetConfig) req;
            request.RequestComplete -= HPCGetConfig_RequestComplete;

            if (request.ResponseOK)
            {
                System.Diagnostics.Debug.Assert(request.SimGridIDs.Length > 0)
            }
            else
            {
                //...
            }
        }
    }


///INCLUDED SO THE CODE COMPILES

    public static class HttpModule
    {
        public static RequestState SendRequest(string uri, int timeout, RequestState state)
        {
            HttpWebRequest _WebRequest;
            HttpWebResponse _WebResponse;
            HttpStatusCode status = HttpStatusCode.ServiceUnavailable;
            string content = string.Empty;

            try
            {
                _WebRequest = CreateWebRequest(new Uri(uri), new NameValueCollection(), "GET");
                _WebRequest.UserAgent = "MUS " + System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
                _WebRequest.Timeout = timeout;
                _WebResponse = (HttpWebResponse)_WebRequest.GetResponse();

                status = _WebResponse.StatusCode;
                content = GetContentFromResponse(_WebResponse);
            }
            catch (WebException ex)
            {
                if (ex.Response != null)
                {
                    status = ((HttpWebResponse)ex.Response).StatusCode;
                    content = string.Concat(status.ToString(), "\r\n", GetContentFromResponse(((HttpWebResponse)ex.Response)));
                }
                else
                {
                    status = ex.Status == WebExceptionStatus.Timeout ? HttpStatusCode.RequestTimeout : HttpStatusCode.BadRequest;
                    content = ex.Message;
                }
            }
            catch (Exception ex)
            {
                status = HttpStatusCode.BadRequest;
                content = ex.Message;
            }

            state.Content = content;
            state.HTTPStatus = status;
            return state;
        }

        public static string GetContentFromResponse(HttpWebResponse response)
        {
            Encoding enc = System.Text.Encoding.GetEncoding(1252);
            StreamReader stream = new StreamReader(response.GetResponseStream(), enc);
            string content = stream.ReadToEnd();
            stream.Close();

            return content;
        }

        public static void CancelRequest(HttpWebRequest WebRequest)
        {
            WebRequest.Abort();
        }

        public static HttpWebRequest CreateWebRequest(Uri uri, NameValueCollection collHeader, string RequestMethod)
        {
            HttpWebRequest webrequest = (HttpWebRequest)WebRequest.Create(uri);
            webrequest.KeepAlive = false;
            webrequest.Method = RequestMethod;

            int iCount = collHeader.Count;
            string key;
            string keyvalue;

            for (int i = 0; i < iCount; i++)
            {
                key = collHeader.Keys[i];
                keyvalue = collHeader[i];
                webrequest.Headers.Add(key, keyvalue);
            }

            webrequest.ContentType = "application/x-www-form-urlencoded";
            webrequest.Accept = "text/plain";
            webrequest.AllowAutoRedirect = false;
            webrequest.Credentials = CredentialCache.DefaultNetworkCredentials;
            collHeader.Clear();

            return webrequest;
        }
    }

    public class RequestState
    {
        #region Private Properties
        protected HPCRequest Parent { get; private set; }
        private string _Content;
        private HttpStatusCode _HTTPStatus;
        private bool Content_set = false;
        private bool HTTPStatus_set = false;
        #endregion

        #region Public Properties
        public string Content
        {
            get { return _Content;  }
            set
            {
                if (!Content_set)
                    _Content = value;
                else
                    throw new Exception("This class only allows the response content to be set once.");
            }
        }
        public HttpStatusCode HTTPStatus
        {
            get { return _HTTPStatus; }
            set
            {
                if (!HTTPStatus_set)
                    _HTTPStatus = value;
                else
                    throw new Exception("This class only allows the response status to be set once.");
            }
        }
        public HPCRequestEnum HPCFunction { get { return Parent.HPCFunction; } }
        #endregion Public Properties

        #region Constructors
        public RequestState(HPCRequest parent)
        {
            Parent = parent;
        }
        #endregion Constructors


        public string extractContentValue(string key)
        {
            int sPos = Content.IndexOf(key + "=");
            if (sPos != -1)
            {
                int len = key.Length + 1;
                int ePos = Content.IndexOf('&', sPos + len);
                if (ePos == -1)
                    return Content.Substring(sPos + len);
                else
                    return Content.Substring(sPos + len, ePos - (sPos + len));
            }
            else
                throw new MissingFieldException("Response field '" + key + "' not found.");
        }
    }


    public enum HPCRequestEnum
    {
        NotSet = 0, HPCGetConfig, HPCCreate, HPCRun, HPCGetStatus, HPCGetMarginals, HPCGetExpectedLosses, HPCGetReinstatements, HPCGetRetroCosts, HPCGetROETrialLosses, HPCDestroy
    }

    public static class HPCRequestEnumExtensions
    {
        public static string RequestString(this HPCRequestEnum HPCFunction)
        {
            switch (HPCFunction)
            {
                case HPCRequestEnum.HPCGetConfig: return "GetConfig";
                case HPCRequestEnum.HPCCreate: return "Create";
                case HPCRequestEnum.HPCRun: return "Run";
                case HPCRequestEnum.HPCGetStatus: return "GetStatus";
                case HPCRequestEnum.HPCGetMarginals: return "GetMarginals";
                case HPCRequestEnum.HPCGetExpectedLosses: return "GetExpectedLosses";
                case HPCRequestEnum.HPCGetReinstatements: return "GetExpectedReinstatements";
                case HPCRequestEnum.HPCGetRetroCosts: return "GetRetroCosts";
                case HPCRequestEnum.HPCGetROETrialLosses: return "GetROETrialLosses";
                case HPCRequestEnum.HPCDestroy: return "Destroy";
                default: return string.Empty;
            }
        }
    }