/// <summary>
/// Convenient static helper method on RegistryKeyWrapper, for when someone is only intersted in knowing
/// whether a particular registry key exists or not.
/// </summary>
public static bool KeyExists(string registryKeyPath, RegistryHive registryHive, RegistryView registryView)
{
using (RegistryKeyWrapper wrapper = new RegistryKeyWrapper(registryKeyPath, registryHive, registryView))
{
return(wrapper.Exists());
}
}
/// <summary>
/// Returns the RegistryKeyWrapper around the sub key with name "name". If that does
/// not exist, returns a RegistryKeyWrapper around null.
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public virtual RegistryKeyWrapper OpenSubKey(string name)
{
ErrorUtilities.VerifyThrowArgumentLength(name, "name");
RegistryKeyWrapper wrapper = this;
string[] keyNames = name.Split(MSBuildConstants.BackslashChar, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < keyNames.Length && wrapper.Exists(); ++i)
{
try
{
wrapper = new RegistryKeyWrapper(wrapper.WrappedKey.OpenSubKey(keyNames[i], false /* not writeable */), _registryHive);
}
catch (Exception ex)
{
if (ExceptionHandling.NotExpectedRegistryException(ex))
{
throw;
}
throw new RegistryException(ex.Message, wrapper.Name + "\\" + keyNames[i], ex);
}
}
return(wrapper);
}
/// <summary>
/// Constructor overload accepting a registry wrapper for unit testing purposes only
/// </summary>
internal ToolsetRegistryReader(PropertyDictionary <ProjectPropertyInstance> environmentProperties, PropertyDictionary <ProjectPropertyInstance> globalProperties, RegistryKeyWrapper msbuildRegistryWrapper)
: base(environmentProperties, globalProperties)
{
error.VerifyThrowArgumentNull(msbuildRegistryWrapper, "msbuildRegistryWrapper");
_msbuildRegistryWrapper = msbuildRegistryWrapper;
}
/// <summary>
/// Reads a string value from the specified registry key
/// </summary>
/// <param name="wrapper">wrapper around key</param>
/// <param name="valueName">name of the value</param>
/// <returns>string data in the value</returns>
private static string GetValue(RegistryKeyWrapper wrapper, string valueName)
{
if (wrapper.Exists())
{
object result = wrapper.GetValue(valueName);
// RegistryKey.GetValue returns null if the value is not present
// and String.Empty if the value is present and no data is defined.
// We preserve this distinction, because a string property in the registry with
// no value really has an empty string for a value (which is a valid property value)
// rather than null for a value (which is an invalid property value)
if (result != null)
{
// Must be a value of string type
if (!(result is string))
{
InvalidToolsetDefinitionException.Throw("NonStringDataInRegistry", wrapper.Name + "@" + valueName);
}
return(result.ToString());
}
}
return(null);
}
/// <summary>
/// Provides an enumerator over the set of sub-toolset names available to a particular
/// toolsversion
/// </summary>
/// <param name="toolsVersion">The tools version.</param>
/// <returns>An enumeration of the sub-toolsets that belong to that toolsversion.</returns>
protected override IEnumerable <string> GetSubToolsetVersions(string toolsVersion)
{
RegistryKeyWrapper toolsVersionWrapper = null;
try
{
try
{
toolsVersionWrapper = _msbuildRegistryWrapper.OpenSubKey("ToolsVersions\\" + toolsVersion);
}
catch (RegistryException ex)
{
InvalidToolsetDefinitionException.Throw(ex, "RegistryReadError", ex.Source, ex.Message);
}
return(toolsVersionWrapper.GetSubKeyNames());
}
finally
{
if (toolsVersionWrapper != null)
{
toolsVersionWrapper.Dispose();
}
}
}
/// <summary>
/// Provides an enumerator over property definitions for a specified tools version
/// </summary>
/// <param name="toolsVersion">The tools version</param>
/// <returns>An enumeration of property definitions</returns>
protected override IEnumerable <ToolsetPropertyDefinition> GetPropertyDefinitions(string toolsVersion)
{
RegistryKeyWrapper toolsVersionWrapper = null;
try
{
try
{
toolsVersionWrapper = _msbuildRegistryWrapper.OpenSubKey("ToolsVersions\\" + toolsVersion);
}
catch (RegistryException ex)
{
InvalidToolsetDefinitionException.Throw(ex, "RegistryReadError", ex.Source, ex.Message);
}
foreach (string propertyName in toolsVersionWrapper.GetValueNames())
{
yield return(CreatePropertyFromRegistry(toolsVersionWrapper, propertyName));
}
}
finally
{
if (toolsVersionWrapper != null)
{
toolsVersionWrapper.Dispose();
}
}
}
/// <summary>
/// Given a registry location containing a property name and value, create the ToolsetPropertyDefinition that maps to it
/// </summary>
/// <param name="toolsetWrapper">Wrapper for the key that we're getting values from</param>
/// <param name="propertyName">The name of the property whose value we wish to generate a ToolsetPropertyDefinition for.</param>
/// <returns>A ToolsetPropertyDefinition instance corresponding to the property name requested.</returns>
private static ToolsetPropertyDefinition CreatePropertyFromRegistry(RegistryKeyWrapper toolsetWrapper, string propertyName)
{
string propertyValue = null;
if (propertyName != null && propertyName.Length == 0)
{
InvalidToolsetDefinitionException.Throw("PropertyNameInRegistryHasZeroLength", toolsetWrapper.Name);
}
try
{
propertyValue = GetValue(toolsetWrapper, propertyName);
}
catch (RegistryException ex)
{
InvalidToolsetDefinitionException.Throw(ex, "RegistryReadError", ex.Source, ex.Message);
}
// For the purposes of error location, use the registry path instead of a file name
IElementLocation location = new RegistryLocation(toolsetWrapper.Name + "@" + propertyName);
return(new ToolsetPropertyDefinition(propertyName, propertyValue, location));
}