C# DefaultPackagePathResolver.GetInstallPath方法代码示例

        /// <summary>
        /// Checks whether an IPackage exists within a PackageManager.  By default, will use the UseSideBySide settings of the DefaultPackagePathProvider the PackageManager is instantiated with.
        /// If passed in TRUE for exhaustive, will check both with and without UseSideBySide set.
        /// </summary>
        /// <param name="packageManager"></param>
        /// <param name="package"></param>
        /// <param name="exhaustive"></param>
        /// <returns></returns>
        public static bool IsPackageInstalled(this PackageManager packageManager,  IPackage package, bool exhaustive = false)
        {

            var pathsDictionary = new Dictionary<string, bool>();
            //Oh god oh god. The <center> cannot hold it is too late.
            var useSideBySide = packageManager.PathResolver.GetPrivateField<bool>("_useSideBySidePaths");
            pathsDictionary.Add(Path.Combine(packageManager.PathResolver.GetInstallPath(package), 
                packageManager.PathResolver.GetPackageFileName(package.Id, package.Version)), useSideBySide);

            //We need to also check the inverse, to see if it was installed with the other setting....
            if (exhaustive)
            {
                var inversePathResolver = new DefaultPackagePathResolver(packageManager.PathResolver.GetPrivateField<IFileSystem>("_fileSystem"), !useSideBySide);
                pathsDictionary.Add(Path.Combine(inversePathResolver.GetInstallPath(package), inversePathResolver.GetPackageFileName(package.Id, package.Version)), !useSideBySide);
            }

            foreach (var path in pathsDictionary.Where(path => packageManager.FileSystem.FileExists(path.Key)))
            {
                if (path.Value)
                {
                    return true;
                }
                
                //If not useSideBySide, we need to crack open the zip file.
                //Need to crack the package open at this point and check the version, otherwise we just need to download it regardless
                var zipPackage = new ZipPackage(packageManager.FileSystem.OpenFile(path.Key));
                if (zipPackage.Version == package.Version)
                {
                    return true;
                }
            }

            //Its not here.  Really.  We tried.
            return false;
        }

        public void GetInstallPathPrependsFileSystemRootToPackageDirectory()
        {
            // Arrange
            MockFileSystem fs = new MockFileSystem();
            DefaultPackagePathResolver resolver = new DefaultPackagePathResolver(fs);
            IPackage testPackage = PackageUtility.CreatePackage("Test");

            // Act
            string installPath = resolver.GetInstallPath(testPackage);

            // Assert
            Assert.Equal(fs.Root + "Test.1.0", installPath);
        }

        public bool CanDetermineVersionlessPackageIsInstalled(string id, string onDiskVersion, string packageVersion, bool installedUsingMultipleVersion, bool currentlyAllowMultipleVersions, bool exhaustive)
        {
            var mfs = new Mock<MockFileSystem>() { CallBase = true };
            mfs.Setup(m => m.Root).Returns(@"c:\packages");

            var installPathResolver = new DefaultPackagePathResolver(mfs.Object, installedUsingMultipleVersion);
            var currentPathResolver = new DefaultPackagePathResolver(mfs.Object, currentlyAllowMultipleVersions);

            var testPackage = new DataServicePackage()
            {
                Version = packageVersion,
                Id = id
            };

            var filePackage = new DataServicePackage()
            {
                Version = onDiskVersion,
                Id = id
            };

            IPackage zipPackage = null;
            if (!string.IsNullOrEmpty(onDiskVersion))
            {
                string baseLocation = installPathResolver.GetInstallPath(filePackage);
                string fileName = installPathResolver.GetPackageFileName(filePackage.Id, SemanticVersion.Parse(filePackage.Version));
                string filePath = Path.Combine(baseLocation, fileName);
                zipPackage = PackageUtility.GetZipPackage(filePackage.Id, filePackage.Version);
                mfs.Setup(m => m.FileExists(filePath)).Returns(true);
                mfs.Setup(m => m.OpenFile(filePath)).Returns(zipPackage.GetStream());
                mfs.Object.AddFile(filePath, zipPackage.GetStream());
            }

            var pm = new PackageManager(new MockPackageRepository(), currentPathResolver, mfs.Object);
            var exists = pm.IsPackageInstalled(testPackage,exhaustive: exhaustive);
            //var test = testPackage.IsPackageInstalled(allowMultipleVersions, pm, mfs.Object);
            return exists;
        }