/// <summary> /// This methods updates the project's .csproj file. It adds all the installed packages to the .csproj file. /// </summary> /// <param name="packageReader">The <see cref="PackageReaderBase"/> to use in reading the nuget package</param> /// <param name="installedPath">The folder path where the package was installed or downloaded to</param> /// <param name="packageToInstall">The package to install with all its dependencies.</param> /// <param name="nuGetFramework">The <see cref="NuGetFramework"/></param> private void UpdateProjectFile( PackageReaderBase packageReader, string installedPath, SourcePackageDependencyInfo packageToInstall, NuGetFramework nuGetFramework) { IEnumerable <FrameworkSpecificGroup> dllItems = packageReader.GetLibItems(); if (dllItems != null) { FrameworkReducer frameworkReducer = new FrameworkReducer(); NuGetFramework nearest = frameworkReducer.GetNearest(nuGetFramework, dllItems.Select(x => x.TargetFramework)); string targetDllFramework = dllItems .Where(x => x.TargetFramework.Equals(nearest)) .SelectMany(x => x.Items).Where(x => x.Contains(".dll")).FirstOrDefault(); if (!string.IsNullOrEmpty(targetDllFramework) && !string.IsNullOrEmpty(installedPath)) { string targetDllFrameworkPath = Path.Combine(installedPath, targetDllFramework.ToString()); string dllName = Assembly.LoadFile(targetDllFrameworkPath).FullName; string dllNameWithProcessArchitecture = dllName + "," + " processorArchitecture=MSIL"; ProjectItem item = this.project.GetItems("Reference").FirstOrDefault(a => a.EvaluatedInclude.Contains(packageToInstall.Id)); if (item == null) { if (ProjectHelper.CheckIfSolutionAndProjectFilesAreInSameFolder(this.project.DirectoryPath)) { ProjectItem projectItem = this.project.AddItem("Reference", dllNameWithProcessArchitecture).FirstOrDefault(); projectItem.HasMetadata("HintPath"); projectItem.SetMetadataValue("HintPath", $"packages\\{packageToInstall.Id}.{ packageToInstall.Version}\\{targetDllFramework.Replace(@"/", "\\")}".Replace(@"\\", "//")); } else { ProjectItem projectItem = this.project.AddItem("Reference", dllNameWithProcessArchitecture).FirstOrDefault(); projectItem.SetMetadataValue("HintPath", $"..\\packages\\{packageToInstall.Id}.{ packageToInstall.Version}\\{targetDllFramework.Replace(@"/", "\\")}".Replace(@"\\", "//")); } this.project.Save(); } ProjectItem dataAnnotationsRef = this.project.GetItems("Reference").FirstOrDefault(a => a.EvaluatedInclude.Contains("System.ComponentModel.DataAnnotations")); if (dataAnnotationsRef == null) { ProjectHelper.AddProjectItem(this.project, "Reference", "System.ComponentModel.DataAnnotations"); } ProjectItem packageConfigRef = this.project.GetItems("None").FirstOrDefault(a => a.EvaluatedInclude.Contains("packages.config")); if (packageConfigRef == null) { ProjectHelper.AddProjectItem(this.project, "None", "packages.config"); } } } }
public static DownloadResourceResult GetPackage(PackageIdentity packageIdentity, ISettings settings) { if (packageIdentity == null) { throw new ArgumentNullException(nameof(packageIdentity)); } if (settings == null) { throw new ArgumentNullException(nameof(settings)); } var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(settings); var defaultPackagePathResolver = new VersionFolderPathResolver(globalPackagesFolder); var hashPath = defaultPackagePathResolver.GetHashPath(packageIdentity.Id, packageIdentity.Version); if (File.Exists(hashPath)) { var installPath = defaultPackagePathResolver.GetInstallPath( packageIdentity.Id, packageIdentity.Version); var nupkgPath = defaultPackagePathResolver.GetPackageFilePath( packageIdentity.Id, packageIdentity.Version); Stream stream = null; PackageReaderBase packageReader = null; try { stream = File.Open(nupkgPath, FileMode.Open, FileAccess.Read, FileShare.Read); packageReader = new PackageFolderReader(installPath); return(new DownloadResourceResult(stream, packageReader)); } catch { if (stream != null) { stream.Dispose(); } if (packageReader != null) { packageReader.Dispose(); } throw; } } return(null); }
public static NuGetVersion FindOverlayVersion(PackageReaderBase package) { return((from file in package.GetFiles() where Path.GetFileName(file) == NuGetOverlayCommandFileName from line in ReadAllLines(package.GetStream(file)) where line.StartsWith(NuGetOverlayCommand) let version = line.Split(' ') .SkipWhile(xs => xs != NuGetOverlayVersionArgument) .Skip(1) .FirstOrDefault() select NuGetVersion.Parse(version)).FirstOrDefault()); }
void RegisterLibraryFolders(PackageReaderBase package, string installPath) { foreach (var folder in GetLibraryFolders(package, installPath)) { if (!packageConfiguration.LibraryFolders.Contains(folder.Path)) { packageConfiguration.LibraryFolders.Add(folder); } else if (packageConfiguration.LibraryFolders[folder.Path].Platform != folder.Platform) { throw new InvalidOperationException(string.Format(Resources.LibraryFolderPlatformMismatchException, folder.Path)); } } }
public NuGetPackageContent(PackageReaderBase reader, ILog log, IFrameworkFilter filter = null) { Ensure.NotNull(reader, "reader"); Ensure.NotNull(log, "log"); if (filter == null) { filter = AnyFrameworkFilter.Instance; } this.reader = reader; this.log = log; this.nuGetLog = new NuGetLogger(log); this.filter = filter; }
static IEnumerable <LibraryFolder> GetLibraryFolders(PackageReaderBase package, string installPath) { var nativeFramework = package.GetItems(BuildDirectory).FirstOrDefault( frameworkGroup => NuGetFramework.FrameworkNameComparer.Equals(frameworkGroup.TargetFramework, NativeFramework)); if (nativeFramework == null) { return(Enumerable.Empty <LibraryFolder>()); } return(from file in nativeFramework.Items group file by Path.GetDirectoryName(file) into folder let platform = ResolvePathPlatformName(folder.Key) where !string.IsNullOrWhiteSpace(platform) select new LibraryFolder(Path.Combine(installPath, folder.Key), platform)); }
public PackageSearchItem(Project project, PackageReaderBase reader) { Identity = reader.GetIdentity(); Id = Identity.Id; Title = reader.NuspecReader.GetTitle(); if (string.IsNullOrEmpty(Title)) { Title = Id; } IsInstalled = isPackageIdInProjectDependencies(project, Id); InstalledVersion = ""; // Find installed version ! var LocalVersion = NuGetPackageManager.Instance.getLocal(Id); CanInstall = false; if (LocalVersion != null) { if (project.dependencies != null) { foreach (JProperty jp in (JToken)project.dependencies) { if (jp.Name == Id) { InstalledVersion = (string)jp.Value; CanInstall = true; } } } if (string.IsNullOrEmpty(InstalledVersion)) { InstalledVersion = LocalVersion.Identity.Version.ToString(); } SelectedVersion = InstalledVersion; } NotifyPropertyChanged("InstalledVersion"); LicenseUrl = reader.NuspecReader.GetLicenseUrl(); ProjectUrl = reader.NuspecReader.GetProjectUrl(); Tags = reader.NuspecReader.GetTags(); Description = reader.NuspecReader.GetDescription(); IconUrl = reader.NuspecReader.GetIconUrl(); Authors = reader.NuspecReader.GetAuthors(); Dependencies = reader.GetPackageDependencies().ToList(); }
private void FetchEmbeddedImage(Func <PackageReaderBase> lazyReader, Uri iconUrl) { var iconBitmapImage = new BitmapImage(); iconBitmapImage.BeginInit(); try { using (PackageReaderBase reader = lazyReader()) // Always returns a new reader. That avoids using an already disposed one { if (reader is PackageArchiveReader par) // This reader is closed in BitmapImage events { string iconEntryNormalized = PathUtility.StripLeadingDirectorySeparators( Uri.UnescapeDataString(iconUrl.Fragment) .Substring(1)); // Substring skips the '#' in the URI fragment // need to use a memorystream, or the bitmapimage won't be freezable. using (Stream parStream = par.GetEntry(iconEntryNormalized).Open()) using (var memoryStream = new MemoryStream()) { parStream.CopyTo(memoryStream); iconBitmapImage.StreamSource = memoryStream; FinalizeBitmapImage(iconBitmapImage); } iconBitmapImage.Freeze(); IconBitmap = iconBitmapImage; BitmapStatus = IconBitmapStatus.EmbeddedIcon; } else // we cannot use the reader object { IconBitmap = Images.DefaultPackageIcon; BitmapStatus = IconBitmapStatus.DefaultIconDueToNoPackageReader; } } } catch (Exception ex) when(IsHandleableBitmapEncodingException(ex)) { IconBitmap = Images.DefaultPackageIcon; BitmapStatus = IconBitmapStatus.DefaultIconDueToDecodingError; } }
private static bool IsAssemblyReference(string filePath) { // assembly reference must be under lib/ if (!filePath.StartsWith(PackagingConstants.Folders.Lib + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase) && !filePath.StartsWith(PackagingConstants.Folders.Lib + Path.AltDirectorySeparatorChar, StringComparison.OrdinalIgnoreCase)) { return(false); } var fileName = Path.GetFileName(filePath); // if it's an empty folder, yes if (fileName == PackagingCoreConstants.EmptyFolder) { return(true); } // Assembly reference must have a .dll|.exe|.winmd extension and is not a resource assembly: return(PackageReaderBase.IsAssemblyReference(filePath)); }
private static bool CheckFrameworkMatch(PackageReaderBase packageReader, NuGetFramework targetFramework, ref NugetPackageType type) { var frameworkReducer = new FrameworkReducer(); Dictionary <NugetPackageType, Func <IEnumerable <FrameworkSpecificGroup> > > getter = new Dictionary <NugetPackageType, Func <IEnumerable <FrameworkSpecificGroup> > > { { NugetPackageType.DotNetImplementationAssembly, () => packageReader.GetItems(NugetPackage.DotNetImplementationAssemblyPath) }, { NugetPackageType.DotNetCompileTimeAssembly, () => packageReader.GetItems(NugetPackage.DotNetCompileTimeAssemblyPath) }, }; foreach (var get in getter) { var items = get.Value(); var targetFrameworkString = targetFramework.GetFrameworkString(); var match = items.Where(x => targetFrameworkString == x.TargetFramework.GetFrameworkString()); if (match.Count() > 0) { type = get.Key; return(true); } } return(false); }
private static Tuple <NugetPackageType, NuGetFramework> GetNearestFramework(PackageReaderBase packageReader, NuGetFramework targetFramework) { var frameworkReducer = new FrameworkReducer(); Dictionary <NugetPackageType, Func <IEnumerable <FrameworkSpecificGroup> > > getter = new Dictionary <NugetPackageType, Func <IEnumerable <FrameworkSpecificGroup> > > { { NugetPackageType.DotNetImplementationAssembly, () => packageReader.GetItems(NugetPackage.DotNetImplementationAssemblyPath) }, { NugetPackageType.DotNetCompileTimeAssembly, () => packageReader.GetItems(NugetPackage.DotNetCompileTimeAssemblyPath) }, }; NuGetFramework nearest = null; foreach (var get in getter) { var items = get.Value(); var libFrameworks = items.Select(x => x.TargetFramework); nearest = frameworkReducer.GetNearest(targetFramework, libFrameworks); if (nearest != null) { return(new Tuple <NugetPackageType, NuGetFramework>(get.Key, nearest)); } } return(null); }
void RemoveContentFolders(PackageReaderBase package, string installPath, string contentPath) { var contentDirectory = new DirectoryInfo(Path.Combine(installPath, PackagingConstants.Folders.Content, contentPath)); if (contentDirectory.Exists) { var bootstrapperContent = new DirectoryInfo(Path.Combine(bootstrapperDirectory, contentPath)); if (bootstrapperContent.Exists) { foreach (var file in package.GetFiles(Path.Combine(PackagingConstants.Folders.Content, contentPath))) { var path = file.Split(DirectorySeparators, 2)[1]; var bootstrapperFilePath = Path.Combine(bootstrapperDirectory, path); if (File.Exists(bootstrapperFilePath)) { File.Delete(bootstrapperFilePath); } } RemoveEmptyDirectories(bootstrapperContent); } } }
/// <summary> /// This method ensures that the packages.config file is created and all the installed packages are added to it. /// </summary> /// <param name="packageToInstall">The nuget package to install with all its dependencies</param> /// <param name="packageReader">The <see cref="PackageReaderBase"/> to use in reading the package.</param> /// <param name="downloadResult">The <see cref="DownloadResourceResult"/> for the package.</param> /// <param name="nuGetFramework">The <see cref="NuGetFramework"/></param> /// <returns>The <see cref="NuspecReader"/> for reading the package's nuspec files.</returns> private async Task <NuspecReader> UpdatePackagesConfigFile( SourcePackageDependencyInfo packageToInstall, PackageReaderBase packageReader, DownloadResourceResult downloadResult, NuGetFramework nuGetFramework) { NuspecReader nuspecReader = await packageReader.GetNuspecReaderAsync(CancellationToken.None).ConfigureAwait(false); Dictionary <string, object> metadata = new Dictionary <string, object>() { { "Name", packageToInstall.Id }, { "TargetFrameWork", nuGetFramework } }; IDictionary <string, object> metadataObject = new ExpandoObject() as IDictionary <string, object>; foreach (KeyValuePair <string, object> kvp in metadata) { metadataObject.Add(kvp.Key, kvp.Value); } Dictionary <string, object> meta = new Dictionary <string, object> { { "Name", metadataObject.ToList().FirstOrDefault().Value }, { "TargetFramework", metadataObject.ToList().LastOrDefault().Value } }; PackagesConfigNuGetProject packagesConfigNuGetProject = new PackagesConfigNuGetProject(this.project.DirectoryPath, meta); await packagesConfigNuGetProject.InstallPackageAsync( packageToInstall, downloadResult, new EmptyNuGetProjectContext(), CancellationToken.None); return(nuspecReader); }
public static async IAsyncEnumerable <(string file, string[] folders, string platform, string architecture)> GetSupportedNativeLibsAsync(PackageReaderBase packageReader, ILogger logger) { var versions = await packageReader.GetItemsAsync(PackagingConstants.Folders.Runtimes, CancellationToken.None); var files = versions.SelectMany(v => v.Items); foreach (var file in files) { var folderPath = Path.GetDirectoryName(file); var folders = folderPath.Split(Path.DirectorySeparatorChar); if (folders.Length != 3 || !folders[2].Equals("native", StringComparison.OrdinalIgnoreCase)) { logger.LogInformation($"Skipping non-native library file located in the runtimes folder: {file} ..."); continue; } var system = folders[1].Split('-'); if (system.Length != 2) { logger.LogInformation($"Skipping file located in the runtime folder that does not specify platform and architecture: {file} ..."); continue; } var platform = system[0][..3] switch
static void UpdateFile(string path, PackageReaderBase packageReader, string file) { using Stream fromStream = packageReader.GetStream(file), toStream = File.Create(path); fromStream.CopyTo(toStream); }
public virtual Task <bool> OnPackageInstallingAsync(PackageIdentity package, NuGetFramework projectFramework, PackageReaderBase packageReader, string installPath) { return(Task.FromResult(true)); }
public virtual Task OnPackageUninstalledAsync(PackageIdentity package, NuGetFramework projectFramework, PackageReaderBase packageReader, string installPath) { return(Task.CompletedTask); }
private async Task <bool> CheckCanBeInstalledAsync(IExtensibleProject project, PackageReaderBase packageReader, NuGetFramework targetFramework, CancellationToken token) { Argument.IsNotNull(() => project); Argument.IsNotNull(() => packageReader); var frameworkReducer = new FrameworkReducer(); var libraries = await packageReader.GetLibItemsAsync(token); var libraryTfms = libraries.Select(x => x.TargetFramework).ToList(); var bestMatches = frameworkReducer.GetNearest(targetFramework, libraryTfms); if (bestMatches is null) { // Try to find first supported platform-specific version foreach (var platformSpecific in project.SupportedPlatforms) { bestMatches = frameworkReducer.GetNearest(platformSpecific, libraryTfms); if (bestMatches is not null) { break; } } } return(bestMatches is not null); }
public override Task <bool> OnPackageInstallingAsync(PackageIdentity package, NuGetFramework projectFramework, PackageReaderBase packageReader, string installPath) { if (PackageIdentityComparer.Default.Equals(package, Owner.targetPackage)) { Owner.InstallPath = PackageHelper.InstallExecutablePackage(package, projectFramework, packageReader, Owner.targetPath); Owner.DialogResult = DialogResult.OK; } return(base.OnPackageInstallingAsync(package, projectFramework, packageReader, installPath)); }
public static IReadOnlyDictionary <NuGetFramework, IReadOnlyList <TypeChanges> > ComparePackageTypes(PackageReaderBase package1, PackageReaderBase package2, out NuGetVersion suggestedVersion) { if (package1 == null) { throw new ArgumentNullException(nameof(package1)); } if (package2 == null) { throw new ArgumentNullException(nameof(package2)); } var frameworkChanges = new Dictionary <NuGetFramework, IReadOnlyList <TypeChanges> >(); foreach (var targetFramework in package1.GetSupportedFrameworks()) { var typeChanges = new List <TypeChanges>(); frameworkChanges.Add(targetFramework, typeChanges.AsReadOnly()); var dlls1 = package1.GetAssemblyReferences(targetFramework).ToList(); var dlls2 = package2.GetAssemblyReferences(targetFramework).ToList(); if (dlls1.Count != 0 && dlls2.Count == 0) { typeChanges.Add(new TypeChanges(null, new[] { Change.NonBreaking("Framework support removed: {0}", targetFramework) }.ToList().AsReadOnly())); continue; } var changes = new List <Change>(); foreach (var file1 in dlls1) { if (dlls2.Contains(file1)) { typeChanges.AddRange(FindChanges(package1.GetStream(file1), package2.GetStream(file1))); } else { changes.Add(Change.Breaking("Assembly removed: {0}", file1)); } } if (changes.Count != 0) { typeChanges.Add(new TypeChanges(null, changes.AsReadOnly())); } } suggestedVersion = SuggestVersion(package1.GetIdentity().Version, frameworkChanges.SelectMany(x => x.Value.SelectMany(y => y.Changes)).ToList()); return(frameworkChanges); }
public static IEnumerable <string> GetAssemblyReferences(this PackageReaderBase package, NuGetFramework targetFramework) { return(package.GetReferenceItems().Where(x => x.TargetFramework == targetFramework).SelectMany(x => x.Items)); }
/// <summary> /// Get absolute paths to the package's assembly references. Requires the package /// to already be installed/restored. /// </summary> public ImmutableList <FilePath> GetPackageAssemblyReferences( PackageReaderBase packageReader, PackageIdentity packageIdentity) => RelativeToAbsolute( GetRelativePackageAssemblyReferences(packageReader), packageIdentity);
public override Task <bool> OnPackageInstallingAsync(PackageIdentity package, NuGetFramework projectFramework, PackageReaderBase packageReader, string installPath) { if (PackageHelper.IsExecutablePackage(package, projectFramework, packageReader)) { Owner.Invoke((Action)(() => { var message = string.Format(Resources.InstallExecutablePackageWarning, package.Id); var result = MessageBox.Show(Owner, message, Resources.InstallExecutablePackageCaption, MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation); if (result == DialogResult.Yes) { Owner.saveFolderDialog.FileName = package.Id; if (Owner.saveFolderDialog.ShowDialog(Owner) == DialogResult.OK) { var targetPath = Owner.saveFolderDialog.FileName; Owner.InstallPath = PackageHelper.InstallExecutablePackage(package, projectFramework, packageReader, targetPath); Owner.DialogResult = DialogResult.OK; } } })); } return(base.OnPackageInstallingAsync(package, projectFramework, packageReader, installPath)); }
static bool IsTaggedPackage(PackageReaderBase package) { var tags = package.NuspecReader.GetTags(); return(tags != null && tags.Contains(PackageTagFilter)); }
private async Task <List <string> > GetSatelliteFilesForLibraryAsync(FrameworkSpecificGroup libraryFrameworkSpecificGroup, PackageReaderBase packageReader, CancellationToken cancellationToken) { var satelliteFiles = new List <string>(); using (var nuspec = await packageReader.GetNuspecAsync(cancellationToken)) { var nuspecReader = new NuspecReader(nuspec); var satelliteFilesInGroup = libraryFrameworkSpecificGroup.Items .Where(item => Path.GetDirectoryName(item) .Split(Path.DirectorySeparatorChar) .Contains(nuspecReader.GetLanguage(), StringComparer.OrdinalIgnoreCase)).ToList(); satelliteFiles.AddRange(satelliteFilesInGroup); return(satelliteFiles); } }
/// <summary> /// Initializes a new <see cref="DownloadResourceResult" /> class. /// </summary> /// <param name="stream">A package stream.</param> /// <param name="packageReader">A package reader.</param> /// <param name="source">A package source.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="stream" /> is <c>null</c>.</exception> public DownloadResourceResult(Stream stream, PackageReaderBase packageReader, string source) : this(stream, source) { _packageReader = packageReader; }
/// <summary> /// Converts IconUrl from PackageItemListViewModel to an image represented by a BitmapSource /// </summary> /// <param name="values">An array of two elements containing the IconUri and a generator function of PackageReaderBase objects</param> /// <param name="targetType">unused</param> /// <param name="parameter">A BitmapImage that will be used as the default package icon</param> /// <param name="culture">unused</param> /// <returns>A BitmapSource with the image</returns> /// <remarks> /// We bind to a BitmapImage instead of a Uri so that we can control the decode size, since we are displaying 32x32 images, while many of the images are 128x128 or larger. /// This leads to a memory savings. /// </remarks> public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture) { if (values == null || values.Length == 0) { return(null); } var iconUrl = values[0] as Uri; var defaultPackageIcon = parameter as BitmapSource; if (iconUrl == null) { return(null); } string cacheKey = GenerateKeyFromIconUri(iconUrl); var cachedBitmapImage = BitmapImageCache.Get(cacheKey) as BitmapSource; if (cachedBitmapImage != null) { return(cachedBitmapImage); } // Some people run on networks with internal NuGet feeds, but no access to the package images on the internet. // This is meant to detect that kind of case, and stop spamming the network, so the app remains responsive. if (ErrorFloodGate.IsOpen) { return(defaultPackageIcon); } var iconBitmapImage = new BitmapImage(); iconBitmapImage.BeginInit(); BitmapSource imageResult; if (IsEmbeddedIconUri(iconUrl)) { // Check if we have enough info to read the icon from the package if (values.Length == 2 && values[1] is Func <PackageReaderBase> lazyReader) { try { PackageReaderBase reader = lazyReader(); // Always returns a new reader. That avoids using an already disposed one if (reader is PackageArchiveReader par) // This reader is closed in BitmapImage events { var iconEntryNormalized = PathUtility.StripLeadingDirectorySeparators( Uri.UnescapeDataString(iconUrl.Fragment) .Substring(1)); // Substring skips the '#' in the URI fragment iconBitmapImage.StreamSource = par.GetEntry(iconEntryNormalized).Open(); void EmbeddedIcon_DownloadOrDecodeFailed(object sender, ExceptionEventArgs args) { reader.Dispose(); CheckForFailedCacheEntry(cacheKey, args); } void EmbeddedIcon_DownloadCompleted(object sender, EventArgs args) { reader.Dispose(); IconBitmapImage_DownloadCompleted(sender, args); } iconBitmapImage.DecodeFailed += EmbeddedIcon_DownloadOrDecodeFailed; iconBitmapImage.DownloadFailed += EmbeddedIcon_DownloadOrDecodeFailed; iconBitmapImage.DownloadCompleted += EmbeddedIcon_DownloadCompleted; imageResult = FinishImageProcessing(iconBitmapImage, iconUrl, defaultPackageIcon); } else // we cannot use the reader object { reader?.Dispose(); AddToCache(cacheKey, defaultPackageIcon); imageResult = defaultPackageIcon; } } catch (Exception) { AddToCache(cacheKey, defaultPackageIcon); imageResult = defaultPackageIcon; } } else // Identified an embedded icon URI, but we are unable to process it { AddToCache(cacheKey, defaultPackageIcon); imageResult = defaultPackageIcon; } } else { iconBitmapImage.UriSource = iconUrl; iconBitmapImage.DecodeFailed += IconBitmapImage_DownloadOrDecodeFailed; iconBitmapImage.DownloadFailed += IconBitmapImage_DownloadOrDecodeFailed; iconBitmapImage.DownloadCompleted += IconBitmapImage_DownloadCompleted; imageResult = FinishImageProcessing(iconBitmapImage, iconUrl, defaultPackageIcon); } return(imageResult); }
/// <summary> /// Initializes a new <see cref="DownloadResourceResult" /> class. /// </summary> /// <param name="stream">A package stream.</param> /// <param name="packageReader">A package reader.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="stream" /> is <c>null</c>.</exception> public DownloadResourceResult(Stream stream, PackageReaderBase packageReader) : this(stream, packageReader, source : null) { }
IReadOnlyList <string> GetRelativePackageAssemblyReferences(PackageReaderBase packageReader) => Normalize(GetMostCompatibleGroup(TargetFramework, packageReader.GetReferenceItems())) ?.Items ?.ToList();
public PackageOperationEventArgs(PackageIdentity package, PackageReaderBase packageReader, string installPath) { Package = package; PackageReader = packageReader; InstallPath = installPath; }