bool IComReferenceResolver.ResolveComClassicReference(System.Runtime.InteropServices.ComTypes.TYPELIBATTR typeLibAttr, string outputDirectory, string wrapperType, string refName, out ComReferenceWrapperInfo wrapperInfo)
{
ComReferenceInfo info;
bool topLevelRef = false;
wrapperInfo = null;
System.Runtime.InteropServices.ComTypes.TYPELIBATTR typelibattr = typeLibAttr;
if (ComReference.RemapAdoTypeLib(base.Log, ref typeLibAttr))
{
base.Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.RemappingAdoTypeLib", new object[] { typelibattr.wMajorVerNum, typelibattr.wMinorVerNum });
}
if (this.IsExistingProjectReference(typeLibAttr, wrapperType, out info))
{
topLevelRef = true;
wrapperType = info.taskItem.GetMetadata("WrapperTool");
}
else if (this.IsExistingDependencyReference(typeLibAttr, out info))
{
if ((wrapperType == null) || ComReferenceTypes.IsPiaOrTlbImp(wrapperType))
{
string key = ComReference.UniqueKeyFromTypeLibAttr(typeLibAttr);
if (this.cachePia.ContainsKey(key))
{
wrapperType = "primary";
}
else if (this.cacheTlb.ContainsKey(key))
{
wrapperType = "tlbimp";
}
}
}
else
{
try
{
info = new ComReferenceInfo();
if (info.InitializeWithTypeLibAttrs(base.Log, typeLibAttr, null, this.TargetProcessorArchitecture))
{
this.allDependencyRefs.Add(info);
}
else
{
info.ReleaseTypeLibPtr();
return false;
}
}
catch (COMException exception)
{
base.Log.LogWarningWithCodeFromResources("ResolveComReference.CannotLoadTypeLib", new object[] { typeLibAttr.guid, typeLibAttr.wMajorVerNum.ToString(CultureInfo.InvariantCulture), typeLibAttr.wMinorVerNum.ToString(CultureInfo.InvariantCulture), exception.Message });
info.ReleaseTypeLibPtr();
return false;
}
}
if (refName == null)
{
refName = info.typeLibName;
}
return this.ResolveComClassicReference(info, outputDirectory, wrapperType, refName, topLevelRef, info.dependentWrapperPaths, out wrapperInfo);
}
/*
* Method: ConvertAttrReferencesToComReferenceInfo
*
* Helper method. Converts TypeLibAttr references to ComReferenceInfo objects.
* This method cannot fail, since we want to proceed with the task even if some references won't load.
*/
private void ConvertAttrReferencesToComReferenceInfo(List<ComReferenceInfo> projectRefs, ITaskItem[] typeLibAttrs)
{
int typeLibAttrsLength = (typeLibAttrs == null) ? 0 : typeLibAttrs.GetLength(0);
for (int i = 0; i < typeLibAttrsLength; i++)
{
ComReferenceInfo projectRefInfo = new ComReferenceInfo();
try
{
if (projectRefInfo.InitializeWithTypeLibAttrs(Log, Silent, TaskItemToTypeLibAttr(typeLibAttrs[i]), typeLibAttrs[i], this.TargetProcessorArchitecture))
{
projectRefs.Add(projectRefInfo);
}
else
{
projectRefInfo.ReleaseTypeLibPtr();
}
}
catch (COMException ex)
{
if (!Silent)
{
Log.LogWarningWithCodeFromResources("ResolveComReference.CannotLoadTypeLibItemSpec", typeLibAttrs[i].ItemSpec, ex.Message);
}
projectRefInfo.ReleaseTypeLibPtr();
// we don't want to fail the task if one of the references is not registered, so just continue
}
}
}
private void ConvertAttrReferencesToComReferenceInfo(List<ComReferenceInfo> projectRefs, ITaskItem[] typeLibAttrs)
{
int num = (typeLibAttrs == null) ? 0 : typeLibAttrs.GetLength(0);
for (int i = 0; i < num; i++)
{
ComReferenceInfo item = new ComReferenceInfo();
try
{
if (item.InitializeWithTypeLibAttrs(base.Log, TaskItemToTypeLibAttr(typeLibAttrs[i]), typeLibAttrs[i], this.TargetProcessorArchitecture))
{
projectRefs.Add(item);
}
else
{
item.ReleaseTypeLibPtr();
}
}
catch (COMException exception)
{
base.Log.LogWarningWithCodeFromResources("ResolveComReference.CannotLoadTypeLibItemSpec", new object[] { typeLibAttrs[i].ItemSpec, exception.Message });
item.ReleaseTypeLibPtr();
}
}
}
/*
* Method: ResolveComClassicReference
*
* Resolves a COM classic reference given the type library attributes and the type of wrapper to use.
* If wrapper type is not specified, this method will first look for an existing reference in the project,
* fall back to looking for a PIA and finally try to generate a regular tlbimp wrapper.
*
* This is the method available for references to call back to resolve their dependencies
*/
bool IComReferenceResolver.ResolveComClassicReference(TYPELIBATTR typeLibAttr, string outputDirectory, string wrapperType, string refName, out ComReferenceWrapperInfo wrapperInfo)
{
// does this reference exist in the project or is it a dependency?
bool topLevelRef = false;
wrapperInfo = null;
// remap the type lib to ADO 2.7 if necessary
TYPELIBATTR oldAttr = typeLibAttr;
if (ComReference.RemapAdoTypeLib(Log, Silent, ref typeLibAttr) && !Silent)
{
// if successfully remapped the reference to ADO 2.7, notify the user
Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.RemappingAdoTypeLib", oldAttr.wMajorVerNum, oldAttr.wMinorVerNum);
}
ComReferenceInfo referenceInfo;
// find an existing ref in the project (taking the desired wrapperType into account, if any)
if (IsExistingProjectReference(typeLibAttr, wrapperType, out referenceInfo))
{
// IsExistingProjectReference should not return null...
Debug.Assert(referenceInfo != null, "IsExistingProjectReference should not return null");
topLevelRef = true;
wrapperType = referenceInfo.taskItem.GetMetadata(ComReferenceItemMetadataNames.wrapperTool);
}
// was this dependency already processed?
else if (IsExistingDependencyReference(typeLibAttr, out referenceInfo))
{
Debug.Assert(referenceInfo != null, "IsExistingDependencyReference should not return null");
// we've seen this dependency before, so we should know what its wrapper type is.
if (wrapperType == null || ComReferenceTypes.IsPiaOrTlbImp(wrapperType))
{
string typeLibKey = ComReference.UniqueKeyFromTypeLibAttr(typeLibAttr);
if (_cachePia.ContainsKey(typeLibKey))
{
wrapperType = ComReferenceTypes.primary;
}
else if (_cacheTlb.ContainsKey(typeLibKey))
{
wrapperType = ComReferenceTypes.tlbimp;
}
}
}
// if not found anywhere, create a new ComReferenceInfo object and resolve it.
else
{
try
{
referenceInfo = new ComReferenceInfo();
if (referenceInfo.InitializeWithTypeLibAttrs(Log, Silent, typeLibAttr, null, this.TargetProcessorArchitecture))
{
allDependencyRefs.Add(referenceInfo);
}
else
{
referenceInfo.ReleaseTypeLibPtr();
return false;
}
}
catch (COMException ex)
{
if (!Silent)
{
Log.LogWarningWithCodeFromResources("ResolveComReference.CannotLoadTypeLib", typeLibAttr.guid,
typeLibAttr.wMajorVerNum.ToString(CultureInfo.InvariantCulture),
typeLibAttr.wMinorVerNum.ToString(CultureInfo.InvariantCulture),
ex.Message);
}
referenceInfo.ReleaseTypeLibPtr();
// can't resolve an unregistered and unknown dependency, so return false
return false;
}
}
// if we don't have the reference name, use the typelib name
if (refName == null)
{
refName = referenceInfo.typeLibName;
}
return ResolveComClassicReference(referenceInfo, outputDirectory, wrapperType, refName, topLevelRef, referenceInfo.dependentWrapperPaths, out wrapperInfo);
}
