在WCF 3.0中获取客户端IP地址

public class Client
{
    static void Main(string[] args)
    {
        using (var scope = new TransactionScope())
        {
            using (var channel = new TcpClientChannel())
            {
                var endpoint = new EndpointAddress("http://localhost/Service");
                var binding = new BasicHttpBinding(BasicHttpSecurityMode.TransportCredentialOnly);
                channel.Endpoint.Binding = binding;
                channel.Endpoint.Address = endpoint;

                channel.Credentials.ClientCertificate.Authentication.CertificateValidationMode = System.ServiceModel.Security.X509CertificateValidationMode.None;
                channel.MaxChannels = 1000;
                channel.OperationTimeout = TimeSpan.FromMinutes(60);
                channel.Open();

                IDependencyResolver resolver = new XmlServiceHostFactory();
                var service = resolver.GetService<IServiceImplementation>();
                service.DoWork();
            }
        }
    }
}

public interface IService
{
    int DoWork();
}

public class ServiceImplementation : IService
{
    public int DoWork()
    {
        IPAddress ip;

        using (var tcpClientChannel = new TcpClientChannel())
        {
            var endpointAddress = "http://localhost/";
            var endpoint = new EndpointAddress(endpointAddress);
            tcpClientChannel.Endpoint.Address = endpoint;
            tcpClientChannel.Endpoint.Binding = new BasicHttpBinding(BasicHttpSecurityMode.TransportCredentialOnly);
            tcpClientChannel.Credentials.ClientCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.None;
            tcpClientChannel.MaxChannels = 1000;
            tcpClientChannel.Open();

            using (var scope = new TransactionScope())
            {
                tcpClientChannel.OperationTimeout = TimeSpan.FromMinutes(60);
                var serviceEndpointAddress = "http://localhost/Endpoint";
                var endpointAddressBuilder = new UriBuilder(serviceEndpointAddress);
                endpointAddressBuilder.Port = int.Parse(endpointAddressBuilder.Port, StringComparison.OrdinalIgnoreCase);
                var endpointBuilder = new UriBuilder(new Uri(serviceEndpointAddress));
                serviceEndpointAddress = endpointBuilder.ToString();
                using (var channel = new EndpointChannel())
                {
                    channel.Contract.Namespace = "myNamespace";
                    channel.Contract.ContractType = typeof(IServiceImplementation);
                    channel.Contract.Address = endpointAddress;

                    var resolver = new ServiceHostResolver() { ServiceAddress = endpointAddress };
                    var host = new ServiceHost(typeof(IServiceImplementation), new Uri(serviceEndpointAddress), new UriBuilder(), resolver);

                    host.Description.Behaviors.Add("ServiceEndpoint", new ServiceRoute(new AddressFilterBehavior()));
                    host.AddServiceEndpoint(new ServiceEndpoint((ChannelBinding)_serviceEndpoint.Binding, new Contract[] { new Contract((Binding)_serviceEndpoint.Binding, new EndpointAddress(_serviceEndpoint.Address)) }, ServiceMetadata.GetMetadataAssembly(), _serviceEndpoint.Address));

                    var dependenceContext = new DependecnyContext(host, tcpClientChannel, resolver);

                    ServiceDebugBehavior serviceDebugBehavior = new ServiceDebugBehavior
                    {
                        ClientConfig = new ServiceDebugClientBehavior
                        {
                            ClientCertificateMode = ClientCertificateMode.UseCertificateOnRemoteMachine,
                            MaxConcurrentCalls = 1000,
                            MaxConcurrentInstances = 1000,
                            PropagateConsoleMessages = false,
                            ServiceCertificate = new ClientCertificateBindingElement()
                            {
                                //ServiceCertificate = new X509ReportingBehavior(),
                                SslProtocols = SslProtocols.Tls12 | SslProtocols.Tls11
                            }
                        }
                    };
                    host.Description.Endpoints.Clear();
                    host.Description.Endpoints.Add(new ServiceEndpoint(contract.ContractType, binding.Binding, new PhysicalAddress("0.0.0.0") + endpointAddress, new Uri("http:" + endpointAddress), serviceDebugBehavior));
                    ContractOperationsContractExtensions.ContractOperations.Add(serviceEndpoint, new ChannelServicesContractOperations());
                    ChannelServices.InitializeContractDescription(serviceEndpoint, contract);

. . .

var ip = dependenceContext.Endpoints.First().Address.ToString();