Référençant shell32 à nouveau, C # Visual Studio

Question

Hmmm. Bon après revisiter PInvoke, je suis sûr que je ne comprends pas bien: - / (juste demandé cette question )

Permettez-moi d'illustrer le code que je dois gérer. Il fonctionne quand je l'utilise « Ajouter une référence -> COM -> Contrôles Microsoft Shell et Automatation » ... mais malheureusement, il place une référence dans mon projet qui ressemble à ceci: « C: \ Users \ Tim \ Documents \ Visual Studio 2008 \ Projects \ Wing \ FileWing \ obj \ Debug \ Interop.Shell32.dll "

Je creuse si le bac de recyclage et de rechercher un élément que je veux récupérer. Y at-il moyen de ne pas se battre à travers le PInvoke pour y parvenir? Ou pour obtenir une référence au system32 / shell32.dll qui me permet d'utiliser ce code lors de l'exécution?

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

En ce moment, vous mélangez 2 concepts différents: PInvoke et COM Interop.

PInvoke vous permet d'accéder aux fonctions natives de C à partir du code managé. Il fonctionne en définissant une signature compatible maréchal de la méthode native en code managé et marquer avec l'attribut DllImport. Elle exige, et ne peut pas avoir, une référence de métadonnées à la DLL native. La DLL est découverte lors de l'exécution en utilisant des règles de chargement normales pour une DLL Win32.

COM Interop vous permet d'accéder à des objets compatibles COM du code managé. Cela se fait en obtenant une définition gérée compatible marshal de l'interface COM, puis gagner un referece à l'objet dans l'une de plusieurs façons. Obtenir la définition gérés est souvent réalisé au moyen de l'ajout d'une référence de métadonnées à la PIA (assemblage PIA) pour le composant COM. Jusqu'à C # 4.0, cette référence ne peut pas être retirée, sans beaucoup de travail, et doit être déployé avec votre application.

Dans cet exemple particulier que vous utilisez COM Interop et non PInvoke.