Como limpar completamente as pastas bin e obj no Visual Studio?

Se você clicar com o botão direito em uma pasta, verá um item de menu "Limpar". Presumi que isso limparia (removeria) o diretório obj e bin. No entanto, pelo que posso ver, não faz nada. Existe outra maneira? (por favor, não me diga para ir ao Windows Explorer ou ao cmd.exe) Eu gostaria de remover a pasta obj e bin para que eu possa facilmente compactar tudo.

Como outros já responderam, o Clean removerá todos os artefatos gerados pela construção. Mas vai deixar tudo o mais para trás.

Se você tiver algumas personalizações em seu projeto MSBuild, isso pode causar problemas e deixar para trás coisas que você acha que deveria ter excluído.

Você pode contornar esse problema com uma simples mudança em seu. * Proj, adicionando isto em algum lugar próximo ao final:

<Target Name="SpicNSpan"
        AfterTargets="Clean">
    <RemoveDir Directories="$(OUTDIR)"/>
</Target>

O que removerá tudo em sua pasta bin da plataforma / configuração atual.

------ Editar ligeira evolução com base na resposta do Shaman abaixo (compartilhe os votos e dê alguns a ele também)

<Target Name="SpicNSpan"  AfterTargets="Clean">
    <!-- Remove obj folder -->
    <RemoveDir Directories="$(BaseIntermediateOutputPath)" />
    <!-- Remove bin folder -->
    <RemoveDir Directories="$(BaseOutputPath)" />
</Target>

---- Edite novamente com partes do xDisruptor, mas removi a exclusão .vs, pois seria melhor servido em um .gitignore (ou equivalente)

Atualizado para VS 2015.

<Target Name="SpicNSpan" AfterTargets="Clean"> <!-- common vars https://msdn.microsoft.com/en-us/library/c02as0cs.aspx?f=255&MSPPError=-2147217396 -->
     <RemoveDir Directories="$(TargetDir)" /> <!-- bin -->
     <RemoveDir Directories="$(ProjectDir)$(BaseIntermediateOutputPath)" /> <!-- obj -->
</Target>

Ele também fornece uma boa sugestão sobre como tornar a tarefa mais fácil de implantar e manter se você tiver vários projetos para implementar isso.

Se você votar nesta resposta, certifique-se de votar em ambos também.

Se você estiver usando git e tiver um correto .gitignoreem seu projeto, você pode

git clean -xdf --dry-run

para remover absolutamente todos os arquivos da .gitignorelista, ou seja, ele limpará obje as binpastas (o que xaciona esse comportamento)

Para o Visual Studio 2015, as variáveis ​​do MSBuild mudaram um pouco:

  <Target Name="SpicNSpan" AfterTargets="Clean"> <!-- common vars https://msdn.microsoft.com/en-us/library/c02as0cs.aspx?f=255&MSPPError=-2147217396 -->
         <RemoveDir Directories="$(TargetDir)" /> <!-- bin -->
         <RemoveDir Directories="$(SolutionDir).vs" /> <!-- .vs -->
         <RemoveDir Directories="$(ProjectDir)$(BaseIntermediateOutputPath)" /> <!-- obj -->
  </Target>

Observe que esse snippet também limpa a pasta .vs do diretório raiz da sua solução. Você pode comentar a linha associada se achar que remover a pasta .vs é um exagero. Eu o habilitei porque percebi que em alguns projetos de terceiros isso causa problemas quando os arquivos ala application.config existem dentro da pasta .vs.

Termo aditivo:

Se você deseja otimizar a manutenção de suas soluções, convém dar um passo adiante e colocar o snippet acima em um arquivo separado, como:

  <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
       <Target Name="SpicNSpan" AfterTargets="Clean"> <!-- common vars https://msdn.microsoft.com/en-us/library/c02as0cs.aspx?f=255&MSPPError=-2147217396 -->
            <RemoveDir Directories="$(TargetDir)" /> <!-- bin -->
            <RemoveDir Directories="$(SolutionDir).vs" /> <!-- .vs -->
            <RemoveDir Directories="$(ProjectDir)$(BaseIntermediateOutputPath)" /> <!-- obj -->
       </Target>
  </Project>

Em seguida, inclua esse arquivo no final de cada um dos seus arquivos * .csproj, assim:

     [...]
     <Import Project="..\..\Tools\ExtraCleanup.targets"/>
  </Project>

Dessa forma, você pode enriquecer ou ajustar sua lógica de limpeza extra centralmente, em um só lugar, sem ter que se preocupar em editar manualmente cada arquivo * .csproj sempre que desejar fazer uma melhoria.

Para excluir bin e obj antes de compilar, adicione ao arquivo de projeto:

<Target Name="BeforeBuild">
    <!-- Remove obj folder -->
    <RemoveDir Directories="$(BaseIntermediateOutputPath)" />
    <!-- Remove bin folder -->
    <RemoveDir Directories="$(BaseOutputPath)" />
</Target>

Aqui está o artigo: Como remover a pasta bin e / ou obj antes de construir ou implantar

Este site: https://sachabarbs.wordpress.com/2014/10/24/powershell-to-clean-visual-studio-binobj-folders/ usa os comandos do powerhell de William Kempf para remover qualquer pasta bin e obj do diretório atual e subdiretórios. Deve ser possível executá-lo a partir da raiz da unidade.

Aqui está a versão de William

 gci -inc bin,obj -rec | rm -rec -force

Nas próprias palavras de William:

Isso apaga todos os diretórios “bin” e “obj” no diretório atual e todos os subdiretórios. Muito útil para executar no diretório do seu espaço de trabalho para chegar a um estado “limpo”, especialmente quando alguém bagunça e há algo que um Clean ou Rebuild dentro do IDE não detecta.

Para aqueles que estão lendo que talvez não saibam, o PowerShell oferece suporte a aliases de comando, aqui ele é reescrito novamente sem usar os aliases

Get-ChildItem -inc bin,obj -rec | Remove-Item -rec -force

OBSERVAÇÃO: você deve ter isso armazenado em um arquivo PowerShell e colocar esse arquivo na raiz da sua solução (onde o arquivo .sln reside) e, em seguida, executá-lo quando quiser uma limpeza adequada (não o mouse micky que VisualStudio faz, e relata o sucesso também).

Confira o fantástico código aberto de Ron Jacobs, CleanProject. Ele ainda cuida do zip, se você quiser.

Aqui está o link do CodePlex

Você pode localizar e remover facilmente as pastas bin e obj no Far Manager.

1. Navegue até sua solução e pressione Alt + F7

2. Na caixa de diálogo de configuração de pesquisa:

   • Digite "bin, obj" no campo "Uma máscara de arquivo ou várias máscaras de arquivo"
   • Marque a opção "Pesquisar por pastas"
   • pressione Enter

3. Depois que a pesquisa for concluída, mude a visualização para "Painel" .

4. Selecione todos os arquivos (com Ctrl + A) e exclua as pastas (pressione "Shift + Del")

Espero que ajude alguém.

No Windows, basta abrir o explorador, navegar até a pasta SLN, clicar no campo de pesquisa e digitar kind: = pasta; obj -> para pastas obj use CTRL + A e exclua-os - o mesmo para bin Feito

Não há necessidade de nenhuma ferramenta ou software extra;)

Não remove as pastas, mas remove os subprodutos de construção. Há algum motivo para você querer que as pastas de construção reais sejam removidas?

Limpar removerá todos os arquivos intermediários e finais criados pelo processo de compilação, como arquivos .obj e .exe ou .dll.

No entanto, ele não remove os diretórios onde esses arquivos foram compilados. Não vejo um motivo convincente para você precisar que os diretórios sejam removidos. Você pode explicar melhor?

Se você olhar dentro desses diretórios antes e depois de uma "Limpeza", verá que a saída compilada será limpa.

Ainda não consigo adicionar um comentário (nenhuma reputação mínima alcançada),
por isso deixo esta resposta para sublinhar que:

a ação "BeforeBuild" com <RemoveDir Directories="$(BaseIntermediateOutputPath)" />é ótima, mas, para mim, está em conflito com um modelo de Entity Framework incluído no mesmo projeto.

O erro que recebo é:

Error reading resource '{mymodel}.csdl' -- 'Could not find a part of the path '{myprojectpath}\obj\Release\edmxResourcesToEmbed\{mymodel}.csdl

Suponho que o "edmxResourcesToembed" seja criado antes que a ação de destino "BeforeBuild" seja executada.

Com base na resposta de Joe, converti o código VB em C #:

/// <summary>
/// Based on code of VSProjCleaner tool (C) 2005 Francesco Balena, Code Archirects
/// </summary>
static class VisualStudioCleaner
{
    public static void Process(string rootDir)
    {
        // Read all the folder names in the specified directory tree
        string[] dirNames = Directory.GetDirectories(rootDir, "*.*", SearchOption.AllDirectories);
        List<string> errorsList = new List<string>();

        // delete any .suo and csproj.user file
        foreach (string dir in dirNames) {
            var files = new List<string>();
            files.AddRange(Directory.GetFiles(dir, "*.suo"));
            files.AddRange(Directory.GetFiles(dir, "*.user"));
            foreach (string fileName in files) {
                try {
                    Console.Write("Deleting {0} ...", fileName);
                    File.Delete(fileName);
                    Console.WriteLine("DONE");
                } catch (Exception ex) {
                    Console.WriteLine();
                    Console.WriteLine(" ERROR: {0}", ex.Message);
                    errorsList.Add(fileName + ": " + ex.Message);
                }
            }
        }

        // Delete all the BIN and OBJ subdirectories
        foreach (string dir in dirNames) {
            string dirName = Path.GetFileName(dir).ToLower();
            if (dirName == "bin" || dirName == "obj") {
                try {
                    Console.Write("Deleting {0} ...", dir);
                    Directory.Delete(dir, true);
                    Console.WriteLine("DONE");
                } catch (Exception ex) {
                    Console.WriteLine();
                    Console.WriteLine(" ERROR: {0}", ex.Message);
                    errorsList.Add(dir + ": " + ex.Message);
                }
            }
        }
        Console.WriteLine(new string('-', 60));
        if (errorsList.Count == 0) {
            Console.WriteLine("All directories and files were removed successfully");
        } else {
            Console.WriteLine("{0} directories or directories couldn't be removed", errorsList.Count);
            Console.WriteLine(new string('-', 60));
            foreach (string msg in errorsList) {
                Console.WriteLine(msg);
            }
        }
    }
}

Eu uso VisualStudioClean, que é fácil de entender e previsível. Saber como funciona e quais arquivos vai deletar me deixa aliviado.

Anteriormente experimentei o VSClean (observe que VisualStudioClean não é VSClean), VSClean é mais avançado, tem muitas configurações que às vezes me fazem pensar que arquivos ele vai excluir? Uma configuração incorreta resultará na perda de meus códigos-fonte. Para testar como a configuração funcionará, é necessário fazer backup de todos os meus projetos, o que leva muito tempo, então, no final, escolho VisualStudioClean.

Conclusão: VisualStudioClean se você deseja limpeza básica, VSClean para cenários mais complexos.

É assim que faço com um arquivo em lote para excluir todas as pastas BIN e OBJ recursivamente.

• Crie um arquivo vazio e nomeie-o DeleteBinObjFolders.bat
• Copie e cole o código a seguir no DeleteBinObjFolders.bat
• Mova o arquivo DeleteBinObjFolders.bat na mesma pasta com seu arquivo de solução (* .sln).

@echo off
@echo Deleting all BIN and OBJ folders...
for /d /r . %%d in (bin,obj) do @if exist "%%d" rd /s/q "%%d"
@echo BIN and OBJ folders successfully deleted :) Close the window.
pause > nul

Eu armazeno meus projetos VS finalizados salvando apenas o código-fonte.

Excluo as pastas BIN, DEBUG, RELEASE, OBJ, ARM e .vs de todos os projetos.

Isso reduz o tamanho do projeto consideravelmente. O projeto

deve ser reconstruído quando retirado do armazenamento.

Apenas um adendo a todas as boas respostas acima, caso alguém não perceba como é fácil em VB / C # automatizar todo o processo até o arquivo zip.

Então, você apenas pega um aplicativo Formulários simples dos modelos (se ainda não tiver um aplicativo de manutenção) e adiciona um botão a ele e, em seguida, o ClickOnce o instala em sua área de trabalho sem se preocupar com configurações especiais ou muito de qualquer coisa. Este é todo o código que você precisa para anexar ao botão:

Imports System.IO.Compression

Private Sub btnArchive_Click(sender As Object, e As EventArgs) Handles btnArchive.Click
    Dim src As String = "C:\Project"
    Dim dest As String = Path.Combine("D:\Archive", "Stub" & Now.ToString("yyyyMMddHHmmss") & ".zip")
    If IsProjectOpen() Then 'You don't want Visual Studio holding a lock on anything while you're deleting folders
        MsgBox("Close projects first, (expletive deleted)", vbOKOnly)
        Exit Sub
    End If
    If MsgBox("Are you sure you want to delete bin and obj folders?", vbOKCancel) = DialogResult.Cancel Then Exit Sub
    If ClearBinAndObj(src) Then ZipFile.CreateFromDirectory(src, dest)
End Sub

Public Function ClearBinAndObj(targetDir As String) As Boolean
    Dim dirstodelete As New List(Of String)
    For Each d As String In My.Computer.FileSystem.GetDirectories(targetDir, FileIO.SearchOption.SearchAllSubDirectories, "bin")
        dirstodelete.Add(d)
    Next
    For Each d As String In My.Computer.FileSystem.GetDirectories(targetDir, FileIO.SearchOption.SearchAllSubDirectories, "obj")
        dirstodelete.Add(d)
    Next
    For Each d In dirstodelete
        Try
            Directory.Delete(d, True)
        Catch ex As Exception
            If MsgBox("Error: " & ex.Message & " - OK to continue?", vbOKCancel) = MsgBoxResult.Cancel Then Return False
        End Try
    Next
    Return True
End Function

Public Function IsProjectOpen()
    For Each clsProcess As Process In Process.GetProcesses()
        If clsProcess.ProcessName.Equals("devenv") Then Return True
    Next
    Return False
End Function

Uma coisa a lembrar é que as exclusões do sistema de arquivos podem dar errado facilmente. Um dos meus favoritos foi quando percebi que não poderia excluir uma pasta porque ela continha itens criados pelo Visual Studio durante a execução com privilégios elevados (para que eu pudesse depurar um serviço).

Eu precisava dar permissão manualmente ou, suponho, executar o aplicativo com privilégios elevados também. De qualquer forma, acho que há algum valor em usar uma abordagem baseada em GUI interativa em vez de um script, especialmente porque isso é provavelmente algo que é feito no final de um longo dia e você não quer descobrir mais tarde que seu backup realmente não existe ...

Atualização: Visual Studio 2019 (Limpe [bin] e [obj] antes do lançamento). No entanto, não tenho certeza se [obj] precisa ser excluído. Esteja ciente de que também há configuração de pacote nuget. Você pode remover a segunda linha se achar que sim.

<Target Name="PreBuild" BeforeTargets="PreBuildEvent" Condition="'$(Configuration)' == 'Release'">
  <!--remove bin-->
  <Exec Command="rd /s /q &quot;$(ProjectDir)$(BaseOutputPath)&quot; &amp;&amp; ^" />
  <!--remove obj-->
  <Exec Command="rd /s /q &quot;$(BaseIntermediateOutputPath)Release&quot;" />
</Target>