A WCF-WPF Chat Application

• Download WCFWPFApp - 157 KB
• Download demo client - 101 KB

Introduction

This application is built on the WCF .NET Framework 3.0. It uses duplex communication and TCP binding (for some reasons that are discussed later in this article). It concentrates on handling and controlling a WCF service that has to make reliable sessions with many clients and keep those connections alive as long as possible.

The application UI is built on WPF .NET Framework 3.0, and here I have to say that I am not good in WPF, and I haven't used animations; I just wanted it to look better, so I chose WPF.

Try the demo online

.NET 3.5 Framework must be installed.

• Download the demo (or alternate location)
• Run it, go to my blog to get an always-updated service IP
• Choose a name and an avatar, and hit Connect

Before we start, I have to mention two great applications that I have found:

• WCF Chat by Nikola Paljetak
• WCF / WPF Chat Application by Sacha Barber (built on Nikola's app).

As Sacha explains here, it is a great application (and Sacha is really smart -I love this man-).

The WCF Chat mechanism developed by Nikola and Sacha is a great technique, but it is complex somehow; I wasn't able to understand Sacha's article the first time I read it, that's why I decided to make this simple and step by step.

Note that this article uses client-server pattern and not peer to peer.

In this article, you are going to learn how to:

• Create a service and configure it to use TCP binding.
• Host a service and manually control it.
• Define service contracts, duplex, and data contracts.
• Implement a reliable session between the service and the client, and keep it alive for a long time.
• Increase max connections, let's say to 100.
• Handle the communication state in the client application.
• Asynchronously call service operations.
• Enable the service to be accessed online.

The application features include:

• Connect to the service and disconnect, offline from inside a network or online from the internet.
• Choose nickname and avatar.
• Participate in public chat, or whisper in private chat.
• Know if someone is writing a message.
• Know if the service stopped or disconnected.
• Reconnect after faults.
• File transfer (updated).

Updates

File transfer enabled

I really recommend these two books in case you like WCF:

• Microsoft Press WCF Step by Step by John Sharp, and
• Wrox Professional WCF Programming by Scott Klein.

Technique

This service is a singleton service; every client starting a session does not instantiate a new instance of the service. This is to enable a single service to deal with many clients. This means that the first client calling the service instantiates a new instance of the service, and each subsequent call is just calling the service operations. Service operations are methods or functions that the service implements; a service represents its operations in an interface, and represents the callback operations in another interface, asking a client to implement those callback operations, to be able to call the client again whenever it may want.

So, you have got to know:

• Contracts: Contracts in Windows Communication Foundation provide the interoperability they need to communicate with the client. It is through contracts that clients and services agree as to the types of operations and structures they will use during the period that they are communicating back and forth. Without contracts, no work would be accomplished because no agreement would happen (Wrox Professional WCF Programming). In our case, we define the service operations that we want the service to implement, in an interface, and define the operations that the service wants the client to implement in another interface called the callback interface, this is where they both agree through contracts.
• EndPoints: The service must define at least one EndPoint and apply binding to it.
• Bindings: WCF has some predefined bindings that are really useful and can fit many cases. In our case, we are going to use netTcpBinding which allows duplex communications (the red EndPoint in the image above), and mexTcpBinding to support publishing service metadata (the blue EndPoint in the image above).
• Addresses: Services have to define an address for every EndPoint (we will go through base addresses later), so it can be called from, and here we have three addresses, one on TCP protocol to call the service, one on TCP protocol to publish metadata, and one on HTTP protocol to enable HTTP GET for metadata. And you (the developer) is the one who defines the service address (it doesn't relate to any other names, or paths, you just define a new address like http://localhost/blablabla/myService.svc and it will work).

Step by step, Building a WCF duplex service

Steps in points:

• Create service assembly:
• Data contracts
• Service contract
• Callback contract
• Concurrency handling
• Service implementation
• Create Host on WPF:
• ServiceHost class
• Binding configuration in config file
• Binding configuration programmatically
• BaseAddresses
• Enable metadata configuration in config file
• Enable metadata configuration programmatically
• Reliable Sessions
• Max Connections
• Create Client on WPF:
• Generate proxy
• Add avatars as embedded resources
• Proxy duplex channel state handling
• Asynchronously calling service operations
• Implement callback interface
• Other stuff:
• Enable online access (port forward and firewalls)
• Automatically locating service IP

Create service assembly

• Create a new folder in the C: directory and name it WCFWPFRoot.
• Fire up Visual Studio, File > New > Project, choose C# Class Library.



• Set the solution name to WCFWPFApp and the project name to ServiceAssembly; the location is the WCFWPFRoot folder.
• Rename Class1.cs to ChatService.cs.
• Remove:

using System.Linq;
using System.Text;

• Right click the project name, choose Add Reference.. , and add a reference for System.ServiceModel.



• Add this line to your code: using System.ServiceModel;.
• ServiceChat.cs should look like this:

using System;
using System.Collections.Generic;
using System.ServiceModel;

namespace ServiceAssembly
{
    public class ChatService
    {
    }
}

• Now, we will start to add some interfaces and other classes beside this class (ChatService) in the ServiceAssembly namespace. The first class we will add is a Data Contract; a data contract means an agreement to transfer this type of data.
• To add a Data Contract, add a reference to System.Runtime.Serialization, and so add this line: using System.Runtime.Serialization;.
• Our data will be of two types, the first one represents a client and consists of name, avatar ID, and time; so we design the client to be like this:

    [DataContract]
    public class Client
    {
        private string _name;
        private int _avatarID;
        private DateTime _time;

        [DataMember]
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        [DataMember]
        public int AvatarID
        {
            get { return _avatarID; }
            set { _avatarID = value; }
        }
        [DataMember]
        public DateTime Time
        {
            get { return _time; }
            set { _time = value; }
        }
    }

• The second Data Contract is for the message. We want clients to send messages to each other; so Message will have information about the sender, content, and time:

    [DataContract]
    public class Message
    {
        private string _sender;
        private string _content;
        private DateTime _time;

        [DataMember]
        public string Sender
        {
            get { return _sender; }
            set { _sender = value; }
        }
        [DataMember]
        public string Content
        {
            get { return _content; }
            set { _content = value; }
        }
        [DataMember]
        public DateTime Time
        {
            get { return _time; }
            set { _time = value; }
        }
    }

• The next Data Contract is the MessageFile to enable sending files between clients.

    [DataContract]
    public class FileMessage
    {
        private string sender;
        private string fileName;
        private byte[] data;
        private DateTime time;

        [DataMember]
        public string Sender 
        {
            get { return sender; }
            set { sender = value; }
        }

        [DataMember]
        public string FileName
        {
            get { return fileName; }
            set { fileName = value; }
        }

        [DataMember]
        public byte[] Data
        {
            get { return data; }
            set { data = value; }
        }

        [DataMember]
        public DateTime Time
        {
            get { return time; }
            set { time = value; }
        }
    }

• After we design our Data Contracts that will be exchanged through the service and clients, we have to design the service operations in an interface:

    [ServiceContract(CallbackContract = typeof(IChatCallback),
                             SessionMode = SessionMode.Required)]
    public interface IChat
    {
        [OperationContract(IsInitiating = true)]
        bool Connect(Client client);

        [OperationContract(IsOneWay = true)]
        void Say(Message msg);

        [OperationContract(IsOneWay = true)]
        void Whisper(Message msg, Client receiver);

        [OperationContract(IsOneWay = true)]
        void IsWriting(Client client);

        [OperationContract(IsOneWay = false)]
        bool SendFile(FileMessage fileMsg, Client receiver);

        [OperationContract(IsOneWay = true, IsTerminating = true)]
        void Disconnect(Client client);
    }

For designing a service contract, we need to know how the client is going to interact with the service. Here, we specify that a client has to start a session with the service, and terminate this session by calling some operations that can really start and terminate a session (this is why we set SessionMode = SessionMode.Required). Well, how can a service start a session or terminate it? The answer is, just by setting two properties (IsInitiating or IsTerminating) in the OperationContract attribute, and the WCF runtime will understand this. Operations can be one-way (void); this has an advantage that a client can call the operation and proceed its process without waiting for a reply from the service. In our contract, all operations are one-way except for the Connect operation; it returns a boolean to know if the client has been successfully joined, or the client name has been found and already exists. The last thing is to reference the Callback interface, which is the interface the client will implement: CallbackContract = typeof(IChatCallback).

• Designing a callback interface is very easy; just want an interface to define some operations to be called on the client side.

    public interface IChatCallback
    {
        [OperationContract(IsOneWay = true)]
        void RefreshClients(List< Client> clients);

        [OperationContract(IsOneWay = true)]
        void Receive(Message msg);

        [OperationContract(IsOneWay = true)]
        void ReceiveWhisper(Message msg, Client receiver);

        [OperationContract(IsOneWay = true)]
        void IsWritingCallback(Client client);

        [OperationContract(IsOneWay = true)]
        void ReceiverFile(FileMessage fileMsg, Client receiver);

        [OperationContract(IsOneWay = true)]
        void UserJoin(Client client);

        [OperationContract(IsOneWay = true)]
        void UserLeave(Client client);
    }

The service is responsible for defining these parameters and calling those operations.

• Time for the service implementation (of IChat interface). Our service contains a generic dictionary of key types of clients and value types of IChatCallback; so this generic collection will hold the online clients as keys and callback objects for each client as values. The service also contains a generic list to hold the online clients (to quickly pass it to users), a public property that represents the current callback object, a private method used by the service to search for a client in the clients list, and an object to synchronize our work - this object is useful to lock the current thread from receiving calls from clients and wait for the current operation to be completed. We will need this because in the service context, you might be sending some information for each callback object using a foreach loop, and suddenly one of these callback objects' client might get disconnected, and the operation won't complete because the collection has been modified and a client has been removed from it.

Well, this brings us to talk about handling concurrency on the service. A WCF service can handle concurrency in three different ways. The Single and Reentrant options use a synchronized pattern to handle incoming calls from clients, but this can make a deadlock if a client tries to call a service and waits for a reply, the service processes the client request and needs to call the client back again, but the client is still waiting for a reply from the service, and thus causing a deadlock. The Reentrant option will make the WCF release the lock, but we will use the Multiple option which allows to make calls on another thread (this is good, but needs us to synchronize our code as we said before).

    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,
        ConcurrencyMode = ConcurrencyMode.Multiple, 
        UseSynchronizationContext = false)]
    public class ChatService
    {
        Dictionary< Client, IChatCallback> clients = 
                 new Dictionary< Client, IChatCallback>();

        List< Client> clientList = new List< Client>();

        public INewServiceCallback CurrentCallback
        {
            get
            {
             return OperationContext.Current.
                    GetCallbackChannel< IChatCallback>();
            }
        }

        object syncObj = new object();

        private bool SearchClientsByName(string name)
        {
            foreach (Client c in clients.Keys)
            {
                if (c.Name == name)
                {
                    return true;
                }
            }
            return false;
        }
    }

• Implement the IChat interface:

    public class ChatService : IChat
    {
        ...
        
        #region IChat Members

        public bool Connect(Client client)
        {
            if (!clients.ContainsValue(CurrentCallback) && 
                !SearchClientsByName(client.Name))
            {
                lock (syncObj)
                {
                    clients.Add(client, CurrentCallback);
                    clientList.Add(client);

                    foreach (Client key in clients.Keys)
                    {
                        IChatCallback callback = clients[key];
                        try
                        {
                            callback.RefreshClients(clientList);
                            callback.UserJoin(client);
                        }
                        catch
                        {
                            clients.Remove(key);
                            return false;
                        }

                    }

                }
                return true;
            }
            return false;
        }

        public void Say(Message msg)
        {
            lock (syncObj)
            {
                foreach (IChatCallback callback in clients.Values)
                {
                    callback.Receive(msg);
                }
            }
        }

        public void Whisper(Message msg, Client receiver)
        {
            foreach (Client rec in clients.Keys)
            {
                if (rec.Name == receiver.Name)
                {
                    IChatCallback callback = clients[rec];
                    callback.ReceiveWhisper(msg, rec);

                    foreach (Client sender in clients.Keys)
                    {
                        if (sender.Name == msg.Sender)
                        {
                            IChatCallback senderCallback = clients[sender];
                            senderCallback.ReceiveWhisper(msg, rec);
                            return;
                        }
                    }
                }
            }
        }

        public void IsWriting(Client client)
        {
            lock (syncObj)
            {
                foreach (IChatCallback callback in clients.Values)
                {
                    callback.IsWritingCallback(client);
                }
            }
        }
        
        public bool SendFile(FileMessage fileMsg, Client receiver)
        {
            foreach (Client rcvr in clients.Keys)
            {
                if (rcvr.Name == receiver.Name)
                {
                    Message msg = new Message();
                    msg.Sender = fileMsg.Sender;
                    msg.Content = "I'M SENDING FILE.. " + fileMsg.FileName;

                    IChatCallback rcvrCallback = clients[rcvr];
                    rcvrCallback.ReceiveWhisper(msg, receiver);
                    rcvrCallback.ReceiverFile(fileMsg, receiver);

                    foreach (Client sender in clients.Keys)
                    {
                        if (sender.Name == fileMsg.Sender)
                        {
                            IChatCallback sndrCallback = clients[sender];
                            sndrCallback.ReceiveWhisper(msg, receiver);
                            return true;
                        }
                    }
                }
            }
            return false;
        }

        public void Disconnect(Client client)
        {
            foreach (Client c in clients.Keys)
            {
                if (client.Name == c.Name)
                {
                    lock (syncObj)
                    {
                        this.clients.Remove(c);
                        this.clientList.Remove(c);
                        foreach (IChatCallback callback in clients.Values)
                        {
                            callback.RefreshClients(this.clientList);
                            callback.UserLeave(client);
                        }
                    }
                    return;
                }
            }
        }

        #endregion
    }

• Finally, this is the complete service assembly:

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.Runtime.Serialization;

namespace ServiceAssembly
{

    [DataContract]
    public class Client
    {
        private string _name;
        private int _avatarID;
        private DateTime _time;

        [DataMember]
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        [DataMember]
        public int AvatarID
        {
            get { return _avatarID; }
            set { _avatarID = value; }
        }
        [DataMember]
        public DateTime Time
        {
            get { return _time; }
            set { _time = value; }
        }
    }

    [DataContract]
    public class Message
    {
        private string _sender;
        private string _content;
        private DateTime _time;

        [DataMember]
        public string Sender
        {
            get { return _sender; }
            set { _sender = value; }
        }
        [DataMember]
        public string Content
        {
            get { return _content; }
            set { _content = value; }
        }
        [DataMember]
        public DateTime Time
        {
            get { return _time; }
            set { _time = value; }
        }
    }



    [ServiceContract(CallbackContract = typeof(IChatCallback), 
                     SessionMode = SessionMode.Required)]
    public interface IChat
    {
        [OperationContract(IsInitiating = true)]
        bool Connect(Client client);

        [OperationContract(IsOneWay = true)]
        void Say(Message msg);

        [OperationContract(IsOneWay = true)]
        void Whisper(Message msg, Client receiver);

        [OperationContract(IsOneWay = true)]
        void IsWriting(Client client);

        [OperationContract(IsOneWay = true, 
                           IsTerminating = true)]
        void Disconnect(Client client);
    }

    public interface IChatCallback
    {
        [OperationContract(IsOneWay = true)]
        void RefreshClients(List< Client> clients);

        [OperationContract(IsOneWay = true)]
        void Receive(Message msg);

        [OperationContract(IsOneWay = true)]
        void ReceiveWhisper(Message msg, Client receiver);

        [OperationContract(IsOneWay = true)]
        void IsWritingCallback(Client client);

        [OperationContract(IsOneWay = true)]
        void UserJoin(Client client);

        [OperationContract(IsOneWay = true)]
        void UserLeave(Client client);
    }


    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,
                     ConcurrencyMode = ConcurrencyMode.Multiple, 
                     UseSynchronizationContext = false)]
    public class ChatService : IChat
    {
        Dictionary< Client, IChatCallback> clients = 
          new Dictionary< List< Client> 
          clientList = new List< Client>();

        public IChatCallback CurrentCallback
        {
            get
            {
                return OperationContext.Current.
                       GetCallbackChannel< IChatCallback>();

            }
        }

        object syncObj = new object();

        private bool SearchClientsByName(string name)
        {
            foreach (Client c in clients.Keys)
            {
                if (c.Name == name)
                {
                    return true;
                }
            }
            return false;
        }


        #region IChat Members

        public bool Connect(Client client)
        {
            if (!clients.ContainsValue(CurrentCallback) && 
                !SearchClientsByName(client.Name))
            {
                lock (syncObj)
                {
                    clients.Add(client, CurrentCallback);
                    clientList.Add(client);

                    foreach (Client key in clients.Keys)
                    {
                        IChatCallback callback = clients[key];
                        try
                        {
                            callback.RefreshClients(clientList);
                            callback.UserJoin(client);
                        }
                        catch
                        {
                            clients.Remove(key);
                            return false;
                        }

                    }

                }
                return true;
            }
            return false;
        }

        public void Say(Message msg)
        {
            lock (syncObj)
            {
                foreach (IChatCallback callback in clients.Values)
                {
                    callback.Receive(msg);
                }
            }
        }

        public void Whisper(Message msg, Client receiver)
        {
            foreach (Client rec in clients.Keys)
            {
                if (rec.Name == receiver.Name)
                {
                    IChatCallback callback = clients[rec];
                    callback.ReceiveWhisper(msg, rec);

                    foreach (Client sender in clients.Keys)
                    {
                        if (sender.Name == msg.Sender)
                        {
                            IChatCallback senderCallback = clients[sender];
                            senderCallback.ReceiveWhisper(msg, rec);
                            return;
                        }
                    }
                }
            }
        }

        public void IsWriting(Client client)
        {
            lock (syncObj)
            {
                foreach (IChatCallback callback in clients.Values)
                {
                    callback.IsWritingCallback(client);
                }
            }
        }

        public bool SendFile(FileMessage fileMsg, Client receiver)
        {
            foreach (Client rcvr in clients.Keys)
            {
                if (rcvr.Name == receiver.Name)
                {
                    Message msg = new Message();
                    msg.Sender = fileMsg.Sender;
                    msg.Content = "I'M SENDING FILE.. " + fileMsg.FileName;

                    IChatCallback rcvrCallback = clients[rcvr];
                    rcvrCallback.ReceiveWhisper(msg, receiver);
                    rcvrCallback.ReceiverFile(fileMsg, receiver);

                    foreach (Client sender in clients.Keys)
                    {
                        if (sender.Name == fileMsg.Sender)
                        {
                            IChatCallback sndrCallback = clients[sender];
                            sndrCallback.ReceiveWhisper(msg, receiver);
                            return true;
                        }
                    }
                }
            }
            return false;
        }
        
        public void Disconnect(Client client)
        {
            foreach (Client c in clients.Keys)
            {
                if (client.Name == c.Name)
                {
                    lock (syncObj)
                    {
                        this.clients.Remove(c);
                        this.clientList.Remove(c);
                        foreach (IChatCallback callback in clients.Values)
                        {
                            callback.RefreshClients(this.clientList);
                            callback.UserLeave(client);
                        }
                    }
                    return;
                }
            }
        }

        #endregion
    }
}

• Set debug mode to Release and build the project. ServiceAssembly.dll will be added to the Release folder under bin folder.

Create Host on WPF

• File > Add > New Project.., choose WPF Application, and set its name to WPFHost.
• Add a reference to System.ServiceModel.
• Add reference and browse for the service DLL file. C: > WCFWPFRoot > WCFWPFApp > ServiceAssembly > bin > Release > ServiceAssembly.dll, in our case.
• Replace the XAML code in window1.xaml with this:

< window title="Chat Service Host" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
x:class="WPFHost.Window1" height="300" width="300" />
    < grid />

        < grid.background />
            < lineargradientbrush />
                < gradientstop color="LightSlateGray" offset="0" />
                < gradientstop color="White" offset="0.5" />
                < gradientstop color="LightSlateGray" offset="0.9" />
            < /lineargradientbrush />
        < /grid.background />
        
        < label name="label1" height="28" width="67" 
        margin="10,93,0,0" verticalalignment="Top" 
        horizontalalignment="Left">Local IP:</label />
        < label name="label2" height="28" width="67"
         margin="10,0,0,85" verticalalignment="Bottom" 
         horizontalalignment="Left">Listen Port:</label />
        < textbox height="23" margin="76,98,108,0" 
        verticalalignment="Top" x:name="textBoxIP" text="localhost" />
        < textbox height="23" margin="76,0,108,88" 
        verticalalignment="Bottom" x:name="textBoxPort" 
        text="7997" />
        < button height="23" width="82" 
        margin="0,0,15,88" verticalalignment="Bottom" 
        horizontalalignment="Right" x:name="buttonStop"
         click="buttonStop_Click">Stop</button />
        < button height="23" width="82" 
        margin="0,96,15,0" verticalalignment="Top"
         horizontalalignment="Right" x:name="buttonStart"
          click="buttonStart_Click">Start</button />
        < label height="28" margin="10,0,15,45" 
        verticalalignment="Bottom" x:name="labelStatus">Status</label />
        < label height="37" margin="10,18,15,0"
         verticalalignment="Top" x:name="labelTitle"
          fontfamily="Jokerman" fontsize="20"
           foreground="White">Chat Service</label />
    < /grid />
< /window />

This is our host application that should instantiate a ServiceHost object. A ServiceHost object is what will actually host your service, enable you to apply bindings, add EndPoints, start the service or stop it. So, we will start defining a ServiceHost programmatically, and then use the configuration file.

• Programmatically: Add a reference to System.Runtime.Serialization.
• Replace the code in window1.xaml.cs with this code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.ServiceModel;
using ServiceAssembly;
using System.ServiceModel.Description;
using System.Xml;

namespace WPFHost
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

        ServiceHost host;

        private void buttonStart_Click(object sender, 
                                       RoutedEventArgs e)
        {
            buttonStart.IsEnabled = false;

            //Define base addresses so all 
            //endPoints can go under it

            Uri tcpAdrs = new Uri("net.tcp://" + 
                textBoxIP.Text.ToString() + ":" + 
                textBoxPort.Text.ToString() + "/WPFHost/");

            Uri httpAdrs = new Uri("http://" + 
                textBoxIP.Text.ToString() + ":" +
                (int.Parse(textBoxPort.Text.ToString()) + 1).ToString() + 
                "/WPFHost/");

            Uri[] baseAdresses = { tcpAdrs, httpAdrs };

            host = new ServiceHost(
                   typeof(ServiceAssembly.ChatService), baseAdresses);


            NetTcpBinding tcpBinding = 
               new NetTcpBinding(SecurityMode.None, true);
            //Updated: to enable file transefer of 64 MB
            tcpBinding.MaxBufferPoolSize = (int)67108864;
            tcpBinding.MaxBufferSize = 67108864;
            tcpBinding.MaxReceivedMessageSize = (int)67108864;
            tcpBinding.TransferMode = TransferMode.Buffered;
            tcpBinding.ReaderQuotas.MaxArrayLength = 67108864;
            tcpBinding.ReaderQuotas.MaxBytesPerRead = 67108864;
            tcpBinding.ReaderQuotas.MaxStringContentLength = 67108864;
            

            tcpBinding.MaxConnections = 100;
            //To maxmize MaxConnections you have 
            //to assign another port for mex endpoint

            //and configure ServiceThrottling as well
            ServiceThrottlingBehavior throttle;
            throttle = 
             host.Description.Behaviors.Find< ServiceThrottlingBehavior>();
            if (throttle == null)
            {
                throttle = new ServiceThrottlingBehavior();
                throttle.MaxConcurrentCalls = 100;
                throttle.MaxConcurrentSessions = 100;
                host.Description.Behaviors.Add(throttle);
            }


            //Enable reliable session and keep 
            //the connection alive for 20 hours.
            tcpBinding.ReceiveTimeout = new TimeSpan(20, 0, 0);
            tcpBinding.ReliableSession.Enabled = true;
            tcpBinding.ReliableSession.InactivityTimeout = 
                                       new TimeSpan(20, 0, 10);

            host.AddServiceEndpoint(typeof(ServiceAssembly.IChat), 
                                    tcpBinding, "tcp");

            //Define Metadata endPoint, So we can 
            //publish information about the service
            ServiceMetadataBehavior mBehave = 
                           new ServiceMetadataBehavior();
            host.Description.Behaviors.Add(mBehave);

            host.AddServiceEndpoint(typeof(IMetadataExchange),
                MetadataExchangeBindings.CreateMexTcpBinding(),
                "net.tcp://" + textBoxIP.Text.ToString() + ":" + 
                (int.Parse(textBoxPort.Text.ToString()) - 1).ToString() + 
                "/WPFHost/mex");


            try
            {
                host.Open();
            }
            catch (Exception ex)
            {
                labelStatus.Content = ex.Message.ToString();
            }
            finally
            {
                if (host.State == CommunicationState.Opened)
                {
                    labelStatus.Content = "Opened";
                    buttonStop.IsEnabled = true;
                }
            }
        }

        private void buttonStop_Click(object sender, RoutedEventArgs e)
        {
            if (host != null)
            {
                try
                {
                    host.Close();
                }
                catch (Exception ex)
                {
                    labelStatus.Content = ex.Message.ToString();
                }
                finally
                {
                    if (host.State == CommunicationState.Closed)
                    {
                        labelStatus.Content = "Closed";
                        buttonStart.IsEnabled = true;
                        buttonStop.IsEnabled = false;
                    }
                }
            }
        }
    }
}

• Using the configuration file: Add New Item and choose the configuration file.
• Add this code:

< configuration />
    < system.servicemodel />
        < services />
            < service name="WCFService.Service" 
              behaviorconfiguration="behaviorConfig" />
                < host />
                    < baseaddresses />
                        < add baseaddress="net.tcp://localhost:7997/WPFHost/" />
                        < add baseaddress="http://localhost:7998/WPFHost/" />
                    < /baseaddresses />
                < /host />
                < endpoint contract="ServiceAssembly.IChat" binding="netTcpBinding" 
                address="tcp" bindingconfiguration="tcpBinding" />

                < endpoint contract="IMetadataExchange" binding="mexTcpBinding" 
                address="net.tcp://localhost:7996/WcfWinFormsHost/mex" />
            < /service />
        < /services />
        < behaviors />
            < servicebehaviors />
                < behavior name="behaviorConfig" />
                    < servicemetadata httpgetenabled="true" />
                    < servicedebug includeexceptiondetailinfaults="true" />
                    < servicethrottling maxconcurrentcalls="100" 
                      maxconcurrentsessions="100" />
                < /behavior />
            < /servicebehaviors />
        < /behaviors />
        < bindings />
            < nettcpbinding />
                < binding name="tcpBinding" maxbuffersize="67108864" 
                maxreceivedmessagesize="67108864" maxbufferpoolsize="67108864"
                 transfermode="Buffered" closetimeout="00:00:10" 
                 opentimeout="00:00:10" receivetimeout="00:20:00" 
                 sendtimeout="00:01:00" maxconnections="100" />
                    < security mode="None" />
                    < /security />
                    < readerquotas maxarraylength="67108864" 
                      maxbytesperread="67108864" 
                      maxstringcontentlength="67108864" />
                    < reliablesession enabled="true" 
                      inactivitytimeout="00:20:00" />
                < /binding />
            < /nettcpbinding />
        < /bindings />
    < /system.servicemodel />
< /configuration />

Create client on WPF

• File > Add > New Project.., choose WPF Application, and set its name to WPFClient.
• Add a reference to System.ServiceModel.
• Set the WPFHost project to be the startup project, start it, hit the Start button to run the service.
• Set the WPFClient project to be the startup project, and add a service reference, as in this picture:



As you see, we give it the address of the mex (our metadata) EndPoint, and it will know and configure a new config file with the address of the TCP EndPoint. Click Advanced to enable asynchronous operations and generic lists.



• Now, hit OK and you will notice that a new app.config file has been added. Open it and modify the binding to enable file transfers of 64 MB, and increase max connections to 100.

     maxBufferPoolSize="67108864" 
     maxBufferSize="67108864" maxConnections="100"
     maxReceivedMessageSize="67108864">

• Switch to window1.xaml.cs and replace its code with this.

Client code commented, read from the top to bottom..

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.IO;
using System.Reflection;
using System.ServiceModel;
using WPFClient.SVC;
using System.Collections;
using System.Windows.Threading;
using Microsoft.Win32;

namespace WPFClient
{
    /// < summary>
    /// Interaction logic for Window1.xaml
    /// < /summary>
    public partial class Window1 : Window, SVC.IChatCallback
    {
        //SVC holds references to the proxy and cotracts..
        SVC.ChatClient proxy = null;
        SVC.Client receiver = null;
        SVC.Client localClient = null;

        //Client will create this folder when loading
        string rcvFilesPath = @"C:/WCF_Received_Files/";

        //When the communication object 
        //turns to fault state it will
        //require another thread to invoke a fault event
        private delegate void FaultedInvoker();

        //This will hold each online client with 
        //a listBoxItem to quickly handle adding
        //and removing clients when they join or leave
        Dictionary< ListBoxItem, SVC.Client> OnlineClients = 
                      new Dictionary< ListBoxItem, Client>();


        public Window1()
        {
            InitializeComponent();
            this.Loaded += new RoutedEventHandler(Window1_Loaded);
            chatListBoxNames.SelectionChanged += new 
              SelectionChangedEventHandler(
              chatListBoxNames_SelectionChanged);
            chatTxtBoxType.KeyDown += 
              new KeyEventHandler(chatTxtBoxType_KeyDown);
            chatTxtBoxType.KeyUp += 
              new KeyEventHandler(chatTxtBoxType_KeyUp);
        }


        //Service might be disconnected or stopped for any reason,
        //so we have to handle the state of the communication object,
        //the communication object will fire 
        //an event for each transitioning
        //from a state to another, notice that when a connection state goes
        //from opening to opened or from opened to closing state.. it can't go
        //back so, if it is closed or faulted you have to set the proxy = null;
        //to be able to create a proxy again and open a connection
        //..
        //I have made a method called HandleProxy() to handle the state
        //of the connection, so in each event like opened, closed or faulted
        //we will call this method, and it will switch on the connection state
        //and apply a suitable reaction.
        //..
        //Because this events will need to be invoked on another thread
        //you can do like so in WPF applications (I've got this idea from
        //Sacha Barber's greate article on WCF WPF Application)

        void InnerDuplexChannel_Closed(object sender, EventArgs e)
        {
            if (!this.Dispatcher.CheckAccess())
            {
                this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, 
                                new FaultedInvoker(HandleProxy));
                return;
            }
            HandleProxy();
        }

        void InnerDuplexChannel_Opened(object sender, EventArgs e)
        {
            if (!this.Dispatcher.CheckAccess())
            {
                this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, 
                                new FaultedInvoker(HandleProxy));
                return;
            }
            HandleProxy();
        }

        void InnerDuplexChannel_Faulted(object sender, EventArgs e)
        {
            if (!this.Dispatcher.CheckAccess())
            {
                this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, 
                                new FaultedInvoker(HandleProxy));
                return;
            }
            HandleProxy();
        }

        #region Private Methods

        /// < summary>
        /// This is the most method I like, it helps us alot
        /// We may can't know when a connection is lost in 
        /// of network failure or service stopped.
        /// And also to maintain performance client doesnt know
        /// that the connection will be lost when hitting the 
        /// disconnect button, but when a session is terminated
        /// this method will be called, and it will handle everything.
        /// < /summary>
        private void HandleProxy()
        {
            if (proxy != null)
            {
                switch (this.proxy.State)
                {
                    case CommunicationState.Closed:
                        proxy = null;
                        chatListBoxMsgs.Items.Clear();
                        chatListBoxNames.Items.Clear();
                        loginLabelStatus.Content = "Disconnected";
                        ShowChat(false);
                        ShowLogin(true);
                        loginButtonConnect.IsEnabled = true;
                        break;
                    case CommunicationState.Closing:
                        break;
                    case CommunicationState.Created:
                        break;
                    case CommunicationState.Faulted:
                        proxy.Abort();
                        proxy = null;
                        chatListBoxMsgs.Items.Clear();
                        chatListBoxNames.Items.Clear();
                        ShowChat(false);
                        ShowLogin(true);
                        loginLabelStatus.Content = "Disconnected";
                        loginButtonConnect.IsEnabled = true;
                        break;
                    case CommunicationState.Opened:
                        ShowLogin(false);
                        ShowChat(true);

                        chatLabelCurrentStatus.Content = "online";
                        chatLabelCurrentUName.Content = this.localClient.Name;

                        Dictionary< int, Image> images = GetImages();
                        Image img = images[loginComboBoxImgs.SelectedIndex];
                        chatCurrentImage.Source = img.Source;
                        break;
                    case CommunicationState.Opening:
                        break;
                    default:
                        break;
                }
            }

        }
        
        /// < summary>
        /// This is the second important method, which creates 
        /// the proxy, subscribe to connection state events
        /// and open a connection with the service
        /// < /summary>
        private void Connect()
        {
            if (proxy == null)
            {
                try
                {
                    this.localClient = new SVC.Client();
                    this.localClient.Name = loginTxtBoxUName.Text.ToString();
                    this.localClient.AvatarID = loginComboBoxImgs.SelectedIndex;
                    InstanceContext context = new InstanceContext(this);
                    proxy = new SVC.ChatClient(context);

                    //As the address in the configuration file is set to localhost
                    //we want to change it so we can call a service in internal 
                    //network, or over internet
                    string servicePath = proxy.Endpoint.ListenUri.AbsolutePath;
                    string serviceListenPort = 
                      proxy.Endpoint.Address.Uri.Port.ToString();
                    proxy.Endpoint.Address = new EndpointAddress("net.tcp://" 
                       + loginTxtBoxIP.Text.ToString() + ":" + 
                       serviceListenPort + servicePath);


                    proxy.Open();

                    proxy.InnerDuplexChannel.Faulted += 
                      new EventHandler(InnerDuplexChannel_Faulted);
                    proxy.InnerDuplexChannel.Opened += 
                      new EventHandler(InnerDuplexChannel_Opened);
                    proxy.InnerDuplexChannel.Closed += 
                      new EventHandler(InnerDuplexChannel_Closed);
                    proxy.ConnectAsync(this.localClient);
                    proxy.ConnectCompleted += new EventHandler< 
                          ConnectCompletedEventArgs>(proxy_ConnectCompleted);
                }
                catch (Exception ex)
                {
                    loginTxtBoxUName.Text = ex.Message.ToString();
                    loginLabelStatus.Content = "Offline";
                    loginButtonConnect.IsEnabled = true;
                }
            }
            else
            {
                HandleProxy();
            }
        }

        private void Send()
        {
            if (proxy != null && chatTxtBoxType.Text != "")
            {
                if (proxy.State == CommunicationState.Faulted)
                {
                    HandleProxy();
                }
                else
                {
                    //Create message, assign its properties
                    SVC.Message msg = new WPFClient.SVC.Message();
                    msg.Sender = this.localClient.Name;
                    msg.Content = chatTxtBoxType.Text.ToString();

                    //If whisper mode is checked and an item is
                    //selected in the list box of clients, it will
                    //arrange a client object called receiver
                    //to whisper
                    if ((bool)chatCheckBoxWhisper.IsChecked)
                    {
                        if (this.receiver != null)
                        {
                            proxy.WhisperAsync(msg, this.receiver);
                            chatTxtBoxType.Text = "";
                            chatTxtBoxType.Focus();
                        }
                    }

                    else
                    {
                        proxy.SayAsync(msg);
                        chatTxtBoxType.Text = "";
                        chatTxtBoxType.Focus();
                    }
                    //Tell the service to tell back 
                    //all clients that this client
                    //has just finished typing..
                    proxy.IsWritingAsync(null);
                }
            }
        }

        
        /// < summary>
        /// This method to enable us scrolling the list box of messages
        /// when a new message comes from the service..
        /// < /summary>
        private ScrollViewer FindVisualChild(DependencyObject obj)
        {
            for (int i = 0; i < VisualTreeHelper.GetChildrenCount(obj); i++)
            {
                DependencyObject child = VisualTreeHelper.GetChild(obj, i);
                if (child != null && child is ScrollViewer)
                {
                    return (ScrollViewer)child;
                }
                else
                {
                    ScrollViewer childOfChild = FindVisualChild(child);
                    if (childOfChild != null)
                    {
                        return childOfChild;
                    }
                }
            }
            return null;
        }
 
        /// < summary>
        /// This is an important method which is called whenever
        /// a message comes from the service, a client joins or
        /// leaves, to return a ready item to be added in the
        /// list box (either the one for messages or the one for
        /// clients).
        /// < /summary>
        private ListBoxItem MakeItem(int imgID, string text)
        {
            ListBoxItem item = new ListBoxItem();
            Dictionary< int, Image> images = GetImages();
            Image img = images[imgID];
            img.Height = 70;
            img.Width = 60;
            item.Content = img;

            TextBlock txtblock = new TextBlock();
            txtblock.Text = text;
            txtblock.VerticalAlignment = VerticalAlignment.Center;

            StackPanel panel = new StackPanel();
            panel.Orientation = Orientation.Horizontal;
            panel.Children.Add(item);
            panel.Children.Add(txtblock);

            ListBoxItem bigItem = new ListBoxItem();
            bigItem.Content = panel;

            return bigItem;
        }

        /// < summary>
        /// This method is not used, I just put it here to help
        /// you in case you want to make a rich text box and enable
        /// emoticons for example.
        /// Just add a richTextBox control and set
        /// richTextBox.Document = MakeDocument(imgid, text);
        /// < /summary>
        private FlowDocument MakeDocument(int imgID, string text)
        {
            Dictionary< int, Image> images = GetImages();
            Image img = images[imgID];
            img.Height = 70;
            img.Width = 60;


            Block imgBlock = new BlockUIContainer(img);
            Block txtBlock = new Paragraph(new Run(text));


            FlowDocument doc = new FlowDocument();
            doc.Blocks.Add(imgBlock);

            doc.Blocks.Add(txtBlock);

            doc.FlowDirection = FlowDirection.LeftToRight;
            return doc;
        }

        /// < summary>
        /// A method to retreive avatars as stream objects
        /// and get an objects of type Image from the stream,
        /// to return a dictionary of images and an ID for each
        /// image.
        /// < /summary>
        private Dictionary< int, Image> GetImages()
        {
            List< Stream> picsStrm = new List< Stream>();

            Assembly asmb = Assembly.GetExecutingAssembly();
            string[] picNames = asmb.GetManifestResourceNames();

            foreach (string s in picNames)
            {
                if (s.EndsWith(".png"))
                {
                    Stream strm = asmb.GetManifestResourceStream(s);
                    if (strm != null)
                    {
                        picsStrm.Add(strm);
                    }
                }
            }

            Dictionary< int, Image> images = new Dictionary< int, Image>();

            int i = 0;

            foreach (Stream strm in picsStrm)
            {

                PngBitmapDecoder decoder = new PngBitmapDecoder(strm,
                    BitmapCreateOptions.PreservePixelFormat, 
                    BitmapCacheOption.Default);
                BitmapSource bitmap = decoder.Frames[0] as BitmapSource;
                Image img = new Image();
                img.Source = bitmap;
                img.Stretch = Stretch.UniformToFill;

                images.Add(i, img);
                i++;

                strm.Close();
            }
            return images;
        }

        /// < summary>
        /// Show or hide login controls depends on the parameter
        /// < /summary>
        /// < param name="show">< /param>
        private void ShowLogin(bool show)
        {
            if (show)
            {
                loginButtonConnect.Visibility = Visibility.Visible;
                loginComboBoxImgs.Visibility = Visibility.Visible;
                loginLabelIP.Visibility = Visibility.Visible;
                loginLabelStatus.Visibility = Visibility.Visible;
                loginLabelTitle.Visibility = Visibility.Visible;
                loginLabelUName.Visibility = Visibility.Visible;
                loginPolyLine.Visibility = Visibility.Visible;
                loginTxtBoxIP.Visibility = Visibility.Visible;
                loginTxtBoxUName.Visibility = Visibility.Visible;
            }
            else
            {
                loginButtonConnect.Visibility = Visibility.Collapsed;
                loginComboBoxImgs.Visibility = Visibility.Collapsed;
                loginLabelIP.Visibility = Visibility.Collapsed;
                loginLabelStatus.Visibility = Visibility.Collapsed;
                loginLabelTitle.Visibility = Visibility.Collapsed;
                loginLabelUName.Visibility = Visibility.Collapsed;
                loginPolyLine.Visibility = Visibility.Collapsed;
                loginTxtBoxIP.Visibility = Visibility.Collapsed;
                loginTxtBoxUName.Visibility = Visibility.Collapsed;
            }
        }


        /// < summary>
        /// Show or hide chat controls depends on the parameter
        /// < /summary>
        /// < param name="show">< /param>
        private void ShowChat(bool show)
        {
            if (show)
            {
                chatButtonDisconnect.Visibility = Visibility.Visible;
                chatButtonSend.Visibility = Visibility.Visible;
                chatCheckBoxWhisper.Visibility = Visibility.Visible;
                chatCurrentImage.Visibility = Visibility.Visible;
                chatLabelCurrentStatus.Visibility = Visibility.Visible;
                chatLabelCurrentUName.Visibility = Visibility.Visible;
                chatListBoxMsgs.Visibility = Visibility.Visible;
                chatListBoxNames.Visibility = Visibility.Visible;
                chatTxtBoxType.Visibility = Visibility.Visible;
                chatLabelWritingMsg.Visibility = Visibility.Visible;
                chatLabelSendFileStatus.Visibility = Visibility.Visible;
                chatButtonOpenReceived.Visibility = Visibility.Visible;
                chatButtonSendFile.Visibility = Visibility.Visible;
            }
            else
            {
                chatButtonDisconnect.Visibility = Visibility.Collapsed;
                chatButtonSend.Visibility = Visibility.Collapsed;
                chatCheckBoxWhisper.Visibility = Visibility.Collapsed;
                chatCurrentImage.Visibility = Visibility.Collapsed;
                chatLabelCurrentStatus.Visibility = Visibility.Collapsed;
                chatLabelCurrentUName.Visibility = Visibility.Collapsed;
                chatListBoxMsgs.Visibility = Visibility.Collapsed;
                chatListBoxNames.Visibility = Visibility.Collapsed;
                chatTxtBoxType.Visibility = Visibility.Collapsed;
                chatLabelWritingMsg.Visibility = Visibility.Collapsed;
                chatLabelSendFileStatus.Visibility = Visibility.Collapsed;
                chatButtonOpenReceived.Visibility = Visibility.Collapsed;
                chatButtonSendFile.Visibility = Visibility.Collapsed;
            }
        }

        #endregion


        #region UI_Events

        void Window1_Loaded(object sender, RoutedEventArgs e)
        {
            //Create a folder named WCF_Received_Files in C directory
            DirectoryInfo dir = new DirectoryInfo(rcvFilesPath);
            dir.Create();

            Dictionary< int, Image> images = GetImages();
            //Populate images in the login comboBoc control
            foreach (Image img in images.Values)
            {
                ListBoxItem item = new ListBoxItem();
                item.Width = 90;
                item.Height = 90;
                item.Content = img;

                loginComboBoxImgs.Items.Add(item);
            }
            loginComboBoxImgs.SelectedIndex = 0;

            ShowChat(false);
            ShowLogin(true);

        }

        private void chatButtonOpenReceived_Click(object sender, 
                                                  RoutedEventArgs e)
        {
            //Open WCF_Received_Files folder in windows explorer
            System.Diagnostics.Process.Start(rcvFilesPath);
        }

        private void chatButtonSendFile_Click(object sender, 
                                              RoutedEventArgs e)
        {
            if (this.receiver != null)
            {
                Stream strm = null;
                try
                {
                    OpenFileDialog fileDialog = new OpenFileDialog();
                    fileDialog.Multiselect = false;

                    if (fileDialog.ShowDialog() == DialogResult.HasValue)
                    {
                        return;
                    }

                    strm = fileDialog.OpenFile();
                    if (strm != null)
                    {
                        byte[] buffer = new byte[(int)strm.Length];

                        int i = strm.Read(buffer, 0, buffer.Length);

                        if (i > 0)
                        {
                            SVC.FileMessage fMsg = new FileMessage();
                            fMsg.FileName = fileDialog.SafeFileName;
                            fMsg.Sender = this.localClient.Name;
                            fMsg.Data = buffer;
                            proxy.SendFileAsync(fMsg, this.receiver);
                            proxy.SendFileCompleted += new 
                                  EventHandler< SendFileCompletedEventArgs>
                            (proxy_SendFileCompleted);
                            chatLabelSendFileStatus.Content = "Sending...";
                        }

                    }
                }
                catch (Exception ex)
                {
                    chatTxtBoxType.Text = ex.Message.ToString();
                }
                finally
                {
                    if (strm != null)
                    {
                        strm.Close();
                    }
                }
            }

        }

        void proxy_SendFileCompleted(object sender, 
                   SendFileCompletedEventArgs e)
        {
            chatLabelSendFileStatus.Content = "File Sent";
        }


        protected override void OnClosing(
                  System.ComponentModel.CancelEventArgs e)
        {
            if (proxy != null)
            {
                if (proxy.State == CommunicationState.Opened)
                {
                    proxy.Disconnect(this.localClient);
                    //dont set proxy.Close(); because 
                    //isTerminating = true on Disconnect()
                    //and this by default will call 
                    //HandleProxy() to take care of this.
                }
                else
                {
                    HandleProxy();
                }
            }
        }

        private void buttonConnect_Click(object sender, 
                                   RoutedEventArgs e)
        {
            loginButtonConnect.IsEnabled = false;
            loginLabelStatus.Content = "Connecting..";
            proxy = null;
            Connect();

        }

        void proxy_ConnectCompleted(object sender, 
                   ConnectCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                loginLabelStatus.Foreground = 
                        new SolidColorBrush(Colors.Red);
                loginTxtBoxUName.Text = e.Error.Message.ToString();
                loginButtonConnect.IsEnabled = true;
            }
            else if (e.Result)
            {
                HandleProxy();
            }
            else if (!e.Result)
            {
                loginLabelStatus.Content = "Name found";
                loginButtonConnect.IsEnabled = true;
            }


        }

        private void chatButtonSend_Click(object sender, 
                                          RoutedEventArgs e)
        {
            Send();
        }

        private void chatButtonDisconnect_Click(object sender, 
                                          RoutedEventArgs e)
        {
            if (proxy != null)
            {
                if (proxy.State == CommunicationState.Faulted)
                {
                    HandleProxy();
                }
                else
                {
                    proxy.DisconnectAsync(this.localClient);
                }
            }
        }


        void chatTxtBoxType_KeyUp(object sender, KeyEventArgs e)
        {
            if (proxy != null)
            {
                if (proxy.State == CommunicationState.Faulted)
                {
                    HandleProxy();
                }
                else
                {
                    if (chatTxtBoxType.Text.Length < 1)
                    {
                        proxy.IsWritingAsync(null);
                    }
                }
            }
        }

        void chatTxtBoxType_KeyDown(object sender, KeyEventArgs e)
        {
            if (proxy != null)
            {
                if (proxy.State == CommunicationState.Faulted)
                {
                    HandleProxy();
                }
                else
                {
                    if (e.Key == Key.Enter)
                    {
                        Send();
                    }
                    else if (chatTxtBoxType.Text.Length < 1)
                    {
                        proxy.IsWritingAsync(this.localClient);
                    }
                }
            }
        }

        void chatListBoxNames_SelectionChanged(object sender, 
                              SelectionChangedEventArgs e)
        {
            //If user select an online client, make a client object
            //to be the receiver if the user wants to whisper him.
            ListBoxItem item = 
                chatListBoxNames.SelectedItem as ListBoxItem;
            if (item != null)
            {
                this.receiver = this.OnlineClients[item];
            }
        }


        #endregion

        #region IChatCallback Members

        public void RefreshClients(List< WPFClient.SVC.Client> clients)
        {
            chatListBoxNames.Items.Clear();
            OnlineClients.Clear();
            foreach (SVC.Client c in clients)
            {
                ListBoxItem item = MakeItem(c.AvatarID, c.Name);
                chatListBoxNames.Items.Add(item);
                OnlineClients.Add(item, c);
            }
        }

        public void Receive(WPFClient.SVC.Message msg)
        {
            foreach (SVC.Client c in this.OnlineClients.Values)
            {
                if (c.Name == msg.Sender)
                {
                    ListBoxItem item = MakeItem(c.AvatarID, 
                        msg.Sender + " : " + msg.Content);
                    chatListBoxMsgs.Items.Add(item);
                }
            }
            ScrollViewer sv = FindVisualChild(chatListBoxMsgs);
            sv.LineDown();
        }

        public void ReceiveWhisper(WPFClient.SVC.Message msg, 
                                   WPFClient.SVC.Client receiver)
        {
            foreach (SVC.Client c in this.OnlineClients.Values)
            {
                if (c.Name == msg.Sender)
                {
                    ListBoxItem item = MakeItem(c.AvatarID,
                        msg.Sender + " whispers " + 
                        receiver.Name + " : " + msg.Content);
                    chatListBoxMsgs.Items.Add(item);
                }
            }
            ScrollViewer sv = FindVisualChild(chatListBoxMsgs);
            sv.LineDown();
        }

        public void IsWritingCallback(WPFClient.SVC.Client client)
        {
            if (client == null)
            {
                chatLabelWritingMsg.Content = "";
            }
            else
            {
                chatLabelWritingMsg.Content += client.Name + 
                      " is writing a message.., ";
            }
        }

        public void ReceiverFile(WPFClient.SVC.FileMessage fileMsg, 
                                 WPFClient.SVC.Client receiver)
        {
            try
            {
                FileStream fileStrm = new FileStream(rcvFilesPath + 
                           fileMsg.FileName, FileMode.Create, 
                           FileAccess.ReadWrite);
                fileStrm.Write(fileMsg.Data, 0, fileMsg.Data.Length);
                chatLabelSendFileStatus.Content = 
                           "Received file, " + fileMsg.FileName;
            }
            catch (Exception ex)
            {
                chatLabelSendFileStatus.Content = ex.Message.ToString();
            }
        }

        public void UserJoin(WPFClient.SVC.Client client)
        {
            ListBoxItem item = MakeItem(client.AvatarID,
                "------------ " + client.Name + " joined chat ------------");
            chatListBoxMsgs.Items.Add(item);
            ScrollViewer sv = FindVisualChild(chatListBoxMsgs);
            sv.LineDown();
        }

        public void UserLeave(WPFClient.SVC.Client client)
        {
            ListBoxItem item = MakeItem(client.AvatarID,
                "------------ " + client.Name + " left chat ------------");
            chatListBoxMsgs.Items.Add(item);
            ScrollViewer sv = FindVisualChild(chatListBoxMsgs);
            sv.LineDown();
        }

        #endregion
    }
}

Other stuff

Enable online access over the Internet

• If your server (the machine that will run the service application) is inside a network, you have to forward the port that the service listens on (in our case, it is 7997). To do this, login in to your router configuration, and port forward 7997 (Help).



• You may also want to open this port manually, or create a rule for it in your firewall. I use Kaspersky Internet Security
.

Automatically locate service IP

You can automatically locate your service by saving an always-updated IP in a text file, uploading it online, and letting your client applications read the IP from the uploaded text file..

    WebRequest request = WebRequest.Create("www.yourserver.com/textfile.txt");
    WebResponse response = request.GetResponse();
    Stream strm = response.GetResponseStream();
    StreamReader reader = new StreamReader(strm);
    string serviceIP = reader.ReadToEnd();

Feedback

These distributed applications are built on a learning experience. I wanted to share the code to learn more and let others learn too, so if you got problems, errors, ideas, please let me know. If you liked it, please vote. Thanks.

You must Sign In to use this message board.

FAQ    Noise Tolerance Very HighHighMediumLowVery Low   Layout Expand Posts & RepliesThread ViewNo JavascriptNo JS + Preview   Per page 102550

Msgs 1 to 25 of 44 (Total in Forum: 44) (Refresh) FirstPrevNext

brilliant hz_nevzat 23:06 10 Jun '09   step by step, clear and brilliant.Great job man! Sign In·View Thread·PermaLink help danyes 15:58 28 May '09   i want to use it in vs2008 i build a new wcfservicelibrary ， in the Iservice.cs using System; using System.Collections.Generic; using System.ServiceModel; using System.Runtime.Serialization; namespace ServiceAssembly { [DataContract] public class Client { private string _name; private int _avatarID ; private DateTime _time; [DataMember] public string Name { get { return _name; } set { _name = value; } } [DataMember] public int AvatarID { get { return _avatarID; } set { _avatarID = value; } } [DataMember] public DateTime Time { get { return _time; } set { _time = value; } } } [DataContract] public class Message { private string _sender; private string _content; private DateTime _time; [DataMember] public string Sender { get { return _sender; } set { _sender = value; } } [DataMember] public string Content { get { return _content; } set { _content = value; } } [DataMember] public DateTime Time { get { return _time; } set { _time = value; } } } in Service1.cs [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single, ConcurrencyMode = ConcurrencyMode.Multiple, UseSynchronizationContext = false)] public class ChatService : IChat { Dictionary< Client, IChatCallback> clients = new Dictionary< List< Client> clientList = new List< Client>(); public IChatCallback CurrentCallback { get { return OperationContext.Current. GetCallbackChannel< IChatCallback>(); } } object syncObj = new object(); private bool SearchClientsByName(string name) { foreach (Client c in clients.Keys) { if (c.Name == name) { return true; } } return false; } #region IChat Members public bool Connect(Client client) { if (!clients.ContainsValue(CurrentCallback) && !SearchClientsByName(client.Name)) { lock (syncObj) { clients.Add(client, CurrentCallback); clientList.Add(client); foreach (Client key in clients.Keys) { IChatCallback callback = clients[key]; try { callback.RefreshClients(clientList); callback.UserJoin(client); } catch { clients.Remove(key); return false; } } } return true; } return false; } public void Say(Message msg) { lock (syncObj) { foreach (IChatCallback callback in clients.Values) { callback.Receive(msg); } } } public void Whisper(Message msg, Client receiver) { foreach (Client rec in clients.Keys) { if (rec.Name == receiver.Name) { IChatCallback callback = clients[rec]; callback.ReceiveWhisper(msg, rec); foreach (Client sender in clients.Keys) { if (sender.Name == msg.Sender) { IChatCallback senderCallback = clients[sender]; senderCallback.ReceiveWhisper(msg, rec); return; } } } } } public void IsWriting(Client client) { lock (syncObj) { foreach (IChatCallback callback in clients.Values) { callback.IsWritingCallback(client); } } } public bool SendFile(FileMessage fileMsg, Client receiver) { foreach (Client rcvr in clients.Keys) { if (rcvr.Name == receiver.Name) { Message msg = new Message(); msg.Sender = fileMsg.Sender; msg.Content = "I'M SENDING FILE.. " + fileMsg.FileName; IChatCallback rcvrCallback = clients[rcvr]; rcvrCallback.ReceiveWhisper(msg, receiver); rcvrCallback.ReceiverFile(fileMsg, receiver); foreach (Client sender in clients.Keys) { if (sender.Name == fileMsg.Sender) { IChatCallback sndrCallback = clients[sender]; sndrCallback.ReceiveWhisper(msg, receiver); return true; } } } } return false; } public void Disconnect(Client client) { foreach (Client c in clients.Keys) { if (client.Name == c.Name) { lock (syncObj) { this.clients.Remove(c); this.clientList.Remove(c); foreach (IChatCallback callback in clients.Values) { callback.RefreshClients(this.clientList); callback.UserLeave(client); } } return; } } } #endregion } } then i config the app.config file it run,but it cant get the client list and it cant send message why? Sign In·View Thread·PermaLink Add Webcam Feature dxonny 4:24 27 May '09   Your application is great! But how to add the webcam feature? Thanks Sign In·View Thread·PermaLink want to use server administration aksshay 23:09 16 Apr '09   Hi ElDemery, this one a nice articles I ever found. I want to use server administration. viz, there will be the administrator who will be responsible to allow chatters to chat. A chatter of one group or room can directly chat to his chatters belonging to his room. But he is not allowed to chat with chatters of other room. For that he is compelled to take permission of admin and when admin will allow him, he will see list of chatters of requested room and will be able to chat. Please tell how this can be implemented. maverick Sign In·View Thread·PermaLink One problem I see. [modified] Shukaido 12:02 25 Nov '08   I love the walkthrough approach to this article. There's not a whole lot of detail as to the why of most of it, but your references to other articles are more than adequate compensation for that. The one problem I noticed was, for those of us who actually treated this like a walkthrough, there was absolutely no discussion of actually building the GUI objects in the WPFClient application. So if you just follow the article line by line, you can't build, because all the GUI objects referenced in WPFClient->Window1.xaml.cs do not exist. You may want to add in a step to actually define the GUI for the client. I actually had to open up your code and copy over the UI from that. Where, what I wanted to do was similar to the server piece where the xaml code is right there to copy for myself. Other than that, you've got my vote, and that is the only reason I am giving this less than a 5. modified on Wednesday, December 3, 2008 3:29 PM Sign In·View Thread·PermaLink Re: One problem I see. Shukaido 6:37 18 Dec '08   OK, I've recently gotten around to actually trying to understand better and learn to make changes, but I never tried to send a message before. I haven't changed anything with the code, yet, but I also never sent messages. Now, when I connect 2 clients, and try to send a message, it reverts the chat windows to the login screen. There's not any errors, and I've tracked the error down to the call "sv.LineDown()". I'm using VS2008 SP1, and .NET 3.5 SP1. Can you think of any reason for this call to have issues? The only alterations I made to the code as I copied/walked through your example code was to change naming conventions to something I'm more familiar/comfortable with. And seperating all classes/interfaces/etc into there own files. I can get you my code so you can see if it's just my machine or whatever, just let me know. Sign In·View Thread·PermaLink Re: One problem I see. Islam ElDemery 3:42 22 Dec '08   I think it faults right after connecting, please show/send me your code, im available on msn messenger. ISSY A WCF-WPF Internet Chat Application CreateUserWizard Control Ajax-enabled using Anthem.NET Video Uploader Control Sign In·View Thread·PermaLink Re: One problem I see. Shukaido 17:28 2 Jan '09   As far as I've tracked it down, The error actually happens when it tries to scroll to the most recent message in the queue. I've made a change that seems to have fixed it, though it requires hardcoding instead of your elegant generic solution. I added "chatListBoxMsgs.ScrollIntoView( item );" at line 651 in Window1.xaml.cs in WPFClient project and commented out lines that use the ScrollViewer object after the for loop as well as all other places where ScrollViewer objects are/were used and used the ListBox.ScrollIntoView(object item) function instead. If you would like to try this solution, then feel free. though all functions of the client/server chat program appear to be working as designed. Now all I have to do is add in my other functions to make it able to handle the new functions that I need to put into it. Thank you for your willingness to help, though. Sign In·View Thread·PermaLink so greate!!! chenli0513 22:28 12 Nov '08   in the namespace WPFClient.SVC :This code was generated by a tool. i am a beginer ; i am so curiouse about the wcf .from you source code i found the file ,it's namespace is WPFClient.SVC on the top of the file show the word This code was generated by a tool. can you tell me the tool ;what 's the relation between the tool and the wpf! Sign In·View Thread·PermaLink Re: so greate!!! Islam ElDemery 0:58 16 Nov '08   Well, WPFClient is the project name, this does not have any relation between the the generated code and the WPF. The code is generated by visual studio through adding new service reference and this is a dialog that calls a tool called svcutil.exe , or by using the tool directly. ISSY A WCF-WPF Internet Chat Application CreateUserWizard Control Ajax-enabled using Anthem.NET Video Uploader Control Sign In·View Thread·PermaLink Error occured;/ ptaku20 13:23 6 Oct '08   System.ServiceModel.CommunicationException occurred Message="The socket connection was aborted. This could be caused by an error processing your message or a receive timeout being exceeded by the remote host, or an underlying network resource issue. +c# 3 what's that mean? Please help Sign In·View Thread·PermaLink Re: Error occured;/ Islam ElDemery 0:28 27 Nov '08   when did u get this error? after the connection is opened? ISSY A WCF-WPF Internet Chat Application CreateUserWizard Control Ajax-enabled using Anthem.NET Video Uploader Control Sign In·View Thread·PermaLink Keep goin man! final_zero 23:39 30 Aug '08   Thanks for this application and this is a nice golden article. Aamer A. Alduais final_zero My Favorite Qoute "Faliure is the beginning of Success" Aamer A. Alduais (^_^Me^_^) Sign In·View Thread·PermaLink Walkthrough Approach is Excellent [modified] Taner Riffat 17:41 23 Jul '08   Hello again Islam, First, please let me say that your walkthough approach to a fairly complex topic is excellent. Well done. It has inspired me to take the same walkthrough approach when I do my next code project article. Second, I have suggestions for improvement. I am guessing you are already aware of these issues, but I am hoping you will revise this article with the following in mind: 1. As I went through the walkthough I followed the "copy and paste" instructions only to find there are errors in the code. This is easily fixed by downloading the source code and copying and pasting the bits you want from there, however, the source code in the article itself should be fixed for things to really flow properly in the walkthrough (i.e. you should not have to refer to the source code to fix errors). The best way to find these errors are to do the walkthorugh yourself from a blank project. 2. In the section where you "Add a Service Reference", readers are asked to key in this reference as per the image: net.tcp://localhost:7996/WPFHost/mex It would be nice to know here a little about where the hell you got this string? Excuse my ignorance, but I know very little about the net.tcp protocol and "mex". I know you have sited references at the beginning of the article but you could elaborate a little here, just a small paragraph of explaination would be helpful. Most of us are familiar with Http and Ftp but net.tcp?? Hmmmm. Also, could you explain why pressing the "Discover" button does not find the service? 3. In the "Create Client on WPF" section I do not see a section on adding the XAML for the Client and also felt that this should have been done first, then the code behind, then "Adding the Service Reference"... 4. Avatars. You should ask the reader to copy the avatars folder from the source code folder and then explain how to add the folder to the walkthrough project, then add the images and finally how to set the embedded property for all the images. 5. Before the "Other Stuff' section you could add a "Running the Application" section or just extend the "Create WPF Client" section. You should explain that you can enter "localhost" for the "Service IP" just to get things working. You could also instruct the reader to start a second client via File Explorer by browsing to the bin folder and double clicking the .exe file. That way the reader can have a chat with multiple clients using "localhost". This would be a perfect ending to the walktrhough. And finally, I would like to thank you again for this excellent piece of work. I think walkthroughs are a really fast and convenient way to learn. How many articles can teach you a complex topic without the need to refer to the source code? The walkthough approach with the "copy and paste" code is by far a superior way to teach a topic. Well done! Thanks again You can contact me at howartthou@hotmail.com. Regards Taner modified on Thursday, July 24, 2008 12:37 AM Sign In·View Thread·PermaLink Re: Walkthrough Approach is Excellent Islam ElDemery 0:51 27 Jul '08   Thank you so much, I'm so happy, I have been always looking for good feedbacks and this is the best one ever, I really didn't notice these issues before altough I have read the article many times! 1- This is right I'll fix the code samples in the article 2- This is the mex endpoint address which provides metada to the service, and it uses the mexTcpBinding binding, refer to this article[^]. 3- This is right, I've just noticed that the xaml code of the client is missing!. 4 and 5- I will make this asap. Again thank you so much for your effort to get this article better. ISSY A WCF-WPF Internet Chat Application CreateUserWizard Control Ajax-enabled using Anthem.NET Video Uploader Control Sign In·View Thread·PermaLink Re: Walkthrough Approach is Excellent Taner Riffat 20:02 27 Jul '08   My pleasure Islam, Glad you considered my suggestions as positive feedback. As you can appreciate it was a bit of effort on my part, but I thought it was worth it because your presentation and walkthrough approach is really good. I hope to see more walkthrough style articles in future. Great job. I will check out the mex article and look forward to this article being revised Thanks again. You can contact me at howartthou@hotmail.com. Regards Taner Sign In·View Thread·PermaLink Create client on WPF Taner Riffat 20:00 22 Jul '08   Hi Islam The bit where you say "Create client on WPF" has me getting nowhere fast. See these two instructions that you give: "Set the WPFHost project to be the startup project, start it, hit the Start button to run the service. Set the WPFClient project to be the startup project, and add a service reference, as in this picture:" Well, when I start the WPFHost I am not able to start the WPFClient, let alone add a service reference. VS 2008 won't let me start two projects at the same time. There is a "set startup projects" feature if you right click the Solution node in Solution Explorer which will let you start two projects at the same time, but once they are started you cannot right click the WPFClient and select "add service reference". So do I have a problem with my VS 2008 configuration or can you please spell out exactly how you started 2 projects at the same time and added the service reference at runtime? Regards Taner You can contact me at howartthou@hotmail.com. Regards Taner Sign In·View Thread·PermaLink Re: Create client on WPF Islam ElDemery 0:04 23 Jul '08   After setting the project as startup, start it without debugging , press Ctrl+F5 not F5 ISSY A WCF-WPF Internet Chat Application CreateUserWizard Control Ajax-enabled using Anthem.NET Video Uploader Control Sign In·View Thread·PermaLink Re: Create client on WPF Taner Riffat 16:27 23 Jul '08   Thanks Islam, hmmmm VS 101 You can contact me at howartthou@hotmail.com. Regards Taner Sign In·View Thread·PermaLink Not good for transfer large file pajopajo 3:43 3 Jul '08   For sending file there is DataContract with byte[]. Buffer mode is not required for large datacontracts. Recommended is Stream mode or ChunkingBinding from MS SDK Sign In·View Thread·PermaLink 1.00/5 (1 vote) Re: Not good for transfer large file Islam ElDemery 0:53 27 Jul '08   Of course you are right, this is just a sample. ISSY A WCF-WPF Internet Chat Application CreateUserWizard Control Ajax-enabled using Anthem.NET Video Uploader Control Sign In·View Thread·PermaLink Really Good work Member 4532563 12:09 9 May '08   Well done ESLam ! i'm Ayman 4m EGypt too and MCTS web application Sign In·View Thread·PermaLink Re: Really Good work Islam ElDemery 12:11 9 May '08   Thanks so much, Glad you liked it ISSY A WCF-WPF Internet Chat Application CreateUserWizard Control Ajax-enabled using Anthem.NET Video Uploader Control Sign In·View Thread·PermaLink Hey great job Sacha Barber 22:13 6 May '08   Somehow I missed this one. This is really good work, if it were not for your post on another atricles forum, I would not have seen this...Really glad I have actually. Its in my bookmarks now. Great, glad my original article helped you out, well maybe not, maybe inspired this article is better way to put it. really cool...well done Sacha Barber Microsoft Visual C# MVP 2008 Codeproject MVP 2008 Your best friend is you. I'm my best friend too. We share the same views, and hardly ever argue My Blog : sachabarber.net Sign In·View Thread·PermaLink Re: Hey great job Islam ElDemery 23:41 6 May '08   Oh, finally.. man i waited for your post for so long, I was going to send you an email asking to have a look on this .. Your original article is the one made me decide to study WCF, and the first step on my way to study .NET 3.0 (I voted 5 for your original article :P ). So happy you liked it, Thanks so much ISSY A WCF-WPF Internet Chat Application CreateUserWizard Control Ajax-enabled using Anthem.NET Video Uploader Control Sign In·View Thread·PermaLink

Last Visit: 12:03 4 Jul '09     Last Update: 12:03 4 Jul '09 12 Next »