Como você configura um OpenFileDialog para selecionar pastas?

No VS .NET, quando você seleciona uma pasta para um projeto, uma caixa de diálogo que se parece com um OpenFileDialog ou SaveFileDialog é exibida, mas é configurada para aceitar apenas pastas. Desde que eu vi isso, eu queria saber como é feito. Estou ciente do FolderBrowserDialog, mas nunca gostei muito dessa caixa de diálogo. Começa muito pequeno e não me permite tirar vantagem de poder digitar um caminho.

Agora estou quase certo de que não existe uma maneira de fazer isso no .NET, mas também estou curioso em saber como você faz isso a partir de código não gerenciado. Além de reimplementar completamente a caixa de diálogo do zero, como você modifica a caixa de diálogo para ter esse comportamento?

Também gostaria de reafirmar que estou ciente do FolderBrowserDialog, mas às vezes não gosto de usá-lo, além de estar realmente curioso para saber como configurar um diálogo dessa maneira. Dizer-me para usar apenas o FolderBrowserDialog me ajuda a manter uma experiência de interface do usuário consistente, mas não satisfaz minha curiosidade, portanto não conta como resposta.

Também não é algo específico do Vista; Eu tenho visto esse diálogo desde o VS .NET 2003, por isso é possível no Win2k e WinXP. Isso é menos uma pergunta "Eu quero saber a maneira correta de fazer isso" e mais uma pergunta "Eu tenho curiosidade sobre isso desde que eu queria fazer isso no VS 2003". Entendo que a caixa de diálogo de arquivos do Vista tem uma opção para fazer isso, mas ele está funcionando no XP, então eu sei que eles fizeram algo para fazê-lo funcionar. As respostas específicas do Vista não são respostas, porque o Vista não existe no contexto da pergunta.

Atualização: estou aceitando a resposta de Scott Wisniewski porque ela vem com uma amostra funcional, mas acho que Serge merece crédito por apontar para a personalização da caixa de diálogo (que é reconhecidamente desagradável do .NET, mas sim o trabalho) e Mark Ransom para descobrir que MS provavelmente rolou uma caixa de diálogo personalizada para esta tarefa.

Eu tenho uma caixa de diálogo que escrevi chamada OpenFileOrFolder, que permite abrir uma pasta ou um arquivo.

Se você definir seu valor AcceptFiles como false, ele funcionará apenas no modo de pasta de aceitação.

Você pode baixar a fonte do GitHub aqui

Você pode usar o FolderBrowserDialogEx - um derivado reutilizável do FolderBrowserDialog interno. Este permite que você digite um caminho, mesmo um caminho UNC. Você também pode procurar computadores ou impressoras com ele. Funciona exatamente como o FBD embutido, mas ... melhor.

(Edição: Eu deveria ter apontado que esta caixa de diálogo pode ser configurada para selecionar arquivos ou pastas.)

Código fonte completo (um pequeno módulo C #). Livre. Licença MS-Public.

Código para usá-lo:

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

Existe o pacote de códigos da API do Windows. Tem muitas coisas relacionadas ao shell, incluindo a CommonOpenFileDialogclasse (noMicrosoft.WindowsAPICodePack.Dialogs espaço para nome). Essa é a solução perfeita - a caixa de diálogo aberta usual, com apenas as pastas exibidas.

Aqui está um exemplo de como usá-lo:

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

Infelizmente, a Microsoft não envia mais este pacote, mas várias pessoas enviaram binários não oficialmente para o NuGet. Um exemplo pode ser encontrado aqui . Este pacote é apenas o material específico do shell. Caso você precise, o mesmo usuário possui vários outros pacotes que oferecem mais funcionalidades presentes no pacote original.

O pacote Ookii.Dialogs contém um wrapper gerenciado em torno da nova caixa de diálogo do navegador de pastas (estilo Vista). Ele também é degradado normalmente em sistemas operacionais mais antigos.

• Diálogos Ookii para WPF visando o .NET 4.5 e disponível no NuGet
• Diálogos Ookii para Windows Forms visando o .NET 4.5 e disponível no NuGet

Melhor usar o FolderBrowserDialog para isso.

using (FolderBrowserDialog dlg = new FolderBrowserDialog())
{
    dlg.Description = "Select a folder";
    if (dlg.ShowDialog() == DialogResult.OK)
    {
        MessageBox.Show("You selected: " + dlg.SelectedPath);
    }
}

Após horas de pesquisa, encontrei esta resposta por leetNightShade para uma solução funcional .

Acredito que há três coisas que tornam essa solução muito melhor que todas as outras.

1. É simples de usar. Requer apenas que você inclua dois arquivos (que podem ser combinados com um de qualquer maneira) em seu projeto.
2. Ele volta ao padrão FolderBrowserDialog quando usado em sistemas XP ou mais antigos.
3. O autor concede permissão para usar o código para qualquer finalidade que você considerar adequada.

   Não há licença, pois você é livre para pegar e fazer com o código o que quiser.

Faça o download do código aqui .

Cópia de áudio exata funciona dessa maneira no Windows XP. A caixa de diálogo padrão de abertura de arquivo é exibida, mas o campo nome do arquivo contém o texto "Nome do arquivo será ignorado".

Apenas adivinhando aqui, mas suspeito que a string seja injetada no controle de edição da caixa de combinação toda vez que uma alteração significativa for feita na caixa de diálogo. Enquanto o campo não estiver em branco e os sinalizadores da caixa de diálogo estiverem configurados para não verificar a existência do arquivo, a caixa de diálogo poderá ser fechada normalmente.

Edit: isso é muito mais fácil do que eu pensava. Aqui está o código em C ++ / MFC, você pode traduzi-lo para o ambiente de sua escolha.

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

Edit 2: Esta deve ser a tradução para C #, mas eu não sou fluente em C #, então não atire em mim se não funcionar.

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
}

Edição 3: Finalmente, olhei para a caixa de diálogo real em questão, no Visual Studio 2005 (não tive acesso a ela anteriormente). Não é a caixa de diálogo padrão para abrir arquivos! Se você inspecionar as janelas no Spy ++ e compará-las com um arquivo padrão aberto, verá que os nomes de estrutura e classe não coincidem. Quando você olha atentamente, também pode identificar algumas diferenças entre o conteúdo das caixas de diálogo. Minha conclusão é que a Microsoft substituiu completamente a caixa de diálogo padrão no Visual Studio para oferecer esse recurso. Minha solução ou algo semelhante será o mais próximo possível, a menos que você esteja disposto a codificar o seu a partir do zero.

OK, deixe-me tentar conectar o primeiro ponto ;-) Jogar um pouco com o Spy ++ ou Winspector mostra que a caixa de texto Pasta no Local do Projeto VS é uma personalização da caixa de diálogo padrão. Não é o mesmo campo que a caixa de texto do nome do arquivo em uma caixa de diálogo de arquivo padrão, como a do Bloco de Notas.

A partir daí, eu acho que o VS oculta o nome do arquivo e as caixas de texto / caixas de combinação e usa um modelo de caixa de diálogo personalizado para adicionar sua própria parte na parte inferior da caixa de diálogo.

EDIT: Aqui está um exemplo de tal personalização e como fazê-lo (no Win32. Não no .NET):

m_ofn é a estrutura OPENFILENAME subjacente à caixa de diálogo do arquivo. Adicione estas 2 linhas:

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

em que IDD_FILEDIALOG_IMPORTXLIFF é um modelo de caixa de diálogo personalizado que será adicionado na parte inferior da caixa de diálogo. Veja a peça em vermelho abaixo. _{(fonte: apptranslator.com )}

Nesse caso, a peça personalizada é apenas um rótulo + um hiperlink, mas pode ser qualquer caixa de diálogo. Ele poderia conter um botão OK que permitiria validar somente a seleção de pastas.

Mas como nos livraríamos de alguns dos controles na parte padrão da caixa de diálogo, eu não sei.

Mais detalhes neste artigo do MSDN .

Você pode subclassificar a caixa de diálogo do arquivo e obter acesso a todos os seus controles. Cada um possui um identificador que pode ser usado para obter seu identificador de janela. Você pode então mostrá-los e ocultá-los, receber mensagens sobre mudanças na seleção, etc. etc. Tudo depende de quanto esforço você deseja fazer.

Fizemos o nosso usando o suporte à classe WTL e personalizamos a caixa de diálogo de arquivo para incluir uma barra de locais personalizada e visualizações COM de plug-in.

O MSDN fornece informações sobre como fazer isso usando o Win32, este artigo do CodeProject inclui um exemplo e este artigo do CodeProject fornece um exemplo do .NET .

Você pode usar código como este

• O filtro é ocultar arquivos
  
• O nome do arquivo é ocultar o primeiro texto
  

Para ocultar avançado da caixa de texto do nome do arquivo, é necessário olhar para OpenFileDialogEx

O código:

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

Presumo que você esteja no Vista usando o VS2008? Nesse caso, acho que a opção FOS_PICKFOLDERS está sendo usada ao chamar a caixa de diálogo do arquivo do Vista IFileDialog . Receio que, no código .NET, isso envolva bastante código de interoperabilidade P / Invoke para funcionar.

Primeira solução

Eu desenvolvi isso como uma versão limpa da caixa de diálogo de seleção de pastas no estilo .NET Win 7 de Bill Seddon, do lyquidity.com (não tenho afiliação). (Aprendi sobre o código dele com outra resposta nesta página ). Eu escrevi o meu próprio porque a solução dele requer uma classe Reflection adicional que não é necessária para esse objetivo focado, usa controle de fluxo baseado em exceção, não armazena em cache os resultados de suas chamadas de reflexão. Observe que a VistaDialogclasse estática aninhada é para que suas variáveis ​​de reflexão estática não tentem ser preenchidas se o Showmétodo nunca for chamado. Ele volta à caixa de diálogo anterior ao Vista, se não estiver em uma versão do Windows suficientemente alta. Deve funcionar no Windows 7, 8, 9, 10 e superior (teoricamente).

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

É usado assim em um formulário do Windows:

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

É claro que você pode brincar com suas opções e quais propriedades ele expõe. Por exemplo, ele permite a seleção múltipla na caixa de diálogo estilo Vista.

Segunda solução

Simon Mourier deu uma resposta que mostra como fazer exatamente o mesmo trabalho usando a interoperabilidade diretamente com a API do Windows, embora sua versão precise ser complementada para usar a caixa de diálogo de estilo mais antiga se estiver em uma versão mais antiga do Windows. Infelizmente, ainda não encontrei o post dele quando desenvolvi minha solução. Nomeie seu veneno!

Experimente este da Codeproject (crédito para Nitron):

Eu acho que é a mesma caixa de diálogo que você está falando - talvez ajude se você adicionar uma captura de tela?

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

No Vista, você pode usar o IFileDialog com o conjunto de opções FOS_PICKFOLDERS. Isso fará com que a janela do OpenFileDialog seja exibida, onde você pode selecionar pastas:

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 mais antigo, você sempre pode recorrer a truques ao selecionar qualquer arquivo na pasta.

Exemplo de trabalho que funciona no .NET Framework 2.0 e posterior pode ser encontrado aqui .

Você pode usar código como este

O filtro é uma sequência vazia. O nome do arquivo é AnyName, mas não está em branco

        openFileDialog.FileName = "AnyFile";
        openFileDialog.Filter = string.Empty;
        openFileDialog.CheckFileExists = false;
        openFileDialog.CheckPathExists = false;

A biblioteca Ookii Dialogs for WPF possui uma classe que fornece uma implementação de uma caixa de diálogo do navegador de pastas para o WPF.

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

Há também uma versão que funciona com o Windows Forms .

Eu sei que a pergunta estava na configuração de, OpenFileDialogmas, como o Google me trouxe aqui, posso também salientar que, se você estiver procurando SOMENTE por pastas, deverá usar um FolderBrowserDialogEm vez disso, conforme respondido por outra pergunta SO abaixo.

Como especificar o caminho usando o diálogo de arquivo aberto no vb.net?