Intégrer pdb dans l'assemblage

Question

Je veux que ma demande soit distribuable sous forme de fichier .exe unique mais je veux être en mesure d'obtenir de beaux rapports d'erreur avec les numéros de ligne de code source (l'application envoie simplement email avec exception.ToString() et quelques informations supplémentaires quand une exception non gérée se produit).

Y at-il un moyen d'intégrer .pdb dans l'assembly?

Answer 1

Utilisez MiniDumps au lieu de "exception.ToString()". Cela vous donnera beaucoup plus d'informations et n'aura pas besoin que le fichier .pdb soit distribué avec le fichier .exe.

Lien utile: Post-Mortem Debugging Your Application with Minidumps and Visual Studio .NET

Answer 2

Vous pouvez écrire un exécutable stub, qui contient des ressources intégrées, à la fois votre exécutable réel et son fichier pdb. Au démarrage de l'exécutable staub, il extrait l'exécutable réel et le pdb dans un répertoire temporaire et le lance.

Tout comme certains installateurs ou d'autres applications font.

Je ne sais pas si cela vaut la peine de faire des efforts supplémentaires.

Answer 3

J'ai utilisé le gestionnaire AssemblyResolve suivant, puis j'ai incorporé à la fois dll et pdb de tous les assemblages. Vous pouvez définir cela comme tout ce qui s'exécute en premier dans l'application avant que les dépendances ne soient nécessaires.

private static void SetupEmbeddedAssemblyResolve() 
    { 
     // Based on http://blogs.msdn.com/b/microsoft_press/archive/2010/02/03/jeffrey-richter-excerpt-2-from-clr-via-c-third-edition.aspx 
     AppDomain.CurrentDomain.AssemblyResolve += (sender, args) => 
     { 
      var name = args.Name; 
      var asmName = new AssemblyName(name); 

      // Any retargetable assembly should be resolved directly using normal load e.g. System.Core issue: 
      // http://stackoverflow.com/questions/18793959/filenotfoundexception-when-trying-to-load-autofac-as-an-embedded-assembly 
      if (name.EndsWith("Retargetable=Yes")) 
      { 
       return Assembly.Load(asmName); 
      } 

      var executingAssembly = Assembly.GetExecutingAssembly(); 
      var resourceNames = executingAssembly.GetManifestResourceNames(); 

      var resourceToFind = asmName.Name + ".dll"; 
      var resourceName = resourceNames.SingleOrDefault(n => n.Contains(resourceToFind)); 

      if (string.IsNullOrWhiteSpace(resourceName)) { return null; } 

      var symbolsToFind = asmName.Name + ".pdb"; 
      var symbolsName = resourceNames.SingleOrDefault(n => n.Contains(symbolsToFind)); 

      var assemblyData = LoadResourceBytes(executingAssembly, resourceName); 

      if (string.IsNullOrWhiteSpace(symbolsName)) 
      { 
       Trace.WriteLine(string.Format("Loading '{0}' as embedded resource '{1}'", resourceToFind, resourceName)); 

       return Assembly.Load(assemblyData); 
      } 
      else 
      { 
       var symbolsData = LoadResourceBytes(executingAssembly, symbolsName); 

       Trace.WriteLine(string.Format("Loading '{0}' as embedded resource '{1}' with symbols '{2}'", resourceToFind, resourceName, symbolsName)); 

       return Assembly.Load(assemblyData, symbolsData); 
      } 
     }; 
    } 

    private static byte[] LoadResourceBytes(Assembly executingAssembly, string resourceName) 
    { 
     using (var stream = executingAssembly.GetManifestResourceStream(resourceName)) 
     { 
      var assemblyData = new Byte[stream.Length]; 

      stream.Read(assemblyData, 0, assemblyData.Length); 

      return assemblyData; 
     } 
    }