public object BeforeSendRequest(ref Message request, IClientChannel channel)
 {
     HttpRequestMessageProperty property = new HttpRequestMessageProperty();
       property.Headers.Add("username", HttpContext.Current.User.Identity.Name);
       request.Properties.Add("username", property);
       return null;
 }

		internal void Apply (HttpRequestMessageProperty hp)
		{
			foreach (var key in Headers.AllKeys)
				hp.Headers [key] = Headers [key];
			if (Accept != null)
				hp.Headers ["Accept"] = Accept;
			if (ContentLength > 0)
				hp.Headers ["Content-Length"] = ContentLength.ToString (NumberFormatInfo.InvariantInfo);
			if (ContentType != null)
				hp.Headers ["Content-Type"] = ContentType;
			if (IfMatch != null)
				hp.Headers ["If-Match"] = IfMatch;
			if (IfModifiedSince != null)
				hp.Headers ["If-Modified-Since"] = IfModifiedSince;
			if (IfNoneMatch != null)
				hp.Headers ["If-None-Match"] = IfNoneMatch;
			if (IfUnmodifiedSince != null)
				hp.Headers ["If-Unmodified-Since"] = IfUnmodifiedSince;
			if (Method != null)
				hp.Method = Method;
			if (SuppressEntityBody)
				hp.SuppressEntityBody = true;
			if (UserAgent != null)
				hp.Headers ["User-Agent"] = UserAgent;
		}

		public object BeforeSendRequest(ref Message request, IClientChannel channel)
		{
			var tokenInjector = ServiceLocator.Current.GetInstance<ISecurityTokenInjector>();

			if (tokenInjector != null)
			{
				object httpRequestMessageObject;

				if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out httpRequestMessageObject))
				{
					var httpRequestMessage = httpRequestMessageObject as HttpRequestMessageProperty;

					if (httpRequestMessage != null)
						tokenInjector.InjectToken(httpRequestMessage.Headers);
				}
				else
				{
					var httpRequestMessage = new HttpRequestMessageProperty();
					tokenInjector.InjectToken(httpRequestMessage.Headers);
					request.Properties.Add(HttpRequestMessageProperty.Name, httpRequestMessage);
				}
			}

			return null;
		}

 public static void QueryString_Property_Sets()
 {
     const string newQueryString = "name=Mary";
     HttpRequestMessageProperty requestMsgProperty = new HttpRequestMessageProperty();
     requestMsgProperty.QueryString = newQueryString;
     Assert.Equal<string>(newQueryString, requestMsgProperty.QueryString);
 }

        static void Main(string[] args)
        {
            var aosUriString = ClientConfiguration.Default.UriString;

            var oauthHeader = OAuthHelper.GetAuthenticationHeader();
            var serviceUriString = SoapUtility.SoapHelper.GetSoapServiceUriString(UserSessionServiceName, aosUriString);

            var endpointAddress = new System.ServiceModel.EndpointAddress(serviceUriString);
            var binding = SoapUtility.SoapHelper.GetBinding();

            var client = new UserSessionServiceClient(binding, endpointAddress);
            var channel = client.InnerChannel;

            UserSessionInfo sessionInfo = null;

            using (OperationContextScope operationContextScope = new OperationContextScope(channel))
            {
                HttpRequestMessageProperty requestMessage = new HttpRequestMessageProperty();
                 requestMessage.Headers[OAuthHelper.OAuthHeader] = oauthHeader;
                 OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage;
                 sessionInfo = ((UserSessionService)channel).GetUserSessionInfo(new GetUserSessionInfo()).result;
            }

            Console.WriteLine();
            Console.WriteLine("User ID: {0}", sessionInfo.UserId);
            Console.WriteLine("Is Admin: {0}", sessionInfo.IsSysAdmin);
            Console.ReadLine();
        }

        public static void Main()
        {
            // Typically this request would be constructed by a web browser or non-WCF application instead of using WCF

            Console.WriteLine("Starting client with ByteStreamHttpBinding");

            using (ChannelFactory<IHttpHandler> cf = new ChannelFactory<IHttpHandler>("byteStreamHttpBinding"))
            {
                IHttpHandler channel = cf.CreateChannel();
                Console.WriteLine("Client channel created");

                Message byteStream = Message.CreateMessage(MessageVersion.None, "*", new ByteStreamBodyWriter(TestFileName));
                HttpRequestMessageProperty httpRequestProperty = new HttpRequestMessageProperty();
                httpRequestProperty.Headers.Add("Content-Type", "application/octet-stream");
                byteStream.Properties.Add(HttpRequestMessageProperty.Name, httpRequestProperty);

                Console.WriteLine("Client calling service");
                Message reply = channel.ProcessRequest(byteStream);

                //Get bytes from the reply 
                XmlDictionaryReader reader = reply.GetReaderAtBodyContents();
                reader.MoveToElement();
                String name = reader.Name;
                Console.WriteLine("First element in the byteStream message is : <" + name + ">");
                byte[] array = reader.ReadElementContentAsBase64();
                String replyMessage = System.Text.Encoding.UTF8.GetString(array);
                Console.WriteLine("Client received a reply from service of length :" + replyMessage.Length);
            }

            Console.WriteLine("Done");
            Console.WriteLine("Press <ENTER> to exit client");
            Console.ReadLine();
        }

 public static void Method_Property_Sets()
 {
     const string newMethod = "PUT";
     HttpRequestMessageProperty requestMsgProperty = new HttpRequestMessageProperty();
     requestMsgProperty.Method = newMethod;
     Assert.Equal<string>(newMethod, requestMsgProperty.Method);
 }

 private static Message CreateNormalRequestMessage()
 {
     var requestProperty = new HttpRequestMessageProperty();
      Message requestMessage = Message.CreateMessage(MessageVersion.None, null);
      requestMessage.Properties.Add(HttpRequestMessageProperty.Name, requestProperty);
      return requestMessage;
 }

 public object BeforeSendRequest(ref System.ServiceModel.Channels.Message Request,
     System.ServiceModel.IClientChannel Channel)
     {
     HttpRequestMessageProperty httpRequestMessage;
     object httpRequestMessageObject;
     if (Request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out httpRequestMessageObject))
         {
         httpRequestMessage = httpRequestMessageObject as HttpRequestMessageProperty;
         if (String.IsNullOrEmpty(httpRequestMessage.Headers["WPMediaToken"]))
             {
             if (WMB.WPMediaApplicationState.Instance.Properties.ContainsKey("WPMediaToken"))
                 httpRequestMessage.Headers["WPMediaToken"] = WMB.WPMediaApplicationState.Instance.Properties["WPMediaToken"].ToString();
             }
         }
     else
         {
         if (WMB.WPMediaApplicationState.Instance.Properties.ContainsKey("WPMediaToken"))
             {
             httpRequestMessage = new HttpRequestMessageProperty();
             httpRequestMessage.Headers.Add("WPMediaToken",
                 WMB.WPMediaApplicationState.Instance.Properties["WPMediaToken"].ToString());
             Request.Properties.Add(HttpRequestMessageProperty.Name, httpRequestMessage);
             }
         }
     return null;
     }

        static void Main(string[] args)
        {
            var binding = new WSHttpBinding(SecurityMode.Transport);
            binding.Name = "binding";
            binding.MaxReceivedMessageSize = 500000;
            binding.AllowCookies = true;

            var client = new SyncReplyClient(binding, new EndpointAddress("https://platform.gaelenlighten.com/api/soap12"));

            using (new OperationContextScope(client.InnerChannel))
            {
                var requestMessage = new HttpRequestMessageProperty();
                requestMessage.Headers["Tenant"] = "tenant.gaelenlighten.com"; // Add your tenant
                var token = "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes("username:password")); // Add your username and password here
                requestMessage.Headers["Authorization"] = token;
                OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessage;

                var response = client.GetReports(new GetReports
                {
                    //// Specify filters
                    ReportStatus = ReportStatus.New,
                    Take = 100,
                    Skip = 0
                });

                var reportList = response.Reports;
                foreach (var report in reportList)
                {
                    ////Example of iterating through the report list
                }
                response.PrintDump();

                Console.ReadLine();
            }
        }

 public object BeforeSendRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel)
 {
     HttpRequestMessageProperty httpRequestMessage;
     object httpRequestMessageObject;
     if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out httpRequestMessageObject))
     {
         httpRequestMessage = httpRequestMessageObject as HttpRequestMessageProperty;
         if (string.IsNullOrEmpty(httpRequestMessage.Headers[HttpRequestHeader.Authorization]))
         {
             var authResult = Expenses.WPF.AADSignIn.AADAuthResult;
             if (authResult != null)
             {
                 httpRequestMessage.Headers[HttpRequestHeader.Authorization] = Expenses.WPF.AADSignIn.AADAuthResult.CreateAuthorizationHeader();
             }
         }
     }
     else
     {
         var authResult = Expenses.WPF.AADSignIn.AADAuthResult;
         if (authResult != null)
         {
             httpRequestMessage = new HttpRequestMessageProperty();
             httpRequestMessage.Headers.Add(HttpRequestHeader.Authorization, Expenses.WPF.AADSignIn.AADAuthResult.CreateAuthorizationHeader());
             request.Properties.Add(HttpRequestMessageProperty.Name, httpRequestMessage);
         }
     }
     return null;
 }

		internal IncomingWebRequestContext (OperationContext context)
		{
			if (context.IncomingMessageProperties != null)
				hp = (HttpRequestMessageProperty) context.IncomingMessageProperties [HttpRequestMessageProperty.Name];
			else
				hp = new HttpRequestMessageProperty ();
		}

 public object BeforeSendRequest(ref Message request, IClientChannel channel)
 {
     object httpRequestMessageObject;
     if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out httpRequestMessageObject))
     {
         HttpRequestMessageProperty httpRequestMessage = httpRequestMessageObject as HttpRequestMessageProperty;
         if (httpRequestMessage != null)
         {
             httpRequestMessage.Headers[SERVICE_KEY_HTTP_HEADER] = (ServiceKey ?? string.Empty);
         }
         else
         {
             httpRequestMessage = new HttpRequestMessageProperty();
             httpRequestMessage.Headers.Add(SERVICE_KEY_HTTP_HEADER, (ServiceKey ?? string.Empty));
             request.Properties[HttpRequestMessageProperty.Name] = httpRequestMessage;
         }
     }
     else
     {
         HttpRequestMessageProperty httpRequestMessage = new HttpRequestMessageProperty();
         httpRequestMessage.Headers.Add(SERVICE_KEY_HTTP_HEADER, (ServiceKey ?? string.Empty));
         request.Properties.Add(HttpRequestMessageProperty.Name, httpRequestMessage);
     }
     return null;
 }

        /// <summary>
        /// Enables inspection or modification of a message before a request message is sent to a service.
        /// </summary>
        /// <returns>
        /// The object that is returned as the <paramref name="correlationState "/>argument of the <see cref="M:System.ServiceModel.Dispatcher.IClientMessageInspector.AfterReceiveReply([email protected],System.Object)"/> method. This is null if no correlation state is used.The best practice is to make this a <see cref="T:System.Guid"/> to ensure that no two <paramref name="correlationState"/> objects are the same.
        /// </returns>
        /// <param name="request">The message to be sent to the service.</param><param name="channel">The WCF client object channel.</param>
        public object BeforeSendRequest(ref Message request, IClientChannel channel)
        {
            HttpRequestMessageProperty httpRequest;
            if (request.Properties.ContainsKey(HttpRequestMessageProperty.Name))
            {
                httpRequest = request.Properties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
            }
            else
            {
                httpRequest = new HttpRequestMessageProperty();
                request.Properties.Add(HttpRequestMessageProperty.Name, httpRequest);
            }
            if (httpRequest != null)
            {
                httpRequest.Headers.Add("Authorization", string.Format("{0}", AdalTokenManager.GetToken(serviceName).CreateAuthorizationHeader()));
                var supportCode = "";
                RuntimeFactory.Current.GetStateStorageContainer().TryGetItem("supportCode", out supportCode);
                var meta = new RequestHeader
                             {
                                 Environment = Utilities.GetEnvironment(),
                                 ConfigSet = Utilities.GetConfigSetName(),
                                 ServiceName = RuntimeFactory.Current.ServiceName,
                                 MessageId = Guid.NewGuid().ToString(),
                                 ServerIdentity = Environment.MachineName,
                                 RuntimeInstance = RuntimeFactory.Current.InstanceId.ToString(),
                                 SupportCode = supportCode
                             };
                httpRequest.Headers.Add("X-Stardust-Meta", Convert.ToBase64String(JsonConvert.SerializeObject(meta).GetByteArray()));
            }

            return RuntimeFactory.Current;

        }

        protected async void Button1_Click(object sender, EventArgs e)
        {
            var authServer = new AuthorizationServerDescription()
            {
                
                TokenEndpoint = new Uri("http://localhost:53022/OAuth/token "),
                ProtocolVersion = ProtocolVersion.V20
            };
            WebServerClient Client= new WebServerClient(authServer, "idefav", "1");

            var code =await Client.GetClientAccessTokenAsync(new string[] { "http://localhost:55045/IService1/DoWork" });
            string token = code.AccessToken;
            Service1Reference.Service1Client service1Client=new Service1Client();
            var httpRequest = (HttpWebRequest)WebRequest.Create(service1Client.Endpoint.Address.Uri);
            ClientBase.AuthorizeRequest(httpRequest,token);
            var httpDetails = new HttpRequestMessageProperty();
            httpDetails.Headers[HttpRequestHeader.Authorization] = httpRequest.Headers[HttpRequestHeader.Authorization];
            
            using (var scope = new OperationContextScope(service1Client.InnerChannel))
            {
                
                if (OperationContext.Current.OutgoingMessageProperties.ContainsKey(HttpRequestMessageProperty.Name))
                {
                    OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = httpDetails;
                }
                else
                {
                    OperationContext.Current.OutgoingMessageProperties.Add(HttpRequestMessageProperty.Name, httpDetails);
                }
                
                Button1.Text= service1Client.DoWork();
            }


        }

    public static void DigestAuthentication_Echo_RoundTrips_String_No_Domain()
    {
        ChannelFactory<IWcfService> factory = null;
        IWcfService serviceProxy = null;
        string testString = "Hello";
        BasicHttpBinding binding;

        try
        {
            // *** SETUP *** \\
            binding = new BasicHttpBinding(BasicHttpSecurityMode.TransportCredentialOnly);
            binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Digest;
            factory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(Endpoints.Http_DigestAuth_NoDomain_Address));

            string DigestUsernameHeaderName = "DigestUsername";
            string DigestPasswordHeaderName = "DigestPassword";
            string DigestRealmHeaderName = "DigestRealm";
            string username = Guid.NewGuid().ToString("n").Substring(0, 8);
            string password = Guid.NewGuid().ToString("n").Substring(0, 16);
            string realm = Guid.NewGuid().ToString("n").Substring(0, 5);
            factory.Credentials.HttpDigest.ClientCredential = new NetworkCredential(username, password, realm);

            serviceProxy = factory.CreateChannel();

            // *** EXECUTE *** \\
            string result = null;
            using (var scope = new OperationContextScope((IContextChannel)serviceProxy))
            {
                HttpRequestMessageProperty requestMessageProperty;
                if (!OperationContext.Current.OutgoingMessageProperties.ContainsKey(HttpRequestMessageProperty.Name))
                {
                    requestMessageProperty = new HttpRequestMessageProperty();
                    OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = requestMessageProperty;
                }
                else
                {
                    requestMessageProperty = (HttpRequestMessageProperty)OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name];
                }

                requestMessageProperty.Headers[DigestUsernameHeaderName] = username;
                requestMessageProperty.Headers[DigestPasswordHeaderName] = password;
                requestMessageProperty.Headers[DigestRealmHeaderName] = realm;

                result = serviceProxy.Echo(testString);
            }

            // *** VALIDATE *** \\
            Assert.True(result == testString, string.Format("Error: expected response from service: '{0}' Actual was: '{1}'", testString, result));

            // *** CLEANUP *** \\
            factory.Close();
            ((ICommunicationObject)serviceProxy).Close();
        }
        finally
        {
            // *** ENSURE CLEANUP *** \\
            ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory);
        }
    }

 private static Message CreateRequestMessage(string authorizationheaderToAdd)
 {
     const string BasicAuthenticationHeaderName = "Authorization";
      Message requestMessage = Message.CreateMessage(MessageVersion.None, null);
      var requestProperty = new HttpRequestMessageProperty();
      requestProperty.Headers.Add(BasicAuthenticationHeaderName, authorizationheaderToAdd);
      requestMessage.Properties.Add(HttpRequestMessageProperty.Name, requestProperty);
      return requestMessage;
 }

    public static void Default_Ctor_Initializes_Properties()
    {
        HttpRequestMessageProperty requestMsgProperty = new HttpRequestMessageProperty();

        Assert.NotNull(requestMsgProperty.Headers);
        Assert.Equal<string>("POST", requestMsgProperty.Method);
        Assert.Equal<string>(string.Empty, requestMsgProperty.QueryString);
        Assert.False(requestMsgProperty.SuppressEntityBody);
    }

 static string GetOperationName(Uri address, IDispatchOperationSelector operationSelector)
 {
     Message message = Message.CreateMessage(MessageVersion.None, "");
     message.Headers.To = address;
     HttpRequestMessageProperty messageProperty = new HttpRequestMessageProperty();
     messageProperty.Method = "GET";
     message.Properties.Add(HttpRequestMessageProperty.Name, messageProperty);
     return operationSelector.SelectOperation(ref message);
 }

        public object BeforeSendRequest(ref Message request, IClientChannel channel)
        {
            MessageBuffer buffer = request.CreateBufferedCopy(Int32.MaxValue);
            request = buffer.CreateMessage();
            Message msg = buffer.CreateMessage();
            ASCIIEncoding encoder = new ASCIIEncoding();

            var sb = new StringBuilder();
            var xmlWriter = XmlWriter.Create(sb, new XmlWriterSettings
            {
                OmitXmlDeclaration = true
            });
            var writer = XmlDictionaryWriter.CreateDictionaryWriter(xmlWriter);
            msg.WriteStartEnvelope(writer);
            msg.WriteStartBody(writer);
            msg.WriteBodyContents(writer);
            xmlWriter.WriteEndElement();
            xmlWriter.WriteEndElement();
            writer.Flush();

            string body = sb.ToString().Replace(" />", "/>");

            byte[] xmlByte = encoder.GetBytes(body);
            SHA1CryptoServiceProvider sha1Crypto = new SHA1CryptoServiceProvider();
            string hash = BitConverter.ToString(sha1Crypto.ComputeHash(xmlByte)).Replace("-", "");
            string hashedContent = hash.ToLower();

            //assign values to hashing and header variables
            string time = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string hashData = "POST\ntext/xml; charset=utf-8\n" + hashedContent + "\n" + time + "\n/transaction/v12";
            //hmac sha1 hash with key + hash_data
            HMAC hmacSha1 = new HMACSHA1(Encoding.UTF8.GetBytes(_hmac)); //key
            byte[] hmacData = hmacSha1.ComputeHash(Encoding.UTF8.GetBytes(hashData)); //data
            //base64 encode on hmac_data
            string base64Hash = Convert.ToBase64String(hmacData);

            HttpRequestMessageProperty httpRequestMessage;
            object httpRequestMessageObject;

            if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out httpRequestMessageObject))
            {
                httpRequestMessage = httpRequestMessageObject as HttpRequestMessageProperty;
                httpRequestMessage.Headers["X-GGe4-Content-SHA1"] = hashedContent;
                httpRequestMessage.Headers["X-GGe4-Date"] = time;
                httpRequestMessage.Headers["Authorization"] = "GGE4_API " + _keyId + ":" + base64Hash;
            }
            else
            {
                httpRequestMessage = new HttpRequestMessageProperty();
                httpRequestMessage.Headers["X-GGe4-Content-SHA1"] = hashedContent;
                httpRequestMessage.Headers["X-GGe4-Date"] = time;
                httpRequestMessage.Headers["Authorization"] = "GGE4_API " + _keyId + ":" + base64Hash;
                request.Properties.Add(HttpRequestMessageProperty.Name, httpRequestMessage);
            }
            return null;
        }