IClientMessageInspector detect one-way operation

Question

I need to do some operation logging in IClientMessageInspector and knowning when an operation has started and ended is vital. I can't however get AfterReceiveReply for one-way operations which is clear why. Is there a way to know that an operation is one-way in BeforeSendRequest overload so I could just ignore it?

Answer 1

Replying to myself, a the moment I'm doing this:

bool isOneWay = request.Headers.ReplyTo == null;

Answer 2

There's no information on the inspector itself (or the message passed to BeforeSendRequest), but you can pass this information to the inspector, and use the message action to see whether the operation is one way or not.

public class StackOverflow_10354828
{
    [ServiceContract]
    public interface ITest
    {
        [OperationContract]
        string Echo(string text);
        [OperationContract(IsOneWay = true)]
        void Process(string input);
    }
    public class Service : ITest
    {
        public string Echo(string text)
        {
            return text;
        }
        public void Process(string input) { }
    }
    class MyInspector : IClientMessageInspector
    {
        public HashSet<string> oneWayActions;

        public MyInspector(ServiceEndpoint endpoint)
        {
            this.oneWayActions = new HashSet<string>();
            foreach (var operation in endpoint.Contract.Operations)
            {
                if (operation.IsOneWay)
                {
                    oneWayActions.Add(operation.Messages[0].Action);
                }
            }
        }

        public void AfterReceiveReply(ref Message reply, object correlationState)
        {
            Console.WriteLine("In AfterReceiveReply");
        }

        public object BeforeSendRequest(ref Message request, IClientChannel channel)
        {
            Console.WriteLine("In BeginSendRequest");
            if (this.oneWayActions.Contains(request.Headers.Action))
            {
                Console.WriteLine("This is a one-way operation");
            }

            return null;
        }
    }
    class MyBehavior : IEndpointBehavior
    {
        public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
        {
        }

        public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
        {
            clientRuntime.MessageInspectors.Add(new MyInspector(endpoint));
        }

        public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
        {
        }

        public void Validate(ServiceEndpoint endpoint)
        {
        }
    }
    public static void Test()
    {
        string baseAddress = "http://" + Environment.MachineName + ":8000/Service";
        ServiceHost host = new ServiceHost(typeof(Service), new Uri(baseAddress));
        host.AddServiceEndpoint(typeof(ITest), new BasicHttpBinding(), "");
        host.Open();
        Console.WriteLine("Host opened");

        ChannelFactory<ITest> factory = new ChannelFactory<ITest>(new BasicHttpBinding(), new EndpointAddress(baseAddress));
        factory.Endpoint.Behaviors.Add(new MyBehavior());
        ITest proxy = factory.CreateChannel();
        proxy.Echo("Hello");
        Console.WriteLine();

        proxy.Process("world");
        Console.WriteLine();

        ((IClientChannel)proxy).Close();
        factory.Close();

        Console.Write("Press ENTER to close the host");
        Console.ReadLine();
        host.Close();
    }
}