public int Run(String strTypeLibName,
String strAssemblyName,
String strAssemblyNamespace,
String strOutputDir,
byte[] aPublicKey,
StrongNameKeyPair sKeyPair,
String strAssemblyRefList,
String strTypeLibRefList,
Version AssemblyVersion,
TypeLibImporterFlags flags,
bool bNoLogo,
bool bSilentMode,
System.Collections.Generic.List <int> silenceList,
bool bVerboseMode,
bool bStrictRef,
bool bStrictRefNoPia,
bool bSearchPathSucceeded,
String strProduct,
String strProductVersion,
String strCompany,
String strCopyright,
String strTrademark,
bool isVersion2,
bool isPreserveSig,
String ruleSetFileName)
{
TlbImpOptions options = new TlbImpOptions();
options.m_strTypeLibName = strTypeLibName;
options.m_strAssemblyName = strAssemblyName;
options.m_strAssemblyNamespace = strAssemblyNamespace;
options.m_strOutputDir = strOutputDir;
options.m_aPublicKey = aPublicKey;
options.m_sKeyPair = sKeyPair;
options.m_strAssemblyRefList = strAssemblyRefList;
options.m_strTypeLibRefList = strTypeLibRefList;
options.m_AssemblyVersion = AssemblyVersion;
options.m_flags = flags;
options.m_bNoLogo = bNoLogo;
options.m_bSilentMode = bSilentMode;
options.m_silenceList = silenceList;
options.m_bVerboseMode = bVerboseMode;
options.m_bStrictRef = bStrictRef;
options.m_bStrictRefNoPia = bStrictRefNoPia;
options.m_bSearchPathSucceeded = bSearchPathSucceeded;
options.m_strProduct = strProduct;
options.m_strProductVersion = strProductVersion;
options.m_strCompany = strCompany;
options.m_strCopyright = strCopyright;
options.m_strTrademark = strTrademark;
options.m_isVersion2 = isVersion2;
options.m_isPreserveSig = isPreserveSig;
options.m_ruleSetFileName = ruleSetFileName;
return(TlbImpCode.Run(options));
}
public int Run(String strTypeLibName,
String strAssemblyName,
String strAssemblyNamespace,
String strOutputDir,
byte[] aPublicKey,
StrongNameKeyPair sKeyPair,
String strAssemblyRefList,
String strTypeLibRefList,
Version AssemblyVersion,
TypeLibImporterFlags flags,
bool bNoLogo,
bool bSilentMode,
System.Collections.Generic.List<int> silenceList,
bool bVerboseMode,
bool bStrictRef,
bool bStrictRefNoPia,
bool bSearchPathSucceeded,
String strProduct,
String strProductVersion,
String strCompany,
String strCopyright,
String strTrademark,
bool isVersion2,
bool isPreserveSig,
String ruleSetFileName)
{
TlbImpOptions options = new TlbImpOptions();
options.m_strTypeLibName = strTypeLibName;
options.m_strAssemblyName = strAssemblyName;
options.m_strAssemblyNamespace = strAssemblyNamespace;
options.m_strOutputDir = strOutputDir;
options.m_aPublicKey = aPublicKey;
options.m_sKeyPair = sKeyPair;
options.m_strAssemblyRefList = strAssemblyRefList;
options.m_strTypeLibRefList = strTypeLibRefList;
options.m_AssemblyVersion = AssemblyVersion;
options.m_flags = flags;
options.m_bNoLogo = bNoLogo;
options.m_bSilentMode = bSilentMode;
options.m_silenceList = silenceList;
options.m_bVerboseMode = bVerboseMode;
options.m_bStrictRef = bStrictRef;
options.m_bStrictRefNoPia = bStrictRefNoPia;
options.m_bSearchPathSucceeded = bSearchPathSucceeded;
options.m_strProduct = strProduct;
options.m_strProductVersion = strProductVersion;
options.m_strCompany = strCompany;
options.m_strCopyright = strCopyright;
options.m_strTrademark = strTrademark;
options.m_isVersion2 = isVersion2;
options.m_isPreserveSig = isPreserveSig;
options.m_ruleSetFileName = ruleSetFileName;
return TlbImpCode.Run(options);
}
private static bool ParseArguments(String []aArgs, ref TlbImpOptions Options, ref int ReturnCode)
{
Option opt;
bool delaysign = false;
// Create the options object that will be returned.
Options = new TlbImpOptions();
// Parse the command line arguments using the command line argument parser.
var cmdLine = new CommandLine(aArgs, new String[] { "*out", "*publickey", "*keyfile", "*keycontainer", "delaysign", "*reference",
"unsafe", "nologo", "silent", "verbose", "+strictref", "primary", "*namespace",
"*asmversion", "sysarray", "*transform", "?", "help", "*tlbreference",
"noclassmembers", "*machine", "*silence", "*product", "*productversion",
"*company", "*copyright", "*trademark", "v2", "preservesig", "*config" });
// Make sure there is at least one argument.
if ((cmdLine.NumArgs + cmdLine.NumOpts) < 1)
{
PrintUsage();
ReturnCode = SuccessReturnCode;
return false;
}
var assemblyRefList = new List<string>();
var typeLibRefList = new List<string>();
// Get the name of the COM typelib.
Options.m_strTypeLibName = cmdLine.GetNextArg();
// Go through the list of options.
while ((opt = cmdLine.GetNextOption()) != null)
{
// Determine which option was specified.
if (opt.Name.Equals("out"))
{
Options.m_strAssemblyName = opt.Value;
}
else if (opt.Name.Equals("namespace"))
{
Options.m_strAssemblyNamespace = opt.Value;
}
else if (opt.Name.Equals("asmversion"))
{
try
{
Options.m_AssemblyVersion = new Version(opt.Value);
}
catch(Exception)
{
throw new TlbImpGeneralException(Resource.FormatString("Err_InvalidVersion"), ErrorCode.Err_InvalidVersion, true);
}
}
else if (opt.Name.Equals("reference"))
{
string FullPath = GetFullPath(opt.Value, false);
if (FullPath == null)
{
ReturnCode = ErrorReturnCode;
return false;
}
if (Options.m_strAssemblyRefList == null)
{
assemblyRefList.Clear();
assemblyRefList.Add(FullPath.ToLower());
Options.m_strAssemblyRefList = FullPath;
}
else
{
if (!assemblyRefList.Contains(FullPath.ToLower())) {
assemblyRefList.Add(FullPath.ToLower());
Options.m_strAssemblyRefList =
Options.m_strAssemblyRefList + ";" + FullPath;
}
}
}
else if (opt.Name.Equals("tlbreference"))
{
string FullPath = GetFullPath(opt.Value, false);
if (FullPath == null)
{
ReturnCode = ErrorReturnCode;
return false;
}
if (Options.m_strTypeLibRefList == null) {
typeLibRefList.Clear();
typeLibRefList.Add(FullPath.ToLower());
Options.m_strTypeLibRefList = FullPath;
}
else
{
if (!typeLibRefList.Contains(FullPath.ToLower()))
{
typeLibRefList.Add(FullPath.ToLower());
Options.m_strTypeLibRefList =
Options.m_strTypeLibRefList + ";" + FullPath;
}
}
}
else if (opt.Name.Equals("delaysign"))
{
delaysign = true;
}
else if (opt.Name.Equals("publickey"))
{
if (Options.m_sKeyPair != null || Options.m_aPublicKey != null)
{
throw new TlbImpGeneralException(Resource.FormatString("Err_TooManyKeys"), ErrorCode.Err_TooManyKeys, true);
}
// Read data from binary file into byte array.
byte[] aData;
FileStream fs = null;
try
{
fs = new FileStream(opt.Value, FileMode.Open, FileAccess.Read, FileShare.Read);
int iLength = (int)fs.Length;
aData = new byte[iLength];
fs.Read(aData, 0, iLength);
}
catch (Exception ex)
{
throw new TlbImpGeneralException(Resource.FormatString("Err_ErrorWhileOpenningFile", new object[] { opt.Value, ex.GetType().ToString(), ex.Message }), ErrorCode.Err_ErrorWhileOpenningFile, true);
}
finally
{
if (fs != null)
fs.Close();
}
Options.m_aPublicKey = aData;
}
else if (opt.Name.Equals("keyfile"))
{
if (Options.m_sKeyPair != null || Options.m_aPublicKey != null)
{
throw new TlbImpGeneralException(Resource.FormatString("Err_TooManyKeys"), ErrorCode.Err_TooManyKeys, true);
}
// Read data from binary file into byte array.
byte[] aData;
FileStream fs = null;
try
{
fs = new FileStream(opt.Value, FileMode.Open, FileAccess.Read, FileShare.Read);
int iLength = (int)fs.Length;
aData = new byte[iLength];
fs.Read(aData, 0, iLength);
}
catch (Exception ex)
{
throw new TlbImpGeneralException(Resource.FormatString("Err_ErrorWhileOpenningFile", new object[] { opt.Value, ex.GetType().ToString(), ex.Message }), ErrorCode.Err_ErrorWhileOpenningFile, true);
}
finally
{
if (fs != null)
fs.Close();
}
Options.m_sKeyPair = new StrongNameKeyPair(aData);
}
else if (opt.Name.Equals("keycontainer"))
{
if ((Options.m_sKeyPair != null) || (Options.m_aPublicKey != null))
{
throw new TlbImpGeneralException(Resource.FormatString("Err_TooManyKeys"), ErrorCode.Err_TooManyKeys, true);
}
Options.m_sKeyPair = new StrongNameKeyPair(opt.Value);
}
else if (opt.Name.Equals("unsafe"))
{
Options.m_flags |= TypeLibImporterFlags.UnsafeInterfaces;
}
else if (opt.Name.Equals("primary"))
{
Options.m_flags |= TypeLibImporterFlags.PrimaryInteropAssembly;
}
else if (opt.Name.Equals("sysarray"))
{
Options.m_flags |= TypeLibImporterFlags.SafeArrayAsSystemArray;
}
else if (opt.Name.Equals("nologo"))
{
Options.m_bNoLogo = true;
}
else if (opt.Name.Equals("silent"))
{
Output.SetSilent(true);
Options.m_bSilentMode = true;
}
else if (opt.Name.Equals("silence"))
{
int warningNumber = int.Parse(opt.Value, System.Globalization.NumberStyles.HexNumber);
Output.Silence(warningNumber);
Options.m_silenceList.Add(warningNumber);
}
else if (opt.Name.Equals("verbose"))
{
Options.m_bVerboseMode = true;
}
else if (opt.Name.Equals("noclassmembers"))
{
Options.m_flags |= TypeLibImporterFlags.PreventClassMembers;
}
else if (opt.Name.Equals("strictref"))
{
if (opt.Value != null)
{
if (String.Compare(opt.Value, "nopia", true) == 0)
{
Options.m_bStrictRefNoPia = true;
}
else
{
throw new TlbImpGeneralException(Resource.FormatString("Err_UnknownStrictRefOpt", opt.Value), ErrorCode.Err_UnknownStrictRefOpt, true);
}
}
else
Options.m_bStrictRef = true;
}
else if (opt.Name.Equals("transform"))
{
if (opt.Value.ToLower(CultureInfo.InvariantCulture) == "dispret")
{
Options.m_flags |= TypeLibImporterFlags.TransformDispRetVals;
}
else if (opt.Value.ToLower(CultureInfo.InvariantCulture) == "serializablevalueclasses")
{
Options.m_flags |= TypeLibImporterFlags.SerializableValueClasses;
}
else
{
throw new TlbImpGeneralException(Resource.FormatString("Err_InvalidTransform", opt.Value), ErrorCode.Err_InvalidTransform, true);
}
}
else if (opt.Name.Equals("machine"))
{
if (opt.Value.ToLower(CultureInfo.InvariantCulture) == "itanium")
{
Options.m_flags |= TypeLibImporterFlags.ImportAsItanium;
}
else if (opt.Value.ToLower(CultureInfo.InvariantCulture) == "x64")
{
Options.m_flags |= TypeLibImporterFlags.ImportAsX64;
}
else if (opt.Value.ToLower(CultureInfo.InvariantCulture) == "x86")
{
Options.m_flags |= TypeLibImporterFlags.ImportAsX86;
}
else if (opt.Value.ToLower(CultureInfo.InvariantCulture) == "agnostic")
{
Options.m_flags |= TypeLibImporterFlags.ImportAsAgnostic;
}
else
{
throw new TlbImpGeneralException(Resource.FormatString("Err_InvalidMachine", opt.Value), ErrorCode.Err_InvalidMachine, true);
}
}
else if (opt.Name.Equals("product"))
{
Options.m_strProduct = opt.Value;
}
else if (opt.Name.Equals("productversion"))
{
Options.m_strProductVersion = opt.Value;
}
else if (opt.Name.Equals("company"))
{
Options.m_strCompany = opt.Value;
}
else if (opt.Name.Equals("copyright"))
{
Options.m_strCopyright = opt.Value;
}
else if (opt.Name.Equals("trademark"))
{
Options.m_strTrademark = opt.Value;
}
else if (opt.Name.Equals("?") || opt.Name.Equals("help"))
{
PrintUsage();
ReturnCode = SuccessReturnCode;
return false;
}
else if (opt.Name.Equals("v2"))
{
Options.m_isVersion2 = true;
}
else if (opt.Name.Equals("preservesig"))
{
Options.m_isPreserveSig = true;
}
else if (opt.Name.Equals("config"))
{
Options.m_ruleSetFileName = opt.Value;
}
}
// Validate that the typelib name has been specified.
if (Options.m_strTypeLibName == null)
{
throw new TlbImpGeneralException(Resource.FormatString("Err_NoInputFile"), ErrorCode.Err_NoInputFile, true);
}
// Gather information needed for strong naming the assembly (if
// the user desires this).
if ((Options.m_sKeyPair != null) && (Options.m_aPublicKey == null))
{
try
{
Options.m_aPublicKey = Options.m_sKeyPair.PublicKey;
}
catch
{
throw new TlbImpGeneralException(Resource.FormatString("Err_InvalidStrongName"), ErrorCode.Err_InvalidStrongName, true);
}
}
if (delaysign && Options.m_sKeyPair != null)
Options.m_sKeyPair = null;
// To be able to generate a PIA, we must also be strong naming the assembly.
if ((Options.m_flags & TypeLibImporterFlags.PrimaryInteropAssembly) != 0)
{
if (Options.m_aPublicKey == null && Options.m_sKeyPair == null)
{
throw new TlbImpGeneralException(Resource.FormatString("Err_PIAMustBeStrongNamed"), ErrorCode.Err_PIAMustBeStrongNamed, true);
}
}
return true;
}
//**************************************************************************
// Entry point called on the typelib importer in the proper app domain.
//**************************************************************************
public static int Run(TlbImpOptions options)
{
if (options == null) throw new ArgumentNullException(nameof(options));
s_Options = options;
Output.SetSilent(options.m_bSilentMode);
Output.Silence(options.m_silenceList);
System.Runtime.InteropServices.ComTypes.ITypeLib TypeLib = null;
String strPIAName = null;
String strPIACodeBase = null;
s_RK = REGKIND.REGKIND_NONE;
if (Environment.OSVersion.Platform != PlatformID.Win32Windows)
{
if (IsImportingToItanium(options.m_flags) || IsImportingToX64(options.m_flags))
{
s_RK |= REGKIND.REGKIND_LOAD_TLB_AS_64BIT;
}
else if (IsImportingToX86(options.m_flags))
{
s_RK |= REGKIND.REGKIND_LOAD_TLB_AS_32BIT;
}
}
//----------------------------------------------------------------------
// Load the typelib.
try
{
LoadTypeLibEx(s_Options.m_strTypeLibName, s_RK, out TypeLib);
s_RefTypeLibraries.Add(s_Options.m_strTypeLibName, TypeLib);
}
catch (COMException e)
{
if (!s_Options.m_bSearchPathSucceeded)
{
// We failed to search for the typelib and we failed to load it.
// This means that the input typelib is not available.
Output.WriteError(Resource.FormatString("Err_InputFileNotFound", s_Options.m_strTypeLibName), ErrorCode.Err_InputFileNotFound);
}
else
{
if (e.ErrorCode == unchecked((int)0x80029C4A))
{
Output.WriteError(Resource.FormatString("Err_InputFileNotValidTypeLib", s_Options.m_strTypeLibName), ErrorCode.Err_InputFileNotValidTypeLib);
}
else
{
Output.WriteError(Resource.FormatString("Err_TypeLibLoad", e), ErrorCode.Err_TypeLibLoad);
}
}
return ErrorReturnCode;
}
catch (Exception e)
{
Output.WriteError(Resource.FormatString("Err_TypeLibLoad", e), ErrorCode.Err_TypeLibLoad);
return ErrorReturnCode;
}
//----------------------------------------------------------------------
// Check to see if there already exists a primary interop assembly for
// this typelib.
if (TlbImpCode.GetPrimaryInteropAssembly(TypeLib, out strPIAName, out strPIACodeBase))
{
Output.WriteWarning(Resource.FormatString("Wrn_PIARegisteredForTlb", strPIAName, s_Options.m_strTypeLibName), WarningCode.Wrn_PIARegisteredForTlb);
}
//----------------------------------------------------------------------
// Retrieve the name of output assembly if it was not explicitly set.
if (s_Options.m_strAssemblyName == null)
{
s_Options.m_strAssemblyName = Marshal.GetTypeLibName(TypeLib) + ".dll";
}
//----------------------------------------------------------------------
// Do some verification on the output assembly.
String strFileNameNoPath = Path.GetFileName(s_Options.m_strAssemblyName);
String strExtension = Path.GetExtension(s_Options.m_strAssemblyName);
// Validate that the extension is valid.
bool bExtensionValid = ".dll".Equals(strExtension.ToLower(CultureInfo.InvariantCulture));
// If the extension is not valid then tell the user and quit.
if (!bExtensionValid)
{
Output.WriteError(Resource.FormatString("Err_InvalidExtension"), ErrorCode.Err_InvalidExtension);
return ErrorReturnCode;
}
// Make sure the output file will not overwrite the input file.
String strInputFilePath = (new FileInfo(s_Options.m_strTypeLibName)).FullName.ToLower(CultureInfo.InvariantCulture);
String strOutputFilePath;
try
{
strOutputFilePath = (new FileInfo(s_Options.m_strAssemblyName)).FullName.ToLower(CultureInfo.InvariantCulture);
}
catch (System.IO.PathTooLongException)
{
Output.WriteError(Resource.FormatString("Err_OutputFileNameTooLong", s_Options.m_strAssemblyName), ErrorCode.Err_OutputFileNameTooLong);
return ErrorReturnCode;
}
if (strInputFilePath.Equals(strOutputFilePath))
{
Output.WriteError(Resource.FormatString("Err_OutputWouldOverwriteInput"), ErrorCode.Err_OutputWouldOverwriteInput);
return ErrorReturnCode;
}
//-------------------------------------------------------------------------
// Load all assemblies provided as explicit references on the command line.
if (s_Options.m_strAssemblyRefList != null)
{
String[] asmPaths = s_Options.m_strAssemblyRefList.Split(';');
foreach (String asmPath in asmPaths)
{
if (!LoadAssemblyRef(asmPath))
return ErrorReturnCode;
}
}
//-------------------------------------------------------------------------
// And the same for type library references.
if (s_Options.m_strTypeLibRefList != null)
{
String[] tlbPaths = s_Options.m_strTypeLibRefList.Split(';');
foreach (String tlbPath in tlbPaths)
{
if (!LoadTypeLibRef(tlbPath))
return ErrorReturnCode;
}
}
//-------------------------------------------------------------------------
// Before we attempt the import, verify the references first
if (!VerifyTypeLibReferences(s_Options.m_strTypeLibName))
return ErrorReturnCode;
//----------------------------------------------------------------------
// Attempt the import.
try
{
try
{
// Import the typelib to an assembly.
AssemblyBuilder AsmBldr = DoImport(TypeLib, s_Options.m_strAssemblyName, s_Options.m_strAssemblyNamespace,
s_Options.m_AssemblyVersion, s_Options.m_aPublicKey, s_Options.m_sKeyPair, s_Options.m_strProduct,
s_Options.m_strProductVersion, s_Options.m_strCompany, s_Options.m_strCopyright, s_Options.m_strTrademark,
s_Options.m_flags, s_Options.m_isVersion2, s_Options.m_isPreserveSig, s_Options.m_ruleSetFileName);
if (AsmBldr == null)
return ErrorReturnCode;
}
catch (TlbImpResolveRefFailWrapperException ex)
{
// Throw out the inner exception instead
throw ex.InnerException;
}
}
catch (ReflectionTypeLoadException e)
{
Output.WriteError(Resource.FormatString("Err_TypeLoadExceptions"), ErrorCode.Err_TypeLoadExceptions);
Exception[] exceptions = e.LoaderExceptions;
for (int i = 0; i < exceptions.Length; i++)
{
try
{
Output.WriteInfo(Resource.FormatString("Msg_DisplayException", new object[] { i, exceptions[i].GetType().ToString(), exceptions[i].Message }), MessageCode.Msg_DisplayException);
}
catch (Exception ex)
{
Output.WriteInfo(Resource.FormatString("Msg_DisplayNestedException", new object [] { i, ex.GetType().ToString(), ex.Message }), MessageCode.Msg_DisplayNestedException);
}
}
return ErrorReturnCode;
}
catch (TlbImpGeneralException tge)
{
Output.WriteTlbimpGeneralException(tge);
return ErrorReturnCode;
}
catch (COMException ex)
{
if ((uint)ex.ErrorCode == HResults.TYPE_E_CANTLOADLIBRARY)
{
// Give a more specific message
Output.WriteError(Resource.FormatString("Err_RefTlbCantLoad"), ErrorCode.Err_RefTlbCantLoad);
}
else
{
// TlbImp COM exception
string msg = Resource.FormatString(
"Err_UnexpectedException",
ex.GetType().ToString(),
ex.Message
);
Output.WriteError(msg, ErrorCode.Err_UnexpectedException);
}
return ErrorReturnCode;
}
catch (TlbImpInvalidTypeConversionException ex)
{
// This usually means that a type conversion has failed outside normal conversion process...
string name = null;
try
{
name = ex.Type.GetDocumentation();
}
catch(Exception)
{
}
if (name != null)
Output.WriteError(Resource.FormatString("Err_FatalErrorInConversion_Named", name), ErrorCode.Err_FatalErrorInConversion_Named);
else
Output.WriteError(Resource.FormatString("Err_FatalErrorInConversion_Unnamed"), ErrorCode.Err_FatalErrorInConversion_Unnamed);
return ErrorReturnCode;
}
catch (SecurityException ex)
{
// Only treat SecurityException with PermissionType != null as permission issue
if (ex.PermissionType == null)
{
string msg = Resource.FormatString(
"Err_UnexpectedException",
ex.GetType().ToString(),
ex.Message
);
Output.WriteError(msg, ErrorCode.Err_UnexpectedException);
}
else
{
Output.WriteError(Resource.GetString("Err_PermissionException"), ErrorCode.Err_PermissionException);
}
return ErrorReturnCode;
}
catch (Exception ex)
{
string msg = Resource.FormatString(
"Err_UnexpectedException",
ex.GetType().ToString(),
ex.Message
);
Output.WriteError(msg, ErrorCode.Err_UnexpectedException);
return ErrorReturnCode;
}
Output.WriteInfo(Resource.FormatString("Msg_TypeLibImported", s_Options.m_strAssemblyName), MessageCode.Msg_TypeLibImported);
return SuccessReturnCode;
}
public int Run(TlbImpOptions s_options)
{
return(TlbImpCode.Run(s_options));
}
//**************************************************************************
// Entry point called on the typelib importer in the proper app domain.
//**************************************************************************
public static int Run(TlbImpOptions options)
{
s_Options = options;
UCOMITypeLib TypeLib = null;
String strPIAName = null;
String strPIACodeBase = null;
//----------------------------------------------------------------------
// Load the typelib.
try
{
LoadTypeLibEx(s_Options.m_strTypeLibName, REGKIND.REGKIND_NONE, out TypeLib);
}
catch (COMException e)
{
if (!s_Options.m_bSearchPathSucceeded)
{
// We failed to search for the typelib and we failed to load it.
// This means that the input typelib is not available.
WriteErrorMsg(Resource.FormatString("Err_InputFileNotFound", s_Options.m_strTypeLibName));
}
else
{
if (e.ErrorCode == unchecked ((int)0x80029C4A))
{
WriteErrorMsg(Resource.FormatString("Err_InputFileNotValidTypeLib", s_Options.m_strTypeLibName));
}
else
{
WriteErrorMsg(Resource.FormatString("Err_TypeLibLoad", e));
}
}
return(ErrorReturnCode);
}
catch (Exception e)
{
WriteErrorMsg(Resource.FormatString("Err_TypeLibLoad", e));
}
//----------------------------------------------------------------------
// Check to see if there already exists a primary interop assembly for
// this typelib.
if (TlbImpCode.GetPrimaryInteropAssembly(TypeLib, out strPIAName, out strPIACodeBase))
{
WriteWarningMsg(Resource.FormatString("Wrn_PIARegisteredForTlb", strPIAName, s_Options.m_strTypeLibName));
}
//----------------------------------------------------------------------
// Retrieve the name of output assembly if it was not explicitly set.
if (s_Options.m_strAssemblyName == null)
{
s_Options.m_strAssemblyName = Marshal.GetTypeLibName(TypeLib) + ".dll";
}
//----------------------------------------------------------------------
// If no extension is provided, append a .dll to the assembly name.
if ("".Equals(Path.GetExtension(s_Options.m_strAssemblyName)))
{
s_Options.m_strAssemblyName = s_Options.m_strAssemblyName + ".dll";
}
//----------------------------------------------------------------------
// Do some verification on the output assembly.
String strFileNameNoPath = Path.GetFileName(s_Options.m_strAssemblyName);
String strExtension = Path.GetExtension(s_Options.m_strAssemblyName);
// Validate that the extension is valid.
bool bExtensionValid = ".dll".Equals(strExtension.ToLower(CultureInfo.InvariantCulture));
// If the extension is not valid then tell the user and quit.
if (!bExtensionValid)
{
WriteErrorMsg(Resource.FormatString("Err_InvalidExtension"));
return(ErrorReturnCode);
}
// Make sure the output file will not overwrite the input file.
String strInputFilePath = (new FileInfo(s_Options.m_strTypeLibName)).FullName.ToLower(CultureInfo.InvariantCulture);
String strOutputFilePath;
try
{
strOutputFilePath = (new FileInfo(s_Options.m_strAssemblyName)).FullName.ToLower(CultureInfo.InvariantCulture);
}
catch (System.IO.PathTooLongException)
{
WriteErrorMsg(Resource.FormatString("Err_OutputFileNameTooLong", s_Options.m_strAssemblyName));
return(ErrorReturnCode);
}
if (strInputFilePath.Equals(strOutputFilePath))
{
WriteErrorMsg(Resource.FormatString("Err_OutputWouldOverwriteInput"));
return(ErrorReturnCode);
}
// Check to see if the output directory is valid.
if (!Directory.Exists(Path.GetDirectoryName(strOutputFilePath)))
{
WriteErrorMsg(Resource.FormatString("Err_InvalidOutputDirectory"));
return(ErrorReturnCode);
}
//----------------------------------------------------------------------
// Attempt the import.
try
{
// Import the typelib to an assembly.
AssemblyBuilder AsmBldr = DoImport(TypeLib, s_Options.m_strAssemblyName, s_Options.m_strAssemblyNamespace, s_Options.m_AssemblyVersion, s_Options.m_aPublicKey, s_Options.m_sKeyPair, s_Options.m_flags);
if (AsmBldr == null)
{
return(ErrorReturnCode);
}
}
catch (ReflectionTypeLoadException e)
{
int i;
Exception[] exceptions;
WriteErrorMsg(Resource.FormatString("Err_TypeLoadExceptions"));
exceptions = e.LoaderExceptions;
for (i = 0; i < exceptions.Length; i++)
{
try
{
Console.Error.WriteLine(Resource.FormatString("Msg_DisplayException", i, exceptions[i]));
}
catch (Exception ex)
{
Console.Error.WriteLine(Resource.FormatString("Msg_DisplayNestedException", i, ex));
}
}
return(ErrorReturnCode);
}
catch (Exception e)
{
WriteErrorMsg(null, e);
return(ErrorReturnCode);
}
//----------------------------------------------------------------------
// Display the success message unless silent mode is enabled.
if (!s_Options.m_bSilentMode)
{
Console.WriteLine(Resource.FormatString("Msg_TypeLibImported", s_Options.m_strAssemblyName));
}
return(SuccessReturnCode);
}
