|
private ConvertTypeLibToAssembly ( [ typeLib, string asmFileName, TypeLibImporterFlags flags, ITypeLibImporterNotifySink notifySink, byte publicKey, |
||
| typeLib | [ | |
| asmFileName | string | |
| flags | TypeLibImporterFlags | |
| notifySink | ITypeLibImporterNotifySink | |
| publicKey | byte | |
| keyPair | ||
| asmNamespace | string | |
| asmVersion | System.Version | |
| return | ||
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;
}
public Assembly ResolveRef(object TypeLib)
{
try
{
ITypeLibConverter converter = new TypeLibConverter();
return(converter.ConvertTypeLibToAssembly(TypeLib, Marshal.GetTypeLibName((ITypeLib)TypeLib) + ".dll", TypeLibImporterFlags.None, new ImporterCallback(), null, null, null, null));
}
catch (Exception)
{
return(null);
}
}
public Assembly ResolveRef(object TypeLib)
{
try
{
ITypeLibConverter converter = new TypeLibConverter();
return converter.ConvertTypeLibToAssembly(TypeLib, Marshal.GetTypeLibName((ITypeLib) TypeLib) + ".dll", TypeLibImporterFlags.None, new ImporterCallback(), null, null, null, null);
}
catch (Exception)
{
return null;
}
}
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");
}
public static string GenerateAssemblyFromTypeLib(UCOMITypeLib typLib)
{
// Need a sink for the TypeLibConverter.
var 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.
var tlc = new TypeLibConverter();
// Generate name of the assembly.
var typeLibName = Marshal.GetTypeLibName(typLib);
var asmName = "Interop." + typeLibName + ".dll";
// Now make the assembly based on COM type information.
var asmBuilder = tlc.ConvertTypeLibToAssembly(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;
}
/*
* 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;
}
private DLLModel convertDLLToManaged(DLLModel dLLModel)
{
Object typeLib;
LoadTypeLibEx(dLLModel.getFullyQualifiedPath(), RegKind.RegKind_None, out typeLib);
if (typeLib == null)
{
Console.WriteLine("LoadTypeLibEx failed.");
}
TypeLibConverter converter = new TypeLibConverter();
ConversionEventHandler eventHandler = new ConversionEventHandler();
string newDllName = dLLModel.getDllFileName()
+ "_converted.dll";
AssemblyBuilder asm = converter.ConvertTypeLibToAssembly(typeLib, newDllName, 0, eventHandler, null, null, null, null);
asm.Save(newDllName);
DLLModel newdLLModel = new DLLModel(AppDomain.CurrentDomain.BaseDirectory + newDllName);
return newdLLModel;
}
private 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;
RegisterTypeInterfaces(a);
return a;
}
}
public string Import(ProjectReference refinfo, Project project)
{
RegistryKey root = Registry.ClassesRoot;
RegistryKey typelibsKey = root.OpenSubKey("TypeLib");
int index = refinfo.Reference.LastIndexOf("{");
if (index < 0) {
return null;
}
RegistryKey typelibKey = typelibsKey.OpenSubKey(refinfo.Reference.Substring(index, refinfo.Reference.Length - index));
if (typelibKey == null) {
return null;
}
string[] versions = typelibKey.GetSubKeyNames();
if (versions.Length <= 0) {
return null;
}
// Use the last version
string version = versions[versions.Length - 1];
RegistryKey versionKey = typelibKey.OpenSubKey(version);
string tlbname = (string)versionKey.GetValue(null);
string tlpath = GetTypelibPath(versionKey);
if (tlpath == null) {
return null;
}
string proxyfilename = "Interop." + Path.GetFileNameWithoutExtension(tlpath) + ".dll";
AbstractProjectConfiguration ac = (AbstractProjectConfiguration)project.ActiveConfiguration;
string fullpath = Path.Combine(ac.OutputDirectory,proxyfilename);
if (!File.Exists(fullpath)) {
string saveCurrDir = Directory.GetCurrentDirectory();
if (!Directory.Exists(ac.OutputDirectory)) {
Directory.CreateDirectory(ac.OutputDirectory);
}
Directory.SetCurrentDirectory(ac.OutputDirectory);
if (!ImportTypelibUsingTlbImpCode(tlpath, ac.OutputDirectory, proxyfilename)) {
MessageBox.Show("Cannot import type library using .Net SDK 1.0. Some, but not all type libraries can succesfully be imported without it. ",
".Net SDK 1.0 not present ?",
MessageBoxButtons.OK,
MessageBoxIcon.Warning,
MessageBoxDefaultButton.Button1);
Object typeLib;
LoadTypeLibEx(tlpath, RegKind.RegKind_None, out typeLib);
if( typeLib == null ) {
throw new System.Exception("LoadTypeLibEx failed.");
}
TypeLibConverter converter = new TypeLibConverter();
ConversionEventHandler eventHandler = new ConversionEventHandler();
AssemblyBuilder asm = converter.ConvertTypeLibToAssembly( typeLib,
proxyfilename, 0, eventHandler, null, null,
Marshal.GetTypeLibName((UCOMITypeLib)typeLib), null );
asm.Save( proxyfilename );
}
Directory.SetCurrentDirectory(saveCurrDir);
}
return fullpath;
}
// This translates the type library into an assembly
internal void TranslateTypeLib()
{
TraceUtil.WriteLineInfo(this, "TranslateTypeLib");
// Already associated with an assembly
if (_assy != null)
return;
ReadTypeLibFile();
if (_iTypeLib == null)
throw new Exception("Failed to open file: " + _fileName);
// If this is present, we can't translate the assembly,
// we just have to try and load it using this name. This
// is the case for things like mscorlib.tlb
if (_translatedAssyFullName != null) {
Assembly assy = null;
try {
String fileName;
// We will have the file name if we are coming through
// here after the type library has been opened previously
// (when it is being restored from the registry).
if (_assyInfo._fileName != null)
fileName = _assyInfo._fileName;
else
fileName = _translatedAssyFullName;
TraceUtil.WriteLineInfo
(null,
"TypeLib - translated assy looking for: "
+ fileName);
assy = Assembly.Load(fileName);
} catch (FileNotFoundException) {
// Don't ask the user if we have already asked
// the user
if (!_dontFindAssy)
assy = FindAssemblyFile();
}
TraceUtil.WriteLineInfo(null,
"TypeLib - source assy is: "
+ assy
+ " for translated lib "
+ _translatedAssyFullName);
RecordTranslatedAssy(assy);
return;
}
CheckForPrimaryInteropAssy();
if (_primaryInteropAssyName != null)
return;
// Only create the versioned names if the primary interop assy
// is not used, since that's not versioned.
CreateAssyNames();
TraceUtil.WriteLineIf(null, TraceLevel.Info,
"TypeLib - converting - url: "
+ _assyInfo._url
+ " file: " + _assyInfo._fileName);
String dir = ComponentInspectorProperties.ConvertedAssemblyDirectory;
Directory.CreateDirectory(dir);
Directory.SetCurrentDirectory(dir);
if (IsAssyCurrent(_assyInfo._fileName, _fileName)) {
// See if there is a translated version already present.
// We don't know if there should be an Ax version or not,
// try the normal one and if it succeeds, try the Ax version.
// If the normal version succeeds however, we can consider
// that we are done.
RecordTranslatedAssy(Assembly.LoadFrom(_assyInfo._url));
TraceUtil.WriteLineInfo(null,
"TypeLib - found previous xlated "
+ _assyInfo._name);
try {
RecordTranslatedAssy(Assembly.LoadFrom(_axAssyInfo._url));
} catch {
// Ignore
}
return;
}
// Convert the type library to an assembly
// The assembly load event happens in here, it is going to
// be unable to add the assembly to the registry since there
// is no CodeBase associated with a dynamically created
// assembly, but that's not a problem since we add it below
// when adding the GUID for the typelib
ProgressDialog progress = new ProgressDialog();
progress.Setup("Converting " + GetName()
+ " to .NET Assembly",
"Please wait while I convert "
+ GetName()
+ " to a .NET Assembly",
ProgressDialog.NO_PROGRESS_BAR,
!ProgressDialog.HAS_PROGRESS_TEXT,
ProgressDialog.FINAL);
progress.ShowIfNotDone();
try {
TypeLibConverter converter = new TypeLibConverter();
AssemblyBuilder asm = converter.ConvertTypeLibToAssembly
(_iTypeLib,
_assyInfo._fileName,
// Can't do this because we can't strong name these
//TypeLibImporterFlags.PrimaryInteropAssembly,
0,
this,
null, null, null, null);
// For the problem associated with Q316653
//FixEventSinkHelpers(asm);
asm.Save(_assyInfo._fileName);
RecordTranslatedAssy(Assembly.LoadFrom(_assyInfo._url));
// Generate the ActiveX wrapper for the typelib,
// if that's necessary
AxImporter.Options impOptions = new AxImporter.Options();
impOptions.outputDirectory = dir;
impOptions.outputName = _axAssyInfo._fileName;
impOptions.references = this;
impOptions.genSources = true;
AxImporter axImport = new AxImporter(impOptions);
try {
// This converts the type library and generates the
// wrapper for any ActiveX controls. It produces
// a list of the assemblies that it created. If there
// are no ActiveX controls this will throw.
String wrapper = axImport.
GenerateFromTypeLibrary(_iTypeLib);
} catch (Exception ex) {
if (ex.Message.StartsWith("Did not find a")) {
TraceUtil.WriteLineInfo(this,
"TypeLib - no controls found");
return;
}
TraceUtil.WriteLineWarning(this,
"TypeLib - AxImporter error "
+ _assyInfo._url + " "
+ ex);
throw new Exception("Error in AxImporter for: "
+ _assyInfo._url, ex);
}
foreach (String aname in axImport.GeneratedAssemblies) {
TraceUtil.WriteLineInfo(this, "TypeLib - AX gen assy: "
+ aname);
}
foreach (String sname in axImport.GeneratedSources) {
TraceUtil.WriteLineInfo(this, "TypeLib - AX gen source: "
+ sname);
}
RecordTranslatedAssy(Assembly.LoadFrom(_axAssyInfo._url));
TraceUtil.WriteLineIf(null, TraceLevel.Info,
"TypeLib - conversion done: "
+ _assyInfo._url);
} finally {
progress.Finished();
}
}
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)
{
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 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 path = null;
if (this.options.ignoreRegisteredOcx)
{
path = this.typeLibName;
}
else
{
path = GetFileOfTypeLib((System.Runtime.InteropServices.ComTypes.ITypeLib) typeLib);
}
DateTime tlbTimeStamp = (path == null) ? DateTime.Now : File.GetLastWriteTime(path);
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, this.options.ignoreRegisteredOcx, 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;
}