/// <summary>
/// Runs specified method.
/// </summary>
/// <param name="entryMethod">The entry method.</param>
/// <returns>TestingAssembly.</returns>
private TestingAssembly runWithAssemblyLoad(Func <string> entryMethod)
{
var assembly = new CILAssembly(GetType().Assembly.Location);
return(AssemblyUtils.RunCIL(entryMethod)
.AddAssembly(assembly));
}
public Boolean TryGetMappedAssembly(CILAssemblyName name, out CILAssembly assembly)
{
Lazy <CILAssembly> lazy;
var retVal = this._assemblies.TryGetValue(name, out lazy);
assembly = retVal ? lazy.Value : null;
return(retVal);
}
/// <summary>
/// Adds a <see cref="TargetFrameworkAttribute"/> to the <see cref="CILAssembly"/> which has given framework information.
/// This method should not be used when adding <see cref="TargetFrameworkAttribute"/> to Portable Class Libraries.
/// </summary>
/// <param name="assembly">The <see cref="CILAssembly"/>.</param>
/// <param name="fwName">The name of the target framework. This will be passed directly as string argument to the attribute constructor.</param>
/// <param name="fwDisplayName">The display name of the target framework.</param>
/// <exception cref="NullReferenceException">If <paramref name="assembly"/> is <c>null</c>.</exception>
public static void AddTargetFrameworkAttributeNative(this CILAssembly assembly, String fwName, String fwDisplayName)
{
assembly.AddCustomAttribute(
ModuleReader.TARGET_FRAMEWORK_ATTRIBUTE_CTOR.NewWrapper(assembly.ReflectionContext),
new CILCustomAttributeTypedArgument[] { CILCustomAttributeFactory.NewTypedArgument(ModuleReader.TARGET_FRAMEWORK_ATTRIBUTE_CTOR.GetParameters().First().ParameterType.NewWrapperAsType(assembly.ReflectionContext), fwName) },
fwDisplayName == null ? null : new CILCustomAttributeNamedArgument[] { CILCustomAttributeFactory.NewNamedArgument(ModuleReader.TARGET_FRAMEWORK_ATTRIBUTE_NAMED_PROPERTY.NewWrapper(assembly.ReflectionContext), CILCustomAttributeFactory.NewTypedArgument((CILType)ModuleReader.TARGET_FRAMEWORK_ATTRIBUTE_NAMED_PROPERTY.NewWrapper(assembly.ReflectionContext).GetPropertyType(), fwDisplayName)) }
);
}
/// <summary>
/// This extension method gets the public key token of the given <see cref="CILAssembly"/>.
/// If the <see cref="CILAssemblyName.Flags"/> specify that the assembly name is not using full public key, then the <see cref="CILAssemblyName.PublicKey"/> is returned directly.
/// Otherwise, the public key token is computed by using <see cref="CILReflectionContext.ComputePublicKeyToken"/> method.
/// </summary>
/// <param name="assembly">The <see cref="CILAssembly"/>.</param>
/// <returns>The public key token of the given <see cref="CILAssembly"/>.</returns>
public static Byte[] GetPublicKeyToken(this CILAssembly assembly)
{
var an = assembly.Name;
var result = an.PublicKey;
return(an.Flags.IsFullPublicKey() && result != null && result.Length > 0 ?
assembly.ReflectionContext.ComputePublicKeyToken(result) :
result);
}
public RuntimeTypeFactory(CILAssembly cilAssembly, CILModule cilModule)
{
var assemblyName = new AssemblyName(cilAssembly.AssemblyName);
var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
_assemblyBuilder = assemblyBuilder;
var moduleBuilder = _assemblyBuilder.DefineDynamicModule(cilModule.ModuleName);
_moduleBuilder = moduleBuilder;
}
private static void ForceLoadAssembly(CILAssembly assembly)
{
var dummy1 = assembly.Name;
var dummy2 = assembly.CustomAttributeData;
var dummy3 = assembly.ForwardedTypeInfos;
foreach (var mod in assembly.Modules)
{
ForceLoadModule(mod);
}
}
/// <inheritdoc />
protected override void generate(EmitterBase emitter)
{
//first and only argument is parametric
var resolvedArguments = CILAssembly.ResolveCustomAttributeArgument(_attribute.ConstructorArguments[0]) as object[];
for (var i = 0; i < resolvedArguments.Length; ++i)
{
var argumentStorage = "arg" + i;
var argumentValue = resolvedArguments[i];
emitter.AssignLiteral(argumentStorage, argumentValue);
}
}
/// <summary>
/// Adds a <see cref="TargetFrameworkAttribute"/> to the <see cref="CILAssembly"/> which represents information for given target framework.
/// </summary>
/// <param name="assembly">The <see cref="CILAssembly"/>.</param>
/// <param name="monikerInfo">The information about target framework, see <see cref="FrameworkMonikerInfo"/>.</param>
/// <param name="monikerMapper">The assembly mapper helper, created by <see cref="E_CIL.CreateMapperForFrameworkMoniker"/> method, or by creating <see cref="EmittingArguments"/> by <see cref="EmittingArguments.CreateForEmittingWithMoniker"/> method and accessing its <see cref="EmittingArguments.AssemblyMapper"/> property.</param>
/// <exception cref="NullReferenceException">If <paramref name="assembly"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">If <paramref name="monikerInfo"/> or <paramref name="monikerMapper"/> is <c>null</c>.</exception>
public static void AddTargetFrameworkAttributeWithMonikerInfo(this CILAssembly assembly, FrameworkMonikerInfo monikerInfo, EmittingAssemblyMapper monikerMapper)
{
ArgumentValidator.ValidateNotNull("Moniker info", monikerInfo);
ArgumentValidator.ValidateNotNull("Moniker mapper", monikerMapper);
var targetFWType = (CILType)monikerMapper.MapTypeBase(ModuleReader.TARGET_FRAMEWORK_ATTRIBUTE_CTOR.DeclaringType.NewWrapper(assembly.ReflectionContext));
var targetFWCtor = targetFWType.Constructors.First(ctor => ctor.Parameters.Count == 1 && ctor.Parameters[0].ParameterType is CILType && ((CILType)ctor.Parameters[0].ParameterType).TypeCode == CILTypeCode.String);
var targetFWProp = targetFWType.DeclaredProperties.First(prop => prop.Name == ModuleReader.TARGET_FRAMEWORK_ATTRIBUTE_NAMED_PROPERTY.Name);
var fwString = monikerInfo.FrameworkName + ",Version=" + monikerInfo.FrameworkVersion;
if (!String.IsNullOrEmpty(monikerInfo.ProfileName))
{
fwString += ",Profile=" + monikerInfo.ProfileName;
}
assembly.AddCustomAttribute(
targetFWCtor,
new CILCustomAttributeTypedArgument[] { CILCustomAttributeFactory.NewTypedArgument((CILType)targetFWCtor.Parameters[0].ParameterType, fwString) },
new CILCustomAttributeNamedArgument[] { CILCustomAttributeFactory.NewNamedArgument(targetFWProp, CILCustomAttributeFactory.NewTypedArgument((CILType)targetFWProp.GetPropertyType(), monikerInfo.FrameworkDisplayName)) }
);
}
/// <summary>
/// Tries to get PCL profile based on <see cref="TargetFrameworkAttribute"/> applied on <see cref="CILAssembly"/>.
/// </summary>
/// <param name="assembly">The <see cref="CILAssembly"/>.</param>
/// <param name="fwName">This will contain the framework name, if attribute is successfully found, otherwise <c>null</c>.</param>
/// <param name="fwVersion">This will contain the framework version, if attribute is successfully found, otherwise <c>null</c>.</param>
/// <param name="fwProfile">This will contain the framework profile, if attribute is successfully found, otherwise <c>null</c>.</param>
/// <remarks>
/// This method works by detecting an custom attribute of type <c>System.Runtime.Versioning.TargetFrameworkAttribute</c> which contains one constructor argument of type <see cref="String"/>.
/// Then the method tries to detect to parse the required information by assuming the string is in format <c><fwName>,Version=<fwVersion>,Profile=<fwProfile></c>, where version and profile information are optional.
/// </remarks>
public static void TryGetTargetFrameworkInfoBasedOnAttribute(this CILAssembly assembly, out String fwName, out String fwVersion, out String fwProfile)
{
fwName = null;
fwVersion = null;
fwProfile = null;
if (assembly != null)
{
foreach (var cd in assembly.CustomAttributeData)
{
if (String.Equals(cd.Constructor.DeclaringType.Name, "TargetFrameworkAttribute") &&
String.Equals(cd.Constructor.DeclaringType.Namespace, "System.Runtime.Versioning") &&
cd.ConstructorArguments.Count == 1 &&
cd.ConstructorArguments[0].Value is String)
{
break;
}
}
}
}
internal CILModuleImpl(CILReflectionContextImpl ctx, Int32 anID, CILAssembly ass, String name)
: base(ctx, CILElementKind.Module, anID, new LazyWithLock <ListProxy <CILCustomAttribute> >(() => ctx.CollectionsFactory.NewListProxy <CILCustomAttribute>()))
{
InitFields(
ref this.name,
ref this.assembly,
ref this.types,
ref this.moduleInitializer,
ref this.associatedMSCorLib,
ref this.typeNameCache,
ref this.manifestResources,
name,
() => ass,
() => ctx.CollectionsFactory.NewListProxy <CILType>(),
this.BuildModuleInitializerType,
this.LoadNativeMSCorLibModule,
null,
this
);
}
private TypeModuleIterator(string currentPath, CILAssembly assembly)
{
_currentPath = currentPath;
_assembly = assembly;
}
internal TypeModuleIterator(CILAssembly assembly)
{
_assembly = assembly;
}
/// <summary>
/// Helper method to get framework moniker info directly from <see cref="CILAssembly"/>.
/// </summary>
/// <param name="loader">The <see cref="CILAssemblyLoader"/>.</param>
/// <param name="assembly">The <see cref="CILAssembly"/>.</param>
/// <returns>The <see cref="FrameworkMonikerInfo"/> for given <paramref name="assembly"/>.</returns>
/// <remarks>
/// <see cref="CILAssemblyLoader.GetFrameworkInfoFor"/> for exception information.
/// </remarks>
public static FrameworkMonikerInfo GetFrameworkInfoFor(this CILAssemblyLoader loader, CILAssembly assembly)
{
ArgumentValidator.ValidateNotNull("Assembly", assembly);
return(loader.GetFrameworkInfoFor(assembly.MainModule));
}
/// <summary>
/// Tries to resolve given assembly name as if given module would reference it.
/// </summary>
/// <param name="thisModule">The <see cref="CILModule"/> loaded by this <see cref="CILAssemblyLoader"/>.</param>
/// <param name="name">The <see cref="CILAssemblyName"/> of reference.</param>
/// <param name="resolvedAssembly">This will hold the resolved assembly, if successful.</param>
/// <returns><c>true</c> if successfully resolved reference; <c>false</c> otherwise.</returns>
public Boolean TryResolveReference(CILModule thisModule, CILAssemblyName name, out CILAssembly resolvedAssembly)
{
String modPath = null;
String libAssemblyPath = null;
var retVal = thisModule != null &&
this._moduleResources.TryGetValue(thisModule, out modPath);
if (retVal)
{
if (!this._callbacks.TryResolveAssemblyFilePath(modPath, name, out libAssemblyPath))
{
// Have to deduce ourselves - most likely client assembly referencing system assembly
var fwInfo = this.GetMonikerInfoFor(modPath, this._loadingArgs[thisModule]);
if (!this._callbacks.TryGetFrameworkAssemblyPath(modPath, name, fwInfo.FrameworkName, fwInfo.FrameworkVersion, fwInfo.ProfileName, out libAssemblyPath))
{
// TODO event
libAssemblyPath = null;
}
}
}
retVal = libAssemblyPath != null;
resolvedAssembly = retVal ? this.LoadModuleFrom(libAssemblyPath).Assembly : null;
return(retVal);
}
/// <summary>
/// Helper method to try get <see cref="TypeForwardingInfo"/> based on type name and type namespace from <see cref="CILAssembly"/>.
/// </summary>
/// <param name="assembly">The <see cref="CILAssembly"/>.</param>
/// <param name="typeName">The type name.</param>
/// <param name="typeNamespace">The type namespace.</param>
/// <param name="tfInfo">The resulting <see cref="TypeForwardingInfo"/>.</param>
/// <returns><c>true</c> if <paramref name="assembly"/> contained a <see cref="TypeForwardingInfo"/> with given <paramref name="typeName"/> and <paramref name="typeNamespace"/> in its <see cref="CILAssembly.ForwardedTypeInfos"/> property; <c>false</c> otherwise.</returns>
/// <exception cref="NullReferenceException">If <paramref name="assembly"/> is <c>null</c>.</exception>
public static Boolean TryGetTypeForwarder(this CILAssembly assembly, String typeName, String typeNamespace, out TypeForwardingInfo tfInfo)
{
return(assembly.ForwardedTypeInfos.TryGetValue(Tuple.Create(typeName, typeNamespace), out tfInfo));
}
/// <summary>
/// Gets all defined types in <paramref name="assembly"/>, including nested types.
/// </summary>
/// <param name="assembly">The <see cref="CILAssembly"/> to get types from.</param>
/// <returns>Enumerable for all defined types in <paramref name="assembly"/>.</returns>
public static IEnumerable <CILType> GetAllDefinedTypes(this CILAssembly assembly)
{
return(assembly.Modules.SelectMany(m => m.DefinedTypes).SelectMany(t => t.AsBreadthFirstEnumerable(tt => tt.DeclaredNestedTypes)));
}
