Modificare il Framework di destinazione per tutti i miei progetti in una soluzione di Visual Studio


104

Devo cambiare il framework di destinazione per tutti i progetti. Ho molte soluzioni con centinaia di progetti.

Qualcosa di nuovo qui o devo cambiare ogni singolo progetto?

Risposte:


37

Puoi farlo usando la macro di Visual Studio di Scott Dorman disponibile su CodeProject:

Visual Studio 2010 e versione Framework di destinazione

Di seguito il codice, scaricalo nella tua <UserProfile>\Documents\Visual Studio 2010\Projects\VSMacros80\MyMacroscartella, apri l'IDE Macro di Visual Studio (Alt-F11) e aggiungilo come elemento esistente al progetto "MyMacros":

'------------------------------------------------------------------------------
' Visual Studio 2008 Macros
'
' ProjectUtilities.vb
'
'------------------------------------------------------------------------------
' Copyright (C) 2007-2008 Scott Dorman (sj_dorman@hotmail.com)
'
' This library is free software; you can redistribute it and/or
' modify it under the terms of the Microsoft Public License (Ms-PL).
'
' This library is distributed in the hope that it will be useful,
' but WITHOUT ANY WARRANTY; without even the implied warranty of
' MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
' Microsoft Public License (Ms-PL) for more details.
'------------------------------------------------------------------------------
Imports System
Imports EnvDTE
Imports EnvDTE80
Imports EnvDTE90
Imports System.Diagnostics

Public Module ProjectUtilities

    Private Class ProjectGuids
        Public Const vsWindowsCSharp As String = "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}"
        Public Const vsWindowsVBNET As String = "{F184B08F-C81C-45F6-A57F-5ABD9991F28F}"
        Public Const vsWindowsVisualCPP As String = "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}"
        Public Const vsWebApplication As String = "{349C5851-65DF-11DA-9384-00065B846F21}"
        Public Const vsWebSite As String = "{E24C65DC-7377-472B-9ABA-BC803B73C61A}"
        Public Const vsDistributedSystem As String = "{F135691A-BF7E-435D-8960-F99683D2D49C}"
        Public Const vsWCF As String = "{3D9AD99F-2412-4246-B90B-4EAA41C64699}"
        Public Const vsWPF As String = "{60DC8134-EBA5-43B8-BCC9-BB4BC16C2548}"
        Public Const vsVisualDatabaseTools As String = "{C252FEB5-A946-4202-B1D4-9916A0590387}"
        Public Const vsDatabase As String = "{A9ACE9BB-CECE-4E62-9AA4-C7E7C5BD2124}"
        Public Const vsDatabaseOther As String = "{4F174C21-8C12-11D0-8340-0000F80270F8}"
        Public Const vsTest As String = "{3AC096D0-A1C2-E12C-1390-A8335801FDAB}"
        Public Const vsLegacy2003SmartDeviceCSharp As String = "{20D4826A-C6FA-45DB-90F4-C717570B9F32}"
        Public Const vsLegacy2003SmartDeviceVBNET As String = "{CB4CE8C6-1BDB-4DC7-A4D3-65A1999772F8}"
        Public Const vsSmartDeviceCSharp As String = "{4D628B5B-2FBC-4AA6-8C16-197242AEB884}"
        Public Const vsSmartDeviceVBNET As String = "{68B1623D-7FB9-47D8-8664-7ECEA3297D4F}"
        Public Const vsWorkflowCSharp As String = "{14822709-B5A1-4724-98CA-57A101D1B079}"
        Public Const vsWorkflowVBNET As String = "{D59BE175-2ED0-4C54-BE3D-CDAA9F3214C8}"
        Public Const vsDeploymentMergeModule As String = "{06A35CCD-C46D-44D5-987B-CF40FF872267}"
        Public Const vsDeploymentCab As String = "{3EA9E505-35AC-4774-B492-AD1749C4943A}"
        Public Const vsDeploymentSetup As String = "{978C614F-708E-4E1A-B201-565925725DBA}"
        Public Const vsDeploymentSmartDeviceCab As String = "{AB322303-2255-48EF-A496-5904EB18DA55}"
        Public Const vsVSTA As String = "{A860303F-1F3F-4691-B57E-529FC101A107}"
        Public Const vsVSTO As String = "{BAA0C2D2-18E2-41B9-852F-F413020CAA33}"
        Public Const vsSharePointWorkflow As String = "{F8810EC1-6754-47FC-A15F-DFABD2E3FA90}"
    End Class

    '' Defines the valid target framework values.
    Enum TargetFramework
        Fx40 = 262144
        Fx35 = 196613
        Fx30 = 196608
        Fx20 = 131072
    End Enum

    '' Change the target framework for all projects in the current solution.
    Sub ChangeTargetFrameworkForAllProjects()
        Dim project As EnvDTE.Project
        Dim clientProfile As Boolean = False

        Write("--------- CHANGING TARGET .NET FRAMEWORK VERSION -------------")
        Try
            If Not DTE.Solution.IsOpen Then
                Write("There is no solution open.")
            Else              
                Dim targetFrameworkInput As String = InputBox("Enter the target framework version (Fx40, Fx35, Fx30, Fx20):", "Target Framework", "Fx40")
                Dim targetFramework As TargetFramework = [Enum].Parse(GetType(TargetFramework), targetFrameworkInput)

                If targetFramework = ProjectUtilities.TargetFramework.Fx35 Or targetFramework = ProjectUtilities.TargetFramework.Fx40 Then
                    Dim result As MsgBoxResult = MsgBox("The .NET Framework version chosen supports a Client Profile. Would you like to use that profile?", MsgBoxStyle.Question Or MsgBoxStyle.YesNo, "Target Framework Profile")
                    If result = MsgBoxResult.Yes Then
                        clientProfile = True
                    End If
                End If

                For Each project In DTE.Solution.Projects
                    If project.Kind <> Constants.vsProjectKindSolutionItems And project.Kind <> Constants.vsProjectKindMisc Then
                        ChangeTargetFramework(project, targetFramework, clientProfile)
                    Else
                        For Each projectItem In project.ProjectItems
                            If Not (projectItem.SubProject Is Nothing) Then
                                ChangeTargetFramework(projectItem.SubProject, targetFramework, clientProfile)
                            End If
                        Next

                    End If
                Next
            End If
        Catch ex As System.Exception
            Write(ex.Message)
        End Try
    End Sub

    '' Change the target framework for a project.
    Function ChangeTargetFramework(ByVal project As EnvDTE.Project, ByVal targetFramework As TargetFramework, ByVal clientProfile As Boolean) As Boolean
        Dim changed As Boolean = True

        If project.Kind = Constants.vsProjectKindSolutionItems Or project.Kind = Constants.vsProjectKindMisc Then
            For Each projectItem In project.ProjectItems
                If Not (projectItem.SubProject Is Nothing) Then
                    ChangeTargetFramework(projectItem.SubProject, targetFramework, clientProfile)
                End If
            Next
        Else
            Try
                If IsLegalProjectType(project) Then
                    SetTargetFramework(project, targetFramework, clientProfile)
                Else
                    Write("Skipping project: " + project.Name + " (" + project.Kind + ")")
                End If
            Catch ex As Exception
                Write(ex.Message)
                changed = False
            End Try
        End If

        Return changed
    End Function

    '' Determines if the project is a project that actually supports changing the target framework.
    Function IsLegalProjectType(ByVal proejct As EnvDTE.Project) As Boolean
        Dim legalProjectType As Boolean = True

        Select Case proejct.Kind
            Case ProjectGuids.vsDatabase
                legalProjectType = False
            Case ProjectGuids.vsDatabaseOther
                legalProjectType = False
            Case ProjectGuids.vsDeploymentCab
                legalProjectType = False
            Case ProjectGuids.vsDeploymentMergeModule
                legalProjectType = False
            Case ProjectGuids.vsDeploymentSetup
                legalProjectType = False
            Case ProjectGuids.vsDeploymentSmartDeviceCab
                legalProjectType = False
            Case ProjectGuids.vsDistributedSystem
                legalProjectType = False
            Case ProjectGuids.vsLegacy2003SmartDeviceCSharp
                legalProjectType = False
            Case ProjectGuids.vsLegacy2003SmartDeviceVBNET
                legalProjectType = False
            Case ProjectGuids.vsSharePointWorkflow
                legalProjectType = False
            Case ProjectGuids.vsSmartDeviceCSharp
                legalProjectType = True
            Case ProjectGuids.vsSmartDeviceVBNET
                legalProjectType = True
            Case ProjectGuids.vsTest
                legalProjectType = False
            Case ProjectGuids.vsVisualDatabaseTools
                legalProjectType = False
            Case ProjectGuids.vsVSTA
                legalProjectType = True
            Case ProjectGuids.vsVSTO
                legalProjectType = True
            Case ProjectGuids.vsWCF
                legalProjectType = True
            Case ProjectGuids.vsWebApplication
                legalProjectType = True
            Case ProjectGuids.vsWebSite
                legalProjectType = True
            Case ProjectGuids.vsWindowsCSharp
                legalProjectType = True
            Case ProjectGuids.vsWindowsVBNET
                legalProjectType = True
            Case ProjectGuids.vsWindowsVisualCPP
                legalProjectType = True
            Case ProjectGuids.vsWorkflowCSharp
                legalProjectType = False
            Case ProjectGuids.vsWorkflowVBNET
                legalProjectType = False
            Case ProjectGuids.vsWPF
                legalProjectType = True
            Case Else
                legalProjectType = False
        End Select
        Return legalProjectType
    End Function

    '' Sets the target framework for the project to the specified framework.
    Sub SetTargetFramework(ByVal project As EnvDTE.Project, ByVal targetFramework As TargetFramework, ByVal clientProfile As Boolean)
        Dim currentTargetFramework As TargetFramework = CType(project.Properties.Item("TargetFramework").Value, TargetFramework)
        Dim targetMoniker As String = GetTargetFrameworkMoniker(targetFramework, clientProfile)
        Dim currentMoniker As String = project.Properties.Item("TargetFrameworkMoniker").Value

        If currentMoniker <> targetMoniker Then
            Write("Changing project: " + project.Name + " from " + currentMoniker + " to " + targetMoniker + ".")
            project.Properties.Item("TargetFrameworkMoniker").Value = targetMoniker
            project.Properties.Item("TargetFramework").Value = targetFramework
        Else
            Write("Skipping project: " + project.Name + ", already at the correct target framework.")
        End If
    End Sub

    Function GetTargetFrameworkMoniker(ByVal targetFramework As TargetFramework, ByVal clientProfile As Boolean) As String
        Dim moniker As String = ".NETFramework,Version=v"
        Select Case targetFramework
            Case ProjectUtilities.TargetFramework.Fx20
                moniker += "2.0"

            Case ProjectUtilities.TargetFramework.Fx30
                moniker += "3.0"

            Case ProjectUtilities.TargetFramework.Fx35
                moniker += "3.5"

            Case ProjectUtilities.TargetFramework.Fx40
                moniker += "4.0"

        End Select

        If clientProfile Then
            moniker += ",Profile=Client"
        End If

        Return moniker
    End Function

    '' Writes a message to the output window
    Sub Write(ByVal s As String)
        Dim out As OutputWindowPane = GetOutputWindowPane("Change Target Framework", True)
        out.OutputString(s)
        out.OutputString(vbCrLf)
    End Sub

    '' Gets an instance of the output window
    Function GetOutputWindowPane(ByVal Name As String, Optional ByVal show As Boolean = True) As OutputWindowPane
        Dim win As Window = DTE.Windows.Item(EnvDTE.Constants.vsWindowKindOutput)
        If show Then win.Visible = True
        Dim ow As OutputWindow = win.Object
        Dim owpane As OutputWindowPane
        Try
            owpane = ow.OutputWindowPanes.Item(Name)
        Catch e As System.Exception
            owpane = ow.OutputWindowPanes.Add(Name)
        End Try
        owpane.Activate()
        Return owpane
    End Function

End Module

3
+1 per il codice, perché il collegamento su CodeProject non sembra più funzionare.
Hannele

81

Target Framework Migrator appena pubblicato , estensione di Visual Studio per modificare più progetti .Net Target Framework contemporaneamente


Questo non è ancora un gioco da ragazzi nel 2013.
Jon Egerton

1
È necessaria solo una singola modifica del numero di versione in vsixmanifest per funzionare in VS 2013
Panagiotis Kanavos

Questa estensione è un vero risparmio di tempo :)
fusione

3
Per VS2015: scaricare, decomprimere, in vsixmanifest: modificare la versione di InstallationTarget in 14.0 e la dipendenza in 4.6
Jeroen K

5
Nuova versione con supporto VS2015 e 4.6 caricata nella galleria.
Pavel Samokha,

35

Uno script di PowerShell che ho usato per fare il mio. Devo ammettere che Bruce è forzato.

Get-ChildItem . -Recurse -Filter *.*proj |ForEach {
    $content = Get-Content $_.FullName
    $content |ForEach {
        $_.Replace("<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>", "<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>")
    } |Set-Content $_.FullName
}

1
Fantastico ma sul mio sistema ho ricevuto un errore, script1.ps1 cannot be loaded because running scripts is disabled on this system. For more information, see about_Execution_Policiesquindi eseguo il comando set-executionpolicy remotesignedper risolverlo.
kuncevic.dev

Sìirree, bigb. Non essere in grado di eseguire script di default su un sistema è una seccatura che do per scontato. Grazie per la segnalazione. For all y'all Set-ExecutionPolicy RemoteSignedconsente di eseguire script PowerShell locali senza firmarli con certificato. Per i dettagli, vedere qui: technet.microsoft.com/en-us/library/ee176961.aspx
Russell B

2
Questo è esattamente quello che stavo cercando. La soluzione più elegante e flessibile per modificare tutti quei file .proj.
Ole Viaud-Murat

1
Per me la migrazione modifica i file di progetto, app.configs e designer
Tomas Kubes

10

C'è sempre il semplice. Un editor di testo decente come Notepad ++ includerà una funzione trova / sostituisci nei file. Basta cercare la stringa della versione corrente nei file csproj / vbproj:

<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>

e sostituisci con la nuova versione

<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>

Buona idea però controllare prima ...


1
Questo è il modo migliore che ho trovato, ho usato Sublime per cambiare tutto
cuongle

7

Da bash:

$find . -name "*.csproj" -exec sed -b -i "s,<TargetFrameworkVersion>[^<]*</TargetFrameworkVersion>,<TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>," {} \;

6

Penso che il modo di gran lunga più semplice per farlo sia usare uno strumento di ricerca e sostituzione. È un vantaggio se supporta regex.

Ce ne devono essere parecchi là fuori - il primo che ho provato ha funzionato per me, però: http://www.ecobyte.com/replacetext/

C'è una nota che dice che ha alcuni problemi su Win7, ma non l'ho sperimentato.

Istruzioni passo passo in quello strumento:

  1. Sostituisci | Aggiungi gruppo | Assegna un nome (ad es. "Il mio gruppo")
  2. Fare clic con il pulsante destro del mouse su MyGroup | Aggiungere i file)...
  3. Scegli la tua fonte (es. Usa cartella, vai alla cartella principale dei progetti che vuoi modificare)
  4. Se necessario, imposta il filtro di inclusione dei file (es. * .Csproj)
  5. Fare clic con il pulsante destro del mouse sulla riga sotto Testo originale | Modifica avanzata ...
  6. Inserisci la tua espressione regolare nella casella di testo di ricerca (ad es. <TargetFrameworkVersion>.*</TargetFrameworkVersion>)
  7. Seleziona "Ricerca espressione regolare" nella casella combinata sotto il testo di ricerca
  8. Inserisci testo sostitutivo (ad es. <TargetFrameworkVersion>4.0</TargetFrameworkVersion>)
  9. Scegli le impostazioni di destinazione e backup (creerà un backup per impostazione predefinita)
  10. Avvia sostituzione (Ctrl + R)

Ora, se per qualche motivo hai bisogno di farlo in codice, probabilmente sarei in grado di farlo anche io (è così che ho trovato questa domanda). In tal caso, richiedilo in un commento.


inserisci qui la descrizione dell'immagine


Ok, ho appena letto il commento di 0xA3 sotto la risposta di ShellShocks. Suppongo che potrebbe essere un problema. Cercherò di trovare un'espressione regolare prima di passare alla soluzione codificata.
Mike Fuchs


2

Le espressioni regolari condizionali mi stanno dando un mal di testa. Quindi ecco una soluzione codificata per la ricerca / sostituzione (sto evitando EnvDTE il più a lungo possibile).

L'ordine non sembra avere importanza per le voci del file di progetto:

Prova qualcosa in questo modo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Text.RegularExpressions;

namespace TextReplaceDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                ReplaceTargetFrameworkVersion("v4.0", "c:/projekt/2005", "*.csproj");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        /// <summary>
        /// Inserts the denoted targetFramework into all occurrences of TargetFrameworkVersion.
        /// If the TargetFrameworkVersion is not present in the file, the method searches for the 
        /// OutputType tag, which should be present, and inserts the TargetFrameworkVersion before that.
        /// </summary>
        /// <param name="targetFramework">New target framework (e.g. "v4.0")</param>
        /// <param name="rootDirectory">Root directory for the file search (e.g. "c:\Projects\2005")</param>
        /// <param name="fileSearchPattern">Pattern to find the project files (e.g. "*.csproj). 
        /// Will get all files for empty parameter.</param>
        public static void ReplaceTargetFrameworkVersion(string targetFramework, string rootDirectory, string fileSearchPattern)
        {
            if (string.IsNullOrEmpty(targetFramework)) throw new ArgumentNullException("targetFramework");
            if (string.IsNullOrEmpty(rootDirectory)) throw new ArgumentNullException("rootDirectory");
            if (string.IsNullOrEmpty(fileSearchPattern)) fileSearchPattern = "*.*";

            string regexPattern = "<TargetFrameworkVersion>.*</TargetFrameworkVersion>";
            string insertText = string.Format("<TargetFrameworkVersion>{0}</TargetFrameworkVersion>", targetFramework);
            string alternativeMarker = "<OutputType>";

            // get all files
            List<FileInfo> files = GetAllFiles(rootDirectory, fileSearchPattern);

            // iterate over found files
            foreach (var file in files)
            {
                string fileContent = File.ReadAllText(file.FullName);
                Match match = Regex.Match(fileContent, regexPattern);
                string newfileContent = null;
                if (match.Success)
                {
                    // replace <TargetFrameworkVersion>
                    newfileContent = fileContent.Replace(match.Value, insertText);
                }
                else if (fileContent.Contains(alternativeMarker))
                {
                    // create <TargetFrameworkVersion>
                    newfileContent = fileContent.Replace(alternativeMarker,
                        insertText + Environment.NewLine + "    " + alternativeMarker);
                }

                // overwrite file
                if (newfileContent != null)
                    File.WriteAllText(file.FullName, newfileContent);
            }
        }


        /// <summary>
        /// Recursive function to find all files in a directory by a searchPattern
        /// </summary>
        /// <param name="path">Path to the root directory</param>
        /// <param name="searchPattern">Pattern for the file search, e.g. "*.txt"</param>
        public static List<FileInfo> GetAllFiles(string path, string searchPattern)
        {
            List<FileInfo> files = new List<FileInfo>();

            DirectoryInfo dir = new DirectoryInfo(path);

            if (dir.Exists)
            {
                // get all files in directory
                files.AddRange(dir.GetFiles(searchPattern));

                // get all files of subdirectories
                foreach (var subDir in dir.GetDirectories())
                {
                    files.AddRange(GetAllFiles(subDir.FullName, searchPattern));
                }
            }
            return files;
        }
    }
}

1

È possibile utilizzare una macro per eseguire questa operazione o ricordare che i file di progetto VS sono file di testo, il che significa che una semplice ricerca e sostituzione globale può ottenere lo stesso risultato ed è una tecnica più generale per apportare la stessa modifica a molti file di progetto.

Per prima cosa eseguire il backup di un file di progetto esistente, quindi apportare la modifica desiderata (ad esempio, modificare il framework di destinazione). Usa WinDiff o WinMerge per confrontare il nuovo file di progetto con il backup. Questo ti dirà il cambiamento che devi apportare. Quindi utilizzare la funzione Trova e sostituisci nei file dell'IDE di Visual Studio per apportare la modifica a tutti i file di progetto.


2
Una semplice ricerca e sostituzione fallirà per i file di progetto che non specificano un framework di destinazione (ad esempio i file originariamente creati in VS 2005). Per tali file di progetto dovresti trovare la posizione corretta per inserire l'elemento del framework di destinazione con un'espressione di ricerca e sostituzione più complicata.
Dirk Vollmar

0

Un'alternativa senza strumenti esterni (e la possibilità di modificare altre impostazioni, ad esempio ToolsVersion):

  1. Utilizzando Visual Studio, crea un nuovo progetto console c # "ManageCSProjFiles" (o il nome che preferisci) in una directory temporanea. Assicurati di selezionare "Posiziona soluzione e progetto nella stessa directory"
  2. Rimuovere Program.cs e Properties / AssemblyInfo.cs dal progetto. Non è necessario compilare mai il progetto.
  3. Salvare il progetto e chiudere Visual Studio.
  4. Utilizzando un editor di testo, apri ManageCSProjFiles.csproj. Aggiungi le seguenti righe in fondo, prima dell'ultima riga:
  <ItemGroup>
    <None Include="**\*.csproj" />
  </ItemGroup>
  1. Copiare ManageCSProjFiles.sln e ManageCSProjFiles.csproj nella directory più alta dell'albero della soluzione.
  2. Se carichi la soluzione ManageCSProjFiles in Visual Studio, ora mostrerà tutti i tuoi file .csproj e potrai modificarli con gli strumenti di ricerca / sostituzione in Visual Studio.

Questo può essere facilmente esteso per altri tipi di progetto.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.