Discussion :

[middle6]

Bonjour, cela fais un moment que j'essaie de savoir comment monter un serveur tcp sur mon "Windows Server 2008" . Depuis la sortie du support socket tcp/udp sur Windows phone on trouve beaucoup de "sample",exemple ou autre mais seulement du côté client (depuis le smartphone lui même) .
Et moi j'aimerais savoir quelle est la façon de monter le cotée serveur...Afin de pouvoir lié une connexion entre mon wp et le serv.
J'ai beau cherché sur Google "how make tcp Server","comment monter Server tcp c# " etc... Sans résultat ou avec des classes a dl mais aucune vrai explication officiel ..(sauf sur linux server) dommage.
Et surtout que faut il créer comme nouveau projet sur Visual studio ?

Encore mille merci d'avance pour vos réponses..
Je ne suis qu'un étudiant ignare en la matière :'(

Mehdi bugnard
(middle)

[middle6]

voici un exemple finallement trouve sur le web. Est-ce correct?
Si oui je ne comprend pas quand sommes nous censé appelé cette méthode pour récupérer les données reçu en tcp..car effectivement cela n'est pas un event donc cela ne devrait pas se lancer tout seul.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
 
using System.Net;
using System.Net.Sockets;
 
private void ReceiveTcpData()
{
            TcpListener server = null;
            try
            {
                // Set the TcpListener on port 5000.
                Int32 port = 5000;
                IPAddress localAddr = IPAddress.Parse("127.0.0.1");
 
                // TcpListener server = new TcpListener(port);
                server = new TcpListener(localAddr, port);
 
                // Start listening for client requests.
                server.Start();
 
                // Buffer for reading data
                Byte[] bytes = new Byte[256];
                String data = null;
 
                // Enter the listening loop.
                while (true)
                {
                    // Perform a blocking call to accept requests.
                    // You could also user server.AcceptSocket() here.
                    TcpClient client = server.AcceptTcpClient();
 
                    data = null;
 
                    // Get a stream object for reading and writing
                    NetworkStream stream = client.GetStream();
 
                    int i;
 
                    // Loop to receive all the data sent by the client.
                    while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
                    {
                        // Translate data bytes to a ASCII string.
                        data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
 
                        // Process the data sent by the client.
                        data = data.ToUpper();
 
                        byte[] msg = System.Text.Encoding.ASCII.GetBytes(data);
 
                        // Send back a response.
                        stream.Write(msg, 0, msg.Length);
                    }
 
                    // Shutdown and end connection
                    client.Close();
                }
            }
            catch (SocketException e)
            {
                MessageBox.Show(string.Format("SocketException: {0}", e));
            }
            finally
            {
                // Stop listening for new clients.
                server.Stop();
            }
}

[Bluedeep]

Bonjour

Mais pourquoi veux tu créer ta propre réception Tcp au lieu d'utiliser WCF ?

[middle6]

Car il me faudrait créer une connexion d'écoute envoie de données et réception en permanence pour un style de jeux "connecté" en multi .
Vu le nombre de requête a exécuté je pensais que c'était surement le meilleur moyen ?! Ou pas...

[middle6]

Heyy re les geek's !
J'ai finalement résolu mon problème tout seul en galérant quelques jours..
A noter que si vous faîtes tourner votre serveur "UDP" ou autres sur un windows Server 2008 R2 vérifié bien qu'il laisse passer les paquets udp (ICMP..) à ouvrir dans le par-feu.
Comme je suis gentil , je suis revenu poster pour les prochains galériens:

CODE CLIENT UDP

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
public partial class MainPage : PhoneApplicationPage
    {
        infoPlayer player = new infoPlayer();
        string msg = "";
 
        // Constructor
        public MainPage()
        {
 
            InitializeComponent();
        }
        private void connection_request_server(string user_name, string machine_type, string commande)
        {
            try
            {
                // Clear the log 
                ClearLog();
                string data = String.Format("{0}-{1}-{2}", user_name, machine_type,commande);
                // Make sure we can perform this action with valid data
                if (ValidateRemoteHost())
                {
                    // Instantiate the SocketClient object
                    SocketClient client = new SocketClient();
 
                    // Ecris dans la console l'etat/etape de connexion en cours sur le serveur avec l'identifiant du "player"
                   // Log(String.Format("Connexion en cours ['{0}'] ...", player.Device_name.ToLower()), true);
 
                    string result = client.Send(txtRemoteHost.Text, 8888, data);
 
 
                    // Receive response from the QOTD server
                    // Log("Requesting Receive ...", true);
                    result = client.Receive(8888);
                    Log(result, false);
 
                    // Close the socket connection explicitly
                    client.Close();
                }
            }
            catch (SocketException sock_exc)
            {
                MessageBox.Show(sock_exc.Message);
 
            }
        }
        /// <summary>
        /// Handle the btnEcho_Click event by receiving text from the Quote of the Day (QOTD) server and outputting the response
        /// </summary>
        private void btnGetQuote_Click(object sender, RoutedEventArgs e)
        {
            connection_request_server(player.Device_name,player.Plateform_name, txtInput.Text);
        }
 
        #region UI Validation
        /// <summary>
        /// Validates the txtInput TextBox
        /// </summary>
        /// <returns>True if the txtInput TextBox contains valid data, False otherwise</returns>
        private bool ValidateInput()
        {
            // txtInput must contain some text
            if (String.IsNullOrWhiteSpace(txtInput.Text))
            {
                MessageBox.Show("Please enter some text to echo");
                return false;
            }
 
            return true;
        }
 
        /// <summary>
        /// Validates the txtRemoteHost TextBox
        /// </summary>
        /// <returns>True if the txtRemoteHost contains valid data, False otherwise</returns>
        private bool ValidateRemoteHost()
        {
            // The txtRemoteHost must contain some text
            if (String.IsNullOrWhiteSpace(txtRemoteHost.Text))
            {
                MessageBox.Show("Please enter a host name");
                return false;
            }
 
            return true;
        }
        #endregion
 
 
 
 
        #region Logging
        /// <summary>
        /// Log text to the txtOutput TextBox
        /// </summary>
        /// <param name="message">The message to write to the txtOutput TextBox</param>
        /// <param name="isOutgoing">True if the message is an outgoing (client to server) message, False otherwise</param>
        /// <remarks>We differentiate between a message from the client and server 
        /// by prepending each line  with ">>" and "<<" respectively.</remarks>
        private void Log(string message, bool isOutgoing)
        {
 
                string direction = (isOutgoing) ? ">> " : "<< ";
                msg = Environment.NewLine + direction + message;
 
            txtOutput.Items.Add(msg);
            txtOutput.ScrollIntoView(txtOutput.Items[txtOutput.Items.Count-1]);
        }
 
        /// <summary>
        /// Clears the txtOutput TextBox
        /// </summary>
        private void ClearLog()
        {
            txtOutput.Items.Add(String.Empty);
        }
        #endregion
    }

CODE SERVER UDP (Avec quelques ajouts de ma parts pour gèrer quelque commande de base) voir class rajoutées

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
 
class Program
    {
        public List<Player> players = new List<Player>();
        public server Server = new server() ;
        public static int Main()
        {
            int recv;
            byte[] data = new byte[1024];
            IPEndPoint ipep = new IPEndPoint(IPAddress.Any, 8888);
            Program prog = new Program();
 
            Socket newsock = new Socket(AddressFamily.InterNetwork,
                            SocketType.Dgram, ProtocolType.Udp);
            //Message de bienvenue et titre du serveur
            Console.WriteLine("Arcadia Serveur 0.1\n");
            newsock.Bind(ipep);
            //Message indiquand l'attente de client ! 
            Console.WriteLine("Waiting for a client...");
 
            IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
            EndPoint Remote = (EndPoint)(sender);
 
            recv = newsock.ReceiveFrom(data, ref Remote);
            //******************
            // On split les données recu afin de partager les différente commandes executé !! Première case du tableau doit toujours etre egal au pseudo de l'user
            //******************
            List<string> data_parse0 = new List<string>();
            string[] tab0 = Encoding.ASCII.GetString(data, 0, recv).Split('-');
            foreach( string i in tab0)
            {
                data_parse0.Add(i);
 
            }
            string id0 = data_parse0[0];
            string machine_nom = data_parse0[1];
            data_parse0.RemoveAt(0);
            data_parse0.RemoveAt(0);
            Console.Write("[ " + id0 + " ] - " + Remote.ToString()+" : "+ prog.executeCommande(data_parse0,id0)+"\n");
            //Console.WriteLine("{0}\n", Remote.ToString());
 
            string welcome = "Welcome to my Serveur\n\n";
            data = Encoding.ASCII.GetBytes(welcome);
            newsock.SendTo(data, data.Length, SocketFlags.None, Remote);
            prog.Server.Ip_server = ipep.Address;
 
            //On rentre dans une boucle infinie qui gère les transaction udp entrant/sortant en repondant en sortie en permancence jusqua fermeture du serveur par commande ou Hard Off/Crash
            while (true)
            {
                data = new byte[1024];
                recv = newsock.ReceiveFrom(data, ref Remote);
 
                //******************
                // On split les données recu afin de partager les différente commandes executé !! Première case du tableau doit toujours etre egal au pseudo de l'user
                //******************
                List<string> data_parse = new List<string>();
                string[] tab = Encoding.ASCII.GetString(data, 0, recv).Split('-');
                foreach (string i in tab)
                {
                    data_parse.Add(i);
 
                }
                //Récupere le nom (ID) du player connecté !!
                string id = data_parse[0];
                string machine_type = data_parse[1];
                //Control si le player est un nouveau player connecté ou pas! Si oui on instancie un nouvel objet player et l'ajoute au tableau des joueurs
                bool newLogin = true;
                foreach(Player var in prog.players)
                {
                   if(var.Device_name.Equals(id))
                   {
                       newLogin = false;
                   }
 
                }
                //Si c'est un nouveau player qui se connecte on construit un nouvel objet "player"
                if (newLogin && data_parse[2].Equals("login"))
                {
                    IPEndPoint remoteIpEndPoint = Remote as IPEndPoint; 
                    prog.players.Add(new Player(id,id,data_parse[1],remoteIpEndPoint.Address));
                }
 
                data_parse.RemoveAt(0);
                data_parse.RemoveAt(0);
                string resultat = prog.executeCommande(data_parse,id);
                data = Encoding.ASCII.GetBytes(resultat);
                Console.WriteLine("[ " + id0 + " ] " + " [ " + machine_type + " ] - " + resultat);
                newsock.SendTo(data, data.Length, SocketFlags.None, Remote);
 
                //Control de commande spécial à appeler après l'envoie de message tel que "Stoper le serveur"
                if (resultat.Equals("stoping server"))
                {
 
                    newsock.Shutdown(SocketShutdown.Both);
                    newsock.Dispose();
                    newsock.Close(0);
 
                    return 0;
                }
            }
        }
 
        //LA fonction qui execute les traitements d'après le tableau de commande envoye
        public string executeCommande(List<string> commande,string user_name)
        {
            string res = "";
 
            switch (commande[0])
            {
                //Se logue au serveur
                case "login":
                    res = "succes login";
                    break;
                //Se deconnecte du serveur
                case "exit":
                case "bye":
                case "disconnect":
                    int index = 0;
                    if (controlUserLogin(user_name)) 
                    {
                        int i = 0;
                        foreach (Player var in players)
                        {
                            if (var.User_name.Equals(user_name))
                            {
                                index = i;
                                res = "succes deconnected ";
                            }
                            i++;
                        }
                        players.RemoveAt(index);
                    } else { res = "you are not loged"; }
                    break;
                //Stop le serveur
                case "stop":
                    if (controlUserLogin(user_name)){res = "stoping server";}else { res = "you are not loged"; }
                    break;
                //Ping le serveur
                case "ping":
                    if (controlUserLogin(user_name)) { res = "ping "+ Server.Ip_server; } else { res = "you are not loged"; }
                    break;
 
                //Renvoie la liste des joueurs connecté preésent dans le tableau de class "players"
                case "list":
                case "player":
                case "players":
                    if (controlUserLogin(user_name))
                    {
                        foreach (Player var in players)
                        {
                            res += var.User_name + " : " + var.Plateform_name + "\n";
                        }
                    }
                    else { res = "you are not loged"; }
 
                    break;
                default:
                    res = "command error";
                    break;
 
            }
            return res;
        }
 
        private bool controlUserLogin(string userName)
        {
            bool control = false;
            foreach (Player var in players)
            {
                if (var.User_name.Equals(userName))
                {
                    control = true;
                }
            }
            return control;
 
        }
 
    }

Class Player

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
 
namespace UdpServer
{
    class Player
    {
 
        //Initialise des variables info- recupere des infos sur le nom - manufacture etc...
        private string device_name;
        public string Device_name
        {
            get { return device_name; }
            set { device_name = value; }
        }
        //Plateform Os Environnement
        private string plateform_name;
        public string Plateform_name
        {
            get { return plateform_name; }
            set { plateform_name = value; }
        }
        //Nom utilisateur
        private string user_name;
        public string User_name
        {
          get { return user_name; }
          set { user_name = value; }
        }
        //Nom utilisateur
        private IPAddress user_IP;
        public IPAddress User_IP
        {
            get { return user_IP; }
            set { user_IP = value; }
        }
 
        //Constructeur
        public Player(string deviceName,string userName,string plateformName,IPAddress userIp)
        {
            this.device_name = deviceName;
            this.plateform_name = plateformName;
            this.user_name = userName;
            this.user_IP = userIp;
        }
    }
}

[Nathanael Marchand]

Attention! UDP != ICMP ce sont deux protocoles différents!
Pour ton jeux WP7, si ca t'intéresse, j'ai fait une conférence aux Microsoft TechDays sur des jeux multi-supports: un jour sur WP7 qui collabore en temps réel avec un joueur PC. La conférence sera bientot disponible (cf ma signature) sur le site des TechDays ainsi que le code source sur codeplex

[middle6]

Mhh ok intéressant dis donc !
Dommage j'étais bien au techdays 2012 à paris mais n'ai pas pu suivre cette événement (snif). J’étais cependant présent au développement de jeux xna sur windows ou il présentait à la fin la libraire "D.A.R.E" pour xna.

Merci beaucoup pour votre réponse cela m'intéresse grandement ^^.
En gros ai-je utilisé la bonne voie pour échange de donnée entre machine pour du multijoueur avec socket client-server UDP ?
Je l'espère lol sinon go recommencez à zéro

PS:je ne trouve pas le lien de cette source sur codeplex .Possible de me 'linker' u lien ?

[Nathanael Marchand]

http://sogames.codeplex.com/ mais pour le moment il n'y a pas encore les sources (peut être ce weekend).

[middle6]

Ok merci pour le lien ! J'etais en train de parcourir votre blog . Sympa.

En fait vous ne m'avez pas encore repondu si j'etais sur la bonne voie.

En gros ai-je utilisé la bonne voie pour échange de donnée entre machine pour du multijoueur avec socket client-server UDP ?

[Nathanael Marchand]

Ok merci pour le lien ! J'etais en train de parcourir votre blog . Sympa.

Merci! Faudrait que je le mette à jour plus souvent et notamment avec l'actu des Tech'Days

En fait vous ne m'avez pas encore repondu si j'etais sur la bonne voie.

Pour les jeux multijoueurs, le UDP est effectivement la solution à privilégier. Après pour l'envoi des données, il y a des solutions plus optimales que faire un String.Format (utiliser une sérialisation binaire notammment).

[middle6]

Ok merci beaucoup .Je vai suivre sa de près