Est-il prudent de transmettre des paramètres de chaîne const Delphi à travers les limites du gestionnaire de mémoire?

Question

Subj. Je voudrais utiliser des chaînes au lieu de PChar parce que me épargne coulée beaucoup, mais si je fais juste

procedure SomeExternalProc(s: string); external SOMEDLL_DLL; 

puis le mettre en œuvre dans un autre projet avec le gestionnaire de mémoire non partagée:

library SeparateDll; 
procedure SomeExternalProc(s: string); 
begin 
    //a bla bla bla 
    //code here code here 
end; 

Je n'ai (formellement) aucune garantie Delphi ne décide pas, pour quelque raison que ce soit, de modifier la chaîne, de modifier son compteur de référence, de la dupliquer ou de la rendre unique, ou quoi que ce soit d'autre. Par exemple

var InternalString: string; 

procedure SomeExternalProc(s: string); 
begin 
    InternalString := s; 
end; 

Delphi incrémente refcounter et copie un pointeur, c'est tout. J'aimerais que Delphi copie les données. Est-ce que déclarer le paramètre "const" le rend sûr pour cette raison? Si non, y a-t-il un moyen de le faire? paramètre Déclarant que PChar ne semble pas être une solution parce que vous devez jeter chaque fois:

procedure SomeExternalProc(s: Pchar); forward; 
procedure LocalProc; 
var local_s: string; 
begin 
    SomeExternalProc(local_s); //<<--- incompatible types: 'string' and 'PAnsiChar' 
end; 

Answer 1

Ce serait probablement travailler, aussi longtemps que vous utilisez ne jamais votre DLL à partir du code compilé dans la même version Delphes. Le format interne de chaîne est connu pour changer entre les versions, et vous n'avez aucune garantie formelle qu'il ne changera pas à nouveau.

Si vous voulez éviter d'avoir à jeter partout où vous l'utilisez, essayez d'emballage la fonction, comme ceci:

procedure SomeExternalProc(s: Pchar); external dllname; 
procedure MyExternalProc(s: string); inline; 
begin 
    SomeExternalProc(PChar(local_s)); 
end; 

Ensuite, dans votre code, vous appelez MyExternalProc au lieu de SomeExternalProc, et tout le monde est heureux.

Answer 2

Si l'application et la DLL sont écrites dans la même version de Delphi, il suffit d'utiliser le gestionnaire de mémoire partagée (plus de détails here).

Si un côté est écrit dans une langue différente, il n'y a pas d'autre moyen que d'utiliser PChar ou WideString (WideString est géré par le gestionnaire de mémoire COM).

Ou vous pouvez écrire une fonction wrapper:

procedure MyExternalProc(const s: string); 
begin 
    SomeExternalProc(PChar(s)); 
end; 

Answer 3

Je recommande d'utiliser un gestionnaire de mémoire de remplacement comme RecyclerMM ou FastMM. Ils ne nécessitent pas de dll MM externe et vous permet de transmettre des chaînes aux dll en toute sécurité. En prime, vous pouvez obtenir une belle amélioration des performances dans toute l'application. FastMM est utilisé comme gestionnaire de mémoire par défaut dans Delphi 2006 et au-delà.

C'est aussi un bon outil pour rechercher les fuites de mémoire.

Answer 4

Juste pour ajouter un seul fait:

Delphi vous permet d'affecter simplement PChar à une chaîne pour le côté DLL vous n'avez pas besoin typecast:

function MyDllFunction(_s: PChar): integer; 
var 
    s: string; 
begin 
    s := _s; // implicit conversion to string 

    // now work with s instead of the _s parameter 
end; 

Cela vaut aussi pour le passage PChar en tant que paramètre d'une fonction qui attend une chaîne (par valeur). Pourquoi ne voulez-vous pas utiliser un MM partagé?