private void GenerateView(FrameworkVersion frameworkVersion)
{
//Source: http://johnhaller.com/useful-stuff/dot-net-portable-apps
switch (frameworkVersion)
{
case FrameworkVersion.NET35:
SetOsValue(WinXpGrid, WinXpText, Availability.Download);
SetOsValue(WinVistaGrid, WinVistaText, Availability.UpdatedTo);
SetOsValue(Win7Grid, Win7Text, Availability.Included);
SetOsValue(Win8Grid, Win8Text, Availability.MustEnable);
SetOsValue(Win10Grid, Win10Text, Availability.MustEnable);
break;
case FrameworkVersion.NET40:
SetOsValue(WinXpGrid, WinXpText, Availability.Download);
SetOsValue(WinVistaGrid, WinVistaText, Availability.Download);
SetOsValue(Win7Grid, Win7Text, Availability.Download);
SetOsValue(Win8Grid, Win8Text, Availability.Included);
SetOsValue(Win10Grid, Win10Text, Availability.MustEnable);
break;
case FrameworkVersion.NET45:
SetOsValue(WinXpGrid, WinXpText, Availability.NotAvailable);
SetOsValue(WinVistaGrid, WinVistaText, Availability.Download);
SetOsValue(Win7Grid, Win7Text, Availability.Download);
SetOsValue(Win8Grid, Win8Text, Availability.Included);
SetOsValue(Win10Grid, Win10Text, Availability.Included);
break;
default:
throw new ArgumentOutOfRangeException(nameof(frameworkVersion), frameworkVersion, null);
}
}
public static List <string> GetReferencedAssemblies(FrameworkVersion frameworkVersion)
{
switch (frameworkVersion)
{
case FrameworkVersion.Version11:
break;
case FrameworkVersion.Version20:
break;
case FrameworkVersion.Version30:
break;
case FrameworkVersion.Version35:
break;
case FrameworkVersion.Version40:
break;
}
List <string> collection = new List <string>();
//string[] list = new string[] { "MicroSoft.VisualBasic.dll", "System.dll", "System.Data.dll", "System.xml.dll", "System.Windows.Forms.dll"};
//collection.AddRange(list);
//collection.Add(Path.GetFileName(typeof(CodeCompilerFactory).Assembly.Location));
//collection.Add(Path.GetFileName(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName));
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
{
collection.Add(asm.Location);
}
return(collection);
}
///<overloads>
/// Retrieves the service pack level for the specified .NET Framework or
/// Foundation Library.
///</overloads>
/// <summary>
/// Retrieves the service pack level for the specified .NET Framework
/// version.
/// </summary>
/// <param name="frameworkVersion">The .NET Framework whose service pack
/// level should be retrieved.</param>
/// <returns>An <see cref="Int32">integer</see> value representing
/// the service pack level for the specified .NET Framework version. If
/// the specified .NET Frameowrk version is not found, -1 is returned.
/// </returns>
public static int GetServicePackLevel(FrameworkVersion frameworkVersion)
{
int servicePackLevel = -1;
switch (frameworkVersion)
{
case FrameworkVersion.Fx10:
servicePackLevel = GetNetfx10SPLevel();
break;
case FrameworkVersion.Fx11:
servicePackLevel = GetNetfxSPLevel(Netfx11RegKeyName, NetfxStandrdSpxRegValueName);
break;
case FrameworkVersion.Fx20:
servicePackLevel = GetNetfxSPLevel(Netfx20RegKeyName, NetfxStandrdSpxRegValueName);
break;
case FrameworkVersion.Fx30:
servicePackLevel = GetNetfxSPLevel(Netfx30SpRegKeyName, NetfxStandrdSpxRegValueName);
break;
case FrameworkVersion.Fx35:
servicePackLevel = GetNetfxSPLevel(Netfx35RegKeyName, NetfxStandrdSpxRegValueName);
break;
default:
break;
}
return(servicePackLevel);
}
protected override string GetToolsVersionXml(FrameworkVersion frameworkVersion)
{
switch (frameworkVersion)
{
case FrameworkVersion.v4_8:
case FrameworkVersion.v4_7_2:
case FrameworkVersion.v4_7_1:
case FrameworkVersion.v4_7:
case FrameworkVersion.v4_6_2:
case FrameworkVersion.v4_6_1:
case FrameworkVersion.v4_6:
return("ToolsVersion=\"14.0\"");
case FrameworkVersion.v4_5_2:
return("ToolsVersion=\"12.0\"");
case FrameworkVersion.v4_5_1:
case FrameworkVersion.v4_5:
case FrameworkVersion.v4_0:
case FrameworkVersion.v3_5:
return("ToolsVersion=\"4.0\"");
case FrameworkVersion.v3_0:
return("ToolsVersion=\"3.0\"");
default:
return("ToolsVersion=\"2.0\"");
}
}
public NetCodeComplier(NetDialect dialect, FrameworkVersion version, Target target)
: base(false)
{
string complieFile = "";
if (dialect == NetDialect.CSharp)
{
complieFile = "csc.exe";
}
else
{
complieFile = "vbc.exe";
}
CSCDictioncry = new Dictionary <FrameworkVersion, string>();
CSCDictioncry.Add(FrameworkVersion.Version11, Path.Combine(@"C:\Windows\Microsoft.NET\Framework\v1.0.3705\", complieFile));
CSCDictioncry.Add(FrameworkVersion.Version20, Path.Combine(@"C:\Windows\Microsoft.NET\Framework\v2.0.50727\", complieFile));
CSCDictioncry.Add(FrameworkVersion.Version30, Path.Combine(@"C:\Windows\Microsoft.NET\Framework\v3.0\", complieFile));
CSCDictioncry.Add(FrameworkVersion.Version35, Path.Combine(@"C:\Windows\Microsoft.NET\Framework\v3.5\", complieFile));
CSCDictioncry.Add(FrameworkVersion.Version40, Path.Combine(@"C:\Windows\Microsoft.NET\Framework\v4.0.30319\", complieFile));
this.Version = version;
this.Target = Target.Exe;
this.ComplieToolPath = CSCDictioncry[FrameworkVersion.VersionLatest];
this.ExecuteToolPath = "";
this.ILDeComplieToolPath = @"C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Bin\NETFX 4.0 Tools\ildasm.exe";
}
public static string DotNetVerName(FrameworkVersion Version)
{
switch (Version)
{
case FrameworkVersion.DotNet10:
return("v1.0.3705");
case FrameworkVersion.DotNet11:
return("v1.1.4322");
case FrameworkVersion.DotNet20:
return("v2.0.50727");
case FrameworkVersion.DotNet30:
return("v3.0");
case FrameworkVersion.DotNet35:
return("v3.5");
case FrameworkVersion.Lastest:
return(null);
default:
return("v4.0.30319");
}
}
///<overloads>
/// Retrieves the exact version number for the specified .NET Framework or
/// Foundation Library.
///</overloads>
/// <summary>
/// Retrieves the exact version number for the specified .NET Framework
/// version.
/// </summary>
/// <param name="frameworkVersion">The .NET Framework whose version should be
/// retrieved.</param>
/// <returns>A <see cref="Version">version</see> representing
/// the exact version number for the specified .NET Framework version.
/// If the specified .NET Frameowrk version is not found, a
/// <see cref="Version"/> is returned that represents a 0.0.0.0 version
/// number.
/// </returns>
public static Version GetExactVersion(FrameworkVersion frameworkVersion)
{
Version fxVersion = new Version();
switch (frameworkVersion)
{
case FrameworkVersion.Fx10:
fxVersion = GetNetfx10ExactVersion();
break;
case FrameworkVersion.Fx11:
fxVersion = GetNetfx11ExactVersion();
break;
case FrameworkVersion.Fx20:
fxVersion = GetNetfx20ExactVersion();
break;
case FrameworkVersion.Fx30:
fxVersion = GetNetfxExactVersion(Netfx30RegKeyName, NetfxStandardVersionRegValueName);
break;
case FrameworkVersion.Fx35:
fxVersion = GetNetfxExactVersion(Netfx35RegKeyName, NetfxStandardVersionRegValueName);
break;
default:
break;
}
return(fxVersion);
}
public Framework this[FrameworkVersion version]
{
get
{
return new Framework(version);
}
}
/// <summary>
/// Determines if the version of ASP.NET is registered with Internet
/// Information Services (IIS) on the local computer.
/// </summary>
/// <param name="frameworkVersion">One of the
/// <see cref="FrameworkVersion"/> values.</param>
/// <returns><see langword="true"/> if the specified ASP.NET version
/// is registered; otherwise <see langword="false"/>.</returns>
public static bool IsAspNetRegistered(FrameworkVersion frameworkVersion)
{
bool ret = false;
switch (frameworkVersion)
{
case FrameworkVersion.Fx10:
ret = IsAspNet10Registered();
break;
case FrameworkVersion.Fx11:
ret = IsAspNet11Registered();
break;
case FrameworkVersion.Fx20:
case FrameworkVersion.Fx30:
case FrameworkVersion.Fx35:
ret = IsAspNet20Registered();
break;
default:
break;
}
return(ret);
}
public static string GetRoot(FrameworkVersion v)
{
switch (v)
{
case FrameworkVersion.NET_1_0:
return(Root_1_0);
case FrameworkVersion.NET_1_1:
return(Root_1_1);
case FrameworkVersion.NET_BETA2:
return(Root_Beta2);
case FrameworkVersion.NET_2_0:
return(Root_2_0);
case FrameworkVersion.NET_3_0:
return(Root_3_0);
case FrameworkVersion.NET_3_5:
return(Root_3_5);
default:
throw new ArgumentOutOfRangeException("v");
}
}
public UpdateManager(string urlOrPath,
string applicationName,
FrameworkVersion appFrameworkVersion,
string rootDirectory = null,
IFileDownloader urlDownloader = null)
{
Contract.Requires(!String.IsNullOrEmpty(urlOrPath));
Contract.Requires(!String.IsNullOrEmpty(applicationName));
updateUrlOrPath = urlOrPath;
this.applicationName = applicationName;
this.appFrameworkVersion = appFrameworkVersion;
this.urlDownloader = urlDownloader ?? new FileDownloader();
if (rootDirectory != null)
{
this.rootAppDirectory = Path.Combine(rootDirectory, applicationName);
return;
}
// Determine the rootAppDirectory in such a way so that Portable
// Apps are more likely to work
var entry = Assembly.GetEntryAssembly();
if (entry != null)
{
rootDirectory = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(entry.Location), "..", ".."));
}
this.rootAppDirectory = Path.Combine(rootDirectory ?? getLocalAppDataDirectory(), applicationName);
}
/// <summary>
/// Returns <see langword="true" /> if the <paramref name="frameworkVersion"/> is supported by the current system/runtime.
/// </summary>
public static bool IsVersionSupported(FrameworkVersion frameworkVersion)
{
if (frameworkVersion >= FrameworkVersion.Net_4_6)
{
return(s_isNet_4_6_Supported.Value);
}
if (frameworkVersion >= FrameworkVersion.Net_4_5_2)
{
return(s_isNet_4_5_2_Supported.Value);
}
if (frameworkVersion >= FrameworkVersion.Net_4_5_1)
{
return(s_isNet_4_5_1_Supported.Value);
}
if (frameworkVersion >= FrameworkVersion.Net_4_5)
{
return(s_isNet_4_5_Supported.Value);
}
if (frameworkVersion == FrameworkVersion.Net_4_0)
{
return(s_isNet_4_0_Supported.Value);
}
throw new ArgumentException(string.Format("'{0}' is not a valid FrameworkVersion.", frameworkVersion));
}
/// <summary>
/// Tries to embed the Fakes data collector settings for the given run settings.
/// </summary>
/// <param name="runSettings">runsettings</param>
/// <param name="sources">test sources</param>
/// <returns>true if runSettings was modified; false otherwise.</returns>
private static bool TryAddFakesDataCollectorSettings(
XmlDocument runSettings,
IEnumerable <string> sources,
FrameworkVersion framework)
{
// A new Fakes Congigurator API makes the decision to add the right datacollector uri to the configuration
// There now exist two data collector URIs to support two different scenarios. The new scenario involves
// using the CLRIE profiler, and the old involves using the Intellitrace profiler (which isn't supported in
// .NET Core scenarios). The old API still exists for fallback measures.
var crossPlatformConfigurator = TryGetFakesCrossPlatformDataCollectorConfigurator();
if (crossPlatformConfigurator != null)
{
var sourceTFMMap = CreateDictionary(sources, framework);
var fakesSettings = crossPlatformConfigurator(sourceTFMMap);
// if no fakes, return settings unchanged
if (fakesSettings == null)
{
return(false);
}
InsertOrReplaceFakesDataCollectorNode(runSettings, fakesSettings);
return(true);
}
return(AddFallbackFakesSettings(runSettings, sources, framework));
}
/// <summary>
/// Gets the path to the Mscorwks.DLL file.
/// </summary>
/// <param name="frameworkVersion"></param>
/// <returns>The fully qualified path to the Mscorwks.DLL for the specified .NET
/// Framework.
/// </returns>
private static string GetMscorwksPath(FrameworkVersion frameworkVersion)
{
string ret = String.Empty;
switch (frameworkVersion)
{
case FrameworkVersion.Fx10:
ret = Path.Combine(Path.Combine(GetInstallRoot(), Netfx10VersionString), NetfxMscorwks);
break;
case FrameworkVersion.Fx11:
ret = Path.Combine(Path.Combine(GetInstallRoot(), Netfx11VersionString), NetfxMscorwks);
break;
case FrameworkVersion.Fx20:
case FrameworkVersion.Fx30:
case FrameworkVersion.Fx35:
ret = Path.Combine(Path.Combine(GetInstallRoot(), Netfx20VersionString), NetfxMscorwks);
break;
default:
break;
}
return(ret);
}
public static List<string> GetReferencedAssemblies(FrameworkVersion frameworkVersion)
{
switch (frameworkVersion)
{
case FrameworkVersion.Version11:
break;
case FrameworkVersion.Version20:
break;
case FrameworkVersion.Version30:
break;
case FrameworkVersion.Version35:
break;
case FrameworkVersion.Version40:
break;
}
List<string> collection = new List<string>();
//string[] list = new string[] { "MicroSoft.VisualBasic.dll", "System.dll", "System.Data.dll", "System.xml.dll", "System.Windows.Forms.dll"};
//collection.AddRange(list);
//collection.Add(Path.GetFileName(typeof(CodeCompilerFactory).Assembly.Location));
//collection.Add(Path.GetFileName(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName));
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
{
collection.Add(asm.Location);
}
return collection;
}
/// <summary>
/// Retrieves the service pack level for the specified .NET Framework
/// version.
/// </summary>
/// <param name="frameworkVersion">One of the
/// <see cref="FrameworkVersion"/> values.</param>
/// <returns>An <see cref="Int32">integer</see> value representing
/// the service pack level for the specified .NET Framework version. If
/// the specified .NET Frameowrk version is not found, -1 is returned.
/// </returns>
public static int GetServicePackLevel(FrameworkVersion frameworkVersion)
{
int servicePackLevel = -1;
switch (frameworkVersion)
{
case FrameworkVersion.Fx10:
servicePackLevel = GetNetfx10SPLevel();
break;
case FrameworkVersion.Fx11:
servicePackLevel = GetNetfx11SPLevel();
break;
case FrameworkVersion.Fx20:
servicePackLevel = GetNetfx20SPLevel();
break;
case FrameworkVersion.Fx30:
servicePackLevel = GetNetfx30SPLevel();
break;
case FrameworkVersion.Fx35:
servicePackLevel = GetNetfx35SPLevel();
break;
default:
break;
}
return(servicePackLevel);
}
/// <summary>
/// Retrieves the exact version number for the specified .NET Framework
/// version.
/// </summary>
/// <param name="frameworkVersion">One of the
/// <see cref="FrameworkVersion"/> values.</param>
/// <returns>A <see cref="Version">version</see> representing
/// the exact version number for the specified .NET Framework version.
/// If the specified .NET Frameowrk version is not found, a
/// <see cref="Version"/> is returned that represents a 0.0.0.0 version
/// number.
/// </returns>
public static Version GetExactVersion(FrameworkVersion frameworkVersion)
{
Version fxVersion = new Version();
switch (frameworkVersion)
{
case FrameworkVersion.Fx10:
fxVersion = GetNetfx10ExactVersion();
break;
case FrameworkVersion.Fx11:
fxVersion = GetNetfx11ExactVersion();
break;
case FrameworkVersion.Fx20:
fxVersion = GetNetfx20ExactVersion();
break;
case FrameworkVersion.Fx30:
fxVersion = GetNetfx30ExactVersion();
break;
case FrameworkVersion.Fx35:
fxVersion = GetNetfx35ExactVersion();
break;
default:
break;
}
return(fxVersion);
}
/// <summary>
/// Determines if the specified .NET Framework version is installed
/// on the local computer.
/// </summary>
/// <param name="frameworkVersion">One of the
/// <see cref="FrameworkVersion"/> values.</param>
/// <returns><see langword="true"/> if the specified .NET Framework
/// version is installed; otherwise <see langword="false"/>.</returns>
public static bool IsInstalled(FrameworkVersion frameworkVersion)
{
bool ret = false;
switch (frameworkVersion)
{
case FrameworkVersion.Fx20:
ret = IsNetfx20Installed();
break;
case FrameworkVersion.Fx30:
ret = IsNetfx30Installed();
break;
case FrameworkVersion.Fx35:
ret = IsNetfx35Installed();
break;
case FrameworkVersion.Fx35Sp1:
ret = IsNetfx35SP1Installed();
break;
default:
break;
}
return(ret);
}
public static UpdateInfo Create(ReleaseEntry currentVersion, IEnumerable<ReleaseEntry> availableReleases, string packageDirectory, FrameworkVersion appFrameworkVersion)
{
Contract.Requires(availableReleases != null);
Contract.Requires(!String.IsNullOrEmpty(packageDirectory));
var latestFull = availableReleases.MaxBy(x => x.Version).FirstOrDefault(x => !x.IsDelta);
if (latestFull == null) {
throw new Exception("There should always be at least one full release");
}
if (currentVersion == null) {
return new UpdateInfo(currentVersion, new[] { latestFull }, packageDirectory, appFrameworkVersion);
}
if (currentVersion.Version == latestFull.Version) {
return new UpdateInfo(currentVersion, Enumerable.Empty<ReleaseEntry>(), packageDirectory, appFrameworkVersion);
}
var newerThanUs = availableReleases.Where(x => x.Version > currentVersion.Version)
.OrderBy(v => v.Version);
var deltasSize = newerThanUs.Where(x => x.IsDelta).Sum(x => x.Filesize);
return (deltasSize < latestFull.Filesize && deltasSize > 0)
? new UpdateInfo(currentVersion, newerThanUs.Where(x => x.IsDelta).ToArray(), packageDirectory, appFrameworkVersion)
: new UpdateInfo(currentVersion, new[] { latestFull }, packageDirectory, appFrameworkVersion);
}
public Framework this[FrameworkVersion version]
{
get
{
return(new Framework(version));
}
}
public UpdateManager(string urlOrPath,
string applicationName,
FrameworkVersion appFrameworkVersion,
string rootDirectory = null,
IFileDownloader urlDownloader = null)
{
Contract.Requires(!String.IsNullOrEmpty(urlOrPath));
Contract.Requires(!String.IsNullOrEmpty(applicationName));
updateUrlOrPath = urlOrPath;
this.applicationName = applicationName;
this.appFrameworkVersion = appFrameworkVersion;
this.urlDownloader = urlDownloader ?? new FileDownloader();
if (rootDirectory != null) {
this.rootAppDirectory = Path.Combine(rootDirectory, applicationName);
return;
}
// Determine the rootAppDirectory in such a way so that Portable
// Apps are more likely to work
var entry = Assembly.GetEntryAssembly();
if (entry != null) {
rootDirectory = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(entry.Location), "..", ".."));
}
this.rootAppDirectory = Path.Combine(rootDirectory ?? getLocalAppDataDirectory(), applicationName);
}
private FrameworkVersion GetFrameworkVersionInternal(ModuleDefinition module, TargetPlatform targetPlatform)
{
FrameworkVersion frameworkVersion = this.GetFrameworkVersionFromTargetFrameworkAttribute(module.Assembly.TargetFrameworkAttributeValue, targetPlatform);
if (frameworkVersion != this.DefaultFrameworkVersion)
{
return(frameworkVersion);
}
string moduleLocation = module.FullyQualifiedName ?? module.FilePath;
if (SystemInformation.IsInNetCoreSharedAssembliesDir(moduleLocation))
{
return(this.GetFrameworkVersionThroughModuleLocation(module, targetPlatform));
}
frameworkVersion = this.GetFrameworkVersionFromSystemRuntimeVersion(module, targetPlatform);
if (frameworkVersion != this.DefaultFrameworkVersion)
{
return(frameworkVersion);
}
if (this.targetPlatformResolver.ResolverCache.AssemblyPathToFrameworkName.ContainsKey(moduleLocation))
{
return(this.GetFrameworkVersionFromFrameworkName(this.targetPlatformResolver.ResolverCache.AssemblyPathToFrameworkName[moduleLocation], targetPlatform));
}
else
{
Task <FrameworkVersion> frameworkVersionTask = Task.Factory.StartNew(() => { return(this.GetFrameworkVersionFromDepsJson(moduleLocation, targetPlatform)); });
frameworkVersionTask.Wait();
return(frameworkVersionTask.Result);
}
}
protected bool TryDetectFramework4Upgrade(ModuleDefinition module, out FrameworkVersion frameworkVersion)
{
frameworkVersion = FrameworkVersion.Unknown;
if (module.IsMain)
{
FrameworkName frameworkName;
if (TryGetTargetFrameworkName(module.Assembly.TargetFrameworkAttributeValue, out frameworkName) &&
TryParseFramework4Name(frameworkName.Version.ToString(), out frameworkVersion))
{
return(true);
}
else
{
bool isInFrameworkDir;
if (IsFramework4Assembly(module.Assembly, out isInFrameworkDir))
{
if (isInFrameworkDir)
{
frameworkVersion = Framework4VersionResolver.GetInstalledFramework4Version();
}
else
{
frameworkVersion = Framework4VersionResolver.GetFrameworkVersionByFileVersion(module.Assembly.MainModule.FilePath);
}
if (frameworkVersion != FrameworkVersion.Unknown)
{
return(true);
}
}
}
}
return(false);
}
protected virtual void AddModulesFrameworkVersions(AssemblyInfo assemblyInfo, AssemblyDefinition assembly, IFrameworkResolver frameworkResolver)
{
foreach (ModuleDefinition module in assembly.Modules)
{
FrameworkVersion frameworkVersion = GetFrameworkVersionForModule(module, frameworkResolver);
assemblyInfo.ModulesFrameworkVersions.Add(module, frameworkVersion);
}
}
public Target(string rootPath, FrameworkVersion version, RuntimeIdentifier runtimeIdentifier, ProgramMetadata metadata, IConsole console)
{
_rootPath = rootPath;
_version = version;
_runtimeIdentifier = runtimeIdentifier;
_metadata = metadata;
_console = console;
}
public ShimmerConfiguration(string applicationName, string url, string projectName = null, FrameworkVersion frameworkVersion = FrameworkVersion.Net45)
{
this.projectName = projectName;
ApplicationName = applicationName;
FrameworkVersion = frameworkVersion;
UrlOrPath = !SystemInspector.Debugger.IsAttached ? CompleteUrl(url) : UrlOrDebugPath(url);
}
public string PathToBuildTool(IPackageTree packageTree, FrameworkVersion version)
{
var path = Path.Combine(packageTree.Root.CurrentDirectory.FullName, "buildengines");
path = Path.Combine(path, "Phantom");
path = Path.Combine(path, "Phantom.exe");
return new FileInfo(path).FullName;
}
public void DetectFrameworkVersion(string packageName, FrameworkVersion expected)
{
var path = IntegrationTestHelper.GetPath("fixtures", packageName);
var zip = new ZipPackage(path);
Assert.Equal(expected, zip.DetectFrameworkVersion());
}
public void DetectFrameworkVersion(string packageName, FrameworkVersion expected)
{
var path = IntegrationTestHelper.GetPath("fixtures", packageName);
var zip = new ZipPackage(path);
Assert.Equal(expected, zip.DetectFrameworkVersion());
}
public static void PopulateWithFrameworkSymbols(HoistedIdentifierMap globalIdentifierMap, TypeIdentifierMap typeIdentifierMap)
{
FrameworkVersion frameworkVersion = FrameworkProvider.GetFrameworkVersion0();
PopulateWithTypes(typeIdentifierMap, frameworkVersion);
PopulateWithFunctions(globalIdentifierMap, typeIdentifierMap, frameworkVersion);
PopulateWithConstants(globalIdentifierMap, typeIdentifierMap, frameworkVersion);
}
private bool TryParseFramework4Name(string frameworkVersionAsString, out FrameworkVersion frameworkVersion)
{
frameworkVersion = FrameworkVersion.Unknown;
switch (frameworkVersionAsString)
{
case "4.0":
frameworkVersion = FrameworkVersion.v4_0;
break;
case "4.5":
frameworkVersion = FrameworkVersion.v4_5;
break;
case "4.5.1":
frameworkVersion = FrameworkVersion.v4_5_1;
break;
case "4.5.2":
frameworkVersion = FrameworkVersion.v4_5_2;
break;
case "4.6":
frameworkVersion = FrameworkVersion.v4_6;
break;
case "4.6.1":
frameworkVersion = FrameworkVersion.v4_6_1;
break;
case "4.6.2":
frameworkVersion = FrameworkVersion.v4_6_2;
break;
case "4.7":
frameworkVersion = FrameworkVersion.v4_7;
break;
case "4.7.1":
frameworkVersion = FrameworkVersion.v4_7_1;
break;
/* AGPL */
case "4.7.2":
frameworkVersion = FrameworkVersion.v4_7_2;
break;
case "4.8":
frameworkVersion = FrameworkVersion.v4_8;
break;
/* End AGPL */
default:
return(false);
}
return(true);
}
public string PathToBuildTool(IPackageTree packageTree, FrameworkVersion version)
{
var path = Path.Combine(packageTree.Root.CurrentDirectory.FullName, "buildengines");
path = Path.Combine(path, "Phantom");
path = Path.Combine(path, "Phantom.exe");
return(new FileInfo(path).FullName);
}
public string CommandLineArguments(string pathToBuildFile, BuildEngine buildEngine, IPackageTree packageTree, FrameworkVersion version)
{
Console.WriteLine(pathToBuildFile);
Console.WriteLine(buildEngine);
Console.WriteLine(packageTree);
Console.WriteLine(version);
return string.Empty;
}
protected UpdateInfo(ReleaseEntry currentlyInstalledVersion, IEnumerable <ReleaseEntry> releasesToApply, string packageDirectory, FrameworkVersion appFrameworkVersion)
{
// NB: When bootstrapping, CurrentlyInstalledVersion is null!
CurrentlyInstalledVersion = currentlyInstalledVersion;
ReleasesToApply = releasesToApply ?? Enumerable.Empty <ReleaseEntry>();
FutureReleaseEntry = ReleasesToApply.MaxBy(x => x.Version).FirstOrDefault();
AppFrameworkVersion = appFrameworkVersion;
this.packageDirectory = packageDirectory;
}
protected UpdateInfo(ReleaseEntry currentlyInstalledVersion, IEnumerable<ReleaseEntry> releasesToApply, string packageDirectory, FrameworkVersion appFrameworkVersion)
{
// NB: When bootstrapping, CurrentlyInstalledVersion is null!
CurrentlyInstalledVersion = currentlyInstalledVersion;
ReleasesToApply = releasesToApply ?? Enumerable.Empty<ReleaseEntry>();
FutureReleaseEntry = ReleasesToApply.MaxBy(x => x.Version).FirstOrDefault();
AppFrameworkVersion = appFrameworkVersion;
this.packageDirectory = packageDirectory;
}
protected override string GetTargetFrameworkVersion(ModuleDefinition module)
{
FrameworkVersion frameworkVersion = this.assemblyInfo.ModulesFrameworkVersions[module];
if (frameworkVersion == FrameworkVersion.Unknown || frameworkVersion == FrameworkVersion.Silverlight)
{
return(null);
}
return(frameworkVersion.ToString(includeVersionSign: false));
}
/// <summary>
/// Initializes the specified target.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="args">The args.</param>
public void Initialize(LogTargets target, string[] args)
{
CacheTargets(GetType().Assembly);
CacheNodeTypes(GetType().Assembly);
CacheVersion();
m_CommandLine = new CommandLineCollection(args);
string logFile = null;
if (m_CommandLine.WasPassed("log"))
{
logFile = m_CommandLine["log"];
if (logFile != null && logFile.Length == 0)
{
logFile = "Prebuild.log";
}
}
else
{
target = target & ~LogTargets.File; //dont output to a file
}
m_Log = new Log(target, logFile);
LogBanner();
m_CurrentWorkingDirectory = new CurrentDirectory();
m_Target = m_CommandLine["target"];
m_Conditionals = m_CommandLine["conditionals"];
if (m_CommandLine["targetframework"] != null)
{
m_TargetFramework = (FrameworkVersion)Enum.Parse(typeof(FrameworkVersion), m_CommandLine["targetframework"]);
cmdlineTargetFramework = true;
}
m_Clean = m_CommandLine["clean"];
string removeDirs = m_CommandLine["removedir"];
if (removeDirs != null && removeDirs.Length == 0)
{
m_RemoveDirectories = removeDirs.Split('|');
}
string flags = m_CommandLine["allowedgroups"]; //allows filtering by specifying a pipe-delimited list of groups to include
if (flags != null && flags.Length == 0)
{
m_ProjectGroups = flags.Split('|');
}
m_PauseAfterFinish = m_CommandLine.WasPassed("pause");
LoadSchema();
}
public string GetFrameworkVersionForBuildTool(FrameworkVersion version)
{
switch (version)
{
case FrameworkVersion.FrameworkVersion2:
return "2.0";
case FrameworkVersion.FrameworkVersion35:
return "3.5";
}
throw new InvalidEnumArgumentException("Invalid Framework Version", (int)version, typeof(FrameworkVersion));
}
public string GetFrameworkVersionForBuildTool(FrameworkVersion version)
{
switch (version)
{
case FrameworkVersion.FrameworkVersion2:
return "v2.0";
case FrameworkVersion.FrameworkVersion35:
return "v3.5";
default:
throw new ArgumentException(string.Format("Unknown framework Version: {0}", version));
}
}
protected virtual string GetTargetFrameworkVersion(ModuleDefinition module)
{
//TODO: handle Silverlight/WinPhone projects
FrameworkVersion frameworkVersion = this.assemblyInfo.ModulesFrameworkVersions[module];
if (frameworkVersion == FrameworkVersion.Unknown || frameworkVersion == FrameworkVersion.Silverlight)
{
return(null);
}
return(frameworkVersion.ToString(includeVersionSign: true));
}
private static bool AddFallbackFakesSettings(
XmlDocument runSettings,
IEnumerable <string> sources,
FrameworkVersion framework)
{
// The fallback settings is for the old implementation of fakes
// that only supports .Net Framework versions
if (framework != FrameworkVersion.Framework35 &&
framework != FrameworkVersion.Framework40 &&
framework != FrameworkVersion.Framework45)
{
return(false);
}
Func <IEnumerable <string>, string> netFrameworkConfigurator = TryGetNetFrameworkFakesDataCollectorConfigurator();
if (netFrameworkConfigurator == null)
{
return(false);
}
// if no fakes, return settings unchanged
var fakesConfiguration = netFrameworkConfigurator(sources);
if (fakesConfiguration == null)
{
return(false);
}
// integrate fakes settings in configuration
// if the settings don't have any data collector settings, populate with empty settings
EnsureSettingsNode(runSettings, new DataCollectionRunSettings());
// embed fakes settings
var fakesSettings = CreateFakesDataCollectorSettings();
var doc = new XmlDocument();
using (var xmlReader = XmlReader.Create(
new StringReader(fakesConfiguration),
new XmlReaderSettings()
{
CloseInput = true
}))
{
doc.Load(xmlReader);
}
fakesSettings.Configuration = doc.DocumentElement;
XmlRunSettingsUtilities.InsertDataCollectorsNode(runSettings.CreateNavigator(), fakesSettings);
return(true);
}
public BuildEngine(IBuildTool buildTool, string buildFile, FrameworkVersion version, IDependencyDispatcher dependencyDispatcher)
{
BuildTool = buildTool;
BuildFile = buildFile;
Version = version;
Dependencies = new List<Dependency>();
Exclusions = new List<string>();
this.dependencyDispatcher = dependencyDispatcher;
Modes = new Dictionary<string, IModeSettings>();
var defaultMode = new ModeSettings( DefaultModeName );
Modes.Add( DefaultModeName, defaultMode );
CurrentModeSettings = defaultMode;
}
public MethodWriter(GenerationManifest artifacts, FrameworkVersion version, MethodInfoWrapper methodInfo)
: base(artifacts, version, methodInfo)
{
this._methodInfo = methodInfo;
// true when this is an Async method and the unity version is present
this._unityVersionOfAsyncExists = NDocUtilities.FindDocumentationUnityAsync(Artifacts.NDocForPlatform("unity"), methodInfo) != null;
// refer to asynchronous versions if the synchronous version doesn't exist but the async version does
this._referAsyncAlternativeUnity = (NDocUtilities.FindDocumentationUnityAsyncAlternative(Artifacts.NDocForPlatform("unity"), methodInfo) != null) &&
(Artifacts.NDocForPlatform("unity") != null) &&
(NDocUtilities.FindDocumentation(Artifacts.NDocForPlatform("unity"), methodInfo) == null);
this._referAsyncAlternativePCL = (NDocUtilities.FindDocumentationPCLAsyncAlternative(Artifacts.NDocForPlatform("pcl"), methodInfo) != null) &&
(Artifacts.NDocForPlatform("pcl") != null) &&
(NDocUtilities.FindDocumentation(Artifacts.NDocForPlatform("pcl"), methodInfo) == null);
}
private GeneratorProjectInfo(string target, string @out, IProjectGenerationError error)
{
this.Target = target;
this.Out = @out;
this.Language = CSharp.GetLanguage(CSharpVersion.V4);
this.VisualStudioVersion = VisualStudioVersion.VS2013;
this.frameworkVersion = FrameworkVersion.v4_5_2;
this.IsDefaultFrameworkVersion = true;
this.AddDocumentation = true;
this.RenameInvalidMembers = true;
this.Error = error;
}
public string CommandLineArguments(string pathToBuildFile, BuildEngine buildEngine, IPackageTree packageTree,
FrameworkVersion version)
{
var cmdLine = new StringBuilder();
cmdLine.AppendFormat(
"{0} /p:OutputPath=\"{1}\" /p:TargetFrameworkVersion={2} /p:NoWarn=1591 /consoleloggerparameters:Summary",
pathToBuildFile.QuotePath(), Path.Combine(packageTree.WorkingDirectory.FullName, buildEngine.BuildRootDirectory),
GetFrameworkVersionForBuildTool(version));
AppendTasks(buildEngine, cmdLine);
AppendParameters(buildEngine, cmdLine);
return cmdLine.ToString();
}
public UpdateManager(string urlOrPath,
string applicationName,
FrameworkVersion appFrameworkVersion,
string rootDirectory = null,
IFileDownloader urlDownloader = null)
{
Contract.Requires(!String.IsNullOrEmpty(urlOrPath));
Contract.Requires(!String.IsNullOrEmpty(applicationName));
updateUrlOrPath = urlOrPath;
this.applicationName = applicationName;
this.appFrameworkVersion = appFrameworkVersion;
this.rootAppDirectory = Path.Combine(rootDirectory ?? getLocalAppDataDirectory(), applicationName);
this.urlDownloader = urlDownloader ?? new FileDownloader();
}
public static bool NativeImageExists(string fileName, FrameworkVersion version, FrameworkArch arch)
{
string assymblyFolder = Path.Combine(Environment.ExpandEnvironmentVariables("%WInDir%"), "assembly");
string nativeImageFileName = Path.GetFileNameWithoutExtension(fileName) + ".ni" + Path.GetExtension(fileName);
string nativeImageFolderName = "NativeImages";
if (FrameworkVersion.NetFX20 == version)
{
nativeImageFolderName += "_v2.0.50727";
}
else if (FrameworkVersion.NetFX40 == version)
{
// version number will keep changing up untill 4.0 RTM
nativeImageFolderName += "_v4.0.*";
}
if (FrameworkArch.x86 == arch)
{
nativeImageFolderName += "_32";
}
else if (FrameworkArch.x64 == arch)
{
nativeImageFolderName += "_64";
}
// search for all directories matching the widcard to suppor 4.0
DirectoryInfo directory = new DirectoryInfo(assymblyFolder);
DirectoryInfo[] nativeImageDirectoryList = directory.GetDirectories(nativeImageFolderName);
if (null == nativeImageDirectoryList || nativeImageDirectoryList.Length < 1)
{
return false;
}
FileInfo[] nativeImageFileList = nativeImageDirectoryList[0].GetFiles(nativeImageFileName, SearchOption.AllDirectories);
if (null == nativeImageFileList || nativeImageFileList.Length < 1)
{
return false;
}
else
{
return true;
}
}
public UpdateManager(string urlOrPath,
string applicationName,
FrameworkVersion appFrameworkVersion,
string rootDirectory = null,
IFileSystemFactory fileSystem = null,
IUrlDownloader urlDownloader = null)
{
Contract.Requires(!String.IsNullOrEmpty(urlOrPath));
Contract.Requires(!String.IsNullOrEmpty(applicationName));
log = LogManager.GetLogger<UpdateManager>();
updateUrlOrPath = urlOrPath;
this.applicationName = applicationName;
this.appFrameworkVersion = appFrameworkVersion;
this.rootAppDirectory = Path.Combine(rootDirectory ?? getLocalAppDataDirectory(), applicationName);
this.fileSystem = fileSystem ?? AnonFileSystem.Default;
this.urlDownloader = urlDownloader ?? new DirectUrlDownloader(fileSystem);
}
public UpdateManager(string urlOrPath,
string applicationName,
FrameworkVersion appFrameworkVersion,
string rootDirectory = null,
IFileSystemFactory fileSystem = null,
IUrlDownloader urlDownloader = null)
{
Contract.Requires(!String.IsNullOrEmpty(urlOrPath));
Contract.Requires(!String.IsNullOrEmpty(applicationName));
// XXX: ALWAYS BE LOGGING
log = new WrappingFullLogger(new FileLogger(applicationName), typeof(UpdateManager));
updateUrlOrPath = urlOrPath;
this.applicationName = applicationName;
this.appFrameworkVersion = appFrameworkVersion;
this.rootAppDirectory = Path.Combine(rootDirectory ?? getLocalAppDataDirectory(), applicationName);
this.fileSystem = fileSystem ?? AnonFileSystem.Default;
this.urlDownloader = urlDownloader ?? new DirectUrlDownloader(fileSystem);
}
public string CommandLineArguments(string pathToBuildFile, BuildEngine buildEngine, IPackageTree packageTree, FrameworkVersion version)
{
return string.Format("{0} --rakefile {1} {2}{3}", Path.Combine(GetRubyDirectory(), "rake"), pathToBuildFile, GenerateParameters(buildEngine.Parameters), GenerateTasks(buildEngine.Tasks)).Trim();
}
/// <summary>
/// Parses the specified node.
/// </summary>
/// <param name="node">The node.</param>
public override void Parse(XmlNode node)
{
m_Name = Helper.AttributeValue(node, "name", m_Name);
m_Path = Helper.AttributeValue(node, "path", m_Path);
m_FilterGroups = Helper.AttributeValue(node, "filterGroups", m_FilterGroups);
m_Version = Helper.AttributeValue(node, "version", m_Version);
m_AppIcon = Helper.AttributeValue(node, "icon", m_AppIcon);
m_ApplicationManifest = Helper.AttributeValue(node, "appmanifest", m_ApplicationManifest);
m_ConfigFile = Helper.AttributeValue(node, "configFile", m_ConfigFile);
m_DesignerFolder = Helper.AttributeValue(node, "designerFolder", m_DesignerFolder);
m_AssemblyName = Helper.AttributeValue(node, "assemblyName", m_AssemblyName);
m_Language = Helper.AttributeValue(node, "language", m_Language);
m_Type = (ProjectType)Helper.EnumAttributeValue(node, "type", typeof(ProjectType), m_Type);
m_Runtime = (ClrRuntime)Helper.EnumAttributeValue(node, "runtime", typeof(ClrRuntime), m_Runtime);
if(m_useFramework)
m_Framework = (FrameworkVersion)Helper.EnumAttributeValue(node, "frameworkVersion", typeof(FrameworkVersion), m_Framework);
m_StartupObject = Helper.AttributeValue(node, "startupObject", m_StartupObject);
m_RootNamespace = Helper.AttributeValue(node, "rootNamespace", m_RootNamespace);
int hash = m_Name.GetHashCode();
Guid guidByHash = new Guid(hash, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
string guid = Helper.AttributeValue(node, "guid", guidByHash.ToString());
m_Guid = new Guid(guid);
m_GenerateAssemblyInfoFile = Helper.ParseBoolean(node, "generateAssemblyInfoFile", false);
m_DebugStartParameters = Helper.AttributeValue(node, "debugStartParameters", string.Empty);
if(string.IsNullOrEmpty(m_AssemblyName))
{
m_AssemblyName = m_Name;
}
if(string.IsNullOrEmpty(m_RootNamespace))
{
m_RootNamespace = m_Name;
}
m_FullPath = m_Path;
try
{
m_FullPath = Helper.ResolvePath(m_FullPath);
}
catch
{
throw new WarningException("Could not resolve Solution path: {0}", m_Path);
}
Kernel.Instance.CurrentWorkingDirectory.Push();
try
{
Helper.SetCurrentDir(m_FullPath);
if( node == null )
{
throw new ArgumentNullException("node");
}
foreach(XmlNode child in node.ChildNodes)
{
IDataNode dataNode = Kernel.Instance.ParseNode(child, this);
if(dataNode is ConfigurationNode)
{
HandleConfiguration((ConfigurationNode)dataNode);
}
else if(dataNode is ReferencePathNode)
{
m_ReferencePaths.Add((ReferencePathNode)dataNode);
}
else if(dataNode is ReferenceNode)
{
m_References.Add((ReferenceNode)dataNode);
}
else if(dataNode is AuthorNode)
{
m_Authors.Add((AuthorNode)dataNode);
}
else if(dataNode is FilesNode)
{
m_Files = (FilesNode)dataNode;
}
}
}
finally
{
Kernel.Instance.CurrentWorkingDirectory.Pop();
}
}
protected override string GetToolsVersionXml(FrameworkVersion frameworkVersion)
{
switch (frameworkVersion)
{
case FrameworkVersion.v3_5:
return "ToolsVersion=\"3.5\"";
case FrameworkVersion.v3_0:
return "ToolsVersion=\"3.0\"";
default:
return "ToolsVersion=\"2.0\"";
}
}
public Framework(FrameworkVersion version)
{
Version = version;
}
public string GetFrameworkVersionForBuildTool(FrameworkVersion version)
{
Console.WriteLine(version);
return "3.5";
}
public string CommandLineArguments(string pathToBuildFile, BuildEngine buildEngine, IPackageTree packageTree, FrameworkVersion version)
{
return string.Format(" -f:{0} {1}", pathToBuildFile, GenerateTasks(buildEngine.Tasks)).Trim();
}
public string GetFrameworkVersionForBuildTool(FrameworkVersion version)
{
return version.ToString();
}
/// <summary>
/// Initializes the specified target.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="args">The args.</param>
public void Initialize(LogTargets target, string[] args)
{
CacheTargets(GetType().Assembly);
CacheNodeTypes(GetType().Assembly);
CacheVersion();
m_CommandLine = new CommandLineCollection(args);
string logFile = null;
if(m_CommandLine.WasPassed("log"))
{
logFile = m_CommandLine["log"];
if(logFile != null && logFile.Length == 0)
{
logFile = "Prebuild.log";
}
}
else
{
target = target & ~LogTargets.File; //dont output to a file
}
m_Log = new Log(target, logFile);
LogBanner();
m_CurrentWorkingDirectory = new CurrentDirectory();
m_Target = m_CommandLine["target"];
m_TargetFramework = (FrameworkVersion)Enum.Parse (typeof (FrameworkVersion), m_CommandLine["targetframework"]);
m_Clean = m_CommandLine["clean"];
string removeDirs = m_CommandLine["removedir"];
if(removeDirs != null && removeDirs.Length == 0)
{
m_RemoveDirectories = removeDirs.Split('|');
}
string flags = m_CommandLine["allowedgroups"];//allows filtering by specifying a pipe-delimited list of groups to include
if(flags != null && flags.Length == 0)
{
m_ProjectGroups = flags.Split('|');
}
m_PauseAfterFinish = m_CommandLine.WasPassed("pause");
LoadSchema();
}
public string PathToBuildTool(IPackageTree packageTree, FrameworkVersion version)
{
Console.WriteLine(version);
return string.Empty;
}
public string PathToBuildTool(IPackageTree packageTree, FrameworkVersion version)
{
return Path.Combine(GetRubyDirectory(), "rake.bat");
}
public ConstructorWriter(GenerationManifest artifacts, FrameworkVersion version, ConstructorInfoWrapper constructorInfo)
: base(artifacts, version, constructorInfo)
{
this._constructorInfo = constructorInfo;
}
