public void Test() { var version1Code = "[assembly: System.Reflection.AssemblyVersion(\"1.0.0.0\")]"; var version2Code = "[assembly: System.Reflection.AssemblyVersion(\"2.0.0.0\")]"; var appDomain1BasePath = Path.Combine(Path.GetTempPath(), "appdomain1"); var appDomain2BasePath = Path.Combine(Path.GetTempPath(), "appdomain2"); CompilationServices.EmitAssembly(Path.Combine(appDomain1BasePath, TestAssemblyName), BaseCode, version1Code); CompilationServices.EmitAssembly(Path.Combine(appDomain2BasePath, TestAssemblyName), BaseCode, version2Code); if (File.Exists(DataFile)) { File.Delete(DataFile); } try { ExecuteTestMethodInAppDomain(appDomain1BasePath, "Store"); ExecuteTestMethodInAppDomain(appDomain2BasePath, "Load"); } catch (Exception e) { while (e is TargetInvocationException) { e = e.InnerException; } Assert.Fail(e.Message); } }
private static Assembly EmitAssemblyAndLoad(string assemblyName, string code) { var assemblyFile = Path.Combine(Path.GetTempPath(), assemblyName); CompilationServices.EmitAssembly(assemblyFile, code); return(Assembly.LoadFrom(assemblyFile)); }
private static AppDomain PrepareTestEnvironment(string assemblyFileName, string code) { var targetAppDomain = CreateAppDomain(); var assemblyPath = Path.Combine(targetAppDomain.BaseDirectory, assemblyFileName + ".dll"); CompilationServices.EmitAssembly(assemblyPath, code); return(targetAppDomain); }
private string InstrumentResource() { string resourceName = ResourceServices.CompleteResourceName(GetType(), "TABytecodeChangesSubject"); string path = CompilationServices.EmitAssemblyFromResource(resourceName); ShellUtilities.ProcessOutput output = InstrumentationServices.InstrumentAssembly("-ta", path); Assert.AreEqual(0, output.ExitCode); return(path); }
public override async void Analyze(RepoProject project) { var logger = project.Repo.AnalysisServices.Logger; try { var services = project.Repo.AnalysisServices; logger.LogMessage("Loading project: " + project.ProjectId); using (services.TaskDispatcher.TrackScope()) { await services.TaskDispatcher.Invoke(async() => { var solution = await lazySolution.Value; Project = solution.GetProject(ProjectId); if (Project == null) { logger.LogError($"Can't find project for {ProjectId} in {solution}"); } else { Compilation = await Project.GetCompilationAsync(); CompilationServices = new CompilationServices(Compilation); foreach (var reference in Compilation.ReferencedAssemblyNames) { var referencedProject = new ReferencedProject() { ProjectId = reference.Name, DisplayName = reference.GetDisplayName(), Properties = new Dictionary <string, string>() { { "PublicKey", string.Concat(reference.PublicKey.Select(b => b.ToString("X2"))) } } }; ProjectContext.ReferencedProjects.TryAdd(referencedProject.ProjectId, referencedProject); } } base.Analyze(project); }); var documents = await Task.WhenAll(DocumentAnalysisTasks); ProjectContext.Finish(project); UploadProject(project, ProjectContext.Project); project.Analyzer = RepoProjectAnalyzer.Null; } } catch (Exception ex) { logger.LogExceptionError($"Loading project {project.ProjectId}", ex); } }
public static AssemblyDefinition AssemblyFromResource(string resourceName, Type simblingType, bool loadSymbols, Action <string> sourceHandler, params Assembly[] references) { string assemblyPath = CompilationServices.EmitAssemblyFromResource( ResourceServices.CompleteResourceName(simblingType, resourceName), sourceHandler, references); ReaderParameters parameters = new ReaderParameters(); parameters.ReadSymbols = loadSymbols; return(AssemblyDefinition.ReadAssembly(assemblyPath, parameters)); }
public void TestCrossAssemblyActivateCallIsIgnored() { const string helperAssemblyCode = @" using Db4objects.Db4o.TA; using Db4objects.Db4o.Activation; public class ActivatorUtil { public static void ActivateForRead(IActivatable item) { item.Activate(ActivationPurpose.Read); } }" ; const string assemblyCode = @" using Db4objects.Db4o.TA; using Db4objects.Db4o.Activation; public class ActivatableItem : IActivatable { public void Bind(IActivator activator) {} public void Activate(ActivationPurpose purpose) {} public string name; } public class Predicates { public bool ByName(ActivatableItem item) { ActivatorUtil.ActivateForRead(item); return item.name.StartsWith(""foo""); } }" ; CompilationServices.EmitAssembly(AssemblyPathFor("ActivatorHelper.dll"), new[] { Db4oAssemblyPath() }, helperAssemblyCode); var crossNQAssemblyPath = AssemblyPathFor("CrossNQ.dll"); CompilationServices.EmitAssembly(crossNQAssemblyPath, new[] { Db4oAssemblyPath(), AssemblyPathFor("ActivatorHelper.dll") }, assemblyCode); var assembly = Assembly.LoadFrom(crossNQAssemblyPath); var type = assembly.GetType("Predicates"); var expression = new QueryExpressionBuilder().FromMethod(type.GetMethod("ByName", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.Public)); AssertSimpleComparisionAgainstConstant(expression, "foo"); }
protected override void Store() { var dynamicAssemblyPath = Path.GetTempFileName() + ".dll"; CompilationServices.EmitAssembly(dynamicAssemblyPath, new string[0], @" namespace Test { public class Subject { public int value; } } " ); _dynamicAssembly = Assembly.LoadFrom(dynamicAssemblyPath); }
public void SetUp() { var dynamicAssemblyPath = Path.Combine(Path.GetTempPath(), "DynamicAssemblyTest.dll"); CompilationServices.EmitAssembly(dynamicAssemblyPath, new string[0], @" namespace Test { public class Subject { public int value; } } " ); var type = Assembly.LoadFrom(dynamicAssemblyPath).GetTypes()[0]; typeName = type.FullName + ", " + type.Assembly.GetName().Name; }
private void Initialize(DefaultHostOptions options, IAssemblyLoadContextAccessor loadContextAccessor) { var applicationHostContext = new ApplicationHostContext { ProjectDirectory = _projectDirectory, RuntimeIdentifiers = _runtimeEnvironment.GetAllRuntimeIdentifiers(), TargetFramework = _targetFramework }; var libraries = ApplicationHostContext.GetRuntimeLibraries(applicationHostContext, throwOnInvalidLockFile: true); Logger.TraceInformation("[{0}]: Project path: {1}", GetType().Name, applicationHostContext.ProjectDirectory); Logger.TraceInformation("[{0}]: Project root: {1}", GetType().Name, applicationHostContext.RootDirectory); Logger.TraceInformation("[{0}]: Project configuration: {1}", GetType().Name, options.Configuration); Logger.TraceInformation("[{0}]: Packages path: {1}", GetType().Name, applicationHostContext.PackagesDirectory); _applicationHostContext = applicationHostContext; _project = applicationHostContext.Project; #if FEATURE_DNX_MIN_VERSION_CHECK ValidateMinRuntimeVersion(libraries); #endif // Create a new Application Environment for running the app. It needs a reference to the Host's application environment // (if any), which we can get from the service provider we were given. // If this is null (i.e. there is no Host Application Environment), that's OK, the Application Environment we are creating // will just have it's own independent set of global data. var hostEnvironment = PlatformServices.Default.Application; var applicationEnvironment = new ApplicationEnvironment(Project, _targetFramework, hostEnvironment); var compilationContext = new CompilationEngineContext( applicationEnvironment, _runtimeEnvironment, loadContextAccessor.Default, new CompilationCache()); var compilationEngine = new CompilationEngine(compilationContext); var runtimeLibraryExporter = new RuntimeLibraryExporter(() => compilationEngine.CreateProjectExporter(Project, _targetFramework, options.Configuration)); var runtimeLibraryManager = new RuntimeLibraryManager(applicationHostContext); // Default services _serviceProvider.Add(typeof(ILibraryExporter), runtimeLibraryExporter); _serviceProvider.Add(typeof(IApplicationEnvironment), applicationEnvironment); _serviceProvider.Add(typeof(IRuntimeEnvironment), PlatformServices.Default.Runtime); _serviceProvider.Add(typeof(ILibraryManager), runtimeLibraryManager); _serviceProvider.Add(typeof(IAssemblyLoadContextAccessor), PlatformServices.Default.AssemblyLoadContextAccessor); _serviceProvider.Add(typeof(IAssemblyLoaderContainer), PlatformServices.Default.AssemblyLoaderContainer); PlatformServices.SetDefault(new ApplicationHostPlatformServices(PlatformServices.Default, applicationEnvironment, runtimeLibraryManager)); if (options.CompilationServerPort.HasValue) { // Change the project reference provider Project.DefaultCompiler = Project.DefaultDesignTimeCompiler; Project.DesignTimeCompilerPort = options.CompilationServerPort.Value; } // TODO: Dedupe this logic in the RuntimeLoadContext var projects = libraries.Where(p => p.Type == Runtime.LibraryTypes.Project) .ToDictionary(p => p.Identity.Name, p => (ProjectDescription)p); var assemblies = PackageDependencyProvider.ResolvePackageAssemblyPaths(libraries); // Configure Assembly loaders _loaders.Add(new ProjectAssemblyLoader(loadContextAccessor, compilationEngine, projects.Values, options.Configuration)); _loaders.Add(new PackageAssemblyLoader(loadContextAccessor, assemblies, libraries)); var compilerOptionsProvider = new CompilerOptionsProvider(projects); _serviceProvider.Add(typeof(ICompilerOptionsProvider), compilerOptionsProvider); CompilationServices.SetDefault( CompilationServices.Create( libraryExporter: runtimeLibraryExporter, compilerOptionsProvider: compilerOptionsProvider ) ); #if DNX451 PackageDependencyProvider.EnableLoadingNativeLibraries(libraries); #endif AddBreadcrumbs(libraries); }
private void EmitAssembly(string assemblyFile) { string[] references = new string[] { Db4oAssemblyPath() }; CompilationServices.EmitAssembly(assemblyFile, references, DataGeneratorCode); }
public void Emit(string fname) { CompilationServices.EmitAssembly(fname, new string[] { _legacyAssembly }, GetCode()); }