Bonjour
Donc voici mon problème je travaille actuellement sur un programme C# utilisant une dll C++. La dll aurait besoin d'un double[][][][][][] afin de fonctionner mais je ne sais pas comment lui faire passer, j'ai essayer avec un marshaller personnalisé mais je n'ai pas réussi a le faire fonctionner: cf le code ci dessous ou d'aplatir le tableau en un double[] mais cette solution est trop lourde pour le programme. Avez vous des solutions?
Merci d'avance
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
public class JaggedArrayMarshaler : ICustomMarshaler
    {
        static ICustomMarshaler GetInstance(string cookie)
        {
            return new JaggedArrayMarshaler();
        }
        GCHandle[] handles;
        GCHandle[] handles2;
        GCHandle[] handles3;
        GCHandle[] handles4;
        GCHandle[] handles5;
        GCHandle buffer;
        Array[] array;
        Array[] array2;
        Array[] array3;
        Array[] array4;
        Array[] array5;
        public void CleanUpManagedData(object ManagedObj)
        {
        }
        public void CleanUpNativeData(IntPtr pNativeData)
        {
            buffer.Free();
            foreach (GCHandle handle in handles)
            {
                handle.Free();
            }
            foreach (GCHandle handle in handles2)
            {
                handle.Free();
            }
            foreach (GCHandle handle in handles3)
            {
                handle.Free();
            }
            foreach (GCHandle handle in handles4)
            {
                handle.Free();
            }
            foreach (GCHandle handle in handles5)
            {
                handle.Free();
            }
        }
        public int GetNativeDataSize()
        {
            return IntPtr.Size;
        }
 
        public IntPtr MarshalManagedToNative(object ManagedObj)
        {
            array = (Array[])ManagedObj;
 
            handles = new GCHandle[array.Length];
            for (int i = 0; i < array.Length; i++)
            {
                array2 = (Array[])array[i];
                handles2 = new GCHandle[array2.Length];
                for (int j = 0; j < array2.Length; j++)
                {
                    array3 = (Array[])array2[j];
                    handles3 = new GCHandle[array3.Length];
                    for (int k = 0; k < array3.Length; k++)
                    {
                        array4 = (Array[])array3[k];
                        handles4 = new GCHandle[array4.Length];
                        for (int l = 0; l < array4.Length; l++)
                        {
                            array5 = (Array[])array4[l];
                            handles5 = new GCHandle[array5.Length];
                            for (int m = 0; m < array5.Length; m++)
                            {
                                handles5[m] = GCHandle.Alloc(array5[m], GCHandleType.Pinned);
 
                            }
                            IntPtr[] pointers5 = new IntPtr[handles5.Length];
                            for (int m = 0; m < handles5.Length; m++)
                            {
                                pointers5[m] = handles5[m].AddrOfPinnedObject();
                            }
                            handles4[l] = GCHandle.Alloc(pointers5, GCHandleType.Pinned);
                        }
                        IntPtr[] pointers4 = new IntPtr[handles4.Length];
                        for (int l = 0; l < handles4.Length; l++)
                        {
                            pointers4[l] = handles4[l].AddrOfPinnedObject();
                        }
                        handles3[k] = GCHandle.Alloc(pointers4, GCHandleType.Pinned);
                    }
                    IntPtr[] pointers3 = new IntPtr[handles3.Length];
                    for (int k = 0; k < handles3.Length; k++)
                    {
                        pointers3[k] = handles3[k].AddrOfPinnedObject();
                    }
                    handles2[j] = GCHandle.Alloc(pointers3, GCHandleType.Pinned);
                }
                IntPtr[] pointers2 = new IntPtr[handles2.Length];
                for (int j = 0; j < handles2.Length; j++)
                {
                    pointers2[j] = handles2[j].AddrOfPinnedObject();
                }
                handles[i] = GCHandle.Alloc(pointers2, GCHandleType.Pinned);
            }
            IntPtr[] pointers = new IntPtr[handles.Length];
            for (int i = 0; i < handles.Length; i++)
            {
                pointers[i] = handles[i].AddrOfPinnedObject();
            }
            buffer = GCHandle.Alloc(pointers, GCHandleType.Pinned);
            return buffer.AddrOfPinnedObject();
        }
        public object MarshalNativeToManaged(IntPtr pNativeData)
        {
            return array;
        }
    }