public static async Task<int> Execute(
IServiceProvider services,
Project project,
string command,
string[] args)
{
var environment = (IApplicationEnvironment)services.GetService(typeof(IApplicationEnvironment));
var commandText = project.Commands[command];
var replacementArgs = CommandGrammar.Process(
commandText,
(key) => GetVariable(environment, key),
preserveSurroundingQuotes: false)
.ToArray();
var entryPoint = replacementArgs[0];
args = replacementArgs.Skip(1).Concat(args).ToArray();
if (string.IsNullOrEmpty(entryPoint) ||
string.Equals(entryPoint, "run", StringComparison.Ordinal))
{
entryPoint = project.EntryPoint ?? project.Name;
}
CallContextServiceLocator.Locator.ServiceProvider = services;
return await ExecuteMain(services, entryPoint, args);
}
public bool TryResolveProject(string name, out Project project)
{
project = _searchPaths.Select(path => Path.Combine(path, name))
.Select(path => GetProject(path))
.FirstOrDefault(p => p != null);
return project != null;
}
public CompiledProjectMetadataReference(Project project, string assemblyPath, string pdbPath)
{
Name = project.Name;
ProjectPath = project.ProjectFilePath;
Path = assemblyPath;
_project = project;
_assemblyPath = assemblyPath;
_pdbPath = pdbPath;
}
public FSharpProjectReference(Project project,
FrameworkName targetFramework,
string configuration,
IEnumerable<IMetadataReference> metadataReferences)
{
_project = project;
_targetFramework = targetFramework;
_configuration = configuration;
_metadataReferences = metadataReferences;
}
public IMetadataProjectReference GetProjectReference(
Project project,
ILibraryKey target,
Func<ILibraryExport> referenceResolver)
{
// The target framework and configuration are assumed to be correct
// in the design time process
var task = _compiler.Compile(project.ProjectDirectory, target);
return new DesignTimeProjectReference(project, task.Result);
}
private static DnxProject GetProject(string path)
{
var cacheKey = Tuple.Create("Project", path);
return(cache.Get <DnxProject>(cacheKey, ctx =>
{
DnxProject project;
DnxProject.TryGetProject(path, out project);
return project;
}));
}
public CscProjectReference(Project project,
FrameworkName targetFramework,
string configuration,
IEnumerable<IMetadataReference> metadataReferences,
IEnumerable<ISourceReference> sourceReferences)
{
_project = project;
_targetFramework = targetFramework;
_configuration = configuration;
_metadataReferences = metadataReferences;
_sourceReferences = sourceReferences;
}
public IMetadataProjectReference GetProjectReference(
Project project,
ILibraryKey libraryKey,
Func<ILibraryExport> referenceResolver,
IList<IMetadataReference> outgoingReferences)
{
var export = referenceResolver();
var incomingReferences = export.MetadataReferences;
var incomingSourceReferences = export.SourceReferences;
return new CscProjectReference(project, libraryKey.TargetFramework, libraryKey.Configuration, incomingReferences, incomingSourceReferences);
}
public DesignTimeAssemblyLoadContextFactory(Project project,
IApplicationEnvironment appEnv,
ICache cache,
ICacheContextAccessor cacheContextAccessor,
INamedCacheDependencyProvider namedDependencyProvider)
{
_project = project;
_appEnv = appEnv;
_cache = cache;
_cacheContextAccessor = cacheContextAccessor;
_namedDependencyProvider = namedDependencyProvider;
}
public bool TryResolveProject(string name, out Project project)
{
project = null;
ProjectInformation projectInfo;
if (_projects.TryGetValue(name, out projectInfo))
{
project = projectInfo.Project;
return project != null;
}
return false;
}
public bool TryResolveProject(string name, out Project project)
{
project = null;
foreach (var searchPath in _searchPaths)
{
var projectPath = Path.Combine(searchPath, name);
if (Project.TryGetProject(projectPath, out project))
{
return true;
}
}
return false;
}
private static string ResolvePath(Project project, string configuration, string path) {
if (string.IsNullOrEmpty(path)) {
return null;
}
if (Path.DirectorySeparatorChar == '/') {
path = path.Replace('\\', Path.DirectorySeparatorChar);
}
else {
path = path.Replace('/', Path.DirectorySeparatorChar);
}
path = path.Replace("{configuration}", configuration);
return Path.Combine(project.ProjectDirectory, path);
}
public IMetadataProjectReference GetProjectReference(
Project project,
ILibraryKey target,
Func<ILibraryExport> referenceResolver,
IList<IMetadataReference> outgoingReferences)
{
// The target framework and configuration are assumed to be correct
// in the design time process
var task = _compiler.Compile(project.ProjectDirectory, target);
foreach (var embeddedReference in task.Result.EmbeddedReferences)
{
outgoingReferences.Add(new EmbeddedMetadataReference(embeddedReference.Key, embeddedReference.Value));
}
return new DesignTimeProjectReference(project, task.Result);
}
private static ApplicationHostContext GetApplicationHostContext(DnxProject project, string configuration, FrameworkName frameworkName)
{
var cacheKey = Tuple.Create("ApplicationContext", project.Name, configuration, frameworkName);
return(cache.Get <ApplicationHostContext>(cacheKey, ctx =>
{
var applicationHostContext = new ApplicationHostContext(null,
project.ProjectDirectory,
packagesDirectory: null,
configuration: configuration,
targetFramework: frameworkName,
cache: cache,
cacheContextAccessor: cacheContextAccessor,
namedCacheDependencyProvider: namedCacheDependencyProvider);
applicationHostContext.DependencyWalker.Walk(project.Name, project.Version, frameworkName);
return applicationHostContext;
}));
}
public static bool TryGetProject(string path, out Project project, ICollection<ICompilationMessage> diagnostics = null)
{
project = null;
string projectPath = null;
if (string.Equals(Path.GetFileName(path), ProjectFileName, StringComparison.OrdinalIgnoreCase))
{
projectPath = path;
path = Path.GetDirectoryName(path);
}
else if (!HasProjectFile(path))
{
return false;
}
else
{
projectPath = Path.Combine(path, ProjectFileName);
}
// Assume the directory name is the project name if none was specified
var projectName = PathUtility.GetDirectoryName(path);
projectPath = Path.GetFullPath(projectPath);
try
{
using (var stream = File.OpenRead(projectPath))
{
project = GetProjectFromStream(stream, projectName, projectPath, diagnostics);
}
}
catch (Exception ex)
{
throw FileFormatException.Create(ex, projectPath);
}
return true;
}
internal static Project GetProjectFromStream(Stream stream, string projectName, string projectPath, ICollection<ICompilationMessage> diagnostics = null)
{
var project = new Project();
var reader = new StreamReader(stream);
var rawProject = JsonDeserializer.Deserialize(reader) as JsonObject;
if (rawProject == null)
{
throw FileFormatException.Create(
"The JSON file can't be deserialized to a JSON object.",
projectPath);
}
// Meta-data properties
project.Name = projectName;
project.ProjectFilePath = Path.GetFullPath(projectPath);
var version = rawProject.Value("version") as JsonString;
if (version == null)
{
project.Version = new SemanticVersion("1.0.0");
}
else
{
try
{
var buildVersion = Environment.GetEnvironmentVariable("DNX_BUILD_VERSION");
project.Version = SpecifySnapshot(version, buildVersion);
}
catch (Exception ex)
{
throw FileFormatException.Create(ex, version, project.ProjectFilePath);
}
}
var fileVersion = Environment.GetEnvironmentVariable("DNX_ASSEMBLY_FILE_VERSION");
if (string.IsNullOrWhiteSpace(fileVersion))
{
project.AssemblyFileVersion = project.Version.Version;
}
else
{
try
{
var simpleVersion = project.Version.Version;
project.AssemblyFileVersion = new Version(simpleVersion.Major,
simpleVersion.Minor,
simpleVersion.Build,
int.Parse(fileVersion));
}
catch (FormatException ex)
{
throw new FormatException("The assembly file version is invalid: " + fileVersion, ex);
}
}
project.Description = rawProject.ValueAsString("description");
project.Summary = rawProject.ValueAsString("summary");
project.Copyright = rawProject.ValueAsString("copyright");
project.Title = rawProject.ValueAsString("title");
project.WebRoot = rawProject.ValueAsString("webroot");
project.EntryPoint = rawProject.ValueAsString("entryPoint");
project.ProjectUrl = rawProject.ValueAsString("projectUrl");
project.LicenseUrl = rawProject.ValueAsString("licenseUrl");
project.IconUrl = rawProject.ValueAsString("iconUrl");
project.Authors = rawProject.ValueAsStringArray("authors") ?? new string[] { };
project.Owners = rawProject.ValueAsStringArray("owners") ?? new string[] { };
project.Tags = rawProject.ValueAsStringArray("tags") ?? new string[] { };
project.Language = rawProject.ValueAsString("language");
project.ReleaseNotes = rawProject.ValueAsString("releaseNotes");
project.RequireLicenseAcceptance = rawProject.ValueAsBoolean("requireLicenseAcceptance", defaultValue: false);
project.IsLoadable = rawProject.ValueAsBoolean("loadable", defaultValue: true);
// TODO: Move this to the dependencies node
project.EmbedInteropTypes = rawProject.ValueAsBoolean("embedInteropTypes", defaultValue: false);
project.Dependencies = new List<LibraryDependency>();
// Project files
project.Files = new ProjectFilesCollection(rawProject,
project.ProjectDirectory,
project.ProjectFilePath,
diagnostics);
var compilerInfo = rawProject.ValueAsJsonObject("compiler");
if (compilerInfo != null)
{
var languageName = compilerInfo.ValueAsString("name") ?? "C#";
var compilerAssembly = compilerInfo.ValueAsString("compilerAssembly");
var compilerType = compilerInfo.ValueAsString("compilerType");
var compiler = new TypeInformation(compilerAssembly, compilerType);
project.CompilerServices = new CompilerServices(languageName, compiler);
}
var commands = rawProject.Value("commands") as JsonObject;
if (commands != null)
{
foreach (var key in commands.Keys)
{
var value = commands.ValueAsString(key);
if (value != null)
{
project.Commands[key] = value;
}
}
}
var scripts = rawProject.Value("scripts") as JsonObject;
if (scripts != null)
{
foreach (var key in scripts.Keys)
{
var stringValue = scripts.ValueAsString(key);
if (stringValue != null)
{
project.Scripts[key] = new string[] { stringValue };
continue;
}
var arrayValue = scripts.ValueAsStringArray(key);
if (arrayValue != null)
{
project.Scripts[key] = arrayValue;
continue;
}
throw FileFormatException.Create(
string.Format("The value of a script in {0} can only be a string or an array of strings", ProjectFileName),
scripts.Value(key),
project.ProjectFilePath);
}
}
var repository = rawProject.Value("repository") as JsonObject;
if (repository != null)
{
project.Repository = repository
.Keys
.ToDictionary(
key => key,
key => repository.ValueAsString(key).Value);
}
project.BuildTargetFrameworksAndConfigurations(rawProject, diagnostics);
PopulateDependencies(
project.ProjectFilePath,
project.Dependencies,
rawProject,
"dependencies",
isGacOrFrameworkReference: false);
return project;
}
public ApplicationEnvironment(Project project, FrameworkName targetFramework, string configuration)
{
_project = project;
_targetFramework = targetFramework;
Configuration = configuration;
}
private ISettings LoadSettings(Project project)
{
return new Settings(project.ProjectDirectory);
}
private void Initialize(DefaultHostOptions options, IServiceProvider hostServices)
{
var cacheContextAccessor = new CacheContextAccessor();
var cache = new Cache(cacheContextAccessor);
var namedCacheDependencyProvider = new NamedCacheDependencyProvider();
_applicationHostContext = new ApplicationHostContext(
hostServices,
_projectDirectory,
options.PackageDirectory,
options.Configuration,
_targetFramework,
cache,
cacheContextAccessor,
namedCacheDependencyProvider);
Logger.TraceInformation("[{0}]: Project path: {1}", GetType().Name, _projectDirectory);
Logger.TraceInformation("[{0}]: Project root: {1}", GetType().Name, _applicationHostContext.RootDirectory);
Logger.TraceInformation("[{0}]: Packages path: {1}", GetType().Name, _applicationHostContext.PackagesDirectory);
_project = _applicationHostContext.Project;
if (Project == null)
{
throw new Exception("Unable to locate " + Project.ProjectFileName);
}
if (options.WatchFiles)
{
var watcher = new FileWatcher(_applicationHostContext.RootDirectory);
_watcher = watcher;
watcher.OnChanged += _ =>
{
_shutdown.RequestShutdownWaitForDebugger();
};
}
else
{
_watcher = NoopWatcher.Instance;
}
_applicationHostContext.AddService(typeof(IApplicationShutdown), _shutdown);
_applicationHostContext.AddService(typeof(IRuntimeOptions), options);
// TODO: Get rid of this and just use the IFileWatcher
_applicationHostContext.AddService(typeof(IFileMonitor), _watcher);
_applicationHostContext.AddService(typeof(IFileWatcher), _watcher);
if (options.CompilationServerPort.HasValue)
{
// Change the project reference provider
Project.DefaultCompiler = Project.DefaultDesignTimeCompiler;
}
CallContextServiceLocator.Locator.ServiceProvider = ServiceProvider;
}
private static DependencyInformation ResolveDependencyInfo(DnxProject project, FrameworkName frameworkName)
{
var cacheKey = Tuple.Create("DependencyInformation", project.Name, "Debug", frameworkName);
return(cache.Get <DependencyInformation>(cacheKey, ctx =>
{
var applicationHostContext = GetApplicationHostContext(project, "Debug", frameworkName);
var info = new DependencyInformation
{
HostContext = applicationHostContext,
ProjectReferences = new List <ProjectReference>(),
References = new List <string>(),
ExportedSourcesFiles = new List <string>()
};
foreach (var library in applicationHostContext.DependencyWalker.Libraries)
{
// Skip unresolved libraries
if (!library.Resolved)
{
continue;
}
if (string.Equals(library.Type, "Project") &&
!string.Equals(library.Identity.Name, project.Name))
{
DnxProject referencedProject = GetProject(library.Path);
if (referencedProject == null)
{
// Should never happen
continue;
}
var targetFrameworkInformation = referencedProject.GetTargetFramework(library.Framework);
// If this is an assembly reference then treat it like a file reference
if (!string.IsNullOrEmpty(targetFrameworkInformation.AssemblyPath) &&
string.IsNullOrEmpty(targetFrameworkInformation.WrappedProject))
{
string assemblyPath = GetProjectRelativeFullPath(referencedProject, targetFrameworkInformation.AssemblyPath);
info.References.Add(assemblyPath);
}
else
{
string wrappedProjectPath = null;
if (!string.IsNullOrEmpty(targetFrameworkInformation.WrappedProject))
{
wrappedProjectPath = GetProjectRelativeFullPath(referencedProject, targetFrameworkInformation.WrappedProject);
}
info.ProjectReferences.Add(new ProjectReference
{
Name = referencedProject.Name,
Framework = library.Framework,
Path = library.Path,
WrappedProjectPath = wrappedProjectPath,
Project = referencedProject
});
}
}
}
var exportWithoutProjects = ProjectExportProviderHelper.GetExportsRecursive(
applicationHostContext.LibraryManager,
applicationHostContext.LibraryExportProvider,
new CompilationTarget("Debug", frameworkName, "Debug", null),
library => library.Type != "Project");
foreach (var reference in exportWithoutProjects.MetadataReferences)
{
var fileReference = reference as IMetadataFileReference;
if (fileReference != null)
{
info.References.Add(fileReference.Path);
}
}
foreach (var sourceFileReference in exportWithoutProjects.SourceReferences.OfType <ISourceFileReference>())
{
info.ExportedSourcesFiles.Add(sourceFileReference.Path);
}
return info;
}));
}
private static string GetProjectRelativeFullPath(DnxProject project, string path)
{
return(Path.GetFullPath(Path.Combine(project.ProjectDirectory, path)));
}
private static DependencyInformation ResolveDependencyInfo(DnxProject project, FrameworkName frameworkName)
{
var cacheKey = Tuple.Create("DependencyInformation", project.Name, "Debug", frameworkName);
return cache.Get<DependencyInformation>(cacheKey, ctx =>
{
var applicationHostContext = GetApplicationHostContext(project, "Debug", frameworkName);
var info = new DependencyInformation
{
HostContext = applicationHostContext,
ProjectReferences = new List<ProjectReference>(),
References = new List<string>(),
ExportedSourcesFiles = new List<string>()
};
foreach (var library in applicationHostContext.DependencyWalker.Libraries)
{
// Skip unresolved libraries
if (!library.Resolved)
{
continue;
}
if (string.Equals(library.Type, "Project") &&
!string.Equals(library.Identity.Name, project.Name))
{
DnxProject referencedProject = GetProject(library.Path);
if (referencedProject == null)
{
// Should never happen
continue;
}
var targetFrameworkInformation = referencedProject.GetTargetFramework(library.Framework);
// If this is an assembly reference then treat it like a file reference
if (!string.IsNullOrEmpty(targetFrameworkInformation.AssemblyPath) &&
string.IsNullOrEmpty(targetFrameworkInformation.WrappedProject))
{
string assemblyPath = GetProjectRelativeFullPath(referencedProject, targetFrameworkInformation.AssemblyPath);
info.References.Add(assemblyPath);
}
else
{
string wrappedProjectPath = null;
if (!string.IsNullOrEmpty(targetFrameworkInformation.WrappedProject))
{
wrappedProjectPath = GetProjectRelativeFullPath(referencedProject, targetFrameworkInformation.WrappedProject);
}
info.ProjectReferences.Add(new ProjectReference
{
Name = referencedProject.Name,
Framework = library.Framework,
Path = library.Path,
WrappedProjectPath = wrappedProjectPath,
Project = referencedProject
});
}
}
}
var exportWithoutProjects = ProjectExportProviderHelper.GetExportsRecursive(
applicationHostContext.LibraryManager,
applicationHostContext.LibraryExportProvider,
new CompilationTarget("Debug", frameworkName, "Debug", null),
library => library.Type != "Project");
foreach (var reference in exportWithoutProjects.MetadataReferences)
{
var fileReference = reference as IMetadataFileReference;
if (fileReference != null)
{
info.References.Add(fileReference.Path);
}
}
foreach (var sourceFileReference in exportWithoutProjects.SourceReferences.OfType<ISourceFileReference>())
{
info.ExportedSourcesFiles.Add(sourceFileReference.Path);
}
return info;
});
}
internal static Project GetProjectFromStream(Stream stream, string projectName, string projectPath, ICollection<ICompilationMessage> diagnostics = null)
{
var project = new Project();
var reader = new JsonTextReader(new StreamReader(stream));
var rawProject = JObject.Load(reader);
// Meta-data properties
var version = rawProject["version"];
var authors = rawProject["authors"];
var owners = rawProject["owners"];
var tags = rawProject["tags"];
var buildVersion = Environment.GetEnvironmentVariable("DNX_BUILD_VERSION");
project.Name = projectName;
project.ProjectFilePath = Path.GetFullPath(projectPath);
if (version == null)
{
project.Version = new SemanticVersion("1.0.0");
}
else
{
try
{
project.Version = SpecifySnapshot(version.Value<string>(), buildVersion);
}
catch (Exception ex)
{
var lineInfo = (IJsonLineInfo)version;
throw FileFormatException.Create(ex, version, project.ProjectFilePath);
}
}
var fileVersion = Environment.GetEnvironmentVariable("DNX_ASSEMBLY_FILE_VERSION");
if (string.IsNullOrWhiteSpace(fileVersion))
{
project.AssemblyFileVersion = project.Version.Version;
}
else
{
try
{
var simpleVersion = project.Version.Version;
project.AssemblyFileVersion = new Version(simpleVersion.Major,
simpleVersion.Minor,
simpleVersion.Build,
int.Parse(fileVersion));
}
catch (FormatException ex)
{
throw new FormatException("The assembly file version is invalid: " + fileVersion, ex);
}
}
project.Description = rawProject.GetValue<string>("description");
project.Summary = rawProject.GetValue<string>("summary");
project.Copyright = rawProject.GetValue<string>("copyright");
project.Title = rawProject.GetValue<string>("title");
project.Authors = authors == null ? new string[] { } : authors.ValueAsArray<string>();
project.Owners = owners == null ? new string[] { } : owners.ValueAsArray<string>();
project.Dependencies = new List<LibraryDependency>();
project.WebRoot = rawProject.GetValue<string>("webroot");
project.EntryPoint = rawProject.GetValue<string>("entryPoint");
project.ProjectUrl = rawProject.GetValue<string>("projectUrl");
project.LicenseUrl = rawProject.GetValue<string>("licenseUrl");
project.IconUrl = rawProject.GetValue<string>("iconUrl");
project.RequireLicenseAcceptance = rawProject.GetValue<bool?>("requireLicenseAcceptance") ?? false;
project.Tags = tags == null ? new string[] { } : tags.ValueAsArray<string>();
project.IsLoadable = rawProject.GetValue<bool?>("loadable") ?? true;
// TODO: Move this to the dependencies node
project.EmbedInteropTypes = rawProject.GetValue<bool>("embedInteropTypes");
// Project files
project.Files = new ProjectFilesCollection(rawProject, project.ProjectDirectory, project.ProjectFilePath, diagnostics);
var languageInfo = rawProject["language"] as JObject;
if (languageInfo != null)
{
var languageName = languageInfo.GetValue<string>("name") ?? "C#";
var languageServicesAssembly = languageInfo.GetValue<string>("assembly");
var projectReferenceProviderType = languageInfo.GetValue<string>("projectReferenceProviderType");
var libraryExporter = new TypeInformation(languageServicesAssembly, projectReferenceProviderType);
project.LanguageServices = new LanguageServices(languageName, libraryExporter);
}
var commands = rawProject["commands"] as JObject;
if (commands != null)
{
foreach (var command in commands)
{
project.Commands[command.Key] = command.Value.Value<string>();
}
}
var scripts = rawProject["scripts"] as JObject;
if (scripts != null)
{
foreach (var script in scripts)
{
var value = script.Value;
if (value.Type == JTokenType.String)
{
project.Scripts[script.Key] = new string[] { value.Value<string>() };
}
else if (value.Type == JTokenType.Array)
{
project.Scripts[script.Key] = script.Value.ValueAsArray<string>();
}
else
{
throw FileFormatException.Create(
string.Format("The value of a script in {0} can only be a string or an array of strings", ProjectFileName),
value,
project.ProjectFilePath);
}
}
}
project.BuildTargetFrameworksAndConfigurations(rawProject);
PopulateDependencies(
project.ProjectFilePath,
project.Dependencies,
rawProject,
"dependencies",
isGacOrFrameworkReference: false);
return project;
}
private void Initialize(DefaultHostOptions options, IServiceProvider hostServices)
{
var cacheContextAccessor = new CacheContextAccessor();
var cache = new Cache(cacheContextAccessor);
var namedCacheDependencyProvider = new NamedCacheDependencyProvider();
_applicationHostContext = new ApplicationHostContext(
hostServices,
_projectDirectory,
options.PackageDirectory,
options.Configuration,
_targetFramework,
cache,
cacheContextAccessor,
namedCacheDependencyProvider);
Logger.TraceInformation("[{0}]: Project path: {1}", GetType().Name, _projectDirectory);
Logger.TraceInformation("[{0}]: Project root: {1}", GetType().Name, _applicationHostContext.RootDirectory);
Logger.TraceInformation("[{0}]: Packages path: {1}", GetType().Name, _applicationHostContext.PackagesDirectory);
_project = _applicationHostContext.Project;
if (Project == null)
{
throw new Exception("Unable to locate " + Project.ProjectFileName);
}
if (options.WatchFiles)
{
var watcher = new FileWatcher(_applicationHostContext.RootDirectory);
_watcher = watcher;
watcher.OnChanged += _ =>
{
_shutdown.RequestShutdownWaitForDebugger();
};
}
else
{
_watcher = NoopWatcher.Instance;
}
_applicationHostContext.AddService(typeof(IApplicationShutdown), _shutdown);
// TODO: Get rid of this and just use the IFileWatcher
_applicationHostContext.AddService(typeof(IFileMonitor), _watcher);
_applicationHostContext.AddService(typeof(IFileWatcher), _watcher);
if (options.CompilationServerPort.HasValue)
{
// Using this ctor because it works on mono, this is hard coded to ipv4
// right now. Mono will eventually have the dualmode overload
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(new IPEndPoint(IPAddress.Loopback, options.CompilationServerPort.Value));
var networkStream = new NetworkStream(socket);
_applicationHostContext.AddService(typeof(IDesignTimeHostCompiler),
new DesignTimeHostCompiler(_shutdown, _watcher, networkStream), includeInManifest: false);
// Change the project reference provider
Project.DefaultLanguageService = new TypeInformation(
typeof(DefaultHost).GetTypeInfo().Assembly.GetName().Name,
typeof(DesignTimeHostProjectReferenceProvider).FullName);
}
CallContextServiceLocator.Locator.ServiceProvider = ServiceProvider;
}
private static string GetProjectRelativeFullPath(DnxProject project, string path)
{
return Path.GetFullPath(Path.Combine(project.ProjectDirectory, path));
}
public DesignTimeProjectReference(Project project, CompileResponse response)
{
_project = project;
_response = response;
}
private static ApplicationHostContext GetApplicationHostContext(DnxProject project, string configuration, FrameworkName frameworkName)
{
var cacheKey = Tuple.Create("ApplicationContext", project.Name, configuration, frameworkName);
return cache.Get<ApplicationHostContext>(cacheKey, ctx =>
{
var applicationHostContext = new ApplicationHostContext(null,
project.ProjectDirectory,
packagesDirectory: null,
configuration: configuration,
targetFramework: frameworkName,
cache: cache,
cacheContextAccessor: cacheContextAccessor,
namedCacheDependencyProvider: namedCacheDependencyProvider);
applicationHostContext.DependencyWalker.Walk(project.Name, project.Version, frameworkName);
return applicationHostContext;
});
}