C# MemoryStream.Reset方法代码示例

        /// <summary>
        /// Merges a row tree with a PDF document containing form fields.
        /// </summary>
        public static void CreatePdf(
            MergeRowTree rowTree, bool ensureAllFieldsHaveValues, MemoryStream sourcePdfStream, Stream destinationStream,
            bool useLegacyBehaviorOfIgnoringInvalidFields = false)
        {
            var streams = new List<Stream>();
            try {
                foreach( var row in rowTree.Rows ) {
                    var stream = new MemoryStream();
                    streams.Add( stream );

                    using( var sourcePdfMemoryStreamCopy = new MemoryStream() ) {
                        // Aspose has decided that in the new Facades PDF library, they will close your source stream for you when you call doc.Save.
                        sourcePdfStream.Reset();
                        sourcePdfStream.CopyTo( sourcePdfMemoryStreamCopy );

                        var doc = new Aspose.Pdf.Facades.Form( sourcePdfMemoryStreamCopy );
                        foreach( var mergeField in doc.FieldNames.Where( mergeField => !mergeField.StartsWith( "noMerge" ) ) ) {
                            var mergeValue = row.Values.SingleOrDefault( v => v.Name == mergeField );
                            if( mergeValue == null ) {
                                if( useLegacyBehaviorOfIgnoringInvalidFields )
                                    continue;
                                throw new MailMergingException( string.Format( "PDF document contains a merge field ({0}) that does not exist.", mergeField ) );
                            }

                            var mergeValueAsString = mergeValue as MergeValue<string>;
                            string value = null;
                            if( mergeValueAsString != null )
                                value = mergeValueAsString.Evaluate( ensureAllFieldsHaveValues );
                            if( value == null )
                                throw new MailMergingException( "Merge field " + mergeValue.Name + " evaluates to an unsupported type." );

                            doc.FillField( mergeValue.Name, value );
                        }
                        doc.Save( stream );
                    }
                }

                if( streams.Any() )
                    PdfOps.ConcatPdfs( streams, destinationStream );
            }
            finally {
                foreach( var i in streams )
                    i.Dispose();
            }
        }

        public static string Decode(string s, bool convertPlus, Encoding charset)
        {
            if (s.IndexOf('%') == -1 && (!convertPlus || s.IndexOf('+') == -1)) {
                return s;
            }

            StringBuilder result = new StringBuilder(s.Length);
            MemoryStream @out = new MemoryStream();
            for (int i = 0; i < s.Length;) {
                char c = s[i];
                if (c == '%') {
                    do {
                        if (i + 2 >= s.Length) {
                            throw new ArgumentException("Incomplete % sequence at: " + i);
                        }
                        int d1 = HexToInt(s[i + 1]);
                        int d2 = HexToInt(s[i + 2]);
                        if (d1 == -1 || d2 == -1) {
                            throw new ArgumentException("Invalid % sequence " + s.Substring(i, 3) + " at " + i);
                        }
                        @out.WriteByte(unchecked((byte)((d1 << 4) + d2)));
                        i += 3;
                    } while (i < s.Length && s[i] == '%');
                    result.Append(charset.GetString(@out.ToArray()));
                    @out.Reset();
                }
                else {
                    if (convertPlus && c == '+') {
                        c = ' ';
                    }
                    result.Append(c);
                    i++;
                }
            }

            return result.ToString();
        }

        /// <summary>
        /// Stores item manifest in zip package's comments
        /// </summary>
        private void UpdateItemManifest()
        {
            if (this.TempZipFile)
                throw new ApplicationException("ZipPackage is read-only when reading from temp directory");

            if (this.ItemManifest.Items.Count == 0)
                throw new ApplicationException("No items to add to package manifest");

            var manifestXml = XmlSerializer.SerializeXml(this.ItemManifest);

            using (var ms = new MemoryStream())
            {
                using (ZipFile zip = this.Items.Length == 0 ? new ZipFile() : ZipFile.Read(this.Items.Reset()))
                {
                    if (zip.ContainsEntry("manifest.xml"))
                        zip.UpdateEntry("manifest.xml", XmlSerializer.StringToUTF8ByteArray(manifestXml));
                    else
                        zip.AddEntry("manifest.xml", XmlSerializer.StringToUTF8ByteArray(manifestXml));

                    zip.Save(ms);
                }

                this.Items = new MemoryStream();
                ms.Reset().CopyTo(this.Items);
            }
        }

        /// <summary>
        /// Returns an open stream from Items for the named item
        /// </summary>
        /// <param name="itemName"></param>
        /// <returns></returns>
        public Stream Extract(string itemName)
        {
            Stream ms = new MemoryStream();

            if (this.TempZipFile)
            {
                using (var file = new FileStream(this.TempZipFilePath, FileMode.Open))
                {
                    file.CopyTo(ms);
                }
            }
            else
            {
                using (ZipFile zip = ZipFile.Read(this.Items.Reset()))
                {
                    ZipEntry entry = zip[itemName];
                    if (entry != null)
                        entry.Extract(ms);
                }
            }

            return ms.Reset();
        }

        /// <summary>
        /// Adds an item to Items
        /// </summary>
        /// <param name="itemType"></param>
        /// <param name="item"></param>
        /// <param name="itemName"></param>
        /// <returns></returns>
        public void Add(ZipPackageItemType itemType, string itemName, Stream item)
        {
            if (this.TempZipFile)
                throw new ApplicationException("ZipPackage is read-only when reading from temp directory");

            using (var ms = new MemoryStream())
            {
                using (ZipFile zip = this.Items.Length == 0 ? new ZipFile() : ZipFile.Read(this.Items.Reset()))
                {
                    zip.AddEntry(itemName, item.Reset());
                    zip.Save(ms);
                }

                this.Items = new MemoryStream();
                ms.Reset().CopyTo(this.Items);
            }

            this.ItemManifest.Items.Add(new OfflineZipPackageItem<string, ZipPackageItemType>(itemName, itemType));

            this.UpdateItemManifest();
        }

        internal static void Test()
        {
            // NOTE: This path is probably wrong, and should not be hard-coded.
            const string sourceFolderPath = @"C:\Red Stapler Vault\Supporting Files\Standard Library\Standard Library\MailMerging";

            var outputFolderPath = TestStatics.OutputFolderPath;
            IoMethods.DeleteFolder( outputFolderPath );

            // Create and extract empty zip file
            var emptyFolderPath = EwlStatics.CombinePaths( outputFolderPath, "Empty" );
            Directory.CreateDirectory( emptyFolderPath );
            var emptyZipPath = EwlStatics.CombinePaths( outputFolderPath, "empty.zip" );
            ZipFolderAsFile( emptyFolderPath, emptyZipPath );
            using( var memoryStream = new MemoryStream() ) {
                ZipFolderAsStream( emptyFolderPath, memoryStream );
                memoryStream.Reset();
                UnZipStreamIntoFolder( memoryStream, EwlStatics.CombinePaths( outputFolderPath, "Empty from stream" ) );
            }

            // File-based
            var zipFilePath = EwlStatics.CombinePaths( outputFolderPath, "file.zip" );
            var extractedPath = EwlStatics.CombinePaths( outputFolderPath, "Extracted from File" );
            ZipFolderAsFile( sourceFolderPath, zipFilePath );
            UnZipFileAsFolder( zipFilePath, extractedPath );

            // Byte-array-based
            var bytes = ZipFolderAsByteArray( sourceFolderPath );
            var byteZipFilePath = EwlStatics.CombinePaths( outputFolderPath, "fileFromBytes.zip" );
            File.WriteAllBytes( byteZipFilePath, bytes );
            UnZipByteArrayAsFolder( File.ReadAllBytes( byteZipFilePath ), EwlStatics.CombinePaths( outputFolderPath, "Extracted from Byte Array" ) );

            // Stream-based
            var streamedFilePath = EwlStatics.CombinePaths( outputFolderPath, "fileFromStream.zip" );
            using( var fs = new FileStream( streamedFilePath, FileMode.Create ) )
                ZipFolderAsStream( sourceFolderPath, fs );

            var streamedExtractedPath = EwlStatics.CombinePaths( outputFolderPath, "Extracted from Stream" );
            using( var memoryStream = new MemoryStream() ) {
                ZipFolderAsStream( sourceFolderPath, memoryStream );
                memoryStream.Reset();
                UnZipStreamIntoFolder( memoryStream, streamedExtractedPath );
            }

            using( var fs = File.OpenRead( streamedFilePath ) ) {
                var files = UnZipStreamAsFileObjects( fs );
                ZipFileObjectsAsStream( files, File.OpenWrite( EwlStatics.CombinePaths( outputFolderPath, "fileFromStreamedFileObjects.zip" ) ) );
            }
        }

        static void Main(string[] args)
        {
            {
                var ms = new MemoryStream();
                var t1 = new Packtest();
                ms.Reset();
                t1.Field9 = null;
                t1.Pack(ms);
                ms.Reset();
                t1.Unpack(ms);
            }
            return;

            var test1 = new SpeedTest(delegate()
            {
                var ms = new MemoryStream();
                var t1 = new Packtest();
                ms.Reset();
                t1.Pack(ms);
                ms.Reset();
                t1.Unpack(ms);
            });

            var test2 = new SpeedTest(delegate()
            {
                var ms = new MemoryStream();
                var t2 = new Packtest2();
                ms.Reset();
                t2.Pack(ms);
                ms.Reset();
                t2.Unpack(ms);
            });

            test2.Test();
            test1.Test();

            Console.WriteLine("My serialize class");
            Console.WriteLine("Min: {0}ms", test1.Min);
            Console.WriteLine("Avg: {0}ms", test1.Average);
            Console.WriteLine("Max: {0}ms", test1.Max);
            Console.WriteLine();
            Console.WriteLine("Binaryreader/writer");
            Console.WriteLine("Min: {0}ms", test2.Min);
            Console.WriteLine("Avg: {0}ms", test2.Average);
            Console.WriteLine("Max: {0}ms", test2.Max);

            Console.ReadKey();
        }