C# IPackageFile.GetStream方法代码示例

        private static string CheckFile(string url, IPackageFile file)
        {
            var binary = new BinaryStoreManager();
            var symbol = new SymbolStoreManager();

            var name = Path.ChangeExtension(Path.GetFileName(file.Path), "pdb");
            var compressedName = name.Substring(0, name.Length - 1) + '_';

            string hash;

            using (var stream = file.GetStream())
                hash = binary.ReadPdbHash(stream);

            byte[] buffer;

            try
            {
                using (var client = new WebClient())
                    buffer = client.DownloadData(string.Format("{0}/{1}/{2}/{3}", url, name, hash, compressedName));
            }
            catch (WebException exception)
            {
                return ((HttpWebResponse)exception.Response).StatusCode.ToString();
            }

            //using (var stream = new MemoryStream(buffer))
            //    if (symbol.ReadHash(stream) != hash)
            //        return "MISMATCHED";

            return "FOUND";
        }

 internal static string Process(IPackageFile file, IPropertyProvider propertyProvider)
 {
     using (var stream = file.GetStream())
     {
         return Process(stream, propertyProvider, throwIfNotFound: false);
     }
 }

 private async Task CopyPackageFileToPath(string installPath, IPackageFile packageFile)
 {
     using (var fileStream = File.Create(Path.Combine(installPath, Path.GetFileName(packageFile.Path))))
     {
         await packageFile.GetStream().CopyToAsync(fileStream);
     }
 }

 private static XElement GetXml(IPackageFile file, IProjectSystem projectSystem)
 {
     using (Stream stream = file.GetStream())
     {
         var content = Preprocessor.Process(file, projectSystem);
         return XElement.Parse(content);
     }
 }

 private static bool VerifySigned(IPackageFile packageFile)
 {
     bool result;
     using (Stream stream = packageFile.GetStream())
     {
         System.IO.StreamReader streamReader = new System.IO.StreamReader(stream);
         string text = streamReader.ReadToEnd();
         result = (text.IndexOf("# SIG # Begin signature block", StringComparison.OrdinalIgnoreCase) > -1 && text.IndexOf("# SIG # End signature block", StringComparison.OrdinalIgnoreCase) > -1);
     }
     return result;
 }

        private static byte[] GetConfigurationFileAsBytes(IPackageFile agentConfigurationFile)
        {
            var agentConfigurationFileStream = agentConfigurationFile.GetStream();

            byte[] configBytes;

            using (var memoryStream = new MemoryStream())
            {
                agentConfigurationFileStream.CopyTo(memoryStream);
                configBytes = memoryStream.ToArray();
                memoryStream.Close();
            }
            return configBytes;
        }

 private void SaveAssemblyFile(string installPath, IPackageFile file)
 {
     var targetPath = installPath.AppendPath(file.Path);
     Directory.CreateDirectory(targetPath.ParentDirectory());
     using (Stream outputStream = File.Create(targetPath)){
         file.GetStream().CopyTo(outputStream);
     }
 }

 protected virtual void UpdateFile(string exePath, IPackageFile file)
 {
     using (Stream fromStream = file.GetStream(), toStream = File.Create(exePath))
     {
         fromStream.CopyTo(toStream);
     }
 }

        void CopyFileToLocation(FileSystemInfoBase target, IPackageFile x)
        {
            var targetPath = Path.Combine(target.FullName, x.EffectivePath);

            var fi = fileSystem.GetFileInfo(targetPath);
            if (fi.Exists) fi.Delete();

            var dir = fileSystem.GetDirectoryInfo(Path.GetDirectoryName(targetPath));
            if (!dir.Exists) dir.Create();

            using (var inf = x.GetStream())
            using (var of = fi.Open(FileMode.CreateNew, FileAccess.Write)) {
                log.Debug("Writing {0} to app directory", targetPath);
                inf.CopyTo(of);
            }
        }

 /// <summary>
 /// Installs a new package file
 /// </summary>
 /// <param name="package">
 /// The package being installed
 /// </param>
 /// <param name="file">
 /// The file to install
 /// </param>
 private void InstallFile(IPackage package, IPackageFile file)
 {
     // map the package file to its deployment location (or suppress it)
      var path = GetFullPath(file);
      if (path == null)
     Log.Trace("Skipping file {0}", file);
      else
      {
     Log.Trace("Extracting file {0} to {1}", file, path);
     // extract the package file and stamp it with the package date
     ExtractFile(file.GetStream(), path);
     File.SetLastWriteTimeUtc(
        path,
        (package.Published ?? DateTimeOffset.UtcNow).UtcDateTime
     );
      }
 }

 internal static bool ContentEquals(IPackageFile targetFile, string fullPath)
 {
     bool isEqual;
     using (var dependencyFileStream = targetFile.GetStream())
     using (var fileContentsStream = File.OpenRead(fullPath))
     {
         isEqual = dependencyFileStream.ContentEquals(fileContentsStream);
     }
     return isEqual;
 }

        private string ExtractToSymbols(IPackage package, IPackageFile symbolFile)
        {
            var path = symbolsPathResolver.GetSymbolsPath(package, symbolFile);

            EnsureDirectory(path);

            using (var file = File.Open(path, FileMode.OpenOrCreate))
                symbolFile.GetStream().CopyTo(file);

            return path;
        }

 private static void UpdateFile(string newFilePath, IPackageFile file)
 {
     EnsureDirectory(newFilePath);
     using (Stream fromStream = file.GetStream(), toStream = File.Create(newFilePath))
     {
         fromStream.CopyTo(toStream);
     }
 }

        private bool UpdateFile(string exePath, IPackageFile file)
        {
            using (Stream fromStream = file.GetStream())
            {
                if (fromStream == null)
                {
                    return false;
                }

                using (Stream toStream = this.filesystemAccessor.GetWriteStream(exePath))
                {
                    if (toStream == null)
                    {
                        return false;
                    }

                    fromStream.CopyTo(toStream);

                    return true;
                }
            }
        }

 private void UnpackFile(string fileOut, IPackageFile file)
 {
     var stream = File.OpenWrite(fileOut);
     file.GetStream().CopyTo(stream);
 }