/// <summary>
/// Analyse file to find generation option.
/// </summary>
/// <param name="xsdFilePath">The XSD file path.</param>
/// <param name="languageIdentifier">The language identifier.</param>
/// <param name="defaultNamespace">The default namespace.</param>
public void Init(string xsdFilePath, string languageIdentifier, string defaultNamespace, TargetFramework framework)
{
string outputFile;
this.generatorParams = GeneratorParams.LoadFromFile(xsdFilePath, out outputFile);
if (this.generatorParams == null)
{
this.generatorParams = new GeneratorParams();
switch (languageIdentifier)
{
case "{B5E9BD33-6D3E-4B5D-925E-8A43B79820B4}":
this.generatorParams.Language = GenerationLanguage.VisualBasic;
break;
case "{B5E9BD36-6D3E-4B5D-925E-8A43B79820B4}":
this.generatorParams.Language = GenerationLanguage.VisualCpp;
break;
default:
this.generatorParams.Language = GenerationLanguage.CSharp;
break;
}
this.generatorParams.TargetFramework = framework;
this.generatorParams.NameSpace = defaultNamespace;
}
this.propertyGrid.SelectedObject = this.generatorParams;
this.OutputFile = outputFile;
}
public static string DisplayFramework(TargetFramework framework)
{
switch (framework)
{
case TargetFramework.Net20:
return "2.0";
case TargetFramework.Net35:
return "3.5";
case TargetFramework.Net40:
return "4.0";
case TargetFramework.Net45:
return "4.5";
case TargetFramework.Net452:
return "4.5.2";
case TargetFramework.Net461:
return "4.6.1";
default:
throw new InvalidOperationException($"Unknown target framework '{framework}'.");
}
}
internal static Result<CodeNamespace> Process(string xsdFile, string targetNamespace,
GenerationLanguage language,
CollectionType collectionType, bool enableDataBinding,
bool hidePrivate,
bool enableSummaryComment, List<NamespaceParam> customUsings,
string collectionBase, bool includeSerializeMethod,
string serializeMethodName, string deserializeMethodName,
string saveToFileMethodName, string loadFromFileMethodName,
bool generateCloneMethod, TargetFramework targetFramework)
{
var generatorParams = new GeneratorParams
{
CollectionObjectType = collectionType,
EnableDataBinding = enableDataBinding,
Language = language,
CustomUsings = customUsings,
CollectionBase = collectionBase,
GenerateCloneMethod = generateCloneMethod,
TargetFramework = targetFramework
};
generatorParams.Miscellaneous.HidePrivateFieldInIde = hidePrivate;
generatorParams.Miscellaneous.EnableSummaryComment = enableSummaryComment;
generatorParams.Serialization.Enabled = includeSerializeMethod;
generatorParams.Serialization.SerializeMethodName = serializeMethodName;
generatorParams.Serialization.DeserializeMethodName = deserializeMethodName;
generatorParams.Serialization.SaveToFileMethodName = saveToFileMethodName;
generatorParams.Serialization.LoadFromFileMethodName = loadFromFileMethodName;
return Process(generatorParams);
}
/// <summary>
/// Create a type defrinition for the given class file and all inner classes.
/// </summary>
public override void CreateType(NetTypeDefinition declaringType, NetModule module, TargetFramework target)
{
// Create basic type
typeDef = new NetTypeDefinition(ClassFile.Empty, target, Scope) { Name = name, Namespace = @namespace, Attributes = Attributes };
module.Types.Add(typeDef);
target.TypeNameMap.Add("custom/" + name, typeDef);
}
/// <summary>
/// Gets services properties.
/// </summary>
public static List<ServiceItem> GetServiceItemList(
TargetFramework targetFramework,
string binaryPathName)
{
HashSet<ServiceItem> oldServices = GetInstalledServices();
InstallService(
targetFramework,
binaryPathName);
HashSet<ServiceItem> newServices = GetInstalledServices();
newServices.ExceptWith(oldServices);
foreach (var serviceItem in newServices)
{
serviceItem.TargetFramework = targetFramework;
serviceItem.BinaryPathName = GetInstalledServiceBinaryPathName(serviceItem.ServiceName);
}
ServiceTransaction.Begin(newServices.ToList());
UninstallService(
targetFramework,
binaryPathName);
ServiceTransaction.Commit();
return newServices.ToList();
}
internal bool SupportsTargetFramework(TargetFramework framework)
{
if (supportedTargetFrameworks == null)
return true;
// return true if framework is based on any of the supported target frameworks
return supportedTargetFrameworks.Any(framework.IsBasedOn);
}
/// <summary>
/// Implement members and setup references now that all types have been created
/// </summary>
public override void Implement(TargetFramework target)
{
if (isValueType)
{
//typeDef.BaseType = typeNameMap.GetByType(typeof(ValueType));
typeDef.IsStruct = true;
}
base.Implement(target);
}
public bool IsBasedOn(TargetFramework potentialBase)
{
TargetFramework tmp = this;
while (tmp != null) {
if (tmp == potentialBase)
return true;
tmp = tmp.BasedOn;
}
return false;
}
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>();
}
/// <summary>
/// Removes project reference from a project document replacing it with the binary one.
/// </summary>
public void ConvertToBinary(TargetFramework framework, string name)
{
var include = String.Format("{0}, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL", name);
var dotNet = framework.ToString().ToLowerInvariant();
var hintPath = String.Format(@"..\packages\{0}.1.0.0.0\lib\{1}\{0}.dll", name, dotNet);
var binary = new XElement(
Ns + "Reference",
new XAttribute("Include", include),
new XElement(Ns + "HintPath", hintPath));
m_element.AddAfterSelf(binary);
m_element.Remove();
}
internal static ICodeExtension GetExtention(TargetFramework target)
{
switch (target)
{
case TargetFramework.Net20:
return new Net20Extension();
case TargetFramework.Net30:
return new Net30Extension();
case TargetFramework.Net35:
return new Net35Extension();
case TargetFramework.Silverlight:
return new SilverlightExtension();
}
return null;
}
/// <summary>
/// Default ctor
/// </summary>
public NetMethodDefinition(string name, JvmClassLib.MethodDefinition javaMethod, NetTypeDefinition declaringType, TargetFramework target, SignedByteMode signMode, string createReason)
{
if (name == null)
throw new ArgumentNullException("name");
if (declaringType == null)
throw new ArgumentNullException("declaringType");
if (target == null)
throw new ArgumentNullException("target");
Name = name;
DeclaringType = declaringType;
this.javaMethod = javaMethod; // Can be null
this.target = target;
this.signMode = signMode;
this.createReason = createReason;
overrides = new OverrideCollection(this);
}
public override void UpgradeProject(CompilerVersion newVersion, TargetFramework newFramework)
{
PortableTargetFramework newFx = newFramework as PortableTargetFramework;
if (newFx != null) {
// Convert to portable library
SD.AnalyticsMonitor.TrackFeature(GetType(), "ConvertToPortableLibrary");
var project = (CompilableProject)Project;
lock (project.SyncRoot) {
var oldTargetFramework = project.CurrentTargetFramework;
if (newVersion != null && GetAvailableCompilerVersions().Contains(newVersion)) {
project.ToolsVersion = newVersion.MSBuildVersion.Major + "." + newVersion.MSBuildVersion.Minor;
}
project.SetProperty(null, null, "TargetFrameworkProfile", newFx.TargetFrameworkProfile, PropertyStorageLocations.Base, true);
project.SetProperty(null, null, "TargetFrameworkVersion", newFx.TargetFrameworkVersion, PropertyStorageLocations.Base, true);
// Convert <Imports>
project.PerformUpdateOnProjectFile(
delegate {
foreach (var import in project.MSBuildProjectFile.Imports) {
if (import.Project.EndsWith(PortableLibraryProjectBehavior.NormalCSharpTargets, StringComparison.OrdinalIgnoreCase)) {
import.Project = PortableLibraryProjectBehavior.PortableTargetsPath + PortableLibraryProjectBehavior.PortableCSharpTargets;
break;
} else if (import.Project.EndsWith(PortableLibraryProjectBehavior.NormalVBTargets, StringComparison.OrdinalIgnoreCase)) {
import.Project = PortableLibraryProjectBehavior.PortableTargetsPath + PortableLibraryProjectBehavior.PortableVBTargets;
break;
}
}
});
// Remove references
foreach (var referenceItem in project.GetItemsOfType(ItemType.Reference).ToArray()) {
// get short assembly name:
string assemblyName = referenceItem.Include;
if (assemblyName.IndexOf(',') >= 0)
assemblyName = assemblyName.Substring(0, assemblyName.IndexOf(','));
if (oldTargetFramework.ReferenceAssemblies.Any(fullName => string.Equals(fullName.ShortName, assemblyName, StringComparison.OrdinalIgnoreCase))) {
// If it's a framework assembly, remove the reference
// (portable libraries automatically reference all available framework assemblies)
ProjectService.RemoveProjectItem(project, referenceItem);
}
}
project.AddProjectType(ProjectTypeGuids.PortableLibrary);
project.Save();
ProjectBrowserPad.RefreshViewAsync();
}
} else {
base.UpgradeProject(newVersion, newFramework);
}
}
public GeneratorFacade(string inputFile,
string nameSpace,
GenerationLanguage language,
CollectionType collectionType,
bool enableDataBinding, bool hidePrivate, bool enableSummaryComment,
List<NamespaceParam> customUsings, string collectionBase, bool includeSerializeMethod,
string serializeMethodName, string deserializeMethodName, string saveToFileMethodName,
string loadFromFileMethodName, bool disableDebug, bool implementCloneMethod,
TargetFramework targetFramework)
{
var provider = CodeDomProviderFactory.GetProvider(language);
this.Init(inputFile, nameSpace, provider, collectionType, enableDataBinding, hidePrivate,
enableSummaryComment, customUsings, collectionBase, includeSerializeMethod, serializeMethodName,
deserializeMethodName, saveToFileMethodName, loadFromFileMethodName, disableDebug,
implementCloneMethod, targetFramework);
}
/// <summary>
/// Create the interface method in the given type
/// </summary>
public void Build(TypeDefinition declaringType, TargetFramework target)
{
// Create method
var name = iMethod.DeclaringType.FullName + "." + iMethod.Name;
var attributes = MethodAttributes.Private | MethodAttributes.HideBySig;
method = new MethodDefinition(name, attributes, target.TypeSystem.Void);
method.DeclaringType = declaringType;
foreach (var gp in iMethod.GenericParameters)
{
method.GenericParameters.Add(new GenericParameter(gp.Name, method));
}
method.ReturnType = ResolveGenericParameters(iMethod.ReturnType, method);
foreach (var paramDef in iMethod.Parameters)
{
method.Parameters.Add(new ParameterDefinition(ResolveGenericParameters(paramDef.ParameterType, method)));
}
declaringType.Methods.Add(method);
// Set override
method.Overrides.Add(iMethod);
// Create method body
if (!method.IsAbstract)
{
var body = method.Body = new MethodBody(method);
var seq = body.GetILProcessor();
if (method.ReturnType.FullName != "System.Void")
{
if (method.ReturnType.IsPrimitive)
{
seq.Emit(OpCodes.Ldc_I4_0);
}
else
{
seq.Emit(OpCodes.Ldnull);
}
}
seq.Emit(OpCodes.Ret);
}
}
public override void UpgradeProject(CompilerVersion newVersion, TargetFramework newFramework)
{
var project = (CompilableProject)Project;
var newFx = newFramework as PortableTargetFramework;
if (newFramework != null && newFx == null) {
// convert to normal .NET project (not portable)
SD.AnalyticsMonitor.TrackFeature(GetType(), "DowngradePortableLibrary");
project.PerformUpdateOnProjectFile(
delegate {
foreach (var import in project.MSBuildProjectFile.Imports) {
if (import.Project.EndsWith(PortableCSharpTargets, StringComparison.OrdinalIgnoreCase)) {
import.Project = NormalTargetsPath + NormalCSharpTargets;
break;
} else if (import.Project.EndsWith(PortableVBTargets, StringComparison.OrdinalIgnoreCase)) {
import.Project = NormalTargetsPath + NormalVBTargets;
break;
}
}
});
project.RemoveProjectType(ProjectTypeGuids.PortableLibrary);
AddReferenceIfNotExists("System");
AddReferenceIfNotExists("System.Xml");
if (newFramework.IsBasedOn(TargetFramework.Net35) || newFramework.IsBasedOn(TargetFramework.Net35Client))
AddReferenceIfNotExists("System.Core");
base.UpgradeProject(newVersion, newFramework);
return;
}
lock (project.SyncRoot) {
if (newVersion != null && GetAvailableCompilerVersions().Contains(newVersion)) {
project.ToolsVersion = newVersion.MSBuildVersion.Major + "." + newVersion.MSBuildVersion.Minor;
}
if (newFx != null) {
project.SetProperty(null, null, "TargetFrameworkProfile", newFx.TargetFrameworkProfile, PropertyStorageLocations.Base, true);
project.SetProperty(null, null, "TargetFrameworkVersion", newFx.TargetFrameworkVersion, PropertyStorageLocations.Base, true);
}
project.Save();
ProjectBrowserPad.RefreshViewAsync();
}
}
public async Task UpdateTargetFrameworkForProjects(TargetFramework framework)
{
await OpenSolution();
var sourceDirectory = Path.GetDirectoryName(_solutionName);
var suoFiles = (new DirectoryInfo(sourceDirectory)).GetFiles("*.suo");
if (!suoFiles.Any())
{
_logger.Log("No .suo file, closing and reopening solution");
await CloseAsync();
_dte = EnvDTEFactory.Create(_visualStudioVersion);
await OpenSolution();
}
var iterations = 15;
_logger.Log("Number of projects updating from the solution: {0}", _projectWrappers.Count());
_logger.Log("Attempting to upgrade all projects to version {0} in {1} attempts", framework.ToDescription(), iterations);
_nonUpdatedProjects.Clear();
_projectWrappers.ToList().ForEach(p => _nonUpdatedProjects.Add(p));
for (int i = 0; i < iterations && _nonUpdatedProjects.Any(p => !p.IsSpecialProject); i++)
{
_logger.Log("************ Attempt {0} ************", i + 1);
var projects = _nonUpdatedProjects.ToArray();
Parallel.ForEach(projects, async project =>
{
await AttemptTo(() =>
{
UpdateProject(project, framework);
});
});
}
await SaveAsync();
await CloseAsync();
}
public static bool IsLessThan(this IEnumerable<TargetFramework> frameworks, TargetFramework framework)
{
return frameworks.Max(x => (int) x) < (int) framework;
}
public static bool IsGreaterThan(this IEnumerable<TargetFramework> frameworks, TargetFramework framework)
{
return frameworks.Any(currentFramework => currentFramework.IsGreaterThan(framework));
}
public static bool IsEqualTo(this TargetFramework a, TargetFramework b)
{
return (int) a == (int) b;
}
public void FromChanges_RemovedAndAddedChanges()
{
var targetFramework = new TargetFramework("tfm1");
var dependency1 = new TestDependency
{
ProviderType = "Xxx",
Id = "dependency1",
OriginalItemSpec = "Dependency1",
Caption = "Dependency1",
SchemaItemType = "Xxx",
Resolved = true
};
var dependency2 = new TestDependency
{
ProviderType = "Xxx",
Id = "dependency2",
OriginalItemSpec = "Dependency2",
Caption = "Dependency2",
SchemaItemType = "Xxx",
Resolved = true
};
var dependencyModelAdded1 = new TestDependencyModel
{
ProviderType = "Xxx",
Id = "addeddependency1",
OriginalItemSpec = "AddedDependency1",
Caption = "AddedDependency1",
SchemaItemType = "Xxx",
Resolved = true,
Icon = KnownMonikers.Uninstall,
ExpandedIcon = KnownMonikers.Uninstall
};
var dependencyModelAdded2 = new TestDependencyModel
{
ProviderType = "Xxx",
Id = "addeddependency2",
OriginalItemSpec = "AddedDependency2",
Caption = "AddedDependency2",
SchemaItemType = "Xxx",
Resolved = true,
Icon = KnownMonikers.Uninstall,
ExpandedIcon = KnownMonikers.Uninstall
};
var dependencyModelAdded3 = new TestDependencyModel
{
ProviderType = "Xxx",
Id = "addeddependency3",
OriginalItemSpec = "AddedDependency3",
Caption = "AddedDependency3",
SchemaItemType = "Xxx",
Resolved = true,
Icon = KnownMonikers.Uninstall,
ExpandedIcon = KnownMonikers.Uninstall
};
var dependencyAdded2Changed = new TestDependency
{
ProviderType = "Xxx",
Id = "addeddependency2",
OriginalItemSpec = "AddedDependency2Changed",
Caption = "AddedDependency2Changed",
SchemaItemType = "Xxx",
Resolved = true
};
var dependencyRemoved1 = new TestDependency
{
ProviderType = "Xxx",
Id = "Removeddependency1",
OriginalItemSpec = "RemovedDependency1",
Caption = "RemovedDependency1",
SchemaItemType = "Xxx",
Resolved = true
};
var dependencyInsteadRemoved1 = new TestDependency
{
ProviderType = "Xxx",
Id = "InsteadRemoveddependency1",
OriginalItemSpec = "InsteadRemovedDependency1",
Caption = "InsteadRemovedDependency1",
SchemaItemType = "Xxx",
Resolved = true
};
var catalogs = IProjectCatalogSnapshotFactory.Create();
var previousSnapshot = new TargetedDependenciesSnapshot(
targetFramework,
catalogs,
ImmutableArray.Create <IDependency>(dependency1, dependency2, dependencyRemoved1));
var changes = new DependenciesChangesBuilder();
changes.Added(dependencyModelAdded1);
changes.Added(dependencyModelAdded2);
changes.Added(dependencyModelAdded3);
changes.Removed("Xxx", "Removeddependency1");
var snapshotFilter = new TestDependenciesSnapshotFilter()
.BeforeAddReject("Xxx", "addeddependency1")
.BeforeAddAccept("Xxx", "addeddependency2", dependencyAdded2Changed)
.BeforeAddAccept("Xxx", "addeddependency3")
.BeforeRemoveAccept("Xxx", "Removeddependency1", dependencyInsteadRemoved1);
var snapshot = TargetedDependenciesSnapshot.FromChanges(
previousSnapshot,
changes.TryBuildChanges() !,
catalogs,
ImmutableArray.Create <IDependenciesSnapshotFilter>(snapshotFilter),
new Dictionary <string, IProjectDependenciesSubTreeProvider>(),
null);
Assert.True(snapshotFilter.Completed);
Assert.NotSame(previousSnapshot, snapshot);
Assert.Same(previousSnapshot.TargetFramework, snapshot.TargetFramework);
Assert.Same(catalogs, snapshot.Catalogs);
AssertEx.CollectionLength(snapshot.Dependencies, 5);
Assert.Contains(snapshot.Dependencies, dep => dep.Id == "dependency1");
Assert.Contains(snapshot.Dependencies, dep => dep.Id == "dependency2");
Assert.Contains(snapshot.Dependencies, dep => dep.Id == "addeddependency2");
Assert.Contains(snapshot.Dependencies, dep => dep.Id == "InsteadRemoveddependency1");
Assert.Contains(snapshot.Dependencies, dep => dep.Id == "addeddependency3");
}
public bool SupportsFramework(TargetFramework fx)
{
IList <TargetFrameworkMoniker> frameworkVersions = this.frameworkVersions;
return(frameworkVersions.Contains(fx.Id) || supportsMonikers);
}
public bool IsSupported(TargetFramework target, Version version) => true;
public static bool IsGreaterThan(this IEnumerable<Assembly> assemblies, TargetFramework framework)
{
return AssemblyInfo.GetTargetFramework(assemblies).IsGreaterThan(framework);
}
bool IsApplicable(TargetFramework fx, bool allowExtra, IEnumerable <SupportedFramework> selected)
{
return(IsApplicable(fx, allowExtra, selected.ToArray()));
}
void SelectFrameworks(List <SupportedFramework> selectedFrameworks)
{
// Which TargetFramework's match these?
var applicable = targetFrameworks.Where(
f => IsApplicable(f, true, selectedFrameworks)).ToList();
if (applicable.Count == 0)
{
AddWarning(GettextCatalog.GetString("No applicable frameworks for this selection!"));
return;
}
//
// 'applicable' contains all TargetFrameworks that match _at least_
// the list of 'selectedFrameworks'.
//
// 'exactMatches' is where they do not contain any additional
// (non-selected) 'SupportedFramework's.
//
var exactMatches = applicable.Where(
a => IsApplicable(a, false, selectedFrameworks)).ToList();
if (exactMatches.Count == 1)
{
// Found an exact match.
SelectFramework(exactMatches[0]);
return;
}
else if (exactMatches.Count > 1)
{
// This should never happen.
AddWarning(GettextCatalog.GetString("Multiple frameworks match the current selection:"));
exactMatches.ForEach(e => AddWarning(" " + e.Id));
AddWarning(GettextCatalog.GetString("You must manually pick a profile in the drop-down selector."));
// This is very bad UX, we should really disable "Ok" / add an "Apply"
// button, but it's better than nothing.
TargetFramework = exactMatches[0];
return;
}
// Union of all the SupportedFrameworks from our applicable TargetFrameworks.
var all = applicable.SelectMany(
a => a.SupportedFrameworks).Distinct(SupportedFramework.EqualityComparer);
// Minus the ones that we already selected.
var extra = all.Where(a => !selectedFrameworks.Contains(a)).ToList();
// Are there any SupportedFrameworks that all our applicable TargetFrameworks
// have in common?
var common = extra.Where(
e => applicable.All(a => a.SupportedFrameworks.Contains(e))).ToList();
if (common.Count == 0)
{
// Ok, the user must pick something.
AddWarning(GettextCatalog.GetString("Found multiple applicable frameworks, you need to select additional check boxes."));
// Same here: randomly pick a profile to make "Ok" happy.
TargetFramework = applicable[0];
return;
}
AddInfo(GettextCatalog.GetString("The following frameworks have been implicitly selected:"));
AddInfo(" " + string.Join(", ", common.Select(GetDisplayName)));
// Implicitly select them.
var implicitlySelected = new List <SupportedFramework> ();
implicitlySelected.AddRange(selectedFrameworks);
implicitlySelected.AddRange(common);
// And let's try again ...
SelectFrameworks(implicitlySelected);
}
/// <summary>
/// Gets the type of the value field
/// </summary>
protected override NetTypeReference GetValueType(TargetFramework target)
{
return(target.TypeNameMap.GetByType(typeof(UInt16)));
}
public PortableRuntimeOptionsPanelWidget(PortableDotNetProject project, IEnumerable <ItemConfiguration> configurations)
{
this.target = project.TargetFramework;
this.project = project;
this.Build();
// Aggregate all SupportedFrameworks from .NETPortable TargetFrameworks
targetFrameworks = GetPortableTargetFrameworks().ToList();
supportedFrameworks = new SortedDictionary <string, List <SupportedFramework> > ();
if (!targetFrameworks.Contains(project.TargetFramework))
{
missingFramework = project.TargetFramework;
targetFrameworks.Insert(0, project.TargetFramework);
}
foreach (var fx in targetFrameworks)
{
foreach (var sfx in fx.SupportedFrameworks)
{
List <SupportedFramework> list;
if (!supportedFrameworks.TryGetValue(sfx.DisplayName, out list))
{
list = new List <SupportedFramework> ();
supportedFrameworks.Add(sfx.DisplayName, list);
}
list.Add(sfx);
}
}
// Now create a list of config options from our supported frameworks
options = new List <OptionCombo> ();
foreach (var fx in supportedFrameworks)
{
var combo = new OptionCombo(fx.Key);
var dict = new SortedDictionary <string, OptionComboItem> ();
foreach (var sfx in fx.Value)
{
var label = GetDisplayName(sfx);
OptionComboItem item;
if (!dict.TryGetValue(label, out item))
{
item = new OptionComboItem(label, sfx);
dict.Add(label, item);
}
item.Targets.Add(sfx.TargetFramework);
}
combo.Items = dict.Values.ToList();
options.Add(combo);
}
CreateUI();
CurrentProfileChanged(project.TargetFramework);
}
/// <summary>
/// Checks that the target framework (e.g. .NETCoreApp1.1 or .NETStandard2.0) is supported
/// by the installed SDKs. Takes into account Mono having .NET Core v1 SDKs installed.
/// </summary>
internal static bool IsSupported(TargetFramework framework)
{
return(IsSupported(framework.Id, Versions, MSBuildSdks.Installed));
}
static string GetDotNetCoreSdkRequiredBuildErrorMessage(bool isUnsupportedVersion, TargetFramework targetFramework)
{
if (isUnsupportedVersion)
{
return(GettextCatalog.GetString("The .NET Core SDK installed is not supported. Please install a more recent version. {0}", DotNetCoreNotInstalledDialog.DotNetCoreDownloadUrl));
}
else if (targetFramework.IsNetStandard20OrNetCore20())
{
return(GettextCatalog.GetString(".NET Core 2.0 SDK is not installed. This is required to build .NET Core 2.0 projects. {0}", DotNetCoreNotInstalledDialog.DotNetCore20DownloadUrl));
}
else if (targetFramework.IsNetCoreApp21())
{
return(GettextCatalog.GetString(".NET Core 2.1 SDK is not installed. This is required to build .NET Core 2.1 projects. {0}", DotNetCoreNotInstalledDialog.DotNetCore21DownloadUrl));
}
else if (targetFramework.IsNetCoreApp22())
{
return(GettextCatalog.GetString(".NET Core 2.2 SDK is not installed. This is required to build .NET Core 2.2 projects. {0}", DotNetCoreNotInstalledDialog.DotNetCore22DownloadUrl));
}
return(GettextCatalog.GetString(".NET Core SDK is not installed. This is required to build .NET Core projects. {0}", DotNetCoreNotInstalledDialog.DotNetCoreDownloadUrl));
}
protected override bool OnGetSupportsFramework(TargetFramework framework)
{
// Allow all SDK style projects to be loaded even if the framework is unknown.
// A PackageReference may define the target framework with an imported MSBuild file.
return(true);
}
public static bool IsLessThanOrEqualTo(this IEnumerable<TargetFramework> frameworks, TargetFramework framework)
{
return frameworks.All(currentFramework => currentFramework.IsLessThanOrEqualTo(framework));
}
/// <summary>
/// Uninstalls services.
/// </summary>
private static void UninstallService(
TargetFramework targetFramework,
string binaryPathName)
{
string installUtilPath = null;
switch (targetFramework)
{
case TargetFramework.Net20:
case TargetFramework.Net35:
installUtilPath = s_installUtil20Path;
break;
case TargetFramework.Net40:
case TargetFramework.Net45:
installUtilPath = s_installUtil40Path;
break;
}
Process p = CreateCustomProcess(
installUtilPath,
string.Format(
"/u \"{0}\"",
binaryPathName),
true);
p.Start();
p.WaitForExit();
if (p.ExitCode == 0)
{
return;
}
string message = string.Format(
Resources.ServiceUninstallError,
binaryPathName);
throw new InvalidOperationException(message);
}
public PortableRuntimeSelectorDialog(TargetFramework initialTarget)
{
this.Title = GettextCatalog.GetString("Change Targets");
this.AddActionWidget(new Button(Stock.Cancel), ResponseType.Cancel);
this.AddActionWidget(new Button(Stock.Ok), ResponseType.Ok);
this.ActionArea.ShowAll();
this.TargetFramework = initialTarget;
// Aggregate all SupportedFrameworks from .NETPortable TargetFrameworks
targetFrameworks = GetPortableTargetFrameworks().ToList();
targetFrameworks.Sort(CompareFrameworks);
supportedFrameworks = new SortedDictionary <string, List <SupportedFramework> > ();
if (!targetFrameworks.Contains(TargetFramework))
{
missingFramework = TargetFramework;
targetFrameworks.Insert(0, TargetFramework);
}
foreach (var fx in targetFrameworks)
{
foreach (var sfx in fx.SupportedFrameworks)
{
List <SupportedFramework> list;
if (!supportedFrameworks.TryGetValue(sfx.DisplayName, out list))
{
list = new List <SupportedFramework> ();
supportedFrameworks.Add(sfx.DisplayName, list);
}
list.Add(sfx);
}
}
// Now create a list of config options from our supported frameworks
options = new List <OptionCombo> ();
foreach (var fx in supportedFrameworks)
{
var combo = new OptionCombo(fx.Key);
var dict = new SortedDictionary <string, OptionComboItem> ();
foreach (var sfx in fx.Value)
{
var label = GetDisplayName(sfx);
OptionComboItem item;
if (!dict.TryGetValue(label, out item))
{
item = new OptionComboItem(label, sfx);
dict.Add(label, item);
}
}
combo.Items = dict.Values.ToList();
options.Add(combo);
}
CreateUI();
CurrentProfileChanged(TargetFramework);
}
public static bool IsLessThanOrEqualTo(this IEnumerable<Assembly> assemblies, TargetFramework framework)
{
return AssemblyInfo.GetTargetFramework(assemblies).IsLessThan(framework);
}
public IDependencyViewModel CreateTargetViewModel(TargetFramework targetFramework, bool hasVisibleUnresolvedDependency)
{
return(new TargetDependencyViewModel(targetFramework, hasVisibleUnresolvedDependency));
}
/// <summary>
/// Retrieves property values from the project file
/// </summary>
protected override void BindProperties()
{
var targetFwStr = this.ProjectMgr.GetProjectProperty("TargetFrameworkVersion");
if (targetFwStr == "v4.0")
this.targetFramework = VS.TargetFramework.Net40;
else
this.targetFramework = VS.TargetFramework.Net45;
this.outputPath = this.ProjectMgr.GetProjectProperty(
"OutputPath",
true
);
this.versionSource = (VersionSource)Enum.Parse(
typeof(VersionSource),
this.ProjectMgr.GetProjectProperty("NuBuildVersionSource", true),
true
);
this.versionFileName = Boolean.Parse(
this.ProjectMgr.GetProjectProperty("NuBuildVersionFileName")
);
this.addBinariesToSubfolder = Boolean.Parse(
this.ProjectMgr.GetProjectProperty("NuBuildAddBinariesToSubfolder")
);
this.autoGenerateDependencies = Boolean.Parse(
this.ProjectMgr.GetProjectProperty("NuBuildAutoGenerateDependencies")
);
this.includePdbs = Boolean.Parse(
this.ProjectMgr.GetProjectProperty("NuBuildIncludePdbs")
);
}
public static ApplePlatform GetFramework(string targetFrameworkMoniker)
{
return(TargetFramework.Parse(targetFrameworkMoniker).Platform);
}
public void FromChanges_UpdatesLevelDependencies()
{
var targetFramework = new TargetFramework("tfm1");
var dependencyPrevious = new TestDependency
{
ProviderType = "Xxx",
Id = "dependency1",
OriginalItemSpec = "Dependency1",
Caption = "Dependency1",
SchemaItemType = "Xxx",
Resolved = true
};
var dependencyModelAdded = new TestDependencyModel
{
ProviderType = "Xxx",
Id = "dependency1",
OriginalItemSpec = "Dependency1",
Caption = "Dependency1",
SchemaItemType = "Xxx",
Resolved = true,
Icon = KnownMonikers.Uninstall,
ExpandedIcon = KnownMonikers.Uninstall
};
var dependencyUpdated = new TestDependency
{
ProviderType = "Xxx",
Id = "dependency1",
OriginalItemSpec = "Dependency1",
Caption = "Dependency1",
SchemaItemType = "Xxx",
Resolved = true
};
var catalogs = IProjectCatalogSnapshotFactory.Create();
var previousSnapshot = new TargetedDependenciesSnapshot(
targetFramework,
catalogs,
ImmutableArray.Create <IDependency>(dependencyPrevious));
var changes = new DependenciesChangesBuilder();
changes.Added(dependencyModelAdded);
var snapshotFilter = new TestDependenciesSnapshotFilter()
.BeforeAddAccept("Xxx", "dependency1", dependencyUpdated);
var snapshot = TargetedDependenciesSnapshot.FromChanges(
previousSnapshot,
changes.TryBuildChanges() !,
catalogs,
ImmutableArray.Create <IDependenciesSnapshotFilter>(snapshotFilter),
new Dictionary <string, IProjectDependenciesSubTreeProvider>(),
null);
Assert.True(snapshotFilter.Completed);
Assert.NotSame(previousSnapshot, snapshot);
Assert.Same(dependencyUpdated, snapshot.Dependencies.Single());
}
string [] BuildArgumentArray()
{
var sb = new List <string> ();
var targetFramework = (string)null;
#if NET
switch (Profile)
{
case Profile.None:
break;
case Profile.iOS:
targetFramework = TargetFramework.DotNet_5_0_iOS_String;
break;
case Profile.tvOS:
targetFramework = TargetFramework.DotNet_5_0_tvOS_String;
break;
case Profile.watchOS:
targetFramework = TargetFramework.DotNet_5_0_watchOS_String;
break;
case Profile.macOSMobile:
targetFramework = TargetFramework.DotNet_5_0_macOS_String;
break;
case Profile.macOSFull:
case Profile.macOSSystem:
throw new InvalidOperationException($"Only the Mobile profile can be specified for .NET");
default:
throw new NotImplementedException($"Profile: {Profile}");
}
#else
switch (Profile)
{
case Profile.None:
break;
case Profile.iOS:
targetFramework = "Xamarin.iOS,v1.0";
break;
case Profile.tvOS:
targetFramework = "Xamarin.TVOS,v1.0";
break;
case Profile.watchOS:
targetFramework = "Xamarin.WatchOS,v1.0";
break;
case Profile.macOSClassic:
targetFramework = "XamMac,v1.0";
break;
case Profile.macOSFull:
targetFramework = "Xamarin.Mac,Version=v4.5,Profile=Full";
break;
case Profile.macOSMobile:
targetFramework = "Xamarin.Mac,Version=v2.0,Profile=Mobile";
break;
case Profile.macOSSystem:
targetFramework = "Xamarin.Mac,Version=v4.5,Profile=System";
break;
default:
throw new NotImplementedException($"Profile: {Profile}");
}
#endif
TargetFramework?tf = null;
if (targetFramework != null)
{
tf = TargetFramework.Parse(targetFramework);
}
if (BaseLibrary == null)
{
if (tf.HasValue)
{
sb.Add($"--baselib={Configuration.GetBaseLibrary (tf.Value)}");
}
}
else if (BaseLibrary != None)
{
sb.Add($"--baselib={BaseLibrary}");
}
if (AttributeLibrary == null)
{
if (tf.HasValue)
{
sb.Add($"--attributelib={Configuration.GetBindingAttributePath (tf.Value)}");
}
}
else if (AttributeLibrary != None)
{
sb.Add($"--attributelib={AttributeLibrary}");
}
if (!string.IsNullOrEmpty(targetFramework))
{
sb.Add($"--target-framework={targetFramework}");
}
foreach (var ad in ApiDefinitions)
{
sb.Add($"--api={ad}");
}
foreach (var s in Sources)
{
sb.Add($"-s={s}");
}
if (ReferenceBclByDefault)
{
if (tf == null)
{
// do nothing
}
else if (tf.Value.IsDotNet == true)
{
References.AddRange(Directory.GetFiles(Configuration.DotNet5BclDir, "*.dll"));
}
else
{
throw new NotImplementedException("ReferenceBclByDefault");
}
}
foreach (var r in References)
{
sb.Add($"-r={r}");
}
if (!string.IsNullOrEmpty(TmpDirectory))
{
sb.Add($"--tmpdir={TmpDirectory}");
}
if (!string.IsNullOrEmpty(ResponseFile))
{
sb.Add($"@{ResponseFile}");
}
if (!string.IsNullOrEmpty(Out))
{
sb.Add($"--out={Out}");
}
if (ProcessEnums)
{
sb.Add("--process-enums");
}
if (Defines != null)
{
foreach (var d in Defines)
{
sb.Add($"-d={d}");
}
}
if (WarnAsError != null)
{
var arg = "--warnaserror";
if (WarnAsError.Length > 0)
{
arg += ":" + WarnAsError;
}
sb.Add(arg);
}
if (NoWarn != null)
{
var arg = "--nowarn";
if (NoWarn.Length > 0)
{
arg += ":" + NoWarn;
}
sb.Add(arg);
}
if (Verbosity != 0)
{
sb.Add("-" + new string (Verbosity > 0 ? 'v' : 'q', Math.Abs(Verbosity)));
}
return(sb.ToArray());
}
public void FromChanges_ReportedChangesAfterBeforeAddFilterDeclinedChange()
{
var targetFramework = new TargetFramework("tfm1");
var dependency1 = new TestDependency
{
ProviderType = "Xxx",
Id = "dependency1",
OriginalItemSpec = "Dependency1",
Caption = "Dependency1",
SchemaItemType = "Xxx",
Resolved = true
};
var dependency2 = new TestDependency
{
ProviderType = "Xxx",
Id = "dependency2",
OriginalItemSpec = "Dependency2",
Caption = "Dependency2",
SchemaItemType = "Xxx",
Resolved = true
};
var dependencyModelNew1 = new TestDependencyModel
{
ProviderType = "Xxx",
Id = "newdependency1",
OriginalItemSpec = "NewDependency1",
Caption = "NewDependency1",
SchemaItemType = "Xxx",
Resolved = true,
Icon = KnownMonikers.Uninstall,
ExpandedIcon = KnownMonikers.Uninstall
};
var catalogs = IProjectCatalogSnapshotFactory.Create();
var previousSnapshot = new TargetedDependenciesSnapshot(
targetFramework,
catalogs,
ImmutableArray.Create <IDependency>(dependency1, dependency2));
var changes = new DependenciesChangesBuilder();
changes.Added(dependencyModelNew1);
var filterAddedDependency = new TestDependency {
Id = "unexpected"
};
var snapshotFilter = new TestDependenciesSnapshotFilter()
.BeforeAddReject("Xxx", "newdependency1", addOrUpdate: filterAddedDependency);
var snapshot = TargetedDependenciesSnapshot.FromChanges(
previousSnapshot,
changes.TryBuildChanges() !,
catalogs,
ImmutableArray.Create <IDependenciesSnapshotFilter>(snapshotFilter),
new Dictionary <string, IProjectDependenciesSubTreeProvider>(),
null);
Assert.True(snapshotFilter.Completed);
Assert.NotSame(previousSnapshot, snapshot);
Assert.Same(previousSnapshot.TargetFramework, snapshot.TargetFramework);
Assert.Same(previousSnapshot.Catalogs, snapshot.Catalogs);
AssertEx.CollectionLength(snapshot.Dependencies, 3);
Assert.Contains(dependency1, snapshot.Dependencies);
Assert.Contains(dependency2, snapshot.Dependencies);
Assert.Contains(filterAddedDependency, snapshot.Dependencies);
}
/// <summary>
/// Implement members and setup references now that all types have been created
/// </summary>
public override void Implement(TargetFramework target)
{
TypeDefinition.IsStruct = true;
base.Implement(target);
}
public static bool IsGreaterThan(this TargetFramework a, TargetFramework b)
{
return (int)a > (int)b;
}
private void ProcessPlatformTemplate(ITemplatePart rootPart, TemplateReplacementSet rootReplacementSet, string platformName, string configuration, BuildTarget buildTarget, TargetFramework targetFramework, IEnumerable <string> references, IEnumerable <string> defines, params HashSet <string>[] priorToCheck)
{
ProcessReferences(buildTarget, references, out HashSet <string> platformAssemblySearchPaths, out HashSet <string> platformAssemblyReferencePaths, priorToCheck);
string minUWPPlatform = EditorUserBuildSettings.wsaMinUWPSDK;
if (string.IsNullOrWhiteSpace(minUWPPlatform) || new Version(minUWPPlatform) < MSBuildTools.DefaultMinUWPSDK)
{
minUWPPlatform = MSBuildTools.DefaultMinUWPSDK.ToString();
}
// This is a try replace because some may hardcode this value
rootPart.TryReplaceToken("TARGET_FRAMEWORK", rootReplacementSet, targetFramework.AsMSBuildString());
rootPart.Tokens["PLATFORM_COMMON_DEFINE_CONSTANTS"].AssignValue(rootReplacementSet, new DelimitedStringSet(";", defines));
rootPart.Tokens["PLATFORM_COMMON_ASSEMBLY_SEARCH_PATHS"].AssignValue(rootReplacementSet, new DelimitedStringSet(";", platformAssemblySearchPaths));
// These are UWP specific, but they will be no-op if not needed
if (buildTarget == BuildTarget.WSAPlayer && configuration == "Player")
{
string targetUWPPlatform = EditorUserBuildSettings.wsaUWPSDK;
if (string.IsNullOrWhiteSpace(targetUWPPlatform))
{
targetUWPPlatform = Utilities.GetUWPSDKs().Max().ToString(4);
}
rootPart.TryReplaceToken("UWP_TARGET_PLATFORM_VERSION", rootReplacementSet, targetUWPPlatform);
rootPart.TryReplaceToken("UWP_MIN_PLATFORM_VERSION", rootReplacementSet, minUWPPlatform);
}
ITemplatePart platformCommonReferencePart = rootPart.Templates["PLATFORM_COMMON_REFERENCE"];
foreach (string reference in platformAssemblyReferencePaths)
{
TemplateReplacementSet replacementSet = platformCommonReferencePart.CreateReplacementSet(rootReplacementSet);
platformCommonReferencePart.Tokens["REFERENCE"].AssignValue(replacementSet, Path.GetFileNameWithoutExtension(reference));
platformCommonReferencePart.Tokens["HINT_PATH"].AssignValue(replacementSet, reference);
}
}
public static bool IsLessThan(this TargetFramework a, TargetFramework b)
{
return !a.IsGreaterThan(b) && !a.IsEqualTo(b);
}
public static bool IsNetStandard20OrNetCore20(this TargetFramework framework) => framework.IsNetStandard("2.0") || framework.IsNetCoreApp("2.0");
public static bool IsLessThanOrEqualTo(this TargetFramework a, TargetFramework b)
{
return a.IsLessThan(b) || a.IsEqualTo(b);
}
public static bool IsNetStandard(this TargetFramework framework) => framework.Id.IsNetStandard();
public IDependencyViewModel CreateTargetViewModel(TargetFramework targetFramework, DiagnosticLevel maximumDiagnosticLevel)
{
return(new TargetDependencyViewModel(targetFramework, maximumDiagnosticLevel));
}
public bool IsSupported(TargetFramework target, Version version)
{
return(target is TargetFramework.Net && version.Major >= 7);
}
protected override bool OnGetSupportsFramework(TargetFramework framework)
{
return(true);
}
public void LoadFrom(FilePath assemblyPath)
{
FileName = assemblyPath;
var tid = Runtime.SystemAssemblyService.GetTargetFrameworkForAssembly(Runtime.SystemAssemblyService.DefaultRuntime, assemblyPath);
if (tid != null)
{
targetFramework = Runtime.SystemAssemblyService.GetTargetFramework(tid);
}
AssemblyDefinition adef = AssemblyDefinition.ReadAssembly(assemblyPath);
MdbReaderProvider mdbProvider = new MdbReaderProvider();
try {
ISymbolReader reader = mdbProvider.GetSymbolReader(adef.MainModule, assemblyPath);
adef.MainModule.ReadSymbols(reader);
} catch {
// Ignore
}
var files = new HashSet <FilePath> ();
foreach (TypeDefinition type in adef.MainModule.Types)
{
foreach (MethodDefinition met in type.Methods)
{
if (met.HasBody && met.Body.Instructions != null && met.Body.Instructions.Count > 0)
{
SequencePoint sp = met.Body.Instructions[0].SequencePoint;
if (sp != null)
{
files.Add(sp.Document.Url);
}
}
}
}
FilePath rootPath = FilePath.Empty;
foreach (FilePath file in files)
{
AddFile(file, BuildAction.Compile);
if (rootPath.IsNullOrEmpty)
{
rootPath = file.ParentDirectory;
}
else if (!file.IsChildPathOf(rootPath))
{
rootPath = FindCommonRoot(rootPath, file);
}
}
if (!rootPath.IsNullOrEmpty)
{
BaseDirectory = rootPath;
}
/*
* foreach (AssemblyNameReference aref in adef.MainModule.AssemblyReferences) {
* if (aref.Name == "mscorlib")
* continue;
* string asm = assemblyPath.ParentDirectory.Combine (aref.Name);
* if (File.Exists (asm + ".dll"))
* References.Add (new ProjectReference (ReferenceType.Assembly, asm + ".dll"));
* else if (File.Exists (asm + ".exe"))
* References.Add (new ProjectReference (ReferenceType.Assembly, asm + ".exe"));
* else
* References.Add (new ProjectReference (ReferenceType.Package, aref.FullName));
* }*/
}
public static bool IsLessThan(this Assembly assembly, TargetFramework framework)
{
return AssemblyInfo.GetTargetFramework(assembly).IsLessThan(framework);
}
/// <summary>
/// Applies changes to <paramref name="previousSnapshot"/> and produces a new snapshot if required.
/// If no changes are made, <paramref name="previousSnapshot"/> is returned unmodified.
/// </summary>
/// <returns>An updated snapshot, or <paramref name="previousSnapshot"/> if no changes occurred.</returns>
public static TargetedDependenciesSnapshot FromChanges(
TargetedDependenciesSnapshot previousSnapshot,
IDependenciesChanges?changes,
IProjectCatalogSnapshot?catalogs)
{
Requires.NotNull(previousSnapshot, nameof(previousSnapshot));
bool anyChanges = false;
TargetFramework targetFramework = previousSnapshot.TargetFramework;
var dependencyById = previousSnapshot.Dependencies.ToDictionary(IDependencyExtensions.GetDependencyId);
if (changes != null && changes.RemovedNodes.Count != 0)
{
foreach (IDependencyModel removed in changes.RemovedNodes)
{
dependencyById.Remove(removed.GetDependencyId());
}
anyChanges = true;
}
if (changes != null && changes.AddedNodes.Count != 0)
{
foreach (IDependencyModel added in changes.AddedNodes)
{
#pragma warning disable CS0618 // Type or member is obsolete
// NOTE we still need to check this in case extensions (eg. WebTools) provide us with top level items that need to be filtered out
if (!added.TopLevel)
{
continue;
}
#pragma warning restore CS0618 // Type or member is obsolete
IDependency dependency = new Dependency(added);
DeduplicateCaptions(ref dependency, dependencyById);
dependencyById[dependency.GetDependencyId()] = dependency;
anyChanges = true;
}
}
// Also factor in any changes to path/framework/catalogs
anyChanges =
anyChanges ||
!targetFramework.Equals(previousSnapshot.TargetFramework) ||
!Equals(catalogs, previousSnapshot.Catalogs);
if (anyChanges)
{
return(new TargetedDependenciesSnapshot(
targetFramework,
catalogs,
dependencyById.ToImmutableValueArray()));
}
return(previousSnapshot);
}
public static bool IsEqualTo(this Assembly assembly, TargetFramework framework)
{
return AssemblyInfo.GetTargetFramework(assembly).IsEqualTo(framework);
}
public void SetTargetFramework(IAssemblyContext targetContext, TargetFramework targetVersion)
{
this.targetContext = targetContext;
this.targetVersion = targetVersion;
}
/// <summary>
/// Updates the <see cref="TargetedDependenciesSnapshot"/> corresponding to <paramref name="changedTargetFramework"/>,
/// returning either:
/// <list type="bullet">
/// <item>An updated <see cref="DependenciesSnapshot"/> object, or</item>
/// <item>the immutable <paramref name="previousSnapshot"/> if no changes were made.</item>
/// </list>
/// </summary>
/// <remarks>
/// As part of the update, each <see cref="IDependenciesSnapshotFilter"/> in <paramref name="snapshotFilters"/>
/// is given a chance to influence the addition and removal of dependency data in the returned snapshot.
/// </remarks>
/// <returns>An updated snapshot, or <paramref name="previousSnapshot"/> if no changes occured.</returns>
public static DependenciesSnapshot FromChanges(
DependenciesSnapshot previousSnapshot,
TargetFramework changedTargetFramework,
IDependenciesChanges?changes,
IProjectCatalogSnapshot?catalogs,
ImmutableArray <TargetFramework> targetFrameworks,
TargetFramework?activeTargetFramework,
ImmutableArray <IDependenciesSnapshotFilter> snapshotFilters,
IReadOnlyDictionary <string, IProjectDependenciesSubTreeProvider> subTreeProviderByProviderType,
IImmutableSet <string>?projectItemSpecs)
{
Requires.NotNull(previousSnapshot, nameof(previousSnapshot));
Requires.NotNull(changedTargetFramework, nameof(changedTargetFramework));
Requires.Argument(!snapshotFilters.IsDefault, nameof(snapshotFilters), "Cannot be default.");
Requires.NotNull(subTreeProviderByProviderType, nameof(subTreeProviderByProviderType));
var builder = previousSnapshot.DependenciesByTargetFramework.ToBuilder();
if (!builder.TryGetValue(changedTargetFramework, out TargetedDependenciesSnapshot previousTargetedSnapshot))
{
previousTargetedSnapshot = TargetedDependenciesSnapshot.CreateEmpty(changedTargetFramework, catalogs);
}
bool builderChanged = false;
var newTargetedSnapshot = TargetedDependenciesSnapshot.FromChanges(
previousTargetedSnapshot,
changes,
catalogs,
snapshotFilters,
subTreeProviderByProviderType,
projectItemSpecs);
if (!ReferenceEquals(previousTargetedSnapshot, newTargetedSnapshot))
{
builder[changedTargetFramework] = newTargetedSnapshot;
builderChanged = true;
}
SyncTargetFrameworks();
activeTargetFramework ??= previousSnapshot.ActiveTargetFramework;
if (builderChanged)
{
// Dependencies-by-target-framework has changed
return(new DependenciesSnapshot(
activeTargetFramework,
builder.ToImmutable()));
}
if (!activeTargetFramework.Equals(previousSnapshot.ActiveTargetFramework))
{
// The active target framework changed
return(new DependenciesSnapshot(
activeTargetFramework,
previousSnapshot.DependenciesByTargetFramework));
}
// Nothing has changed, so return the same snapshot
return(previousSnapshot);
void SyncTargetFrameworks()
{
// Only sync if a the full list of target frameworks has been provided
if (targetFrameworks.IsDefault)
{
return;
}
// This is a long-winded way of doing this that minimises allocations
// Ensure all required target frameworks are present
foreach (TargetFramework targetFramework in targetFrameworks)
{
if (!builder.ContainsKey(targetFramework))
{
builder.Add(targetFramework, TargetedDependenciesSnapshot.CreateEmpty(targetFramework, catalogs));
builderChanged = true;
}
}
// Remove any extra target frameworks
if (builder.Count != targetFrameworks.Length)
{
// NOTE We need "ToList" here as "Except" is lazy, and attempts to remove from the builder
// while iterating will throw "Collection was modified"
IEnumerable <TargetFramework> targetFrameworksToRemove = builder.Keys.Except(targetFrameworks).ToList();
foreach (TargetFramework targetFramework in targetFrameworksToRemove)
{
builder.Remove(targetFramework);
}
builderChanged = true;
}
}
}
public List <Project> AnalyzeProject(string projectPath, bool includeTransitiveDependencies, int transitiveDepth)
{
var dependencyGraph = _dependencyGraphService.GenerateDependencyGraph(projectPath);
if (dependencyGraph == null)
{
return(null);
}
var projects = new List <Project>();
foreach (var packageSpec in dependencyGraph.Projects.Where(p => p.RestoreMetadata.ProjectStyle == ProjectStyle.PackageReference))
{
// Restore the packages
_dotNetRestoreService.Restore(packageSpec.FilePath);
// Load the lock file
string lockFilePath = _fileSystem.Path.Combine(packageSpec.RestoreMetadata.OutputPath, "project.assets.json");
var lockFile = LockFileUtilities.GetLockFile(lockFilePath, NullLogger.Instance);
// Create a project
var project = new Project(packageSpec.Name, packageSpec.FilePath, packageSpec.RestoreMetadata.Sources.Select(s => s.SourceUri).ToList());
projects.Add(project);
// Get the target frameworks with their dependencies
foreach (var targetFrameworkInformation in packageSpec.TargetFrameworks)
{
var targetFramework = new TargetFramework(targetFrameworkInformation.FrameworkName);
project.TargetFrameworks.Add(targetFramework);
var target = lockFile.Targets.FirstOrDefault(t => t.TargetFramework.Equals(targetFrameworkInformation.FrameworkName));
if (target != null)
{
foreach (var projectDependency in targetFrameworkInformation.Dependencies)
{
var projectLibrary = target.Libraries.FirstOrDefault(library => string.Equals(library.Name, projectDependency.Name, StringComparison.OrdinalIgnoreCase));
bool isDevelopmentDependency = false;
if (projectLibrary != null)
{
// Determine whether this is a development dependency
var packageIdentity = new PackageIdentity(projectLibrary.Name, projectLibrary.Version);
var packageInfo = LocalFolderUtility.GetPackageV3(packageSpec.RestoreMetadata.PackagesPath, packageIdentity, NullLogger.Instance);
if (packageInfo != null)
{
isDevelopmentDependency = packageInfo.GetReader().GetDevelopmentDependency();
}
}
var dependency = new Dependency(projectDependency.Name, projectDependency.LibraryRange.VersionRange, projectLibrary?.Version,
projectDependency.AutoReferenced, false, isDevelopmentDependency);
targetFramework.Dependencies.Add(dependency);
// Process transitive dependencies for the library
if (includeTransitiveDependencies)
{
AddDependencies(targetFramework, projectLibrary, target, 1, transitiveDepth);
}
}
}
}
}
return(projects);
}
/// <summary>
/// Gets the type of the value field
/// </summary>
protected virtual NetTypeReference GetValueType(TargetFramework target)
{
return(target.TypeNameMap.GetByJavaClassName(ClassName));
}
public async Task <IRule?> GetBrowseObjectRuleAsync(IDependency dependency, TargetFramework targetFramework, IProjectCatalogSnapshot?catalogs)
{
Requires.NotNull(dependency, nameof(dependency));
IImmutableDictionary <string, IPropertyPagesCatalog> namedCatalogs = await GetNamedCatalogsAsync();
Requires.NotNull(namedCatalogs, nameof(namedCatalogs));
if (!namedCatalogs.TryGetValue(PropertyPageContexts.BrowseObject, out IPropertyPagesCatalog browseObjectsCatalog))
{
// Issue https://github.com/dotnet/project-system/issues/4860 suggests this code path
// can exist, however a repro was not found to dig deeper into the underlying cause.
// For now just return null as the upstream caller handles null correctly anyway.
return(null);
}
string?itemSpec = string.IsNullOrEmpty(dependency.OriginalItemSpec)
? dependency.FilePath
: dependency.OriginalItemSpec;
var context = ProjectPropertiesContext.GetContext(
UnconfiguredProject,
itemType: dependency.SchemaItemType,
itemName: itemSpec);
Rule?schema = dependency.SchemaName != null?browseObjectsCatalog.GetSchema(dependency.SchemaName) : null;
if (schema == null)
{
// Since we have no browse object, we still need to create *something* so
// that standard property pages can pop up.
Rule emptyRule = RuleExtensions.SynthesizeEmptyRule(context.ItemType);
return(GetConfiguredProjectExports().PropertyPagesDataModelProvider.GetRule(
emptyRule,
context.File,
context.ItemType,
context.ItemName));
}
if (dependency.Resolved && !Strings.IsNullOrEmpty(dependency.OriginalItemSpec))
{
return(GetConfiguredProjectExports().RuleFactory.CreateResolvedReferencePageRule(
schema,
context,
dependency.OriginalItemSpec,
dependency.BrowseObjectProperties));
}
return(browseObjectsCatalog.BindToContext(schema.Name, context));
async Task <IImmutableDictionary <string, IPropertyPagesCatalog> > GetNamedCatalogsAsync()
{
if (catalogs != null)
{
return(catalogs.NamedCatalogs);
}
if (_namedCatalogs == null)
{
Assumes.NotNull(ActiveConfiguredProject);
Assumes.Present(ActiveConfiguredProject.Services.PropertyPagesCatalog);
// Note: it is unlikely that we end up here, however for cases when node providers
// getting their node data not from Design time build events, we might have OnDependenciesChanged
// event coming before initial design time build event updates NamedCatalogs in this class.
// Thus, just in case, explicitly request it here (GetCatalogsAsync will acquire a project read lock)
_namedCatalogs = await ActiveConfiguredProject.Services.PropertyPagesCatalog.GetCatalogsAsync();
}
return(_namedCatalogs);
}
ConfiguredProjectExports GetConfiguredProjectExports()
{
Assumes.NotNull(ActiveConfiguredProject);
ConfiguredProject project = targetFramework.Equals(TargetFramework.Any)
? ActiveConfiguredProject
: _dependenciesSnapshotProvider.GetConfiguredProject(targetFramework) ?? ActiveConfiguredProject;
return(GetActiveConfiguredProjectExports(project));
}
}
