Discussion :

[michastro]

Bonjour,
J'ai une librairie en C# avec dedans cette méthode:

Code :

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

       public void writeSimulator(byte[] data, byte nombre)

Donc SendBuff est un tableau d'octets.
Dans Delphi, j'importe la librairie et j'ai ceci dans l'importation:

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
// *********************************************************************//
// Déclaration de classe proxy de serveur OLE
// Objet serveur        : TSimulator
// Chaîne d'aide : 
// Interface par défaut : _Simulator
// DISP Int. Déf. ?     : No
// Interface événements : 
// TypeFlags            : (2) CanCreate
// *********************************************************************//
  TSimulator = class(TOleServer)
  public
    constructor Create(AOwner: TComponent); override;
    destructor  Destroy; override;
    procedure Connect; override;
    procedure ConnectTo(svrIntf: _Simulator);
    procedure Disconnect; override;
    function Equals(obj: OleVariant): WordBool;
    function GetHashCode: Integer;
    function GetType: _Type;
    procedure writeSimulator(data: PSafeArray; nombre: Byte);
    procedure readSimulator(var data: PSafeArray; nombre: Byte);

Ensuite dans mon code j'appelle writeSimulator comme ceci:

Code :

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

                    MCMT2021.VoieAD.writeSimulator(PSafeArray(SendBuff), NumbyteWrite);

SendBuf étant un tableau d'octets.
Je me fait jeter par le transtypage, et si je ne le mets pas aussi!!
Merci de votre aide.
Michel

[ShaiLeTroll]

Ou as tu vu que l'on pouvait caster un array of byte en PSafeArray, as tu regardé ce qu'est un SAFEARRAY ?

Code c++ :

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

1
2
3
4
5
6
7
8
typedef struct tagSAFEARRAY {
  USHORT         cDims;
  USHORT         fFeatures;
  ULONG          cbElements;
  ULONG          cLocks;
  PVOID          pvData;
  SAFEARRAYBOUND rgsabound[1];
} SAFEARRAY;

Pour moi un SafeArray cela se crée avec les fonctions COM comme SafeArrayCreate + SafeArrayPutElement ou SafeArrayAccessData/finally/SafeArrayUnAccessData (cela te fourni un pointer sur lequel tu peux faire un Move de ton tableau)

Sinon via VarArrayCreate et VarArrayAsPSafeArray

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
 
var
  LSafeArray: PSafeArray;
  VarBound: TVarArrayBound;
  DataPtr: Pointer;
begin
  FillChar(VarBound, SizeOf(VarBound), 0);
  VarBound.ElementCount := NumbyteWrite;
 
  LSafeArray:= SafeArrayCreate(varByte, 1, @VarBound); 
  try
    SafeArrayCheck(SafeArrayAccessData(LSafeArray, DataPtr));
    try
      Move(SendBuf[0], DataPtr^, NumbyteWrite);
    finally
      SafeArrayCheck(SafeArrayUnAccessData(LSafeArray));
    end;
 
    MCMT2021.VoieAD.writeSimulator(LSafeArray, NumbyteWrite);
 
  finally
    SafeArrayDestroy(LSafeArray);
  end;

[michastro]

Bonjour,
Je récupère d'une DLL écrite en C# via COM un tableau d'octets sous forme d'une SafeArray. Je peux récupérer l'adresse du tableau avec le pointeur MaSafeArray.pvData. Maintenant comment assigner ce pointeur à un tableau du style

Code :

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

tableau:=PbyteArray(MaSafeArray.pvData)

(mais ça ne marche pas). Ca doit être simple, mais je bute dessus.
Merci
Michel

[ShaiLeTroll]

[EDIT = discussions fusionnées] Doublon du sujet Transtypage de SafeArray[/EDIT]

Pour lire suffit d'inverser la Dest/Source du Move

[michastro]

Bonsoir,
En suivant les conseils, j'ai écrit ça et cela marche. Sachant que writesimulator transmet un PSafeArray, et read simulator en reçoit un.

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
 
    mySafeArrayBounds[0].cElements := 9;
    mySafeArrayBounds[0].lLbound := 0;
    mySafeArray:=SafeArrayCreate(VarByte,1,@mySafeArrayBounds);
    mySafeArray.pvData:=@SendBuff[0];
    if (SendBuff[0] = $E0) then
    begin
        MCMT2021.VoieAD.writeSimulator(mySafeArray,NumbyteWrite);
        mySafeArrayRetour:=SafeArrayCreate(VarByte,1,@mySafeArrayBounds);
        MCMT2021.VoieAD.readSimulator(mySafeArrayRetour,NumbyteRead);
        if SafeArrayAccessData(mySafeArrayRetour,pointer(PByte)) = S_OK then
        begin
           for I := 0 to NumbyteRead - 1 do
              RecBuff[I] := PByte[I];
        end;
     end;

Une seule chose, je n'ai pas réussi à réutiliser mySafeArray pour le retour de la fonction readSimulator, j'ai été obligé de creer un nouveau PSafeArray (mySafeArrayRetour).
Merci pour l'aide

[ShaiLeTroll]

Fraudra penser au Destroy et UnAccess sinon fuite mémoire assurée

Voici une version plus safe mais à mon avis, il faudrait plutôt faire une classe Wrapper qui vient encapsuler TSimulator pour fournir des fonctions avec des paramètres TBytes, cela serait plus élégant.

Code :

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

1
2
3
4
5
6
type
  TSimulatorHelper = class helper for TSimulator
  public
    function WriteToSimulator(const Data: TBytes): Integer;
    function ReadFromSimulator(var Data: TBytes): Integer;
  end;

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
 
function TSimulatorHelper.WriteToSimulator(const Data: TBytes): Integer;
var
  LSafeArray: PSafeArray;
  VarBound: TVarArrayBound;
  DataPtr: Pointer;
begin
  Result := Length(Data);
  if (Result > 0) and (Data[0] = $E0) then
  begin
    FillChar(VarBound, SizeOf(VarBound), 0);
    VarBound.ElementCount := Result;
 
    LSafeArray:= SafeArrayCreate(varByte, 1, @VarBound); 
    try
      SafeArrayCheck(SafeArrayAccessData(LSafeArray, DataPtr));
      try
        Move(Data[0], DataPtr^, Result);
      finally
        SafeArrayCheck(SafeArrayUnAccessData(LSafeArray));
      end;
 
      Self.writeSimulator(LSafeArray, Result);
 
    finally
      SafeArrayDestroy(LSafeArray);
    end;
  end
  else
    Result := -1;
end;

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
 
function TSimulatorHelper.ReadFromSimulator(var Data: TBytes): Integer;
var
  LSafeArray: PSafeArray;
  VarBound: TVarArrayBound;
  DataPtr: Pointer;
begin  
  Result := Length(Data);
  if (Result > 0) then
  begin
    FillChar(VarBound, SizeOf(VarBound), 0);
    VarBound.ElementCount := Result;
 
    LSafeArray:= SafeArrayCreate(varByte, 1, @VarBound); 
    try
      Self.readSimulator(LSafeArray, Result); 
 
      SafeArrayCheck(SafeArrayAccessData(LSafeArray, DataPtr));
      try
        Move(DataPtr^, Data[0], Result);
      finally
        SafeArrayCheck(SafeArrayUnAccessData(LSafeArray));
      end;
    finally
      SafeArrayDestroy(LSafeArray);
    end;
  end
  else
    Result := -1;
end;

Ainsi le code d'utilisation est beaucoup plus élégant grâce à l'assistant

Code :

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

1
2
3
4
5
if MCMT2021.VoieAD.WriteToSimulator(SendBuff) > 0 then
begin
  // RecBuff taille fixe ou SetLength ?
  MCMT2021.VoieAD.ReadFromSimulator(RecBuff);
end;

Attention à utiliser NumbyteWrite systématiquement, d'où vient de 9 en dur pour le nombre d'élément ?




Je note que sur Stackoverflow, la réponse est la même, Move compris
et Remy Lebeau a bien insisté à ne pas utiliser pvData sur un tableau non verrouillé, ce que vous n'avez pas pris en compte comme remarque.

[michastro]

Bonjour,
Joli code!! MERCI. Sinon le 9 en dur est toujours valable pour le writeSimulator, mais par contre c'est un bug pour le readSimulator, car là la taille varie. J'avais bien mis plus bas le Unaccess, par contre j'avais oublié le destroy.
Encore Merci.
Michel