Question

In my client/server application, I want count other value in everyone client.
I made application using callbacks, but something is wrong. I get Exception, when I want call method pipeproxy.polacz(S); Which get value to server and write in server console now.

Exception is:

This operation would deadlock because the reply cannot be received until the current Message completes processing. If you want to allow out-of-order message processing, specify ConcurrencyMode of Reentrant or Multiple on CallbackBehaviorAttribute.

Other problem is, how sum resault in this funkction from all clients.
example;

client 1: S = 1;  
client 2: S = 2;  
client 3: S = 3;

And this function take result from all clients and sum it. So server will write 6 in server console.

My application code:

server:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using Interface;

namespace WCFapp
{
    class Program
    {
        static void Main(string[] args)
        {
            Klienci cust = new Klienci();
            cust.Connect();
        }
    }
}

.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Interface;

namespace WCFapp
{
     [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
class Klienci : IMessage
{
    private static List<ImessageCallback> subscribers =
        new List<ImessageCallback>();

    public void lista()
    {
        string nm = Console.ReadLine();
        if (nm == "1")
        {
            Console.WriteLine("Number of conected clients: " + subscribers.Count());
            funkcja();

        }
    }

    public void Connect()
    {
        using (ServiceHost host = new ServiceHost(
            typeof(Klienci), new Uri("net.tcp://localhost:8000")))
        {
            host.AddServiceEndpoint(typeof(IMessage),
                new NetTcpBinding(), "ISubscribe");

            try
            {
                host.Open();
                lista();
                Console.ReadLine();
                host.Close();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }

    public bool Subscribe()
    {
        try
        {
            ImessageCallback callback = OperationContext.Current.GetCallbackChannel<ImessageCallback>();
            if (!subscribers.Contains(callback))
                subscribers.Add(callback);
            Console.WriteLine("Client is conected ({0}).", callback.GetHashCode());
            return true;
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
            return false;
        }
    }

    public bool Unsubscribe()
    {
        try
        {
            ImessageCallback callback = OperationContext.Current.GetCallbackChannel<ImessageCallback>();
            if (subscribers.Contains(callback))
                subscribers.Remove(callback);
            Console.WriteLine("Client is unconected ({0}).", callback.GetHashCode());
            return true;
        }
        catch
        {
            return false;
        }
    }

    public void funkcja()
    {
        int a = 1; int b = 3;
        subscribers.ForEach(delegate(ImessageCallback callback)
        {
            if (((ICommunicationObject)callback).State == CommunicationState.Opened)
            {
            Console.WriteLine("a= {0} , b= {1}", a, b);
            callback.klient_licz(a, b);
            a++;
            b++;
            }
        });

    }

    public void polacz(int S)
    {

        Console.WriteLine("Sum: {0}", S);
    }
  }
}

Interface:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;


namespace Interface
{
     [ServiceContract(CallbackContract = typeof(ImessageCallback), SessionMode = SessionMode.Required)]
public interface IMessage
{
    [OperationContract]
    void funkcja();

    [OperationContract]
    void polacz(int S);

    [OperationContract]
    bool Subscribe();

    [OperationContract]
    bool Unsubscribe();

}
[ServiceContract]
public interface ImessageCallback
{
    [OperationContract]
    void klient_licz(int a, int b);
}

}

Client:

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using Interface;

namespace Client
{
    class Program
    {
        static void Main(string[] args)
        {
            clients cl = new clients();
            if (cl.Conect() == true)
            {
                string tmp = Console.ReadLine();
                while (tmp != "EXIT")
                {
                    cl.SendMessage(tmp);
                    tmp = Console.ReadLine();
                }

            }
             cl.Close();
             Environment.Exit(0);
       }
   }
}

.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using Interface;

namespace Client
{
    class clients : ImessageCallback, IDisposable
    {
        IMessage pipeProxy = null;
        public bool Conect()
        {
            DuplexChannelFactory<IMessage> pipeFactory =
                new DuplexChannelFactory<IMessage>(
                    new InstanceContext(this),
                    new NetTcpBinding(),
                    new EndpointAddress("net.tcp://localhost:8000/ISubscribe"));
            try
            {
                pipeProxy = pipeFactory.CreateChannel();
                pipeProxy.Subscribe();
               return true;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return false;
            }

        }

        public void Close()
        {
            pipeProxy.Unsubscribe();
        }


        public void klient_licz(int a, int b)
        {
            int S = a + b;
            Console.WriteLine("Sum= {0}", S);
            pipeProxy.polacz(S); //ERROR
        }

    }
}

Answer 1

The issue here is that inside your callback method klient_licz (which is called by the server) you are making another server call. This is not allowed the way your contracts are currently setup.

1. Check you really need this behaviour. Do you really need to make a server call INSIDE a method on the callback interface (klient_licz).

2. If you do need this behaviour then you might be able to fix things by marking the klient_licz call OneWay on the callback interface. That will mean that server call to the callback will not block until the client returns (which is what is currently causing your issue because the server is waiting for the client call to return but the client call is waiting on a call to the server):

   [ServiceContract]  
   public interface ImessageCallback {  
           [OperationContract(IsOneWay = true)]  
           void klient_licz(int a, int b);  
   }
   

3. Alternatively you could mark the callback implimentation with a concurrancy mode other than the default mode Single. Eg Reentrant as follows – but bear in mind that this means that calls to callback will not long be marshalled to the UI thead ie will be on threadpool threads so you would have to dispatch to update the UI from method on the callback interface:

   [CallbackBehavior(ConcurrencyMode = ConcurrencyMode.Reentrant)]  
   class clients : ImessageCallback, IDisposable {  
    ...
   }
   

If you want to understand ConcurrencyMode and how it effects execution then you will really need to do someback ground reading as it does get a little complicated – but if you dont have that background it is difficult to really understand what is happen when you change the ConcurrencyMode. This dasBlonde blog post has a good summary of the different modes and behaviour – but you might want to start with some tutorials that are a bit more beginner orientated.