internal SolutionWriter(AssemblyDefinition assembly, TargetPlatform targetPlatform, string targetDir, string solutionFileName, 
			Dictionary<ModuleDefinition, string> modulesProjectsRelativePaths, Dictionary<ModuleDefinition, Guid> modulesProjectsGuids,
            VisualStudioVersion visualStudioVersion, ILanguage language)
        {
            this.assembly = assembly;
            this.targetPlatform = targetPlatform;
            this.targetDir = targetDir;
            this.solutionFileName = solutionFileName;
            this.modulesProjectsRelativePaths = modulesProjectsRelativePaths;
            this.modulesProjectsGuids = modulesProjectsGuids;
            if (language is ICSharp)
            {
                this.languageGuid = new Guid(WinRTProjectBuilder.CSharpGUID);
            }
            else if (language is IVisualBasic)
            {
                this.languageGuid = new Guid(WinRTProjectBuilder.VisualBasicGUID);
            }
            else
            {
                throw new NotSupportedException();
            }

            this.visualStudioVersion = visualStudioVersion;
        }

        internal WinRTSolutionWriter(AssemblyDefinition assembly, TargetPlatform targetPlatform, string targetDir, string solutionFileName, 
			Dictionary<ModuleDefinition, string> modulesProjectsRelativePaths, Dictionary<ModuleDefinition, Guid> modulesProjectsGuids,
            VisualStudioVersion visualStudioVersion, ILanguage language, IEnumerable<string> platforms)
            : base(assembly, targetPlatform, targetDir, solutionFileName, modulesProjectsRelativePaths, modulesProjectsGuids, visualStudioVersion, language)
        {
            this.platforms = platforms;
        }

 public TestWinRTProjectBuilder(string assemblyPath, AssemblyDefinition assembly,
     Dictionary<ModuleDefinition, Mono.Collections.Generic.Collection<TypeDefinition>> userDefinedTypes,
     Dictionary<ModuleDefinition, Mono.Collections.Generic.Collection<Resource>> resources,
     string targetPath, ILanguage language, IDecompilationPreferences preferences, VisualStudioVersion visualStudioVersion, ProjectGenerationSettings projectGenerationSettings = null)
     : base(assemblyPath, assembly, userDefinedTypes, resources, targetPath, language, preferences, NoCacheAssemblyInfoService.Instance, visualStudioVersion, projectGenerationSettings)
 {
 }

 /// <summary>
 /// Initializes a new instance of the MockSolution class.
 /// </summary>
 public MockSolution(FileInfo solutionFile, IList<ISolutionProjectInfo> projectListe, string rawContent, VisualStudioVersion version)
 {
     SolutionFile = solutionFile;
     ProjectListe = projectListe;
     RawContent = rawContent;
     Version = version;
 }

 private static string GetVersionKey(VisualStudioVersion visualStudioVersion)
 {
     if (visualStudioVersion == VisualStudioVersion.VS2012) {
         return "11.0";
     }
     return "10.0";
 }

 public SaveSolutionCommand(ISettings settings, string solutionFileName, VisualStudioVersion visualStudioVersion, SolutionViewModel solution)
 {
     _settings = settings;
     _solutionFileName = solutionFileName;
     _visualStudioVersion = visualStudioVersion;
     _solution = solution;
 }

 private static string GetVstuBridgeAssembly(VisualStudioVersion version)
 {
   try
   {
     string vsTargetYear = string.Empty;
     switch (version)
     {
       case VisualStudioVersion.VisualStudio2010:
         vsTargetYear = "2010";
         break;
       case VisualStudioVersion.VisualStudio2012:
         vsTargetYear = "2012";
         break;
       case VisualStudioVersion.VisualStudio2013:
         vsTargetYear = "2013";
         break;
       case VisualStudioVersion.VisualStudio2015:
         vsTargetYear = "2015";
         break;
     }
     return UnityVSSupport.GetVstuBridgePathFromRegistry(vsTargetYear, true) ?? UnityVSSupport.GetVstuBridgePathFromRegistry(vsTargetYear, false);
   }
   catch (Exception ex)
   {
     return (string) null;
   }
 }

 /// <summary>
 /// Copies settings from a Visual Studio installation to Sql Server Management Studio.
 /// </summary>
 /// <param name="vsVersion">Represents the version of Visual Studio from which we will read the settings.</param>
 /// <param name="sqlVersion">Represents the version of SSMS which will receive the settings.</param>
 public void CopyVSToSql(VisualStudioVersion vsVersion, SqlStudioVersion sqlVersion)
 {
     string vsRegKeyPath = string.Format(_vsRegKeyFormat, _versionStrings[Enum.GetName(typeof(VisualStudioVersion), vsVersion)]);
     string sqlRegKeyPath = string.Format(_sqlRegKeyFormat, _versionStrings[Enum.GetName(typeof(SqlStudioVersion), sqlVersion)]);
     CreateMappingsFromVisualStudioToSql();
     Copy(vsRegKeyPath, sqlRegKeyPath);
 }

 public MainViewModel(ILogger logger)
 {
     VisualStudioVersions = Enum.GetValues(typeof(VisualStudioVersion)).Cast<VisualStudioVersion>().ToArray();
     _selectedVisualStudioVersion = VisualStudioVersion.VisualStudio2015;
     _logger = logger;
     _missingProjects = new ObservableCollection<FileInfo>();
 }

        internal static DTE Create(VisualStudioVersion visualStudioVersion)
        {
            var vsProgID = visualStudioVersion.ToDescription();
            var type = Type.GetTypeFromProgID(vsProgID, true);
            var obj = Activator.CreateInstance(type, true);

            return obj as DTE;
        }

 /// Dumps include directories for selected toolchain.
 public static void DumpSdkIncludes(VisualStudioVersion vsVersion =
     VisualStudioVersion.Latest)
 {
     Console.WriteLine("\nInclude search path (VS: {0}):", vsVersion);
     var includes = GetSystemIncludes(vsVersion);
     foreach (var include in includes)
         Console.WriteLine("\t{0}", include);
 }

 public WinRTProjectBuilder(string assemblyPath, string targetPath, ILanguage language,
     IDecompilationPreferences preferences, IFileGenerationNotifier notifier,
     IAssemblyInfoService assemblyInfoService, VisualStudioVersion visualStudioVersion = VisualStudioVersion.VS2010,
     ProjectGenerationSettings projectGenerationSettings = null)
     : base(assemblyPath, targetPath, language, null, preferences, notifier, assemblyInfoService, visualStudioVersion, projectGenerationSettings)
 {
     Initialize();
 }

 public static string GetVisualStudioExecutable(VisualStudioVersion visualStudioVersion)
 {
     var regPath = String.Format(@"Software\Microsoft\VisualStudio\{0}", GetVersionKey(visualStudioVersion));
     using (var hiveKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32))
     using (var key = hiveKey.OpenSubKey(regPath)) {
         var installPath = key.GetValue("InstallDir") as string;
         return Path.Combine(installPath, "devenv.exe");
     }
 }

 public static string GetVisualStudioExecutable(VisualStudioVersion visualStudioVersion)
 {
     var regPath = String.Format(@"Software\{0}Microsoft\VisualStudio\{1}",
         Environment.Is64BitOperatingSystem ? @"Wow6432Node\" : String.Empty,
         GetVersionKey(visualStudioVersion));
     using (var key = Registry.LocalMachine.OpenSubKey(regPath)) {
         var installPath = key.GetValue("InstallDir") as string;
         return Path.Combine(installPath, "devenv.exe");
     }
 }

 private static string GetVersionKey(VisualStudioVersion visualStudioVersion)
 {
     switch (visualStudioVersion) {
         case VisualStudioVersion.VS2012:
             return "11.0";
         case VisualStudioVersion.VS2013:
             return "12.0";
     }
     return "10.0";
 }

        public MainViewModel(ILogger logger)
        {
            VisualStudioVersions = Enum.GetValues(typeof(VisualStudioVersion)).Cast<VisualStudioVersion>().ToArray();
            TargetFrameworkVersions = Enum.GetValues(typeof(TargetFramework)).Cast<TargetFramework>().ToArray();
            _selectedVisualStudioVersion = VisualStudioVersion.VisualStudio2015;
            _selectedTargetFramework = TargetFramework.v4_5;
            _logger = logger;

            _nonUpdatedProjects = new ObservableCollection<ProjectWrapper>();

        }

        internal static string GetVisualStudioInstallationDir(VisualStudioVersion version)
        {
            string registryKeyString = String.Format(@"SOFTWARE{0}Microsoft\VisualStudio\{1}",
                Environment.Is64BitProcess ? @"\Wow6432Node\" : "\\",
                GetVersionNumber(version));

            using (var localMachineKey = Registry.LocalMachine.OpenSubKey(registryKeyString))
            {
                return localMachineKey.GetValue("InstallDir") as string;
            }
        }

        public SolutionWrapper(string solutionName, VisualStudioVersion visualStudioVersion, ILogger logger)
        {
            _solutionName = solutionName;
            _visualStudioVersion = visualStudioVersion;
            _logger = logger;
            _projectWrappers = new List<ProjectWrapper>();
            _dte = EnvDTEFactory.Create(visualStudioVersion);

            _nonUpdatedProjects = new ObservableCollection<ProjectWrapper>();
            NonUpdatedProjects = new ReadOnlyCollection<ProjectWrapper>(_nonUpdatedProjects);
        }

        /// <inheritdoc />
        public IVisualStudio GetVisualStudio(VisualStudioVersion version, bool launchIfNoActiveInstance, ILogger logger)
        {
            if (logger == null)
                throw new ArgumentNullException("logger");

            IVisualStudio visualStudio = GetActiveVisualStudio(version, logger);
            if (visualStudio == null && launchIfNoActiveInstance)
                visualStudio = LaunchVisualStudio(version, logger);

            return visualStudio;
        }

        /// <summary>
        /// Creates a wrapper for a particular DTE object.
        /// </summary>
        /// <param name="dte">The DTE object to wrap.</param>
        /// <param name="version">The version of Visual Studio represented by this object.</param>
        /// <param name="wasLaunched">True if Visual Studio was launched by our code, false if an existing instance was obtained.</param>
        /// <param name="logger">The logger.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="dte"/> or <paramref name="logger"/> is null.</exception>
        public VisualStudio(DTE dte, VisualStudioVersion version, bool wasLaunched, ILogger logger)
        {
            if (logger == null)
                throw new ArgumentNullException("logger");
            if (dte == null)
                throw new ArgumentNullException("dte");

            this.logger = logger;
            this.dte = dte;
            this.version = version;
            this.wasLaunched = wasLaunched;
        }