static EntryAssemblyInformation()
{
EntryAssembly = Assembly.GetEntryAssembly();
foreach (object obj in EntryAssembly.GetCustomAttributes(typeof(AssemblyTitleAttribute), true))
{
Title = (string)typeof(AssemblyTitleAttribute).GetProperty("Title").GetValue(obj, null);
}
foreach (object obj in EntryAssembly.GetCustomAttributes(typeof(AssemblyDescriptionAttribute), true))
{
Description = ((AssemblyDescriptionAttribute)obj).Description;
}
foreach (object obj in EntryAssembly.GetCustomAttributes(typeof(AssemblyCompanyAttribute), true))
{
Company = ((AssemblyCompanyAttribute)obj).Company;
}
foreach (object obj in EntryAssembly.GetCustomAttributes(typeof(AssemblyProductAttribute), true))
{
Product = ((AssemblyProductAttribute)obj).Product;
}
foreach (object obj in EntryAssembly.GetCustomAttributes(typeof(AssemblyCopyrightAttribute), true))
{
Copyright = ((AssemblyCopyrightAttribute)obj).Copyright;
}
Version = EntryAssembly.GetName().Version.ToString();
StartupPath = System.Windows.Forms.Application.StartupPath;
}
private static void logStartupState(Configuration config)
{
// begin logging session with a form feed
Log.Logger.Information("\r\n\f");
Log.Logger.Information("Begin. {@DebugInfo}", new
{
AppName = EntryAssembly.GetName().Name,
Version = BuildVersion.ToString(),
#if DEBUG
Mode = "Debug",
#else
Mode = "Release",
#endif
LogLevel_Verbose_Enabled = Log.Logger.IsVerboseEnabled(),
LogLevel_Debug_Enabled = Log.Logger.IsDebugEnabled(),
LogLevel_Information_Enabled = Log.Logger.IsInformationEnabled(),
LogLevel_Warning_Enabled = Log.Logger.IsWarningEnabled(),
LogLevel_Error_Enabled = Log.Logger.IsErrorEnabled(),
LogLevel_Fatal_Enabled = Log.Logger.IsFatalEnabled(),
config.LibationFiles,
AudibleFileStorage.BooksDirectory,
config.InProgress,
AudibleFileStorage.DownloadsInProgressDirectory,
DownloadsInProgressFiles = Directory.EnumerateFiles(AudibleFileStorage.DownloadsInProgressDirectory).Count(),
AudibleFileStorage.DecryptInProgressDirectory,
DecryptInProgressFiles = Directory.EnumerateFiles(AudibleFileStorage.DecryptInProgressDirectory).Count(),
});
}
protected override string GetFileName()
{
var basepath = Environment.ExpandEnvironmentVariables("%HOMEDRIVE%%HOMEPATH%");
var assemblyName = EntryAssembly.GetName().Name;
var filepath = Path.Combine(basepath, "settings", $"{assemblyName}.json");
return(filepath);
}
private static T getAttribute <T> () where T : Attribute
{
object[] attributes = EntryAssembly.GetCustomAttributes(typeof(T), false);
if (attributes.Length == 0)
{
return(null);
}
return(attributes[0] as T);
}
/// <summary>
/// Initializes static members of the <see cref="EmbeddedResources"/> class.
/// </summary>
static EmbeddedResources()
{
EntryAssembly = typeof(EmbeddedResources).GetTypeInfo().Assembly;
ResourceNames = new ReadOnlyCollection <string>(EntryAssembly.GetManifestResourceNames());
var uri = new UriBuilder(EntryAssembly.CodeBase);
var path = Uri.UnescapeDataString(uri.Path);
EntryAssemblyDirectory = Path.GetDirectoryName(path);
}
/// <summary>
/// Initializes a new instance of the <see cref="App"/> class.
/// </summary>
/// <param name="owner">The owner program.</param>
/// <param name="plugin">The plugin.</param>
/// <param name="assemblyName">The assembly containg the plugin code and resources.</param>
public App(Application owner, IPluginClient plugin, string assemblyName)
{
Owner = owner;
Plugin = plugin;
AssemblyName = assemblyName;
// Ensure only one instance is running at a time.
Logger.Write(Category.Debug, "Checking uniqueness");
try
{
AppGuid = Plugin.Guid;
if (AppGuid == Guid.Empty)
{
// In case the guid is provided by the project settings and not source code.
Contract.RequireNotNull(Assembly.GetEntryAssembly(), out Assembly EntryAssembly);
Contract.RequireNotNull(EntryAssembly.GetCustomAttribute <GuidAttribute>(), out GuidAttribute AppGuidAttribute);
AppGuid = Guid.Parse(AppGuidAttribute.Value);
}
string AppUniqueId = AppGuid.ToString("B").ToUpperInvariant();
// Try to create a global named event with a unique name. If we can create it we are first, otherwise there is another instance.
// In that case, we just abort.
bool createdNew;
InstanceEvent = new EventWaitHandle(false, EventResetMode.ManualReset, AppUniqueId, out createdNew);
if (!createdNew)
{
Logger.Write(Category.Warning, "Another instance is already running");
InstanceEvent.Close();
InstanceEvent = null;
Owner.Shutdown();
return;
}
}
catch (Exception e)
{
Logger.Write(Category.Error, $"(from App) {e.Message}");
Owner.Shutdown();
return;
}
// This code is here mostly to make sure that the Taskbar static class is initialized ASAP.
// The taskbar rectangle is never empty. And if it is, we have no purpose.
if (TaskbarLocation.ScreenBounds.IsEmpty)
{
Owner.Shutdown();
}
else
{
Owner.Startup += OnStartup;
// Make sure we stop only on a call to Shutdown. This is for plugins that have a main window, we don't want to exit when it's closed.
Owner.ShutdownMode = ShutdownMode.OnExplicitShutdown;
}
}
private static void GetAllAssemblies()
{
void addAssemblies()
{
for (int i = 0; i < AssembliesCore._referencedAssemblies.Length; i++)
{
AddAssembly(AssembliesCore._referencedAssemblies[i], false);
}
}
AddAssembly(EntryAssembly, false);
if (AssembliesCore._referencedAssemblies == null)
{
var cauldronHelper = EntryAssembly.GetType("CauldronInterceptionHelper")?.GetMethod("GetReferencedAssemblies", BindingFlags.Public | BindingFlags.Static);
if (cauldronHelper != null)
{
if (cauldronHelper.Invoke(null, null) is Assembly[] refAssemblies && refAssemblies.Length > 0)
{
AssembliesCore._referencedAssemblies = refAssemblies;
addAssemblies();
return;
}
}
var assemblies = new List <Assembly>();
var allAssemblies = AppDomain.CurrentDomain.GetAssemblies();
for (int i = 0; i < allAssemblies.Length; i++)
{
var assembly = allAssemblies[i];
if (AddAssembly(assembly, false) != null)
{
var referencedAssemblies = assembly.GetReferencedAssemblies();
for (int c = 0; c < referencedAssemblies.Length; c++)
{
LoadAssembly(referencedAssemblies[c]);
}
}
}
;
return;
}
addAssemblies();
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
//Class1 test = new Class1();
Assembly EntryAssembly;
EntryAssembly = System.Reflection.Assembly.GetExecutingAssembly();
foreach (AssemblyName Name in EntryAssembly.GetReferencedAssemblies())
{
Console.WriteLine("Name: {0}", Name.ToString());
}
Startup startup = new Startup();
startup.Start();
}
public void InitializeServices(AutofacServiceProvider rootServices)
{
TenantServices ??= new AutofacServiceProvider(rootServices.LifetimeScope.BeginLifetimeScope(builder =>
{
var services = new ServiceCollection();
// HACK: IWebHostEnvironment is registered in the root container but we need to register a temporary instance for the time of tenant services configuration
// because discovery of default application parts relies on IWebHostEnvironment.ApplicationName
// https://github.com/dotnet/aspnetcore/blob/v3.1.6/src/Mvc/Mvc.Core/src/DependencyInjection/MvcCoreServiceCollectionExtensions.cs#L81
var dummyWebHostEnvironmentService = ServiceDescriptor.Singleton <IWebHostEnvironment>(new DummyWebHostEnvironment {
ApplicationName = EntryAssembly?.GetName().Name
});
services.Add(dummyWebHostEnvironmentService);
ConfigureServices(services);
services.RemoveAll((service, _) => service == dummyWebHostEnvironmentService || ShouldResolveFromRoot(service));
builder.Populate(services);
}));
}
public Application(string[] args)
{
CommandLineArgs.AddRange(args);
var cmdParser = new CommandLineParser();
EntryAssembly = Assembly.GetEntryAssembly();
if (EntryAssembly == null)
{
#pragma warning disable CA1303 // Do not pass literals as localized parameters
throw new Exception("Can't get entry assembly!");
#pragma warning restore CA1303 // Do not pass literals as localized parameters
}
var entryAssemblyName = EntryAssembly.GetName()?.Name;
if (entryAssemblyName == null)
{
#pragma warning disable CA1303 // Do not pass literals as localized parameters
throw new Exception("Can't get entry assembly name!");
#pragma warning restore CA1303 // Do not pass literals as localized parameters
}
if (!IsInteractiveMode)
{
Options = cmdParser.Parse <ApplicationOptions>(CommandLineArgs.ToArray());
ServiceName = (((ApplicationOptions)Options).ServiceNamePrefix == ApplicationOptions.NOPREFIX ? "" : ((ApplicationOptions)Options).ServiceNamePrefix)
+ entryAssemblyName;
}
else
{
if (Manager != null)
{
Options = cmdParser.Parse(CommandLineArgs.ToArray(), Manager.OptionsClass);
}
ServiceName = entryAssemblyName;
}
Manager = new T();
}
/// <summary>
/// 取得类型
/// </summary>
/// <returns>类型</returns>
private Type GetType(string typeName)
{
Type type = Type.GetType(typeName);
if (type == null)
{
type = DefaultAssembly.GetType(typeName);
}
if (type == null)
{
type = CallingAssembly.GetType(typeName);
}
if (type == null)
{
type = ExecutingAssembly.GetType(typeName);
}
if (type == null)
{
type = EntryAssembly.GetType(typeName);
}
return(type);
}
public void CanResolveAllSystemEntryPoints()
{
IEnumerable <Type> EntryPoints = EntryAssembly.GetTypes()
.Where(_ => typeof(TBase).IsAssignableFrom(_) &&
!_.IsAbstract)
.ToArray();
RegisterEntryPoints(EntryPoints);
RegisterDependencies();
AddExtraRegistrations();
using IServiceScope scope = CreateServiceScope();
IServiceProvider serviceProvider = scope.ServiceProvider;
foreach (Type entryPoint in EntryPoints)
{
serviceProvider
.GetService(entryPoint)
.Should()
.NotBeNull(entryPoint.Name);
}
}
internal bool CompileInternal(ProjectContext context, string config, string probingFolderPath)
{
// Check if ambient library
if (AmbientLibraries.Contains(context.ProjectName()))
{
return(true);
}
bool compilationResult;
// Check if already compiled
if (_compiledLibraries.TryGetValue(context.ProjectName(), out compilationResult))
{
return(compilationResult);
}
// Get compilation options and source files
var compilationOptions = context.ResolveCompilationOptions(config);
var projectSourceFiles = CompilerUtility.GetCompilationSources(context, compilationOptions);
// Check if precompiled
if (!projectSourceFiles.Any())
{
return(_compiledLibraries[context.ProjectName()] = true);
}
// Set up Output Paths
var outputPaths = context.GetOutputPaths(config);
var outputPath = outputPaths.CompilationOutputPath;
var intermediateOutputPath = outputPaths.IntermediateOutputDirectoryPath;
Directory.CreateDirectory(outputPath);
Directory.CreateDirectory(intermediateOutputPath);
// Create the library exporter
var exporter = context.CreateExporter(config);
// Gather exports for the project
var dependencies = exporter.GetDependencies().ToList();
// Get compilation options
var outputName = outputPaths.CompilationFiles.Assembly;
// Set default platform if it isn't already set and we're on desktop
if (compilationOptions.EmitEntryPoint == true && String.IsNullOrEmpty(compilationOptions.Platform) && context.TargetFramework.IsDesktop())
{
// See https://github.com/dotnet/cli/issues/2428 for more details.
compilationOptions.Platform = RuntimeInformation.ProcessArchitecture == Architecture.X64 ?
"x64" : "anycpu32bitpreferred";
}
var references = new List <string>();
var sourceFiles = new List <string>();
var resources = new List <string>();
// Get the runtime directory
var runtimeDirectory = Paths.GetParentFolderPath(EntryAssembly.Location);
foreach (var dependency in dependencies)
{
sourceFiles.AddRange(dependency.SourceReferences.Select(s => s.GetTransformedFile(intermediateOutputPath)));
foreach (var resourceFile in dependency.EmbeddedResources)
{
var transformedResource = resourceFile.GetTransformedFile(intermediateOutputPath);
var resourceName = ResourceManifestName.CreateManifestName(
Path.GetFileName(resourceFile.ResolvedPath), compilationOptions.OutputName);
resources.Add($"\"{transformedResource}\",{resourceName}");
}
var library = dependency.Library as ProjectDescription;
var package = dependency.Library as PackageDescription;
// Compile other referenced libraries
if (library != null && !AmbientLibraries.Contains(library.Identity.Name) && dependency.CompilationAssemblies.Any())
{
if (!_compiledLibraries.ContainsKey(library.Identity.Name))
{
var projectContext = GetProjectContextFromPath(library.Project.ProjectDirectory);
if (projectContext != null)
{
// Right now, if !success we try to use the last build
var success = Compile(projectContext, config, probingFolderPath);
}
}
}
// Check for an unresolved library
if (library != null && !library.Resolved)
{
var assetFileName = CompilerUtility.GetAssemblyFileName(library.Identity.Name);
// Search in the runtime directory
var assetResolvedPath = Path.Combine(runtimeDirectory, assetFileName);
if (!File.Exists(assetResolvedPath))
{
// Fallback to the project output path or probing folder
assetResolvedPath = ResolveAssetPath(outputPath, probingFolderPath, assetFileName);
if (String.IsNullOrEmpty(assetResolvedPath))
{
// Fallback to this (possible) precompiled module bin folder
var path = Path.Combine(Paths.GetParentFolderPath(library.Path), Constants.BinDirectoryName, assetFileName);
assetResolvedPath = File.Exists(path) ? path : null;
}
}
if (!String.IsNullOrEmpty(assetResolvedPath))
{
references.Add(assetResolvedPath);
}
}
// Check for an unresolved package
else if (package != null && !package.Resolved)
{
var runtimeAssets = new HashSet <string>(package.RuntimeAssemblies.Select(x => x.Path), StringComparer.OrdinalIgnoreCase);
string fallbackBinPath = null;
foreach (var asset in package.CompileTimeAssemblies)
{
var assetFileName = Path.GetFileName(asset.Path);
var isRuntimeAsset = runtimeAssets.Contains(asset.Path);
// Search in the runtime directory
var relativeFolderPath = isRuntimeAsset ? String.Empty : CompilerUtility.RefsDirectoryName;
var assetResolvedPath = Path.Combine(runtimeDirectory, relativeFolderPath, assetFileName);
if (!File.Exists(assetResolvedPath))
{
// Fallback to the project output path or probing folder
assetResolvedPath = ResolveAssetPath(outputPath, probingFolderPath, assetFileName, relativeFolderPath);
}
if (String.IsNullOrEmpty(assetResolvedPath))
{
if (fallbackBinPath == null)
{
fallbackBinPath = String.Empty;
// Fallback to a (possible) parent precompiled module bin folder
var parentBinPaths = CompilerUtility.GetOtherParentProjectsLocations(context, package)
.Select(x => Path.Combine(x, Constants.BinDirectoryName));
foreach (var binaryPath in parentBinPaths)
{
var path = Path.Combine(binaryPath, relativeFolderPath, assetFileName);
if (File.Exists(path))
{
assetResolvedPath = path;
fallbackBinPath = binaryPath;
break;
}
}
}
else if (!String.IsNullOrEmpty(fallbackBinPath))
{
var path = Path.Combine(fallbackBinPath, relativeFolderPath, assetFileName);
assetResolvedPath = File.Exists(path) ? path : null;
}
}
if (!String.IsNullOrEmpty(assetResolvedPath))
{
references.Add(assetResolvedPath);
}
}
}
// Check for a precompiled library
else if (library != null && !dependency.CompilationAssemblies.Any())
{
// Search in the project output path or probing folder
var assetFileName = CompilerUtility.GetAssemblyFileName(library.Identity.Name);
var assetResolvedPath = ResolveAssetPath(outputPath, probingFolderPath, assetFileName);
if (String.IsNullOrEmpty(assetResolvedPath))
{
// Fallback to this precompiled project output path
var path = Path.Combine(CompilerUtility.GetAssemblyFolderPath(library.Project.ProjectDirectory,
config, context.TargetFramework.DotNetFrameworkName), assetFileName);
assetResolvedPath = File.Exists(path) ? path : null;
}
if (!String.IsNullOrEmpty(assetResolvedPath))
{
references.Add(assetResolvedPath);
}
}
// Check for a resolved but ambient library (compiled e.g by VS)
else if (library != null && AmbientLibraries.Contains(library.Identity.Name))
{
// Search in the regular project output path, fallback to the runtime directory
references.AddRange(dependency.CompilationAssemblies.Select(r => File.Exists(r.ResolvedPath)
? r.ResolvedPath : Path.Combine(runtimeDirectory, r.FileName)));
}
else
{
references.AddRange(dependency.CompilationAssemblies.Select(r => r.ResolvedPath));
}
}
// Check again if already compiled, here through the dependency graph
if (_compiledLibraries.TryGetValue(context.ProjectName(), out compilationResult))
{
return(compilationResult);
}
var sw = Stopwatch.StartNew();
string depsJsonFile = null;
DependencyContext dependencyContext = null;
// Add dependency context as a resource
if (compilationOptions.PreserveCompilationContext == true)
{
var allExports = exporter.GetAllExports().ToList();
var exportsLookup = allExports.ToDictionary(e => e.Library.Identity.Name);
var buildExclusionList = context.GetTypeBuildExclusionList(exportsLookup);
var filteredExports = allExports
.Where(e => e.Library.Identity.Type.Equals(LibraryType.ReferenceAssembly) ||
!buildExclusionList.Contains(e.Library.Identity.Name));
dependencyContext = new DependencyContextBuilder().Build(compilationOptions,
filteredExports,
filteredExports,
false, // For now, just assume non-portable mode in the legacy deps file (this is going away soon anyway)
context.TargetFramework,
context.RuntimeIdentifier ?? string.Empty);
depsJsonFile = Path.Combine(intermediateOutputPath, compilationOptions.OutputName + "dotnet-compile.deps.json");
resources.Add($"\"{depsJsonFile}\",{compilationOptions.OutputName}.deps.json");
}
// Add project source files
sourceFiles.AddRange(projectSourceFiles);
// Add non culture resources
var resgenFiles = CompilerUtility.GetNonCultureResources(context.ProjectFile, intermediateOutputPath, compilationOptions);
AddNonCultureResources(resources, resgenFiles);
var translated = TranslateCommonOptions(compilationOptions, outputName);
var allArgs = new List <string>(translated);
allArgs.AddRange(GetDefaultOptions());
// Add assembly info
var assemblyInfo = Path.Combine(intermediateOutputPath, $"dotnet-compile.assemblyinfo.cs");
allArgs.Add($"\"{assemblyInfo}\"");
if (!String.IsNullOrEmpty(outputName))
{
allArgs.Add($"-out:\"{outputName}\"");
}
allArgs.AddRange(references.Select(r => $"-r:\"{r}\""));
allArgs.AddRange(resources.Select(resource => $"-resource:{resource}"));
allArgs.AddRange(sourceFiles.Select(s => $"\"{s}\""));
// Gather all compile IO
var inputs = new List <string>();
var outputs = new List <string>();
inputs.Add(context.ProjectFile.ProjectFilePath);
if (context.LockFile != null)
{
inputs.Add(context.LockFile.LockFilePath);
}
if (context.LockFile.ExportFile != null)
{
inputs.Add(context.LockFile.ExportFile.ExportFilePath);
}
inputs.AddRange(sourceFiles);
inputs.AddRange(references);
inputs.AddRange(resgenFiles.Select(x => x.InputFile));
var cultureResgenFiles = CompilerUtility.GetCultureResources(context.ProjectFile, outputPath, compilationOptions);
inputs.AddRange(cultureResgenFiles.SelectMany(x => x.InputFileToMetadata.Keys));
outputs.AddRange(outputPaths.CompilationFiles.All());
outputs.AddRange(resgenFiles.Where(x => x.OutputFile != null).Select(x => x.OutputFile));
//outputs.AddRange(cultureResgenFiles.Where(x => x.OutputFile != null).Select(x => x.OutputFile));
// Locate RSP file
var rsp = Path.Combine(intermediateOutputPath, $"dotnet-compile-csc.rsp");
// Check if there is no need to compile
if (!CheckMissingIO(inputs, outputs) && !TimestampsChanged(inputs, outputs))
{
if (File.Exists(rsp))
{
// Check if the compilation context has been changed
var prevInputs = new HashSet <string>(File.ReadAllLines(rsp));
var newInputs = new HashSet <string>(allArgs);
if (!prevInputs.Except(newInputs).Any() && !newInputs.Except(prevInputs).Any())
{
PrintMessage($"{context.ProjectName()}: Previously compiled, skipping dynamic compilation.");
return(_compiledLibraries[context.ProjectName()] = true);
}
}
else
{
// Write RSP file for the next time
File.WriteAllLines(rsp, allArgs);
PrintMessage($"{context.ProjectName()}: Previously compiled, skipping dynamic compilation.");
return(_compiledLibraries[context.ProjectName()] = true);
}
}
if (!CompilerUtility.GenerateNonCultureResources(context.ProjectFile, resgenFiles, Diagnostics))
{
return(_compiledLibraries[context.ProjectName()] = false);
}
PrintMessage(String.Format($"{context.ProjectName()}: Dynamic compiling for {context.TargetFramework.DotNetFrameworkName}"));
// Write the dependencies file
if (dependencyContext != null)
{
var writer = new DependencyContextWriter();
using (var fileStream = File.Create(depsJsonFile))
{
writer.Write(dependencyContext, fileStream);
}
}
// Write assembly info and RSP files
var assemblyInfoOptions = AssemblyInfoOptions.CreateForProject(context);
File.WriteAllText(assemblyInfo, AssemblyInfoFileGenerator.GenerateCSharp(assemblyInfoOptions, sourceFiles));
File.WriteAllLines(rsp, allArgs);
// Locate runtime config files
var runtimeConfigPath = Path.Combine(runtimeDirectory, EntryAssembly.GetName().Name + FileNameSuffixes.RuntimeConfigJson);
var cscRuntimeConfigPath = Path.Combine(runtimeDirectory, "csc" + FileNameSuffixes.RuntimeConfigJson);
// Automatically create the csc runtime config file
if (Files.IsNewer(runtimeConfigPath, cscRuntimeConfigPath))
{
lock (_syncLock)
{
if (Files.IsNewer(runtimeConfigPath, cscRuntimeConfigPath))
{
File.Copy(runtimeConfigPath, cscRuntimeConfigPath, true);
}
}
}
// Locate csc.dll and the csc.exe asset
var cscDllPath = Path.Combine(runtimeDirectory, CompilerUtility.GetAssemblyFileName("csc"));
// Search in the runtime directory
var cscRelativePath = Path.Combine("runtimes", "any", "native", "csc.exe");
var cscExePath = Path.Combine(runtimeDirectory, cscRelativePath);
// Fallback to the packages storage
if (!File.Exists(cscExePath) && !String.IsNullOrEmpty(context.PackagesDirectory))
{
cscExePath = Path.Combine(context.PackagesDirectory, CscLibrary?.Name ?? String.Empty,
CscLibrary?.Version ?? String.Empty, cscRelativePath);
}
// Automatically create csc.dll
if (Files.IsNewer(cscExePath, cscDllPath))
{
lock (_syncLock)
{
if (Files.IsNewer(cscExePath, cscDllPath))
{
File.Copy(cscExePath, cscDllPath, true);
}
}
}
// Locate the csc dependencies file
var cscDepsPath = Path.Combine(runtimeDirectory, "csc.deps.json");
// Automatically create csc.deps.json
if (NativePDBWriter != null && Files.IsNewer(cscDllPath, cscDepsPath))
{
lock (_syncLock)
{
if (Files.IsNewer(cscDllPath, cscDepsPath))
{
// Only reference windows native pdb writers
var runtimeLibraries = new List <RuntimeLibrary>();
runtimeLibraries.Add(NativePDBWriter);
DependencyContext cscDependencyContext = new DependencyContext(
DependencyContext.Default.Target, CompilationOptions.Default,
new List <CompilationLibrary>(), runtimeLibraries,
new List <RuntimeFallbacks>());
// Write the csc.deps.json file
if (cscDependencyContext != null)
{
var writer = new DependencyContextWriter();
using (var fileStream = File.Create(cscDepsPath))
{
writer.Write(cscDependencyContext, fileStream);
}
}
// Windows native pdb writers are outputed on dotnet publish.
// But not on dotnet build during development, we do it here.
// Check if there is a packages storage
if (!String.IsNullOrEmpty(context.PackagesDirectory))
{
var assetPaths = NativePDBWriter.NativeLibraryGroups.SelectMany(l => l.AssetPaths);
foreach (var assetPath in assetPaths)
{
// Resolve the pdb writer from the packages storage
var pdbResolvedPath = Path.Combine(context.PackagesDirectory,
NativePDBWriter.Name, NativePDBWriter.Version, assetPath);
var pdbOutputPath = Path.Combine(runtimeDirectory, assetPath);
// Store the pdb writer in the runtime directory
if (Files.IsNewer(pdbResolvedPath, pdbOutputPath))
{
Directory.CreateDirectory(Paths.GetParentFolderPath(pdbOutputPath));
File.Copy(pdbResolvedPath, pdbOutputPath, true);
}
}
}
}
}
}
// Execute CSC!
var result = Command.Create("csc.dll", new string[] { $"-noconfig", "@" + $"{rsp}" })
.WorkingDirectory(runtimeDirectory)
.OnErrorLine(line => Diagnostics.Add(line))
.OnOutputLine(line => Diagnostics.Add(line))
.Execute();
compilationResult = result.ExitCode == 0;
if (compilationResult)
{
compilationResult &= CompilerUtility.GenerateCultureResourceAssemblies(context.ProjectFile, cultureResgenFiles, references, Diagnostics);
}
PrintMessage(String.Empty);
if (compilationResult && Diagnostics.Count == 0)
{
PrintMessage($"{context.ProjectName()}: Dynamic compilation succeeded.");
PrintMessage($"0 Warning(s)");
PrintMessage($"0 Error(s)");
}
else if (compilationResult && Diagnostics.Count > 0)
{
PrintMessage($"{context.ProjectName()}: Dynamic compilation succeeded but has warnings.");
PrintMessage($"0 Error(s)");
}
else
{
PrintMessage($"{context.ProjectName()}: Dynamic compilation failed.");
}
foreach (var diagnostic in Diagnostics)
{
PrintMessage(diagnostic);
}
PrintMessage($"Time elapsed {sw.Elapsed}");
PrintMessage(String.Empty);
return(_compiledLibraries[context.ProjectName()] = compilationResult);
}
private XDocument Serialize()
{
XDocument xDoc = new XDocument();
//apender
var param = new XElement("param");
param.SetAttributeValue("name", "ConversionPattern");
param.SetAttributeValue("value", LogPattern);
var layout = new XElement("layout", param);
layout.SetAttributeValue("type", typeof(PatternLayout));
var file = new XElement("file");
file.SetAttributeValue("value", LogFilePath);
var append = new XElement("appendToFile");
append.SetAttributeValue("value", AppendToFile);
var rollingstyle = new XElement("rollingStyle");
rollingstyle.SetAttributeValue("value",
Enum.GetName(typeof(RollingFileAppender.RollingMode)
, RollingFileAppender.RollingMode.Size));
var maxFiles = new XElement("maxSizeRollBackups");
maxFiles.SetAttributeValue("value", MaxLogFiles);
var maxFileSize = new XElement("maximumFileSize");
maxFileSize.SetAttributeValue("value", "{0}MB".FormatWith(MaxLogSizeInMB));
var staticLogFile = new XElement("StaticLogFileName");
staticLogFile.SetAttributeValue("value", true);
var appender = new XElement("appender"
, file
, append
, rollingstyle
, maxFiles
, maxFileSize
, staticLogFile
, layout);
appender.SetAttributeValue("name", EntryAssembly.GetName().Name);
appender.SetAttributeValue("type", typeof(RollingFileAppender));
//Root
var level = new XElement("level");
level.SetAttributeValue("value", Level.Name);
var appRef = new XElement("appender-ref");
appRef.SetAttributeValue("ref", EntryAssembly.GetName().Name);
var root = new XElement("root", level, appRef);
//Config
var section = new XElement("section");
section.SetAttributeValue("name", "log4net");
section.SetAttributeValue("type", "{0}, {1}".FormatWith(typeof(Log4NetConfigurationSectionHandler), "log4net"));
var configSection = new XElement("configSections", section);
var configuration = new XElement("configuration",
configSection,
new XElement("log4net",
appender, root));
return(XDocument.Parse(configuration.ToString()));
}
public ViewLocator(Application application)
: this(EntryAssembly != null && !EntryAssembly.IsInDesignMode() ? new[] { EntryAssembly } : new Assembly[0])
{
}
// will be called when all assemblies are loaded (can be async for downloading)
// which means we need to report errors to the plugin, since it won't get it from calling managed code
internal bool CreateApplication()
{
SetCurrentApplication(null);
if (EntryAssembly == null)
{
EmitError(2103, "Could not find the entry point assembly");
return(false);
}
Type entry_type = EntryAssembly.GetType(EntryPointType);
if (entry_type == null)
{
EmitError(2103, String.Format("Could not find the startup type {0} on the {1}",
EntryPointType, EntryPointAssembly));
return(false);
}
if (!entry_type.IsSubclassOf(typeof(Application)) && entry_type != typeof(Application))
{
#if SANITY
Type t = entry_type;
int spacing = 0;
Console.WriteLine("Application type: {0}", typeof(Application).AssemblyQualifiedName);
while (t != null)
{
if (spacing > 0)
{
for (int i = 0; i < spacing; i++)
{
Console.Write(" ");
}
Console.Write("+ ");
}
Console.WriteLine("{0} from {1}", t.AssemblyQualifiedName, t.Assembly.Location);
spacing += 2;
t = t.BaseType;
}
#endif
EmitError(2103, "Startup type does not derive from System.Windows.Application");
return(false);
}
foreach (Assembly a in Assemblies)
{
Application.LoadXmlnsDefinitionMappings(a);
}
Application instance = null;
try {
instance = (Application)Activator.CreateInstance(entry_type);
// set HasElevatedPermissions based on IsRunningOutOfBrowser and ElevatedPermissions.Required
if (IsElevatedPermissionsRequired)
{
instance.HasElevatedPermissions = instance.IsRunningOutOfBrowser;
}
} catch {
EmitError(2103, String.Format("Error while creating the instance of type {0}", entry_type));
return(false);
}
if (instance.IsRunningOutOfBrowser)
{
IntPtr window_handle = instance.MainWindow.native;
WindowSettings ws = OutOfBrowserSettings.WindowSettings;
if (ws != null)
{
Window w = instance.MainWindow;
w.Width = ws.Width;
w.Height = ws.Height;
switch (ws.WindowStartupLocation)
{
case WindowStartupLocation.Manual:
w.Left = ws.Left;
w.Top = ws.Top;
break;
case WindowStartupLocation.CenterScreen:
IntPtr windowing_system = NativeMethods.runtime_get_windowing_system();
IntPtr moon_window = NativeMethods.window_get_moon_window(window_handle);
w.Left = ((NativeMethods.moon_windowing_system_get_screen_width(windowing_system, moon_window) - w.Width) / 2);
w.Top = ((NativeMethods.moon_windowing_system_get_screen_height(windowing_system, moon_window) - w.Height) / 2);
break;
default:
// let the OS decide where to show the window
break;
}
Uri source = UriHelper.FromNativeUri(NativeMethods.surface_get_source_location(Surface.Native));
string host = source.Host;
if (String.IsNullOrEmpty(source.Host))
{
host = "localhost";
}
NativeMethods.window_set_title(window_handle, ws.Title + " - " + host);
NativeMethods.window_set_style(window_handle, ws.WindowStyle);
}
else
{
NativeMethods.window_set_title(window_handle, OutOfBrowserSettings.ShortName);
}
}
StartupEventArgs args = new StartupEventArgs();
instance.OnStartup(args);
return(true);
}
