¿Cómo se configura un OpenFileDialog para seleccionar carpetas?

251

En VS .NET, cuando selecciona una carpeta para un proyecto, se muestra un cuadro de diálogo que parece un OpenFileDialog o SaveFileDialog, pero está configurado para aceptar solo carpetas. Desde que vi esto, he querido saber cómo se hace. Conozco el FolderBrowserDialog, pero nunca me ha gustado ese diálogo. Comienza demasiado pequeño y no me permite aprovechar la posibilidad de escribir una ruta.

Ahora estoy casi seguro de que no hay una forma de hacerlo desde .NET, pero también tengo curiosidad por saber cómo hacerlo desde un código no administrado. A menos que se vuelva a implementar completamente el diálogo desde cero, ¿cómo se modifica el diálogo para que tenga este comportamiento?

También me gustaría reiterar que conozco el FolderBrowserDialog, pero a veces no me gusta usarlo, además de tener una curiosidad genuina sobre cómo configurar un diálogo de esta manera. Decirme que solo use el FolderBrowserDialog me ayuda a mantener una experiencia de interfaz de usuario coherente, pero no satisface mi curiosidad, por lo que no contará como una respuesta.

Tampoco es algo específico de Vista; He estado viendo este diálogo desde VS .NET 2003, por lo que es factible en Win2k y WinXP. Esto es menos una pregunta de "Quiero saber la forma correcta de hacer esto" y más de "Tengo curiosidad acerca de esto desde la primera vez que quise hacerlo en VS 2003". Entiendo que el diálogo de archivo de Vista tiene una opción para hacer esto, pero ha estado funcionando en XP, así que sé que hicieron algo para que funcione. Las respuestas específicas de Vista no son respuestas, porque Vista no existe en el contexto de la pregunta.

Actualización: Me estoy aceptando la respuesta de Scott Wisniewski, ya que viene con una muestra de trabajo, pero creo que merece crédito por Serge apunta a la personalización de diálogo (que es ciertamente desagradable de .NET pero hace el trabajo) y Mark Ransom para averiguar que la EM probablemente rodó un cuadro de diálogo personalizado para esta tarea.

OwenP
fuente
77
solo una solución simple de codeproject codeproject.com/Articles/44914/… [La clave para hacer que OpenFileDialog seleccione archivos y carpetas es establecer las propiedades ValidateNames y CheckFileExists en false (dialog.ValidateNames = false; dialog.CheckFileExists = false) y establezca FileName en alguna palabra clave especial para asegurarse de que se seleccionen las carpetas (dialog.FileName = "Folder Selection";).]
Riju
3
Envíe esto como respuesta, hizo el trabajo para mi proyecto.
CigarDoug
@Riju se dialog.FileName = "Folder Selection"supone que está dialog.FileName = "Folder Selection."con el período final? de todos modos no puedo hacer que funcione en powershell con el segundo clic de "Abrir" de cualquier manera. Sigue diciendo que el archivo no se encuentra, a pesar de que CheckFileExists es supuestamente falso
ComradeJoecool
nvm, en la configuración dialog.CheckFileExists = 0de
PowerShell
¿Has probado los cuadros de diálogo de Ookii para WPF ?
C. Augusto Proiete

Respuestas:

57

Tengo un cuadro de diálogo que escribí llamado cuadro de diálogo OpenFileOrFolder que le permite abrir una carpeta o un archivo.

Si establece su valor AcceptFiles en falso, entonces solo funciona en el modo aceptar carpeta.

Puedes descargar la fuente de GitHub aquí

Scott Wisniewski
fuente
44
Muy interesante, y definitivamente tan complicado como había imaginado. ¿Alguna posibilidad de anotarlo y señalar lo que hace? Esto, junto con otros comentarios, me lleva a creer que MS probablemente acaba de lanzar su propio diálogo.
OwenP
1
Recibo el siguiente error cuando intento crear su solución ... desafortunadamente, C ++ no es uno de mis puntos fuertes ... El error 1 no puede abrir el archivo de inclusión 'afxres.h'.
Ignacio Soler Garcia
1
@SoMoS, y otros con el mismo problema: en el archivo WindowsFormsApplication1.csproj edite la línea 100 para que coincida con su configuración. En mi caso, tuve que cambiar "9.0" a "10.0" (dos veces) y eliminar "(x86)" (dos veces).
RenniePet
2
Descargué el código (zip) y encontré el archivo .h (C) y lo compilé con un error como no se puede abrir el archivo de inclusión 'sal.h'.
Lei Yang el
2
¡Esta solución tampoco funciona en VS2010 y VS2017!
AleX_
49

Puede usar FolderBrowserDialogEx , una derivada reutilizable del FolderBrowserDialog incorporado. Este le permite escribir una ruta, incluso una ruta UNC. También puede buscar computadoras o impresoras con él. Funciona igual que el FBD incorporado, pero ... mejor.

(EDITAR: debería haber señalado que este cuadro de diálogo se puede configurar para seleccionar archivos o carpetas).

Código fuente completo (un módulo C # corto). Gratis. Licencia de MS-Public.

Código para usarlo:

var dlg1 = new Ionic.Utils.FolderBrowserDialogEx();
dlg1.Description = "Select a folder to extract to:";
dlg1.ShowNewFolderButton = true;
dlg1.ShowEditBox = true;
//dlg1.NewStyle = false;
dlg1.SelectedPath = txtExtractDirectory.Text;
dlg1.ShowFullPathInEditBox = true;
dlg1.RootFolder = System.Environment.SpecialFolder.MyComputer;

// Show the FolderBrowserDialog.
DialogResult result = dlg1.ShowDialog();
if (result == DialogResult.OK)
{
    txtExtractDirectory.Text = dlg1.SelectedPath;
}
Cheeso
fuente
77
Lo siento si me ofendí, es frustrante hacer una pregunta y deletrear "Quiero esta cosa específica, no estas otras cosas" y que la gente sugiera alegremente lo no solicitado. Quería un diálogo de navegador de archivos, no un diálogo de navegador de carpetas.
OwenP
15
La forma en que está formulada la pregunta, me parece que está pidiendo un cuadro de diálogo de selección de carpetas, ¿no es así? De todos modos, esto es exactamente lo que estaba buscando +1
Tim
Definitivamente la mejor respuesta hasta ahora
Vasil Popov
1
Eso no cambia el hecho de que la respuesta sigue siendo una respuesta de solo enlace. Mostrar cómo usar el código alojado en un recurso fuera del sitio deja de ser útil cuando ese enlace también deja de estar disponible temporal o permanentemente. Las reglas están ahí por una razón, y esta contribución está en conflicto con esas reglas.
Inspectable
1
Miré esta respuesta, y aparentemente no hace referencia a un recurso externo. Entonces, "cualquier otra respuesta" está claramente equivocada. Si sientes que estoy exagerando, tal vez deberías plantear un problema en meta para discutir las reglas. No lo haré Solo los aplicaré.
Inspectable
48

Existe el paquete de códigos API de Windows. Tiene muchas cosas relacionadas con el shell, incluida la CommonOpenFileDialogclase (en el Microsoft.WindowsAPICodePack.Dialogsespacio de nombres). Esta es la solución perfecta: el diálogo abierto habitual con solo carpetas mostradas.

Aquí hay un ejemplo de cómo usarlo:

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

Desafortunadamente, Microsoft ya no envía este paquete, pero varias personas han subido binarios de forma no oficial a NuGet. Un ejemplo se puede encontrar aquí . Este paquete es solo el material específico del shell. Si lo necesita, el mismo usuario tiene varios otros paquetes que ofrecen más funciones presentes en el paquete original.

Ken Wayne VanderLinde
fuente
1
No sabía que esto estaba en el paquete de códigos API de Windows, gracias por señalar esto.
Patrick Klug
10
La clase CommonOpenFileDialog solo existe en Windows Vista o posterior, por lo que arrojará una excepción en los sistemas operativos más antiguos
Rachel
1
¿Puede decirme cómo hacer referencia al paquete de códigos de API de Windows?
Jeff
1
La galería de archivos ha sido retirada. , o eso dice el enlace ... ¿Podría ser este el nuevo lugar para ello?
Predeterminado
3
Por cierto, la clase CommonOpenFileDialog está en el espacio de nombres Microsoft.WindowsAPICodePack.Dialogs (me llevó un tiempo encontrarlo).
morgb
35

El paquete Ookii.Dialogs contiene un contenedor administrado alrededor del nuevo cuadro de diálogo del navegador de carpetas (estilo Vista). También se degrada con gracia en los sistemas operativos más antiguos.

Christian Klauser
fuente
2
¡Genial, es de código abierto con licencia de estilo BSD!
Roman Starkov
77
El único problema es que no me dejaré usar el perfil del cliente .NET Framework como objetivo.
Kugel
2
Muy buena solución. Esta es, en mi opinión, la mejor respuesta. Exactamente lo que estaba buscando desde hace 3 años.
Samuel
1
Otro problema con esta solución: no permite al usuario pegar una ruta inexistente. Una menor, comparativamente, pero sigue siendo una pena.
Roman Starkov
1
La mejor respuesta práctica para aquellos que desean un OpenFileDialogdiálogo de carpeta de estilo.
aqua
27

Es mejor usar el FolderBrowserDialog para eso.

using (FolderBrowserDialog dlg = new FolderBrowserDialog())
{
    dlg.Description = "Select a folder";
    if (dlg.ShowDialog() == DialogResult.OK)
    {
        MessageBox.Show("You selected: " + dlg.SelectedPath);
    }
}
Ryan Farley
fuente
99
Soy consciente de que es mejor usar un FolderBrowserDialog. Tengo curiosidad de cómo se hizo independientemente. El FolderBrowserDialog apesta de muchas maneras de todos modos; Incluso en Vista no tiene la barra de lugares. Es curioso cómo, si es mejor, MS lo ha evitado en 3 versiones VS hasta ahora.
OwenP
24
FolderBrowserDialog tiene muchos problemas de usabilidad. No consideraría realmente ponerlo en una aplicación. Vea mi publicación para un diálogo que tiene una usabilidad mucho mejor
Scott Wisniewski
66
FolderBrowserDialog no permite: - escribir / pegar rutas completas en el campo de texto en la parte inferior - usar la barra "Enlaces favoritos" en Vista - usar Buscar en Vista
decasteljau
89
FolderBrowserDialog es una parte de la interfaz de usuario realmente horrible.
mackenir
32
En serio, gente, POR FAVOR, dejen de poner este molesto diálogo en sus aplicaciones. Tiene una interfaz de usuario MUY MALA como se destacó en los comentarios anteriores.
Roman Starkov
23

Después de horas de búsqueda, encontré esta respuesta de leetNightShade a una solución que funcionaba .

Creo que hay tres cosas que hacen que esta solución sea mucho mejor que todas las demás.

  1. Es simple de usar. Solo requiere que incluya dos archivos (que se pueden combinar en uno de todos modos) en su proyecto.
  2. Recurre al FolderBrowserDialog estándar cuando se usa en sistemas XP o anteriores.
  3. El autor otorga permiso para usar el código para cualquier propósito que considere adecuado.

    No hay licencia como tal, ya que es libre de tomar y hacer con el código lo que quiera.

Descargue el código aquí .

Alex Essilfie
fuente
@MattDavis: Confirmé que funciona en .NET Framework 4.0 (tanto Standard como Client Profile). Solo asegúrese de tener FolderSelectDialog.cs y Reflector.cs agregados a su proyecto. Sin embargo, una cosa ... ¿estás ejecutando en Windows 8? Lo probé en una computadora Win7.
Alex Essilfie
@ Alex Essilfie, tienes razón. Debo haber hecho algo mal al incluirlo en mi proyecto. Eliminaré mi comentario anterior para mayor claridad.
Matt Davis
Revisé varias opciones y pensé que esta era la mejor. Recomiendo
Jaded
Trabajó en Windows 10 para mí. Buena solución simple
David Wilton
tengo que respetar la conmutación por error en sistemas más antiguos
Mike M
17

Exact Audio Copy funciona de esta manera en Windows XP. Se muestra el cuadro de diálogo de apertura de archivo estándar, pero el campo de nombre de archivo contiene el texto "Se ignorará el nombre de archivo".

Solo adivino aquí, pero sospecho que la cadena se inyecta en el control de edición del cuadro combinado cada vez que se realiza un cambio significativo en el diálogo. Mientras el campo no esté en blanco, y los indicadores de diálogo estén configurados para no verificar la existencia del archivo, el diálogo puede cerrarse normalmente.

Editar: esto es mucho más fácil de lo que pensaba. Aquí está el código en C ++ / MFC, puede traducirlo al entorno de su elección.

CFileDialog dlg(true, NULL, "Filename will be ignored", OFN_HIDEREADONLY | OFN_NOVALIDATE | OFN_PATHMUSTEXIST | OFN_READONLY, NULL, this);
dlg.DoModal();

Edición 2: Esta debería ser la traducción a C #, pero no soy fluido en C #, así que no me disparen si no funciona.

OpenFileDialog openFileDialog1 = new OpenFileDialog();

openFileDialog1.FileName = "Filename will be ignored";
openFileDialog1.CheckPathExists = true;
openFileDialog1.ShowReadOnly = false;
openFileDialog1.ReadOnlyChecked = true;
openFileDialog1.CheckFileExists = false;
openFileDialog1.ValidateNames = false;

if(openFileDialog1.ShowDialog() == DialogResult.OK)
{
    // openFileDialog1.FileName should contain the folder and a dummy filename
}

Edición 3: Finalmente miré el diálogo real en cuestión, en Visual Studio 2005 (no tenía acceso a él antes). ¡No es el cuadro de diálogo estándar para abrir archivos! Si inspecciona las ventanas en Spy ++ y las compara con un archivo estándar abierto, verá que la estructura y los nombres de clase no coinciden. Cuando observa de cerca, también puede detectar algunas diferencias entre el contenido de los cuadros de diálogo. Mi conclusión es que Microsoft reemplazó por completo el cuadro de diálogo estándar en Visual Studio para darle esta capacidad. Mi solución o algo similar estará lo más cerca posible, a menos que esté dispuesto a codificar la suya desde cero.

Mark Ransom
fuente
17

OK, déjenme intentar conectar el primer punto ;-) Jugar un poco con Spy ++ o Winspector muestra que el cuadro de texto Carpeta en la ubicación del proyecto VS es una personalización del diálogo estándar. No es el mismo campo que el cuadro de texto del nombre de archivo en un cuadro de diálogo de archivo estándar como el del Bloc de notas.

A partir de ahí, supongo, VS oculta los cuadros de texto / cuadros combinados de nombre de archivo y tipo de archivo y utiliza una plantilla de diálogo personalizada para agregar su propia parte en la parte inferior del cuadro de diálogo.

EDITAR: Aquí hay un ejemplo de dicha personalización y cómo hacerlo (en Win32. No .NET):

m_ofn es la estructura OPENFILENAME que subyace al diálogo del archivo. Agregue estas 2 líneas:

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

donde IDD_FILEDIALOG_IMPORTXLIFF es una plantilla de diálogo personalizada que se agregará en la parte inferior del diálogo. Vea la parte en rojo a continuación. (fuente: apptranslator.com )texto alternativo

En este caso, la parte personalizada es solo una etiqueta + un hipervínculo, pero podría ser cualquier diálogo. Podría contener un botón Aceptar que nos permitiría validar la selección de solo carpeta.

Pero cómo nos desharíamos de algunos de los controles en la parte estándar del diálogo, no lo sé.

Más detalles en este artículo de MSDN .

Serge Wautier
fuente
1
Eso suena como algunas explicaciones que he escuchado en el pasado, pero nunca he visto una demostración del concepto. ¿Hay tutoriales en la documentación de MSDN acerca de hacerlo?
OwenP
10

Puede subclasificar el cuadro de diálogo del archivo y obtener acceso a todos sus controles. Cada uno tiene un identificador que se puede utilizar para obtener su identificador de ventana. Luego puede mostrarlos y ocultarlos, obtener mensajes de ellos sobre cambios en la selección, etc. Todo depende de cuánto esfuerzo desee realizar.

Hicimos el nuestro usando el soporte de clase WTL y personalizamos el diálogo de archivo para incluir una barra de lugares personalizada y vistas COM de complemento.

MSDN proporciona información sobre cómo hacer esto usando Win32, este artículo de CodeProject incluye un ejemplo y este artículo de CodeProject proporciona un ejemplo de .NET .

Jeff Yates
fuente
10

Puedes usar un código como este

  • El filtro es ocultar archivos
  • El nombre del archivo es ocultar primer texto

Para ocultar el cuadro de texto avanzado para el nombre de archivo, debe mirar OpenFileDialogEx

El código:

{
    openFileDialog2.FileName = "\r";
    openFileDialog1.Filter = "folders|*.neverseenthisfile";
    openFileDialog1.CheckFileExists = false;
    openFileDialog1.CheckPathExists = false;
}
Avram
fuente
Simple y es lo que necesito para Windows 7+
Hao Nguyen
También se requiere OFN_NOVALIDATE en las banderas
Goblin Alchemist el
5

¿Asumo que estás en Vista usando VS2008? En ese caso, creo que la opción FOS_PICKFOLDERS se está utilizando al llamar al diálogo de archivo de Vista IFileDialog . Me temo que en el código .NET esto implicaría un montón de código de interoperabilidad P / Invoke retorcido para que funcione.

Duncan Smart
fuente
1
Específico de Vista; Vi esto por primera vez en VS 2003 en Windows XP.
OwenP
2

Primera solución

Desarrollé esto como una versión limpia del cuadro de diálogo de selección de carpeta estilo .NET Win 7 de Bill Seddon de lyquidity.com (no tengo afiliación). (Me enteré de su código de otra respuesta en esta página ). Escribí la mía porque su solución requiere una clase de reflexión adicional que no es necesaria para este propósito específico, usa control de flujo basado en excepciones, no almacena en caché los resultados de sus llamadas de reflexión. Tenga en cuenta que la VistaDialogclase estática anidada es para que sus variables de reflexión estática no intenten rellenarse si Shownunca se llama al método. Vuelve al diálogo anterior a Vista si no está en una versión de Windows lo suficientemente alta. Debería funcionar en Windows 7, 8, 9, 10 y superior (teóricamente).

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; } }
        }
    }
}

Se usa así en un formulario de Windows:

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

Por supuesto, puede jugar con sus opciones y las propiedades que expone. Por ejemplo, permite la selección múltiple en el cuadro de diálogo de estilo Vista.

Segunda solución

Simon Mourier dio una respuesta que muestra cómo hacer exactamente el mismo trabajo usando interoperabilidad directamente con la API de Windows, aunque su versión tendría que complementarse para usar el diálogo de estilo anterior si se trata de una versión anterior de Windows. Desafortunadamente, aún no había encontrado su publicación cuando encontré mi solución. ¡Nombra tu veneno!

ErikE
fuente
Ejemplo de uso similar para llamar a este cuadro de diálogo fino como un cuadro de diálogo (por ejemplo, desde aplicaciones tipo consola) con un asa vacía: se compila de inmediato: var dialog = new FolderSelectDialog {InitialDirectory = "C: \\", Title = "Seleccione un carpeta para importar música desde "}; if (dialog.Show ()) {string myFolder = dialog.FileName; }
Philm
Nota: Mi ejemplo de uso como comentario es difícil de leer, por lo tanto: Cambio más importante al "ejemplo" de uso original: Use una coma entre InitialDirectory y Title ..
Philm
1

Pruebe este de Codeproject (crédito a Nitron):

Creo que es el mismo diálogo del que estás hablando, ¿tal vez sería útil si agregas una captura de pantalla?

bool GetFolder(std::string& folderpath, const char* szCaption=NULL, HWND hOwner=NULL)
{
    bool retVal = false;

    // The BROWSEINFO struct tells the shell how it should display the dialog.
    BROWSEINFO bi;
    memset(&bi, 0, sizeof(bi));

    bi.ulFlags   = BIF_USENEWUI;
    bi.hwndOwner = hOwner;
    bi.lpszTitle = szCaption;

    // must call this if using BIF_USENEWUI
    ::OleInitialize(NULL);

    // Show the dialog and get the itemIDList for the selected folder.
    LPITEMIDLIST pIDL = ::SHBrowseForFolder(&bi);

    if(pIDL != NULL)
    {
        // Create a buffer to store the path, then get the path.
        char buffer[_MAX_PATH] = {'\0'};
        if(::SHGetPathFromIDList(pIDL, buffer) != 0)
        {
            // Set the string value.
            folderpath = buffer;
            retVal = true;
        }       

        // free the item id list
        CoTaskMemFree(pIDL);
    }

    ::OleUninitialize();

    return retVal;
}
demoncodemonkey
fuente
images.google.com/… Investigue cuando no esté seguro. Describí lo que quería, y FolderBrowserDialog ya ha sido descalificado como respuesta.
OwenP
"Conozco el FolderBrowserDialog, pero nunca me ha gustado ese diálogo. Comienza demasiado pequeño y no me permite aprovechar la posibilidad de escribir una ruta". Investigue usted mismo: puede escribir un camino allí. De todos modos, creo que es una pregunta un poco ambigua, así que buena suerte con ella.
demoncodemonkey 03 de
@demoncodemonkey: no puede escribir una parte de la ruta y luego navegar hasta el objetivo que desee. De lejos, no es tan conveniente como las opciones que ofrece FileOpenDialog.
Treb
1

En Vista puede usar IFileDialog con el conjunto de opciones FOS_PICKFOLDERS. Eso provocará la visualización de una ventana similar a OpenFileDialog donde puede seleccionar carpetas:

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);
}

Para Windows más antiguos, siempre puede recurrir al truco con la selección de cualquier archivo en la carpeta.

Puede encontrar un ejemplo de trabajo que funciona en .NET Framework 2.0 y versiones posteriores aquí .

Josip Medved
fuente
1

Puedes usar un código como este

El filtro es una cadena vacía. El nombre del archivo es AnyName pero no está en blanco.

        openFileDialog.FileName = "AnyFile";
        openFileDialog.Filter = string.Empty;
        openFileDialog.CheckFileExists = false;
        openFileDialog.CheckPathExists = false;
lantran
fuente
66
Sé que esta es una publicación antigua, pero por el bien de cualquiera que quiera probar esto, en realidad no funciona a menos que el directorio que desea abrir no tenga absolutamente ningún directorio secundario. Entonces, si quiero permitir que mi usuario busque una carpeta y la seleccione, y complete la ruta de la carpeta en algún cuadro de texto, el usuario nunca podría seleccionar C: \ SomeParentDir si el directorio C: \ SomeParentDir \ SomeChildDir existe, porque al seleccionar "Abrir "simplemente te lleva al directorio secundario.
Jim
Buen intento ... pero esto da como resultado una interfaz de usuario terrible ya que "AnyFile" en el cuadro de texto solo está esperando que el usuario anule su texto ... aparte de eso, el usuario también puede seleccionar archivos, no lo suficientemente bueno. pero buen intento ..
GY
-1

Sé que la pregunta era sobre la configuración, OpenFileDialogpero al ver que Google me trajo aquí, también puedo señalar que si SOLO está buscando carpetas, debería usar un FolderBrowserDialogEn lugar de lo que responde otra pregunta SO a continuación

¿Cómo especificar la ruta usando el diálogo de abrir archivo en vb.net?

AltF4_
fuente
Engañoso. 1) Es no la única opción; 2) No es una buena opción en la mayoría de los casos; Aún así, requiere el menor código, intercambiado por más tiempo del usuario final dedicado.
Meow Cat 2012