public ReferenceIntegrityCheckReport Report(ProjectReference reference) { const string identity = "ContainsReferencedProjectsCheck"; if (this.IsSatisfiedBy(reference)) { return ReferenceIntegrityCheckReport.Ok(identity, reference); } ReportMessage message; if (!ContainsInSolution(this.projectsInSolution, reference)) { string solutionName = this.projectsInSolution.First().Referrer; message = ReportMessage.Error("The solution '{0}' doesn't contain project '{1}'.", solutionName, reference.Name); return ReferenceIntegrityCheckReport.NotOk(message, identity, reference); } ProjectReference[] projectReferences = this.parser.ParseProjectReferences(reference.FullPath); string missingReferenceNames = string.Join(", ", projectReferences .Where(r => !ContainsInSolution(this.projectsInSolution ,r)) .Select(r => r.Name)); message = ReportMessage.Error("The solution '{0}' doesn't contain '{1}', but '{2}' requires it to be.", reference.Referrer, missingReferenceNames, reference.Name); return ReferenceIntegrityCheckReport.NotOk(message, identity, reference); }
public void ProjectReferenceQuestion() { var optionValue = new ProjectReference( "ProjPath", new Guid( "76606c7b-5bf1-497c-9b0f-9695a6a8788d" ), "ProjectName", new XElement( "ProjectReference" ) ); var option = new UserQuestionLiteralWithDescriptionOption<ProjectReference>( "A", "Option A", optionValue, "WasNull" ); Assert.That( option.GetQuestionText(), Is.EqualTo( "(A) Option A:\r\nName: ProjectName\r\nKey: 76606c7b-5bf1-497c-9b0f-9695a6a8788d\r\nPath: ProjPath\r\n" ) ); Assert.That( option.GetValue(), Is.EqualTo( optionValue ) ); }
public AddMissingReferenceCodeAction(Project project, string title, ProjectReference projectReferenceToAdd, AssemblyIdentity missingAssemblyIdentity) { _project = project; Title = title; _projectReferenceToAdd = projectReferenceToAdd; _missingAssemblyIdentity = missingAssemblyIdentity; }
public override void LoadProject (IProgressMonitor monitor, SolutionEntityItem item, MSBuildProject msproject) { base.LoadProject (monitor, item, msproject); var dnp = item as DotNetProject; if (dnp == null) return; // Convert .projitems imports into project references foreach (var sp in msproject.Imports.Where (im => im.Label == "Shared" && im.Project.EndsWith (".projitems"))) { var projitemsFile = sp.Project; if (!string.IsNullOrEmpty (projitemsFile)) { projitemsFile = MSBuildProjectService.FromMSBuildPath (item.ItemDirectory, projitemsFile); projitemsFile = Path.Combine (Path.GetDirectoryName (msproject.FileName), projitemsFile); if (File.Exists (projitemsFile)) { MSBuildSerializer iser = Handler.CreateSerializer (); iser.SerializationContext.BaseFile = projitemsFile; iser.SerializationContext.ProgressMonitor = monitor; MSBuildProject p = new MSBuildProject (); p.Load (projitemsFile); Handler.LoadProjectItems (p, iser, ProjectItemFlags.Hidden | ProjectItemFlags.DontPersist); var r = new ProjectReference (ReferenceType.Project, Path.GetFileNameWithoutExtension (projitemsFile)); r.Flags = ProjectItemFlags.DontPersist; r.SetItemsProjectPath (projitemsFile); dnp.References.Add (r); } } } }
public Task AddReferenceAsync(ProjectReference reference, CancellationToken cancellationToken = default(CancellationToken)) { if (reference == null) { return MakeExceptionTask(new ArgumentNullException("reference")); } EnsureInstanceDb(); switch (reference.Kind) { case ProjectReferenceKind.ExtensionModule: if (_references == null) { _references = new HashSet<ProjectReference>(); } _references.Add(reference); string filename; try { filename = Path.GetFileNameWithoutExtension(reference.Name); } catch (Exception e) { return MakeExceptionTask(e); } return _typeDb.LoadExtensionModuleAsync(_factory, filename, reference.Name, cancellationToken).ContinueWith(RaiseModulesChanged); } return Task.Factory.StartNew(EmptyTask); }
internal static bool TryGetReference( Solution solution, ProjectReference projectReference, Compilation finalOrDeclarationCompilation, VersionStamp version, out MetadataReference reference) { // if we have one from snapshot cache, use it. it will make sure same compilation will get same metadata reference always. MetadataOnlyReferenceSet referenceSet; if (s_snapshotCache.TryGetValue(finalOrDeclarationCompilation, out referenceSet)) { reference = referenceSet.GetMetadataReference(finalOrDeclarationCompilation, projectReference.Aliases, projectReference.EmbedInteropTypes); return true; } // okay, now use version based cache that can live multiple compilation as long as there is no semantic changes. // get one for the branch if (TryGetReferenceFromBranch(solution.BranchId, projectReference, finalOrDeclarationCompilation, version, out reference)) { return true; } // see whether we can use primary branch one var primaryBranchId = solution.Workspace.PrimaryBranchId; if (solution.BranchId != primaryBranchId && TryGetReferenceFromBranch(primaryBranchId, projectReference, finalOrDeclarationCompilation, version, out reference)) { return true; } // noop, we don't have any reference = null; return false; }
private SerializableProjectReference(SerializationInfo info, StreamingContext context) { var projectId = ((SerializableProjectId)info.GetValue("projectId", typeof(SerializableProjectId))).ProjectId; var aliases = ImmutableArray.Create((string[])info.GetValue("aliases", typeof(string[]))); var embedInteropTypes = info.GetBoolean("embedInteropTypes"); _projectReference = new ProjectReference(projectId, aliases, embedInteropTypes); }
public SerializableProjectReference(ProjectReference projectReference) { if (projectReference == null) { throw new ArgumentNullException(nameof(projectReference)); } _projectReference = projectReference; }
internal static MetadataReference GetOrBuildReference( Solution solution, ProjectReference projectReference, Compilation finalCompilation, VersionStamp version, CancellationToken cancellationToken) { MetadataReference reference; if (TryGetReference(solution, projectReference, finalCompilation, version, out reference)) { return reference; } // okay, we don't have one. so create one now. // first, prepare image // * NOTE * image is cancellable, do not create it inside of conditional weak table. var service = solution.Workspace.Services.GetService<ITemporaryStorageService>(); var image = MetadataOnlyImage.Create(service, finalCompilation, cancellationToken); if (image.IsEmpty) { // unfortunately, we couldn't create one. do best effort if (TryGetReference(solution, projectReference, finalCompilation, VersionStamp.Default, out reference)) { // we have one from previous compilation!!, it might be out-of-date big time, but better than nothing. // re-use it return reference; } } // okay, proceed with whatever image we have // now, remove existing set var mapFromBranch = s_cache.GetValue(solution.BranchId, s_createReferenceSetMap); mapFromBranch.Remove(projectReference.ProjectId); // create new one var newReferenceSet = new MetadataOnlyReferenceSet(version, image); var referenceSet = s_snapshotCache.GetValue(finalCompilation, _ => newReferenceSet); if (newReferenceSet != referenceSet) { // someone else has beaten us. // let image go eagerly. otherwise, finalizer in temporary storage will take care of it image.Cleanup(); // return new reference return referenceSet.GetMetadataReference(finalCompilation, projectReference.Aliases, projectReference.EmbedInteropTypes); } // record it to version based cache as well. snapshot cache always has a higher priority. we don't need to check returned set here // since snapshot based cache will take care of same compilation for us. mapFromBranch.GetValue(projectReference.ProjectId, _ => referenceSet); // return new reference return referenceSet.GetMetadataReference(finalCompilation, projectReference.Aliases, projectReference.EmbedInteropTypes); }
public void creating_a_project_references_from_a_project_copies_attributes() { var sourceProject = new CsProjFile(@"Solution1\harness\SlickGridHarness.csproj"); var targetProject = new CsProjFile(@"Solution1\docs\FubuMVC.SlickGrid.Docs.csproj"); var projectReference = new ProjectReference(targetProject, sourceProject); projectReference.Include.ShouldEqual(@"..\harness\SlickGridHarness.csproj"); projectReference.ProjectGuid.ShouldEqual(sourceProject.ProjectGuid); projectReference.ProjectName.ShouldEqual(sourceProject.ProjectName); }
public Given_a_project_with_a_reference_for_a_project_not_existing_in_solution() { var projectsInSolution = new[] { ProjectReferenceTestSample.ReferenceFromSolutionToProjectWithoutReferences, ProjectReferenceTestSample.ReferenceFromSolutionToProjectWithReferences }; var parserMock = new Mock<IProjectParser>(); parserMock .Setup(p => p.ParseProjectReferences(ProjectReferenceTestSample.ReferenceFromSolutionToProjectWithReferences.FullPath)) .Returns(new[] { ProjectReferenceTestSample.ReferenceFromProjectToAProjectWithSameName }); this.check = new ProjectReferenceExistsInSolutionCheck(projectsInSolution, parserMock.Object); this.reference = ProjectReferenceTestSample.ReferenceFromSolutionToProjectWithReferences; }
private AssemblyDefinition ReadAssembly(ProjectReference projectReference) { AssemblyDefinition assemblyDefinition = null; if (!m_cache.TryGetValue(projectReference, out assemblyDefinition)) { assemblyDefinition = ReadAssembly( projectReference.Location, Path.GetDirectoryName(projectReference.Location)); if (assemblyDefinition != null) m_cache[projectReference] = assemblyDefinition; } return assemblyDefinition; }
public Given_a_reference_with_path_which_does_not_exist() { this.reference = new ProjectReference { Name = "what", Path = "what.csproj", Referrer = "project", SourceType = ReferenceSourceType.Project }; this.check = new SolutionIntegrityCheck( new MockFileSystem(new Dictionary<string, MockFileData> { { "any.csproj", new MockFileData(String.Empty) } }), new ProjectReference[0], Mock.Of<IProjectParser>()); }
public Given_a_project_with_a_reference_which_does_not_exist_in_solution() { var projectsInSolution = new[] { ProjectReferenceTestSample.ReferenceFromSolutionToProjectWithReferences }; var parserMock = new Mock<IProjectParser>(); parserMock .Setup(p => p.ParseProjectReferences(ProjectReferenceTestSample.ReferenceFromSolutionToProjectWithReferences.FullPath)) .Returns(new[] { ProjectReferenceTestSample.ReferenceFromProjectToAProjectWithSameName }); var fileSystem = new MockFileSystem(new Dictionary<string, MockFileData> { {Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, "testB.csproj")), new MockFileData(String.Empty)} }); this.reference = ProjectReferenceTestSample.ReferenceFromSolutionToProjectWithReferences; this.check = new SolutionIntegrityCheck(fileSystem, projectsInSolution, parserMock.Object); }
private static bool IsEquals(AssemblyNameReference name, ProjectReference projectReference) { var result = string. Equals(name.Name, projectReference.Name, StringComparison.InvariantCultureIgnoreCase) && string. Equals(name.Culture, projectReference.Culture, StringComparison.InvariantCultureIgnoreCase); if (result) { var token = (name.PublicKeyToken == null || name.PublicKeyToken.Length == 0) ? string.Empty : Helper.PublicKeyTokenConvertFrom(name.PublicKeyToken); result = string. Equals(token, projectReference.PublicKeyToken, StringComparison.InvariantCultureIgnoreCase); } return result; }
internal void TryProjectConversionForIntroducedOutputPath(string binPath, AbstractProject projectToReference) { AssertIsForeground(); if (this.CanConvertToProjectReferences) { // We should not already have references for this, since we're only introducing the path for the first time Contract.ThrowIfTrue(HasMetadataFileNameToConvertedProjectReference(binPath)); var metadataReference = TryGetCurrentMetadataReference(binPath); if (metadataReference != null) { var projectReference = new ProjectReference( projectToReference.Id, metadataReference.Properties.Aliases, metadataReference.Properties.EmbedInteropTypes); if (CanAddProjectReference(projectReference)) { RemoveMetadataReferenceCore(metadataReference, disposeReference: true); AddProjectReference(projectReference); AddMetadataFileNameToConvertedProjectReference(binPath, projectReference); } } } }
private void UpdateMetadataFileNameToConvertedProjectReference(string filePath, ProjectReference projectReference) { lock (_gate) { _metadataFileNameToConvertedProjectReference[filePath] = projectReference; } }
private void AddMetadataFileNameToConvertedProjectReference(string filePath, ProjectReference projectReference) { lock (_gate) { _metadataFileNameToConvertedProjectReference.Add(filePath, projectReference); } }
protected void RemoveProjectReference(ProjectReference projectReference) { AssertIsForeground(); lock (_gate) { Contract.ThrowIfFalse(_projectReferences.Remove(projectReference)); } if (_pushingChangesToWorkspaceHosts) { this.ProjectTracker.NotifyWorkspaceHosts(host => host.OnProjectReferenceRemoved(this.Id, projectReference)); } }
public override void OnNodeDrop(object dataObject, DragOperation operation) { // It allows dropping either project references or projects. // Dropping a project creates a new project reference to that project DotNetProject project = dataObject as DotNetProject; if (project != null) { ProjectReference pr = new ProjectReference(project); DotNetProject p = CurrentNode.GetParentDataItem(typeof(DotNetProject), false) as DotNetProject; // Circular dependencies are not allowed. if (HasCircularReference(project, p.Name)) { return; } // If the reference already exists, bail out if (ProjectReferencesProject(p, project.Name)) { return; } p.References.Add(pr); IdeApp.ProjectOperations.Save(p); return; } // It's dropping a ProjectReference object. ProjectReference pref = dataObject as ProjectReference; ITreeNavigator nav = CurrentNode; if (operation == DragOperation.Move) { NodePosition pos = nav.CurrentPosition; nav.MoveToObject(dataObject); DotNetProject p = nav.GetParentDataItem(typeof(DotNetProject), true) as DotNetProject; nav.MoveToPosition(pos); DotNetProject p2 = nav.GetParentDataItem(typeof(DotNetProject), true) as DotNetProject; p.References.Remove(pref); // Check if there is a cyclic reference after removing from the source project if (pref.ReferenceType == ReferenceType.Project) { DotNetProject pdest = p.ParentSolution.FindProjectByName(pref.Reference) as DotNetProject; if (pdest == null || ProjectReferencesProject(pdest, p2.Name)) { // Restore the dep p.References.Add(pref); return; } } p2.References.Add(pref); IdeApp.ProjectOperations.Save(p); IdeApp.ProjectOperations.Save(p2); } else { nav.MoveToParent(typeof(DotNetProject)); DotNetProject p = nav.DataItem as DotNetProject; // Check for cyclic referencies if (pref.ReferenceType == ReferenceType.Project) { DotNetProject pdest = p.ParentSolution.FindProjectByName(pref.Reference) as DotNetProject; if (pdest == null) { return; } if (HasCircularReference(pdest, p.Name)) { return; } // The reference is already there if (ProjectReferencesProject(p, pdest.Name)) { return; } } p.References.Add((ProjectReference)pref.Clone()); IdeApp.ProjectOperations.Save(p); } }
static bool UpgradeMonoGameProject(MonoDevelop.Core.ProgressMonitor monitor, DotNetProjectExtension extension, MSBuildProject project) { bool needsSave = false; bool containsMGCB = project.ItemGroups.Any(x => x.Items.Any(i => System.IO.Path.GetExtension(i.Include) == ".mgcb")); bool isMonoGame = project.PropertyGroups.Any(x => x.GetProperties().Any(p => p.Name == "MonoGamePlatform")) || project.ItemGroups.Any(x => x.Items.Any(i => i.Name == "Reference" && i.Include == "MonoGame.Framework")) || containsMGCB; bool isDesktopGL = project.ItemGroups.Any(x => x.Items.Any(i => i.Include.EndsWith("SDL2.dll"))); bool isApplication = project.PropertyGroups.Any(x => x.GetProperties().Any(p => p.Name == "OutputType" && p.Value == "Exe")) | project.PropertyGroups.Any(x => x.GetProperties().Any(p => p.Name == "AndroidApplication" && string.Compare(p.Value, bool.TrueString, true) == 0)); bool isShared = project.PropertyGroups.Any(x => x.GetProperties().Any(p => p.Name == "HasSharedItems" && p.Value == "true")); bool absoluteReferenes = false; var type = extension.Project.GetType().Name; monitor.Log.WriteLine("Found {0}", type); monitor.Log.WriteLine("Found {0}", project.GetType().Name); var platform = isDesktopGL ? "DesktopGL" : "Windows"; var path = MonoGameExtensionsPath; if (extension.Project.FlavorGuids.Contains("{FEACFBD2-3405-455C-9665-78FE426C6842}")) { platform = "iOS"; } if (extension.Project.FlavorGuids.Contains("{06FA79CB-D6CD-4721-BB4B-1BD202089C55}")) { platform = "tvOS"; } if (extension.Project.FlavorGuids.Contains("{EFBA0AD7-5A72-4C68-AF49-83D382785DCF}")) { platform = "Android"; } if (extension.Project.FlavorGuids.Contains("{948B3504-5B70-4649-8FE4-BDE1FB46EC69}")) { platform = "MacOSX"; // MonoMac Classic does not use MSBuild so we need to absolute path. path = MonoGameExtensionsAbsolutePath; absoluteReferenes = true; } if (extension.Project.FlavorGuids.Contains("{42C0BBD9-55CE-4FC1-8D90-A7348ABAFB23}")) { platform = "DesktopGL"; // Xamarin.Mac Classic does not use MSBuild so we need to absolute path. path = MonoGameExtensionsAbsolutePath; absoluteReferenes = true; } if (extension.Project.FlavorGuids.Contains("{A3F8F2AB-B479-4A4A-A458-A89E7DC349F1}")) { platform = "DesktopGL"; } monitor.Log.WriteLine("Platform = {0}", platform); monitor.Log.WriteLine("Path = {0}", path); monitor.Log.WriteLine("isMonoGame {0}", isMonoGame); if (isMonoGame) { var ritems = new List <MSBuildItem> (); foreach (var ig in project.ItemGroups) { foreach (var i in ig.Items.Where(x => x.Name == "Reference" && x.Include == "MonoGame.Framework")) { var metaData = i.Metadata; if (!metaData.HasProperty("HintPath")) { monitor.Log.WriteLine("Fixing {0} to be MonoGameContentReference", i.Include); metaData.SetValue("HintPath", string.Format(path, platform, "MonoGame.Framework.dll")); needsSave = true; } } foreach (var i in ig.Items.Where(x => x.Name == "Reference" && x.Include == "Tao.Sdl")) { var metaData = i.Metadata; if (!metaData.HasProperty("HintPath")) { monitor.Log.WriteLine("Fixing {0} to be Tao.Sdl", i.Include); metaData.SetValue("HintPath", string.Format(path, platform, "Tao.Sdl.dll")); needsSave = true; } } foreach (var i in ig.Items.Where(x => x.Name == "Reference" && x.Include.StartsWith("OpenTK") && (platform != "iOS" && platform != "Android"))) { var metaData = i.Metadata; if (!metaData.HasProperty("HintPath")) { monitor.Log.WriteLine("Fixing {0} to be OpenTK", i.Include); metaData.SetValue("HintPath", string.Format(path, platform, "OpenTK.dll")); metaData.SetValue("SpecificVersion", "true"); needsSave = true; } } } foreach (var a in ritems) { project.RemoveItem(a); } var dotNetProject = extension.Project; if (dotNetProject != null && absoluteReferenes) { var items = new List <ProjectReference> (); var newitems = new List <ProjectReference> (); foreach (var reference in dotNetProject.References) { if (reference.Reference == "MonoGame.Framework" && string.IsNullOrEmpty(reference.HintPath)) { items.Add(reference); newitems.Add(ProjectReference.CreateCustomReference(ReferenceType.Assembly, reference.Reference, string.Format(path, platform, "MonoGame.Framework.dll"))); } if (reference.Reference.StartsWith("OpenTK", StringComparison.OrdinalIgnoreCase) && string.IsNullOrEmpty(reference.HintPath)) { items.Add(reference); newitems.Add(ProjectReference.CreateCustomReference(ReferenceType.Assembly, reference.Reference, string.Format(path, platform, "OpenTK.dll"))); } if (reference.Reference == "Tao.Sdl" && string.IsNullOrEmpty(reference.HintPath)) { items.Add(reference); newitems.Add(ProjectReference.CreateCustomReference(ReferenceType.Assembly, reference.Reference, string.Format(path, platform, "Tao.Sdl.dll"))); } } dotNetProject.References.RemoveRange(items); dotNetProject.References.AddRange(newitems); } } if (isMonoGame && containsMGCB && (isApplication || isShared)) { if (!project.PropertyGroups.Any(x => x.GetProperties().Any(p => p.Name == "MonoGamePlatform")) && !isShared) { monitor.Log.WriteLine("Adding MonoGamePlatform {0}", platform == "tvOS" ? "iOS" : platform); project.PropertyGroups.First().SetValue("MonoGamePlatform", platform == "tvOS" ? "iOS" : platform, true); needsSave = true; } if (!project.Imports.Any(x => x.Project.StartsWith(MonoGameCommonProps, StringComparison.OrdinalIgnoreCase)) && !isShared) { monitor.Log.WriteLine("Adding MonoGame.Common.props Import"); project.AddNewImport(MonoGameCommonProps, string.Format("Exists('{0}')", MonoGameCommonProps), project.PropertyGroups.First()); needsSave = true; } if (containsMGCB) { var ritems = new List <MSBuildItem> (); foreach (var ig in project.ItemGroups) { foreach (var i in ig.Items.Where(x => System.IO.Path.GetExtension(x.Include) == ".mgcb")) { if (i.Name != "MonoGameContentReference" && i.Name == "None") { monitor.Log.WriteLine("Fixing {0} to be MonoGameContentReference", i.Include); ig.AddNewItem("MonoGameContentReference", i.Include); ritems.Add(i); needsSave = true; } } } foreach (var a in ritems) { project.RemoveItem(a); } } if (!project.Imports.Any(x => x.Project.StartsWith(MonoGameContentBuildTargets, StringComparison.OrdinalIgnoreCase)) && !isShared) { monitor.Log.WriteLine("Adding MonoGame Content Builder .targets"); project.AddNewImport(MonoGameContentBuildTargets); needsSave = true; } } return(needsSave); }
/// <summary> /// Constructs a new client wrapping the given <see cref="BigqueryService"/>. /// </summary> /// <remarks> /// Care should be taken when constructing the service: if the default serializer settings are used, /// result values which can be parsed as date/time values can cause problems. Where possible, either use /// <see cref="BigQueryClient.Create(string, Apis.Auth.OAuth2.GoogleCredential)"/> or construct a service /// using serializer settings from <see cref="BigQueryClient.CreateJsonSerializersSettings"/>. /// </remarks> /// <param name="projectReference">A fully-qualified identifier for the project. Must not be null.</param> /// <param name="service">The service to wrap. Must not be null.</param> public BigQueryClientImpl(ProjectReference projectReference, BigqueryService service) : this(projectReference, service, null) { }
public void InitializeItem(SolutionItem policyParent, ProjectCreateInformation projectCreateInformation, string defaultLanguage, SolutionEntityItem item) { MonoDevelop.Projects.Project project = item as MonoDevelop.Projects.Project; if (project == null) { MessageService.ShowError(GettextCatalog.GetString("Can't create project with type: {0}", type)); return; } // Set the file before setting the name, to make sure the file extension is kept project.FileName = Path.Combine(projectCreateInformation.ProjectBasePath, projectCreateInformation.ProjectName); project.Name = projectCreateInformation.ProjectName; var dnp = project as DotNetProject; if (dnp != null) { if (policyParent.ParentSolution != null && !policyParent.ParentSolution.FileFormat.SupportsFramework(dnp.TargetFramework)) { SetClosestSupportedTargetFramework(policyParent.ParentSolution.FileFormat, dnp); } var substitution = new string[, ] { { "ProjectName", GetProjectNameForSubstitution(projectCreateInformation) } }; foreach (var desc in references) { if (!projectCreateInformation.ShouldCreate(desc.CreateCondition)) { continue; } if (desc.ProjectReference.ReferenceType == ReferenceType.Project) { string referencedProjectName = StringParserService.Parse(desc.ProjectReference.Reference, substitution); var parsedReference = ProjectReference.RenameReference(desc.ProjectReference, referencedProjectName); dnp.References.Add(parsedReference); } else { dnp.References.Add(desc.ProjectReference); } } } foreach (SingleFileDescriptionTemplate resourceTemplate in resources) { try { if (!projectCreateInformation.ShouldCreate(resourceTemplate.CreateCondition)) { continue; } var projectFile = new ProjectFile(resourceTemplate.SaveFile(policyParent, project, defaultLanguage, project.BaseDirectory, null)); projectFile.BuildAction = BuildAction.EmbeddedResource; project.Files.Add(projectFile); } catch (Exception ex) { if (!IdeApp.IsInitialized) { throw; } MessageService.ShowError(GettextCatalog.GetString("File {0} could not be written.", resourceTemplate.Name), ex); } } foreach (FileDescriptionTemplate fileTemplate in files) { try { if (!projectCreateInformation.ShouldCreate(fileTemplate.CreateCondition)) { continue; } fileTemplate.SetProjectTagModel(projectCreateInformation.Parameters); fileTemplate.AddToProject(policyParent, project, defaultLanguage, project.BaseDirectory, null); } catch (Exception ex) { if (!IdeApp.IsInitialized) { throw; } MessageService.ShowError(GettextCatalog.GetString("File {0} could not be written.", fileTemplate.Name), ex); } finally { fileTemplate.SetProjectTagModel(null); } } }
/// <summary> /// Constructs a new client wrapping the given <see cref="BigqueryService"/>, with a specified default location /// for location-specific operations. /// </summary> /// <remarks> /// Care should be taken when constructing the service: if the default serializer settings are used, /// result values which can be parsed as date/time values can cause problems. Where possible, either use /// <see cref="BigQueryClient.Create(string, Apis.Auth.OAuth2.GoogleCredential)"/> or construct a service /// using serializer settings from <see cref="BigQueryClient.CreateJsonSerializersSettings"/>. /// </remarks> /// <param name="projectReference">A fully-qualified identifier for the project. Must not be null.</param> /// <param name="service">The service to wrap. Must not be null.</param> /// <param name="defaultLocation">The default location to use for location-specific operations. May be null.</param> public BigQueryClientImpl(ProjectReference projectReference, BigqueryService service, string defaultLocation) : this(GaxPreconditions.CheckNotNull(projectReference, nameof(projectReference)).ProjectId, service, defaultLocation) { }
public void OnProjectReferenceRemoved(ProjectId projectId, ProjectReference projectReference) { }
public void OnProjectReferenceAdded(ProjectId projectId, ProjectReference projectReference) { }
public void AddProjectReference(ProjectId projectId, ProjectReference projectReference) { OnProjectReferenceAdded(projectId, projectReference); }
public void RemoveProjectReference(ProjectId projectId, ProjectReference projectReference) { OnProjectReferenceRemoved(projectId, projectReference); }
public override void OnNodeRemoved(object dataObject) { ProjectReference pref = (ProjectReference)dataObject; pref.StatusChanged -= ReferenceStatusChanged; }
public void can_write_and_read_project_references() { var include = @"..\OtherProject\OtherProject.csproj"; var project = CsProjFile.CreateAtSolutionDirectory("MyProj", "myproj"); var reference1 = new ProjectReference(include) { ProjectName = "OtherProject", ProjectGuid = Guid.NewGuid() }; project.Add(reference1); project.Save(); var project2 = CsProjFile.LoadFrom(project.FileName); var reference2 = project2.Find<ProjectReference>(reference1.Include); var all = project2.All<ProjectReference>(); reference2.ShouldNotBeNull(); reference2.ProjectName.ShouldEqual(reference1.ProjectName); reference2.ProjectGuid.ShouldEqual(reference1.ProjectGuid); }
public override bool HasChildNodes(MonoDevelop.Ide.Gui.Components.ITreeBuilder builder, object dataObject) { ProjectReference pref = (ProjectReference)dataObject; return(!pref.IsValid); }
/// <summary> /// Attempts to get (without waiting) a metadata reference to a possibly in progress /// compilation. Actual compilation references are preferred over skeletal assembly /// references. Could potentially return null if nothing can be provided. /// </summary> internal MetadataReference GetPartialMetadataReference(Solution solution, ProjectState fromProject, ProjectReference projectReference, CancellationToken cancellationToken) { var state = this.ReadState(); // get compilation in any state it happens to be in right now. Compilation compilation; if (state.Compilation.TryGetValue(out compilation) && compilation != null && this.ProjectState.LanguageServices == fromProject.LanguageServices) { // if we have a compilation and its the correct language, use a simple compilation reference return compilation.ToMetadataReference(projectReference.Aliases, projectReference.EmbedInteropTypes); } return null; }
Task EnsureAnalysisDocumentIsOpen() { if (analysisDocument != null) { Microsoft.CodeAnalysis.Document doc; try { doc = RoslynWorkspace.CurrentSolution.GetDocument(analysisDocument); } catch (Exception) { doc = null; } if (doc != null) { return(Task.CompletedTask); } } if (Editor == null) { UnsubscribeAnalysisDocument(); return(Task.CompletedTask); } if (Project != null && !IsUnreferencedSharedProject(Project)) { lock (analysisDocumentLock) { UnsubscribeRoslynWorkspace(); RoslynWorkspace = TypeSystemService.GetWorkspace(this.Project.ParentSolution); if (RoslynWorkspace == null) // Solution not loaded yet { return(Task.CompletedTask); } SubscribeRoslynWorkspace(); analysisDocument = FileName != null?TypeSystemService.GetDocumentId(this.Project, this.FileName) : null; if (analysisDocument != null) { TypeSystemService.InformDocumentOpen(analysisDocument, Editor); return(Task.CompletedTask); } } } lock (adhocProjectLock) { var token = analysisDocumentSrc.Token; if (adhocProject != null) { return(Task.CompletedTask); } if (Editor != null) { var node = TypeSystemService.GetTypeSystemParserNode(Editor.MimeType, BuildAction.Compile); if (Editor.MimeType == "text/x-csharp" || node?.Parser.CanGenerateAnalysisDocument(Editor.MimeType, BuildAction.Compile, new string[0]) == true) { var newProject = Services.ProjectService.CreateDotNetProject("C#"); this.adhocProject = newProject; newProject.Name = "InvisibleProject"; newProject.References.Add(ProjectReference.CreateAssemblyReference("mscorlib")); newProject.References.Add(ProjectReference.CreateAssemblyReference("System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")); newProject.References.Add(ProjectReference.CreateAssemblyReference("System.Core")); newProject.FileName = "test.csproj"; if (!Window.ViewContent.IsUntitled) { adHocFile = Editor.FileName; } else { adHocFile = (Platform.IsWindows ? "C:\\" : "/") + Window.ViewContent.UntitledName + ".cs"; } newProject.Files.Add(new ProjectFile(adHocFile, BuildAction.Compile)); adhocSolution = new Solution(); adhocSolution.AddConfiguration("", true); adhocSolution.DefaultSolutionFolder.AddItem(newProject); return(TypeSystemService.Load(adhocSolution, new ProgressMonitor(), token, false).ContinueWith(task => { if (token.IsCancellationRequested) { return; } UnsubscribeRoslynWorkspace(); RoslynWorkspace = task.Result.FirstOrDefault(); // 1 solution loaded ->1 workspace as result SubscribeRoslynWorkspace(); analysisDocument = RoslynWorkspace.CurrentSolution.Projects.First().DocumentIds.First(); TypeSystemService.InformDocumentOpen(RoslynWorkspace, analysisDocument, Editor); })); } } } return(Task.CompletedTask); }
public ProjectReferenceDescriptor(ProjectReference pref) { this.pref = pref; }
public void TestAddP2PReference1() { using (var workspace = CreateWorkspace()) { var solution = workspace.CurrentSolution; var project1 = new TestHostProject(workspace, name: "project1"); var project2 = new TestHostProject(workspace, name: "project2"); workspace.AddTestProject(project1); workspace.AddTestProject(project2); var reference = new ProjectReference(project2.Id); workspace.OnProjectReferenceAdded(project1.Id, reference); var snapshot = workspace.CurrentSolution; var id1 = snapshot.Projects.First(p => p.Name == project1.Name).Id; var id2 = snapshot.Projects.First(p => p.Name == project2.Name).Id; Assert.True(snapshot.GetProject(id1).ProjectReferences.Contains(reference), "ProjectReferences did not contain project2"); } }
void LogRemovedReferenceFromProject(ProjectReference referenceProjectItem) { LogRemovedReferenceFromProject(referenceProjectItem.Reference, ProjectName); }
/// <summary> /// Get a metadata reference to this compilation info's compilation with respect to /// another project. For cross language references produce a skeletal assembly. If the /// compilation is not available, it is built. If a skeletal assembly reference is /// needed and does not exist, it is also built. /// </summary> internal async Task<MetadataReference> GetMetadataReferenceAsync( Solution solution, ProjectState fromProject, ProjectReference projectReference, CancellationToken cancellationToken) { Compilation compilation; // if we already have the compilation and its right kind then use it. if (this.ProjectState.LanguageServices == fromProject.LanguageServices && this.TryGetCompilation(out compilation)) { return compilation.ToMetadataReference(projectReference.Aliases, projectReference.EmbedInteropTypes); } // If same language then we can wrap the other project's compilation into a compilation reference if (this.ProjectState.LanguageServices == fromProject.LanguageServices) { // otherwise, base it off the compilation by building it first. compilation = await this.GetCompilationAsync(solution, cancellationToken).ConfigureAwait(false); return compilation.ToMetadataReference(projectReference.Aliases, projectReference.EmbedInteropTypes); } else { // otherwise get a metadata only image reference that is built by emitting the metadata from the referenced project's compilation and re-importing it. return await this.GetMetadataOnlyImageReferenceAsync(solution, projectReference, cancellationToken).ConfigureAwait(false); } }
void LogAddedReferenceToProject(ProjectReference referenceProjectItem) { LogAddedReferenceToProject(referenceProjectItem.Reference, ProjectName); }
/// <summary> /// Gets a metadata reference to a the metadata-only-image corresponding to the compilation. /// </summary> private async Task<MetadataReference> GetMetadataOnlyImageReferenceAsync( Solution solution, ProjectReference projectReference, CancellationToken cancellationToken) { using (Logger.LogBlock(FeatureId.SkeletonAssembly, FunctionId.SkeletonAssembly_GetMetadataOnlyImage, cancellationToken)) { var projectId = this.ProjectState.Id; var version = await this.GetDependentSemanticVersionAsync(solution, cancellationToken).ConfigureAwait(false); // get or build compilation up to decleration state. this compilation will be used to provide live xml doc comment var declarationCompilation = await this.GetOrBuildDeclarationCompilationAsync(solution, cancellationToken: cancellationToken).ConfigureAwait(false); MetadataReference reference; if (!MetadataOnlyReference.TryGetReference(solution, projectReference, declarationCompilation, version, out reference)) { // using async build lock so we don't get multiple consumers attempting to build metadata-only images for the same compilation. using (await this.buildLock.DisposableWaitAsync(cancellationToken).ConfigureAwait(false)) { // okay, we still don't have one. bring the compilation to final state since we are going to use it to create skeleton assembly var compilation = await this.GetOrBuildCompilationAsync(solution, lockGate: false, cancellationToken: cancellationToken).ConfigureAwait(false); reference = MetadataOnlyReference.GetOrBuildReference(solution, projectReference, compilation, version, cancellationToken); } } return reference; } }
protected bool CanAddProjectReference(ProjectReference projectReference) { if (projectReference.ProjectId == this.Id) { // cannot self reference return false; } lock (_gate) { if (_projectReferences.Contains(projectReference)) { // already have this reference return false; } } var project = this.ProjectTracker.GetProject(projectReference.ProjectId); if (project != null) { // cannot add a reference to a project that references us (it would make a cycle) return !project.TransitivelyReferences(this.Id); } return true; }
protected void UpdateProjectReferenceAliases(AbstractProject referencedProject, ImmutableArray<string> aliases) { AssertIsForeground(); var projectReference = GetCurrentProjectReferences().Single(r => r.ProjectId == referencedProject.Id); var newProjectReference = new ProjectReference(referencedProject.Id, aliases, projectReference.EmbedInteropTypes); // Is this a project with converted references? If so, make sure we track it string referenceBinPath = referencedProject.BinOutputPath; if (referenceBinPath != null && HasMetadataFileNameToConvertedProjectReference(referenceBinPath)) { UpdateMetadataFileNameToConvertedProjectReference(referenceBinPath, newProjectReference); } // Remove the existing reference first RemoveProjectReference(projectReference); AddProjectReference(newProjectReference); }
private void UpdateProject(ProjectFileInfo projectFileInfo) { var project = _workspace.CurrentSolution.GetProject(projectFileInfo.WorkspaceId); var unusedDocuments = project.Documents.ToDictionary(d => d.FilePath, d => d.Id); foreach (var file in projectFileInfo.SourceFiles) { if (unusedDocuments.Remove(file)) { continue; } using (var stream = File.OpenRead(file)) { var sourceText = SourceText.From(stream, encoding: Encoding.UTF8); var id = DocumentId.CreateNewId(projectFileInfo.WorkspaceId); var version = VersionStamp.Create(); var loader = TextLoader.From(TextAndVersion.Create(sourceText, version)); _workspace.AddDocument(DocumentInfo.Create(id, file, filePath: file, loader: loader)); } } if (projectFileInfo.SpecifiedLanguageVersion.HasValue || projectFileInfo.DefineConstants != null) { var parseOptions = projectFileInfo.SpecifiedLanguageVersion.HasValue ? new CSharpParseOptions(projectFileInfo.SpecifiedLanguageVersion.Value) : new CSharpParseOptions(); if (projectFileInfo.DefineConstants != null && projectFileInfo.DefineConstants.Any()) { parseOptions = parseOptions.WithPreprocessorSymbols(projectFileInfo.DefineConstants); } _workspace.SetParseOptions(project.Id, parseOptions); } foreach (var unused in unusedDocuments) { _workspace.RemoveDocument(unused.Value); } var unusedProjectReferences = new HashSet <ProjectReference>(project.ProjectReferences); foreach (var projectReferencePath in projectFileInfo.ProjectReferences) { ProjectFileInfo projectReferenceInfo; if (_context.Projects.TryGetValue(projectReferencePath, out projectReferenceInfo)) { var reference = new ProjectReference(projectReferenceInfo.WorkspaceId); if (unusedProjectReferences.Remove(reference)) { // This reference already exists continue; } _workspace.AddProjectReference(project.Id, reference); } else { _logger.LogWarning($"Unable to resolve project reference '{projectReferencePath}' for '{projectFileInfo}'."); } } foreach (var unused in unusedProjectReferences) { _workspace.RemoveProjectReference(project.Id, unused); } var unusedAnalyzers = new Dictionary <string, AnalyzerReference>(project.AnalyzerReferences.ToDictionary(a => a.FullPath)); foreach (var analyzerPath in projectFileInfo.Analyzers) { if (!File.Exists(analyzerPath)) { _logger.LogWarning($"Unable to resolve assembly '{analyzerPath}'"); } else { if (unusedAnalyzers.Remove(analyzerPath)) { continue; } #if DNX451 var analyzerReference = new AnalyzerFileReference(analyzerPath); project.AddAnalyzerReference(analyzerReference); #endif } } foreach (var analyzerReference in unusedAnalyzers.Values) { project.RemoveAnalyzerReference(analyzerReference); } var unusedReferences = new HashSet <MetadataReference>(project.MetadataReferences); foreach (var referencePath in projectFileInfo.References) { if (!File.Exists(referencePath)) { _logger.LogWarning($"Unable to resolve assembly '{referencePath}'"); } else { var metadataReference = _metadataReferenceCache.GetMetadataReference(referencePath); if (unusedReferences.Remove(metadataReference)) { continue; } _logger.LogVerbose($"Adding reference '{referencePath}' to '{projectFileInfo.ProjectFilePath}'."); _workspace.AddMetadataReference(project.Id, metadataReference); } } foreach (var reference in unusedReferences) { _workspace.RemoveMetadataReference(project.Id, reference); } }
private bool TryGetMetadataFileNameToConvertedProjectReference(string filePath, out ProjectReference projectReference) { lock (_gate) { return _metadataFileNameToConvertedProjectReference.TryGetValue(filePath, out projectReference); } }
void AddReferenceToProject(ProjectReference assemblyReference) { project.References.Add(assemblyReference); project.Save(); LogAddedReferenceToProject(assemblyReference); }
// Internal for unit testing internal void AddProjectReference(ProjectReference projectReference) { AssertIsForeground(); // dev11 is sometimes calling us multiple times for the same data if (!CanAddProjectReference(projectReference)) { return; } lock (_gate) { // always manipulate current state after workspace is told so it will correctly observe the initial state _projectReferences.Add(projectReference); } if (_pushingChangesToWorkspaceHosts) { // This project is already pushed to listening workspace hosts, but it's possible that our target // project hasn't been yet. Get the dependent project into the workspace as well. var targetProject = this.ProjectTracker.GetProject(projectReference.ProjectId); this.ProjectTracker.StartPushingToWorkspaceAndNotifyOfOpenDocuments(SpecializedCollections.SingletonEnumerable(targetProject)); this.ProjectTracker.NotifyWorkspaceHosts(host => host.OnProjectReferenceAdded(this.Id, projectReference)); } }
protected void GetReferences(Project project, MonoDevelop.Prj2Make.Schema.Csproj.Reference[] References, ProjectReferenceCollection references, IProgressMonitor monitor) { if (References == null || References.Length == 0) { return; } monitor.BeginTask(null, 5 + References.Length); try { // Get the GAC path string strBasePathMono1_0 = GetPackageDirectory("mono", "mono/1.0"); monitor.Step(1); string strBasePathGtkSharp = GetPackageDirectory("gtk-sharp", "mono/gtk-sharp"); monitor.Step(1); string strBasePathGtkSharp2_0 = GetPackageDirectory("gtk-sharp-2.0", "mono/gtk-sharp-2.0"); monitor.Step(1); string strBasePathGeckoSharp = GetPackageDirectory("gecko-sharp", "mono/gecko-sharp"); monitor.Step(1); string strBasePathGeckoSharp2_0 = GetPackageDirectory("gecko-sharp-2.0", "mono/gecko-sharp-2.0"); string[] monoLibs = new string [] { strBasePathMono1_0, strBasePathGtkSharp2_0, strBasePathGtkSharp, strBasePathGeckoSharp2_0, strBasePathGeckoSharp }; // Iterate through the reference collection of the csproj file foreach (MonoDevelop.Prj2Make.Schema.Csproj.Reference rf in References) { monitor.Step(1); ProjectReference rfOut = null; if (rf.Package != null && rf.Package.Length != 0) { rfOut = new ProjectReference(MonoDevelop.Projects.ReferenceType.Project, Path.GetFileName(rf.Name)); rfOut.LocalCopy = true; references.Add(rfOut); } else if (rf.AssemblyName != null) { string rname = rf.AssemblyName; if (rname == "System.XML") { rname = "System.Xml"; } string oref = Runtime.SystemAssemblyService.DefaultAssemblyContext.GetAssemblyFullName(rname, fx); if (oref == null) { if (rf.HintPath != null) { string asm = MapPath(project.ItemDirectory, rf.HintPath); if (!System.IO.File.Exists(asm)) { monitor.ReportWarning(GettextCatalog.GetString("Referenced assembly not found: ") + asm); } ProjectReference aref = new ProjectReference(MonoDevelop.Projects.ReferenceType.Assembly, asm); references.Add(aref); continue; } monitor.ReportWarning(GettextCatalog.GetString("Assembly reference could not be imported: ") + rf.AssemblyName); continue; } rfOut = new ProjectReference(MonoDevelop.Projects.ReferenceType.Package, oref); rfOut.LocalCopy = true; references.Add(rfOut); } else if (rf.HintPath != null) { // HACK - under Unix filenames are case sensitive // Under Windows there's no agreement on Xml vs XML ;-) if (Path.GetFileName(rf.HintPath) == "System.XML.dll") { ProjectReference pref = GetMonoReferece(strBasePathMono1_0, "System.Xml.dll"); if (pref != null) { references.Add(pref); continue; } } else { foreach (string libDir in monoLibs) { if (libDir == null) { continue; } if (rf.HintPath == null) { continue; } rfOut = GetMonoReferece(libDir, rf.HintPath); if (rfOut != null) { break; } } if (rfOut == null) { rfOut = new ProjectReference(MonoDevelop.Projects.ReferenceType.Package, Path.GetFileName(rf.HintPath)); rfOut.LocalCopy = true; } references.Add(rfOut); } } else { monitor.ReportWarning(GettextCatalog.GetString("Assembly reference could not be imported: ") + rf.Name); } } } finally { monitor.EndTask(); } }
protected int AddMetadataReferenceAndTryConvertingToProjectReferenceIfPossible(string filePath, MetadataReferenceProperties properties) { AssertIsForeground(); // If this file is coming from a project, then we should convert it to a project reference instead if (this.CanConvertToProjectReferences && ProjectTracker.TryGetProjectByBinPath(filePath, out var project)) { var projectReference = new ProjectReference(project.Id, properties.Aliases, properties.EmbedInteropTypes); if (CanAddProjectReference(projectReference)) { AddProjectReference(projectReference); AddMetadataFileNameToConvertedProjectReference(filePath, projectReference); return VSConstants.S_OK; } } // regardless whether the file exists or not, we still record it. one of reason // we do that is some cross language p2p references might be resolved // after they are already reported as metadata references. since we use bin path // as a way to discover them, if we don't previously record the reference ourselves, // cross p2p references won't be resolved as p2p references when we finally have // all required information. // // it looks like // 1. project system sometimes won't guarantee build dependency for intellisense build // if it is cross language dependency // 2. output path of referenced cross language project might be changed to right one // once it is already added as a metadata reference. // // but this has one consequence. even if a user adds a project in the solution as // a metadata reference explicitly, that dll will be automatically converted back to p2p // reference. // // unfortunately there is no way to prevent this using information we have since, // at this point, we don't know whether it is a metadata reference added because // we don't have enough information yet for p2p reference or user explicitly added it // as a metadata reference. AddMetadataReferenceCore(this.MetadataReferenceProvider.CreateMetadataReference(this, filePath, properties)); // here, we change behavior compared to old C# language service. regardless of file being exist or not, // we will always return S_OK. this is to support cross language p2p reference better. // // this should make project system to cache all cross language p2p references regardless // whether it actually exist in disk or not. // (see Roslyn bug 7315 for history - http://vstfdevdiv:8080/DevDiv_Projects/Roslyn/_workitems?_a=edit&id=7315) // // after this point, Roslyn will take care of non-exist metadata reference. // // But, this doesn't sovle the issue where actual metadata reference // (not cross language p2p reference) is missing at the time project is opened. // // in that case, msbuild filter those actual metadata references out, so project system doesn't know // path to the reference. since it doesn't know where dll is, it can't (or currently doesn't) // setup file change notification either to find out when dll becomes available. // // at this point, user has 2 ways to recover missing metadata reference once it becomes available. // // one way is explicitly clicking that missing reference from solution explorer reference node. // the other is building the project. at that point, project system will refresh references // which will discover new dll and connect to us. once it is connected, we will take care of it. return VSConstants.S_OK; }
public new void OnProjectReferenceRemoved(ProjectId projectId, ProjectReference projectReference) => base.OnProjectReferenceRemoved(projectId, projectReference);
public ProjectState RemoveProjectReference(ProjectReference projectReference) { Contract.Requires(this.ProjectReferences.Contains(projectReference)); return this.With( projectInfo: this.ProjectInfo.WithProjectReferences(this.ProjectReferences.Remove(projectReference)).WithVersion(this.Version.GetNewerVersion())); }
/// <inheritdoc /> public override PagedAsyncEnumerable <DatasetList, BigQueryDataset> ListDatasetsAsync(ProjectReference projectReference, ListDatasetsOptions options = null) { GaxPreconditions.CheckNotNull(projectReference, nameof(projectReference)); var pageManager = new DatasetPageManager(this); return(new RestPagedAsyncEnumerable <ListRequest, DatasetList, BigQueryDataset>( () => CreateListDatasetsRequest(projectReference, options), pageManager)); }