pintar - print c#

¿Cómo obtener la ruta csc.exe?

Question

¿Hay una manera de obtener la ruta para el último csc.exe de .NET Framework?

El archivo normalmente se encuentra en: c: / Windows / Microsoft.NET / Framework / vX.X.XXX pero el problema es que puede haber varias versiones instaladas + hay versiones de 32 y 64 bits.

¿Alguna solución a esto?

Answer 1

Actualizado:

Abra el Símbolo del sistema o PowerShell y ejecute el siguiente comando para obtener una lista de la ruta completa de los compiladores para las diferentes versiones de .Net Frameworks instaladas.

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

Ruta CSC es la siguiente:

C: / Archivos de programa / MSBuild // Bin

Ej .: Será 12.0, si está utilizando Visual Studio 2013.

Answer 2

La mejor manera de encontrar la ruta CSC.exe se ejecuta en CLI (Intérprete de línea de comandos) en esa línea simple:

dir /s %WINDIR%/CSC.EXE

dir - muestra el directorio

/ s - incluye subcarpetas

% WINDIR% / CSC.EXE: busca en la carpeta raíz frases como "CSC.exe".

Y es nuestro resultado:

Entonces podemos simplemente compilar código ejemplo por línea como:

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

Saludos.

Answer 3

Microsoft ha documentado esto bien recientemente - verifique here

El archivo ejecutable csc.exe generalmente se encuentra en la carpeta Microsoft.NET / Framework / en el directorio de Windows. Su ubicación puede variar según la configuración exacta de una computadora en particular. Si hay más de una versión de .NET Framework instalada en su computadora, encontrará varias versiones de este archivo.

Answer 4

Nigromancia.
Así es como lo hacen en 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" 

Pero en 2018, sería mejor usar el compilador incorporado de Roslyn:

Aquí un ejemplo:

 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

Answer 5

Puede usar 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

Answer 6

Si ya instaló Visual Studio, simplemente: Haga clic en Inicio, señale Todos los programas, señale Microsoft Visual Studio, señale Visual Studio Tools, y luego haga clic en Visual Studio Command Prompt y ahí tiene su cuadro de línea de comando donde compila de la siguiente manera:

csc PathToYourCsSource

Answer 7

Supongo que quieres usar csc.exe para compilar archivos, por eso csc.exe la ruta. En lugar de buscar en el registro para este propósito, puede usar la siguiente secuencia de comandos por lotes que he creado para obtener la ruta al último archivo 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 

CompileCS.cmd como CompileCS.cmd y CompileCS.cmd en la misma ruta que sus archivos * .cs. Entonces puedes simplemente compilarlo de la siguiente manera:

CompileCS GetDotNetVersion.cs

Que compilará la aplicación de consola GetDotNetVersion, un programa para determinar las versiones .NET instaladas, que he publicado here.

Sugerencia: si desea ejecutar la aplicación C # automáticamente después de la compilación, agregue
%outPath%%outFileName%.exe
hasta el final del script por lotes.

La secuencia de comandos comprueba la existencia de los directorios del sistema para .NET 2.0.x, 3.5 y 4.0.30319; en otras carpetas nunca he visto csc.exe. Debido a que realiza la comprobación de la versión más antigua a la más nueva, la variable dotNet contiene la última ruta existente.

Tenga en cuenta que

• Microsoft almacena todas las versiones 4.x de .NET, incluida la última versión 4.7.1, en la carpeta 4.0.30319. Por eso, si se instala alguna versión de .NET 4.x, la encontrará allí.

• Si necesita la versión de 64 bits en lugar de la versión de 32 bits, simplemente reemplace Framework por Framework64 en la variable de entorno dotNetBase (2ª línea del script).

• Si bien csc.exe aún existe, está restringido a C # versión 5 (recibirá esta advertencia cada vez que invoque a csc.exe). Pero para muchas pequeñas aplicaciones de consola útiles, C # 5 todavía está bien. Si necesita una versión superior (C # 6 o 7), entonces necesitará Visual Studio o puede visitar el área de Roslyn GitHub para obtener el código fuente del compilador de Roslyn.

Answer 8

c: / Windows / Microsoft.NET / Framework / vX.X.XXX Debe contener la última versión de csc.exe de 32 bits

c: / Windows / Microsoft.NET / Framework64 / vX.X.XXX Debe contener la última versión de 64 bits de csc.exe

Eso es lo que es para el mío de todos modos.

Por cierto: puede acceder a ambos utilizando la línea de comandos de Visual Studio desde la carpeta de herramientas de Visual Studio en sus archivos de programa. Automáticamente configura todas las rutas que necesita para crear aplicaciones de 32 y 64 bits con su compilador csc.