Comment configurer un OpenFileDialog pour sélectionner des dossiers?

Il est l'API de Windows Pack de Code. Il a beaucoup de shell choses liées, y compris le CommonOpenFileDialog la classe (dans le Microsoft.WindowsAPICodePack.Dialogs espace de noms). C'est la solution parfaite - l'habituelle boîte de dialogue ouvrir avec seulement des dossiers.

Voici un exemple de comment l'utiliser:

CommonOpenFileDialog cofd = new CommonOpenFileDialog();
cofd.IsFolderPicker = true;
cofd.ShowDialog();

---

Malheureusement, Microsoft n'est plus livré ce package, mais plusieurs personnes ont officieusement téléchargé les fichiers binaires à NuGet. Un exemple peut être trouvé ici. Ce package n'est qu'une coquille spécifique des choses. Si vous avez besoin d'elle, de la même utilisateur dispose de plusieurs autres paquets qui offrent plus de fonctionnalités présent dans le package d'origine.

La Ookii.Les boîtes de dialogue paquet contient un gérés wrapper autour de la nouvelle (Vista-style) dossier de dialogue du navigateur. Elle a également dégrade gracieusement sur les anciens systèmes d'exploitation.

• Ookii les boîtes de dialogue de WPF de mieux les cibler .NET 4.5 et disponible sur NuGet
• Ookii les boîtes de dialogue de Windows Forms de mieux les cibler .NET 4.5 et disponible sur NuGet

Après des heures de recherche j'ai trouvé cette réponse par leetNightShade à une solution de travail.

Il y a trois choses que je crois que cette solution soit beaucoup mieux que tous les autres.

1. Il est simple à utiliser.
   Il n'exige de vous d'inclure deux fichiers (qui peuvent être combinés pour un de toute façon) dans votre projet.
2. Qu'elle retombe à la norme FolderBrowserDialog lorsqu'il est utilisé sur XP ou des systèmes plus anciens.
3. L'auteur accorde l'autorisation d'utiliser le code pour n'importe quel but que vous estimez.
   

   Il n'y a pas de licence en tant que tel vous êtes libre de le prendre et de le faire avec le code que vous voulez.

Télécharger le code ici.

OK, laissez-moi essayer de connecter le premier point 😉
En jouant un peu avec Spy++ ou Winspector montre que le Dossier de zone de texte dans le VS Emplacement du Projet est une personnalisation de la boîte de dialogue standard. Ce n'est pas le même domaine que le nom de fichier de zone de texte dans une boîte de dialogue standard fichier comme celui dans le bloc-notes.

À partir de là, je me figure, VS cache le nom de fichier et le type du fichier des zones de texte/zones de liste modifiables et utilise un custom modèle de boîte de dialogue pour ajouter sa propre part dans le fond de la boîte de dialogue.

EDIT: Voici un exemple de personnalisation et comment le faire (en Win32. pas .NET):

m_ofn est la structure OPENFILENAME qui sous-tend la boîte de dialogue de fichier. Ajouter ces 2 lignes:

  m_ofn.lpTemplateName = MAKEINTRESOURCE(IDD_FILEDIALOG_IMPORTXLIFF);
  m_ofn.Flags |= OFN_ENABLETEMPLATE;

où IDD_FILEDIALOG_IMPORTXLIFF est une coutume modèle de boîte de dialogue qui sera ajouté dans le bas de la boîte de dialogue. Voir la partie en rouge ci-dessous.


_{(source: apptranslator.com)}

Dans ce cas, la mesure n'est qu'une étiquette + un lien hypertexte, mais il pourrait être n'importe quel dialogue. Elle pourrait contenir un bouton OK qui nous auraient permis de valider le dossier de sélection.

Mais comment nous débarrasser de certains des contrôles dans la partie standard de la boîte de dialogue, je ne sais pas.

Plus en détail dans cet article MSDN.

Vous pouvez utiliser le code comme ceci

• Le filtre est de masquer les fichiers
• Le nom du fichier est de masquer premier texte

À avancé cacher de la zone de texte pour le nom de fichier que vous devez regarder
OpenFileDialogEx

Le code:

{
    openFileDialog2.FileName = "\r";
    openFileDialog1.Filter = "folders|*.neverseenthisfile";
    openFileDialog1.CheckFileExists = false;
    openFileDialog1.CheckPathExists = false;
}

Première Solution

J'ai développé ce que un nettoyage de la version de .NET Win 7-dossier de style, sélectionnez la boîte de dialogue par le projet de Loi Seddon de lyquidity.com (je n'ai pas d'affiliation). (Je l'ai appris de son code de une autre réponse sur cette page). J'ai écrit mon propre parce que sa solution nécessite une Réflexion complémentaire de la classe qui n'est pas nécessaire pour cet objectif, utilise exception basée sur le contrôle de flux, ne pas mettre en cache les résultats de sa réflexion appels. Notez que le sous-statique VistaDialog classe est alors que sa statique de réflexion variables n'essayez pas d'obtenir remplie si le Show méthode n'est jamais appelé. Il revient à la pré-Vista dialogue si ce n'est dans une assez grande version de Windows. Devrait fonctionner sous Windows 7, 8, 9, 10 et plus (théoriquement).

using System;
using System.Reflection;
using System.Windows.Forms;
namespace ErikE.Shuriken {
///<summary>
///Present the Windows Vista-style open file dialog to select a folder. Fall back for older Windows Versions
///</summary>
public class FolderSelectDialog {
private string _initialDirectory;
private string _title;
private string _fileName = "";
public string InitialDirectory {
get { return string.IsNullOrEmpty(_initialDirectory) ? Environment.CurrentDirectory : _initialDirectory; }
set { _initialDirectory = value; }
}
public string Title {
get { return _title ?? "Select a folder"; }
set { _title = value; }
}
public string FileName { get { return _fileName; } }
public bool Show() { return Show(IntPtr.Zero); }
///<param name="hWndOwner">Handle of the control or window to be the parent of the file dialog</param>
///<returns>true if the user clicks OK</returns>
public bool Show(IntPtr hWndOwner) {
var result = Environment.OSVersion.Version.Major >= 6
? VistaDialog.Show(hWndOwner, InitialDirectory, Title)
: ShowXpDialog(hWndOwner, InitialDirectory, Title);
_fileName = result.FileName;
return result.Result;
}
private struct ShowDialogResult {
public bool Result { get; set; }
public string FileName { get; set; }
}
private static ShowDialogResult ShowXpDialog(IntPtr ownerHandle, string initialDirectory, string title) {
var folderBrowserDialog = new FolderBrowserDialog {
Description = title,
SelectedPath = initialDirectory,
ShowNewFolderButton = false
};
var dialogResult = new ShowDialogResult();
if (folderBrowserDialog.ShowDialog(new WindowWrapper(ownerHandle)) == DialogResult.OK) {
dialogResult.Result = true;
dialogResult.FileName = folderBrowserDialog.SelectedPath;
}
return dialogResult;
}
private static class VistaDialog {
private const string c_foldersFilter = "Folders|\n";
private const BindingFlags c_flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
private readonly static Assembly s_windowsFormsAssembly = typeof(FileDialog).Assembly;
private readonly static Type s_iFileDialogType = s_windowsFormsAssembly.GetType("System.Windows.Forms.FileDialogNative+IFileDialog");
private readonly static MethodInfo s_createVistaDialogMethodInfo = typeof(OpenFileDialog).GetMethod("CreateVistaDialog", c_flags);
private readonly static MethodInfo s_onBeforeVistaDialogMethodInfo = typeof(OpenFileDialog).GetMethod("OnBeforeVistaDialog", c_flags);
private readonly static MethodInfo s_getOptionsMethodInfo = typeof(FileDialog).GetMethod("GetOptions", c_flags);
private readonly static MethodInfo s_setOptionsMethodInfo = s_iFileDialogType.GetMethod("SetOptions", c_flags);
private readonly static uint s_fosPickFoldersBitFlag = (uint) s_windowsFormsAssembly
.GetType("System.Windows.Forms.FileDialogNative+FOS")
.GetField("FOS_PICKFOLDERS")
.GetValue(null);
private readonly static ConstructorInfo s_vistaDialogEventsConstructorInfo = s_windowsFormsAssembly
.GetType("System.Windows.Forms.FileDialog+VistaDialogEvents")
.GetConstructor(c_flags, null, new[] { typeof(FileDialog) }, null);
private readonly static MethodInfo s_adviseMethodInfo = s_iFileDialogType.GetMethod("Advise");
private readonly static MethodInfo s_unAdviseMethodInfo = s_iFileDialogType.GetMethod("Unadvise");
private readonly static MethodInfo s_showMethodInfo = s_iFileDialogType.GetMethod("Show");
public static ShowDialogResult Show(IntPtr ownerHandle, string initialDirectory, string title) {
var openFileDialog = new OpenFileDialog {
AddExtension = false,
CheckFileExists = false,
DereferenceLinks = true,
Filter = c_foldersFilter,
InitialDirectory = initialDirectory,
Multiselect = false,
Title = title
};
var iFileDialog = s_createVistaDialogMethodInfo.Invoke(openFileDialog, new object[] { });
s_onBeforeVistaDialogMethodInfo.Invoke(openFileDialog, new[] { iFileDialog });
s_setOptionsMethodInfo.Invoke(iFileDialog, new object[] { (uint) s_getOptionsMethodInfo.Invoke(openFileDialog, new object[] { }) | s_fosPickFoldersBitFlag });
var adviseParametersWithOutputConnectionToken = new[] { s_vistaDialogEventsConstructorInfo.Invoke(new object[] { openFileDialog }), 0U };
s_adviseMethodInfo.Invoke(iFileDialog, adviseParametersWithOutputConnectionToken);
try {
int retVal = (int) s_showMethodInfo.Invoke(iFileDialog, new object[] { ownerHandle });
return new ShowDialogResult {
Result = retVal == 0,
FileName = openFileDialog.FileName
};
}
finally {
s_unAdviseMethodInfo.Invoke(iFileDialog, new[] { adviseParametersWithOutputConnectionToken[1] });
}
}
}
//Wrap an IWin32Window around an IntPtr
private class WindowWrapper : IWin32Window {
private readonly IntPtr _handle;
public WindowWrapper(IntPtr handle) { _handle = handle; }
public IntPtr Handle { get { return _handle; } }
}
}
}

Il est utilisé comme dans un Formulaire Windows:

var dialog = new FolderSelectDialog {
InitialDirectory = musicFolderTextBox.Text,
Title = "Select a folder to import music from"
};
if (dialog.Show(Handle)) {
musicFolderTextBox.Text = dialog.FileName;
}

Vous pouvez bien sûr jouer avec ses options, et quelles sont les propriétés qu'il expose. Par exemple, il permet la sélection multiple dans le Vista-style boîte de dialogue.

Deuxième Solution

Simon Mourier ont donné une réponse qui montre comment faire exactement le même travail à l'aide de l'interopérabilité à l'encontre de l'API Windows directement, même si sa version devrait être complétée d'utiliser l'ancienne boîte de dialogue style de si dans une version antérieure de Windows. Malheureusement, je n'avais pas trouvé son post, mais lorsque j'ai travaillé jusqu'à ma solution. Nommez votre poison!

Sur Vista, vous pouvez utiliser IFileDialog avec FOS_PICKFOLDERS option. Que va provoquer l'affichage de OpenFileDialog fenêtre où vous pouvez sélectionner des dossiers:

var frm = (IFileDialog)(new FileOpenDialogRCW());
uint options;
frm.GetOptions(out options);
options |= FOS_PICKFOLDERS;
frm.SetOptions(options);
if (frm.Show(owner.Handle) == S_OK) {
IShellItem shellItem;
frm.GetResult(out shellItem);
IntPtr pszString;
shellItem.GetDisplayName(SIGDN_FILESYSPATH, out pszString);
this.Folder = Marshal.PtrToStringAuto(pszString);
}

Pour les plus anciennes de Windows, vous pouvez toujours recourir à l'astuce avec la sélection de n'importe quel fichier dans le dossier.

Exemple de travail qui fonctionne sur .NET Framework 2.0 et plus tard peut être trouvé ici.

La Ookii les boîtes de dialogue de WPF bibliothèque dispose d'une classe qui fournit une mise en œuvre d'un dossier de dialogue du navigateur pour WPF.

https://github.com/caioproiete/ookii-dialogs-wpf

Il y a aussi une version qui fonctionne avec Windows Forms.