SilverlightShow: SocketsLight - Silverlight Sockets Framework Comments

Re: SocketsLight - Silverlight Sockets Framework

Armadous — Tue, 09 Aug 2011 17:26:49 GMT

This thing saved me a lot of time, mostly. I ran into an issue where clients were seemingly randomly receiving incomplete messages and throwing deserialization exceptions. What I thought was an issue with this project was actually a sleepy IIS problem.

If you app has long lived clients and relatively infrequence web requests turn off IIS worker process idle timeout.

RE: SocketsLight - Silverlight Sockets Framework

dejan — Wed, 11 Aug 2010 12:04:52 GMT

There is some bugs.

Now funct.

RE: SocketsLight - Silverlight Sockets Framework

dejan — Mon, 09 Aug 2010 10:05:39 GMT

Same issue as peter. By big objects packets doesnt reach for some clients ( > 20 packets ) .

thx,

dejan

RE: SocketsLight - Silverlight Sockets Framework

Hu Bin — Mon, 19 Jul 2010 15:39:40 GMT

VERY NICE work Alexey!!

We are using sockets with Silverlight but the code is never tidy enough...

Your implementation gave us a good direction where to go to...

THANKS!

RE: SocketsLight - Silverlight Sockets Framework

peter — Fri, 23 Apr 2010 14:30:40 GMT

some times when i use SendMessageAsync in loop to multi users the packet doesnt reach for some clients, when i put Thread.Sleep(300) before sending (in the loop) it work ok, but sometimes it happens again...., how can i be sure that the packets reach 100% ?

thx,

peter

RE: SocketsLight - Silverlight Sockets Framework

Eric — Mon, 01 Mar 2010 04:55:20 GMT

I do not understand the following piece of the SendMessageAsync method of the MessageClient class. I assume it has something to do with making the byteframe, but what does adding a 0 every 1024 bytes and a 1 at the very end do?

byte[] serializedMessage = this.messageSerializer.Serialize(message);

List<byte> messageByteList = serializedMessage.ToList();

for (int i = 1023; i < serializedMessage.Length; i += 1023)

{

messageByteList.Insert(i, 0);

i++;

}

messageByteList.Add(1);

RE: SocketsLight - Silverlight Sockets Framework

Peter Gfader — Thu, 18 Feb 2010 02:28:00 GMT

VERY NICE work Alexey!!

We are using sockets with Silverlight but the code is never tidy enough...

Your implementation gave us a good direction where to go to...

THANKS!

.peter.gfader.

http://peitor.blogspot.com/

http://twitter.com/peitor

RE: SocketsLight - Silverlight Sockets Framework

James Peckham — Thu, 17 Dec 2009 08:29:20 GMT

simply awesome. thank you for this wonderful library.

to 'bob': it comes with an example in the code... just check it out.

RE: SocketsLight - Silverlight Sockets Framework

bob — Tue, 18 Aug 2009 14:04:58 GMT

nice work Alex.

i'm trying to create multi-player tic-tac-toe game using Silverlight 3. can you supply some example how to use your code in such game? thanks.

RE: SocketsLight - Silverlight Sockets Framework

Alexey Zakharov — Tue, 30 Jun 2009 15:18:38 GMT

>> odanvin

Thanks for you comment. You'd better write about it at codeplex discussion section. Also I can provide you access to contribute to the project.

RE: SocketsLight - Silverlight Sockets Framework

David Roh — Tue, 30 Jun 2009 12:26:08 GMT

Thank you for sharing this Alexey,

Communication optimization is a key feature in the success of many business applications - nice work.

David

RE: SocketsLight - Silverlight Sockets Framework

odanvin — Sat, 20 Jun 2009 20:56:09 GMT

First of all thanks you for this added value on the sockets. I just want to share reconnection capabilities in case of lost connections. It could happen during web application recycling for example. In this case the messageServer just have to send a Message to all clients before it stops in the Application_End method of the Global.asax.cs. Then clients will be able to raise the ConnectionLost event and try to reconnect. Find below my the added feature on the MessageClient:

    
            // --------------------------------------------------------------------------------------------------------------------  
        
            // <copyright file="MessageClient.cs" company="Alexey Zakharov">  
        
            //   This file is part of SocketsLight Framework.  
        
            //  
        
            //   SocketsLight Framework is free software: you can redistribute it and/or modify  
        
            //   it under the terms of the GNU General Public License as published by   
        
            //   the Free Software Foundation, either version 3 of the License, or   
        
            //   (at your option) any later version.   
        
            //     
        
            //   SocketsLight Framework is distributed in the hope that it will be useful,   
        
            //   but WITHOUT ANY WARRANTY; without even the implied warranty of   
        
            //   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   
        
            //   GNU General Public License for more details.   
        
            //     
        
            //   You should have received a copy of the GNU General Public License   
        
            //   along with Foobar.  If not, see http://www.gnu.org/license.  
        
            // copyright> 
        
            // <summary> 
        
            //   Defines the MessageClient type.  
        
            // summary> 
        
            // --------------------------------------------------------------------------------------------------------------------  
        
            namespace Witcraft.SocketsLight.Client  
        
            {  
        
                using System;  
        
                using System.Collections.Generic;  
        
                using System.ComponentModel;  
        
                using System.Linq;  
        
                using System.Net;  
        
                using System.Net.Sockets;  
        
                using System.Windows;  
        
                using Witcraft.SocketsLight.Server;  
        
            using System.Windows.Threading;  
        
                using System.Diagnostics;  
        
                using System.Threading;  
        
                using System.Windows.Browser;  
        
                /// <summary> 
        
                /// Send and recives messages.  
        
                /// summary> 
        
                public class MessageClient : IMessageClient  
        
                {  
        
                    /// <summary> 
        
                    /// Used to aggregate message frames.  
        
                    /// summary> 
        
                    private List<byte> messageBuffer = new List<byte>();  
        
                    /// <summary> 
        
                    /// Serialize and deserialize messages.  
        
                    /// summary> 
        
                    private IMessageSerializer messageSerializer;  
        
                    /// <summary> 
        
                    /// Port which will be used for message transfer.  
        
                    /// summary> 
        
                    private int port;  
        
                    /// <summary> 
        
                    /// Socket which will be used for message transfer.  
        
                    /// summary> 
        
                    private Socket socket;  
        
                    /// <summary> 
        
                    /// Dispatcher enabling code execution on UI thread.  
        
                    /// summary> 
        
                    private Dispatcher dispatcher;  
        
                    /// <summary> 
        
                    /// Web client attempting connection re-establishment.  
        
                    /// summary> 
        
                    private WebClient reconnectClient;  
        
                    /// <summary> 
        
                    /// Timer controlling the connection re-establishment.  
        
                    /// summary> 
        
                    private Timer reconnectTimer;  
        
                    /// <summary> 
        
                    /// Date and time when connection re-establishment starts.   
        
                    /// summary> 
        
                    private DateTime reconnectTime;  
        
                    /// <summary> 
        
                    /// Period between each connection re-establishment attempt.  
        
                    /// summary> 
        
                    private TimeSpan reconnectPolling;  
        
                    /// <summary> 
        
                    /// Period during connection re-establishment are attempted.  
        
                    /// summary> 
        
                    private TimeSpan reconnectTimeout;  
        
                    /// <summary> 
        
                    /// Initializes a new instance of the <see cref="MessageClient"/> class.  
        
                    /// summary> 
        
                    /// <param name="port">  
        
                    /// param> 
        
                    /// <param name="messageSerializer">  
        
                    /// param> 
        
                    public MessageClient(int port, IMessageSerializer messageSerializer)  
        
                        : this(port, messageSerializer, null)  
        
                    {  
        
                    }  
        
                    /// <summary> 
        
                    /// Initializes a new instance of the <see cref="MessageClient"/> class.  
        
                    /// summary> 
        
                    /// <param name="port">The port.param> 
        
                    /// <param name="messageSerializer">The message serializer.param> 
        
                    /// <param name="dispatcher">The dispatcher.param> 
        
                    public MessageClient(int port, IMessageSerializer messageSerializer, Dispatcher dispatcher)  
        
                    {  
        
                        this.port = port;  
        
                        this.messageSerializer = messageSerializer;  
        
                        this.socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);  
        
                        this.dispatcher = dispatcher;  
        
                        this.reconnectPolling = TimeSpan.FromSeconds(5);  
        
                        this.reconnectTimeout = TimeSpan.FromSeconds(30);  
        
                        this.reconnectClient = new WebClient();  
        
                        this.reconnectClient.DownloadStringCompleted += new DownloadStringCompletedEventHandler(ReconnectClient_DownloadStringCompleted);  
        
                    }  
        
                    /// <summary> 
        
                    /// Prevents a default instance of the <see cref="MessageClient"/> class from being created.  
        
                    /// summary> 
        
                    private MessageClient()  
        
                    {  
        
                    }  
        
                    /// <summary> 
        
                    /// Occurs when client has connected to message server  
        
                    /// summary> 
        
                    public event EventHandler<AsyncCompletedEventArgs> ConnectCompleted;  
        
                    /// <summary> 
        
                    /// Occure if connection with message server has been lost.  
        
                    /// summary> 
        
                    public event EventHandler<EventArgs> ConnectionLost;  
        
                    /// <summary> 
        
                    /// Occurs when new message have been recieved.  
        
                    /// summary> 
        
                    public event EventHandler<MessageRecievedEventArgs> MessageRecieved;  
        
                    /// <summary> 
        
                    /// Occurs when message is sent  
        
                    /// summary> 
        
                    public event EventHandler<AsyncCompletedEventArgs> SendCompleted;  
        
                    /// <summary> 
        
                    /// Indicates if client is connected to message server.  
        
                    /// summary> 
        
                    public bool Connected  
        
                    {  
        
                        get  
        
                        {  
        
                            return this.socket.Connected;  
        
                        }  
        
                    }  
        
                    /// <summary> 
        
                    /// Connect to message server async.  
        
                    /// summary> 
        
                    /// <param name="state">  
        
                    /// param> 
        
                    public void ConnectAsync()  
        
                    {  
        
                        this.ConnectAsync(null);  
        
                    }  
        
                    /// <summary> 
        
                    /// Connect to message server async.  
        
                    /// summary> 
        
                    /// <param name="state">  
        
                    /// param> 
        
                    public void ConnectAsync(object state)  
        
                    {  
        
                        if (!this.Connected)  
        
                        {  
        
                            var endPoint = new DnsEndPoint(Application.Current.Host.Source.DnsSafeHost, this.port);  
        
                            var args = new SocketAsyncEventArgs { UserToken = state, RemoteEndPoint = endPoint };  
        
                            args.Completed += this.OnSocketConnected;  
        
                            this.socket.ConnectAsync(args);  
        
                        }  
        
                    }  
        
                    /// <summary> 
        
                    /// Reconnects to message server.  
        
                    /// summary> 
        
                    private void Reconnect()  
        
                    {  
        
                        //start reconnect timer  
        
                        reconnectTime = DateTime.Now;  
        
                        Debug.WriteLine(string.Format("Connection re-establishment started at {0}", reconnectTime.ToString("o")));  
        
                        this.reconnectTimer = new Timer(this.Reconnect  
        
                            , null  
        
                            , TimeSpan.Zero  
        
                            , reconnectPolling);  
        
                    }  
        
                    /// <summary> 
        
                    /// Reconnects to message server.  
        
                    /// summary> 
        
                    /// <param name="state">The state.param> 
        
                    private void Reconnect(object state)  
        
                    {  
        
                        //consider reconnect timeout  
        
                        if ((DateTime.Now - reconnectTime) > reconnectTimeout)  
        
                            throw new TimeoutException(string.Format("Connection re-establishment failed since {0} and during {1}", reconnectTime, reconnectTimeout));  
        
                        //skip web request call if previous request is still busy  
        
                        if (!reconnectClient.IsBusy)  
        
                        {  
        
                            Debug.WriteLine(string.Format("Connection re-establishment attempt at {0}", DateTime.Now.ToString("o")));  
        
                            dispatcher.BeginInvoke(() => 
        
                            {  
        
                                reconnectClient.DownloadStringAsync(HtmlPage.Document.DocumentUri);  
        
                            });  
        
                        }  
        
                    }  
        
                    void ReconnectClient_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)  
        
                    {  
        
                        if (e.Error == null)  
        
                        {  
        
                            //stop reconnect timer  
        
                            reconnectTime = DateTime.MinValue;  
        
                            this.reconnectTimer.Dispose();  
        
                            //reconnect socket client  
        
                            dispatcher.BeginInvoke(() => 
        
                            {  
        
                                this.socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);  
        
                                this.ConnectAsync();  
        
                                Debug.WriteLine(string.Format("Connection re-established in {0}", (DateTime.Now - reconnectTime).ToString()));  
        
                            });  
        
                        }  
        
                    }  
        
                    /// <summary> 
        
                    /// Disconnect from message server.  
        
                    /// summary> 
        
                    public void Disconnect()  
        
                    {  
        
                        this.socket.Close();  
        
                    }  
        
                    /// <summary> 
        
                    /// Send message.  
        
                    /// summary> 
        
                    /// <param name="message">  
        
                    /// param> 
        
                    public void SendMessageAsync(Message message)  
        
                    {  
        
                        this.SendMessageAsync(message, null);  
        
                    }  
        
                    /// <summary> 
        
                    /// Send message.  
        
                    /// summary> 
        
                    /// <param name="message">  
        
                    /// param> 
        
                    /// <param name="userState">  
        
                    /// param> 
        
                    public void SendMessageAsync(Message message, object userState)  
        
                    {  
        
                        if ((this.socket == null) || (this.Connected == false))  
        
                        {  
        
                            // TODO : throw exception.  
        
                        }  
        
                        var args = new SocketAsyncEventArgs();  
        
                        byte[] serializedMessage = this.messageSerializer.Serialize(message);  
        
                        List<byte> messageByteList = serializedMessage.ToList();  
        
                        for (int i = 1023; i < serializedMessage.Length; i += 1023)  
        
                        {  
        
                            messageByteList.Insert(i, 0);  
        
                            i++;  
        
                        }  
        
                        messageByteList.Add(1);  
        
                        args.SetBuffer(messageByteList.ToArray(), 0, messageByteList.Count);  
        
                        args.Completed += this.SocketSendCompleted;  
        
                        args.UserToken = userState;  
        
                        this.socket.SendAsync(args);  
        
                    }  
        
                    /// <summary> 
        
                    /// summary> 
        
                    /// <param name="e">  
        
                    /// param> 
        
                    private void OnConnected(AsyncCompletedEventArgs e)  
        
                    {  
        
                        EventHandler<AsyncCompletedEventArgs> handler = this.ConnectCompleted;  
        
                        if (handler != null)  
        
                        {  
        
                            handler(this, e);  
        
                        }  
        
                    }  
        
                    /// <summary> 
        
                    /// summary> 
        
                    /// <param name="e">  
        
                    /// param> 
        
                    private void OnConnectionLost()  
        
                    {  
        
                        EventHandler<EventArgs> handler = this.ConnectionLost;  
        
                        if (handler != null)  
        
                        {  
        
                            handler(this, new EventArgs());  
        
                        }  
        
                    }  
        
                    /// <summary> 
        
                    /// summary> 
        
                    /// <param name="e">  
        
                    /// param> 
        
                    private void OnMessageRecieved(MessageRecievedEventArgs e)  
        
                    {  
        
                        EventHandler<MessageRecievedEventArgs> handler = this.MessageRecieved;  
        
                        if (handler != null)  
        
                        {  
        
                            handler(this, e);  
        
                        }  
        
                    }  
        
                    /// <summary> 
        
                    /// summary> 
        
                    /// <param name="e">  
        
                    /// param> 
        
                    private void OnSendCompleted(AsyncCompletedEventArgs e)  
        
                    {  
        
                        EventHandler<AsyncCompletedEventArgs> handler = this.SendCompleted;  
        
                        if (handler != null)  
        
                        {  
        
                            handler(this, e);  
        
                        }  
        
                    }  
        
                    /// <summary> 
        
                    /// summary> 
        
                    /// <param name="sender">  
        
                    /// param> 
        
                    /// <param name="e">  
        
                    /// param> 
        
                    private void OnSocketConnected(object sender, SocketAsyncEventArgs e)  
        
                    {  
        
                        AsyncCompletedEventArgs asyncArgs;  
        
                        if (this.Connected)  
        
                        {  
        
                            var response = new byte[1024];  
        
                            e.SetBuffer(response, 0, response.Length);  
        
                            e.Completed -= this.OnSocketConnected;  
        
                            e.Completed += this.OnSocketReceive;  
        
                            this.socket.ReceiveAsync(e);  
        
                            asyncArgs = new AsyncCompletedEventArgs(null, false, e.UserToken);  
        
                            this.OnConnected(asyncArgs);  
        
                        }  
        
                        // TODO: Handle error while connection.  
        
                    }  
        
                    /// <summary> 
        
                    /// summary> 
        
                    /// <param name="sender">  
        
                    /// param> 
        
                    /// <param name="e">  
        
                    /// param> 
        
                    private void OnSocketReceive(object sender, SocketAsyncEventArgs e)  
        
                    {  
        
                        if (e.BytesTransferred == 0)  
        
                        {  
        
                            this.OnConnectionLost();  
        
                            this.socket.Close();  
        
                            //reconnect if possible  
        
                            if (dispatcher != null) this.Reconnect();  
        
                            return;  
        
                        }  
        
                        this.messageBuffer.AddRange(e.Buffer.Take(e.BytesTransferred - 1));  
        
                        if (e.Buffer[e.BytesTransferred - 1] > 0)  
        
                        {  
        
                            this.OnMessageRecieved(  
        
                                new MessageRecievedEventArgs(this.messageSerializer.Deserialize(this.messageBuffer.ToArray())));  
        
                            this.messageBuffer.Clear();  
        
                        }  
        
                        this.socket.ReceiveAsync(e);  
        
                    }  
        
                    /// <summary> 
        
                    /// summary> 
        
                    /// <param name="sender">  
        
                    /// param> 
        
                    /// <param name="e">  
        
                    /// param> 
        
                    private void SocketSendCompleted(object sender, SocketAsyncEventArgs e)  
        
                    {  
        
                        if (e.SocketError == SocketError.Success)  
        
                        {  
        
                            this.OnSendCompleted(new AsyncCompletedEventArgs(null, false, e.UserToken));  
        
                        }  
        
                        // TODO: Handle error if send is not successful.  
        
                    }  
        
                }  
        
            }

RE: SocketsLight - Silverlight Sockets Framework

Lixin — Thu, 28 May 2009 20:52:37 GMT

Good work!

It is very useful when you try to push something from an application running in full trust mode into your Silverlight application. I have been using sockets to do so in the past one year but I have to say the SocketsLight framework can really simplify the coding and make development efficient.

Thanks.

RE: SocketsLight - Silverlight Sockets Framework

Alexey — Thu, 28 May 2009 12:35:58 GMT

>> is this working just over http connection?

It uses tcp protocol

>> and if it is (by the Timer logic it look that it does), there is a possiblity to create a duplex logic with a always connected port >> (Dont care about firewall blocking) other than http port( http keep-alive or non-http protocol at all) ?

Timer is not used for polling. Timer is used in weather example to invoke server method which would broadcast message with new random weather data.

RE: SocketsLight - Silverlight Sockets Framework

Fabio Kaminski — Thu, 28 May 2009 11:59:41 GMT

Nice Project!

it may become a very helpful tool when the perfomance may be an issue.

i doubt WCF polling duplex could be more optimized than that, with that tons of protocol implementation.

is this working just over http connection?

im asking this cause when firewall and proxy´s may become present, we could have connection problems.

and if it is (by the Timer logic it look that it does), there is a possiblity to create a duplex logic with a always connected port (Dont care about firewall blocking) other than http port( http keep-alive or non-http protocol at all) ?

thanks and congratulations!