public static byte[] GenerateErrorHtml(bool showDetails, IRuntimeEnvironment runtimeEnvironment, Exception exception)
        {
            // Build the message for each error
            var builder = new StringBuilder();
            var rawExceptionDetails = new StringBuilder();

            if (!showDetails)
            {
                WriteMessage("An error occurred while starting the application.", builder);
            }
            else
            {
                Debug.Assert(exception != null);
                var wasSourceCodeWrittenOntoPage = false;
                var flattenedExceptions = FlattenAndReverseExceptionTree(exception);
                foreach (var innerEx in flattenedExceptions)
                {
                    WriteException(innerEx, builder, ref wasSourceCodeWrittenOntoPage);
                }

                WriteRawExceptionDetails("Show raw exception details", exception.ToString(), rawExceptionDetails);
            }

            // Generate the footer
            var footer = showDetails ? GenerateFooterEncoded(runtimeEnvironment) : null;

            // And generate the full markup
            return Encoding.UTF8.GetBytes(string.Format(CultureInfo.InvariantCulture, _errorPageFormatString, builder, rawExceptionDetails, footer));
        }

        public static void Register(CommandLineApplication cmdApp, IApplicationEnvironment appEnvironment, IAssemblyLoadContextAccessor loadContextAccessor, IRuntimeEnvironment runtimeEnvironment)
        {
            cmdApp.Command("graph", (Action<CommandLineApplication>)(c => {
            c.Description = "Perform parsing, static analysis, semantic analysis, and type inference";

            c.HelpOption("-?|-h|--help");

            c.OnExecute((Func<System.Threading.Tasks.Task<int>>)(async () => {
              var jsonIn = await Console.In.ReadToEndAsync();
              var sourceUnit = JsonConvert.DeserializeObject<SourceUnit>(jsonIn);

              var root = Directory.GetCurrentDirectory();
              var dir = Path.Combine(root, sourceUnit.Dir);
              var context = new GraphContext
              {
            RootPath = root,
            SourceUnit = sourceUnit,
            ProjectDirectory = dir,
            HostEnvironment = appEnvironment,
            LoadContextAccessor = loadContextAccessor,
            RuntimeEnvironment = runtimeEnvironment
              };

              var result = await GraphRunner.Graph(context);

              Console.WriteLine(JsonConvert.SerializeObject(result, Formatting.Indented));
              return 0;
            }));
              }));
        }

 // This is intentionally NOT an extension method because it is only really here for testing
 internal static IEnumerable<string> GetAllRuntimeIdentifiersWithoutOverride(IRuntimeEnvironment env)
 {
     if (!string.Equals(env.OperatingSystem, RuntimeOperatingSystems.Windows, StringComparison.Ordinal))
     {
         yield return GetRuntimeIdentifierWithoutOverride(env);
     }
     else
     {
         var arch = env.RuntimeArchitecture.ToLowerInvariant();
         if (env.OperatingSystemVersion.Equals("6.1", StringComparison.Ordinal))
         {
             yield return "win7-" + arch;
         }
         else if (env.OperatingSystemVersion.Equals("6.2", StringComparison.Ordinal))
         {
             yield return "win8-" + arch;
             yield return "win7-" + arch;
         }
         else if (env.OperatingSystemVersion.Equals("6.3", StringComparison.Ordinal))
         {
             yield return "win81-" + arch;
             yield return "win8-" + arch;
             yield return "win7-" + arch;
         }
         else if (env.OperatingSystemVersion.Equals("10.0", StringComparison.Ordinal))
         {
             yield return "win10-" + arch;
             yield return "win81-" + arch;
             yield return "win8-" + arch;
             yield return "win7-" + arch;
         }
     }
 }

    public static void Register(CommandLineApplication cmdApp, IApplicationEnvironment appEnv, IRuntimeEnvironment runtimeEnv)
    {
      if (runtimeEnv.OperatingSystem == "Windows")
      {
        _dnuPath = new Lazy<string>(FindDnuWindows);
      }
      else
      {
        _dnuPath = new Lazy<string>(FindDnuNix);
      }

      cmdApp.Command("depresolve", c => {
        c.Description = "Perform a combination of parsing, static analysis, semantic analysis, and type inference";

        c.HelpOption("-?|-h|--help");

        c.OnExecute(async () => {
          //System.Diagnostics.Debugger.Launch();
          var jsonIn = await Console.In.ReadToEndAsync();
          var sourceUnit = JsonConvert.DeserializeObject<SourceUnit>(jsonIn);

          var dir = Path.Combine(Directory.GetCurrentDirectory(), sourceUnit.Dir);
          var deps = await DepResolve(dir);

          var result = new List<Resolution>();
          foreach(var dep in deps)
          {
            result.Add(Resolution.FromLibrary(dep));
          }

          Console.WriteLine(JsonConvert.SerializeObject(result, Formatting.Indented));
          return 0;
        });
      });
    }

 private static string GetDefaultDotNetReferenceAssembliesPath(IFileSystem fileSystem, IRuntimeEnvironment runtimeEnvironment)
 {            
     var os = runtimeEnvironment.OperatingSystemPlatform;
     
     if (os == Platform.Windows)
     {
         return null;
     }
     
     if (os == Platform.Darwin && 
         fileSystem.Directory.Exists("/Library/Frameworks/Mono.framework/Versions/Current/lib/mono/xbuild-frameworks"))
     {
         return "/Library/Frameworks/Mono.framework/Versions/Current/lib/mono/xbuild-frameworks";
     }
     
     if (fileSystem.Directory.Exists("/usr/local/lib/mono/xbuild-frameworks"))
     {
         return "/usr/local/lib/mono/xbuild-frameworks";
     }
     
     if (fileSystem.Directory.Exists("/usr/lib/mono/xbuild-frameworks"))
     {
         return "/usr/lib/mono/xbuild-frameworks";
     }
     
     return null;
 }

        internal static RSA GenerateKey(IRuntimeEnvironment environment) {
            if (string.Equals(environment.OperatingSystem, "Windows", StringComparison.OrdinalIgnoreCase)) {
#if DNXCORE50
                // On CoreCLR, use RSACng.
                return new RSACng(2048);
#else
                // On desktop CLR, use RSACryptoServiceProvider.
                return new RSACryptoServiceProvider(2048);
#endif
            }

            // When the runtime is identified as Mono, use RSACryptoServiceProvider, independently of the operating system.
            if (string.Equals(environment.RuntimeType, "Mono", StringComparison.OrdinalIgnoreCase)) {
                return new RSACryptoServiceProvider(2048);
            }

#if DNXCORE50
            // On Linux and Darwin, use RSAOpenSsl when running on CoreCLR.
            if (string.Equals(environment.OperatingSystem, "Linux", StringComparison.OrdinalIgnoreCase) ||
                string.Equals(environment.OperatingSystem, "Darwin", StringComparison.OrdinalIgnoreCase)) {
                return new RSAOpenSsl(2048);
            }
#endif

            // If no appropriate implementation can be found, throw an exception.
            throw new PlatformNotSupportedException("No RSA implementation compatible with your configuration can be found.");
        }

        public Program(IRuntimeEnvironment runtimeEnvironment)
        {
            _loggerFactory = new LoggerFactory();

            var commandProvider = new CommandOutputProvider(runtimeEnvironment);
            _loggerFactory.AddProvider(commandProvider);
        }

 public Startup(IHostingEnvironment hostingEnvironment, IApplicationEnvironment applicationEnvironment, IRuntimeEnvironment runtimeEnvironment)
 {
   log("Startup");
   log("Platform = " + runtimeEnvironment.OperatingSystem);
   string PrjFolder = "";
   // Set up configuration sources.
   var builder = new ConfigurationBuilder()
       .AddJsonFile("appsettings.json")
       .AddEnvironmentVariables();
   Configuration = builder.Build();
   try
   {
     PrjFolder = Directory.GetParent(hostingEnvironment.WebRootPath).FullName;
   }
   catch
   {
     // bei migrations klappts nicht mit der Ermittlung des Pfads aus env
     PrjFolder = Directory.GetCurrentDirectory();
     log("Could't get project folder from HostingEnvironment, using CurDir: " + PrjFolder);
   }
   _DataFolder = Path.Combine(PrjFolder, "data");
   log("DataFolder = " + _DataFolder);
   // Ordner überprüfen
   try
   {
     string AcessTestFileName = Path.Combine(_DataFolder, "_accestest.accestest");
     File.Create(AcessTestFileName);
   }
   catch (Exception E)
   {
     log("Could't write in DataFolder: " + E.Message);
   }
 }

        /// <summary>
        /// Uses Reflection to verify that the specified member signatures are present in emitted metadata
        /// </summary>
        /// <param name="appDomainHost">Unit test AppDomain host</param>
        /// <param name="expectedSignatures">Baseline signatures - use the Signature() factory method to create instances of SignatureDescription</param>
        internal static void VerifyMemberSignatures(
            IRuntimeEnvironment appDomainHost, params SignatureDescription[] expectedSignatures)
        {
            Assert.NotNull(expectedSignatures);
            Assert.NotEmpty(expectedSignatures);

            var succeeded = true;
            var expected = new List<string>();
            var actual = new List<string>();

            foreach (var signature in expectedSignatures)
            {
                List<string> actualSignatures = null;
                var expectedSignature = signature.ExpectedSignature;

                if (!VerifyMemberSignatureHelper(
                    appDomainHost, signature.FullyQualifiedTypeName, signature.MemberName,
                    ref expectedSignature, out actualSignatures))
                {
                    succeeded = false;
                }

                expected.Add(expectedSignature);
                actual.AddRange(actualSignatures);
            }

            if (!succeeded)
            {
                TriggerSignatureMismatchFailure(expected, actual);
            }
        }

 public Program(IRuntimeEnvironment runtimeEnv)
 {
     var loggerFactory = new LoggerFactory();
     CommandOutputProvider = new CommandOutputProvider(runtimeEnv);
     loggerFactory.AddProvider(CommandOutputProvider);
     Logger = loggerFactory.CreateLogger<Program>();
 }

 public static PlatformServices Create(
     PlatformServices basePlatformServices,
     IApplicationEnvironment application = null,
     IRuntimeEnvironment runtime = null,
     IAssemblyLoaderContainer container = null,
     IAssemblyLoadContextAccessor accessor = null,
     ILibraryManager libraryManager = null)
 {
     if (basePlatformServices == null)
     {
         return new DefaultPlatformServices(
             application,
             runtime,
             container,
             accessor,
             libraryManager
         );
     }
     return new DefaultPlatformServices(
             application ?? basePlatformServices.Application,
             runtime ?? basePlatformServices.Runtime,
             container ?? basePlatformServices.AssemblyLoaderContainer,
             accessor ?? basePlatformServices.AssemblyLoadContextAccessor,
             libraryManager ?? basePlatformServices.LibraryManager
         );
 }

 public CompilationEngineContext(IApplicationEnvironment applicationEnvironment,
                                 IRuntimeEnvironment runtimeEnvironment,
                                 IAssemblyLoadContext defaultLoadContext,
                                 CompilationCache cache)
     : this(applicationEnvironment, runtimeEnvironment, defaultLoadContext, cache, NoopWatcher.Instance)
 {
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="RuntimeInfoMiddleware"/> class
        /// </summary>
        /// <param name="next"></param>
        /// <param name="options"></param>
        public RuntimeInfoMiddleware(
            RequestDelegate next,
            RuntimeInfoPageOptions options,
            ILibraryManager libraryManager,
            IRuntimeEnvironment runtimeEnvironment)
        {
            if (next == null)
            {
                throw new ArgumentNullException(nameof(next));
            }

            if (options == null)
            {
                throw new ArgumentNullException(nameof(options));
            }

            if (libraryManager == null)
            {
                throw new ArgumentNullException(nameof(libraryManager));
            }

            if (runtimeEnvironment == null)
            {
                throw new ArgumentNullException(nameof(runtimeEnvironment));
            }

            _next = next;
            _options = options;
            _libraryManager = libraryManager;
            _runtimeEnvironment = runtimeEnvironment;
        }

        /// <summary>
        /// Uses Reflection to verify that the specified member signature is present in emitted metadata
        /// </summary>
        /// <param name="appDomainHost">Unit test AppDomain host</param>
        /// <param name="fullyQualifiedTypeName">
        /// Fully qualified type name for member
        /// Names must be in format recognized by reflection
        /// e.g. MyType&lt;T&gt;.MyNestedType&lt;T, U&gt; => MyType`1+MyNestedType`2
        /// </param>
        /// <param name="memberName">
        /// Name of member on specified type whose signature needs to be verified
        /// Names must be in format recognized by reflection
        /// e.g. For explicitly implemented member - I1&lt;string&gt;.Method => I1&lt;System.String&gt;.Method
        /// </param>
        /// <param name="expectedSignature">
        /// Baseline string for signature of specified member
        /// Skip this argument to get an error message that shows all available signatures for specified member
        /// This argument is passed by reference and it will be updated with a formatted form of the baseline signature for error reporting purposes
        /// </param>
        /// <param name="actualSignatures">List of found signatures matching member name</param>
        /// <returns>True if a matching member signature was found, false otherwise</returns>
        private static bool VerifyMemberSignatureHelper(
            IRuntimeEnvironment appDomainHost, string fullyQualifiedTypeName, string memberName,
            ref string expectedSignature, out List<string> actualSignatures)
        {
            Assert.False(string.IsNullOrWhiteSpace(fullyQualifiedTypeName), "'fullyQualifiedTypeName' can't be null or empty");
            Assert.False(string.IsNullOrWhiteSpace(memberName), "'memberName' can't be null or empty");

            var retVal = true; actualSignatures = new List<string>();
            var signatures = appDomainHost.GetMemberSignaturesFromMetadata(fullyQualifiedTypeName, memberName);
            var signatureAssertText = "Signature(\"" + fullyQualifiedTypeName + "\", \"" + memberName + "\", \"{0}\"),";

            if (!string.IsNullOrWhiteSpace(expectedSignature))
            {
                expectedSignature = expectedSignature.Replace("\"", "\\\"");
            }
            expectedSignature = string.Format(signatureAssertText, expectedSignature);

            if (signatures.Count > 1)
            {
                var found = false;
                foreach (var signature in signatures)
                {
                    var actualSignature = signature.Replace("\"", "\\\"");
                    actualSignature = string.Format(signatureAssertText, actualSignature);

                    if (actualSignature == expectedSignature)
                    {
                        actualSignatures.Clear();
                        actualSignatures.Add(actualSignature);
                        found = true; break;
                    }
                    else
                    {
                        actualSignatures.Add(actualSignature);
                    }
                }
                if (!found)
                {
                    retVal = false;
                }
            }
            else if (signatures.Count == 1)
            {
                var actualSignature = signatures.First().Replace("\"", "\\\"");
                actualSignature = string.Format(signatureAssertText, actualSignature);
                actualSignatures.Add(actualSignature);

                if (expectedSignature != actualSignature)
                {
                    retVal = false;
                }
            }
            else
            {
                retVal = false;
            }

            return retVal;
        }

        public static byte[] GenerateErrorHtml(bool showDetails, IRuntimeEnvironment runtimeEnvironment, params object[] errorDetails)
        {
            if (!showDetails)
            {
                errorDetails = new[] { "An error occurred while starting the application." };
            }

            // Build the message for each error
            var wasSourceCodeWrittenOntoPage = false;
            var builder = new StringBuilder();
            var rawExceptionDetails = new StringBuilder();

            foreach (object error in errorDetails ?? new object[0])
            {
                var ex = error as Exception;
                if (ex == null && error is ExceptionDispatchInfo)
                {
                    ex = ((ExceptionDispatchInfo)error).SourceException;
                }

                if (ex != null)
                {
                    var flattenedExceptions = FlattenAndReverseExceptionTree(ex);

                    var compilationException = flattenedExceptions.OfType<ICompilationException>()
                                                                  .FirstOrDefault();
                    if (compilationException != null)
                    {
                        WriteException(compilationException, builder, ref wasSourceCodeWrittenOntoPage);

                        var compilationErrorMessages = compilationException.CompilationFailures
                            .SelectMany(f => f.Messages.Select(m => m.FormattedMessage))
                            .Take(MaxCompilationErrorsToShow);

                        WriteRawExceptionDetails("Show raw compilation error details", compilationErrorMessages, rawExceptionDetails);
                    }
                    else
                    {
                        foreach (var innerEx in flattenedExceptions)
                        {
                            WriteException(innerEx, builder, ref wasSourceCodeWrittenOntoPage);
                        }

                        WriteRawExceptionDetails("Show raw exception details", new[] { ex.ToString() }, rawExceptionDetails);
                    }
                }
                else
                {
                    var message = Convert.ToString(error, CultureInfo.InvariantCulture);
                    WriteMessage(message, builder);
                }
            }

            // Generate the footer
            var footer = showDetails ? GenerateFooterEncoded(runtimeEnvironment) : null;

            // And generate the full markup
            return Encoding.UTF8.GetBytes(string.Format(CultureInfo.InvariantCulture, _errorPageFormatString, builder, rawExceptionDetails, footer));
        }

 public static void Update(this RuntimeEnvironment source, IRuntimeEnvironment environment)
 {
     source.OperatingSystem = environment.OperatingSystem;
     source.OperatingSystemVersion = environment.OperatingSystemVersion;
     source.RuntimeArchitecture = environment.RuntimeArchitecture;
     source.RuntimeType = environment.RuntimeType;
     source.RuntimeVersion = environment.RuntimeVersion;
 }

        public Startup(IApplicationEnvironment env, IRuntimeEnvironment runtimeEnvironment)
        {
            // Setup configuration sources.
            var builder = new ConfigurationBuilder(env.ApplicationBasePath)
                .AddJsonFile("config.json");

            builder.AddEnvironmentVariables();
            Configuration = builder.Build();
        }

        //  private readonly Platform _platform;
        public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv, IRuntimeEnvironment runtimeEnvironment)
        {
            var builder = new ConfigurationBuilder()
                .SetBasePath(appEnv.ApplicationBasePath)
                .AddJsonFile("config.json")
                .AddEnvironmentVariables();

            Configuration = builder.Build();
        }

        public EnvironmentController(
            ILoggerFactory loggerFactory,
            IRuntimeEnvironment runtimeEnv)
            : base(loggerFactory.CreateLogger(nameof(EnvironmentController)))
        {
            this.runtimeEnv = runtimeEnv;

            this.hostname = Environment.MachineName;
        }

        public TestLogger(IRuntimeEnvironment runtimeEnv, bool debug = false)
        {
            var commandOutputProvider = new CommandOutputProvider(runtimeEnv);
            if (debug)
            {
                commandOutputProvider.LogLevel = LogLevel.Debug;
            }

            _commandOutputLogger = (CommandOutputLogger)commandOutputProvider.CreateLogger("");
        }