Discussion :

[olibara]

Bonjour


Encore un petit truc pour lequel j'ai pas l'expérience en cSharp

Je dois apeller une fonction qui me va me rendre un tableau de structure et le nombre d'elements de ce tableau

Comment dois je declarer ce tableau dont je ne connais pas encore la longueur pour le passer a ma fonction

Exemple pratique de la fonction d'allocation

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
   public struct PntF
    {
      public double X;
      public double Y;
    };
 
    // *****************************************************
    unsafe static public int RoadPntById()
    {
      char ch = (char)1;
      IntPtr hBcta = (IntPtr)0;
      UInt32 attrId = 1039;
      int count;
      PntF* P; 
      Routing.bctaOpen(ref hBcta, Environ.RoutingDataPath, ch);
      attrId = 8967209;
// j'appelle une DLL qui alloue son propre buffer P et me rends un pointeur
      count = bctaGetElemNodes(hBcta, attrId, out P);
// je m'empresse de recopier le resultat de la DLL dans mon environnement cSharp
      PntF[] nP = new PntF[count];
      for (int i = 0; i < count; i++)
      {
        nP[i] = P[i];
      }
// Je ferme la DLL qui désaloue ses buffer
      Routing.bctaClose(hBcta);
      return 0;
    }

La question est : Comment appeller RoadPntById() en lui passant un array de type PntF dont je ne connais pas la longueur ?
Merci pour votre aide .

[TheCaribouX]

Salut! J'avoue ne pas avoir tout tout compris, mais pour ce qui est de manipuler des tableaux de taille variables d'objets, perso j'utilise les List<T> ou T est le type.
myList.Count te permet d'avoir sa taille.

[olibara]

Salut

Oui je comprends
Tu declare une liste et puis tu fait des add dans cette liste là ou tu veux

C'est effectivement une bonne solution, mais je me demande si c'est pas beaucoup plus lourd que d'avoir un simple array, d'autant que le nombre d'éléments sera tres faible (entre 2 et +/- 20 max)

Pour aider ta compréhension voici ce que je fais

qq part dans le program C# j'ai un Id (id de polyline) et je dois connaitre un nombre d'élements lié a cet ID (les points du polyline)

Pour cela j'appelle une DLL qui prends l'ID, alloue un buffer et me rends un count et un pointeur sur le buffer contenant les points alloués

j'ai encapsulé une fonction qui appelle la dll, recopie son buffer et referme le buffer;

Donc en fait j'aurais voulu
1- declarer un array de point dont je ne connais pas encore la longueur
2- Appeller ma fonction qui appelle la ddl en lui passant cet array vide
3- Recupere le count et l'array remplis.


C'est vrai, avec une liste ca marche mais n'este ce pa beaucoup plus lourd qu'un simple array ??

[Guulh]

Je n'ai pas la réponse à ta question, mais il y a sous forum spécialisé dans ces problématiques d'interop et d'appels de dll natives, dans DotNet \ Framework \Interop il me semble. Tu as toutes les chances d'avoir plus de réponses pertinentes là-bas.

[StormimOn]

Salut! J'avoue ne pas avoir tout tout compris, mais poru ce qui est de manipuler des tableaux de taille variables d'objets, perso j'utilise les List<T> ou T est le type. myList.Count te permet d'avoir sa taille.

Comme sa méthode native lui renvoie une longueur, utiliser un tableau est tout aussi simple. Le dynamisme d'une liste n'est pas vraiment nécessaire à priori, cela dépend de l'utilisation faite du tableau.

Comment appeller RoadPntById() en lui passant un array de type PntF dont je ne connais pas la longueur ?
Merci pour votre aide .

N'ayant jamais eu à utiliser l'unsafe, je vais écrire le reste en supposant que cela ne change rien à du code "safe", ce qui doit être le cas je pense ^^

Pour faire ce que tu veux, retourne ton tableau directement depuis la méthode. Au lieu de faire un

Code :

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

return 0;

qui ne sert absolument à rien, fais plutôt

Code :

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

return nP;

et change la signature de ta méthode en

Code :

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

unsafe static public PntF[] RoadPntById()

[olibara]

Salut

Merci,

Tu a tout a fais raison mais comment je declare a l'appel ?

PntF[] PntArray=RoadPntById();

??

Ce qui me trouble encore en cSharp qui n'utilise pas d'allocation et de free explicites, c'est que je vais allouer ce tableau dans ma fonction

Code :

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

PntF[] nP = new PntF[count];

et puis l'assigner au return
Donc ce tableau ne sera plus local a la fonction !
Mais comment le GC va le deviner ?

[StormimOn]

Tu a tout a fais raison mais comment je déclare l'appel ?

PntF[] PntArray=RoadPntById();

??

Bein oui tout simplement. C'est la même chose que

Code :

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

int i = monObjet.GetMaxLength();

si GetMaxLength() renvoie un entier. Tu t'attendais à quoi d'autre ?
Toujours dans l'optique ou le unsafe ne change rien à ce que je connais évidemment

Ce qui me trouble encore en C# qui n'utilise pas d'allocation et de free explicites, c'est que je vais allouer ce tableau dans ma fonction et puis l'assigner au return. Donc ce tableau ne sera plus local a la fonction ! Mais comment le GC va le deviner ?

Tu peux toujours faire une recherche sur google pour chercher divers articles sur le fonctionnement du GC, mais le GC se moque de savoir si ta variable est locale à une méthode ou non. En très gros, il cherche les objets qui ne sont plus référencés (plus utilisés donc), ce qui n'a aucun rapport avec le fait que ce soit local ou non

[olibara]

5/5

Et pour le Unsafe en fait ca change rien du tout en fait aussi loin que j'ai pu voir, c'est juste une maniere de dire au compilateur de ne pas s'inquiter de ce que tu fait quand tu chipote avec des pointeurs entre autre.

En clair : je sais ce que je fais, laisse moi tranquille ..

Mais ca ne change en rien sa gestion
Par contre Fixed que je n'ai pas encore utilisé est un peu plus particulier car cela fixe reellement l'adresse d'une variable.

[StormimOn]

Si le problème est réglé, n'oublie pas le bouton