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