public System.Reflection.Emit.AssemblyBuilder ConvertTypeLibToAssembly (object! typeLib, string! asmFileName, TypeLibImporterFlags flags, ITypeLibImporterNotifySink! notifySink, Byte[]! publicKey, System.Reflection.StrongNameKeyPair! keyPair, string asmNamespace, Version asmVersion) {
CodeContract.Requires(typeLib != null);
CodeContract.Requires(asmFileName != null);
CodeContract.Requires(notifySink != null);
CodeContract.Requires(asmFileName.Length <= 260);
return default(System.Reflection.Emit.AssemblyBuilder);
}
// Convert a type library into an emitted assembly.
public AssemblyBuilder ConvertTypeLibToAssembly
(Object typeLib, String asmFileName,
int flags, ITypeLibImporterNotifySink notifySink,
byte[] publicKey, StrongNameKeyPair keyPair,
bool unsafeInterfaces)
{
throw new NotImplementedException();
}
// Convert a type library into an emitted assembly.
public AssemblyBuilder ConvertTypeLibToAssembly
(Object typeLib, String asmFileName,
int flags, ITypeLibImporterNotifySink notifySink,
byte[] publicKey, StrongNameKeyPair keyPair,
bool unsafeInterfaces)
{
throw new NotImplementedException();
}
public AssemblyBuilder ConvertTypeLibToAssembly
(Object typeLib, String asmFileName,
TypeLibImporterFlags flags,
ITypeLibImporterNotifySink notifySink,
byte[] publicKey, StrongNameKeyPair keyPair,
String asmNamespace, Version asmVersion)
{
throw new NotImplementedException();
}
public AssemblyBuilder ConvertTypeLibToAssembly
(Object typeLib, String asmFileName,
TypeLibImporterFlags flags,
ITypeLibImporterNotifySink notifySink,
byte[] publicKey, StrongNameKeyPair keyPair,
String asmNamespace, Version asmVersion)
{
throw new NotImplementedException();
}
public AssemblyBuilder ConvertTypeLibToAssembly([MarshalAs(UnmanagedType.Interface)] object typeLib, string asmFileName, TypeLibImporterFlags flags, ITypeLibImporterNotifySink notifySink, byte[] publicKey, StrongNameKeyPair keyPair, string asmNamespace, Version asmVersion)
{
if (typeLib == null)
{
throw new ArgumentNullException("typeLib");
}
if (asmFileName == null)
{
throw new ArgumentNullException("asmFileName");
}
if (notifySink == null)
{
throw new ArgumentNullException("notifySink");
}
if (string.Empty.Equals(asmFileName))
{
throw new ArgumentException(Environment.GetResourceString("Arg_InvalidFileName"), "asmFileName");
}
if (asmFileName.Length > 260)
{
throw new ArgumentException(Environment.GetResourceString("IO.PathTooLong"), asmFileName);
}
if ((((flags & TypeLibImporterFlags.PrimaryInteropAssembly) != TypeLibImporterFlags.None) && (publicKey == null)) && (keyPair == null))
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_PIAMustBeStrongNamed"));
}
ArrayList eventItfInfoList = null;
AssemblyNameFlags none = AssemblyNameFlags.None;
AssemblyName asmName = GetAssemblyNameFromTypelib(typeLib, asmFileName, publicKey, keyPair, asmVersion, none);
AssemblyBuilder asmBldr = CreateAssemblyForTypeLib(typeLib, asmFileName, asmName, (flags & TypeLibImporterFlags.PrimaryInteropAssembly) != TypeLibImporterFlags.None, (flags & TypeLibImporterFlags.ReflectionOnlyLoading) != TypeLibImporterFlags.None, (flags & TypeLibImporterFlags.NoDefineVersionResource) != TypeLibImporterFlags.None);
string fileName = Path.GetFileName(asmFileName);
ModuleBuilder mod = asmBldr.DefineDynamicModule(fileName, fileName);
if (asmNamespace == null)
{
asmNamespace = asmName.Name;
}
TypeResolveHandler handler = new TypeResolveHandler(mod, notifySink);
AppDomain domain = Thread.GetDomain();
ResolveEventHandler handler2 = new ResolveEventHandler(handler.ResolveEvent);
ResolveEventHandler handler3 = new ResolveEventHandler(handler.ResolveAsmEvent);
ResolveEventHandler handler4 = new ResolveEventHandler(handler.ResolveROAsmEvent);
domain.TypeResolve += handler2;
domain.AssemblyResolve += handler3;
domain.ReflectionOnlyAssemblyResolve += handler4;
nConvertTypeLibToMetadata(typeLib, asmBldr.InternalAssembly, mod.InternalModule, asmNamespace, flags, handler, out eventItfInfoList);
UpdateComTypesInAssembly(asmBldr, mod);
if (eventItfInfoList.Count > 0)
{
new TCEAdapterGenerator().Process(mod, eventItfInfoList);
}
domain.TypeResolve -= handler2;
domain.AssemblyResolve -= handler3;
domain.ReflectionOnlyAssemblyResolve -= handler4;
return asmBldr;
}
public AssemblyBuilder ConvertTypeLibToAssembly([MarshalAs(UnmanagedType.Interface)] Object typeLib,
String asmFileName,
int flags,
ITypeLibImporterNotifySink notifySink,
byte[] publicKey,
StrongNameKeyPair keyPair,
bool unsafeInterfaces)
{
return ConvertTypeLibToAssembly(typeLib,
asmFileName,
(unsafeInterfaces
? TypeLibImporterFlags.UnsafeInterfaces
: 0),
notifySink,
publicKey,
keyPair,
null,
null);
}
public AssemblyBuilder ConvertTypeLibToAssembly([MarshalAs(UnmanagedType.Interface)] Object typeLib,
String asmFileName,
int flags,
ITypeLibImporterNotifySink notifySink,
byte[] publicKey,
StrongNameKeyPair keyPair,
bool unsafeInterfaces)
{
return(ConvertTypeLibToAssembly(typeLib,
asmFileName,
(unsafeInterfaces
? TypeLibImporterFlags.UnsafeInterfaces
: 0),
notifySink,
publicKey,
keyPair,
null,
null));
}
public System.Reflection.Emit.AssemblyBuilder ConvertTypeLibToAssembly(object typeLib, string asmFileName, int flags, ITypeLibImporterNotifySink notifySink, Byte[] publicKey, System.Reflection.StrongNameKeyPair keyPair, bool unsafeInterfaces)
{
}
public TypeResolveHandler(ModuleBuilder mod, ITypeLibImporterNotifySink userSink)
{
m_Module = mod;
m_UserSink = userSink;
}
private static extern void nConvertTypeLibToMetadata(Object typeLib, RuntimeAssembly asmBldr, RuntimeModule modBldr, String nameSpace, TypeLibImporterFlags flags, ITypeLibImporterNotifySink notifySink, out ArrayList eventItfInfoList);
public TypeResolveHandler(Module mod, ITypeLibImporterNotifySink userSink)
{
m_Module = mod;
m_UserSink = userSink;
}
public AssemblyBuilder DoProcess(
Object typeLib,
string asmFilename,
TypeLibImporterFlags flags,
ITypeLibImporterNotifySink notifySink,
byte[] publicKey,
StrongNameKeyPair keyPair,
string asmNamespace,
Version asmVersion,
bool isVersion2,
bool isPreserveSig,
string ruleSetFileName)
{
m_resolver = notifySink;
TypeLib tlb = new TypeLib((TypeLibTypes.Interop.ITypeLib)typeLib);
if (asmNamespace == null)
{
asmNamespace = tlb.GetDocumentation();
string fileName = System.IO.Path.GetFileNameWithoutExtension(asmFilename);
if (fileName != asmNamespace)
asmNamespace = fileName;
//
// Support for GUID_ManagedName (for namespace)
//
string customManagedNamespace = tlb.GetCustData(CustomAttributeGuids.GUID_ManagedName) as string;
if (customManagedNamespace != null)
{
customManagedNamespace = customManagedNamespace.Trim();
if (customManagedNamespace.ToUpper().EndsWith(".DLL"))
customManagedNamespace = customManagedNamespace.Substring(0, customManagedNamespace.Length - 4);
else if (customManagedNamespace.ToUpper().EndsWith(".EXE"))
customManagedNamespace = customManagedNamespace.Substring(0, customManagedNamespace.Length - 4);
asmNamespace = customManagedNamespace;
}
}
//
// Check for GUID_ExportedFromComPlus
//
object value = tlb.GetCustData(CustomAttributeGuids.GUID_ExportedFromComPlus);
if (value != null)
{
// Make this a critical failure, instead of returning null which will be ignored.
throw new TlbImpGeneralException(Resource.FormatString("Err_CircularImport", asmNamespace), ErrorCode.Err_CircularImport);
}
string strModuleName = asmFilename;
if (asmFilename.Contains("\\"))
{
int nIndex;
for (nIndex = strModuleName.Length; strModuleName[nIndex - 1] != '\\'; --nIndex) ;
strModuleName = strModuleName.Substring(nIndex);
}
// If the version information was not specified, then retrieve it from the typelib.
if (asmVersion == null)
{
using (TypeLibAttr attr = tlb.GetLibAttr())
{
asmVersion = new Version(attr.wMajorVerNum, attr.wMinorVerNum, 0, 0);
}
}
// Assembly name should not have .DLL
// while module name must contain the .DLL
string strAsmName = String.Copy(strModuleName);
if (strAsmName.EndsWith(".DLL", StringComparison.InvariantCultureIgnoreCase))
strAsmName = strAsmName.Substring(0, strAsmName.Length - 4);
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = strAsmName;
assemblyName.SetPublicKey(publicKey);
assemblyName.Version = asmVersion;
assemblyName.KeyPair = keyPair;
m_assemblyBuilder = CreateAssemblyBuilder(assemblyName, tlb, flags);
m_moduleBuilder = CreateModuleBuilder(m_assemblyBuilder, strModuleName);
// Add a listener for the reflection load only resolve events.
AppDomain currentDomain = Thread.GetDomain();
ResolveEventHandler asmResolveHandler = ReflectionOnlyResolveAsmEvent;
currentDomain.ReflectionOnlyAssemblyResolve += asmResolveHandler;
ConverterSettings settings;
settings.m_isGenerateClassInterfaces = true;
settings.m_namespace = asmNamespace;
settings.m_flags = flags;
settings.m_isVersion2 = isVersion2;
settings.m_isPreserveSig = isPreserveSig;
RuleEngine.InitRuleEngine(new TlbImpActionManager(),
new TlbImpCategoryManager(),
new TlbImpConditionManager(),
new TlbImpOperatorManager());
if (ruleSetFileName != null)
{
try
{
RuleFileParser parser = new RuleFileParser(ruleSetFileName);
settings.m_ruleSet = parser.Parse();
}
catch (Exception ex)
{
Output.WriteWarning(Resource.FormatString("Wrn_LoadRuleFileFailed",
ruleSetFileName, ex.Message),
WarningCode.Wrn_LoadRuleFileFailed);
settings.m_ruleSet = null;
}
}
else
{
settings.m_ruleSet = null;
}
m_converterInfo = new ConverterInfo(m_moduleBuilder, tlb, m_resolver, settings);
//
// Generate class interfaces
// NOTE:
// We have to create class interface ahead of time because of the need to convert default interfaces to
// class interfafces. However, this creates another problem that the event interface is always named first
// before the other interfaces, because we need to create the type builder for the event interface first
// so that we can create a class interface that implement it. But in the previous version of TlbImp,
// it doesn't have to do that because it can directly create a typeref with the class interface name,
// without actually creating anything like the TypeBuilder. The result is that the name would be different
// with interop assemblies generated by old tlbimp in this case.
// Given the nature of reflection API, this cannot be easily workarounded unless we switch to metadata APIs.
// I believe this is acceptable because this only happens when:
// 1. People decide to migrate newer .NET framework
// 2. The event interface name conflicts with a normal interface
//
// In this case the problem can be easily fixed with a global refactoring, so I wouldn't worry about that
//
if (m_converterInfo.GenerateClassInterfaces)
{
CreateClassInterfaces();
}
//
// Generate the remaining types except coclass
// Because during creating coclass, we require every type, including all the referenced type to be created
// This is a restriction of reflection API that when you override a method in parent interface, the method info
// is needed so the type must be already created and loaded
//
var coclassList = new List<TypeInfo>();
int nCount = tlb.GetTypeInfoCount();
for (int n = 0; n < nCount; ++n)
{
try
{
TypeInfo type = tlb.GetTypeInfo(n);
string strType = type.GetDocumentation();
using (TypeAttr attr = type.GetTypeAttr())
{
TypeLibTypes.Interop.TYPEKIND kind = attr.typekind;
TypeInfo typeToProcess;
TypeAttr attrToProcess;
if (kind == TypeLibTypes.Interop.TYPEKIND.TKIND_ALIAS)
{
ConvCommon.ResolveAlias(type, attr.tdescAlias, out typeToProcess, out attrToProcess);
if (attrToProcess.typekind == TypeLibTypes.Interop.TYPEKIND.TKIND_ALIAS)
{
continue;
}
else
{
// We need to duplicate the definition of the user defined type in the name of the alias
kind = attrToProcess.typekind;
typeToProcess = type;
attrToProcess = attr;
}
}
else
{
typeToProcess = type;
attrToProcess = attr;
}
switch (kind)
{
// Process coclass later because of reflection API requirements
case TypeLibTypes.Interop.TYPEKIND.TKIND_COCLASS:
coclassList.Add(typeToProcess);
break;
case TypeLibTypes.Interop.TYPEKIND.TKIND_ENUM:
m_converterInfo.GetEnum(typeToProcess, attrToProcess);
break;
case TypeLibTypes.Interop.TYPEKIND.TKIND_DISPATCH:
case TypeLibTypes.Interop.TYPEKIND.TKIND_INTERFACE:
m_converterInfo.GetInterface(typeToProcess, attrToProcess);
break;
case TypeLibTypes.Interop.TYPEKIND.TKIND_MODULE:
m_converterInfo.GetModule(typeToProcess, attrToProcess);
break;
case TypeLibTypes.Interop.TYPEKIND.TKIND_RECORD:
m_converterInfo.GetStruct(typeToProcess, attrToProcess);
break;
case TypeLibTypes.Interop.TYPEKIND.TKIND_UNION:
m_converterInfo.GetUnion(typeToProcess, attrToProcess);
break;
}
m_converterInfo.ReportEvent(
MessageCode.Msg_TypeInfoImported,
Resource.FormatString("Msg_TypeInfoImported", typeToProcess.GetDocumentation()));
}
}
catch (ReflectionTypeLoadException)
{
throw; // Fatal failure. Throw
}
catch (TlbImpResolveRefFailWrapperException)
{
throw; // Fatal failure. Throw
}
catch (TlbImpGeneralException)
{
throw; // Fatal failure. Throw
}
catch (TypeLoadException)
{
throw; // TypeLoadException is critical. Throw.
}
catch (Exception)
{
}
}
// Process coclass after processing all the other types
foreach (TypeInfo type in coclassList)
{
using (TypeAttr attr = type.GetTypeAttr())
{
try
{
m_converterInfo.GetCoClass(type, attr);
}
catch (ReflectionTypeLoadException)
{
throw; // Fatal failure. Throw
}
catch (TlbImpResolveRefFailWrapperException)
{
throw; // Fatal failure. Throw
}
catch (TlbImpGeneralException)
{
throw; // Fatal failure. Throw
}
catch (TypeLoadException)
{
throw; // TypeLoadException is critical. Throw.
}
catch (Exception)
{
}
}
}
//
// Build an array of EventItfInfo & generate event provider / event sink helpers
//
var eventAdapterGenerator = new Event.TCEAdapterGenerator();
var eventItfList = new List<Event.EventItfInfo>();
foreach (IConvBase symbol in m_converterInfo.GetAllConvBase)
{
var convInterface = symbol as IConvInterface;
if (convInterface != null)
{
if (convInterface.EventInterface != null)
{
Debug.Assert(convInterface.EventInterface is ConvEventInterfaceLocal);
var local = convInterface.EventInterface as ConvEventInterfaceLocal;
Type eventInterfaceType = convInterface.EventInterface.ManagedType;
// Build EventItfInfo and add to the list
Type sourceInterfaceType = convInterface.ManagedType;
string sourceInterfaceName = sourceInterfaceType.FullName;
Event.EventItfInfo eventItfInfo = new Event.EventItfInfo(
eventInterfaceType.FullName,
sourceInterfaceName,
local.EventProviderName,
eventInterfaceType,
convInterface.ManagedType);
eventItfList.Add(eventItfInfo);
}
}
}
eventAdapterGenerator.Process(m_moduleBuilder, eventItfList);
return m_assemblyBuilder;
}
public AssemblyBuilder ConvertTypeLibToAssembly([MarshalAs(UnmanagedType.Interface)] Object typeLib,
String asmFileName,
TypeLibImporterFlags flags,
ITypeLibImporterNotifySink notifySink,
byte[] publicKey,
StrongNameKeyPair keyPair,
String asmNamespace,
Version asmVersion)
{
// Validate the arguments.
if (typeLib == null)
{
throw new ArgumentNullException("typeLib");
}
if (asmFileName == null)
{
throw new ArgumentNullException("asmFileName");
}
if (notifySink == null)
{
throw new ArgumentNullException("notifySink");
}
if (String.Empty.Equals(asmFileName))
{
throw new ArgumentException(Environment.GetResourceString("Arg_InvalidFileName"), "asmFileName");
}
if (asmFileName.Length > Path.MAX_PATH)
{
throw new ArgumentException(Environment.GetResourceString("IO.PathTooLong"), asmFileName);
}
if ((flags & TypeLibImporterFlags.PrimaryInteropAssembly) != 0 && publicKey == null && keyPair == null)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_PIAMustBeStrongNamed"));
}
Contract.EndContractBlock();
ArrayList eventItfInfoList = null;
// Determine the AssemblyNameFlags
AssemblyNameFlags asmNameFlags = AssemblyNameFlags.None;
// Retrieve the assembly name from the typelib.
AssemblyName asmName = GetAssemblyNameFromTypelib(typeLib, asmFileName, publicKey, keyPair, asmVersion, asmNameFlags);
// Create the dynamic assembly that will contain the converted typelib types.
AssemblyBuilder asmBldr = CreateAssemblyForTypeLib(typeLib, asmFileName, asmName,
(flags & TypeLibImporterFlags.PrimaryInteropAssembly) != 0,
(flags & TypeLibImporterFlags.ReflectionOnlyLoading) != 0,
(flags & TypeLibImporterFlags.NoDefineVersionResource) != 0);
// Define a dynamic module that will contain the contain the imported types.
String strNonQualifiedAsmFileName = Path.GetFileName(asmFileName);
ModuleBuilder modBldr = asmBldr.DefineDynamicModule(strNonQualifiedAsmFileName, strNonQualifiedAsmFileName);
// If the namespace hasn't been specified, then use the assembly name.
if (asmNamespace == null)
{
asmNamespace = asmName.Name;
}
// Create a type resolve handler that will also intercept resolve ref messages
// on the sink interface to build up a list of referenced assemblies.
TypeResolveHandler typeResolveHandler = new TypeResolveHandler(modBldr, notifySink);
// Add a listener for the type resolve events.
AppDomain currentDomain = Thread.GetDomain();
ResolveEventHandler resolveHandler = new ResolveEventHandler(typeResolveHandler.ResolveEvent);
ResolveEventHandler asmResolveHandler = new ResolveEventHandler(typeResolveHandler.ResolveAsmEvent);
ResolveEventHandler ROAsmResolveHandler = new ResolveEventHandler(typeResolveHandler.ResolveROAsmEvent);
currentDomain.TypeResolve += resolveHandler;
currentDomain.AssemblyResolve += asmResolveHandler;
currentDomain.ReflectionOnlyAssemblyResolve += ROAsmResolveHandler;
// Convert the types contained in the typelib into metadata and add them to the assembly.
nConvertTypeLibToMetadata(typeLib, asmBldr.InternalAssembly, modBldr.InternalModule, asmNamespace, flags, typeResolveHandler, out eventItfInfoList);
// Update the COM types in the assembly.
UpdateComTypesInAssembly(asmBldr, modBldr);
// If there are any event sources then generate the TCE adapters.
if (eventItfInfoList.Count > 0)
{
new TCEAdapterGenerator().Process(modBldr, eventItfInfoList);
}
// Remove the listener for the type resolve events.
currentDomain.TypeResolve -= resolveHandler;
currentDomain.AssemblyResolve -= asmResolveHandler;
currentDomain.ReflectionOnlyAssemblyResolve -= ROAsmResolveHandler;
// We have finished converting the typelib and now have a fully formed assembly.
return(asmBldr);
}
public AssemblyBuilder ConvertTypeLibToAssembly([MarshalAs(UnmanagedType.Interface)] object typeLib, string asmFileName, int flags, ITypeLibImporterNotifySink notifySink, byte[] publicKey, StrongNameKeyPair keyPair, bool unsafeInterfaces)
{
return(this.ConvertTypeLibToAssembly(typeLib, asmFileName, unsafeInterfaces ? TypeLibImporterFlags.UnsafeInterfaces : TypeLibImporterFlags.None, notifySink, publicKey, keyPair, (string)null, (Version)null));
}
// Token: 0x06006FEE RID: 28654 RVA: 0x0018074A File Offset: 0x0017E94A
public TypeResolveHandler(ModuleBuilder mod, ITypeLibImporterNotifySink userSink)
{
this.m_Module = mod;
this.m_UserSink = userSink;
}
private static extern void nConvertTypeLibToMetadata(Object typeLib, AssemblyBuilder asmBldr, ModuleBuilder modBldr, String nameSpace, TypeLibImporterFlags flags, ITypeLibImporterNotifySink notifySink, out ArrayList eventItfInfoList);
public AssemblyBuilder ConvertTypeLibToAssembly([MarshalAs(UnmanagedType.Interface)] Object typeLib,
String asmFileName,
TypeLibImporterFlags flags,
ITypeLibImporterNotifySink notifySink,
byte[] publicKey,
StrongNameKeyPair keyPair,
String asmNamespace,
Version asmVersion)
{
// Validate the arguments.
if (typeLib == null)
throw new ArgumentNullException("typeLib");
if (asmFileName == null)
throw new ArgumentNullException("asmFileName");
if (notifySink == null)
throw new ArgumentNullException("notifySink");
if (String.Empty.Equals(asmFileName))
throw new ArgumentException(Environment.GetResourceString("Arg_InvalidFileName"), "asmFileName");
if (asmFileName.Length > Path.MaxPath)
throw new ArgumentException(Environment.GetResourceString("IO.PathTooLong"), asmFileName);
if ((flags & TypeLibImporterFlags.PrimaryInteropAssembly) != 0 && publicKey == null && keyPair == null)
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_PIAMustBeStrongNamed"));
Contract.EndContractBlock();
ArrayList eventItfInfoList = null;
// Determine the AssemblyNameFlags
AssemblyNameFlags asmNameFlags = AssemblyNameFlags.None;
// Retrieve the assembly name from the typelib.
AssemblyName asmName = GetAssemblyNameFromTypelib(typeLib, asmFileName, publicKey, keyPair, asmVersion, asmNameFlags);
// Create the dynamic assembly that will contain the converted typelib types.
AssemblyBuilder asmBldr = CreateAssemblyForTypeLib(typeLib, asmFileName, asmName,
(flags & TypeLibImporterFlags.PrimaryInteropAssembly) != 0,
(flags & TypeLibImporterFlags.ReflectionOnlyLoading) != 0,
(flags & TypeLibImporterFlags.NoDefineVersionResource) != 0);
// Define a dynamic module that will contain the contain the imported types.
String strNonQualifiedAsmFileName = Path.GetFileName(asmFileName);
ModuleBuilder modBldr = asmBldr.DefineDynamicModule(strNonQualifiedAsmFileName, strNonQualifiedAsmFileName);
// If the namespace hasn't been specified, then use the assembly name.
if (asmNamespace == null)
asmNamespace = asmName.Name;
// Create a type resolve handler that will also intercept resolve ref messages
// on the sink interface to build up a list of referenced assemblies.
TypeResolveHandler typeResolveHandler = new TypeResolveHandler(modBldr, notifySink);
// Add a listener for the type resolve events.
AppDomain currentDomain = Thread.GetDomain();
ResolveEventHandler resolveHandler = new ResolveEventHandler(typeResolveHandler.ResolveEvent);
ResolveEventHandler asmResolveHandler = new ResolveEventHandler(typeResolveHandler.ResolveAsmEvent);
ResolveEventHandler ROAsmResolveHandler = new ResolveEventHandler(typeResolveHandler.ResolveROAsmEvent);
currentDomain.TypeResolve += resolveHandler;
currentDomain.AssemblyResolve += asmResolveHandler;
currentDomain.ReflectionOnlyAssemblyResolve += ROAsmResolveHandler;
// Convert the types contained in the typelib into metadata and add them to the assembly.
nConvertTypeLibToMetadata(typeLib, asmBldr.InternalAssembly, modBldr.InternalModule, asmNamespace, flags, typeResolveHandler, out eventItfInfoList);
// Update the COM types in the assembly.
UpdateComTypesInAssembly(asmBldr, modBldr);
// If there are any event sources then generate the TCE adapters.
if (eventItfInfoList.Count > 0)
new TCEAdapterGenerator().Process(modBldr, eventItfInfoList);
// Remove the listener for the type resolve events.
currentDomain.TypeResolve -= resolveHandler;
currentDomain.AssemblyResolve -= asmResolveHandler;
currentDomain.ReflectionOnlyAssemblyResolve -= ROAsmResolveHandler;
// We have finished converting the typelib and now have a fully formed assembly.
return asmBldr;
}
public System.Reflection.Emit.AssemblyBuilder ConvertTypeLibToAssembly(Object typeLib, string asmFileName, TypeLibImporterFlags flags, ITypeLibImporterNotifySink notifySink, byte[] publicKey, System.Reflection.StrongNameKeyPair keyPair, string asmNamespace, Version asmVersion)
{
return default(System.Reflection.Emit.AssemblyBuilder);
}
public System.Reflection.Emit.AssemblyBuilder ConvertTypeLibToAssembly(object typeLib, string asmFileName, int flags, ITypeLibImporterNotifySink notifySink, Byte[] publicKey, System.Reflection.StrongNameKeyPair keyPair, bool unsafeInterfaces)
{
}
public System.Reflection.Emit.AssemblyBuilder ConvertTypeLibToAssembly(object typeLib, string asmFileName, TypeLibImporterFlags flags, ITypeLibImporterNotifySink notifySink, Byte[] publicKey, System.Reflection.StrongNameKeyPair keyPair, string asmNamespace, Version asmVersion)
{
Contract.Requires(typeLib != null);
Contract.Requires(asmFileName != null);
Contract.Requires(notifySink != null);
Contract.Requires(asmFileName.Length <= 260);
Contract.Requires((int)((int)flags & 1) == 0 || publicKey != null || keyPair != null);
return(default(System.Reflection.Emit.AssemblyBuilder));
}
public System.Reflection.Emit.AssemblyBuilder ConvertTypeLibToAssembly(Object typeLib, string asmFileName, TypeLibImporterFlags flags, ITypeLibImporterNotifySink notifySink, byte[] publicKey, System.Reflection.StrongNameKeyPair keyPair, string asmNamespace, Version asmVersion)
{
return(default(System.Reflection.Emit.AssemblyBuilder));
}
private static extern void nConvertTypeLibToMetadata(object typeLib, RuntimeAssembly asmBldr, RuntimeModule modBldr, string nameSpace, TypeLibImporterFlags flags, ITypeLibImporterNotifySink notifySink, out ArrayList eventItfInfoList);
public AssemblyBuilder DoProcess(
Object typeLib,
string asmFilename,
TypeLibImporterFlags flags,
ITypeLibImporterNotifySink notifySink,
byte[] publicKey,
StrongNameKeyPair keyPair,
string asmNamespace,
Version asmVersion,
bool isVersion2,
bool isPreserveSig,
bool isRemoveEnumPrefix)
{
m_resolver = notifySink;
TypeLib tlb = new TypeLib((ITypeLib)typeLib);
if (asmNamespace == null)
{
asmNamespace = tlb.GetDocumentation();
string fileName = System.IO.Path.GetFileNameWithoutExtension(asmFilename);
if (fileName != asmNamespace)
{
asmNamespace = fileName;
}
//
// Support for GUID_ManagedName (for namespace)
//
string customManagedNamespace = tlb.GetCustData(CustomAttributeGuids.GUID_ManagedName) as string;
if (customManagedNamespace != null)
{
customManagedNamespace = customManagedNamespace.Trim();
if (customManagedNamespace.ToUpper().EndsWith(".DLL"))
{
customManagedNamespace = customManagedNamespace.Substring(0, customManagedNamespace.Length - 4);
}
else if (customManagedNamespace.ToUpper().EndsWith(".EXE"))
{
customManagedNamespace = customManagedNamespace.Substring(0, customManagedNamespace.Length - 4);
}
asmNamespace = customManagedNamespace;
}
}
//
// Check for GUID_ExportedFromComPlus
//
object value = tlb.GetCustData(CustomAttributeGuids.GUID_ExportedFromComPlus);
if (value != null)
{
// Make this a critical failure, instead of returning null which will be ignored.
throw new TlbImpGeneralException(Resource.FormatString("Err_CircularImport", asmNamespace), ErrorCode.Err_CircularImport);
}
string strModuleName = asmFilename;
if (asmFilename.Contains("\\"))
{
int nIndex;
for (nIndex = strModuleName.Length; strModuleName[nIndex - 1] != '\\'; --nIndex)
{
;
}
strModuleName = strModuleName.Substring(nIndex);
}
// If the version information was not specified, then retrieve it from the typelib.
if (asmVersion == null)
{
using (TypeLibAttr attr = tlb.GetLibAttr())
{
asmVersion = new Version(attr.wMajorVerNum, attr.wMinorVerNum, 0, 0);
}
}
// Assembly name should not have .DLL
// while module name must contain the .DLL
string strAsmName = String.Copy(strModuleName);
if (strAsmName.EndsWith(".DLL", StringComparison.InvariantCultureIgnoreCase))
{
strAsmName = strAsmName.Substring(0, strAsmName.Length - 4);
}
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = strAsmName;
assemblyName.SetPublicKey(publicKey);
assemblyName.Version = asmVersion;
assemblyName.KeyPair = keyPair;
m_assemblyBuilder = CreateAssemblyBuilder(assemblyName, tlb, flags);
m_moduleBuilder = CreateModuleBuilder(m_assemblyBuilder, strModuleName);
// Add a listener for the reflection load only resolve events.
AppDomain currentDomain = Thread.GetDomain();
ResolveEventHandler asmResolveHandler = new ResolveEventHandler(ReflectionOnlyResolveAsmEvent);
currentDomain.ReflectionOnlyAssemblyResolve += asmResolveHandler;
ConverterSettings settings;
settings.m_isGenerateClassInterfaces = true;
settings.m_namespace = asmNamespace;
settings.m_flags = flags;
settings.m_isVersion2 = isVersion2;
settings.m_isPreserveSig = isPreserveSig;
settings.m_isRemoveEnumPrefix = isRemoveEnumPrefix;
m_converterInfo = new ConverterInfo(m_moduleBuilder, tlb, m_resolver, settings);
//
// Generate class interfaces
// NOTE:
// We have to create class interface ahead of time because of the need to convert default interfaces to
// class interfafces. However, this creates another problem that the event interface is always named first
// before the other interfaces, because we need to create the type builder for the event interface first
// so that we can create a class interface that implement it. But in the previous version of TlbImp,
// it doesn't have to do that because it can directly create a typeref with the class interface name,
// without actually creating anything like the TypeBuilder. The result is that the name would be different
// with interop assemblies generated by old tlbimp in this case.
// Given the nature of reflection API, this cannot be easily workarounded unless we switch to metadata APIs.
// I believe this is acceptable because this only happens when:
// 1. People decide to migrate newer .NET framework
// 2. The event interface name conflicts with a normal interface
//
// In this case the problem can be easily fixed with a global refactoring, so I wouldn't worry about that
//
if (m_converterInfo.GenerateClassInterfaces)
{
CreateClassInterfaces();
}
//
// Generate the remaining types except coclass
// Because during creating coclass, we require every type, including all the referenced type to be created
// This is a restriction of reflection API that when you override a method in parent interface, the method info
// is needed so the type must be already created and loaded
//
List <TypeInfo> coclassList = new List <TypeInfo>();
int nCount = tlb.GetTypeInfoCount();
for (int n = 0; n < nCount; ++n)
{
TypeInfo type = null;
try
{
type = tlb.GetTypeInfo(n);
string strType = type.GetDocumentation();
TypeInfo typeToProcess;
TypeAttr attrToProcess;
using (TypeAttr attr = type.GetTypeAttr())
{
TYPEKIND kind = attr.typekind;
if (kind == TYPEKIND.TKIND_ALIAS)
{
ConvCommon.ResolveAlias(type, attr.tdescAlias, out typeToProcess, out attrToProcess);
if (attrToProcess.typekind == TYPEKIND.TKIND_ALIAS)
{
continue;
}
else
{
// We need to duplicate the definition of the user defined type in the name of the alias
kind = attrToProcess.typekind;
typeToProcess = type;
attrToProcess = attr;
}
}
else
{
typeToProcess = type;
attrToProcess = attr;
}
switch (kind)
{
// Process coclass later because of reflection API requirements
case TYPEKIND.TKIND_COCLASS:
coclassList.Add(typeToProcess);
break;
case TYPEKIND.TKIND_ENUM:
m_converterInfo.GetEnum(typeToProcess, attrToProcess);
break;
case TYPEKIND.TKIND_DISPATCH:
case TYPEKIND.TKIND_INTERFACE:
m_converterInfo.GetInterface(typeToProcess, attrToProcess);
break;
case TYPEKIND.TKIND_MODULE:
m_converterInfo.GetModule(typeToProcess, attrToProcess);
break;
case TYPEKIND.TKIND_RECORD:
m_converterInfo.GetStruct(typeToProcess, attrToProcess);
break;
case TYPEKIND.TKIND_UNION:
m_converterInfo.GetUnion(typeToProcess, attrToProcess);
break;
}
m_converterInfo.ReportEvent(
MessageCode.Msg_TypeInfoImported,
Resource.FormatString("Msg_TypeInfoImported", typeToProcess.GetDocumentation()));
}
}
catch (ReflectionTypeLoadException)
{
throw; // Fatal failure. Throw
}
catch (TlbImpResolveRefFailWrapperException)
{
throw; // Fatal failure. Throw
}
catch (TlbImpGeneralException)
{
throw; // Fatal failure. Throw
}
catch (TypeLoadException)
{
throw; // TypeLoadException is critical. Throw.
}
catch (Exception)
{
}
}
// Process coclass after processing all the other types
foreach (TypeInfo type in coclassList)
{
using (TypeAttr attr = type.GetTypeAttr())
{
try
{
m_converterInfo.GetCoClass(type, attr);
}
catch (ReflectionTypeLoadException)
{
throw; // Fatal failure. Throw
}
catch (TlbImpResolveRefFailWrapperException)
{
throw; // Fatal failure. Throw
}
catch (TlbImpGeneralException)
{
throw; // Fatal failure. Throw
}
catch (TypeLoadException)
{
throw; // TypeLoadException is critical. Throw.
}
catch (Exception)
{
}
}
}
//
// Build an array of EventItfInfo & generate event provider / event sink helpers
//
Event.TCEAdapterGenerator eventAdapterGenerator = new Event.TCEAdapterGenerator();
List <Event.EventItfInfo> eventItfList = new List <Event.EventItfInfo>();
foreach (IConvBase symbol in m_converterInfo.GetAllConvBase)
{
IConvInterface convInterface = symbol as IConvInterface;
if (convInterface != null)
{
if (convInterface.EventInterface != null)
{
Debug.Assert(convInterface.EventInterface is ConvEventInterfaceLocal);
ConvEventInterfaceLocal local = convInterface.EventInterface as ConvEventInterfaceLocal;
Type eventInterfaceType = convInterface.EventInterface.ManagedType;
// Build EventItfInfo and add to the list
Type sourceInterfaceType = convInterface.ManagedType;
string sourceInterfaceName = sourceInterfaceType.FullName;
Event.EventItfInfo eventItfInfo = new Event.EventItfInfo(
eventInterfaceType.FullName,
sourceInterfaceName,
local.EventProviderName,
eventInterfaceType,
convInterface.ManagedType);
eventItfList.Add(eventItfInfo);
}
}
}
eventAdapterGenerator.Process(m_moduleBuilder, eventItfList);
return(m_assemblyBuilder);
}
public AssemblyBuilder ConvertTypeLibToAssembly([MarshalAs(UnmanagedType.Interface)] object typeLib, string asmFileName, TypeLibImporterFlags flags, ITypeLibImporterNotifySink notifySink, byte[] publicKey, StrongNameKeyPair keyPair, string asmNamespace, Version asmVersion)
{
if (typeLib == null)
{
throw new ArgumentNullException("typeLib");
}
if (asmFileName == null)
{
throw new ArgumentNullException("asmFileName");
}
if (notifySink == null)
{
throw new ArgumentNullException("notifySink");
}
if (string.Empty.Equals(asmFileName))
{
throw new ArgumentException(Environment.GetResourceString("Arg_InvalidFileName"), "asmFileName");
}
if (asmFileName.Length > 260)
{
throw new ArgumentException(Environment.GetResourceString("IO.PathTooLong"), asmFileName);
}
if ((flags & TypeLibImporterFlags.PrimaryInteropAssembly) != TypeLibImporterFlags.None && publicKey == null && keyPair == null)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_PIAMustBeStrongNamed"));
}
ArrayList arrayList = null;
AssemblyNameFlags asmNameFlags = AssemblyNameFlags.None;
AssemblyName assemblyNameFromTypelib = TypeLibConverter.GetAssemblyNameFromTypelib(typeLib, asmFileName, publicKey, keyPair, asmVersion, asmNameFlags);
AssemblyBuilder assemblyBuilder = TypeLibConverter.CreateAssemblyForTypeLib(typeLib, asmFileName, assemblyNameFromTypelib, (flags & TypeLibImporterFlags.PrimaryInteropAssembly) > TypeLibImporterFlags.None, (flags & TypeLibImporterFlags.ReflectionOnlyLoading) > TypeLibImporterFlags.None, (flags & TypeLibImporterFlags.NoDefineVersionResource) > TypeLibImporterFlags.None);
string fileName = Path.GetFileName(asmFileName);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(fileName, fileName);
if (asmNamespace == null)
{
asmNamespace = assemblyNameFromTypelib.Name;
}
TypeLibConverter.TypeResolveHandler typeResolveHandler = new TypeLibConverter.TypeResolveHandler(moduleBuilder, notifySink);
AppDomain domain = Thread.GetDomain();
ResolveEventHandler value = new ResolveEventHandler(typeResolveHandler.ResolveEvent);
ResolveEventHandler value2 = new ResolveEventHandler(typeResolveHandler.ResolveAsmEvent);
ResolveEventHandler value3 = new ResolveEventHandler(typeResolveHandler.ResolveROAsmEvent);
domain.TypeResolve += value;
domain.AssemblyResolve += value2;
domain.ReflectionOnlyAssemblyResolve += value3;
TypeLibConverter.nConvertTypeLibToMetadata(typeLib, assemblyBuilder.InternalAssembly, moduleBuilder.InternalModule, asmNamespace, flags, typeResolveHandler, out arrayList);
TypeLibConverter.UpdateComTypesInAssembly(assemblyBuilder, moduleBuilder);
if (arrayList.Count > 0)
{
new TCEAdapterGenerator().Process(moduleBuilder, arrayList);
}
domain.TypeResolve -= value;
domain.AssemblyResolve -= value2;
domain.ReflectionOnlyAssemblyResolve -= value3;
return(assemblyBuilder);
}
public virtual System.Reflection.Emit.AssemblyBuilder ConvertTypeLibToAssembly(object typeLib, string asmFileName, TypeLibImporterFlags flags, ITypeLibImporterNotifySink notifySink, byte[] publicKey, System.Reflection.StrongNameKeyPair keyPair, string asmNamespace, System.Version asmVersion)
{
}