La méthode Application.Quit() ne parvient pas à effacer le processus

Question

J'ai vu beaucoup de messages renvoyés par un moteur de recherche Google à ce sujet, mais aucune des solutions référencées dans ceux-ci ne permet de résoudre ce problème. Donc, j'ai pensé que j'essayerais moi-même.

Après ce bloc de code:

PowerPoint.Application powerPoint = new Microsoft.Office.Interop.PowerPoint.Application(); 
powerPoint.Visible = Office.MsoTriState.msoTrue; 
Microsoft.Office.Interop.PowerPoint.Presentation ppt = null;enter code here 

Je peux délivrer le ppt.Quit(); La commande et Powerpoint se ferment et aucun processus n'est en cours d'exécution.

Cependant, si après ce code je fais ceci:

ppt = powerPoint.Presentations.Open(localCopyOfPPT, 
            Microsoft.Office.Core.MsoTriState.msoCTrue, 
            Microsoft.Office.Core.MsoTriState.msoTriStateMixed, 
            Microsoft.Office.Core.MsoTriState.msoTrue); 
ppt.Close(); 
powerPoint.Quit(); 

Ensuite, le quit() ne fonctionnera pas. Quelque chose à propos de l'ouverture de la présentation, même si je la ferme alors, empêche le Quit() de fonctionner, il apparaît.

Quelqu'un at-il des idées sur la façon dont je peux obtenir l'application pour quitter correctement?

Answer 1

Le fichier KB Aritcle suivant pourrait vous aider à aller au fond du problème. http://support.microsoft.com/kb/317109

Vous devrez peut-être appeler explicitement System.Runtime.InteropServices.Marshal.ReleaseComObject sur votre instance ppt.

Answer 2

powerPoint.Presentations.Open (..)

Notez l'utilisation de l'objet de présentations. COM utilise la gestion manuelle de la mémoire basée sur le comptage des références, chaque interface COM a une méthode AddRef() et Release(). L'appel AddRef est automatique lorsque vous obtenez un objet. Lorsque vous avez terminé, vous devez appeler la méthode Release(). L'utilisation de l'objet Presentations ajoute ici une référence à l'objet Presentations. Qui à son tour ajoute une référence à l'objet d'application interne.

Ceci est très incompatible avec la gestion de la mémoire dans le framework .NET. C'est automatique, le garbage collector s'en charge. Ce qu'il fait aussi pour les objets COM, l'encapsuleur interop dispose d'un finaliseur, il décrémente le nombre de références lorsqu'il constate qu'aucune référence .NET n'est laissée sur l'objet COM.

Vous voyez peut-être où cela se passe: PowerPoint ne peut pas quitter tant que toutes les références d'objet ne sont pas libérées. Ce qui ne peut pas arriver jusqu'à ce que le garbage collector soit exécuté et que le thread finalizer soit terminé. Votre appel à la méthode Quit() pas fait fonctionner le garbage collector. Seul GC.Collect() + GC.WaitForPendingFinalizers peut le faire.

Vous pouvez également effectuer une approche manuelle. Il nécessite Marshal.ReleaseComObject(). Cela est difficile à obtenir correctement, notez que vous n'avez pas de référence à l'objet Presentations stocké n'importe où dans votre code. Vous devrez réécrire complètement votre code pour garder une trace de ces références afin que vous puissiez appeler ReleaseComObject() sur eux.

Je ne peux pas le recommander. Si vous vraiment vraiment voulez PowerPoint à quitter alors le mieux est de vous assurer que toutes vos références sont nulles et appelez GC.Collect() et GC.WFPF. Je ne peux pas le recommander non plus. Il va quitter, finalement. Ne t'en fais pas pour ça.

Answer 3

je fais face Même problème dans mon travail ... Vous essayez ci-dessous le code il fonctionne

PowerPoint.Application powerPoint = new Microsoft.Office.Interop.PowerPoint.Application(); 
    //powerPoint.Visible = Office.MsoTriState.msoTrue; 
    Microsoft.Office.Interop.PowerPoint.Presentation ppt = null; 

    try 
    { 
     ppt = powerPoint.Presentations.Open(localCopyOfPPT, 
              Microsoft.Office.Core.MsoTriState.msoCTrue, 
              Microsoft.Office.Core.MsoTriState.msoTriStateMixed, 
              Microsoft.Office.Core.MsoTriState.msoFalse); 
    ppt.Close(); 
    Marshal.FinalReleaseComObject(ppt); 
    }catch(){}finally 
    { 
     powerPoint.Quit(); 
     Marshal.FinalReleaseComObject(powerPoint); 
     GC.Collect(); 
    } 

Answer 4

Alternative pour votre problème.trouver le processus une fois le travail terminé, puis le tuer.

Code:

Process[] processes = Process.GetProcessesByName("powerpnt"); 
for (int i = 0; i < processes.Count(); i++) 
{ 
    processes[i].Kill(); 
} 

Espace de noms: System.Diagnostics

Answer 5

Essayez le ci-dessous.

GC.Collect(); 
GC.WaitForPendingFinalizers(); 

Vous pourriez avoir à utiliser de cette manière aussi

GC.Collect(); 
GC.WaitForPendingFinalizers(); 

GC.Collect(); 
GC.WaitForPendingFinalizers(); 

Parce que, voir le dernier point de cette page http://code.msdn.microsoft.com/office/CSAutomatePowerPoint-b312d416

Answer 6

Si vous avez plusieurs instances de PowerPoint vous ouvrez pouvez utiliser quelque chose le long de ces lignes - C'est la façon la plus simple que j'ai trouvé pour fermer les applications PowerPoint qui ne seront pas effacées lorsqu'on leur demandera de quitter.

Voilà comment je finis par PowerPoint meurtre/fermeture (spécifié par chemin du document qui a été ouvert)

/// <summary> 
    /// Close open PowerPoint document 
    /// </summary> 
    /// <param name="path">Path to document</param> 
    /// <param name="saveChanges">Save changes to document</param> 
    public void PowerPointCloseOpenDocument(String path, Boolean saveChanges = true) 
    { 
     ppApp = getPowerPointApp(path); 
     PowerPoint.Presentation pp = null; 

     if (!String.IsNullOrEmpty(path)) 
     { 
      foreach (PowerPoint.Presentation p in ppApp.Presentations) 
      { 
       if (p.FullName.Equals(path, StringComparison.CurrentCultureIgnoreCase)) 
       { 
        try 
        { 
         pp = p; 
        } 
        catch (Exception) 
        { } 
        break; 
       } 
      } 
     } 
     if(saveChanges) 
     { 
      if(pp!=null) 
      { 
       pp.Save(); 
      } 
     } 
     if(pp!= null) 
     { 
      Marshal.FinalReleaseComObject(pp); 
     } 
     if(null != ppApp) 
     { 
      Marshal.FinalReleaseComObject(ppApp); 
     } 
     var procs = FileUtil.WhoIsLocking(path); 
     if(procs!= null) 
     { 
      foreach(var proc in procs) 
      { 
       proc.Kill(); 
      } 
     } 
     GC.Collect(); 
     GC.WaitForPendingFinalizers(); 

     GC.Collect(); 
     GC.WaitForPendingFinalizers(); 
    } 

private PowerPoint.Application getPowerPointApp(String path = "") 
    { 
     try 
     { 
      PowerPoint.Application ppapp = null; 
      try 
      { 
       if (!String.IsNullOrEmpty(path)) 
       { 
        ppapp = ((PowerPoint.Presentation)System.Runtime.InteropServices.Marshal.BindToMoniker(path)).Application; 
       } 
      } 
      catch (Exception) { } 
      if (ppapp == null) 
      { 
       try 
       { 
        ppapp = (PowerPoint.Application)System.Runtime.InteropServices.Marshal.GetActiveObject("PowerPoint.Application"); 
       } 
       catch (Exception) 
       { 
        ppapp = new PowerPoint.Application(); 
        ppapp.Visible = Microsoft.Office.Core.MsoTriState.msoTrue; 
       } 
      } 
      if (ppapp != null) 
      { 
       ppapp.DisplayAlerts = Microsoft.Office.Interop.PowerPoint.PpAlertLevel.ppAlertsNone; 
      } 
      try { ppapp.Activate(); } 
      catch (Exception) { } 
      return ppapp; 
     } 
     catch (Exception) 
     { 
      return (PowerPoint.Application)Activator.CreateInstance(Type.GetTypeFromProgID("PowerPoint.Application")); 
     } 
    } 

Le fichier Util classe qui vous fournit la liste des processus de verrouillage actuellement un document.

static public class FileUtil 
{ 
    [StructLayout(LayoutKind.Sequential)] 
    struct RM_UNIQUE_PROCESS 
    { 
     public int dwProcessId; 
     public System.Runtime.InteropServices.ComTypes.FILETIME ProcessStartTime; 
    } 

    const int RmRebootReasonNone = 0; 
    const int CCH_RM_MAX_APP_NAME = 255; 
    const int CCH_RM_MAX_SVC_NAME = 63; 

    enum RM_APP_TYPE 
    { 
     RmUnknownApp = 0, 
     RmMainWindow = 1, 
     RmOtherWindow = 2, 
     RmService = 3, 
     RmExplorer = 4, 
     RmConsole = 5, 
     RmCritical = 1000 
    } 

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] 
    struct RM_PROCESS_INFO 
    { 
     public RM_UNIQUE_PROCESS Process; 

     [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCH_RM_MAX_APP_NAME + 1)] 
     public string strAppName; 

     [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCH_RM_MAX_SVC_NAME + 1)] 
     public string strServiceShortName; 

     public RM_APP_TYPE ApplicationType; 
     public uint AppStatus; 
     public uint TSSessionId; 
     [MarshalAs(UnmanagedType.Bool)] 
     public bool bRestartable; 
    } 

    [DllImport("rstrtmgr.dll", CharSet = CharSet.Unicode)] 
    static extern int RmRegisterResources(uint pSessionHandle, 
              UInt32 nFiles, 
              string[] rgsFilenames, 
              UInt32 nApplications, 
              [In] RM_UNIQUE_PROCESS[] rgApplications, 
              UInt32 nServices, 
              string[] rgsServiceNames); 

    [DllImport("rstrtmgr.dll", CharSet = CharSet.Auto)] 
    static extern int RmStartSession(out uint pSessionHandle, int dwSessionFlags, string strSessionKey); 

    [DllImport("rstrtmgr.dll")] 
    static extern int RmEndSession(uint pSessionHandle); 

    [DllImport("rstrtmgr.dll")] 
    static extern int RmGetList(uint dwSessionHandle, 
           out uint pnProcInfoNeeded, 
           ref uint pnProcInfo, 
           [In, Out] RM_PROCESS_INFO[] rgAffectedApps, 
           ref uint lpdwRebootReasons); 

    /// <summary> 
    /// Find out what process(es) have a lock on the specified file. 
    /// </summary> 
    /// <param name="path">Path of the file.</param> 
    /// <returns>Processes locking the file</returns> 
    /// <remarks>See also: 
    /// http://msdn.microsoft.com/en-us/library/windows/desktop/aa373661(v=vs.85).aspx 
    /// http://wyupdate.googlecode.com/svn-history/r401/trunk/frmFilesInUse.cs (no copyright in code at time of viewing) 
    /// 
    /// </remarks> 
    static public List<Process> WhoIsLocking(string path) 
    { 
     uint handle; 
     string key = Guid.NewGuid().ToString(); 
     List<Process> processes = new List<Process>(); 

     int res = RmStartSession(out handle, 0, key); 
     if (res != 0) throw new Exception("Could not begin restart session. Unable to determine file locker."); 

     try 
     { 
      const int ERROR_MORE_DATA = 234; 
      uint pnProcInfoNeeded = 0, 
       pnProcInfo = 0, 
       lpdwRebootReasons = RmRebootReasonNone; 

      string[] resources = new string[] { path }; // Just checking on one resource. 

      res = RmRegisterResources(handle, (uint)resources.Length, resources, 0, null, 0, null); 

      if (res != 0) throw new Exception("Could not register resource."); 

      //Note: there's a race condition here -- the first call to RmGetList() returns 
      //  the total number of process. However, when we call RmGetList() again to get 
      //  the actual processes this number may have increased. 
      res = RmGetList(handle, out pnProcInfoNeeded, ref pnProcInfo, null, ref lpdwRebootReasons); 

      if (res == ERROR_MORE_DATA) 
      { 
       // Create an array to store the process results 
       RM_PROCESS_INFO[] processInfo = new RM_PROCESS_INFO[pnProcInfoNeeded]; 
       pnProcInfo = pnProcInfoNeeded; 

       // Get the list 
       res = RmGetList(handle, out pnProcInfoNeeded, ref pnProcInfo, processInfo, ref lpdwRebootReasons); 
       if (res == 0) 
       { 
        processes = new List<Process>((int)pnProcInfo); 

        // Enumerate all of the results and add them to the 
        // list to be returned 
        for (int i = 0; i < pnProcInfo; i++) 
        { 
         try 
         { 
          processes.Add(Process.GetProcessById(processInfo[i].Process.dwProcessId)); 
         } 
         // catch the error -- in case the process is no longer running 
         catch (ArgumentException) { } 
        } 
       } 
       else throw new Exception("Could not list processes locking resource."); 
      } 
      else if (res != 0) throw new Exception("Could not list processes locking resource. Failed to get size of result."); 
     } 
     finally 
     { 
      RmEndSession(handle); 
     } 

     return processes; 
    }  
}