How can I browse a local virtual folder in C#?

Question

In my C# program I have to browse directories. So I use the method System.IO.Directory.GetFiles(directory) and it works well when directory is a real directory like "C:\Program File" but when it's a virtual directory (eg: librairie directory), directory value looks like this : "::{031E4825-7B94-4dc3-B131-E946B44C8DD5}\Pictures.library-ms" and I don't know how to browse it.

Answer 1

You need to translate the virtual path into a physical one, try:

DirectoryInfo directoryInfo = new DirectoryInfo(Server.MapPath("your virtual folder here"));

You might want to read up on DirectoryInfo. If that's no use, give this a try this instead:

DirectoryInfo info = new DirectoryInfo("virtual folder here");
FileInfo[] files = info.GetFiles("*.*", SearchOption.AllDirectories);

Answer 2

I know this is crazy old, but in case someone wants the solution, here is what I have figured out over the past half-day looking into this. There are several solutions out there that can get you the folder names if you give it the path to the Virtual Folder's XML location , but nothing I have seen gets you there from ::{031E4825-....}. There was a hint in another question's answer to use the WindowsAPICodePack's KnownFoldersBrowser example. So I read through the source code in that and have come up with the following:

Here is the DialogBox I was using to get folders, and I have enabled it for AllowNonFileSystemItems, which allows Library folder selections:

Microsoft.WindowsAPICodePack.Dialogs.CommonOpenFileDialog dlg = new Microsoft.WindowsAPICodePack.Dialogs.CommonOpenFileDialog();
dlg.Title = "Pick Folder";
dlg.IsFolderPicker = true;
dlg.InitialDirectory = Environment.SpecialFolder.Personal.ToString();  // If default setting does not exist, pick the Personal folder

dlg.AddToMostRecentlyUsedList = false;
dlg.AllowNonFileSystemItems = true;
dlg.DefaultDirectory = dlg.InitialDirectory;
dlg.EnsurePathExists = true;
dlg.EnsureFileExists = false;
dlg.EnsureReadOnly = false;
dlg.EnsureValidNames = true;
dlg.Multiselect = true;
dlg.ShowPlacesList = true;

if (dlg.ShowDialog() == Microsoft.WindowsAPICodePack.Dialogs.CommonFileDialogResult.Ok)
{
    foreach ( string dirname in dlg.FileNames )
    {
        var libFolders = ExpandFolderPath(dirname);
        if ( libFolders == null )
        {
            MessageBox.Show("Could not add '" + dirname + "', please try another.");
        }
        else
        {
            foreach ( string libfolder in libFolders )
            {
                DoWork(libfolder);
            }
        }
    }
}

I then iterate over allSpecialFolders to find this same ::{031E4825-...} which is the ParsingName for the SpecialFolder (yeah, probably a more elegant way). After that, use the XML reading from other solutions (I used a CodeProject example that did the same thing) to get the folders in that library folder:

    /// <summary>Gets the folders associated with a path</summary>
    /// <param name="libname"></param>
    /// <returns>Folder, or List of folders in library, and null if there was an issue</string></returns>
    public List<string> ExpandFolderPath(string foldername)
    {
        List<string> dirList = new List<string> { };
        // If the foldername is an existing directory, just return that
        if ( System.IO.Directory.Exists(foldername) )
        {
            dirList.Add(foldername);
            return dirList;
        }

        // It's not a directory, so check if it's a GUID Library folder
        ICollection<IKnownFolder> allSpecialFolders = Microsoft.WindowsAPICodePack.Shell.KnownFolders.All;
        Regex libguid = new Regex(@"\b([A-F0-9]{8}(?:-[A-F0-9]{4}){3}-[A-F0-9]{12})\b");
        var match = libguid.Match(foldername);
        if ( match == null )
            return null;

        string fpath = "";
        // Iterate over each folder and find the one we want
        foreach ( var folder in allSpecialFolders )
        {
            if ( folder.ParsingName == foldername )
            {
                // We now have access to the xml path
                fpath = folder.Path;
                break;
            }
        }
        if ( fpath == "" )
        {
            // Could not find it exactly, so find one with the same prefix, and
            // replace the filename
            foreach ( var folder in allSpecialFolders )
            {
                if ( folder.ParsingName.Contains(match.Groups[1].Value) )
                {
                    string sameDir = System.IO.Path.GetDirectoryName(folder.Path);
                    string newPath = System.IO.Path.Combine(sameDir, match.Groups[2].Value);
                    if ( System.IO.File.Exists(newPath) )
                        fpath = newPath;
                    break;
                }
            }
        }

        if ( fpath == "" )
            return null;

        var intFolders = GetLibraryInternalFolders(fpath);

        return intFolders.Folders.ToList();

    }


    /// <summary>
    /// Represents an instance of a Windows 7 Library
    /// </summary>
    public class Win7Library
    {
        public Win7Library()
        {

        }

        public string Name { get; set; }

        public string[] Folders { get; set; }
    }

    [DllImport("shell32.dll")]
    static extern int SHGetKnownFolderPath( [MarshalAs(UnmanagedType.LPStruct)] Guid rfid, uint dwFlags, IntPtr hToken, out IntPtr pszPath );

    //Handles call to SHGetKnownFolderPath
    public static string getpathKnown( Guid rfid )
    {
        IntPtr pPath;
        if ( SHGetKnownFolderPath(rfid, 0, IntPtr.Zero, out pPath) == 0 )
        {
            string s = System.Runtime.InteropServices.Marshal.PtrToStringUni(pPath);
            System.Runtime.InteropServices.Marshal.FreeCoTaskMem(pPath);

            return s;
        }
        else return string.Empty;
    }

    private static string ResolveStandardKnownFolders( string knowID )
    {
        if ( knowID.StartsWith("knownfolder:") )
        {
            return getpathKnown(new Guid(knowID.Substring(12)));
        }
        else
        {
            return knowID;
        }
    }

    private static Win7Library GetLibraryInternalFolders( string libraryXmlPath )
    {
        Win7Library newLibrary = new Win7Library();
        //The Name of a Library is just its file name without the extension
        newLibrary.Name = System.IO.Path.GetFileNameWithoutExtension(libraryXmlPath);

        List<string> folderpaths = new List<string>();

        System.Xml.XmlDocument xmlDoc = new System.Xml.XmlDocument(); //* create an xml document object.
        xmlDoc.Load(libraryXmlPath); //* load the library as an xml doc.

        //Grab all the URL tags in the document, 
        //these point toward the folders contained in the library.
        System.Xml.XmlNodeList directories = xmlDoc.GetElementsByTagName("url");

        foreach ( System.Xml.XmlNode x in directories )
        {
            //Special folders use windows7 Know folders GUIDs instead 
            //of full file paths, so we have to resolve them
            folderpaths.Add(ResolveStandardKnownFolders(x.InnerText));
        }

        newLibrary.Folders = folderpaths.ToArray();
        return newLibrary;
    }

Hope this helps someone in future!