Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / XmlUtils / System / Xml / Xsl / IlGen / XmlILModule.cs / 1305376 / XmlILModule.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
//-----------------------------------------------------------------------------
using System.Collections;
using System.Diagnostics;
using System.Diagnostics.SymbolStore;
using System.Reflection;
using System.Reflection.Emit;
using System.Security;
using System.Security.Permissions;
using System.Xml.Xsl.Runtime;
using System.Runtime.Versioning;
namespace System.Xml.Xsl.IlGen {
using DebuggingModes = DebuggableAttribute.DebuggingModes;
internal enum XmlILMethodAttributes {
None = 0,
NonUser = 1, // Non-user method which should debugger should step through
Raw = 2, // Raw method which should not add an implicit first argument of type XmlQueryRuntime
}
internal class XmlILModule {
public static readonly PermissionSet CreateModulePermissionSet; // Permission set that contains permissions required for generating module
private static long AssemblyId; // Unique identifier used to ensure that assembly names are unique within AppDomain
private static ModuleBuilder LREModule; // Module used to emit dynamic lightweight-reflection-emit (LRE) methods
private TypeBuilder typeBldr;
private Hashtable methods, urlToSymWriter;
private string modFile;
private bool persistAsm, useLRE, emitSymbols;
private static readonly Guid LanguageGuid = new Guid(0x462d4a3e, 0xb257, 0x4aee, 0x97, 0xcd, 0x59, 0x18, 0xc7, 0x53, 0x17, 0x58);
private static readonly Guid VendorGuid = new Guid(0x994b45c4, 0xe6e9, 0x11d2, 0x90, 0x3f, 0x00, 0xc0, 0x4f, 0xa3, 0x02, 0xa1);
private const string RuntimeName = "{" + XmlReservedNs.NsXslDebug + "}" + "runtime";
static XmlILModule() {
AssemblyName asmName;
AssemblyBuilder asmBldr;
CreateModulePermissionSet = new PermissionSet(PermissionState.None);
// CreateDelegate demands MemberAccess permission
CreateModulePermissionSet.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.MemberAccess));
// DynamicMethod constructor demands ControlEvidence permissions.
// Emitting symbols in DefineDynamicModule (to allow to debug the stylesheet) requires UnmanagedCode permission.
CreateModulePermissionSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.ControlEvidence | SecurityPermissionFlag.UnmanagedCode));
AssemblyId = 0;
// 1. LRE assembly only needs to execute
// 2. No temp files need be created
// 3. Never allow assembly to Assert permissions
asmName = CreateAssemblyName();
asmBldr = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Run);
try {
CreateModulePermissionSet.Assert();
// Add custom attribute to assembly marking it as security transparent so that Assert will not be allowed
// and link demands will be converted to full demands.
asmBldr.SetCustomAttribute(new CustomAttributeBuilder(XmlILConstructors.Transparent, new object[] {}));
// Store LREModule once. If multiple threads are doing this, then some threads might get different
// modules. This is OK, since it's not mandatory to share, just preferable.
LREModule = asmBldr.DefineDynamicModule("System.Xml.Xsl.CompiledQuery", false);
}
finally {
CodeAccessPermission.RevertAssert();
}
}
public XmlILModule(TypeBuilder typeBldr) {
this.typeBldr = typeBldr;
this.emitSymbols = ((ModuleBuilder) this.typeBldr.Module).GetSymWriter() != null;
this.useLRE = false;
this.persistAsm = false;
// Index all methods added to this module by unique name
this.methods = new Hashtable();
if (this.emitSymbols) {
// Create mapping from source document to symbol writer
this.urlToSymWriter = new Hashtable();
}
}
public bool EmitSymbols {
get {
return this.emitSymbols;
}
}
// SxS note: AssemblyBuilder.DefineDynamicModule() below may be using name which is not SxS safe.
// This file is written only for internal tracing/debugging purposes. In retail builds persistAsm
// will be always false and the file should never be written. As a result it's fine just to supress
// the the SxS warning.
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
[ResourceExposure(ResourceScope.None)]
public XmlILModule(bool useLRE, bool emitSymbols) {
AssemblyName asmName;
AssemblyBuilder asmBldr;
ModuleBuilder modBldr;
Debug.Assert(!(useLRE && emitSymbols));
this.useLRE = useLRE;
this.emitSymbols = emitSymbols;
this.persistAsm = false;
// Index all methods added to this module by unique name
this.methods = new Hashtable();
if (!useLRE) {
// 1. If assembly needs to support debugging, then it must be saved and re-loaded (rule of CLR)
// 2. Get path of temp directory, where assembly will be saved
// 3. Never allow assembly to Assert permissions
asmName = CreateAssemblyName();
#if DEBUG
if (XmlILTrace.IsEnabled) {
this.modFile = "System.Xml.Xsl.CompiledQuery";
this.persistAsm = true;
}
#endif
asmBldr = AppDomain.CurrentDomain.DefineDynamicAssembly(
asmName,
this.persistAsm ? AssemblyBuilderAccess.RunAndSave : AssemblyBuilderAccess.Run);
// Add custom attribute to assembly marking it as security transparent so that Assert will not be allowed
// and link demands will be converted to full demands.
asmBldr.SetCustomAttribute(new CustomAttributeBuilder(XmlILConstructors.Transparent, new object[] { }));
if (emitSymbols) {
// Create mapping from source document to symbol writer
this.urlToSymWriter = new Hashtable();
// Add DebuggableAttribute to assembly so that debugging is a better experience
DebuggingModes debuggingModes = DebuggingModes.Default | DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggingModes.DisableOptimizations;
asmBldr.SetCustomAttribute(new CustomAttributeBuilder(XmlILConstructors.Debuggable, new object[] {debuggingModes}));
}
// Create ModuleBuilder
if (this.persistAsm)
modBldr = asmBldr.DefineDynamicModule("System.Xml.Xsl.CompiledQuery", this.modFile + ".dll", emitSymbols);
else
modBldr = asmBldr.DefineDynamicModule("System.Xml.Xsl.CompiledQuery", emitSymbols);
this.typeBldr = modBldr.DefineType("System.Xml.Xsl.CompiledQuery.Query", TypeAttributes.Public);
}
}
///
/// Define a method in this module with the specified name and parameters.
///
public MethodInfo DefineMethod(string name, Type returnType, Type[] paramTypes, string[] paramNames, XmlILMethodAttributes xmlAttrs) {
MethodInfo methResult;
int uniqueId = 1;
string nameOrig = name;
Type[] paramTypesNew;
bool isRaw = (xmlAttrs & XmlILMethodAttributes.Raw) != 0;
// Ensure that name is unique
while (this.methods[name] != null) {
// Add unique id to end of name in order to make it unique within this module
uniqueId++;
name = nameOrig + " (" + uniqueId + ")";
}
if (!isRaw) {
// XmlQueryRuntime is always 0th parameter
paramTypesNew = new Type[paramTypes.Length + 1];
paramTypesNew[0] = typeof(XmlQueryRuntime);
Array.Copy(paramTypes, 0, paramTypesNew, 1, paramTypes.Length);
paramTypes = paramTypesNew;
}
if (!this.useLRE) {
MethodBuilder methBldr;
methBldr = this.typeBldr.DefineMethod(
name,
MethodAttributes.Private | MethodAttributes.Static,
returnType,
paramTypes);
if (emitSymbols && (xmlAttrs & XmlILMethodAttributes.NonUser) != 0) {
// Add DebuggerStepThroughAttribute and DebuggerNonUserCodeAttribute to non-user methods so that debugging is a better experience
methBldr.SetCustomAttribute(new CustomAttributeBuilder(XmlILConstructors.StepThrough, new object[] {}));
methBldr.SetCustomAttribute(new CustomAttributeBuilder(XmlILConstructors.NonUserCode, new object[] {}));
}
if (!isRaw)
methBldr.DefineParameter(1, ParameterAttributes.None, RuntimeName);
for (int i = 0; i < paramNames.Length; i++) {
if (paramNames[i] != null && paramNames[i].Length != 0)
methBldr.DefineParameter(i + (isRaw ? 1 : 2), ParameterAttributes.None, paramNames[i]);
}
methResult = methBldr;
}
else {
DynamicMethod methDyn = new DynamicMethod(name, returnType, paramTypes, LREModule);
methDyn.InitLocals = true;
if (!isRaw)
methDyn.DefineParameter(1, ParameterAttributes.None, RuntimeName);
for (int i = 0; i < paramNames.Length; i++) {
if (paramNames[i] != null && paramNames[i].Length != 0)
methDyn.DefineParameter(i + (isRaw ? 1 : 2), ParameterAttributes.None, paramNames[i]);
}
methResult = methDyn;
}
// Index method by name
this.methods[name] = methResult;
return methResult;
}
///
/// Get an XmlILGenerator that can be used to generate the body of the specified method.
///
public static ILGenerator DefineMethodBody(MethodBase methInfo) {
DynamicMethod methDyn = methInfo as DynamicMethod;
if (methDyn != null)
return methDyn.GetILGenerator();
MethodBuilder methBldr = methInfo as MethodBuilder;
if (methBldr != null)
return methBldr.GetILGenerator();
return ((ConstructorBuilder) methInfo).GetILGenerator();
}
///
/// Find a MethodInfo of the specified name and return it. Return null if no such method exists.
///
public MethodInfo FindMethod(string name) {
return (MethodInfo) this.methods[name];
}
///
/// Define ginitialized data field with the specified name and value.
///
public FieldInfo DefineInitializedData(string name, byte[] data) {
Debug.Assert(!this.useLRE, "Cannot create initialized data for an LRE module");
return this.typeBldr.DefineInitializedData(name, data, FieldAttributes.Private | FieldAttributes.Static);
}
///
/// Define private static field with the specified name and value.
///
public FieldInfo DefineField(string fieldName, Type type) {
Debug.Assert(!this.useLRE, "Cannot create field for an LRE module");
return this.typeBldr.DefineField(fieldName, type, FieldAttributes.Private | FieldAttributes.Static);
}
///
/// Define static constructor for this type.
///
public ConstructorInfo DefineTypeInitializer() {
Debug.Assert(!this.useLRE, "Cannot create type initializer for an LRE module");
return this.typeBldr.DefineTypeInitializer();
}
///
/// Add the file name of a document containing source code for this module and return a symbol writer.
///
public ISymbolDocumentWriter AddSourceDocument(string fileName) {
ISymbolDocumentWriter symDoc;
Debug.Assert(this.emitSymbols, "Cannot add source information to a module that doesn't allow symbols.");
symDoc = this.urlToSymWriter[fileName] as ISymbolDocumentWriter;
if (symDoc == null) {
symDoc = ((ModuleBuilder) this.typeBldr.Module).DefineDocument(fileName, LanguageGuid, VendorGuid, Guid.Empty);
this.urlToSymWriter.Add(fileName, symDoc);
}
return symDoc;
}
///
/// Once all methods have been defined, CreateModule must be called in order to "bake" the methods within
/// this module.
///
// SxS note: AssemblyBuilder.Save() below is using name which is not SxS safe. This file is written only for
// internal tracing/debugging purposes. In retail builds persistAsm will be always false and the file should
// never be written. As a result it's fine just to supress the the SxS warning.
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
[ResourceExposure(ResourceScope.None)]
public void BakeMethods() {
Type typBaked;
Hashtable methodsBaked;
if (!this.useLRE) {
typBaked = this.typeBldr.CreateType();
if (this.persistAsm) {
// Persist the assembly to disk
((AssemblyBuilder) this.typeBldr.Module.Assembly).Save(this.modFile + ".dll");
}
// Replace all MethodInfos in this.methods
methodsBaked = new Hashtable(this.methods.Count);
foreach (string methName in this.methods.Keys) {
methodsBaked[methName] = typBaked.GetMethod(methName, BindingFlags.NonPublic | BindingFlags.Static);
}
this.methods = methodsBaked;
// Release TypeBuilder and symbol writer resources
this.typeBldr = null;
this.urlToSymWriter = null;
}
}
///
/// Wrap a delegate around a MethodInfo of the specified name and type and return it.
///
public Delegate CreateDelegate(string name, Type typDelegate) {
if (!this.useLRE)
return Delegate.CreateDelegate(typDelegate, (MethodInfo) this.methods[name]);
return ((DynamicMethod) this.methods[name]).CreateDelegate(typDelegate);
}
///
/// Define unique assembly name (within AppDomain).
///
private static AssemblyName CreateAssemblyName() {
AssemblyName name;
System.Threading.Interlocked.Increment(ref AssemblyId);
name = new AssemblyName();
name.Name = "System.Xml.Xsl.CompiledQuery." + AssemblyId;
return name;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
//-----------------------------------------------------------------------------
using System.Collections;
using System.Diagnostics;
using System.Diagnostics.SymbolStore;
using System.Reflection;
using System.Reflection.Emit;
using System.Security;
using System.Security.Permissions;
using System.Xml.Xsl.Runtime;
using System.Runtime.Versioning;
namespace System.Xml.Xsl.IlGen {
using DebuggingModes = DebuggableAttribute.DebuggingModes;
internal enum XmlILMethodAttributes {
None = 0,
NonUser = 1, // Non-user method which should debugger should step through
Raw = 2, // Raw method which should not add an implicit first argument of type XmlQueryRuntime
}
internal class XmlILModule {
public static readonly PermissionSet CreateModulePermissionSet; // Permission set that contains permissions required for generating module
private static long AssemblyId; // Unique identifier used to ensure that assembly names are unique within AppDomain
private static ModuleBuilder LREModule; // Module used to emit dynamic lightweight-reflection-emit (LRE) methods
private TypeBuilder typeBldr;
private Hashtable methods, urlToSymWriter;
private string modFile;
private bool persistAsm, useLRE, emitSymbols;
private static readonly Guid LanguageGuid = new Guid(0x462d4a3e, 0xb257, 0x4aee, 0x97, 0xcd, 0x59, 0x18, 0xc7, 0x53, 0x17, 0x58);
private static readonly Guid VendorGuid = new Guid(0x994b45c4, 0xe6e9, 0x11d2, 0x90, 0x3f, 0x00, 0xc0, 0x4f, 0xa3, 0x02, 0xa1);
private const string RuntimeName = "{" + XmlReservedNs.NsXslDebug + "}" + "runtime";
static XmlILModule() {
AssemblyName asmName;
AssemblyBuilder asmBldr;
CreateModulePermissionSet = new PermissionSet(PermissionState.None);
// CreateDelegate demands MemberAccess permission
CreateModulePermissionSet.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.MemberAccess));
// DynamicMethod constructor demands ControlEvidence permissions.
// Emitting symbols in DefineDynamicModule (to allow to debug the stylesheet) requires UnmanagedCode permission.
CreateModulePermissionSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.ControlEvidence | SecurityPermissionFlag.UnmanagedCode));
AssemblyId = 0;
// 1. LRE assembly only needs to execute
// 2. No temp files need be created
// 3. Never allow assembly to Assert permissions
asmName = CreateAssemblyName();
asmBldr = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Run);
try {
CreateModulePermissionSet.Assert();
// Add custom attribute to assembly marking it as security transparent so that Assert will not be allowed
// and link demands will be converted to full demands.
asmBldr.SetCustomAttribute(new CustomAttributeBuilder(XmlILConstructors.Transparent, new object[] {}));
// Store LREModule once. If multiple threads are doing this, then some threads might get different
// modules. This is OK, since it's not mandatory to share, just preferable.
LREModule = asmBldr.DefineDynamicModule("System.Xml.Xsl.CompiledQuery", false);
}
finally {
CodeAccessPermission.RevertAssert();
}
}
public XmlILModule(TypeBuilder typeBldr) {
this.typeBldr = typeBldr;
this.emitSymbols = ((ModuleBuilder) this.typeBldr.Module).GetSymWriter() != null;
this.useLRE = false;
this.persistAsm = false;
// Index all methods added to this module by unique name
this.methods = new Hashtable();
if (this.emitSymbols) {
// Create mapping from source document to symbol writer
this.urlToSymWriter = new Hashtable();
}
}
public bool EmitSymbols {
get {
return this.emitSymbols;
}
}
// SxS note: AssemblyBuilder.DefineDynamicModule() below may be using name which is not SxS safe.
// This file is written only for internal tracing/debugging purposes. In retail builds persistAsm
// will be always false and the file should never be written. As a result it's fine just to supress
// the the SxS warning.
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
[ResourceExposure(ResourceScope.None)]
public XmlILModule(bool useLRE, bool emitSymbols) {
AssemblyName asmName;
AssemblyBuilder asmBldr;
ModuleBuilder modBldr;
Debug.Assert(!(useLRE && emitSymbols));
this.useLRE = useLRE;
this.emitSymbols = emitSymbols;
this.persistAsm = false;
// Index all methods added to this module by unique name
this.methods = new Hashtable();
if (!useLRE) {
// 1. If assembly needs to support debugging, then it must be saved and re-loaded (rule of CLR)
// 2. Get path of temp directory, where assembly will be saved
// 3. Never allow assembly to Assert permissions
asmName = CreateAssemblyName();
#if DEBUG
if (XmlILTrace.IsEnabled) {
this.modFile = "System.Xml.Xsl.CompiledQuery";
this.persistAsm = true;
}
#endif
asmBldr = AppDomain.CurrentDomain.DefineDynamicAssembly(
asmName,
this.persistAsm ? AssemblyBuilderAccess.RunAndSave : AssemblyBuilderAccess.Run);
// Add custom attribute to assembly marking it as security transparent so that Assert will not be allowed
// and link demands will be converted to full demands.
asmBldr.SetCustomAttribute(new CustomAttributeBuilder(XmlILConstructors.Transparent, new object[] { }));
if (emitSymbols) {
// Create mapping from source document to symbol writer
this.urlToSymWriter = new Hashtable();
// Add DebuggableAttribute to assembly so that debugging is a better experience
DebuggingModes debuggingModes = DebuggingModes.Default | DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggingModes.DisableOptimizations;
asmBldr.SetCustomAttribute(new CustomAttributeBuilder(XmlILConstructors.Debuggable, new object[] {debuggingModes}));
}
// Create ModuleBuilder
if (this.persistAsm)
modBldr = asmBldr.DefineDynamicModule("System.Xml.Xsl.CompiledQuery", this.modFile + ".dll", emitSymbols);
else
modBldr = asmBldr.DefineDynamicModule("System.Xml.Xsl.CompiledQuery", emitSymbols);
this.typeBldr = modBldr.DefineType("System.Xml.Xsl.CompiledQuery.Query", TypeAttributes.Public);
}
}
///
/// Define a method in this module with the specified name and parameters.
///
public MethodInfo DefineMethod(string name, Type returnType, Type[] paramTypes, string[] paramNames, XmlILMethodAttributes xmlAttrs) {
MethodInfo methResult;
int uniqueId = 1;
string nameOrig = name;
Type[] paramTypesNew;
bool isRaw = (xmlAttrs & XmlILMethodAttributes.Raw) != 0;
// Ensure that name is unique
while (this.methods[name] != null) {
// Add unique id to end of name in order to make it unique within this module
uniqueId++;
name = nameOrig + " (" + uniqueId + ")";
}
if (!isRaw) {
// XmlQueryRuntime is always 0th parameter
paramTypesNew = new Type[paramTypes.Length + 1];
paramTypesNew[0] = typeof(XmlQueryRuntime);
Array.Copy(paramTypes, 0, paramTypesNew, 1, paramTypes.Length);
paramTypes = paramTypesNew;
}
if (!this.useLRE) {
MethodBuilder methBldr;
methBldr = this.typeBldr.DefineMethod(
name,
MethodAttributes.Private | MethodAttributes.Static,
returnType,
paramTypes);
if (emitSymbols && (xmlAttrs & XmlILMethodAttributes.NonUser) != 0) {
// Add DebuggerStepThroughAttribute and DebuggerNonUserCodeAttribute to non-user methods so that debugging is a better experience
methBldr.SetCustomAttribute(new CustomAttributeBuilder(XmlILConstructors.StepThrough, new object[] {}));
methBldr.SetCustomAttribute(new CustomAttributeBuilder(XmlILConstructors.NonUserCode, new object[] {}));
}
if (!isRaw)
methBldr.DefineParameter(1, ParameterAttributes.None, RuntimeName);
for (int i = 0; i < paramNames.Length; i++) {
if (paramNames[i] != null && paramNames[i].Length != 0)
methBldr.DefineParameter(i + (isRaw ? 1 : 2), ParameterAttributes.None, paramNames[i]);
}
methResult = methBldr;
}
else {
DynamicMethod methDyn = new DynamicMethod(name, returnType, paramTypes, LREModule);
methDyn.InitLocals = true;
if (!isRaw)
methDyn.DefineParameter(1, ParameterAttributes.None, RuntimeName);
for (int i = 0; i < paramNames.Length; i++) {
if (paramNames[i] != null && paramNames[i].Length != 0)
methDyn.DefineParameter(i + (isRaw ? 1 : 2), ParameterAttributes.None, paramNames[i]);
}
methResult = methDyn;
}
// Index method by name
this.methods[name] = methResult;
return methResult;
}
///
/// Get an XmlILGenerator that can be used to generate the body of the specified method.
///
public static ILGenerator DefineMethodBody(MethodBase methInfo) {
DynamicMethod methDyn = methInfo as DynamicMethod;
if (methDyn != null)
return methDyn.GetILGenerator();
MethodBuilder methBldr = methInfo as MethodBuilder;
if (methBldr != null)
return methBldr.GetILGenerator();
return ((ConstructorBuilder) methInfo).GetILGenerator();
}
///
/// Find a MethodInfo of the specified name and return it. Return null if no such method exists.
///
public MethodInfo FindMethod(string name) {
return (MethodInfo) this.methods[name];
}
///
/// Define ginitialized data field with the specified name and value.
///
public FieldInfo DefineInitializedData(string name, byte[] data) {
Debug.Assert(!this.useLRE, "Cannot create initialized data for an LRE module");
return this.typeBldr.DefineInitializedData(name, data, FieldAttributes.Private | FieldAttributes.Static);
}
///
/// Define private static field with the specified name and value.
///
public FieldInfo DefineField(string fieldName, Type type) {
Debug.Assert(!this.useLRE, "Cannot create field for an LRE module");
return this.typeBldr.DefineField(fieldName, type, FieldAttributes.Private | FieldAttributes.Static);
}
///
/// Define static constructor for this type.
///
public ConstructorInfo DefineTypeInitializer() {
Debug.Assert(!this.useLRE, "Cannot create type initializer for an LRE module");
return this.typeBldr.DefineTypeInitializer();
}
///
/// Add the file name of a document containing source code for this module and return a symbol writer.
///
public ISymbolDocumentWriter AddSourceDocument(string fileName) {
ISymbolDocumentWriter symDoc;
Debug.Assert(this.emitSymbols, "Cannot add source information to a module that doesn't allow symbols.");
symDoc = this.urlToSymWriter[fileName] as ISymbolDocumentWriter;
if (symDoc == null) {
symDoc = ((ModuleBuilder) this.typeBldr.Module).DefineDocument(fileName, LanguageGuid, VendorGuid, Guid.Empty);
this.urlToSymWriter.Add(fileName, symDoc);
}
return symDoc;
}
///
/// Once all methods have been defined, CreateModule must be called in order to "bake" the methods within
/// this module.
///
// SxS note: AssemblyBuilder.Save() below is using name which is not SxS safe. This file is written only for
// internal tracing/debugging purposes. In retail builds persistAsm will be always false and the file should
// never be written. As a result it's fine just to supress the the SxS warning.
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
[ResourceExposure(ResourceScope.None)]
public void BakeMethods() {
Type typBaked;
Hashtable methodsBaked;
if (!this.useLRE) {
typBaked = this.typeBldr.CreateType();
if (this.persistAsm) {
// Persist the assembly to disk
((AssemblyBuilder) this.typeBldr.Module.Assembly).Save(this.modFile + ".dll");
}
// Replace all MethodInfos in this.methods
methodsBaked = new Hashtable(this.methods.Count);
foreach (string methName in this.methods.Keys) {
methodsBaked[methName] = typBaked.GetMethod(methName, BindingFlags.NonPublic | BindingFlags.Static);
}
this.methods = methodsBaked;
// Release TypeBuilder and symbol writer resources
this.typeBldr = null;
this.urlToSymWriter = null;
}
}
///
/// Wrap a delegate around a MethodInfo of the specified name and type and return it.
///
public Delegate CreateDelegate(string name, Type typDelegate) {
if (!this.useLRE)
return Delegate.CreateDelegate(typDelegate, (MethodInfo) this.methods[name]);
return ((DynamicMethod) this.methods[name]).CreateDelegate(typDelegate);
}
///
/// Define unique assembly name (within AppDomain).
///
private static AssemblyName CreateAssemblyName() {
AssemblyName name;
System.Threading.Interlocked.Increment(ref AssemblyId);
name = new AssemblyName();
name.Name = "System.Xml.Xsl.CompiledQuery." + AssemblyId;
return name;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- MimeFormImporter.cs
- FontStyleConverter.cs
- XmlEncoding.cs
- WebRequestModuleElement.cs
- ToolTipAutomationPeer.cs
- SqlFormatter.cs
- Binding.cs
- DataRelationPropertyDescriptor.cs
- ValueTable.cs
- BooleanProjectedSlot.cs
- DecimalConverter.cs
- Compensate.cs
- DiscoveryClient.cs
- InputBuffer.cs
- RootProfilePropertySettingsCollection.cs
- LogWriteRestartAreaAsyncResult.cs
- DataMisalignedException.cs
- _emptywebproxy.cs
- InputScopeManager.cs
- AVElementHelper.cs
- Char.cs
- PeerCredential.cs
- SqlStatistics.cs
- OleDbFactory.cs
- CollectionTraceRecord.cs
- GeneralTransform3D.cs
- CultureMapper.cs
- TextUtf8RawTextWriter.cs
- KeyTime.cs
- FontSourceCollection.cs
- FullTextState.cs
- SecurityKeyEntropyMode.cs
- TypedDatasetGenerator.cs
- GridViewColumnHeader.cs
- EasingQuaternionKeyFrame.cs
- ClientConvert.cs
- RtfNavigator.cs
- ConfigLoader.cs
- OuterGlowBitmapEffect.cs
- NativeMethodsCLR.cs
- TextMarkerSource.cs
- ThreadAbortException.cs
- DataGridViewRowPrePaintEventArgs.cs
- CrossContextChannel.cs
- BooleanConverter.cs
- DetailsViewDeletedEventArgs.cs
- ChannelPool.cs
- SharedPersonalizationStateInfo.cs
- SchemaElementDecl.cs
- CodeSubDirectoriesCollection.cs
- PageCatalogPartDesigner.cs
- Atom10FormatterFactory.cs
- TraversalRequest.cs
- XmlSchemaIdentityConstraint.cs
- ConstraintManager.cs
- StaticContext.cs
- PipeStream.cs
- RayMeshGeometry3DHitTestResult.cs
- CodeMemberMethod.cs
- ScriptingAuthenticationServiceSection.cs
- IntSecurity.cs
- EmulateRecognizeCompletedEventArgs.cs
- PerspectiveCamera.cs
- WindowsRichEdit.cs
- DeclarativeCatalogPart.cs
- DataChangedEventManager.cs
- OdbcDataAdapter.cs
- ProgressBar.cs
- BaseComponentEditor.cs
- Delegate.cs
- TextChange.cs
- SubtreeProcessor.cs
- SqlNodeAnnotations.cs
- DictionaryEntry.cs
- AttachmentService.cs
- HtmlInputCheckBox.cs
- DataGridTextBox.cs
- EventMappingSettings.cs
- LocalValueEnumerator.cs
- AttributeCollection.cs
- IndicShape.cs
- DataProtectionSecurityStateEncoder.cs
- BaseCollection.cs
- PassportAuthenticationModule.cs
- SeekStoryboard.cs
- DataFormats.cs
- EntityConnectionStringBuilder.cs
- XamlGridLengthSerializer.cs
- __ConsoleStream.cs
- PartitionedStreamMerger.cs
- XmlDataSource.cs
- DeferredBinaryDeserializerExtension.cs
- DetailsViewPageEventArgs.cs
- ChannelTerminatedException.cs
- HMAC.cs
- BrowserDefinitionCollection.cs
- SymmetricAlgorithm.cs
- ZipIOModeEnforcingStream.cs
- WindowsBrush.cs
- ConfigXmlReader.cs