CODEWITHSUNDEEP
c#visual-studiovisual-studio-2005formatting
Dan
Dan

Reputation: 941

Formatting - at once - all the files in a Visual Studio project

I am interested in formatting all the files in a Visual Studio (ver. 2005) project all at once.

Currently, there is a way to format a single document by doing something like Edit->Advanced->Format Document. However, I don't see a single command to format all the files of a project all at once.

Any idea how to do that?

Upvotes: 80

Views: 62078

Answers (7)

jgx
jgx

Reputation: 117

I encounter the same problem now. For Visual Studio 2022 17.10.2, installed from marketplace, the plugin FormatAllFilesPlus works for me. Right click on solution or project, then select "Format All Files" in the menu.

Upvotes: 0

Rami A.
Rami A.

Reputation: 10602

There's a new way to format all files in a Visual Studio project using the dotnet CLI:

  1. Install dotnet format by running the following command:
    dotnet tool install -g dotnet-format
  2. Run it, replacing ProjectFile.csproj with the path to your project file, with the following command line:
    dotnet format ProjectFile.csproj

Upvotes: 14

Chayim Friedman
Chayim Friedman

Reputation: 71605

If anyone is still interested in this question, Visual Studio 2019 brought this functionality through a feature called Code Cleanup!

Just run Code Cleanup for Solution!

And you can also create multiple clean profiles and define which actions happen in each one.

Upvotes: 38

Dan Fuller
Dan Fuller

Reputation: 1161

Tim Abell wrote a macro to do this on his blog:

Here's a handy macro script for visual studio I knocked together today. It runs "edit, format document" on every document of the listed file types.

You have to keep an eye on it as it's interactive and does sometimes pop up a message and wait for an answer.

You can get the vb file at https://github.com/timabell/vs-formatter-macro More info at https://github.com/timabell/vs-formatter-macro/wiki

The original code is available at the blog post. Note that this is older than the version available on github above.

Upvotes: 26

ANeves
ANeves

Reputation: 6395

Note, that the following solution does not work by itself starting with Visual Studio 2015. You need to apply the answer by Marcus Mangelsdorf as well. Then, this script works in Visual Studio 2015 and 2017.

Phil Haack outlined a good procedure - adding a reusable script to indent the project.

Open your NuGet profile for edition

  1. Open the Package Manager;
  2. Type $profile to see the location of your NuGet profile;
  3. Type mkdir –force (split-path $profile) to create the profile's folder if it does not exist;
  4. Edit the profile with the command notepad $profile.

Add the reusable method to the NuGet profile

Phil used davidfowl's Format-Document method which he found at https://gist.github.com/davidfowl/984358:

# Function to format all documents based on https://gist.github.com/984353
function Format-Document {
    param(
        [parameter(ValueFromPipelineByPropertyName = $true)]
        [string[]]$ProjectName
    )
    Process {
        $ProjectName | %{ 
                        Recurse-Project -ProjectName $_ -Action { param($item)
                        if($item.Type -eq 'Folder' -or !$item.Language) {
                            return
                        }

                        $window = $item.ProjectItem.Open('{7651A701-06E5-11D1-8EBD-00A0C90F26EA}')
                        if ($window) {
                            Write-Host "Processing `"$($item.ProjectItem.Name)`""
                            [System.Threading.Thread]::Sleep(100)
                            $window.Activate()
                            $Item.ProjectItem.Document.DTE.ExecuteCommand('Edit.FormatDocument')
                            $Item.ProjectItem.Document.DTE.ExecuteCommand('Edit.RemoveAndSort')
                            $window.Close(1)
                        }
                    }
        }
    }
}

function Recurse-Project {
    param(
        [parameter(ValueFromPipelineByPropertyName = $true)]
        [string[]]$ProjectName,
        [parameter(Mandatory = $true)]$Action
    )
    Process {
        # Convert project item guid into friendly name
        function Get-Type($kind) {
            switch($kind) {
                '{6BB5F8EE-4483-11D3-8BCF-00C04F8EC28C}' { 'File' }
                '{6BB5F8EF-4483-11D3-8BCF-00C04F8EC28C}' { 'Folder' }
                default { $kind }
            }
        }

        # Convert language guid to friendly name
        function Get-Language($item) {
            if(!$item.FileCodeModel) {
                return $null
            }

            $kind = $item.FileCodeModel.Language
            switch($kind) {
                '{B5E9BD34-6D3E-4B5D-925E-8A43B79820B4}' { 'C#' }
                '{B5E9BD33-6D3E-4B5D-925E-8A43B79820B4}' { 'VB' }
                default { $kind }
            }
        }

        # Walk over all project items running the action on each
        function Recurse-ProjectItems($projectItems, $action) {
            $projectItems | %{
                $obj = New-Object PSObject -Property @{
                    ProjectItem = $_
                    Type = Get-Type $_.Kind
                    Language = Get-Language $_
                }

                & $action $obj

                if($_.ProjectItems) {
                    Recurse-ProjectItems $_.ProjectItems $action
                }
            }
        }

        if($ProjectName) {
            $p = Get-Project $ProjectName
        }
        else {
            $p = Get-Project
        }

        $p | %{ Recurse-ProjectItems $_.ProjectItems $Action } 
    }
}

# Statement completion for project names
Register-TabExpansion 'Recurse-Project' @{
    ProjectName = { Get-Project -All | Select -ExpandProperty Name }
}

Reopen Visual Studio to use the command

When you reopen Visual Studio, the command is available.

Simply run it from the NuGet Package Manager Console: Format-Document This will re-format all files of the selected project.
To apply to the whole solution, use the command Get-Project -All | Format-Document, which lists the projects and then for each of them calls the reformatting command.

As the author put it:

With this in place, you can now indulge your OCD and run the Format-Document command to clean up your entire solution. I just ran it against <Project> and now can become the whitespace Nazi I’ve always wanted to be.

10/10, would run again.

Upvotes: 17

Mikhail
Mikhail

Reputation: 21829

The Format All Files extension worked for me. Nothing to do, just install and click!

Upvotes: 37

Marcus Mangelsdorf
Marcus Mangelsdorf

Reputation: 3090

Additional step needed for Visual Studio 2015

Phil Haack's solution posted by ANeves is perfect, but for some reason $item.FileCodeModel.Language always returns null in Visual Studio 2015 making the Format-Document skip all files and effectively do nothing.

To (hackily) work around this limitation you can replace the Get-Language function:

# Convert language guid to friendly name
function Get-Language($item) {
    if(!$item.FileCodeModel) {
        return $null
    }

    $kind = $item.FileCodeModel.Language
    switch($kind) {
        '{B5E9BD34-6D3E-4B5D-925E-8A43B79820B4}' { 'C#' }
        '{B5E9BD33-6D3E-4B5D-925E-8A43B79820B4}' { 'VB' }
        default { $kind }
    }
}

with the following variant that uses the file's extension instead of the Language GUID:

# Convert file extension to friendly language name
function Get-Language($item) {
   if(!$item.FileCodeModel) {
       return $null
   }

   $filename = $item.Name
   $ext = $filename.substring($filename.lastindexof('.'),
                              ($filename.length - $filename.lastindexof('.')))
   switch($ext) {
       '.cs' { 'C#' }
       '.vb' { 'VB' }
       # If you want to prevent re-formatting files that are not VB or C# source files 
       # (e.g. XML files in your project etc.), replace the following line with 
       # "default { $null }" (thanks to HHenn for this suggestion!)
       default { $ext }
   }            
}

Upvotes: 13

Related Questions