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;
}
