private Type CreateCallableInterfaceFromDelegate(Type delegateType, ModuleScope moduleScope)
{
Type type;
long count = 1;
AssemblyName aName = new AssemblyName("DynamicAssemblyExample");
AssemblyBuilder ab =
AppDomain.CurrentDomain.DefineDynamicAssembly(
aName,
AssemblyBuilderAccess.Run);
// Create the module.
ModuleBuilder mb = ab.DefineDynamicModule(aName.Name);
TypeBuilder typeBuilder = mb.DefineType(
String.Format("ProxyDelegate_{0}_{1}", delegateType.Name, count),
TypeAttributes.Interface | TypeAttributes.Abstract | TypeAttributes.Public);
MethodInfo invoke = delegateType.GetMethod("Invoke");
ParameterInfo[] parameters = invoke.GetParameters();
Type returnType = invoke.ReturnType;
Type[] parameterTypes = new Type[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
parameterTypes[i] = parameters[i].ParameterType;
}
typeBuilder.DefineMethod("Invoke", MethodAttributes.Abstract | MethodAttributes.Virtual | MethodAttributes.Public, CallingConventions.HasThis, returnType, parameterTypes);
type = typeBuilder.CreateType();
return type;
}
public RepositoryForDelegates()
{
scope = new ModuleScope();
dictionary = new Dictionary<Type, Type>();
counter = 0;
}
/// <summary>
/// Initializes a new instance of the DynamicAdapterBuilder class.
/// </summary>
/// <param name="originalObject">The type of object to build an adapter for</param>
public DynamicAdapterBuilder(Type originalObject, ModuleScope scope)
{
OriginalObject = originalObject;
ModuleScope = scope;
stagePipeline.Add(new SetupEmitterStage());
stagePipeline.Add(new CopyReturnTypeStage());
stagePipeline.Add(new DictionaryParameterToXPathNavigableStage());
stagePipeline.Add(new AddIDicitionaryConversionLogicStage());
stagePipeline.Add(new InitMethodInvocationParamsStage());
stagePipeline.Add(new CorrectIDictionaryMethodInvocationParamsStage());
stagePipeline.Add(new InvokeMethodStage());
stagePipeline.Add(new ReturnStage());
}
public Type GetAdapter(Type typeToBeAdapted)
{
try
{
lock (_cacheLock)
{
Type adapterType;
if (!TypeAdapterCache.TryGetValue(typeToBeAdapted, out adapterType))
{
DynamicAdapterBuilder builder = new DynamicAdapterBuilder(typeToBeAdapted, _Module);
adapterType = builder.Build();
TypeAdapterCache.Add(typeToBeAdapted, adapterType);
}
return adapterType;
}
}
catch
{
//On exception, reset module scope
_Module = new ModuleScope(false);
throw;
}
}
/// <summary>
/// Initializes a new instance of the <see cref = "DefaultProxyBuilder" /> class.
/// </summary>
/// <param name = "scope">The module scope for generated proxy types.</param>
public DefaultProxyBuilder(ModuleScope scope)
{
this.scope = scope;
}
public WCFProxyBuilder(ModuleScope scope)
{
this.logger = NullLogger.Instance;
this.scope = scope;
}
protected DefaultProxyBuilder(ModuleScope scope)
{
this.scope = scope;
}
/// <summary>
/// Initializes a new instance of the <see cref = "DefaultProxyBuilder" /> class.
/// </summary>
/// <param name = "scope">The module scope for generated proxy types.</param>
public DefaultProxyBuilder(ModuleScope scope)
{
this.scope = scope;
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceHostInterfaceProxyGenerator"/> class.
/// </summary>
/// <param name="scope">The scope of the module being built.</param>
/// <param name="interface">The interface that will be proxied.</param>
public ServiceHostInterfaceProxyGenerator(ModuleScope scope, Type @interface)
: base(scope, @interface)
{
_metadataBuddyType = @interface.GetMetadataClassType();
}
/// <summary>
/// Resets the <see cref="ModuleScope"/> used for deserialization to a given <paramref name="scope"/>.
/// </summary>
/// <param name="scope">The scope to be used for deserialization.</param>
/// <remarks>By default, the deserialization process uses a different scope than the rest of the application, which can lead to multiple proxies
/// being generated for the same type. By explicitly setting the deserialization scope to the application's scope, this can be avoided.</remarks>
public static void SetScope (ModuleScope scope)
{
if (scope == null)
throw new ArgumentNullException ("scope");
_scope = scope;
}
public InternalProxyService()
{
_moduleScope = new ModuleScope();
_genericGenerator = new ProxyGenerator(new DefaultProxyBuilder(_moduleScope));
}
public WCFInterfaceProxyWithoutTargetGenerator(ModuleScope scope, Type @interface)
: base(scope, @interface)
{
}
/// <summary>
/// Saves the generated assembly to a physical file. Note that this renders the <see cref = "PersistentProxyBuilder" /> unusable.
/// </summary>
/// <returns>The path of the generated assembly file, or null if no assembly has been generated.</returns>
/// <remarks>
/// This method does not support saving multiple files. If both a signed and an unsigned module have been generated, use the
/// respective methods of the <see cref = "ModuleScope" />.
/// </remarks>
public string SaveAssembly()
{
return(ModuleScope.SaveAssembly());
}
/// <summary>
/// Initializes a new instance of the DynamicAdapterStore class.
/// </summary>
public DynamicAdapterCachingBuilder()
{
_Module = new ModuleScope(false);
}
public DocumentProxyGenerator(ModuleScope scope, Type targetType)
: base(scope, targetType)
{
}
