public static (byte[] data, byte[] map) Compile(string source, Args args) { var @try = new AssemblerSyntax().ManyParser.Parse(source); var map = new DebugSymbols(); var offset = 0; var asm = new DynamicAssembly(args.OutFile, ("timestamp", $"{DateTime.UtcNow.Ticks}")); var gen = asm.GetGenerator(); foreach (var expression in @try) { void CompileToken(Instruction token) { map.symbols.Add(((short)offset, source.Split('\n')[offset])); offset++; gen.Emit(token); var value = token.Assembly(); var str = $"0x{value:X16}, offset: 0x{offset:X3}, op-code: 0x{token.OPCode:X2}, id: {token.ID}"; Trace($"compile :: {str}"); } switch (expression) { case InstructionExpression iExp: CompileToken(iExp.Instruction); break; case TransformationContext ctx: { foreach (var ins in ctx.Instructions) { CompileToken(ins); } break; } case ErrorCompileToken error: Error(error, source); throw new AncientCompileException(error.ErrorResult.ToString()); case CommentToken _: break; case NullExpression _: break; default: Warn(Warning.IgnoredToken, $"Ignored {expression} at {expression.InputPosition}"); break; } } return(asm.GetBytes(), DebugSymbols.ToBytes(map)); }
public void Create() { var d = new DynamicAssembly("test", ("foo", "bar")); Assert.Equal("test", d.Name); Assert.Equal(("foo", "bar"), d.Metadata.First()); Assert.Throws <InvalidOperationException>(() => { d.GetBytes(); }); Assert.NotNull(d.GetGenerator()); Assert.IsType <ILGen>(d.GetGenerator()); d.GetGenerator().Emit(new ldi(0xF, 0xC)); Assert.Equal(sizeof(ulong), d.GetILCode().Length); Assert.Equal($"{0xF00C0000:X}", $"{BitConverter.ToUInt32(d.GetILCode().Reverse().ToArray()):X}"); }
public Assembly BuildAssembly(string assemblyName) { _assembly = new DynamicAssembly(); AddSchemaAttribute(); foreach (var csdl in _csdlArtifacts) { BuildTypes(csdl); } var assemblyBuilder = _assembly.Compile(new AssemblyName(assemblyName)); // add the assembly to the list for assembly resolution _createdAssemblies.Add(assemblyBuilder); // EdmRelationshipAttributes require real Clr types so it adds these // attributes using CustomAttributeBuilder on already created assembly foreach (var csdl in _csdlArtifacts) { AddRelationshipAttributes(csdl, (AssemblyBuilder)assemblyBuilder); } return(assemblyBuilder); }
public MainForm(string columnsXmlFileName, string connectionStringFromCmdLine, string sqlEventAnalyzerDatabaseName) { _unattendedConnectionStringFromCmdLine = connectionStringFromCmdLine; if (sqlEventAnalyzerDatabaseName != null) { ConfigHandler.DatabaseName = sqlEventAnalyzerDatabaseName; } DynamicAssembly.EnableDynamicLoadingForDlls(Assembly.GetExecutingAssembly(), "SQLEventAnalyzer.Resources.Assemblies"); PreInitialize(); InitializeDatabaseOperation(false); Initialize(); bool success = true; if (columnsXmlFileName != null) { ManageColumnsForm form = new ManageColumnsForm(); form.Initialize(); success = form.LoadColumnXmlFile(columnsXmlFileName); } if (!success) { _unattendedExitCode = -1; Close(); } }
public Type[] GetControllerTypes(IEnumerable <ServiceInfo> services) { var result = _webApiGenerator.Generate(services); DynamicAssembly assembly = new DynamicAssembly(_eventHub); assembly.AppendSourceUnits(result); assembly.AddWebApiReferences(); AssemblyPurpose p = AssemblyPurpose.Handlers | AssemblyPurpose.Commands | AssemblyPurpose.Queries | AssemblyPurpose.Results; assembly.AddReferenceFrom(_dynamicPool.Where(x => (x.Purpose & p) > 0).Select(x => x.Assembly)); _dynamicPool.AddOrReplace(assembly); assembly.Compile(); var controllerTypes = assembly.Assembly.GetTypes() .Where(x => typeof(ControllerBase).IsAssignableFrom(x)) .ToArray(); return(controllerTypes); }
public CoreServiceInfo(Type t, string version, string name, int priority, bool debug, bool quiet) { _TypeOf = t; _Name = name; _Version = version; _Priority = priority; _Debug = debug; _Quiet = quiet; if (VitaNexCore.ServiceAssemblies.Contains(_TypeOf.Assembly)) { DynamicAssembly = _TypeOf.Assembly; DynamicAssemblyFile = new FileInfo(DynamicAssembly.Location); _Version = DynamicAssembly.GetName().Version.ToString(); } _OptionsProperty = _TypeOf.GetProperty("CSOptions", SearchFlags); _ConfigMethod = _TypeOf.GetMethod("CSConfig", SearchFlags); _InvokeMethod = _TypeOf.GetMethod("CSInvoke", SearchFlags); _DisposeMethod = _TypeOf.GetMethod("CSDispose", SearchFlags); _LoadMethod = _TypeOf.GetMethod("CSLoad", SearchFlags); _SaveMethod = _TypeOf.GetMethod("CSSave", SearchFlags); VitaNexCore.RegisterPlugin(this); }
public CoreModuleInfo(Type typeOf, string version, string name, bool enabled, int priority, bool debug, bool quiet) { _TypeOf = typeOf; _Name = name; _Version = version; _Enabled = enabled; _Priority = priority; _Debug = debug; _Quiet = quiet; Deferred = !_Enabled; if (VitaNexCore.ModuleAssemblies.Contains(_TypeOf.Assembly)) { DynamicAssembly = _TypeOf.Assembly; DynamicAssemblyFile = new FileInfo(DynamicAssembly.Location); _Version = DynamicAssembly.GetName().Version.ToString(); } _OptionsProperty = _TypeOf.GetProperty("CMOptions", SearchFlags); _ConfigMethod = _TypeOf.GetMethod("CMConfig", SearchFlags); _InvokeMethod = _TypeOf.GetMethod("CMInvoke", SearchFlags); _DisposeMethod = _TypeOf.GetMethod("CMDispose", SearchFlags); _LoadMethod = _TypeOf.GetMethod("CMLoad", SearchFlags); _SaveMethod = _TypeOf.GetMethod("CMSave", SearchFlags); _EnabledMethod = _TypeOf.GetMethod("CMEnabled", SearchFlags); _DisabledMethod = _TypeOf.GetMethod("CMDisabled", SearchFlags); VitaNexCore.RegisterPlugin(this); }
public void Assemblies_with_transitive_reference_are_include() { var busAssembly = new DynamicAssembly("Fake.NServiceBus.Core"); var assemblyC = new DynamicAssembly("C", new[] { busAssembly }); var assemblyB = new DynamicAssembly("B", new[] { assemblyC }); var assemblyA = new DynamicAssembly("A", new[] { assemblyB }); var assemblyD = new DynamicAssembly("D", new[] { assemblyB }); var scanner = new AssemblyScanner(DynamicAssembly.TestAssemblyDirectory); scanner.ScanAppDomainAssemblies = false; scanner.CoreAssemblyName = busAssembly.DynamicName; var result = scanner.GetScannableAssemblies(); Assert.IsTrue(result.Assemblies.Contains(assemblyA)); Assert.IsTrue(result.Assemblies.Contains(assemblyB)); Assert.IsTrue(result.Assemblies.Contains(assemblyC)); Assert.IsTrue(result.Assemblies.Contains(assemblyD)); Assert.IsTrue(result.Assemblies.Contains(busAssembly)); Assert.AreEqual(5, result.Assemblies.Count); }
public static void TransformWhenAssemblyIsDynamic() { var @dynamic = new DynamicAssembly(); var references = new[] { @dynamic }.Transform().ToList(); Assert.That(references.Count, Is.EqualTo(0)); }
public void Skipped_exes_should_be_excluded() { var busAssembly = new DynamicAssembly("Fake.NServiceBus.Core"); var excludedAssembly1 = new DynamicAssembly("A", new[] { busAssembly }, executable: true); var excludedAssembly2 = new DynamicAssembly("A", new[] { busAssembly }, executable: true); var includedAssembly = new DynamicAssembly("B", new[] { busAssembly }, executable: true); var scanner = new AssemblyScanner(DynamicAssembly.TestAssemblyDirectory); scanner.CoreAssemblyName = busAssembly.DynamicName; scanner.AssembliesToSkip.Add(excludedAssembly1.DynamicName); // without file extension scanner.AssembliesToSkip.Add(excludedAssembly2.FileName); // with file extension var result = scanner.GetScannableAssemblies(); Assert.That(result.SkippedFiles.Any(s => s.FilePath == excludedAssembly1.FilePath)); Assert.That(result.SkippedFiles.Any(s => s.FilePath == excludedAssembly2.FilePath)); Assert.That(result.Assemblies.Contains(includedAssembly.Assembly)); }
static GenericInterfaceWrapper() { WrappedTypeCache = new Dictionary <Type, Type>(); DynamicAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly( new AssemblyName(AssemblyName), AssemblyBuilderAccess.RunAndSave); DynamicModule = DynamicAssembly.DefineDynamicModule(ModuleName); }
public void Assemblies_which_reference_older_nsb_version_are_included() { var busAssemblyV2 = new DynamicAssembly("Fake.NServiceBus.Core", version: new Version(2, 0, 0), fakeIdentity: true); var assemblyReferencesV2 = new DynamicAssembly("AssemblyWithReference2", new[] { busAssemblyV2 }); var busAssemblyV1 = new DynamicAssembly("Fake.NServiceBus.Core", version: new Version(1, 0, 0), fakeIdentity: true); var assemblyReferencesV1 = new DynamicAssembly("AssemblyWithReference1", new[] { busAssemblyV1 }); var scanner = new AssemblyScanner(DynamicAssembly.TestAssemblyDirectory); scanner.ThrowExceptions = false; scanner.ScanAppDomainAssemblies = false; scanner.CoreAssemblyName = busAssemblyV2.Name; var result = scanner.GetScannableAssemblies(); Assert.IsTrue(result.Assemblies.Contains(busAssemblyV2)); Assert.IsTrue(result.Assemblies.Contains(assemblyReferencesV1)); Assert.IsTrue(result.Assemblies.Contains(assemblyReferencesV2)); Assert.AreEqual(3, result.Assemblies.Count); }
static NonPublicFastObjectRW() { Initialize_Func = DynamicAssembly.BuildDynamicMethod <Action <object> >((dm, ilGen) => StaticFastObjectRW <T> .ImplInitialize(ilGen), typeof(T).Module, true); GetOrdinal_String_Func = DynamicAssembly.BuildDynamicMethod <Func <object, string, int> >((dm, ilGen) => StaticFastObjectRW <T> .ImplGetOrdinal <string>(ilGen), typeof(T).Module, true); GetOrdinal_UTF16_Func = DynamicAssembly.BuildDynamicMethod <Func <object, Ps <char>, int> >((dm, ilGen) => StaticFastObjectRW <T> .ImplGetOrdinal <Ps <char> >(ilGen), typeof(T).Module, true); GetOrdinal_UTF8_Func = DynamicAssembly.BuildDynamicMethod <Func <object, Ps <Utf8Byte>, int> >((dm, ilGen) => StaticFastObjectRW <T> .ImplGetOrdinal <Ps <Utf8Byte> >(ilGen), typeof(T).Module, true); OnReadAll_String_Func = DynamicAssembly.BuildDynamicMethod <Action <object, IDataWriter <string> > >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnReadAll <string>(ilGen), typeof(T).Module, true); OnReadAll_UTF16_Func = DynamicAssembly.BuildDynamicMethod <Action <object, IDataWriter <Ps <char> > > >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnReadAll <Ps <char> >(ilGen), typeof(T).Module, true); OnReadAll_UTF8_Func = DynamicAssembly.BuildDynamicMethod <Action <object, IDataWriter <Ps <Utf8Byte> > > >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnReadAll <Ps <Utf8Byte> >(ilGen), typeof(T).Module, true); OnReadAll_INT32_Func = DynamicAssembly.BuildDynamicMethod <Action <object, IDataWriter <int> > >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnReadAll <int>(ilGen), typeof(T).Module, true); OnWriteAll_String_Func = DynamicAssembly.BuildDynamicMethod <Action <object, IDataReader <string> > >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnWriteAll <string>(ilGen), typeof(T).Module, true); OnWriteAll_UTF16_Func = DynamicAssembly.BuildDynamicMethod <Action <object, IDataReader <Ps <char> > > >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnWriteAll <Ps <char> >(ilGen), typeof(T).Module, true); OnWriteAll_UTF8_Func = DynamicAssembly.BuildDynamicMethod <Action <object, IDataReader <Ps <Utf8Byte> > > >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnWriteAll <Ps <Utf8Byte> >(ilGen), typeof(T).Module, true); OnWriteAll_INT32_Func = DynamicAssembly.BuildDynamicMethod <Action <object, IDataReader <int> > >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnWriteAll <int>(ilGen), typeof(T).Module, true); OnReadValue_String_Func = DynamicAssembly.BuildDynamicMethod <Action <object, string, IValueWriter> >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnReadValue <string>(ilGen), typeof(T).Module, true); OnReadValue_UTF16_Func = DynamicAssembly.BuildDynamicMethod <Action <object, Ps <char>, IValueWriter> >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnReadValue <Ps <char> >(ilGen), typeof(T).Module, true); OnReadValue_UTF8_Func = DynamicAssembly.BuildDynamicMethod <Action <object, Ps <Utf8Byte>, IValueWriter> >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnReadValue <Ps <Utf8Byte> >(ilGen), typeof(T).Module, true); OnReadValue_Int32_Func = DynamicAssembly.BuildDynamicMethod <Action <object, int, IValueWriter> >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnReadValue <int>(ilGen), typeof(T).Module, true); OnWriteValue_String_Func = DynamicAssembly.BuildDynamicMethod <Action <object, string, IValueReader> >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnWriteValue <string>(ilGen), typeof(T).Module, true); OnWriteValue_UTF16_Func = DynamicAssembly.BuildDynamicMethod <Action <object, Ps <char>, IValueReader> >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnWriteValue <Ps <char> >(ilGen), typeof(T).Module, true); OnWriteValue_UTF8_Func = DynamicAssembly.BuildDynamicMethod <Action <object, Ps <Utf8Byte>, IValueReader> >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnWriteValue <Ps <Utf8Byte> >(ilGen), typeof(T).Module, true); OnWriteValue_Int32_Func = DynamicAssembly.BuildDynamicMethod <Action <object, int, IValueReader> >((dm, ilGen) => StaticFastObjectRW <T> .ImplOnWriteValue <int>(ilGen), typeof(T).Module, true); }
public static Delegate GetInternal( Type delegateType, Type trueType, Dictionary <Type, Delegate> map, Func <Type, Type, LambdaExpression> build, bool updater ) { Delegate lambda; #endif if (trueType == null) { trueType = delegateType; } lock (lockObj) { if (map.TryGetValue(trueType, out lambda)) { return(lambda); } } var method = build(delegateType, trueType); #if DEBUG && DEBUG_SERIALIZATION TypeBuilder typeBuilder; //todo: this lock still isnt locking properly lock (buildLock) { lock (lockObj) { if (map.TryGetValue(trueType, out lambda)) { return(lambda); } } var @delegate = DynamicAssembly.Generate(GetDynamicTypeName(trueType, updater), method, out typeBuilder); lambda = Tuple.Create(@delegate, typeBuilder); lock (lockObj) { map[trueType] = lambda; } } #else lambda = method.Compile(); lock (lockObj) { map[trueType] = lambda; } #endif return(lambda); }
public MainForm() { DynamicAssembly.EnableDynamicLoadingForDlls(Assembly.GetExecutingAssembly(), "SQLEventAnalyzer.Resources.Assemblies"); PreInitialize(); InitializeDatabaseOperation(false); Initialize(); CheckForCustomColumnsUpdate(); }
private CompileResult CompileCode(string[] references) { DynamicAssembly assembly = new DynamicAssembly("AnyAssemblyName", references); assembly.CustomClasses.AddNew(codeEditorControl1.Text); CompileResult result = CSharpCompiler.CompileDynamicAssembly(assembly); return(result); }
private void codeEditorControl1_CompileRequest(CodeEditorControl sender, CompileRequestEventArgs args) { codeEditorControl1.ErrorPanelSettings.Header = "Compile..."; DynamicAssembly assembly = new DynamicAssembly("TestAssembly", codeEditorControl1.References.ToStringPathArray()); assembly.CustomClasses.AddNew(codeEditorControl1.Text); CompileResult result = CSharpCompiler.CompileDynamicAssembly(assembly); codeEditorControl1.ShowErrors(result.Errors, "Sucseed"); }
public void TestMethod1() { DynamicAssembly dynamicAssembly = new DynamicAssembly(); dynamicAssembly.DEBUG_MODE = true; FeignClientTypeBuilder feignClientTypeBuilder = new FeignClientTypeBuilder(dynamicAssembly); feignClientTypeBuilder.BuildType(typeof(ITestService));; feignClientTypeBuilder.Save(); }
public DynamicAssemblyManager(DynamicAssembly dynamicAssembly) { _dynamicAssembly = dynamicAssembly; _entityTypeBuilder = new EntityTypeBuilder(dynamicAssembly); _mappingTypeBuilder = new MappingTypeBuilder(dynamicAssembly); // TODO: should this use Thread.GetDomain()?? AppDomain.CurrentDomain.AssemblyResolve += ResolveAssembly; }
public MainForm(string useSessionId, string columnsXmlFileName, bool verboseMode, string connectionStringFromCmdLine, bool forceDelete, string applicationName, string sqlEventAnalyzerDatabaseName) { _unattendedConnectionStringFromCmdLine = connectionStringFromCmdLine; _forceDelete = forceDelete; _unattendedUseSessionParameter = true; if (sqlEventAnalyzerDatabaseName != null) { ConfigHandler.DatabaseName = sqlEventAnalyzerDatabaseName; } bool success = true; DynamicAssembly.EnableDynamicLoadingForDlls(Assembly.GetExecutingAssembly(), "SQLEventAnalyzer.Resources.Assemblies"); PreInitialize(); if (verboseMode) { dataViewUserControl1.SetVerboseMode(); customColumnsToolStripMenuItem.Visible = false; recordToolStripMenuItem.Visible = false; changeConnectionToolStripMenuItem.Visible = false; toolStripSeparator2.Visible = false; toolStripSeparator3.Visible = false; recordToolStripMenuItem.ShortcutKeys = Keys.None; customColumnsToolStripMenuItem.ShortcutKeys = Keys.None; showHiddenColumnsToolStripMenuItem.Visible = false; if (applicationName != null) { GenericHelper.ApplicationName = applicationName; } } InitializeDatabaseOperation(false); Initialize(); if (columnsXmlFileName != null) { ManageColumnsForm form = new ManageColumnsForm(); form.Initialize(); success = form.LoadColumnXmlFile(columnsXmlFileName); } if (success) { _useSessionId = useSessionId; _verboseMode = verboseMode; } else { _unattendedExitCode = -3; Close(); } }
public void TestMethod1() { DynamicAssembly dynamicAssembly = new DynamicAssembly(); dynamicAssembly.DEBUG_MODE = true; FeignClientHttpProxyTypeBuilder feignClientTypeBuilder = new FeignClientHttpProxyTypeBuilder(dynamicAssembly); FeignClientTypeInfo feignClientTypeInfo = feignClientTypeBuilder.Build(typeof(ITestService)); FeignClientTypeInfo feignClientTypeInfo1 = feignClientTypeBuilder.Build(typeof(ITestControllerService)); feignClientTypeBuilder.Save(); }
public static DynamicAssembly AddWebApiReferences(this DynamicAssembly a) { a.AddReferenceFromType <Profile>(); a.AddReferenceFromType <ControllerBase>(); a.Purpose = AssemblyPurpose.RequestProfiles | AssemblyPurpose.ResponseProfiles | AssemblyPurpose.Controllers | AssemblyPurpose.Responses | AssemblyPurpose.Requests; return(a); }
public void Set_throws_in_EDMX_mode_only_when_used_if_type_is_POCO_but_is_in_attributed_assembly_Dev10_883031() { var assembly = new DynamicAssembly(); assembly.HasAttribute(new EdmSchemaAttribute()); assembly.DynamicStructuralType("PocoEntity").Property("Id").HasType(typeof(int)); assembly.DynamicStructuralType("EocoEntity").Property("Id").HasType(typeof(int)).HasAttribute( new EdmEntityTypeAttribute()); assembly.Compile(new AssemblyName("MixedPocoEocoAssembly")); var pocoType = assembly.Types.Single(t => t.Name == "PocoEntity"); var setMethod = typeof(DbContext).GetDeclaredMethod("Set", Type.EmptyTypes).MakeGenericMethod(pocoType); var createMethod = typeof(DbSet <>).MakeGenericType(pocoType) .GetDeclaredMethods() .Single(m => m.Name == "Create" && !m.IsGenericMethodDefinition); var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(PregenContextEdmx.Csdl).CreateReader() }); var storeItemCollection = new StoreItemCollection(new[] { XDocument.Parse(PregenContextEdmx.Ssdl).CreateReader() }); IList <EdmSchemaError> errors; var storageMappingItemCollection = StorageMappingItemCollection.Create( edmItemCollection, storeItemCollection, new[] { XDocument.Parse(PregenContextEdmx.Msl).CreateReader() }, null, out errors); var workspace = new MetadataWorkspace( () => edmItemCollection, () => storeItemCollection, () => storageMappingItemCollection); using (var context = new DbContext( new EntityConnection(workspace, new SqlConnection(), entityConnectionOwnsStoreConnection: true), contextOwnsConnection: true)) { var set = setMethod.Invoke(context, null); Assert.Throws <InvalidOperationException>( () => { try { createMethod.Invoke(set, null); } catch (TargetInvocationException tie) { throw tie.InnerException; } }).ValidateMessage( "DbSet_PocoAndNonPocoMixedInSameAssembly", "PocoEntity"); } }
public static DynamicAssembly AddDefaultReferences(this DynamicAssembly assembly) { assembly.AddReferenceFromType(typeof(ICommandHandler <,>)); assembly.AddReferenceFromType <IRepository>(); assembly.AddReferenceFromType <SqlParameterCollection>(); assembly.AddReferenceFromType <IConfiguration>(); assembly.Purpose = AssemblyPurpose.Handlers | AssemblyPurpose.Queries | AssemblyPurpose.Commands | AssemblyPurpose.Results; return(assembly); }
public static void Main() { DynamicAssembly.EnableDynamicLoadingForDlls(Assembly.GetExecutingAssembly(), "DatabaseDescriptionTool.Resources.Assemblies"); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException); Application.ThreadException += ApplicationThreadException; AppDomain.CurrentDomain.UnhandledException += CurrentDomainUnhandledException; Application.Run(new MainForm()); }
public ErrorModel DeleteData(Type type, object data, string formName) { var updObj = DynamicAssembly.InvokeGenericMethod(type, this, "JsonToObject", data); ErrorModel err = this.ValidateObject(updObj, formName); if (err != null) { return(err); } DynamicAssembly.InvokeGenericMethod(type, this, "DeleteDataLogic", updObj); return(null); }
private static bool TestIsSupportEmit() { try { DynamicAssembly.DefineType(nameof(TestIsSupportEmit), TypeAttributes.Public).CreateTypeInfo(); return(true); } catch (Exception) { return(false); } }
private async Task WhenHandlerIsExecuted(string json, string requestTypeName, string handlerName) { DynamicAssembly assembly = (DynamicAssembly)_context["assembly"]; var type = assembly.Load("Basic", requestTypeName); dynamic arg = JsonConvert.DeserializeObject(json, type); var handlerType = assembly.Load("dbo", handlerName); await _applicationExecutor.ExecuteAsync <IServiceProvider>(async conteiner => { dynamic handler = conteiner.GetService(handlerType); _context["result"] = await handler.Execute(arg); }); }
public static Type Create(string[] columnNames, Type[] columnTypes) { var moduleBuilder = DynamicAssembly.GetExistingDynamicAssemblyOrCreateNew(Assembly.GetExecutingAssembly()); var typeName = DynamicAssembly.GetUniqueTypeName("DbMap.Runtime.DynamicType"); var typeBuilder = moduleBuilder.DefineType(typeName, TypeAttributes.Public | TypeAttributes.Sealed, null); // .ctor() { var constructor = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes); var il = constructor.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes)); il.Emit(OpCodes.Ret); } // Private fields/get properties. for (var index = 0; index < columnNames.Length; index++) { var columnName = columnNames[index]; var columnType = columnTypes[index]; for (var innerIndex = 0; innerIndex < index; innerIndex++) { if (columnName == columnNames[innerIndex]) { ThrowException.DuplicateFieldNames(columnNames[innerIndex]); } } if (columnType.IsClass == false) { columnType = typeof(Nullable <>).MakeGenericType(columnType); } var fieldName = "<" + columnName + ">k__BackingField"; var field = typeBuilder.DefineField(fieldName, columnType, FieldAttributes.Private); var getMethod = typeBuilder.DefineMethod("get_" + columnName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, columnType, Type.EmptyTypes); var il = getMethod.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldfld, field); il.Emit(OpCodes.Ret); var property = typeBuilder.DefineProperty(columnName, PropertyAttributes.HasDefault, columnType, null); property.SetGetMethod(getMethod); } return(typeBuilder.CreateTypeInfo()); }
public void ThenResultIs(string json) { DynamicAssembly assembly = (DynamicAssembly)_context["assembly"]; var type = assembly.Load("Basic", "UserEntity"); if (json.Trim().StartsWith("[")) { type = type.MakeArrayType(); } object expected = JsonConvert.DeserializeObject(json, type); object actual = _context["result"]; actual.Should().BeEquivalentTo(expected); }
private static Type CreateWeakProviderType() { var assembly = new DynamicAssembly(); var dynamicType = assembly.DynamicType("WeakProviderFactory").HasBaseClass(typeof(DbProviderFactory)); dynamicType.CtorAccess = MemberAccess.Public; dynamicType.Field("Instance").HasType(dynamicType).IsStatic().IsInstance(); var compiledAssembly = assembly.Compile(new AssemblyName("ProviderAssembly")); // We need this so that Type.GetType() used in DbProviderFactories.GetFactory will work for // the dynamic assembly. In other words, this is only needed for the test code to work. AppDomain.CurrentDomain.AssemblyResolve += (sender, args) => args.Name.StartsWith("ProviderAssembly") ? compiledAssembly : null; return assembly.GetType("WeakProviderFactory"); }
public void AppDomainAssemblies_are_included_when_enabling_ScanAppDomainAssemblies() { var busAssembly = new DynamicAssembly("Fake.NServiceBus.Core"); Assembly.LoadFrom(busAssembly.FilePath); var scanner = new AssemblyScanner(); // don't scan the dynamic assembly folder scanner.CoreAssemblyName = busAssembly.DynamicName; scanner.ScanAppDomainAssemblies = true; var result = scanner.GetScannableAssemblies(); Assert.IsTrue(result.Assemblies.Contains(busAssembly)); }
public void Assemblies_with_direct_reference_are_included() { var busAssembly = new DynamicAssembly("Fake.NServiceBus.Core.dll"); var assemblyWithReference = new DynamicAssembly("AssemblyWithReference.dll", new[] { busAssembly }); var scanner = new AssemblyScanner(DynamicAssembly.TestAssemblyDirectory); scanner.CoreAssemblyName = busAssembly.DynamicName; var result = scanner.GetScannableAssemblies(); Assert.IsTrue(result.Assemblies.Contains(assemblyWithReference)); Assert.IsTrue(result.Assemblies.Contains(busAssembly)); Assert.AreEqual(2, result.Assemblies.Count); }
public IDynamicAssemblyManager Create(string assemblyName) { if (Managers.ContainsKey(assemblyName) == false) { lock (ManagerLocker) { if (Managers.ContainsKey(assemblyName) == false) { var dynamicAssembly = new DynamicAssembly(assemblyName, PersistDynamicAssemblies); var manager = new DynamicAssemblyManager(dynamicAssembly); Managers.TryAdd(assemblyName, manager); } } } return Managers[assemblyName]; }
/// <summary> /// Initializes a new instance of the <see cref = "CodeGenerator" /> class. /// </summary> /// <param name = "assembly">The assembly.</param> /// <param name = "is64Bits"></param> protected CodeGenerator (DynamicAssembly assembly, bool is64Bits) { this.Assembly = assembly; this.Is64Bits = is64Bits; }
public DynamicAssembly(string nameWithoutExtension, DynamicAssembly[] references = null, Version version = null, bool fakeIdentity = false) { if (version == null) { version = new Version(1, 0, 0, 0); } if (references == null) { references = new DynamicAssembly[0]; } Name = nameWithoutExtension; Namespace = nameWithoutExtension; FileName = $"{Namespace}{Path.GetFileNameWithoutExtension(Path.GetRandomFileName())}{Interlocked.Increment(ref dynamicAssemblyId)}.dll"; DynamicName = Path.GetFileNameWithoutExtension(FileName); var builder = new StringBuilder(); builder.AppendLine("using System.Reflection;"); builder.AppendLine($"[assembly: AssemblyVersion(\"{version}\")]"); builder.AppendLine($"[assembly: AssemblyFileVersion(\"{version}\")]"); builder.AppendFormat("namespace {0} {{ ", Namespace); var provider = new CSharpCodeProvider(); var param = new CompilerParameters(new string[] { }, FileName); param.GenerateExecutable = false; param.GenerateInMemory = false; param.OutputAssembly = FilePath = Path.Combine(TestAssemblyDirectory, FileName); param.TempFiles = new TempFileCollection(TestAssemblyDirectory, false); foreach (var reference in references) { builder.AppendLine($"using {reference.Namespace};"); param.ReferencedAssemblies.Add(reference.FilePath); } builder.AppendLine("public class Foo { public Foo() {"); foreach (var reference in references) { builder.AppendLine($"new {reference.Namespace}.Foo();"); } builder.AppendLine("} } }"); var result = provider.CompileAssemblyFromSource(param, builder.ToString()); ThrowIfCompilationWasNotSuccessful(result); provider.Dispose(); if (fakeIdentity) { var reader = AssemblyDefinition.ReadAssembly(FilePath); reader.Name.Name = nameWithoutExtension; reader.MainModule.Name = nameWithoutExtension; reader.Write(FilePath); } Assembly = result.CompiledAssembly; }
public void Assemblies_with_transitive_reference_are_include() { var busAssembly = new DynamicAssembly("Fake.NServiceBus.Core"); var assemblyC = new DynamicAssembly("C", new[] { busAssembly }); var assemblyB = new DynamicAssembly("B", new[] { assemblyC }); var assemblyA = new DynamicAssembly("A", new[] { assemblyB }); var assemblyD = new DynamicAssembly("D", new[] { assemblyB }); var scanner = new AssemblyScanner(DynamicAssembly.TestAssemblyDirectory); scanner.CoreAssemblyName = busAssembly.DynamicName; var result = scanner.GetScannableAssemblies(); Assert.IsTrue(result.Assemblies.Contains(assemblyA)); Assert.IsTrue(result.Assemblies.Contains(assemblyB)); Assert.IsTrue(result.Assemblies.Contains(assemblyC)); Assert.IsTrue(result.Assemblies.Contains(assemblyD)); Assert.IsTrue(result.Assemblies.Contains(busAssembly)); Assert.AreEqual(5, result.Assemblies.Count); }
public void Assemblies_which_reference_older_nsb_version_are_included() { var busAssemblyV2 = new DynamicAssembly("Fake.NServiceBus.Core", version: new Version(2, 0, 0), fakeIdentity: true); var assemblyReferencesV2 = new DynamicAssembly("AssemblyWithReference2", new[] { busAssemblyV2 }); var busAssemblyV1 = new DynamicAssembly("Fake.NServiceBus.Core", version: new Version(1, 0, 0), fakeIdentity: true); var assemblyReferencesV1 = new DynamicAssembly("AssemblyWithReference1", new[] { busAssemblyV1 }); var scanner = new AssemblyScanner(DynamicAssembly.TestAssemblyDirectory); scanner.ThrowExceptions = false; scanner.CoreAssemblyName = busAssemblyV2.Name; var result = scanner.GetScannableAssemblies(); Assert.IsTrue(result.Assemblies.Contains(busAssemblyV2)); Assert.IsTrue(result.Assemblies.Contains(assemblyReferencesV1)); Assert.IsTrue(result.Assemblies.Contains(assemblyReferencesV2)); Assert.AreEqual(3, result.Assemblies.Count); }
public void ImplicitLoadAssemblyForType_checks_calling_schema_assembly_and_references_for_views_if_type_assembly_filtered() { var assembly = new DynamicAssembly(); assembly.HasAttribute(new EdmSchemaAttribute()); var callingAssembly = assembly.Compile(new AssemblyName("WithEdmSchemaAttribute")); var mockCache = new Mock<IViewAssemblyCache>(); var workspace = new MetadataWorkspace( () => new EdmItemCollection(Enumerable.Empty<XmlReader>()), () => null, () => null, () => new ObjectItemCollection(mockCache.Object)); workspace.ImplicitLoadAssemblyForType(typeof(object), callingAssembly); mockCache.Verify(m => m.CheckAssembly(typeof(object).Assembly, It.IsAny<bool>()), Times.Never()); mockCache.Verify(m => m.CheckAssembly(callingAssembly, true), Times.Once()); }
public MappingTypeBuilder(DynamicAssembly dynamicAssembly) { _dynamicAssembly = dynamicAssembly; }
public EntityTypeBuilder(DynamicAssembly dynamicAssembly) { _dynamicAssembly = dynamicAssembly; }