async Task LoadExceptionList() { classes.Add("System.Exception"); try { Microsoft.CodeAnalysis.Compilation compilation = null; Microsoft.CodeAnalysis.ProjectId dummyProjectId = null; if (IdeApp.ProjectOperations.CurrentSelectedProject != null) { compilation = await TypeSystemService.GetCompilationAsync(IdeApp.ProjectOperations.CurrentSelectedProject); } if (compilation == null) { //no need to unload this assembly context, it's not cached. dummyProjectId = Microsoft.CodeAnalysis.ProjectId.CreateNewId("GetExceptionsProject"); compilation = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create("GetExceptions") .AddReferences(MetadataReferenceCache.LoadReference(dummyProjectId, System.Reflection.Assembly.GetAssembly(typeof(object)).Location)) //corlib .AddReferences(MetadataReferenceCache.LoadReference(dummyProjectId, System.Reflection.Assembly.GetAssembly(typeof(Uri)).Location)); //System.dll } var exceptionClass = compilation.GetTypeByMetadataName("System.Exception"); foreach (var t in compilation.GlobalNamespace.GetAllTypes().Where((arg) => arg.IsDerivedFromClass(exceptionClass))) { classes.Add(t.GetFullMetadataName()); } if (dummyProjectId != null) { MetadataReferenceCache.RemoveReferences(dummyProjectId); } } catch (Exception e) { LoggingService.LogError("Failed to obtain exceptions list in breakpoint dialog.", e); } await Runtime.RunInMainThread(() => { entryExceptionType.SetCodeCompletionList(classes.ToList()); }); }
void LoadExceptionList() { classes.Add("System.Exception"); if (IdeApp.ProjectOperations.CurrentSelectedProject != null) { var compilation = TypeSystemService.GetCompilationAsync(IdeApp.ProjectOperations.CurrentSelectedProject).Result; var exceptionClass = compilation.GetTypeByMetadataName("System.Exception"); foreach (var t in compilation.GlobalNamespace.GetAllTypes().Where((arg) => arg.IsDerivedFromClass(exceptionClass))) { classes.Add(t.GetFullMetadataName()); } } else { //no need to unload this assembly context, it's not cached. var dummyProjectId = Microsoft.CodeAnalysis.ProjectId.CreateNewId("GetExceptionsProject"); var compilation = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create("GetExceptions") .AddReferences(MetadataReferenceCache.LoadReference(dummyProjectId, System.Reflection.Assembly.GetAssembly(typeof(object)).Location)) //corlib .AddReferences(MetadataReferenceCache.LoadReference(dummyProjectId, System.Reflection.Assembly.GetAssembly(typeof(Uri)).Location)); //System.dll var exceptionClass = compilation.GetTypeByMetadataName("System.Exception"); foreach (var t in compilation.GlobalNamespace.GetAllTypes().Where((arg) => arg.IsDerivedFromClass(exceptionClass))) { classes.Add(t.GetFullMetadataName()); } MetadataReferenceCache.RemoveReferences(dummyProjectId); } entryExceptionType.SetCodeCompletionList(classes.ToList()); }
private static IEnumerable <FeedPackage> ParsePage(XDocument doc, string id, MetadataReferenceCache metadataCache) { return(doc.Root.Name == _xnameEntry ? new List <FeedPackage> { ParsePackage(id, doc.Root, metadataCache) } : doc.Root.Elements(_xnameEntry).Select(x => ParsePackage(id, x, metadataCache))); }
MetadataReference LoadMetadataReference(string path) { var projectId = Microsoft.CodeAnalysis.ProjectId.CreateNewId("WebFormsTypeContext"); var reference = MetadataReferenceCache.LoadReference(projectId, path); MetadataReferenceCache.RemoveReferences(projectId); return(reference); }
public void MetadataReferenceCache_CachesObjectCorrectly() { //// Arrange var objectToCache = new ObjectCacheTest(); var cache = new MetadataReferenceCache(); //// Act 1 var stringCachedBefore = cache.GetString(ObjectCacheTest.TestStringCachedBefore); var stringCachedOnce = ObjectCacheTest.TestStringCachedOnce; //// Assert 1 // Assert that all equal objects that will be cached should be: // 1 - Equal. // 2 - Not the same reference. // Strings Assert.NotSame(objectToCache.StringCachedBefore, stringCachedBefore); Assert.Equal(objectToCache.StringCachedBefore, stringCachedBefore); Assert.NotSame(objectToCache.StringCachedDuring1, objectToCache.StringCachedDuring2); Assert.Equal(objectToCache.StringCachedDuring1, objectToCache.StringCachedDuring2); Assert.NotSame(objectToCache.StringCachedOnce, stringCachedOnce); Assert.Equal(objectToCache.StringCachedOnce, stringCachedOnce); // Versions Assert.NotSame(objectToCache.VersionCachedDuring1, objectToCache.VersionCachedDuring2); Assert.Equal(objectToCache.VersionCachedDuring1, objectToCache.VersionCachedDuring2); //// Act 2 var cachedObject = cache.GetObject(objectToCache); var cachedStringCachedOnce = cache.GetString(stringCachedOnce); //// Assert 2 // Assert that all equal objects that were cached should be: // 1 - Equal to their original value. // 2 - The same reference. // Strings Assert.Same(objectToCache.StringCachedBefore, stringCachedBefore); Assert.Equal(objectToCache.StringCachedBefore, ObjectCacheTest.TestStringCachedBefore); Assert.Same(objectToCache.StringCachedDuring1, objectToCache.StringCachedDuring2); Assert.Equal(objectToCache.StringCachedDuring1, ObjectCacheTest.TestStringCachedDuring); Assert.Same(objectToCache.StringCachedOnce, cachedStringCachedOnce); Assert.Equal(objectToCache.StringCachedOnce, ObjectCacheTest.TestStringCachedOnce); // Check that uncached fields are untouched. Assert.Equal(objectToCache.DateTimeNeverCached, ObjectCacheTest.TestDateTimeNeverCached); }
public void MetadataReferenceCache_ParsesVersion() { // Arrange var version = new NuGetVersion(3, 2, 1); var cache = new MetadataReferenceCache(); // Act var cachedVersion = cache.GetVersion(version.ToString()); // Assert Assert.Equal(version, cachedVersion); }
public void AssertMetadataReferenceCache_CachesStringMethodCorrectly() { // Arrange var objectToCache = new ObjectCacheTest(); var cache = new MetadataReferenceCache(); // Act var cachedObject = cache.GetObject(objectToCache); // Assert Assert.True(ReferenceEquals(cachedObject, objectToCache)); Assert.Equal(objectToCache.StringCachedBefore, ObjectCacheTest.TestStringCachedBefore); Assert.Equal(cache.CachableMethodTypes.Count(), 1); Assert.Equal(cache.CachableMethodTypes.Single().Key.Name, "MetadataReferenceCache"); Assert.Equal(cache.CachableMethodTypes.Single().Value.Name, "GetString"); }
/// <summary> /// Finds all entries on the page and parses them /// </summary> public static IEnumerable <V2FeedPackageInfo> ParsePage(XDocument doc) { MetadataReferenceCache metadataCache = new MetadataReferenceCache(); if (doc.Root.Name == _xnameEntry) { return(new List <V2FeedPackageInfo> { ParsePackage(doc.Root, metadataCache) }); } else { return(doc.Root.Elements(_xnameEntry) .Select(x => ParsePackage(x, metadataCache))); } }
public void MetadataReferenceCache_ReturnsCachedVersion() { // Arrange var version1 = "3.2.1"; var version2 = "3.2.1"; var cache = new MetadataReferenceCache(); // Act var cachedVersion1 = cache.GetVersion(version1); var cachedVersion2 = cache.GetVersion(version2); // Assert Assert.Equal(version1, version2); Assert.Same(cachedVersion1, cachedVersion2); }
public void MetadataReferenceCache_ReturnsCachedParsedVersion() { // Arrange var version = new NuGetVersion(3, 2, 1); var versionString1 = version.ToString(); var versionString2 = version.ToString(); var cache = new MetadataReferenceCache(); // Act var cachedVersion1 = cache.GetVersion(versionString1); var cachedVersion2 = cache.GetVersion(versionString2); // Assert Assert.Equal(versionString1, versionString2); Assert.NotSame(versionString1, versionString2); Assert.Same(cachedVersion1, cachedVersion2); }
public void MetadataReferenceCache_ReturnsNonNormalizedVersion() { // Arrange var version1 = "1.0"; var version2 = "1.0.0"; var version3 = "1.0.0.0"; var cache = new MetadataReferenceCache(); // Act var cachedVersion1 = cache.GetVersion(version1); var cachedVersion2 = cache.GetVersion(version2); var cachedVersion3 = cache.GetVersion(version3); // Assert Assert.Equal("1.0", cachedVersion1.ToString()); Assert.Equal("1.0.0", cachedVersion2.ToString()); Assert.Equal("1.0.0.0", cachedVersion3.ToString()); }
public void MetadataReferenceCache_ReturnsCachedString() { // Arrange var hello = "hello"; var there = " there"; // Using StringBuilder because if assigning to "hello there" directly results in a constant that is an equal reference. var string1 = new StringBuilder().Append(hello).Append(there).ToString(); var string2 = new StringBuilder().Append(hello).Append(there).ToString(); var cache = new MetadataReferenceCache(); // Act var cachedString1 = cache.GetString(string1); var cachedString2 = cache.GetString(string2); // Assert Assert.Equal(string1, string2); Assert.NotSame(string1, string2); Assert.Same(cachedString1, cachedString2); }
public ReferenceSet(MetadataReferenceCache cache) { _cache = cache; }
public MetadataFileReferenceResolver(string baseDir) { _baseDir = baseDir; _cache = new MetadataReferenceCache((path, properties) => MetadataReference.CreateFromFile(path, properties)); }
private static V2FeedPackageInfo ParsePackage(XElement element, MetadataReferenceCache metadataCache) { var properties = element.Element(_xnameProperties); var idElement = properties.Element(_xnameId); var titleElement = element.Element(_xnameTitle); // If 'Id' element exist, use its value as accurate package Id // Otherwise, use the value of 'title' if it exist // Use the given Id as final fallback if all elements above don't exist string identityId = metadataCache.GetString(idElement?.Value ?? titleElement?.Value); string versionString = properties.Element(_xnameVersion).Value; NuGetVersion version = metadataCache.GetVersion(metadataCache.GetString(versionString)); string downloadUrl = metadataCache.GetString(element.Element(_xnameContent).Attribute("src").Value); string title = metadataCache.GetString(titleElement?.Value); string summary = metadataCache.GetString(GetString(element, _xnameSummary)); string description = metadataCache.GetString(GetString(properties, _xnameDescription)); string iconUrl = metadataCache.GetString(GetString(properties, _xnameIconUrl)); string licenseUrl = metadataCache.GetString(GetString(properties, _xnameLicenseUrl)); string projectUrl = metadataCache.GetString(GetString(properties, _xnameProjectUrl)); string reportAbuseUrl = metadataCache.GetString(GetString(properties, _xnameReportAbuseUrl)); string tags = metadataCache.GetString(GetString(properties, _xnameTags)); string dependencies = metadataCache.GetString(GetString(properties, _xnameDependencies)); string downloadCount = metadataCache.GetString(GetString(properties, _xnameDownloadCount)); bool requireLicenseAcceptance = StringComparer.OrdinalIgnoreCase.Equals(bool.TrueString, GetString(properties, _xnameRequireLicenseAcceptance)); string packageHash = metadataCache.GetString(GetString(properties, _xnamePackageHash)); string packageHashAlgorithm = metadataCache.GetString(GetString(properties, _xnamePackageHashAlgorithm)); NuGetVersion minClientVersion = null; var minClientVersionString = GetString(properties, _xnameMinClientVersion); if (!string.IsNullOrEmpty(minClientVersionString)) { if (NuGetVersion.TryParse(minClientVersionString, out minClientVersion)) { minClientVersion = metadataCache.GetVersion(minClientVersionString); } } DateTimeOffset?created = GetDate(properties, _xnameCreated); DateTimeOffset?lastEdited = GetDate(properties, _xnameLastEdited); DateTimeOffset?published = GetDate(properties, _xnamePublished); IEnumerable <string> owners = null; IEnumerable <string> authors = null; var authorNode = element.Element(_xnameAuthor); if (authorNode != null) { authors = authorNode.Elements(_xnameName).Select(e => metadataCache.GetString(e.Value)); } return(new V2FeedPackageInfo(new PackageIdentity(identityId, version), title, summary, description, authors, owners, iconUrl, licenseUrl, projectUrl, reportAbuseUrl, tags, created, lastEdited, published, dependencies, requireLicenseAcceptance, downloadUrl, downloadCount, packageHash, packageHashAlgorithm, minClientVersion)); }
public async Task <bool> MoveNextAsync() { var metadataCache = new MetadataReferenceCache(); if (_currentPage == null) { _currentPage = _isSearchAvailable ? await _feedParser.GetSearchPageAsync(_searchTerm, _filter, _skip, _take, _logger, _token) : await _feedParser.GetPackagesPageAsync(_searchTerm, _filter, _skip, _take, _logger, _token); var results = _allVersions? _currentPage.Items.GroupBy(p => p.Id) .Select(group => group.OrderByDescending(p => p.Version)).SelectMany(pg => pg) .Select( package => V2FeedUtilities.CreatePackageSearchResult(package, metadataCache, _filter, (V2FeedParser)_feedParser, _logger, _token)).Where(p => _filter.IncludeDelisted || p.IsListed) : _currentPage.Items.GroupBy(p => p.Id) .Select(group => group.OrderByDescending(p => p.Version).First()) .Select( package => V2FeedUtilities.CreatePackageSearchResult(package, metadataCache, _filter, (V2FeedParser)_feedParser, _logger, _token)).Where(p => _filter.IncludeDelisted || p.IsListed); var enumerator = results.GetEnumerator(); _currentEnumerator = enumerator; return(_currentEnumerator.MoveNext()); } else { if (!_currentEnumerator.MoveNext()) { if (_currentPage.Items.Count != _take) // Last page not filled completely, no more pages left { return(false); } _skip += _take; _currentPage = _isSearchAvailable ? await _feedParser.GetSearchPageAsync(_searchTerm, _filter, _skip, _take, _logger, _token) : await _feedParser.GetPackagesPageAsync(_searchTerm, _filter, _skip, _take, _logger, _token); var results = _allVersions ? _currentPage.Items.GroupBy(p => p.Id) .Select(group => group.OrderByDescending(p => p.Version)).SelectMany(pg => pg) .Select( package => V2FeedUtilities.CreatePackageSearchResult(package, metadataCache, _filter, (V2FeedParser)_feedParser, _logger, _token)).Where(p => _filter.IncludeDelisted || p.IsListed) : _currentPage.Items.GroupBy(p => p.Id) .Select(group => group.OrderByDescending(p => p.Version).First()) .Select( package => V2FeedUtilities.CreatePackageSearchResult(package, metadataCache, _filter, (V2FeedParser)_feedParser, _logger, _token)).Where(p => _filter.IncludeDelisted || p.IsListed); var enumerator = results.GetEnumerator(); _currentEnumerator = enumerator; return(_currentEnumerator.MoveNext()); } else { return(true); } } }
private static FeedPackage ParsePackage(string id, XElement element, MetadataReferenceCache metadataCache) { var properties = element.Element(_xnameProperties); var idElement = properties.Element(_xnameId); var titleElement = element.Element(_xnameTitle); var identityId = metadataCache.GetString(idElement?.Value ?? titleElement?.Value ?? id); var versionString = properties.Element(_xnameVersion).Value; var downloadUrl = metadataCache.GetString(element.Element(_xnameContent).Attribute("src").Value); var title = metadataCache.GetString(titleElement?.Value); var summary = metadataCache.GetString(GetString(element, _xnameSummary)); var description = metadataCache.GetString(GetString(properties, _xnameDescription)); var iconUrl = metadataCache.GetString(GetString(properties, _xnameIconUrl)); var licenseUrl = metadataCache.GetString(GetString(properties, _xnameLicenseUrl)); var projectUrl = metadataCache.GetString(GetString(properties, _xnameProjectUrl)); var reportAbuseUrl = metadataCache.GetString(GetString(properties, _xnameReportAbuseUrl)); var tags = metadataCache.GetString(GetString(properties, _xnameTags)); var dependencies = metadataCache.GetString(GetString(properties, _xnameDependencies)); var downloadCount = metadataCache.GetString(GetString(properties, _xnameDownloadCount)); var requireLicenseAcceptance = StringComparer.OrdinalIgnoreCase.Equals(bool.TrueString, GetString(properties, _xnameRequireLicenseAcceptance)); var packageHash = metadataCache.GetString(GetString(properties, _xnamePackageHash)); var packageHashAlgorithm = metadataCache.GetString(GetString(properties, _xnamePackageHashAlgorithm)); var copyright = metadataCache.GetString(GetString(properties, _xnameCopyright)); var galleryDetailsUrl = metadataCache.GetString(GetString(properties, _xnameGalleryDetailsUrl)); var releaseNotes = metadataCache.GetString(GetString(properties, _xnameReleaseNotes)); var minClientVersionString = GetString(properties, _xnameMinClientVersion); var created = GetDate(properties, _xnameCreated); var published = GetDate(properties, _xnamePublished); var lastUpdated = GetDate(properties, _xnameLastUpdated); var lastEdited = GetDate(properties, _xnameLastEdited); var isAbsoluteLatestVersion = StringComparer.OrdinalIgnoreCase.Equals(bool.TrueString, GetString(properties, _xnameIsAbsoluteLatestVersion)); var isLatestVersion = StringComparer.OrdinalIgnoreCase.Equals(bool.TrueString, GetString(properties, _xnameIsLatestVersion)); var isPrerelease = StringComparer.OrdinalIgnoreCase.Equals(bool.TrueString, GetString(properties, _xnameIsPrelease)); var language = metadataCache.GetString(GetString(properties, _xnameLanguage)); var licenseNames = metadataCache.GetString(GetString(properties, _xnameLicenseNames)); var licenseReportUrl = metadataCache.GetString(GetString(properties, _xnameLicenseReportUrl)); var packageUrl = metadataCache.GetString(GetString(properties, _xnamePackageUrl)); var packageSize = GetLong(properties, _xnamePackageSize); var versionDownloadCount = GetInt(properties, _xnameVersionDownloadCount); string authors = null; var authorNode = element.Element(_xnameAuthor); if (authorNode != null) { authors = string.Join(" ", authorNode.Elements(_xnameName).Select(e => metadataCache.GetString(e.Value))); } return(new FeedPackage { Authors = authors, Copyright = copyright, Created = created, Dependencies = dependencies, Description = description, DownloadCount = int.TryParse(downloadCount, out int d) ? d : 0, DownloadUrl = downloadUrl, GalleryDetailsUrl = galleryDetailsUrl, IconUrl = iconUrl, Id = identityId, IsAbsoluteLatestVersion = isAbsoluteLatestVersion, IsLatestVersion = isLatestVersion, IsPreRelease = isPrerelease, Language = language, LastUpdated = lastUpdated, LastEdited = lastEdited, LicenseNames = licenseNames, LicenseReportUrl = licenseReportUrl, LicenseUrl = licenseUrl, MinClientVersion = minClientVersionString, PackageHash = packageHash, PackageHashAlgorithm = packageHashAlgorithm, ProjectUrl = projectUrl, PackageSize = packageSize, PackageUrl = packageUrl, Published = published, ReleaseNotes = releaseNotes, ReportAbuseUrl = reportAbuseUrl, RequireLicenseAcceptance = requireLicenseAcceptance, Summary = summary, Tags = tags, Title = title, Version = versionString, VersionDownloadCount = versionDownloadCount });