WinApi - GetLastError contre le Maréchal.GetLastWin32Error

J'ai testé beaucoup de choses. Mais je n'ai pas trouvé les inconvénients de ces 2!

Mais voir la accepté de répondre.

J'ai lu ici que l'appel GetLastError en code managé est dangereux, parce que le Cadre pourrait interne "écraser" la dernière erreur. Je n'ai jamais eu de problèmes notables avec GetLastError et il me semble que le .NET Framework est assez intelligent pour ne pas l'écraser. Donc j'ai quelques questions sur ce sujet:

dans [DllImport("kernel32.dll", SetLastError = true)] ne le SetLastError attribut de rendre le Cadre de stocker le code d'erreur pour l'utilisation de Marshal.GetLastWin32Error() ?
est là un exemple où la plaine GetLastError ne donne pas le résultat correct ?
dois-je vraiment à utiliser Marshal.GetLastWin32Error() ?
est ce "problème" Framework version liés ?

public class ForceFailure
{
    [DllImport("kernel32.dll")]
    static extern uint GetLastError();
    [DllImport("kernel32.dll", SetLastError = true)]
    static extern bool SetVolumeLabel(string lpRootPathName, string lpVolumeName);

    public static void Main()
    {
        if (SetVolumeLabel("XYZ:\\", "My Imaginary Drive "))
            System.Console.WriteLine("It worked???");
        else
        {
            //the first last error check is fine here:
            System.Console.WriteLine(GetLastError());
            System.Console.WriteLine(Marshal.GetLastWin32Error());
        }
    }
}

Produire des erreurs:

if (SetVolumeLabel("XYZ:\\", "My Imaginary Drive "))
    Console.WriteLine("It worked???");
else
{
    //bad programming but ok GetlLastError is overwritten:
    Console.WriteLine(Marshal.GetLastWin32Error());
    try
    {
        using (new FileStream("sdsdafsdfsdfs sdsd ", FileMode.Open)) { }
    }
    catch { }
    Console.WriteLine(GetLastError());
}

if (SetVolumeLabel("XYZ:\\", "My Imaginary Drive "))
    Console.WriteLine("It worked???");
else
{
    //bad programming and Marshal.GetLastWin32Error() is overwritten as well:
    Console.WriteLine(GetLastError());
    try
    {
        using (new FileStream("sdsdafsdfsdfs sdsd ", FileMode.Open)) { }
    }
    catch { }
    Console.WriteLine(Marshal.GetLastWin32Error());
}

//turn off concurrent GC
GC.Collect(); //doesn't effect any of the candidates

Console.WriteLine(" -> " + GetLastError());
Console.WriteLine(" -> " + GetLastError());
Console.WriteLine(Marshal.GetLastWin32Error());
Console.WriteLine(Marshal.GetLastWin32Error());
//when you exchange them -> same behaviour just turned around

Je ne vois pas la différence! Les deux se comportent de la même sauf Marshal.GetLastWin32Error stocke les résultats à partir de l'App->CLR->WinApi appelle ainsi et GetLastError stocke uniquement les résultats à partir de l'App->WinApi appels.

La Collecte des ordures ne semble pas appeler n'importe quel WinApi fonctions d'écraser le dernier code d'erreur

GetLastError est thread-safe. SetLastError stocke un code d'erreur pour chaque thread appelant.
depuis quand serait-GC exécuter dans mes filets ?

GetLastError œuvres, il est possible que cela fonctionne dans tous les existants .NET Framework versions et des mises en œuvre. Ainsi, votre code fonctionne, mais ce n'est pas de prouver quoi que ce soit. .NET Framework, les développeurs sont libres de changer .NET mise en œuvre par la voie, que GetLastError va s'arrêter une journée de travail.
.NET développeurs seule garantie, que GetLastWin32Error fonctionne correctement. Vous souhaitez utiliser GetlastError hack, peut-être qu'il le sera toujours, mais c'est toujours un hack. Donc, la question est un peu philosophique: peut-on utiliser des hacks, si il n'est pas prouvé, qu'il est incorrect.
Ce serait un mauvais .NET Framework version. J'imagine que beaucoup de logiciel est en cours d'exécution avec la simple GetLastError parce que le programmeur n'ai pas entendu parler de Maréchal.GetLastWin32Error ou quoi que ce soit. Faire la mise à jour que vous avez mentionné serait briser tous ces logiciels.
Peut-être que ce n'est pas convaincante exemple... de toute façon. Appel de l'API Win32 avec SetLastError=true. Les appels de l'API avec SetLastError=false. Appel GetLastWin32Error - il garde la dernière erreur de la part du premier appel d'API, par définition.
Sur la bonne ou mauvaise .NET Framework version - encore une fois, c'est la philosophie. Vous n'avez pas à me convaincre (et personne d'autre, je l'espère) à utiliser GetLastError. Mais tout le monde n'a pas à vous convaincre d'utiliser GetLastWin32Error.
Voir this. Je voulais savoir exactement si je dois ou ne pas avoir à les jeter tous mes utilisations de GetLastError dans le code existant. Actuellement, il n'est tout simplement pas de prouver qu'il est dangereux.

InformationsquelleAutor Bitterblue | 2013-07-29

c#managed marshalling unmanaged winapi

69

Vous devez toujours utiliser la Maréchal.GetLastWin32Error. Le principal problème est le garbage collector. Si elle s'exécute entre l'appel de SetVolumeLabel et l'appel de GetLastError ensuite, vous recevrez la valeur faux, parce que le GC a sûrement écrasé le dernier résultat.

Par conséquent, vous devez toujours spécifier le SetLastError=true dans le DllImport-Attribut:
```
[DllImport("kernel32.dll", SetLastError=true)]
static extern bool SetVolumeLabel(string lpRootPathName, string lpVolumeName);
```
Cela garantit que le marhsallling stub appelle immédiatement après la fonction native de la "GetLastError" et le stocke dans le fil local.

Et si vous avez spécifié cet attribut ensuite, l'appel à Maréchal.GetLastWin32Error aura toujours de la valeur correcte.

Pour plus d'infos voir aussi GetLastError et du code managé

Également une autre fonction de .NET peut changer les fenêtres "GetLastError". Voici un exemple qui produit des résultats différents:
```
using System.IO;
using System.Runtime.InteropServices;

public class ForceFailure
{
  [DllImport("kernel32.dll")]
  public static extern uint GetLastError();

  [DllImport("kernel32.dll", SetLastError = true)]
  private static extern bool SetVolumeLabel(string lpRootPathName, string lpVolumeName);

  public static void Main()
  {
    if (SetVolumeLabel("XYZ:\\", "My Imaginary Drive "))
      System.Console.WriteLine("It worked???");
    else
    {
      System.Console.WriteLine(Marshal.GetLastWin32Error());
      try
      {
        using (new FileStream("sdsdafsdfsdfs sdsd ", FileMode.Open)) {}
      }
      catch
      {
      }
      System.Console.WriteLine(GetLastError());
    }
  }
}
```
Aussi, il semble que cela dépend de la CLR qui vous aide! Si vous compilez avec .NET2, il va produire "2 /0"; si vous passez .NET 4, il sera sortie "2 /2"...

De sorte qu'il est dépendait de la version CLR, mais vous ne devriez pas faire confiance à la maternelle GetLastError fonction; toujours utiliser le Marshal.GetLastWin32Error.
- Je ne pouvais pas créer une fausse valeur retournée par GetLastError. Voir mon edit et un exemple de code.
- Voir mon édité réponse; il semble être dépendait de la CLR-version...
- Eh bien, votre exemple plutôt prouve que vous avez tort. Si vous les échanger, vous obtenez le même indésirables le comportement de Marshal.GetLastWin32Error. Mais c'est en fait la mauvaise programmation. Comme lorsque vous écrasez une variable et s'attendre à avoir de la valeur ancienne encore. Ce que je comprends de la dllimport chose est bien conçu dans .NET et l'utilisation de GetLastError est de sauvegarder bien que les gens essaient de te faire peur de l'utiliser.
- votre sna devrait être accepté comme correct ans. Le GetLastError article a été une révélation 🙂 Merci
- Je suis d'accord avec @Bitterblue que l'exemple est faux ou trompeurs au moins.. sans doute la nouvelle FileStream soit produit un nouveau message d'erreur ou le remet à zéro. Il est prévu que le résultat retourné par les deux Maréchal.GetLastWin32Error et GetLastError à la fois le retour d'une "nouvelle" suite à l'époque.
- Salut @BatteryBackupUnit: La fonction n'est là que, sur ce point, NOUS ne savons pas qui l'API Win32 qui pourrait être appelé entre l'gérés et administrés partie du code... nous n'avons pas écrire le CLR, nous devons donc supposer qu'il pourrait y avoir d'autres appels Win32 API est quelques situations particulières (comme la GC ou d'autres scénarios) que nous ne contrôlons pas. Pour cela, nous devons utiliser "SetLastError", afin de s'assurer que nous obtenons le code d'erreur approprié.
- Une chose est sûre. Cependant, votre exemple ne prouve pas que. Si vous voulais prouver que, vous aurez à effectuer un Marshal.GetLastWin32Error() et GetLastError() sans autres appels entre les deux. Maintenant, si les deux appels de retour à un résultat différent, vous auriez prouvé qu'il y a une différence. Avec votre exemple, la différence est peut-être que new FileStream(...) est d'effectuer un Win32 appel. Cela pourrait même être un DllImport avec SetLastError = true!
- Toute personne travaillant avec des PInvoke devriez lire cette question et de la réponse dans son intégralité. Pas de réglage de la "SetLastError' true provoque toutes sortes de chagrin.
InformationsquelleAutor Jochen Kalmbach
9

TL;DR
- Utilisez [DllImport(SetLastError = true)] et Marshal.GetLastWin32Error()
- effectuer le Marshal.GetLastWin32Error() immédiatement après l'échec de la Win32 appel et sur le même thread.
Argumentation

Comme je l'ai lu, l'explication officielle pourquoi vous avez besoin de Marshal.GetLastWin32Error peut être trouvé ici:

Le common language runtime pouvez faire des appels internes à l'Api qui écrasent le GetLastError maintenu par le système d'exploitation.

Pour le dire en d'autres mots:

Entre votre Win32 appel qui définit l'erreur, le CLR peut "insérer" autres appels Win32 qui pourrait remplacer l'erreur.
La spécification de [DllImport(SetLastError = true)] permet de s'assurer que le CLR récupère le code d'erreur avant que le CLR exécute tous les imprévus appels Win32.
Pour accéder à cette variable, nous avons besoin d'utiliser Marshal.GetLastWin32Error.

Maintenant ce que @Bitterblue trouvé, c'est que ces "insérée appels" ne se produisent pas souvent et qu'il ne pouvait pas en trouver. Mais ce n'est pas vraiment surpising. Pourquoi? Parce qu'il est extrêmement difficile de "boîte noire test" si GetLastError fonctionne de manière fiable:
- vous pouvez détecter des manque de fiabilité que si un CLR-inséré Win32 appel fait échoue dans l'intervalle.
- l'échec de ces appels peuvent être dépend internes et des facteurs externes. Comme l'heure/calendrier, la pression de la mémoire, des périphériques, de l'état de l'ordinateur, la version de windows...
- d'insertion des appels Win32 par CLR peut dépendre de facteurs externes. Donc, dans certaines circonstances, la CLR insère un Win32 appel, dans d'autres il ne l'est pas.
- comportement peut varier selon les versions CLR ainsi
Il est un composant spécifique - le Garbage collector (GC) - qui est connu pour interrompre une .net thread si il y a la pression de la mémoire et de faire un peu de traitement sur ce thread (voir Ce qui se passe lors d'une collecte des ordures). Maintenant, si la GC ont été à l'exécution d'une faute Win32 appel, ce serait briser votre appel à GetLastError.

Pour résumer, vous avez une multitude de facteurs inconnus qui peuvent influer sur la fiabilité de GetLastError. Vous aurez plus de chances de ne pas trouver un manque de sérieux problème lors du développement/tests, mais il pourrait peut-être sauter dans la production à tout moment. Donc, faire usage [DllImport(SetLastError = true)] et Marshal.GetLastWin32Error() et d'améliorer la qualité de votre sommeil 😉

InformationsquelleAutor BatteryBackupUnit
4

dans [DllImport("kernel32.dll", SetLastError = true)] ne SetLastError attribut de rendre le Cadre de stocker le code d'erreur pour l'utilisation du Maréchal.GetLastWin32Error() ?

Oui, comme il est démontré dans DllImportAttribute.SetLastError Champ

est là un exemple où la plaine GetLastError ne donne pas le résultat correct ?

Comme documenté dans Maréchal.GetLastWin32Error Méthode, si le cadre lui-même (par exemple, le garbage collector) appelle une méthode native qui définit une valeur d'erreur entre les appels à la méthode native et GetLastError vous obtenez la valeur de l'erreur de le cadre de l'appel à la place de votre appel.

dois-je vraiment utiliser le Maréchal.GetLastWin32Error() ?

Puisque vous ne pouvez pas garantir que le cadre ne sera jamais appeler une méthode native entre votre appel et de l'appel à GetLastError, oui. Aussi, pourquoi pas?

est ce "problème" Framework version liés ?

Il pourrait certainement être (par exemple, des changements dans le garbage collector), mais il n'a pas à.
- J'ai vérifié GC, mais ne voyons pas de problème encore. Voir modifier dans mon code d'exemple.
- GC était juste un exemple, je n'ai aucune idée si il pourrait causer des problèmes. Mais il peut sûrement dans votre fil si simultanées GC est désactivé. Ne pas seulement penser automatique et/ou les opérations d'arrière-plan dans le cadre. Peut-être que vous aurez un temps d'appeler certains (réussi) cadre de l'API qui appelle en interne une API native entre vos appels à l'API native et GetLastError. Voulez-vous vraiment à analyser la mise en œuvre de tous les appels que vous faites avant d'appeler GetLastError?
- Non, mais la première chose à faire après l'appel d'une WinApi fonction est d'appeler GetLastError de ne pas appeler un autre WinApi fonction ou de jouer une partie de Tetris. En outre Marshal.GetLastWin32Error est juste la même valeur sur un calque différent. Si le CLR est mal conçu et appelle d'autres WInApi fonctions, qui peut garantir que ce n'est pas l'écrasement de cette valeur par un autre appel d'un SetLastError = true marqué l'importation ?
- Le CLR ne pas avoir, en tant qu'objectif de la conception, de ne pas appeler d'autres fonctions de l'API Windows entre deux de votre P/Invoke appels. Ainsi, si elle ne présente en aucun cas, il n'est pas une indication de mauvaise conception. Il y a un certain nombre de situations où la manipulation supplémentaire nécessaire à l'appui de code géré peut entraîner un traitement supplémentaire derrière les scènes entre deux de vos déclarations. Ce est de par sa conception, et le fait qu'il n'est pas un défaut mais en fait, permet à votre code de travail comme vous le souhaitez. Marshal.GetLastWin32Error a été ajoutée spécifiquement pour le rendre encore possible de travailler avec des Api.
- Notons que .NET est une garantie que rien de tout cela caché traitement écrasera Marshal.GetLastWin32Error's planqué valeur. Ainsi, si vous effectuez un appel à un P/Invoke fonction avec SetLastError = true, et vous n'avez pas d'autre P/Invoke appels sur le même thread (ce qui signifie aussi de ne pas appeler les fonctions de la bibliothèque qui pourraient eux-mêmes P/Invoke), puis Marshal.GetLastWin32Error sera de retour la valeur de GetLastError qu'il l'était au moment de votre appel de P/Invoke est de retour. Le monde géré pouvez contrôler quand Marshal.GetLastWin32Error changements, mais pas quand la GetLastError la fonction de l'API n'.
InformationsquelleAutor cremor

Vous devez vous connecter pour publier un commentaire.

TL;DR

Argumentation