Program.RunScript.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Scripting;
using Microsoft.CodeAnalysis.Emit;
using Microsoft.CodeAnalysis.Scripting;
using Microsoft.CodeAnalysis.Scripting.Hosting;

namespace CSharpScriptRunner
{
 static partial class Program
 {
 sealed class Config
 {
 public string Type { get; set; }
 public string Method { get; set; }
 }

 static async Task<ErrorCodes> RunScript(string[] arguments)
 {
 const string NuGetReferenceRegex = @"^\s*#r\s+""\s*nuget:\s*(?<name>[\w\d.-]+)\s*[\/,]\s*(?<version>[\w\d.-]+)\s*""\s*$";

 IEnumerable<string> args = arguments;
 var runtimeExt = string.Empty;
 while (args.FirstOrDefault()?.StartsWith('-') ?? false)
 {
 var arg = args.First();
 args = args.Skip(1);
 if (arg.StartsWith("-r", StringComparison.OrdinalIgnoreCase))
 runtimeExt = arg.Substring(2);
 else
 {
 WriteLineError($"Argument {arg} is not recognized.", ConsoleColor.Red);
 return ErrorCodes.UnrecognizedArgument;
 }
 }

 var filePath = args.FirstOrDefault();
 if (!File.Exists(filePath))
 {
 WriteLineError($"Script file '{filePath}' does not exist.", ConsoleColor.Red);
 return ErrorCodes.ScriptFileDoesNotExist;
 }

 var scriptPath = Path.GetFullPath(filePath);
 if (string.IsNullOrEmpty(runtimeExt))
 runtimeExt = Path.GetExtension(Path.GetFileNameWithoutExtension(scriptPath)).TrimStart('.');
 if (!string.IsNullOrEmpty(runtimeExt))
 {
 var exePath = Process.GetCurrentProcess().MainModule.FileName;
 var filename = Path.GetFileName(exePath);
 var dir = Path.GetDirectoryName(Path.GetDirectoryName(exePath));
 var runtimeDir = Path.GetFileName(dir);
 dir = Path.GetDirectoryName(dir);
 if (runtimeExt != runtimeDir)
 {
 exePath = Path.Combine(dir, runtimeExt, "bin", filename);
 if (File.Exists(exePath))
 {
 using var process = Process.Start(new ProcessStartInfo(exePath, string.Join(" ", args.Select(x => $"\"{x.Replace("\"", "\\\"")}\""))) { UseShellExecute = false });
 await process.WaitForExitAsync();
 return (ErrorCodes)process.ExitCode;
 }

 WriteLine($"Warning: Runtime '{runtimeExt}' was not found. Proceeding anyway...", ConsoleColor.Yellow);
 }
 }

 var (buildReferences, assemblyLoader) = await LoadPackages(scriptPath);

 var cacheFileBase = GetCacheFilenameBase(scriptPath);
 var assemblyFile = cacheFileBase + ".dll";
 var hashFile = cacheFileBase + ".hash";
 var configFile = cacheFileBase + ".json";
 var scriptHash = GetFileHash(scriptPath);

 if (!TryGetCache(assemblyFile, hashFile, configFile, scriptHash, out var config))
 {
 // Check for new release only when compiling
 Process.Start(new ProcessStartInfo { FileName = Process.GetCurrentProcess().MainModule.FileName, Arguments = Verbs.Update, CreateNoWindow = true, UseShellExecute = false });

 if (!TryBuild(scriptPath, assemblyFile, hashFile, configFile, scriptHash, buildReferences, out config))
 return ErrorCodes.ScriptCompilationFailed;
 }

 var assembly = Assembly.Load(File.ReadAllBytes(assemblyFile));
 var type = assembly.GetType(config.Type);
 if (type == null)
 throw new Exception($"Entry type '{config.Type}' not found");
 var entryPoint = type.GetMethod(config.Method, BindingFlags.Static | BindingFlags.Public);
 if (entryPoint == null)
 throw new Exception($"Entry point '{config.Type}.{config.Method}' not found");

 // Clear SynchronizationContext to mimic standard console app behavior in script
 using (var nullSyncCtxScope = new SynchronizationContextScope())
 {
 nullSyncCtxScope.Install(null);

 Debug.Assert(Thread.CurrentThread.GetApartmentState() == ApartmentState.STA);

 var task = (Task<object>)entryPoint.Invoke(null, new object[] { new object[] { new ScriptGlobals(args.Skip(1).ToArray()), assemblyLoader } });
 var errorCode = (ErrorCodes?)((await task) as int?) ?? ErrorCodes.OK;
 if (errorCode > ErrorCodes.OK && errorCode <= ErrorCodes.Reserved)
 return ErrorCodes.ScriptReturnRangeConflict;
 return errorCode;
 }

 static string GetCacheFilenameBase(string filename)
 {
 using (var hasher = SHA256.Create())
 {
 var bytes = hasher.ComputeHash(Encoding.Unicode.GetBytes(filename.ToUpperInvariant()));
 var result = new StringBuilder(bytes.Length * 2);
 foreach (var b in bytes)
 result.Append(b.ToString("X2"));
 Directory.CreateDirectory(CachePath);
 return Path.Combine(CachePath, result.ToString());
 }
 }

 static byte[] GetFileHash(string filename)
 {
 var bytes = File.ReadAllBytes(filename);
 using (var hasher = SHA256.Create())
 {
 return hasher.ComputeHash(bytes);
 }
 }

 static bool TryGetCache(string assemblyFile, string hashFile, string configFile, byte[] scriptHash, out Config config)
 {
 config = null;
 if (!File.Exists(assemblyFile) || !File.Exists(hashFile) || !File.Exists(configFile))
 return false;

 var cachedHash = File.ReadAllBytes(hashFile);
 if (!cachedHash.SequenceEqual(scriptHash))
 return false;

 var cfgJson = File.ReadAllText(configFile, Encoding.UTF8);
 config = JsonSerializer.Deserialize<Config>(cfgJson);
 return true;
 }

 static bool TryBuild(string scriptFile, string assemblyFile, string hashFile, string configFile, byte[] scriptHash, IEnumerable<string> references, out Config config)
 {
 config = null;
 var lines = File.ReadAllLines(scriptFile);
 Console.WriteLine($"Compiling script '{scriptFile}'...");
 var options = ScriptOptions.Default
 .WithEmitDebugInformation(true)
 .WithFilePath(scriptFile)
 .WithFileEncoding(Encoding.UTF8)
 .AddReferences(references)
 ;

 var script = string.Join(Environment.NewLine, lines);
 script = Regex.Replace(script, NuGetReferenceRegex, match => new string(match.Value.Select(x => char.IsWhiteSpace(x) ? x : ' ').ToArray()), RegexOptions.Multiline | RegexOptions.IgnoreCase);
 var compilation = CSharpScript.Create(script, options, typeof(ScriptGlobals)).GetCompilation();
 //compilation = compilation.WithOptions(compilation.Options.WithOutputKind(OutputKind.ConsoleApplication));
 using (var stream = File.OpenWrite(assemblyFile))
 {
 var result = compilation.Emit(stream, options: new EmitOptions(debugInformationFormat: DebugInformationFormat.Embedded));
 PrintCompilationDiagnostics(result, lines);
 if (!result.Success)
 return false;
 }

 File.WriteAllBytes(hashFile, scriptHash);

 var scriptEntryPoint = compilation.GetEntryPoint(default);
 config = new Config
 {
 Type = scriptEntryPoint.ContainingType.MetadataName,
 Method = scriptEntryPoint.Name
 };

 var json = JsonSerializer.Serialize(config);
 File.WriteAllText(configFile, json, Encoding.UTF8);
 return true;
 }

 static async Task<(IEnumerable<string> BuildReferences, InteractiveAssemblyLoader assemblyLoader1)> LoadPackages(string scriptPath)
 {
 var buildReferences = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
 var runtimeReferences = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
 var matches = Regex.Matches(File.ReadAllText(scriptPath), NuGetReferenceRegex, RegexOptions.Multiline | RegexOptions.IgnoreCase);
 foreach (Match match in matches)
 await NuGet.LoadPackage(match.Groups["name"].Value, match.Groups["version"].Value, buildReferences, runtimeReferences);

 var assemblyLoader = new InteractiveAssemblyLoader();
 foreach (var path in runtimeReferences)
 assemblyLoader.RegisterDependency(Assembly.LoadFrom(path));
 return (buildReferences, assemblyLoader);
 }

 static void PrintCompilationDiagnostics(EmitResult result, string[] lines)
 {
 var color = Console.ForegroundColor;
 foreach (var diag in result.Diagnostics)
 {
 switch (diag.Severity)
 {
 case DiagnosticSeverity.Warning: Console.ForegroundColor = ConsoleColor.Yellow; break;
 case DiagnosticSeverity.Error: Console.ForegroundColor = ConsoleColor.Red; break;
 default: Console.ForegroundColor = color; break;
 }

 var loc = diag.Location.GetLineSpan();
 Console.WriteLine($"{diag.Severity} ({loc.StartLinePosition.Line}, {loc.StartLinePosition.Character}): {diag.GetMessage()}");
 if (lines != null)
 {
 var color2 = Console.ForegroundColor;
 var codeStart = lines[loc.StartLinePosition.Line].Substring(0, loc.StartLinePosition.Character);
 var codeEnd = lines[loc.EndLinePosition.Line].Substring(loc.EndLinePosition.Character);
 var code = string.Join(Environment.NewLine, lines.Skip(loc.StartLinePosition.Line).Take(loc.EndLinePosition.Line - loc.StartLinePosition.Line + 1));
 code = code.Substring(codeStart.Length, code.Length - codeStart.Length - codeEnd.Length);

 Console.ForegroundColor = color;
 Console.Write(codeStart);
 Console.ForegroundColor = color2;
 Console.Write(code);
 Console.ForegroundColor = color;
 Console.Write(codeEnd);
 Console.WriteLine();
 }
 }
 Console.ForegroundColor = color;
 }
 }
 }
}