private bool GetActiveProject(out EnvDTE.Project project, out FrameworkName frameworkName)
{
project = null;
frameworkName = null;
IntPtr hierarchyPointer = IntPtr.Zero;
IntPtr selectionContainerPointer = IntPtr.Zero;
try
{
uint itemid;
IVsMultiItemSelect multiItemSelect;
Marshal.ThrowExceptionForHR(
_monitorSelection.GetCurrentSelection(
out hierarchyPointer,
out itemid,
out multiItemSelect,
out selectionContainerPointer));
if (itemid != (uint)VSConstants.VSITEMID.Root)
{
return(false);
}
var hierarchy = Marshal.GetObjectForIUnknown(hierarchyPointer) as IVsHierarchy;
if (hierarchy == null)
{
return(false);
}
object extensibilityObject;
object targetFrameworkVersion;
object targetFrameworkMonikerObject;
Marshal.ThrowExceptionForHR(
hierarchy.GetProperty((uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID.VSHPROPID_ExtObject, out extensibilityObject));
Marshal.ThrowExceptionForHR(
hierarchy.GetProperty((uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID3.VSHPROPID_TargetFrameworkVersion, out targetFrameworkVersion));
Marshal.ThrowExceptionForHR(
hierarchy.GetProperty((uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID4.VSHPROPID_TargetFrameworkMoniker, out targetFrameworkMonikerObject));
string targetFrameworkMoniker = targetFrameworkMonikerObject as string;
frameworkName = new System.Runtime.Versioning.FrameworkName(targetFrameworkMoniker);
project = extensibilityObject as EnvDTE.Project;
return(true);
}
finally
{
if (hierarchyPointer != IntPtr.Zero)
{
Marshal.Release(hierarchyPointer);
}
if (selectionContainerPointer != IntPtr.Zero)
{
Marshal.Release(selectionContainerPointer);
}
}
}
/// <summary>
/// Based on a target framework moniker, get the set of reference assembly directories which
/// correspond to the highest version of the target framework identifier property on the target framework moniker.
/// </summary>
private static IList<string> GetHighestVersionReferenceAssemblyDirectories(FrameworkNameVersioning targetFrameworkMoniker, out FrameworkNameVersioning highestVersionMoniker)
{
IList<string> referenceAssemblyDirectories = null;
string targetFrameworkRootDirectory = ToolLocationHelper.GetProgramFilesReferenceAssemblyRoot();
highestVersionMoniker = ToolLocationHelper.HighestVersionOfTargetFrameworkIdentifier(targetFrameworkRootDirectory, targetFrameworkMoniker.Identifier);
if (highestVersionMoniker == null)
{
referenceAssemblyDirectories = new List<string>();
}
else
{
referenceAssemblyDirectories = ToolLocationHelper.GetPathToReferenceAssemblies(targetFrameworkRootDirectory, highestVersionMoniker);
}
return referenceAssemblyDirectories;
}
/// <summary>
/// Get the redist list which corresponds to the highest target framework for a given target framework moniker.
///
/// This is done in two ways:
/// First, if the latestTargetFrameworkDirectories parameter is passed into RAR those directories will be used to get the redist list
/// regardless of the target framework moniker.
///
/// Second, if latest Target Framework Directories is not passed in then we ask the ToollocationHelper for the highest target framework which has
/// a TargetFrameworkIdentifier which matches the passed in TargetFrameworkMoniker.
/// </summary>
private Tuple<RedistList, string> GetHighestVersionFullFrameworkForTFM(FrameworkNameVersioning targetFrameworkMoniker)
{
RedistList redistList = null;
Tuple<RedistList, string> redistListAndOtherFrameworkName = null;
if (targetFrameworkMoniker != null)
{
lock (s_monikerToHighestRedistList)
{
if (!s_monikerToHighestRedistList.TryGetValue(targetFrameworkMoniker.Identifier, out redistListAndOtherFrameworkName))
{
IList<string> referenceAssemblyDirectories = null;
string otherFrameworkName = null;
// The latestTargetFrameworkDirectories can be passed into RAR, if they are then use those directories rather than
// getting a list by looking at the file system.
if (_latestTargetFrameworkDirectories != null && _latestTargetFrameworkDirectories.Length > 0)
{
referenceAssemblyDirectories = new List<string>(_latestTargetFrameworkDirectories);
otherFrameworkName = String.Join(";", _latestTargetFrameworkDirectories);
}
else if (targetFrameworkMoniker != null)
{
FrameworkNameVersioning highestFrameworkName = null;
referenceAssemblyDirectories = GetHighestVersionReferenceAssemblyDirectories(targetFrameworkMoniker, out highestFrameworkName);
if (highestFrameworkName != null)
{
otherFrameworkName = highestFrameworkName.FullName;
}
}
if (referenceAssemblyDirectories != null && referenceAssemblyDirectories.Count > 0)
{
HashSet<string> seenFrameworkDirectories = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
List<AssemblyTableInfo> assemblyTableInfos = new List<AssemblyTableInfo>();
foreach (string path in referenceAssemblyDirectories)
{
string[] listPaths = RedistList.GetRedistListPathsFromDisk(path);
foreach (string listPath in listPaths)
{
if (!seenFrameworkDirectories.Contains(listPath))
{
assemblyTableInfos.Add(new AssemblyTableInfo(listPath, path));
seenFrameworkDirectories.Add(listPath);
}
}
}
// If the same set of directories was passed in before then the redist list will already be cached.
redistList = RedistList.GetRedistList(assemblyTableInfos.ToArray());
}
redistListAndOtherFrameworkName = new Tuple<RedistList, string>(redistList, otherFrameworkName);
s_monikerToHighestRedistList.Add(targetFrameworkMoniker.Identifier, redistListAndOtherFrameworkName);
}
}
}
return redistListAndOtherFrameworkName;
}
/// <summary>
/// Construct.
/// </summary>
/// <param name="findDependencies">If true, then search for dependencies.</param>
/// <param name="findSatellites">If true, then search for satellite files.</param>
/// <param name="findSerializatoinAssemblies">If true, then search for serialization assembly files.</param>
/// <param name="findRelatedFiles">If true, then search for related files.</param>
/// <param name="searchPaths">Paths to search for dependent assemblies on.</param>
/// <param name="candidateAssemblyFiles">List of literal assembly file names to be considered when SearchPaths has {CandidateAssemblyFiles}.</param>
/// <param name="resolvedSDKItems">Resolved sdk items</param>
/// <param name="frameworkPaths">Path to the FX.</param>
/// <param name="installedAssemblies">Installed assembly XML tables.</param>
/// <param name="targetProcessorArchitecture">Like x86 or IA64\AMD64, the processor architecture being targetted.</param>
/// <param name="fileExists">Delegate used for checking for the existence of a file.</param>
/// <param name="directoryExists">Delegate used for files.</param>
/// <param name="getDirectories">Delegate used for getting directories.</param>
/// <param name="getAssemblyName">Delegate used for getting assembly names.</param>
/// <param name="getAssemblyMetadata">Delegate used for finding dependencies of a file.</param>
/// <param name="getRegistrySubKeyNames">Used to get registry subkey names.</param>
/// <param name="getRegistrySubKeyDefaultValue">Used to get registry default values.</param>
internal ReferenceTable
(
IBuildEngine buildEngine,
bool findDependencies,
bool findSatellites,
bool findSerializationAssemblies,
bool findRelatedFiles,
string[] searchPaths,
string[] allowedAssemblyExtensions,
string[] relatedFileExtensions,
string[] candidateAssemblyFiles,
ITaskItem[] resolvedSDKItems,
string[] frameworkPaths,
InstalledAssemblies installedAssemblies,
System.Reflection.ProcessorArchitecture targetProcessorArchitecture,
FileExists fileExists,
DirectoryExists directoryExists,
GetDirectories getDirectories,
GetAssemblyName getAssemblyName,
GetAssemblyMetadata getAssemblyMetadata,
GetRegistrySubKeyNames getRegistrySubKeyNames,
GetRegistrySubKeyDefaultValue getRegistrySubKeyDefaultValue,
OpenBaseKey openBaseKey,
GetAssemblyRuntimeVersion getRuntimeVersion,
Version targetedRuntimeVersion,
Version projectTargetFramework,
FrameworkNameVersioning targetFrameworkMoniker,
TaskLoggingHelper log,
string[] latestTargetFrameworkDirectories,
bool copyLocalDependenciesWhenParentReferenceInGac,
bool doNotCopyLocalIfInGac,
GetAssemblyPathInGac getAssemblyPathInGac,
IsWinMDFile isWinMDFile,
bool ignoreVersionForFrameworkReferences,
ReadMachineTypeFromPEHeader readMachineTypeFromPEHeader,
WarnOrErrorOnTargetArchitectureMismatchBehavior warnOrErrorOnTargetArchitectureMismatch,
bool ignoreFrameworkAttributeVersionMismatch,
bool unresolveFrameworkAssembliesFromHigherFrameworks
)
{
_buildEngine = buildEngine;
_log = log;
_findDependencies = findDependencies;
_findSatellites = findSatellites;
_findSerializationAssemblies = findSerializationAssemblies;
_findRelatedFiles = findRelatedFiles;
_frameworkPaths = frameworkPaths;
_allowedAssemblyExtensions = allowedAssemblyExtensions;
_relatedFileExtensions = relatedFileExtensions;
_installedAssemblies = installedAssemblies;
_targetProcessorArchitecture = targetProcessorArchitecture;
_fileExists = fileExists;
_directoryExists = directoryExists;
_getDirectories = getDirectories;
_getAssemblyName = getAssemblyName;
_getAssemblyMetadata = getAssemblyMetadata;
_getRuntimeVersion = getRuntimeVersion;
_projectTargetFramework = projectTargetFramework;
_targetedRuntimeVersion = targetedRuntimeVersion;
_openBaseKey = openBaseKey;
_targetFrameworkMoniker = targetFrameworkMoniker;
_latestTargetFrameworkDirectories = latestTargetFrameworkDirectories;
_copyLocalDependenciesWhenParentReferenceInGac = copyLocalDependenciesWhenParentReferenceInGac;
_doNotCopyLocalIfInGac = doNotCopyLocalIfInGac;
_getAssemblyPathInGac = getAssemblyPathInGac;
_isWinMDFile = isWinMDFile;
_readMachineTypeFromPEHeader = readMachineTypeFromPEHeader;
_warnOrErrorOnTargetArchitectureMismatch = warnOrErrorOnTargetArchitectureMismatch;
_ignoreFrameworkAttributeVersionMismatch = ignoreFrameworkAttributeVersionMismatch;
// Set condition for when to check assembly version against the target framework version
_checkAssemblyVersionAgainstTargetFrameworkVersion = unresolveFrameworkAssembliesFromHigherFrameworks || ((_projectTargetFramework ?? ReferenceTable.s_targetFrameworkVersion_40) <= ReferenceTable.s_targetFrameworkVersion_40);
// Convert the list of installed SDK's to a dictionary for faster lookup
_resolvedSDKReferences = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase);
_ignoreVersionForFrameworkReferences = ignoreVersionForFrameworkReferences;
if (resolvedSDKItems != null)
{
foreach (ITaskItem resolvedSDK in resolvedSDKItems)
{
string sdkName = resolvedSDK.GetMetadata("SDKName");
if (sdkName.Length > 0)
{
if (!_resolvedSDKReferences.ContainsKey(sdkName))
{
_resolvedSDKReferences.Add(sdkName, resolvedSDK);
}
else
{
_resolvedSDKReferences[sdkName] = resolvedSDK;
}
}
}
}
// Compile searchpaths into fast resolver array.
_compiledSearchPaths = AssemblyResolution.CompileSearchPaths
(
buildEngine,
searchPaths,
candidateAssemblyFiles,
targetProcessorArchitecture,
frameworkPaths,
fileExists,
getAssemblyName,
getRegistrySubKeyNames,
getRegistrySubKeyDefaultValue,
openBaseKey,
installedAssemblies,
getRuntimeVersion,
targetedRuntimeVersion,
getAssemblyPathInGac
);
}
private bool GetActiveProject(out EnvDTE.Project project, out FrameworkName frameworkName)
{
project = null;
frameworkName = null;
IntPtr hierarchyPointer = IntPtr.Zero;
IntPtr selectionContainerPointer = IntPtr.Zero;
try
{
uint itemid;
IVsMultiItemSelect multiItemSelect;
Marshal.ThrowExceptionForHR(
_monitorSelection.GetCurrentSelection(
out hierarchyPointer,
out itemid,
out multiItemSelect,
out selectionContainerPointer));
if (itemid != (uint)VSConstants.VSITEMID.Root)
{
return false;
}
var hierarchy = Marshal.GetObjectForIUnknown(hierarchyPointer) as IVsHierarchy;
if (hierarchy == null)
{
return false;
}
object extensibilityObject;
object targetFrameworkVersion;
object targetFrameworkMonikerObject;
Marshal.ThrowExceptionForHR(
hierarchy.GetProperty((uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID.VSHPROPID_ExtObject, out extensibilityObject));
Marshal.ThrowExceptionForHR(
hierarchy.GetProperty((uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID3.VSHPROPID_TargetFrameworkVersion, out targetFrameworkVersion));
Marshal.ThrowExceptionForHR(
hierarchy.GetProperty((uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID4.VSHPROPID_TargetFrameworkMoniker, out targetFrameworkMonikerObject));
string targetFrameworkMoniker = targetFrameworkMonikerObject as string;
frameworkName = new System.Runtime.Versioning.FrameworkName(targetFrameworkMoniker);
project = extensibilityObject as EnvDTE.Project;
return true;
}
finally
{
if (hierarchyPointer != IntPtr.Zero)
{
Marshal.Release(hierarchyPointer);
}
if (selectionContainerPointer != IntPtr.Zero)
{
Marshal.Release(selectionContainerPointer);
}
}
}