Riferimento nuovo Shell32, C # di Visual Studio

Question

Hmmm. Va bene, dopo la rivisitazione PInvoke, sono sicuro che non ho ben capito: - / (appena chiesto questa domanda )

Permettetemi di illustrare il codice ho bisogno di gestire. Funziona quando uso "Add Reference -> COM -> Controlli Microsoft Shell e Automatation" ... ma purtroppo pone un punto di riferimento nel mio progetto che assomiglia a questo: "C: \ Users \ Tim \ Documenti \ Visual Studio 2008 \ Projects \ Ala \ FileWing \ obj \ Debug \ Interop.Shell32.dll "

Sto scavando anche se il cestino e cercare per un elemento che voglio recuperare. C'è un modo non combattere attraverso il PInvoke per ottenere questo fatto? O per ottenere un riferimento alla system32 / shell32.dll che mi permette di utilizzare questo codice in fase di esecuzione?

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 si sta mescolando 2 concetti diversi: PInvoke e COM Interop.

PInvoke consente di accedere alle funzioni native C dall'interno di codice gestito. Funziona attraverso la definizione di un maresciallo firma compatibile del metodo nativo in codice gestito e la marcatura con l'attributo DllImport. Si richiede, e non può avere, un riferimento di metadati alla DLL nativa. La DLL viene scoperto in fase di esecuzione utilizzando le normali regole di carico per una DLL Win32.

interoperabilità COM permette di accedere a oggetti compatibili COM dal codice gestito. Questo viene fatto da ottenere un maresciallo definizione compatibile gestita dell'interfaccia COM e poi guadagnando un referece all'oggetto in uno dei diversi modi. Ottenere la definizione gestita è spesso realizzato mediante l'aggiunta di un riferimento metadati al PIA (assembly di interoperabilità primario) per il componente COM. Fino a C # 4.0, questo riferimento non può essere rimosso, senza un sacco di lavoro, e deve essere distribuito con l'applicazione.

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