Discussion :

[glouffy6]

Bonjour,

Je fais une application qui doit communiquer avec une autre application via le réseau. L'autre application est écrite en C. Dans la définition de la fonction gérant la communication il est indiqué que je dois lui envoyer une structure composé de plusieurs types (char, char, short int,char[]).
Cependant je n'arrive pas depuis mon application a envoyer un structure ... comment puis-je faire ?

[alavoler]

C'est quoi le protocol de communication ?

[metos57]

Bonjour,

Code :

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

1
2
3
4
5
6
7
8
9
 
[StructLayout(LayoutKind.Sequential)]
public class toto
{ 
     public byte bidule; 
 
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst=LF_10)]
    public string nom; 
}

Cela te permet d'envoyer les données en fournissant le format des données et leur positionnement (LayoutKind.Sequential indique que l'odre des atributs est fixé par l'ordre séquantiel, d'abord bidule et après nom).
De plus tu peux 'fixer' certain champ comme les string avec l'attribut MarshalAs

Cela fonctionne pour les socket par exemple.

[smyley]

Dès que tu arrives à envoyer un byte[] tu as gagné.
J'ai écrit une petite classe (il y a 2 ans ) qui pourrai te servir : elle permet de convertir un struct en byte[] et réciproquement. Il te suffira donc de bien définir ta struct pour qu'elle corresponde au format attendu par ton programme :

Code c# :

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
 
public static class StructGetter
    {
        public static void WriteBlock(Stream Output, object structure)
        {
            byte[] buf = new byte[SizeOf(structure)];
            WriteBlock(Output, structure, buf);
        }
 
        public static void WriteBlock(Stream Output, object structure, byte[] buf)
        {
            GetBytes(structure, buf, 0, buf.Length);
            Output.Write(buf, 0, SizeOf(structure));
        }
 
        public static object ReadBlock(Stream Input, Type structure_type)
        {
            byte[] buf = new byte[Marshal.SizeOf(structure_type)];
            return ReadBlock(Input, structure_type, buf);
        }
 
        public static object ReadBlock(Stream Input, Type structure_type, byte[] buf)
        {
            if (Input.Read(buf, 0, Marshal.SizeOf(structure_type)) < Marshal.SizeOf(structure_type))
                throw new DreamShield.Data.InvalidDataException("Stream too short");
 
            return GetStruct(buf, 0, Marshal.SizeOf(structure_type), structure_type);
        }
 
        public static int SizeOf(object structure)
        {
            return Marshal.SizeOf(structure);
        }
 
        public static void GetBytes(object val,
                                      [In, Out] byte[] buffer,
                                     int offset,
                                    int bufsize)
        {
            if (val == null)
                throw new ArgumentNullException("val");
 
            int size = SizeOf(val);
            IntPtr p = Marshal.AllocHGlobal(size);
 
            try
            {
                Marshal.StructureToPtr(val, p, true);
                Marshal.Copy(p, buffer, offset, bufsize);
            }
            finally
            {
                Marshal.FreeHGlobal(p);
            }
        }
 
        public static object GetStruct(byte[] buffer,
                                       int offset,
                                       int count,
                                       Type struct_type)
        {
            IntPtr p = Marshal.AllocHGlobal(count);
            object result = null;
 
            try
            {
                Marshal.Copy(buffer, offset, p, count);
                result = Marshal.PtrToStructure(p, struct_type);
            }
            finally
            {
                Marshal.FreeHGlobal(p);
            }
 
            return result;
        }
    }

[glouffy6]

Ok merci beaucoup, j'ai finalement réussis à la faire marché en bidouillant avec les tableaux de byte, merci beaucoup les gars

[SaumonAgile]

N'oublie pas de cliquer sur

[glouffy6]

Finalement, je suis obligé d'utiliser ta classe smyley, et j'ai un petit pb!

je déclare ma struct comme ca :

Code :

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

1
2
3
4
5
6
7
8
 
        public struct ordreEnvoiStruct
        {
            public char typeDonnee;
            public char car;
            public short longueur;
            public Char[] donnee;
        }

Après quand j'utilise la méthode StructGetter.WriteBlock(stream,ordreEnvoiStruct)

j'ai une exception levée dans la méthode GetBytes. L'erreur est par rapport au tableau de char le message est "le type de donnée ne correspond pas"

Une idée ?

[smyley]

Tu ne peut pas utiliser ma méthode pour transmettre une struct de taille variable (ce qu'est le char[], vu que tu ne lui a pas donné de taille). Si tu tiens absolument à envoyer un char soit il faudra te coder ta propre méthode pour convertir le char[] en byte[] (ça peut se faire via les classes de System.Text.Encoding via les méthodes GetBytes et GetString des différents encodages disponibles), soit tu utilise la serialization binaire (BinarySerializer) ou xml (XmlSerializer).