public static string GetManagedWrapperForCOM(string fileName)
{
ITypeLib typeLib;
if (LoadTypeLibEx(fileName, RegKind.None, out typeLib) != 0)
{
return(null);
}
if (typeLib == null)
{
return(null);
}
string fname = null;
try
{
ConversionEventHandler eventHandler = new ConversionEventHandler();
AssemblyBuilder asm = converter.ConvertTypeLibToAssembly(typeLib, System.IO.Path.Combine(ProjectFactory.Instance.ProjectDirectory, System.IO.Path.GetFileNameWithoutExtension(fileName) + ".dll"), 0, eventHandler, null, null, null, null);
asm.Save(System.IO.Path.GetFileNameWithoutExtension(fileName) + ".dll");
fname = System.IO.Path.GetFileNameWithoutExtension(fileName);
}
finally
{
Marshal.ReleaseComObject(typeLib);
}
return(fname);
}
static int Main(string[] args)
{
if (args.Length < 2)
{
Console.WriteLine("Usage: tlb-convert <unmanaged COM DLL path> <managed wrapper path> [root namespace]");
return(2);
}
try
{
string srcDll = args[0];
string outDll = args[1];
string rootNamespace = args.Length == 3 ? args[2] : null;
Object typeLib;
LoadTypeLibEx(srcDll, RegKind.RegKind_None, out typeLib);
TypeLibConverter tlbConv = new TypeLibConverter();
AssemblyBuilder asm = tlbConv.ConvertTypeLibToAssembly(typeLib, outDll, 0, new ConversionEventHandler(), null, null, rootNamespace, null);
asm.Save(outDll);
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}\n{1}", e.Message, e.StackTrace);
return(1);
}
Console.WriteLine("\nConversion successful.");
return(0);
}
private Assembly ConvertTypeLib(NativeMethods.ITypeLib typeLib, string assemblyPath, string assemblyFile, string assemblyNamespace, Version assemblyVersion, TypeLibImporterFlags flags, byte[] publicKey, StrongNameKeyPair keyPair)
{
try
{
this.RaiseMessage(string.Format("Converting '{0}'.", GetTypeLibName(typeLib)));
TypeLibConverter converter = new TypeLibConverter();
AssemblyBuilder assemblyBuilder = converter.ConvertTypeLibToAssembly(typeLib, Path.Combine(assemblyPath, assemblyFile), flags, this, publicKey, keyPair, assemblyNamespace, assemblyVersion);
this.RaiseMessage(string.Format("Saving '{0}'.", assemblyFile));
string currentDirectory = Environment.CurrentDirectory;
Environment.CurrentDirectory = assemblyPath;
assemblyBuilder.Save(assemblyFile);
Environment.CurrentDirectory = currentDirectory;
return(assemblyBuilder);
}
catch (COMException exception)
{
this.RaiseError(exception.Message);
}
return(null);
}
public Assembly Convert(ITypeLib tl)
{
tl.GetLibAttr(out IntPtr ipta);
var ta = *(_TYPELIBATTR *)ipta;
tl.ReleaseTLibAttr(ipta);
var hash = Fnv1((byte *)&ta, sizeof(_TYPELIBATTR) - 2).ToString("x");
tl.GetDocumentation(-1, out var tlName, out var tlDescription, out var _, out var _);
var fileName = $"{tlName} {ta.wMajorVerNum}.{ta.wMinorVerNum} #{hash}.dll";
var netPath = saveDir + fileName;
if (!s_converted.TryGetValue(fileName, out var asm) || !File.Exists(netPath))
{
Print($"Converted: {tlName} ({tlDescription}) to \"{fileName}\".");
var converter = new TypeLibConverter();
asm = converter.ConvertTypeLibToAssembly(tl, netPath,
TypeLibImporterFlags.ReflectionOnlyLoading | TypeLibImporterFlags.TransformDispRetVals | TypeLibImporterFlags.UnsafeInterfaces,
this, null, null, tlName, null);
asm.Save(fileName);
s_converted[fileName] = asm;
}
return(asm);
}
Assembly ITypeLibImporterNotifySink.ResolveRef(object typeLib)
{
Assembly assembly2;
try
{
string comReference = this.importer.GetComReference((System.Runtime.InteropServices.ComTypes.ITypeLib)typeLib);
if (comReference != null)
{
this.importer.AddReferencedAssembly(comReference);
}
Assembly primaryInteropAssembly = this.importer.FindRCW((System.Runtime.InteropServices.ComTypes.ITypeLib)typeLib);
if (primaryInteropAssembly != null)
{
assembly2 = primaryInteropAssembly;
}
else
{
try
{
string assemName = Path.Combine(this.options.outputDirectory, Marshal.GetTypeLibName((System.Runtime.InteropServices.ComTypes.ITypeLib)typeLib) + ".dll");
if (this.importer.GetReferencedAssembly(assemName) != null)
{
return(this.importer.GetCopiedAssembly(assemName, false, false));
}
TypeLibConverter tlbConverter = new TypeLibConverter();
primaryInteropAssembly = this.importer.GetPrimaryInteropAssembly((System.Runtime.InteropServices.ComTypes.ITypeLib)typeLib, tlbConverter);
if (primaryInteropAssembly != null)
{
return(primaryInteropAssembly);
}
AssemblyBuilder asmBldr = tlbConverter.ConvertTypeLibToAssembly(typeLib, assemName, TypeLibImporterFlags.None, new AxImporter.ImporterCallback(this.importer), this.options.publicKey, this.options.keyPair, null, null);
if (comReference == null)
{
this.importer.SaveAssemblyBuilder((System.Runtime.InteropServices.ComTypes.ITypeLib)typeLib, asmBldr, assemName);
this.importer.AddRCW((System.Runtime.InteropServices.ComTypes.ITypeLib)typeLib, asmBldr);
return(asmBldr);
}
assembly2 = this.importer.GetCopiedAssembly(comReference, false, false);
}
catch
{
assembly2 = null;
}
}
}
finally
{
Marshal.ReleaseComObject(typeLib);
}
return(assembly2);
}
public void BuildLib(string targetFolder)
{
NativeMethods.LoadTypeLibEx(VBoxWrapper.COMInterface.VBoxComUtils.GetVirtualBoxComTypeLib(), NativeMethods.RegKind.RegKind_None, out _typeLibInMemory);
if (_typeLibInMemory == null)
{
throw new DllNotFoundException("Could not load Virtualbox-Typelibrary.");
}
TypeLibConverter converter = new TypeLibConverter();
ConversionEventHandler handler = new ConversionEventHandler();
AssemblyBuilder asm = converter.ConvertTypeLibToAssembly(_typeLibInMemory, "Interop.VirtualBox.dll", TypeLibImporterFlags.SafeArrayAsSystemArray, handler, null, null, "VirtualBox", null); //using assembly name "VirtualBox" and SafeArrayAsSystemArray to be compatible to VisualStudio-Generated Interop-Assembly
asm.Save("Interop.VirtualBox.dll");
}
/// <summary>
/// Gets an assembly used to interop with the objects defined in the type
/// library.
/// </summary>
/// <param name="typeLibraryName">
/// Name of the type library such as SHDocVw.dll
/// </param>
/// <returns>
/// Returns the assembly if found/created otherwise null.
/// </returns>
public static Assembly GetAssemblyForTypeLib(string typeLibraryName)
{
object typeLib = null;
LoadTypeLibEx(typeLibraryName, RegKind.RegKind_None, out typeLib);
if (typeLib == null)
{
return(null);
}
TypeLibConverter converter = new TypeLibConverter();
ConversionEventHandler eventHandler = new ConversionEventHandler();
AssemblyBuilder asm = converter.ConvertTypeLibToAssembly(typeLib, "Interop." + typeLibraryName, 0, eventHandler, null, null, null, null);
return(asm);
}
public static void Main()
{
Object typeLib;
LoadTypeLibEx("SHDocVw.dll", RegKind.RegKind_None, out typeLib);
if (typeLib == null)
{
Console.WriteLine("LoadTypeLibEx failed.");
return;
}
TypeLibConverter converter = new TypeLibConverter();
ConversionEventHandler eventHandler = new ConversionEventHandler();
AssemblyBuilder asm = converter.ConvertTypeLibToAssembly(typeLib, "ExplorerLib.dll", 0, eventHandler, null, null, null, null);
asm.Save("ExplorerLib.dll");
}
public static string GenerateAssemblyFromTypeLib(UCOMITypeLib typLib)
{
// Need a sink for the TypeLibConverter.
ImporterNotiferSink sink = new ImporterNotiferSink();
#region Notes on Strong Name...
/* Don't need a *.snk file if you are not building a primary interop asm.
* Just send in nulls to the ConvertTypeLibToAssembly() method.
* But if you have a valid *.snk file, you can use it as so:
*
* // Object representation of *.snk file.
* FileStream fs = File.Open(@"D:\APress Books\InteropBook\MyTypeLibImporter\bin\Debug\theKey.snk",
* FileMode.Open);
* System.Reflection.StrongNameKeyPair keyPair = new StrongNameKeyPair(fs);
*/
#endregion
// This class will covert COM type info into
// .NET metadata and vice-versa.
TypeLibConverter tlc = new TypeLibConverter();
// Generate name of the assembly.
string typeLibName = Marshal.GetTypeLibName(typLib);
string asmName = "interop." + typeLibName + ".dll";
// Now make the assembly based on COM type information.
AssemblyBuilder asmBuilder = tlc.ConvertTypeLibToAssembly((UCOMITypeLib)typLib,
asmName,
TypeLibImporterFlags.SafeArrayAsSystemArray,
sink,
null, // If you have a strong name: keyPair.PublicKey,
null, // If you have a strong name: keyPair
typeLibName, // Namespace name is same as file name.
null); // null = (typeLibMajor.typeLibMinor.0.0)
// Save the assembly in the app directory!
asmBuilder.Save(asmName);
// return Assembly ref to call.
return(asmName);
}
public Assembly Import(string InteropFileName, string path, string name, TlbImp parent)
{
ITypeLib typeLib;
AsmPath = Path.GetDirectoryName(InteropFileName);
LoadTypeLibEx(path, RegKind.RegKind_None, out typeLib);
if (typeLib == null)
{
return(null);
}
TypeLibConverter converter = new TypeLibConverter();
ConversionEventHandler eventHandler = new ConversionEventHandler(parent == null?this:parent);
AssemblyBuilder asm =
converter.ConvertTypeLibToAssembly(typeLib, Path.GetFileName(InteropFileName), TypeLibImporterFlags.None, eventHandler, null, null, name, null);
string outputFolder = Path.GetDirectoryName(InteropFileName);
string interopFName = Path.Combine(outputFolder, String.Concat("Interop.", name, ".dll"));
asm.Save(Path.GetFileName(interopFName));
Marshal.ReleaseComObject(typeLib);
return(asm as Assembly);
}
private Assembly GenerateAssemblyFromNativeTypeLibInternal(Guid iid, Guid typeLibraryID, ITypeLib typeLibrary)
{
Assembly asm = null;
try
{
lock (this)
{
TypelibraryAssembly.TryGetValue(typeLibraryID, out asm);
if (asm == null)
{
string assemblyName = "";
string notused1 = "";
string notused2 = "";
int notused3;
string namespaceName;
typeLibrary.GetDocumentation(-1, out namespaceName, out notused1, out notused3, out notused2);
if (String.IsNullOrEmpty(namespaceName))
{
throw Fx.AssertAndThrowFatal("Assembly cannot be null");
}
assemblyName = String.Concat(namespaceName, GetRandomName(), ".dll");
asm = TypelibraryConverter.ConvertTypeLibToAssembly(typeLibrary, assemblyName, TypeLibImporterFlags.SerializableValueClasses, new ConversionEventHandler(iid, typeLibraryID), null, null, namespaceName, null);
TypelibraryAssembly[typeLibraryID] = asm;
}
}
}
catch (ReflectionTypeLoadException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.FailedToConvertTypelibraryToAssembly)));
}
if (asm == null)
{
throw Fx.AssertAndThrowFatal("Assembly cannot be null");
}
return(asm);
}
public static Assembly ConvertTypeLibToAssembly(ITypeLib typeLib)
{
if (m_typelibs == null)
{
LoadTypeLibAssemblies();
}
if (m_typelibs.ContainsKey(Marshal.GetTypeLibGuid(typeLib)))
{
return(m_typelibs[Marshal.GetTypeLibGuid(typeLib)]);
}
else
{
string strAssemblyPath = GetTypeLibDirectory();
strAssemblyPath = Path.Combine(strAssemblyPath, Marshal.GetTypeLibName(typeLib) + ".dll");
TypeLibConverter conv = new TypeLibConverter();
AssemblyBuilder asm = conv.ConvertTypeLibToAssembly(typeLib, strAssemblyPath, TypeLibImporterFlags.ReflectionOnlyLoading,
new TypeLibCallback(), null, null, null, null);
asm.Save(Path.GetFileName(strAssemblyPath));
Assembly a = Assembly.LoadFile(strAssemblyPath);
m_typelibs[Marshal.GetTypeLibGuid(typeLib)] = a;
lock (m_typelibsname)
{
m_typelibsname[a.FullName] = a;
}
RegisterTypeInterfaces(a);
return(a);
}
}
internal static Assembly generateAssemblyFromTypeLib(UCOMITypeLib typeLib, bool safeArrayAsArray, string asmFilePath, out bool foundPIAInstead)
{
foundPIAInstead = false;
string typeLibName = Marshal.GetTypeLibName(typeLib);
string asmDir, asmName, asmFullPath;
if (asmFilePath == "")
{
// asmFilePath == "" means that user does not want the assembly saved in a file. A filename argument
// is required by the conversion function, although no file is actually written by it. Therefore we
// supply one in case it is truly necessary.
asmName = "interop." + typeLibName + ".dll";
asmDir = "";
}
else
{
asmDir = System.IO.Path.GetDirectoryName(asmFilePath);
if (asmDir == null)
{
// asmFilePath was a root dir, like c:\.
string asmRoot = System.IO.Path.GetPathRoot(asmFilePath);
asmDir = asmRoot == null ? "" : asmRoot;
}
else
{
asmDir = asmDir + System.IO.Path.DirectorySeparatorChar;
}
// M code ensures that if asmFilePath is a dir and not a filename it ends in \, so asmName will be ""
// if it is a dir.
asmName = System.IO.Path.GetFileName(asmFilePath);
if (asmName == "")
{
// asmFilePath was just a dir.
asmName = "interop." + typeLibName + ".dll";
}
}
asmFullPath = asmDir + asmName;
ImporterNotiferSink sink = new ImporterNotiferSink(safeArrayAsArray, asmDir);
TypeLibConverter tlc = new TypeLibConverter();
// Check for an existing PIA and use it if it exists.
IntPtr pTLibAttr;
typeLib.GetLibAttr(out pTLibAttr);
TYPELIBATTR typeLibAttr = (TYPELIBATTR)Marshal.PtrToStructure(pTLibAttr, typeof(TYPELIBATTR));
string piaName, piaCodeBase;
bool piaExists = tlc.GetPrimaryInteropAssembly(typeLibAttr.guid, typeLibAttr.wMajorVerNum, typeLibAttr.wMinorVerNum,
typeLibAttr.lcid, out piaName, out piaCodeBase);
typeLib.ReleaseTLibAttr(pTLibAttr);
if (piaExists)
{
Assembly pia = Assembly.LoadWithPartialName(piaName);
if (pia != null)
{
foundPIAInstead = true;
return(pia);
}
}
TypeLoader.isBuildingDynamicAssembly = true;
try {
AssemblyBuilder asmBuilder = tlc.ConvertTypeLibToAssembly(typeLib, asmFullPath,
safeArrayAsArray ? TypeLibImporterFlags.SafeArrayAsSystemArray : 0, sink, null, null, typeLibName, null);
Type[] tt = asmBuilder.GetTypes();
if (asmFilePath != "")
{
asmBuilder.Save(asmName);
}
return(asmBuilder);
} finally {
TypeLoader.isBuildingDynamicAssembly = false;
}
}
/*
* Method: GenerateWrapper
*
* Generates a wrapper for this reference.
*/
internal bool GenerateWrapper(out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
string rootNamespace = ReferenceInfo.typeLibName;
string wrapperPath = GetWrapperPath();
bool generateWrapperSucceeded = true;
if (ExecuteAsTool)
{
// delegate generation of the assembly to an instance of the TlbImp ToolTask. MUST
// HAVE SET SDKTOOLSPATH TO THE TARGET SDK TO WORK
var tlbImp = new ResolveComReference.TlbImp();
tlbImp.BuildEngine = BuildEngine;
tlbImp.EnvironmentVariables = EnvironmentVariables;
tlbImp.DelaySign = DelaySign;
tlbImp.KeyContainer = KeyContainer;
tlbImp.KeyFile = KeyFile;
tlbImp.OutputAssembly = wrapperPath;
tlbImp.ToolPath = ToolPath;
tlbImp.TypeLibName = ReferenceInfo.fullTypeLibPath;
tlbImp.AssemblyNamespace = rootNamespace;
tlbImp.AssemblyVersion = null;
tlbImp.PreventClassMembers = _noClassMembers;
tlbImp.SafeArrayAsSystemArray = true;
tlbImp.Silent = Silent;
tlbImp.Transform = ResolveComReference.TlbImpTransformFlags.TransformDispRetVals;
if (_referenceFiles != null)
{
// Issue is that there may be reference dependencies that need to be passed in. It is possible
// that the set of references will also contain the file that is meant to be written here (when reference resolution
// found the file in the output folder). We need to filter out this case.
var fullPathToOutput = Path.GetFullPath(wrapperPath); // Current directory is the directory of the project file.
tlbImp.ReferenceFiles = _referenceFiles.Where(rf => String.Compare(fullPathToOutput, rf, StringComparison.OrdinalIgnoreCase) != 0).ToArray();
}
switch (_targetProcessorArchitecture)
{
case UtilitiesProcessorArchitecture.MSIL:
tlbImp.Machine = "Agnostic";
break;
case UtilitiesProcessorArchitecture.AMD64:
tlbImp.Machine = "X64";
break;
case UtilitiesProcessorArchitecture.IA64:
tlbImp.Machine = "Itanium";
break;
case UtilitiesProcessorArchitecture.X86:
tlbImp.Machine = "X86";
break;
case UtilitiesProcessorArchitecture.ARM:
tlbImp.Machine = "ARM";
break;
case null:
break;
default:
// Transmit the flag directly from the .targets files and rely on tlbimp.exe to produce a good error message.
tlbImp.Machine = _targetProcessorArchitecture;
break;
}
generateWrapperSucceeded = tlbImp.Execute();
// store the wrapper info...
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = (HasTemporaryWrapper) ? null : wrapperPath;
// Changed to ReflectionOnlyLoadFrom, related to bug:
// RCR: Bad COM-interop assemblies being generated when using 64-bit MSBuild to build a project that is targeting 32-bit platform
// The original call to UnsafeLoadFrom loads the assembly in preparation for execution. If the assembly is x86 and this is x64 msbuild.exe then we
// have problems (UnsafeLoadFrom will fail). We only use this assembly for reference resolution so we don't need to be ready to execute the code.
//
// Its actually not clear to me that we even need to load the assembly at all. Reference resoluton is only used in the !ExecuteAsTool which is not
// where we are right now.
//
// If we really do need to load it then:
//
// wrapperInfo.assembly = Assembly.ReflectionOnlyLoadFrom(wrapperPath);
}
else
{
// use framework classes in-proc to generate the assembly
TypeLibConverter converter = new TypeLibConverter();
AssemblyBuilder assemblyBuilder = null;
StrongNameKeyPair keyPair;
byte[] publicKey;
GetAndValidateStrongNameKey(out keyPair, out publicKey);
try
{
TypeLibImporterFlags flags = TypeLibImporterFlags.SafeArrayAsSystemArray | TypeLibImporterFlags.TransformDispRetVals;
if (_noClassMembers)
{
flags |= TypeLibImporterFlags.PreventClassMembers;
}
switch (_targetProcessorArchitecture)
{
case UtilitiesProcessorArchitecture.MSIL:
flags |= TypeLibImporterFlags.ImportAsAgnostic;
break;
case UtilitiesProcessorArchitecture.AMD64:
flags |= TypeLibImporterFlags.ImportAsX64;
break;
case UtilitiesProcessorArchitecture.IA64:
flags |= TypeLibImporterFlags.ImportAsItanium;
break;
case UtilitiesProcessorArchitecture.X86:
flags |= TypeLibImporterFlags.ImportAsX86;
break;
case UtilitiesProcessorArchitecture.ARM:
flags |= TypeLibImporterFlags.ImportAsArm;
break;
default:
// Let the type importer decide.
break;
}
// Start the conversion process. We'll get callbacks on ITypeLibImporterNotifySink to resolve dependent refs.
assemblyBuilder = converter.ConvertTypeLibToAssembly(ReferenceInfo.typeLibPointer, wrapperPath,
flags, this, publicKey, keyPair, rootNamespace, null);
}
catch (COMException ex)
{
if (!Silent)
{
Log.LogWarningWithCodeFromResources("ResolveComReference.ErrorCreatingWrapperAssembly", ItemName, ex.Message);
}
throw new ComReferenceResolutionException(ex);
}
// if we're done, and this is not a temporary wrapper, write it out to disk
if (!HasTemporaryWrapper)
{
WriteWrapperToDisk(assemblyBuilder, wrapperPath);
}
// store the wrapper info...
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = (HasTemporaryWrapper) ? null : wrapperPath;
wrapperInfo.assembly = assemblyBuilder;
}
// ...and we're done!
return(generateWrapperSucceeded);
}
internal bool GenerateWrapper(out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
string typeLibName = this.ReferenceInfo.typeLibName;
string wrapperPath = base.GetWrapperPath();
StrongNameKeyPair keyPair = null;
byte[] publicKey = null;
StrongNameUtils.GetStrongNameKey(base.Log, base.KeyFile, base.KeyContainer, out keyPair, out publicKey);
if (base.DelaySign)
{
keyPair = null;
if (publicKey == null)
{
base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "StrongNameUtils.NoPublicKeySpecified", new object[0]);
throw new StrongNameException();
}
}
else
{
publicKey = null;
if (keyPair == null)
{
if ((base.KeyContainer != null) && (base.KeyContainer.Length > 0))
{
base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.StrongNameUtils.NoKeyPairInContainer", new object[] { base.KeyContainer });
throw new StrongNameException();
}
if ((base.KeyFile != null) && (base.KeyFile.Length > 0))
{
base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.StrongNameUtils.NoKeyPairInFile", new object[] { base.KeyFile });
throw new StrongNameException();
}
}
}
bool flag = true;
if (!base.ExecuteAsTool)
{
TypeLibConverter converter = new TypeLibConverter();
AssemblyBuilder assemblyBuilder = null;
try
{
TypeLibImporterFlags flags = TypeLibImporterFlags.TransformDispRetVals | TypeLibImporterFlags.SafeArrayAsSystemArray;
if (this.noClassMembers)
{
flags |= TypeLibImporterFlags.PreventClassMembers;
}
string str4 = this.targetProcessorArchitecture;
if (str4 != null)
{
if (!(str4 == "MSIL"))
{
if (str4 == "AMD64")
{
goto Label_0323;
}
if (str4 == "IA64")
{
goto Label_032F;
}
if (str4 == "x86")
{
goto Label_033B;
}
}
else
{
flags |= TypeLibImporterFlags.ImportAsAgnostic;
}
}
goto Label_0345;
Label_0323:
flags |= TypeLibImporterFlags.ImportAsX64;
goto Label_0345;
Label_032F:
flags |= TypeLibImporterFlags.ImportAsItanium;
goto Label_0345;
Label_033B:
flags |= TypeLibImporterFlags.ImportAsX86;
Label_0345:
assemblyBuilder = converter.ConvertTypeLibToAssembly(this.ReferenceInfo.typeLibPointer, wrapperPath, flags, this, publicKey, keyPair, typeLibName, null);
}
catch (COMException exception)
{
base.Log.LogWarningWithCodeFromResources("ResolveComReference.ErrorCreatingWrapperAssembly", new object[] { this.ItemName, exception.Message });
throw new ComReferenceResolutionException(exception);
}
if (!this.HasTemporaryWrapper)
{
this.WriteWrapperToDisk(assemblyBuilder, wrapperPath);
}
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = this.HasTemporaryWrapper ? null : wrapperPath;
wrapperInfo.assembly = assemblyBuilder;
return(flag);
}
ResolveComReference.TlbImp imp = new ResolveComReference.TlbImp {
BuildEngine = base.BuildEngine,
EnvironmentVariables = base.EnvironmentVariables,
DelaySign = base.DelaySign,
KeyContainer = base.KeyContainer,
KeyFile = base.KeyFile,
OutputAssembly = wrapperPath,
ToolPath = base.ToolPath,
TypeLibName = this.ReferenceInfo.typeLibPath,
AssemblyNamespace = typeLibName,
AssemblyVersion = null,
PreventClassMembers = this.noClassMembers,
SafeArrayAsSystemArray = true,
Transform = ResolveComReference.TlbImpTransformFlags.TransformDispRetVals
};
if (this.referenceFiles != null)
{
string fullPathToOutput = Path.GetFullPath(wrapperPath);
imp.ReferenceFiles = (from rf in this.referenceFiles
where string.Compare(fullPathToOutput, rf, StringComparison.OrdinalIgnoreCase) != 0
select rf).ToArray <string>();
}
string targetProcessorArchitecture = this.targetProcessorArchitecture;
if (targetProcessorArchitecture != null)
{
if (!(targetProcessorArchitecture == "MSIL"))
{
if (targetProcessorArchitecture == "AMD64")
{
imp.Machine = "X64";
}
else if (targetProcessorArchitecture == "IA64")
{
imp.Machine = "Itanium";
}
else if (targetProcessorArchitecture == "x86")
{
imp.Machine = "X86";
}
else
{
imp.Machine = this.targetProcessorArchitecture;
}
}
else
{
imp.Machine = "Agnostic";
}
}
flag = imp.Execute();
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = this.HasTemporaryWrapper ? null : wrapperPath;
return(flag);
}
Assembly ITypeLibImporterNotifySink.ResolveRef(Object typeLib)
{
try {
string assem = importer.GetComReference((UCOMITypeLib)typeLib);
if (assem != null)
{
importer.AddReferencedAssembly(assem);
}
Assembly a = importer.FindRCW((UCOMITypeLib)typeLib);
if (a != null)
{
return(a);
}
// Generate the RCW for the typelib. We have to go through the motions of this anyway,
// because there is no easy way to find the dependent references for this typelib.
//
try {
string tlbName = Marshal.GetTypeLibName((UCOMITypeLib)typeLib);
string rcwName = Path.Combine(options.outputDirectory, tlbName + ".dll");
Debug.WriteLineIf(AxWrapperGen.AxWrapper.Enabled, "\tConverting recursive TypeLib Name: " + tlbName + " in " + rcwName);
if (importer.GetReferencedAssembly(rcwName) != null)
{
Debug.WriteLineIf(AxWrapperGen.AxWrapper.Enabled, "\t\tFound RCW in referenced assembly list at " + rcwName);
return(importer.GetCopiedAssembly(rcwName, false, false));
}
// Create the TypeLibConverter.
TypeLibConverter tlbConv = new TypeLibConverter();
// Try to locate the primary interop assembly first.
//
a = importer.GetPrimaryInteropAssembly((UCOMITypeLib)typeLib, tlbConv);
if (a != null)
{
return(a);
}
else
{
// Convert the typelib.
AssemblyBuilder asmBldr = tlbConv.ConvertTypeLibToAssembly(typeLib,
rcwName,
(TypeLibImporterFlags)0,
new ImporterCallback(importer),
options.publicKey,
options.keyPair,
null,
null);
if (assem == null)
{
// Save the assembly to the disk only if we did not find it already on the reference list.
//
Debug.WriteLineIf(AxWrapperGen.AxWrapper.Enabled, "\t\tGenerated RCW at " + rcwName);
string rcwAssem = importer.SaveAssemblyBuilder((UCOMITypeLib)typeLib, asmBldr, rcwName);
importer.AddRCW((UCOMITypeLib)typeLib, asmBldr);
return(asmBldr);
}
else
{
Debug.WriteLineIf(AxWrapperGen.AxWrapper.Enabled, "\t\tFound COM Reference at " + assem);
return(importer.GetCopiedAssembly(assem, false, false));
}
}
}
catch (Exception) {
return(null);
}
}
finally {
Marshal.ReleaseComObject(typeLib);
}
}
/// <include file='doc\AxImporter.uex' path='docs/doc[@for="AxImporter.GenerateFromTypeLibrary1"]/*' />
/// <devdoc>
/// <para>
/// Generates a wrapper for an ActiveX control for use in the design-time
/// environment.
/// </para>
/// </devdoc>
public string GenerateFromTypeLibrary(UCOMITypeLib typeLib, Guid clsid)
{
string axWFW = null;
string axctlType = null;
Assembly rcw = null;
// Look to see if we can find the AxWrapper also for this typeLib.
//
axWFW = GetAxReference(typeLib);
if (axWFW != null && clsid != Guid.Empty)
{
axctlType = GetAxTypeFromAssembly(axWFW, clsid);
}
if (axWFW == null)
{
string tlbName = Marshal.GetTypeLibName(typeLib);
string rcwName = Path.Combine(options.outputDirectory, tlbName + ".dll");
Debug.WriteLineIf(AxWrapperGen.AxWrapper.Enabled, "Converting TypeLib Name: " + tlbName + " in " + rcwName);
AddReferencedAssembly(GetManagedReference("System.Windows.Forms"));
AddReferencedAssembly(GetManagedReference("System.Drawing"));
AddReferencedAssembly(GetManagedReference("System"));
string rcwAssem = GetComReference(typeLib);
if (rcwAssem != null)
{
AddReferencedAssembly(rcwAssem);
rcw = GetCopiedAssembly(rcwAssem, false, false);
AddDependentAssemblies(rcw);
}
else
{
TypeLibConverter tlbConverter = new TypeLibConverter();
// Try to locate the primary interop assembly first.
//
rcw = GetPrimaryInteropAssembly(typeLib, tlbConverter);
if (rcw != null)
{
rcwAssem = GetLocalPath(rcw.EscapedCodeBase);
AddDependentAssemblies(rcw);
}
else
{
AssemblyBuilder asmBldr = tlbConverter.ConvertTypeLibToAssembly(typeLib,
rcwName,
(TypeLibImporterFlags)0,
new ImporterCallback(this),
options.publicKey,
options.keyPair,
null,
null);
if (rcwAssem == null)
{
// Save the assembly to the disk only if we did not find it already on the reference list.
//
rcwAssem = SaveAssemblyBuilder(typeLib, asmBldr, rcwName);
rcw = GetCopiedAssembly(rcwAssem, false, false);
}
}
}
Debug.Assert(rcw != null, "No assembly obtained from: " + rcwAssem);
// Create a list of the referenced assemblies and create the WFW Wrapper for the AxControl.
//
int i = 0;
string[] refAssems = new string[this.refAssems.Count];
foreach (string assem in this.refAssems)
{
string name = assem;
name = name.Replace("%20", " ");
Debug.WriteLineIf(AxWrapperGen.AxWrapper.Enabled, "Adding " + name + " to the wrapper reference list...");
refAssems[i++] = name;
}
if (axctlType == null)
{
string file = GetFileOfTypeLib(typeLib);
DateTime tlbTimeStamp = (file == null) ? DateTime.Now : File.GetLastWriteTime(file);
// Hook up the type resolution events for the appdomain so we can delay load
// any assemblies/types users gave us in the /i option.
//
ResolveEventHandler assemblyResolveEventHandler = new ResolveEventHandler(OnAssemblyResolve);
AppDomain.CurrentDomain.AssemblyResolve += assemblyResolveEventHandler;
try {
if (options.genSources)
{
AxWrapperGen.GeneratedSources = new ArrayList();
}
if (options.outputName == null)
{
options.outputName = "Ax" + tlbName + ".dll";
}
axctlType = AxWrapperGen.GenerateWrappers(this, clsid, rcw, refAssems, tlbTimeStamp, out axWFW);
if (options.genSources)
{
generatedSources = AxWrapperGen.GeneratedSources;
}
}
finally {
AppDomain.CurrentDomain.AssemblyResolve -= assemblyResolveEventHandler;
}
if (axctlType == null)
{
throw new Exception(SR.GetString(SR.AXNoActiveXControls, ((typeLibName != null) ? typeLibName : tlbName)));
}
}
if (axctlType != null)
{
// Add the WFW assembly to the references list.
//
Debug.Assert(axWFW != null && axWFW.Length > 0, "Invalid output assembly name");
AddReferencedAssembly(axWFW);
AddTypeLibAttr(typeLib);
AddGeneratedAssembly(axWFW);
}
}
return(axctlType);
}
private bool InitializeTDxInputWrapper()
{
bool bReturn = false;
Object typeLib = null;
try
{
//get Com-Server from Registry
RegistryKey regKey
= Registry.LocalMachine.OpenSubKey("Software\\Classes\\CLSID\\{82C5AB54-C92C-4D52-AAC5-27E25E22604C}\\InprocServer32", false);
if (regKey != null)
{
string strTypeLibName = regKey.GetValue("").ToString();
regKey.Close();
LoadTypeLibEx(strTypeLibName
, RegKind.RegKind_None
, out typeLib);
}
else
{
// --- No registry set, there must be no 3DConnexion ---
return false;
}
}
catch (Exception)
{
}
if (typeLib == null)
{
Console.WriteLine("LoadTypeLibEx failed.");
throw new NotSupportedException("Com- Server not found.");
}
TypeLibConverter converter = new TypeLibConverter();
ConversionEventHandler eventHandler = new ConversionEventHandler();
m_Assembly = converter.ConvertTypeLibToAssembly(typeLib, "Import3DxInputAssembly.dll", 0, eventHandler, null, null, null, null);
//Type[] ExpTypes = m_Assembly.GetTypes();
try
{
m_OSimpleDevice = m_Assembly.CreateInstance("Import3DxInputAssembly.DeviceClass");
}
catch
{
//int nTest;
}
if (m_OSimpleDevice != null)
{
Type TheType = m_OSimpleDevice.GetType();
//MethodInfo[] TheMethods = TheType.GetMethods();
MethodInfo method = TheType.GetMethod("get_Sensor");
m_OSensor = method.Invoke(m_OSimpleDevice, null); // kein Parameter
method = TheType.GetMethod("get_Keyboard");
m_OKeyboard = method.Invoke(m_OSimpleDevice, null);
TheType = m_OKeyboard.GetType();
//TheMethods = TheType.GetMethods();
bReturn = true;
}
return bReturn;
}
// public static TypeLibInfo CreateDll_1(FileInfo file, DirectoryInfo outputDir, string Namespace)
// {
// var task = Task.Factory.StartNew(() => TlbConverter.CreateDllTask(file, outputDir, Namespace ));
// var result = task.Result;
// task = null;
// System.GC.Collect();
// GC.WaitForPendingFinalizers();
// return result;
// }
// public static TypeLibInfo CreateDll(FileInfo file, DirectoryInfo outputDir, string Namespace)
// {
// TypeLibInfo i = null;
// var thread = new System.Threading.Thread(() => {
// i = TlbConverter.CreateDllTask(file, outputDir, Namespace);
// });
// thread.IsBackground = true;
// thread.Start();
// thread.Join();
// thread = null;
// System.GC.Collect();
// GC.WaitForPendingFinalizers();
// return i;
// }
public static TypeLibInfo CreateDll(FileInfo file, DirectoryInfo outputDir, string Namespace)
{
Console.WriteLine($"-----------------File: {file.Name} is now processing-------------------");
if (file.Name == "InfTypeLib.tlb")
{
// Console.ReadLine();
}
var typeLibInfo = new TypeLibInfo()
{
OriginalName = file.Name,
path = outputDir.FullName
};
AssemblyBuilder asm = null;
var tlc = new TypeLibConverter();
External.LoadTypeLibEx(file.FullName, External.RegKind.RegKind_None, out ITypeLib typeLib);
if (typeLib == null)
{
Console.WriteLine("LoadTypeLibEx failed.");
return(null);
}
typeLibInfo.TlbName = Marshal.GetTypeLibName(typeLib);
typeLibInfo.AsmName = typeLibInfo.TlbName + ".dll";
Console.WriteLine(typeLibInfo.GetFileinfo());
if (typeLibInfo.Exists)
{
Console.WriteLine($"AsmName {typeLibInfo.AsmName} exists, no need to convert");
return(typeLibInfo);
}
TypeLibConverter tlbConv = new TypeLibConverter();
ConversionEventHandler eventHandler = new ConversionEventHandler(typeLibInfo);
try
{
asm = tlbConv.ConvertTypeLibToAssembly(typeLib, typeLibInfo.AsmName, TypeLibImporterFlags.SafeArrayAsSystemArray, eventHandler, null, null, Namespace + typeLibInfo.TlbName, null);
}
catch (Exception e)
{
Console.WriteLine("Failed to convert, trying again", e.Message, e.StackTrace);
Console.WriteLine($"OriginalName {typeLibInfo.OriginalName}");
Console.WriteLine($"TlbName {typeLibInfo.TlbName}");
Console.WriteLine($"AsmName {typeLibInfo.AsmName}");
return(null);
}
try
{
asm.Save(typeLibInfo.AsmName);
}
catch (Exception e)
{
Console.WriteLine("Failed to save, trying again", e.Message, e.StackTrace);
Console.WriteLine($"OriginalName {typeLibInfo.OriginalName}");
Console.WriteLine($"TlbName {typeLibInfo.TlbName}");
Console.WriteLine($"AsmName {typeLibInfo.AsmName}");
return(null);
}
return(typeLibInfo);
}
public string GenerateFromTypeLibrary(UCOMITypeLib typeLib, Guid clsid)
{
string fileName = null;
string axTypeFromAssembly = null;
Assembly assem = null;
fileName = this.GetAxReference((System.Runtime.InteropServices.ComTypes.ITypeLib)typeLib);
if ((fileName != null) && (clsid != Guid.Empty))
{
axTypeFromAssembly = this.GetAxTypeFromAssembly(fileName, clsid);
}
if (fileName == null)
{
string typeLibName = Marshal.GetTypeLibName((System.Runtime.InteropServices.ComTypes.ITypeLib)typeLib);
string asmFileName = Path.Combine(this.options.outputDirectory, typeLibName + ".dll");
this.AddReferencedAssembly(this.GetManagedReference("System.Windows.Forms"));
this.AddReferencedAssembly(this.GetManagedReference("System.Drawing"));
this.AddReferencedAssembly(this.GetManagedReference("System"));
string comReference = this.GetComReference((System.Runtime.InteropServices.ComTypes.ITypeLib)typeLib);
if (comReference != null)
{
this.AddReferencedAssembly(comReference);
assem = this.GetCopiedAssembly(comReference, false, false);
this.AddDependentAssemblies(assem, comReference);
}
else
{
TypeLibConverter tlbConverter = new TypeLibConverter();
assem = this.GetPrimaryInteropAssembly((System.Runtime.InteropServices.ComTypes.ITypeLib)typeLib, tlbConverter);
if (assem != null)
{
comReference = this.GetLocalPath(assem.EscapedCodeBase);
this.AddDependentAssemblies(assem, comReference);
}
else
{
AssemblyBuilder asmBldr = tlbConverter.ConvertTypeLibToAssembly((System.Runtime.InteropServices.ComTypes.ITypeLib)typeLib, asmFileName, TypeLibImporterFlags.None, new ImporterCallback(this), this.options.publicKey, this.options.keyPair, null, null);
if (comReference == null)
{
comReference = this.SaveAssemblyBuilder((System.Runtime.InteropServices.ComTypes.ITypeLib)typeLib, asmBldr, asmFileName);
assem = asmBldr;
}
}
}
int num = 0;
string[] refAssemblies = new string[this.refAssems.Count];
foreach (string str6 in this.refAssems)
{
string str7 = str6;
str7 = str7.Replace("%20", " ");
refAssemblies[num++] = str7;
}
if (axTypeFromAssembly == null)
{
string fileOfTypeLib = GetFileOfTypeLib((System.Runtime.InteropServices.ComTypes.ITypeLib)typeLib);
DateTime tlbTimeStamp = (fileOfTypeLib == null) ? DateTime.Now : File.GetLastWriteTime(fileOfTypeLib);
ResolveEventHandler handler = new ResolveEventHandler(this.OnAssemblyResolve);
AppDomain.CurrentDomain.AssemblyResolve += handler;
AppDomain.CurrentDomain.TypeResolve += new ResolveEventHandler(this.OnTypeResolve);
try
{
if (this.options.genSources)
{
AxWrapperGen.GeneratedSources = new ArrayList();
}
if (this.options.outputName == null)
{
this.options.outputName = "Ax" + typeLibName + ".dll";
}
axTypeFromAssembly = AxWrapperGen.GenerateWrappers(this, clsid, assem, refAssemblies, tlbTimeStamp, out fileName);
if (this.options.genSources)
{
this.generatedSources = AxWrapperGen.GeneratedSources;
}
}
finally
{
AppDomain.CurrentDomain.AssemblyResolve -= handler;
AppDomain.CurrentDomain.TypeResolve -= new ResolveEventHandler(this.OnTypeResolve);
}
if (axTypeFromAssembly == null)
{
string message = System.Design.SR.GetString("AXNoActiveXControls", new object[] { (this.typeLibName != null) ? this.typeLibName : typeLibName });
if (this.options.msBuildErrors)
{
message = "AxImp: error aximp000: " + message;
}
throw new Exception(message);
}
}
if (axTypeFromAssembly != null)
{
this.AddReferencedAssembly(fileName);
this.AddTypeLibAttr((System.Runtime.InteropServices.ComTypes.ITypeLib)typeLib);
this.AddGeneratedAssembly(fileName);
}
}
return(axTypeFromAssembly);
}
private Assembly loadComAssembly(string fileName)
{
string strPath = Path.GetDirectoryName(fileName) + "\\";
if (Path.GetDirectoryName(fileName).Length <= 0)
{
strPath = Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName) + @"\";
}
//if (Path.GetDirectoryName(fileName).Length <= 0)
// strPath = string.Empty;
string strSrcFileName = strPath + Path.GetFileName(fileName);
if (!File.Exists(strSrcFileName))
{
return(null);
}
//RegComDll(m_mapComAssembly[assembly.FullName].ToString());
RegComDll(strSrcFileName); //每次自动注册com dll
string strDstFileName = "interop." + Path.GetFileName(fileName);
string strDetFullFileName = strPath + strDstFileName;
string strNameSpace = Path.GetFileNameWithoutExtension(fileName);//文件名作为命名空间
//如果interop.dll的时间比dll时间早，则需要重新生成
bool bNeedGenrate = false;
if (File.Exists(strDetFullFileName))
{
DateTime dtInteropTime = File.GetLastWriteTime(strDetFullFileName);
DateTime dtSrcTime = File.GetLastWriteTime(strSrcFileName);
if (dtSrcTime >= dtInteropTime)
{
bNeedGenrate = true;
}
}
else
{
bNeedGenrate = true;
}
if (bNeedGenrate)
{
Object typeLib;
LoadTypeLibEx(fileName, RegKind.RegKind_None, out typeLib);
if (typeLib == null)
{
//throw new Exception("载入失败！");
return(null);
}
TypeLibConverter converter = new TypeLibConverter();
ConversionEventHandler eventHandler = new ConversionEventHandler();
AssemblyBuilder ab = converter.ConvertTypeLibToAssembly(typeLib, strDetFullFileName, 0,
eventHandler, null, null, strNameSpace, null);
ab.Save(strDstFileName);
}
Assembly asm = Assembly.LoadFile(strDetFullFileName);//Application.StartupPath + @"\" + strDstFileName);
//Type t = asm.GetType("interop.test.tcls1"); //old
//Type t = asm.GetType("Prj2.tcls1"); //new, comdll=Prj2.dll
if (asm != null)
{
m_mapComAssembly[asm.FullName] = strSrcFileName;
}
return(asm);
}
public string GenerateMetaData(string strSrcTypeLib, string outPath, byte[] PublicKey, StrongNameKeyPair KeyPair)
{
string str2;
try
{
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
}
catch (Exception exception)
{
if ((exception is NullReferenceException) || (exception is SEHException))
{
throw;
}
ComSoapPublishError.Report(exception.ToString());
throw;
}
string str = "";
if ((0 >= strSrcTypeLib.Length) || (0 >= outPath.Length))
{
return(str);
}
if (!outPath.EndsWith("/", StringComparison.Ordinal) && !outPath.EndsWith(@"\", StringComparison.Ordinal))
{
outPath = outPath + @"\";
}
ITypeLib typeLib = null;
typeLib = CacheInfo.GetTypeLib(strSrcTypeLib);
if (typeLib == null)
{
return(str);
}
str = CacheInfo.GetMetadataName(strSrcTypeLib, typeLib, out str2);
if (str.Length == 0)
{
return(str);
}
if (this._nameonly)
{
return(str);
}
string assemblyPath = outPath + str2;
if (this._signed)
{
try
{
AssemblyManager manager = new AssemblyManager();
if (manager.CompareToCache(assemblyPath, strSrcTypeLib))
{
new Publish().GacInstall(assemblyPath);
return(str);
}
if (manager.GetFromCache(assemblyPath, strSrcTypeLib))
{
new Publish().GacInstall(assemblyPath);
return(str);
}
goto Label_0133;
}
catch (Exception exception2)
{
if ((exception2 is NullReferenceException) || (exception2 is SEHException))
{
throw;
}
ComSoapPublishError.Report(exception2.ToString());
goto Label_0133;
}
}
if (File.Exists(assemblyPath))
{
return(str);
}
Label_0133:
try
{
ITypeLibConverter converter = new TypeLibConverter();
ImporterCallback notifySink = new ImporterCallback {
OutputDir = outPath
};
AssemblyBuilder builder = converter.ConvertTypeLibToAssembly(typeLib, assemblyPath, TypeLibImporterFlags.UnsafeInterfaces, notifySink, PublicKey, KeyPair, null, null);
FileInfo info = new FileInfo(assemblyPath);
builder.Save(info.Name);
if (this._signed)
{
new AssemblyManager().CopyToCache(assemblyPath, strSrcTypeLib);
new Publish().GacInstall(assemblyPath);
}
}
catch (ReflectionTypeLoadException exception3)
{
Exception[] loaderExceptions = exception3.LoaderExceptions;
for (int i = 0; i < loaderExceptions.Length; i++)
{
try
{
ComSoapPublishError.Report(loaderExceptions[i].ToString());
}
catch (Exception exception4)
{
if ((exception4 is NullReferenceException) || (exception4 is SEHException))
{
throw;
}
ComSoapPublishError.Report(exception3.ToString());
}
}
return(string.Empty);
}
catch (Exception exception5)
{
if ((exception5 is NullReferenceException) || (exception5 is SEHException))
{
throw;
}
ComSoapPublishError.Report(exception5.ToString());
return(string.Empty);
}
return(str);
}
