示例#1
0
        public void SendMessage(int Channel, byte[] data, SharpClient client)
        {
            SharpSerializer ser = SharpSerializer.Create();

            ser.Write((byte)SharpConnectionMessages.DirectData);

            ser.Write((short)0);
            ser.Write(Channel);
            ser.Write(data.Length);
            ser.Write(data);

            if (client.isMine)
            {
                S_OnReceivedData(serverclient, Channel, data);
            }
            else
            {
                client.SendMessage(ser.DataAndPost());
            }

            if (ser.inUse)
            {
                ser.Post();
            }
        }
示例#2
0
        void S_OnClientDisconnected(SharpClient client)
        {
            #region Broadcasting Other Clients
            SharpSerializer ser = SharpSerializer.Create();
            ser.Write((byte)SharpConnectionMessages.ClientDisconnected);
            ser.Write(client.NetworkID);

            Broadcast(ser.DataAndPost(), client);
            #endregion

            SharpNetworking.Instance.OnClientDisconnected(client);

            room.RemoveClient(client);

            #region Closing Socket & Thread
            try
            {
                TCPMessageHandler.CloseConnection(client.Connection);
            }
            catch { }
            try
            {
                client.ListeningThread.Abort();
            }
            catch { }
            client.ListeningThread = null;

            #endregion
        }
示例#3
0
        void HandleAcceptedConnection(TcpClient client, SharpClient sclient)
        {
            SharpSerializer syncPack = SharpSerializer.Create();

            syncPack.Write((byte)IncomingConnectionResponse.Approved);

            short netID = this.room.NextFreeID;

            sclient.AssingNetID(netID);


            syncPack.Write(netID);
            this.room.Write(ref syncPack);

            TCPMessageHandler.Write(client, syncPack.DataAndPost());

            this.room.AssignClient(sclient);
            Thread t = new Thread(() => ListenClient(sclient));

            sclient.ListeningThread = t;
            sclient.Connection      = client;

            t.Start();

            S_OnClientConnected(sclient);
        }
示例#4
0
文件: Program.cs 项目: asciima/JGate
    static void Main(string[] args)
    {
        try
        {
            SharpClient client = new SharpClient();
            client.OnConnect = () =>
            {
                Console.WriteLine("OnConnect");
                string msg = "hello from sharpclient";
                client.Write(Encoding.UTF8.GetBytes(msg));
            };
            client.OnClose = () =>
            {
                Console.WriteLine("close now");
            };
            client.OnMessage = (byte[] msg) =>
            {
                Console.WriteLine("read :" + Encoding.UTF8.GetString(msg));
            };



            client.Connect("localhost", 28800);
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }
        Console.ReadKey();
    }
示例#5
0
    static void Main(string[] args)
    {
        try
        {
            SharpClient client = new SharpClient();
            client.SetChannel("test_1");

            client.OnConnect = () =>
            {
                Console.WriteLine("OnConnect");
                string msg = "hello from sharpclient";
                client.Write(Encoding.UTF8.GetBytes(msg));
            };
            client.OnClose = () =>
            {
                Console.WriteLine("close now");
            };
            client.OnMessage = (byte[] msg) =>
            {
                Console.WriteLine("read :" + Encoding.UTF8.GetString(msg));
            };


            //client.Connect("jgate.qipai.io", 18666);//公网
            client.Connect("localhost", 18666);//内网
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }
        Console.ReadKey();
    }
示例#6
0
        void C_OnReceivedMessage(byte[] rawMessage)
        {
            SharpSerializer         ser          = SharpSerializer.Create(rawMessage);
            SharpConnectionMessages incomingType = (SharpConnectionMessages)ser.ReadByte();

            if (incomingType == SharpConnectionMessages.ClientConnected)
            {
                SharpClient incomingClient = new SharpClient(ref ser);
                this.room.AssignClient(incomingClient);
                C_OnClientConnected(incomingClient);
            }
            else if (incomingType == SharpConnectionMessages.ClientDisconnected)
            {
                short netID = ser.ReadInt16();
                C_OnClientDisconnected(this.room.Get(netID));
            }
            else if (incomingType == SharpConnectionMessages.DirectData)
            {
                short  sender      = ser.ReadShort();
                int    channel     = ser.ReadInt32();
                int    packageSize = ser.ReadInt32();
                byte[] rawData     = ser.ReadBytes(packageSize);
                C_OnReceivedData(this.room.Get(sender), channel, rawData);
            }

            ser.Post();
        }
示例#7
0
        public void Disconnect()
        {
            if (!connected)
            {
                throw new Exception("You are not connected already");
            }
            connected = false;


            ip   = "";
            port = 0;
            room = null;
            me   = null;


            try
            {
                TCPMessageHandler.CloseConnection(server_client);
            }
            catch { }
            try
            {
                listenerThread.Abort();
                listenerThread = null;
            }
            catch { }
        }
示例#8
0
        void HandleIncomingConnectionRequest(SharpSerializer incomingData, TcpClient client)
        {
            IncomingConnectionRequests request = (IncomingConnectionRequests)incomingData.ReadByte();

            if (request == IncomingConnectionRequests.RoomDetails)
            {
                //Sending Room Details And Goodby
                SharpRoomDetails room_details = this.room.GetAsDetails();

                SharpSerializer respond = SharpSerializer.Create();
                room_details.Write(ref respond);

                TCPMessageHandler.Write(client, respond.DataAndPost());

                TCPMessageHandler.CloseConnection(client);

                return;
            }
            else if (request == IncomingConnectionRequests.ConnectionApprove)
            {
                SharpSerializer respond = SharpSerializer.Create();

                SharpClient incomingClient = new SharpClient(ref incomingData);

                if (this.room.isFull)
                {
                    respond.Write((byte)IncomingConnectionResponse.ServerIsFull);
                    TCPMessageHandler.Write(client, respond.DataAndPost());
                    TCPMessageHandler.CloseConnection(client);
                    return;
                }

                if (this.room.isExistName(incomingClient.ClientName))
                {
                    respond.Write((byte)IncomingConnectionResponse.NameIsExist);
                    TCPMessageHandler.Write(client, respond.DataAndPost());
                    TCPMessageHandler.CloseConnection(client);
                    return;
                }

                string incomingPassword = incomingData.ReadString();
                if (!this.room.isValidPassword(incomingPassword))
                {
                    respond.Write((byte)IncomingConnectionResponse.WrongPassword);
                    TCPMessageHandler.Write(client, respond.DataAndPost());
                    TCPMessageHandler.CloseConnection(client);
                    return;
                }

                HandleAcceptedConnection(client, incomingClient);
            }
            else
            {
                TCPMessageHandler.CloseConnection(client);
            }
        }
示例#9
0
        public void Disconnect()
        {
            if (!hosted)
            {
                throw new Exception("You are not hosted already");
            }
            hosted = false;

            foreach (var item in this.room.ConnectedClients)
            {
                try
                {
                    TCPMessageHandler.CloseConnection(item.Connection);
                }
                catch { }

                try
                {
                    item.ListeningThread.Abort();
                }
                catch { }

                item.ListeningThread = null;
            }

            port         = 0;
            serverclient = null;
            room         = null;



            try
            {
                listener.Stop();
            }
            catch { }
            try
            {
                listener = null;
            }
            catch { }

            try
            {
                S_StoppedHosted();
            }
            catch { }

            try
            {
                listenerThread.Abort();
                listenerThread = null;
            }
            catch { }
        }
示例#10
0
 void Broadcast(byte[] data, SharpClient except)
 {
     foreach (var item in this.room.ConnectedClients)
     {
         if (item == except)
         {
             continue;
         }
         item.SendMessage(data);
     }
 }
示例#11
0
        void S_OnClientConnected(SharpClient client)
        {
            #region Broadcasting To Other clients
            SharpSerializer ser = SharpSerializer.Create();
            ser.Write((byte)SharpConnectionMessages.ClientConnected);
            client.Write(ref ser);

            Broadcast(ser.DataAndPost(), client);
            #endregion

            SharpNetworking.Instance._OnClientConnected(client);
        }
示例#12
0
    public static bool Connect(string IP, int Port, string Password, SharpClient self, out ConnectResults result)
    {
        if (IsConnected)
        {
            result = ConnectResults.AlreadyConnected;
            return(false);
        }
        bool succes = isconnected = client.Connect(IP, Port, Password, self, out result);

        _ishost = !succes;
        return(succes);
    }
示例#13
0
        public void SendMessage(int Channel, byte[] data, SharpClient client)
        {
            SharpSerializer ser = SharpSerializer.Create();

            ser.Write((byte)SharpConnectionMessages.MessageType2);

            ser.Write(client.NetworkID);
            ser.Write(Channel);
            ser.Write(data.Length);
            ser.Write(data);

            Server.SendMessage(ser.DataAndPost());
        }
示例#14
0
        void ListenClient(SharpClient client)
        {
            while (true)
            {
                byte[] package = null;
                try
                {
                    package = TCPMessageHandler.Read(client.Connection);
                }
                catch
                {
                    S_OnClientDisconnected(client);
                    return;
                }

                S_OnReceivedMessage(client, package);
            }
        }
示例#15
0
        public bool Host(out HostResult result, int Port, SharpRoom room)
        {
            if (hosted)
            {
                result = HostResult.AlreadyHosted;
                return(false);
            }
            try
            {
                this.port = Port;
                this.room = room;

                IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, this.port);
                listener = new TcpListener(endPoint);
                listener.Start();

                serverclient = new SharpClient("ServerClient");
                room.AssignClient(serverclient);

                listenerThread = new Thread(ListenClients);
                listenerThread.Start();

                hosted = true;

                S_OnHosted();
                result = HostResult.Succes;
                return(true);
            }
            catch (Exception e)
            {
                try { listener.Stop(); } catch { }
                try { listenerThread.Abort(); } catch { }

                listenerThread = null;
                listener       = null;
                hosted         = false;

                result = HostResult.UnhandledException;
                return(false);
            }
        }
示例#16
0
		protected void OnDoubleClickTab(SharpClient.UI.Controls.TabControl tc, SharpClient.UI.Controls.TabPage page)
		{
			Content c = (Content)page.Tag;

			// Make Content record its current position and remember it for the future 
			c.RecordRestore();

			// Invert docked status
			c.Docked = (c.Docked == false);

			// Remove from current WindowContent and restore its position
			_manager.HideContent(c, false, true);
			_manager.ShowContent(c);
		}
示例#17
0
 void C_OnReceivedData(SharpClient sender, int channel, byte[] data)
 {
     //Console.WriteLine(sender.ClientName + " : " + Encoding.UTF8.GetString(data));
     SharpNetworking.Instance.OnMessageReceived(sender, channel, data);
 }
示例#18
0
 void C_OnClientDisconnected(SharpClient client)
 {
     //Console.WriteLine("A Player Disconnected : " + client.ClientName);
     SharpNetworking.Instance.OnClientDisconnected(client);
 }
示例#19
0
			public DrawTab(SharpClient.UI.Controls.TabPage tabPage, Rectangle drawRect, int index)
			{
				_index = index;
				_tabPage = tabPage;
				_drawRect = drawRect;
			}
示例#20
0
 void S_OnReceivedData(SharpClient sender, int channel, byte[] data)
 {
     SharpNetworking.Instance.OnMessageReceived(sender, channel, data);
 }
示例#21
0
        void S_OnReceivedMessage(SharpClient sender, byte[] data)
        {
            SharpSerializer         ser  = SharpSerializer.Create(data);
            SharpConnectionMessages type = (SharpConnectionMessages)ser.ReadByte();

            if (type == SharpConnectionMessages.MessageType1)
            {
                #region Message Type 1
                SharpTargets targets = (SharpTargets)ser.ReadByte();
                int          channel = ser.ReadInt32();
                int          size    = ser.ReadInt32();
                byte[]       rawData = ser.ReadBytes(size);


                if (targets == SharpTargets.Server)
                {
                    S_OnReceivedData(sender, channel, rawData);
                    return;
                }

                SharpSerializer package = SharpSerializer.Create();
                package.Write((byte)SharpConnectionMessages.DirectData);

                package.Write(sender.NetworkID);
                package.Write(channel);
                package.Write(size);
                package.Write(rawData);
                if (targets == SharpTargets.All)
                {
                    Broadcast(package.DataAndPost(), null);
                    S_OnReceivedData(sender, channel, rawData);
                }
                else if (targets == SharpTargets.ClientsOnly)
                {
                    Broadcast(package.DataAndPost(), null);
                }
                else if (targets == SharpTargets.OtherClientsOnly)
                {
                    Broadcast(package.DataAndPost(), sender);
                }
                else if (targets == SharpTargets.Others)
                {
                    Broadcast(package.DataAndPost(), sender);
                    S_OnReceivedData(sender, channel, rawData);
                }
                #endregion
            }
            else if (type == SharpConnectionMessages.MessageType2)
            {
                #region Message Type 2
                short  targetID = ser.ReadInt16();
                int    channel  = ser.ReadInt32();
                int    size     = ser.ReadInt32();
                byte[] rawData  = ser.ReadBytes(size);

                if (targetID == 0)
                {
                    S_OnReceivedData(sender, channel, rawData);
                    return;
                }

                SharpSerializer package = SharpSerializer.Create();
                package.Write((byte)SharpConnectionMessages.DirectData);
                package.Write(sender.NetworkID);
                package.Write(channel);
                package.Write(size);
                package.Write(rawData);

                this.room.Get(targetID).SendMessage(package.DataAndPost());
                #endregion
            }
            else if (type == SharpConnectionMessages.MessageType3)
            {
                #region Message Type 3
                short   targetCount = ser.ReadInt16();
                short[] targets     = new short[targetCount];
                for (int i = 0; i < targetCount; i++)
                {
                    targets[i] = ser.ReadInt16();
                }

                int    channel = ser.ReadInt32();
                int    size    = ser.ReadInt32();
                byte[] rawData = ser.ReadBytes(size);

                SharpSerializer package = SharpSerializer.Create();
                package.Write((byte)SharpConnectionMessages.DirectData);
                package.Write(sender.NetworkID);
                package.Write(channel);
                package.Write(size);
                package.Write(rawData);

                byte[] goData = package.DataAndPost();
                for (int i = 0; i < targets.Length; i++)
                {
                    if (targets[i] == 0)
                    {
                        S_OnReceivedData(sender, channel, rawData);
                    }
                    else
                    {
                        this.room.Get(targets[i]).SendMessage(goData);
                    }
                }
                #endregion
            }
        }
示例#22
0
//		public void AddStackControlTab(string ContentTitle,string uniqueTitle,int imageindex,SharpClient.UI.Docking.State _docState,string stackHeader,string stackData,string details,int ColumnHeaderValue,bool sortable)
//		{				
//			try
//			{
//				SharpClient.UI.Controls.TabControl stackTabControl=AddPanelContents(ContentTitle,imageindex,_docState,true);   
//
//				foreach(SharpClient.UI.Controls.TabPage  t in stackTabControl.TabPages)
//				{
//					if(Convert.ToString(t.Tag).ToLower()==uniqueTitle.ToLower() )
//					{						
//						foreach(Control control in t.Controls)
//						{
//							if(control.GetType()==typeof(PGRptControl.StackControl))
//							{
//								((PGRptControl.StackControl)control).RefreshData(stackHeader,stackData,details,ColumnHeaderValue);
//								break;
//							}
//						}
//						stackTabControl.SelectedTab=t;
//						t.Show();
//						return;
//					}
//				}
//			
//				SharpClient.UI.Controls.TabPage tPage=new SharpClient.UI.Controls.TabPage(uniqueTitle); 
//				tPage.Tag=uniqueTitle;
//				tPage.Dock=DockStyle.Fill;
//				stackTabControl.TabPages.Add(tPage);
//				PGRptControl.StackControl stackControl=new PGRptControl.StackControl(sortable); 				
//				stackControl.RefreshData(stackHeader,stackData,details,ColumnHeaderValue);					
//				stackControl.Dock=DockStyle.Fill;
//				tPage.Controls.Add(stackControl); 							
//				stackTabControl.SelectedTab=tPage;
//				tPage.Show();
//			}
//			catch(Exception ex)
//			{
//				MessageBox.Show(ex.Message,"Error",MessageBoxButtons.OK ,MessageBoxIcon.Error);
//			}
//		}

		public void AddStackControlTab(string ContentTitle,string uniqueTitle,int imageindex,SharpClient.UI.Docking.State _docState,string stackHeader,string stackData,string details,int ColumnHeaderValue,bool wizard,bool sortable)
		{				
			try
			{
				SharpClient.UI.Controls.TabControl stackTabControl=AddPanelContents(ContentTitle,imageindex,_docState,true);   
				
				foreach(SharpClient.UI.Controls.TabPage  t in stackTabControl.TabPages)
				{
					if(Convert.ToString(t.Tag).ToLower()==uniqueTitle.ToLower() )
					{						
						foreach(Control control in t.Controls)
						{
							if(control.GetType()==typeof(PGRptControl.StackControl))
							{
								((PGRptControl.StackControl)control).RefreshData(stackHeader,stackData,details,ColumnHeaderValue);
								break;
							}
						}
						stackTabControl.SelectedTab=t;
						t.Show();
						return;
					}
				}
			
				stackTabControl.ClosePressed-=new EventHandler(stackTabControl_ClosePressed); 
				//Remove the closing option
				stackTabControl.ShowArrows=false;
				stackTabControl.ShowClose=false; 
				SharpClient.UI.Controls.TabPage tPage=new SharpClient.UI.Controls.TabPage(uniqueTitle); 
				tPage.Tag=uniqueTitle;
				tPage.Dock=DockStyle.Fill;
				stackTabControl.TabPages.Add(tPage);
				PGRptControl.StackControl stackControl=new PGRptControl.StackControl(sortable); 
				stackControl.Wizard= wizard;
				stackControl.StackControl_ItemSelected+=new PGRptControl.StackControl_ItemSelectedHandler(stackControl_StackControl_ItemSelected); 
				stackControl.RefreshData(stackHeader,stackData,details,ColumnHeaderValue);					
				stackControl.Dock=DockStyle.Fill;
				tPage.Controls.Add(stackControl); 							
				stackTabControl.SelectedTab=tPage;
				tPage.Show();
			}
			catch(Exception ex)
			{
				MessageBox.Show(ex.Message,"Error",MessageBoxButtons.OK ,MessageBoxIcon.Error);
			}
		}
示例#23
0
        public bool Connect(string IP, int Port, string Password, SharpClient Self, out ConnectResults result)
        {
            if (Password == null)
            {
                Password = "";
            }
            if (this.connected)
            {
                result = ConnectResults.AlreadyConnected;
                return(false);
            }
            try
            {
                server_client = new TcpClient();
                IPAddress address = null;
                #region IP Parse
                try
                {
                    address = IPAddress.Parse(IP);
                }
                catch
                {
                    result = ConnectResults.InvalidIpAddress;
                    return(false);
                }
                #endregion
                IPEndPoint remoteAddress = new IPEndPoint(address, Port);

                #region Physical Connetion
                try
                {
                    server_client.Connect(remoteAddress);
                }
                catch
                {
                    result = ConnectResults.UnhandledException;
                    return(false);
                }
                #endregion

                #region ID Self
                SharpSerializer hailMessage = SharpSerializer.Create();

                hailMessage.Write((byte)IncomingConnectionRequests.ConnectionApprove);
                Self.Write(ref hailMessage);
                hailMessage.Write(Password);

                TCPMessageHandler.Write(server_client, hailMessage.DataAndPost());
                #endregion

                #region Wait For Response
                byte[]          responseRaw = TCPMessageHandler.Read(server_client);
                SharpSerializer response    = SharpSerializer.Create(responseRaw);
                #endregion

                IncomingConnectionResponse message = (IncomingConnectionResponse)response.ReadByte();
                if (message == IncomingConnectionResponse.WrongPassword)
                {
                    TCPMessageHandler.CloseConnection(server_client);
                    result = ConnectResults.InvalidPassword;
                    return(false);
                }
                if (message == IncomingConnectionResponse.ServerIsFull)
                {
                    TCPMessageHandler.CloseConnection(server_client);
                    result = ConnectResults.ServerIsFull;
                    return(false);
                }
                if (message == IncomingConnectionResponse.NameIsExist)
                {
                    TCPMessageHandler.CloseConnection(server_client);
                    result = ConnectResults.NameIsExist;
                    return(false);
                }


                short myID = response.ReadInt16();
                Self.AssingNetID(myID);

                this.room = new SharpRoom(ref response);

                this.listenerThread = new Thread(ListenServer);
                this.listenerThread.Start();

                connected = true;

                me = Self;
                room.AssignClient(me);

                room.Server.Connection      = server_client;
                room.Server.ListeningThread = listenerThread;

                C_OnConnected(room);

                result = ConnectResults.Succes;
                return(true);
            }
            catch (Exception e)
            {
                try
                {
                    TCPMessageHandler.CloseConnection(server_client);
                }
                catch { }
                server_client = null;

                connected = false;

                try
                {
                    listenerThread.Abort();
                }
                catch { }
                listenerThread = null;

                me = null;

                room = null;

                result = ConnectResults.UnhandledException;
                return(false);
            }
        }
示例#24
0
		private SharpClient.UI.Controls.TabControl AddPanelContents(string ContentTitle,int imageListIndex,SharpClient.UI.Docking.State _dockstate,bool bShow)
		{
			SharpClient.UI.Controls.TabControl stackTabControl=null;
			Content cStack=null;
			if(_stackManager==null)
			{
				_stackManager=new DockingManager(this,SharpClient.UI.Common.VisualStyle.IDE);
				_stackManager.InnerControl=sharpClientMDITab;
				_stackManager.OuterControl= psStatusBar;	
			}

			if(_stackManager.Contents[ContentTitle]==null)
			{
				stackTabControl=new SharpClient.UI.Controls.TabControl();				
				stackTabControl.Appearance = SharpClient.UI.Controls.TabControl.VisualAppearance.MultiDocument;
				stackTabControl.BackColor = System.Drawing.SystemColors.ActiveCaptionText;
				stackTabControl.ButtonActiveColor = System.Drawing.SystemColors.ActiveCaptionText;
				stackTabControl.ButtonInactiveColor = System.Drawing.SystemColors.InactiveCaptionText;
				stackTabControl.Dock = System.Windows.Forms.DockStyle.Fill;
				stackTabControl.Font = new System.Drawing.Font("Arial", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((System.Byte)(0)));
				stackTabControl.HideTabsMode = SharpClient.UI.Controls.TabControl.HideTabsModes.ShowAlways;
				stackTabControl.HotTextColor = System.Drawing.SystemColors.Desktop;
				stackTabControl.IDEPixelBorder = false;
				stackTabControl.Location = new System.Drawing.Point(0, 31);				
				stackTabControl.Size = new System.Drawing.Size(790, 484);			
				stackTabControl.ClosePressed+=new EventHandler(stackTabControl_ClosePressed); 
				cStack=_stackManager.Contents.Add(stackTabControl,ContentTitle,imageList1,imageListIndex );								
				_stackManager.AddContentWithState(cStack,_dockstate);
								
			}
			else
			{
				cStack=_stackManager.Contents[ContentTitle];
				stackTabControl=cStack.Control as SharpClient.UI.Controls.TabControl;
			}

			ShowStackControl(bShow,cStack);	
			return stackTabControl;
		}
示例#25
0
 protected override void calculateInsets(SharpClient.UI.Charting.Insets insets, System.Drawing.Graphics g)
 {
     base.calculateInsets(insets, g);
     generateAxisLabel();
     setMaxXLabelHeight(g);
     setMaxYLabelWidth(g);
     insets.Left += (m_maxYLabelWidth + m_maxXLabelHeight);
     //insets.Top += m_maxXLabelHeight;
     insets.Bottom += 3 * m_maxXLabelHeight;
     insets.Right += 2 * m_maxYLabelWidth;
 }