web-dev-qa-db-fra.com

Comment obtenir le chemin csc.exe?

Existe-t-il un moyen d’obtenir un chemin pour le dernier fichier csc.exe du .NET Framework?

Le fichier se trouve généralement dans: c:\Windows\Microsoft.NET\Framework\vX.X.XXX mais le problème est que plusieurs versions peuvent être installées + il existe des versions 32 et 64 bits.

Une solution à cela?

c#.netcsc
43
yper

c:\Windows\Microsoft.NET\Framework\vX.X.XXX devrait contenir la dernière version 32 bits de csc.exe

c:\Windows\Microsoft.NET\Framework64\vX.X.XXX devrait contenir la dernière version 64 bits de csc.exe

C'est ce que c'est pour le mien de toute façon.

BTW: Vous pouvez accéder aux deux en utilisant la ligne de commande Visual Studio à partir du dossier Outils de Visual Studio dans vos fichiers de programme. Il configure automatiquement tous les chemins nécessaires pour créer des applications 32 et 64 bits avec votre compilateur csc.

24
Liquid Wotter

Le meilleur moyen de trouver le chemin CSC.exe est de s'exécuter dans la ligne de commande CLI (interpréteur de ligne de commande):

dir /s %WINDIR%\CSC.EXE

dir - affiche le répertoire

/ s - inclut les sous-dossiers

% WINDIR%\CSC.EXE - recherche dans le dossier racine une phrase telle que "CSC.exe".

Et c'est notre résultat:  enter image description here

Ensuite, nous pouvons simplement compiler un exemple de code par ligne comme:

C:\WINDOWS\...\v.4.0.30319\CSC.exe HelloWorld.cs

Cordialement.

10
Bear

Vous pouvez utiliser System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory().

using System.Runtime.InteropServices;
var frameworkPath = RuntimeEnvironment.GetRuntimeDirectory();
var cscPath = Path.Combine(frameworkPath, "csc.exe");

Console.WriteLine(frameworkPath);  // C:\Windows\Microsoft.NET\Framework\v4.0.30319
Console.WriteLine(cscPath); }      // C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe
10
Samuel Neff

Mis à jour:

Ouvrez l'invite de commande ou Powershell et exécutez la commande ci-dessous pour répertorier le chemin complet des compilateurs pour les différentes versions de .Net Frameworks installées.

dir %WINDIR%\Microsoft.NET\Framework64\csc.exe /s/b

Chemin CSC est comme suit:

C:\Program Files\MSBuild \\ Bin

Ex: ce sera 12.0, si vous utilisez Visual Studio 2013.

7
naveddeshmukh

Si vous avez déjà installé Visual Studio, il vous suffit de: Cliquez sur Démarrer, pointez sur Tous les programmes, sur Microsoft Visual Studio, sur Outils de Visual Studio, puis cliquez sur Invite de commandes de Visual Studio où vous compilez comme suit:

csc PathToYourCsSource
3
Xavier Baquero

Je suppose que vous voulez utiliser csc.exe pour compiler des fichiers, c’est pourquoi vous demandiez le chemin. Plutôt que de regarder dans le registre à cette fin, vous pouvez utiliser le petit script batch que j'ai créé pour obtenir le chemin d'accès au fichier latest csc.exe disponible:

@echo off
set dotNetBase=%SystemRoot%\Microsoft.NET\Framework\
rem get latest .net path containing csc.exe:
set dotNet20=%dotNetBase%v2.0.50727\
set dotNet35=%dotNetBase%v3.5\
set dotNet40=%dotNetBase%v4.0.30319\
if exist %dotNet20%nul set dotNet=%dotNet20%
if exist %dotNet35%nul set dotNet=%dotNet35%
if exist %dotNet40%nul set dotNet=%dotNet40%
set outPath=%~DP1
set outFileName=%~n1
"%dotNet%csc.exe" /t:exe /out:%outPath%%outFileName%.exe %1

Enregistrez-le sous le nom CompileCS.cmd et placez-le dans le même chemin que vos fichiers * .cs. Ensuite, vous pouvez simplement le compiler comme suit:

CompileCS GetDotNetVersion.cs

Ce qui compilera l'application console GetDotNetVersion, un programme permettant de déterminer les versions .NET installées, que j'ai publiées ici.

Indice: Si vous voulez exécuter l'application C # automatiquement après la compilation, ajoutez 
%outPath%%outFileName%.exe 
à la fin du script batch.

Le script vérifie l'existence des répertoires système pour .NET 2.0.x, 3.5 et 4.0.30319 - dans d'autres dossiers, je n'ai jamais vu csc.exe. Etant donné qu’elle vérifie la version la plus ancienne à la plus récente, la variable dotNet contient le dernier chemin existant.

Notez que 

  • Microsoft enregistre toutes les versions 4.x de .NET - y compris la dernière version 4.7.1 - dans le dossier 4.0.30319. À cause de cela, si une version de .NET 4.x est installée, vous la trouverez là.

  • Si vous avez besoin de la version 64 bits plutôt que de la version 32 bits, remplacez simplement Framework par Framework64 dans la variable d'environnement dotNetBase (2e ligne du script).

  • Bien que csc.exe existe toujours, il est limité à C # version 5 (vous obtiendrez cet avertissement chaque fois que vous invoquerez csc.exe). Mais pour beaucoup de petites applications de console utiles, C # 5 est toujours correct. Si vous avez besoin d'une version supérieure (C # 6 ou 7), vous aurez besoin de Visual Studio ou de la zone Roslyn GitHub pour obtenir le code source du compilateur Roslyn.

1
Matt

Microsoft a bien documenté cela récemment - vérifiez ici

Le fichier exécutable csc.exe se trouve généralement dans le Dossier Microsoft.NET\Framework\sous le répertoire Windows. Son emplacement peut varier en fonction de la configuration exacte d'un ordinateur particulier. Si plusieurs versions du .NET Framework sont installé sur votre ordinateur, vous trouverez plusieurs versions de cela fichier.

1
Naren

Nécromancie.
Voici comment ils le font dans ReportViewer:

string compilerDirectory = System.IO.Path.Combine(
System.Environment.GetEnvironmentVariable("windir")
, "Microsoft.NET\\Framework" + (System.Environment.Is64BitProcess ? "64" : "")
, System.Runtime.InteropServices.RuntimeEnvironment.GetSystemVersion());

C:\WINDOWS\Microsoft.NET\Framework64\v4.0.30319
"C:\WINDOWS\Microsoft.NET\Framework64\v4.0.30319\vbc.exe" 
"C:\WINDOWS\Microsoft.NET\Framework64\v4.0.30319\csc.exe"

Mais en 2018, vous feriez mieux d'utiliser le compilateur intégré Roslyn:

Voici un exemple: 

         protected override System.CodeDom.Compiler.CompilerResults FromFileBatch(System.CodeDom.Compiler.CompilerParameters options, string[] fileNames)
        {

#if NETSTANDARD2_0
            return NetStandardFromFileBatch(options, fileNames);
#else
            return OldFromFileBatch(options, fileNames);
#endif
        }




#if NETSTANDARD2_0         



        protected System.CodeDom.Compiler.CompilerResults NetStandardFromFileBatch(System.CodeDom.Compiler.CompilerParameters options, string[] fileNames)
        {
            //// C:\Program Files\dotnet\sdk\2.0.0\Roslyn

            //string sysver = System.Runtime.InteropServices.RuntimeEnvironment.GetSystemVersion();
            //System.Console.WriteLine(sysver);


            //string pf64 = System.Environment.ExpandEnvironmentVariables("%ProgramW6432%");
            //string pf32 = System.Environment.ExpandEnvironmentVariables("%ProgramFiles(x86)%");
            //string pf = pf32;

            //if (System.IntPtr.Size * 8 == 64)
            //    pf = pf64;

            //// compilerDirectory = System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFiles);
            ////compilerDirectory = System.IO.Path.Combine(compilerDirectory, "dotnet", "sdk", "2.0.0", "Roslyn");
            //compilerDirectory = System.IO.Path.Combine(pf32, "MSBuild", "14.0", "Bin");
            //if (System.IntPtr.Size * 8 == 64)
            //    compilerDirectory = System.IO.Path.Combine(compilerDirectory, "AMD64");

            string assemblyName = System.IO.Path.GetFileNameWithoutExtension(options.OutputAssembly);

            Microsoft.CodeAnalysis.SyntaxTree[] syntaxTrees = new Microsoft.CodeAnalysis.SyntaxTree[fileNames.Length];

            for (int i = 0; i < fileNames.Length; ++i)
            {
                string fileContent = System.IO.File.ReadAllText(fileNames[i], System.Text.Encoding.UTF8);

                Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions op = null;

                // ERR_EncodinglessSyntaxTree = 37236 - Encoding must be specified... 
                syntaxTrees[i] = Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxTree.ParseText(
                    fileContent, op, fileNames[i], System.Text.Encoding.UTF8
                );

            }

            Microsoft.CodeAnalysis.MetadataReference[] references =
                new Microsoft.CodeAnalysis.MetadataReference[options.ReferencedAssemblies.Count];

            for (int i = 0; i < references.Length; ++i)
            {
                references[i] = Microsoft.CodeAnalysis.MetadataReference.CreateFromFile(
                    options.ReferencedAssemblies[i]
                );
            }



            Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions co =
                new Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions
            (
                Microsoft.CodeAnalysis.OutputKind.DynamicallyLinkedLibrary
            );

            co.WithOptionStrict(Microsoft.CodeAnalysis.VisualBasic.OptionStrict.Off);
            co.WithOptionExplicit(false);
            co.WithOptionInfer(true);

            Microsoft.CodeAnalysis.Compilation compilation = Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilation.Create(
                assemblyName,
                syntaxTrees,
                references,
                co
            );


            System.CodeDom.Compiler.CompilerResults compilerResults = new System.CodeDom.Compiler.CompilerResults(options.TempFiles);

            compilerResults.NativeCompilerReturnValue = -1;

            // using (var dllStream = new System.IO.MemoryStream())
            using (System.IO.FileStream dllStream = System.IO.File.Create(options.OutputAssembly))
            {
                using (System.IO.MemoryStream pdbStream = new System.IO.MemoryStream())
                {
                    Microsoft.CodeAnalysis.Emit.EmitResult emitResult = compilation.Emit(dllStream, pdbStream);
                    if (!emitResult.Success)
                    {

                        foreach (Microsoft.CodeAnalysis.Diagnostic diagnostic in emitResult.Diagnostics)
                        {
                            // options.TreatWarningsAsErrors
                            if (diagnostic.IsWarningAsError || diagnostic.Severity == Microsoft.CodeAnalysis.DiagnosticSeverity.Error)
                            {
                                string errorNumber = diagnostic.Id;
                                string errorMessage = diagnostic.GetMessage();

                                string message = $"{errorNumber}: {errorMessage};";
                                string fileName = diagnostic.Location.SourceTree.FilePath;

                                Microsoft.CodeAnalysis.FileLinePositionSpan lineSpan = diagnostic.Location.GetLineSpan();
                                string codeInQuestion = lineSpan.Path;
                                int line = lineSpan.StartLinePosition.Line;
                                int col = lineSpan.StartLinePosition.Character;

                                compilerResults.Errors.Add(
                                    new System.CodeDom.Compiler.CompilerError(fileName, line, col, errorNumber, errorMessage)
                                );
                            } // End if 

                        } // Next diagnostic 

                        // emitResult.Diagnostics
                        // CheckCompilationResult(emitResult);
                    }
                    else
                    {
                        compilerResults.PathToAssembly = options.OutputAssembly;
                        compilerResults.NativeCompilerReturnValue = 0;
                    }
                }
            }

            // compilerResults.CompiledAssembly = System.Reflection.Assembly.Load(array3, null);

            return compilerResults;
        }
#endif
0
Stefan Steiger