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

在 WCF 3.0 中，可以通过实现 IDependencyContext 和 IRequestChannel 来获取客户端的 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();
            }
        }
    }
}

客户端代码使用了一个 TCP 客户端 Channel 来与服务端创建一个网络连接。服务端通过在配置文件（Web.config）中添加一个 EndpointAddress 的值来指定了服务所在的地址和端口号。

客户端还使用一个名为“BasicHttpBinding”的 Binding 对象指定了基本 HTTP 绑定。它使用一个名为“BasicHttpSecurityMode”的可选属性值，该属性值指示是否只使用 TransportCredentialOnly 安全模式。这里我们将其设置为“TransportCredentialOnly”，这意味着客户端将不使用基本安全认证和授权服务中的任何用户证书或 Windows 身份验证提供程序。

最后，客户端将配置最大通道数和操作超时时间。在服务端中，我们将客户端 IP 地址通过一个名为 DependencyContext 的属性存储以便其他服务可以通过 DI 容器访问它。

在服务端：

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();