/// <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)); } }