Fare nuovamente riferimento a shell32, C# Visual Studio

Question

Hmmm. Ok, dopo aver rivisitato PInvoke, sono sicuro di non averlo capito: -/(appena chiesto this question)

Lasciatemi illustrare il codice che devo gestire. Funziona quando uso "Aggiungi riferimento -> COM -> Microsoft Shell Controls and Automatation" ... ma purtroppo pone un riferimento nel mio progetto che assomiglia a questo: "C: \ Users \ Tim \ Documents \ Visual Studio 2008 \ Projects \ Wing \ FileWing \ obj \ Debug \ Interop.Shell32.dll "

Sto scavando attraverso il cestino e cerco un oggetto che voglio recuperare. C'è un modo per NON combattere attraverso il PInvoke per fare questo? O per ottenere un riferimento al system32/shell32.dll che mi permette di utilizzare questo codice in fase di runtime?

private void recoverRecyclerBinEntry(string fileName, int size) 
{ 
    try 
    { 
     Shell Shl = new Shell(); 
     Folder Recycler = Shl.NameSpace(10); 

     // scans through all the recyclers entries till the one to recover has been found 
     for (int i = 0; i < Recycler.Items().Count; i++) 
     { 
      FolderItem FI = Recycler.Items().Item(i); 
      string FileName = Recycler.GetDetailsOf(FI, 0); 
      if (Path.GetExtension(FileName) == "") 
       FileName += Path.GetExtension(FI.Path); 
      //Necessary for systems with hidden file extensions. 

      string FilePath = Recycler.GetDetailsOf(FI, 1); 
      string combinedPath = Path.Combine(FilePath, FileName); 

      if (size == FI.Size && fileName == combinedPath) 
      { 
       Debug.Write("Match found. Restoring " + combinedPath + "..."); 
       Undelete(FI); 
       Debug.WriteLine("done."); 
      } 
      else 
      { 
       Debug.WriteLine("No match"); 
      } 
     } 
    } 
    catch (Exception ex) 
    { 
     Debug.WriteLine(ex.Message); 
     Debug.WriteLine(ex.StackTrace); 
    } 
} 

private bool Undelete(FolderItem Item) 
{ 
    try 
    { 
     foreach (FolderItemVerb FIVerb in Item.Verbs()) 
     { 
      if (
       (FIVerb.Name.ToUpper().Contains("WIEDERHERSTELLEN")) || 
       (FIVerb.Name.ToUpper().Contains("ESTORE")) || 
       (FIVerb.Name.ToUpper().Contains("NDELETE")) 
       ) 
      { 
       FIVerb.DoIt(); 
       return true; 
      } 
     } 
     //execute the first one: 
     Item.Verbs().Item(0).DoIt(); 
     return true; 
    } 
    catch (Exception) 
    { 
     Debug.WriteLine("ERROR undeleting"); 
     return false; 
    } 
} 

Answer 1

In questo momento stai mescolando 2 concetti diversi: PInvoke e COM Interop.

PInvoke consente di accedere alle funzioni C native dal codice gestito. Funziona definendo una firma compatibile maresciallo del metodo nativo nel codice gestito e contrassegnandolo con l'attributo DllImport. Richiede, e non può avere, un riferimento ai metadati della DLL nativa. La DLL viene rilevata in fase di esecuzione utilizzando le normali regole di caricamento per una DLL Win32.

COM Interop consente di accedere agli oggetti COM compatibili dal codice gestito. Ciò viene ottenuto ottenendo una definizione gestita compatibile con il marshal dell'interfaccia COM e ottenendo un riferimento all'oggetto in uno dei vari modi. L'acquisizione della definizione gestita viene spesso eseguita aggiungendo un riferimento ai metadati al PIA (assembly di interoperabilità primario) per il componente COM. Fino al C# 4.0, questo riferimento non può essere rimosso, senza molto lavoro, e deve essere distribuito con l'applicazione.

In questo particolare esempio si utilizza l'interoperabilità COM e non PInvoke.