C# MemoryStream.Seek方法代码示例

    public static void Main() {
        var ms = new MemoryStream();
        ms.Write(new byte[] { 0, 1, 2, 3 }, 0, 4);

        ms.Seek((Int64)0, SeekOrigin.Begin);
        PrintStatus(ms);

        ms.Seek((Int64)0, SeekOrigin.End);
        PrintStatus(ms);

        ms.Seek((Int64)(-2), SeekOrigin.Current);
        PrintStatus(ms);
    }

    public async Task Invoke(HttpContext context)
    {
        var bodyStream = context.Response.Body;

        var responseBodyStream = new MemoryStream();
        context.Response.Body = responseBodyStream;

        await _next(context);
     
        responseBodyStream.Seek(0, SeekOrigin.Begin);
        var responseBody = new StreamReader(responseBodyStream).ReadToEnd();
        _logger.LogInformation($"RESPONSE LOG: {responseBody}");
        responseBodyStream.Seek(0, SeekOrigin.Begin);
        await responseBodyStream.CopyToAsync(bodyStream);
    }

    private static string ConvertRtfToXaml(string rtfText)
    {
        var richTextBox = new RichTextBox();
        if (string.IsNullOrEmpty(rtfText)) return "";

        var textRange = new TextRange(richTextBox.Document.ContentStart, richTextBox.Document.ContentEnd);

        //Create a MemoryStream of the Rtf content

        using (var rtfMemoryStream = new MemoryStream())
        {
            using (var rtfStreamWriter = new StreamWriter(rtfMemoryStream))
            {
                rtfStreamWriter.Write(rtfText);
                rtfStreamWriter.Flush();
                rtfMemoryStream.Seek(0, SeekOrigin.Begin);

                //Load the MemoryStream into TextRange ranging from start to end of RichTextBox.
                textRange.Load(rtfMemoryStream, DataFormats.Rtf);
            }
        }

        using (var rtfMemoryStream = new MemoryStream())
        {

            textRange = new TextRange(richTextBox.Document.ContentStart, richTextBox.Document.ContentEnd);
            textRange.Save(rtfMemoryStream, DataFormats.Xaml);
            rtfMemoryStream.Seek(0, SeekOrigin.Begin);
            using (var rtfStreamReader = new StreamReader(rtfMemoryStream))
            {
                return rtfStreamReader.ReadToEnd();
            }
        }

    }

    public static void Main()
    {
        Console.WriteLine("999 is 03e7 when big endian");
        Console.WriteLine("999 = " + BitConverter.ToString(BitConverter.GetBytes(999)));
        Console.WriteLine("byteorder = " + (BitConverter.IsLittleEndian ? "little" : "big"));
        int x = (1 << 24)
              + (2 << 16)
              + (3 <<  8)
              + 4;

        Console.WriteLine("int   = " + x + " # " +
            BitConverter.ToString(BitConverter.GetBytes(x), 0));

        using(var m = new MemoryStream())
        {
            using(var w = new BinaryWriter(m))
            {
                w.Write(x);
                m.Seek(0, SeekOrigin.Begin);
                var buf = m.GetBuffer();
                Array.Resize(ref buf, 4);
                Console.WriteLine("write = " + BitConverter.ToInt32(buf, 0) + " # " +
                    BitConverter.ToString(buf, 0));

                using(var r = new BinaryReader(m))
                {
                    int y = r.ReadInt32();
                    Console.WriteLine("read  = " +y + " # " +
                        BitConverter.ToString(BitConverter.GetBytes(y)));
                }
            }
        }
    }

    private static void Test(string content, Action action)
    {
        TextWriter savedStandardOutput = Console.Out;
        TextReader savedStandardInput = Console.In;

        try
        {
            using (MemoryStream memStream = new MemoryStream())
            {
                // Write the content, but leave the stream open.
                using (StreamWriter sw = new StreamWriter(memStream, Encoding.Unicode, 1024, true))
                {
                    sw.Write(content);
                    sw.Flush();
                }

                memStream.Seek(0, SeekOrigin.Begin);

                using (StreamReader sr = new StreamReader(memStream))
                {
                    Console.SetIn(sr);
                    action();
                }

            }
        }
        finally
        {
            Console.SetOut(savedStandardOutput);
            Console.SetIn(savedStandardInput);
        }
    }

    protected void OnOpenActionActivated(object sender, EventArgs e)
    {
        Gtk.FileChooserDialog fc = new FileChooserDialog (
                                       "Choose image to open",
                                       this,
                                       Gtk.FileChooserAction.Open, "Cancel", ResponseType.Cancel, "Open", ResponseType.Accept);
        fc.Filter = new FileFilter();
        fc.Filter.AddPattern ("*.png");
        fc.Filter.AddPattern ("*.jpg");
        fc.Filter.AddPattern("*.jpeg");
        fc.Filter.AddPattern ("*.gif");
        fc.Filter.AddPattern("*.tiff");

        if (fc.Run() == (int)ResponseType.Accept)
        {
            System.Drawing.Image host = System.Drawing.Image.FromFile (fc.Filename);
            Bitmap hostImage = new Bitmap (host);
            MemoryStream pic = new MemoryStream ();
            hostImage.Save (pic, System.Drawing.Imaging.ImageFormat.Png);

            pic.Seek (0, SeekOrigin.Begin);
            Gdk.Pixbuf pb = new Gdk.Pixbuf (pic);
            originalImage.Pixbuf = pb;
        }
        //Don't forget to call Destroy() or the FileChooserDialog window won't get closed.
        fc.Destroy();
    }

    /// <summary>
    /// Builds and in memory stream containing the binary data in a multi-part MIME that is ready for upload
    /// </summary>
    /// <returns></returns>
    public override byte [] GenerateMimeEncodedChunk()
    {
        var inMemoryStream = new MemoryStream();
        using (inMemoryStream)
        {
            WriteBoundaryLine(inMemoryStream);
//            WriteAsciiLine(inMemoryStream, "Content-Disposition: name=\"request_payload\"");
            WriteAsciiLine(inMemoryStream, "Content-Disposition: form-data; name=\"request_payload\"");  //Server v9.2 is stricter about request syntax
            WriteAsciiLine(inMemoryStream, "Content-Type: text/xml");
            WriteAsciiLine(inMemoryStream);
            WriteAsciiLine(inMemoryStream); //[2015-10-17] Extra line to meet expectations for 2 empty lines after content

            WriteBoundaryLine(inMemoryStream);
//            WriteAsciiLine(inMemoryStream, "Content-Disposition: name=\"tableau_file\"; filename=\"FILE-NAME\"");
            WriteAsciiLine(inMemoryStream, "Content-Disposition: form-data; name=\"tableau_file\"; filename=\"FILE-NAME\"");  //Server v9.2 is stricter about request syntax
            WriteAsciiLine(inMemoryStream, "Content-Type: application/octet-stream");
            WriteAsciiLine(inMemoryStream);

            //Write the raw binary data
            inMemoryStream.Write(_uploadData, 0, _numberBytes);
            WriteAsciiLine(inMemoryStream);
            WriteBoundaryLine(inMemoryStream, true);

            //Go to the beginning
            inMemoryStream.Seek(0, SeekOrigin.Begin);
            return inMemoryStream.ToArray();
        }
    }

    public static void CreateStaticReport()
    {
        //Open template
        string path = System.Web.HttpContext.Current.Server.MapPath("~");
        path = path.Substring(0, path.LastIndexOf("\\"));
        path += @"\designer\MyTestBook1.xls";

        //Instantiate a new Workbook object.
        Workbook book = new Workbook(path);

        ImageOrPrintOptions imgOptions = new ImageOrPrintOptions();
        imgOptions.ImageFormat = System.Drawing.Imaging.ImageFormat.Jpeg;

        Worksheet sheet = book.Worksheets[0];
        SheetRender sheetRender = new SheetRender(sheet, imgOptions);

        //Create a memory stream object.
        MemoryStream memorystream = new MemoryStream();

        //Convert worksheet to image.
        sheetRender.ToImage(0, memorystream);

        memorystream.Seek(0, SeekOrigin.Begin);

        //Set Response object to stream the image file.
        byte[] data = memorystream.ToArray();
        HttpContext.Current.Response.Clear();
        HttpContext.Current.Response.ContentType = "image/jpeg";
        HttpContext.Current.Response.AddHeader("content-disposition", "attachment; filename=SheetImage.jpeg");
        HttpContext.Current.Response.OutputStream.Write(data, 0, data.Length);

        //End response to avoid unneeded html after xls
        HttpContext.Current.Response.End();
    }

    public void saveImageDataToLibrary(string jsonArgs)
    {
        try
        {
            var options = JsonHelper.Deserialize<string[]>(jsonArgs);

            string imageData = options[0];
            byte[] imageBytes = Convert.FromBase64String(imageData);

            using (var imageStream = new MemoryStream(imageBytes))
            {
                imageStream.Seek(0, SeekOrigin.Begin);

                string fileName = String.Format("c2i_{0:yyyyMMdd_HHmmss}", DateTime.Now);
                var library = new MediaLibrary();
                var picture = library.SavePicture(fileName, imageStream);

                if (picture.Name.Contains(fileName))
                {
                    DispatchCommandResult(new PluginResult(PluginResult.Status.OK,
                        "Image saved: " + picture.Name));
                }
                else
                {
                    DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR,
                        "Failed to save image: " + picture.Name));
                }
            }
        }
        catch (Exception ex)
        {
            DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, ex.Message));
        }
    }

        public static void MemoryStream_Write_BeyondCapacity()
        {
            using (MemoryStream memoryStream = new MemoryStream())
            {
                long origLength = memoryStream.Length;
                byte[] bytes = new byte[10];
                for (int i = 0; i < bytes.Length; i++)
                    bytes[i] = (byte)i;
                int spanPastEnd = 5;
                memoryStream.Seek(spanPastEnd, SeekOrigin.End);
                Assert.Equal(memoryStream.Length + spanPastEnd, memoryStream.Position);

                // Test Write
                memoryStream.Write(bytes, 0, bytes.Length);
                long pos = memoryStream.Position;
                Assert.Equal(pos, origLength + spanPastEnd + bytes.Length);
                Assert.Equal(memoryStream.Length, origLength + spanPastEnd + bytes.Length);

                // Verify bytes were correct.
                memoryStream.Position = origLength;
                byte[] newData = new byte[bytes.Length + spanPastEnd];
                int n = memoryStream.Read(newData, 0, newData.Length);
                Assert.Equal(n, newData.Length);
                for (int i = 0; i < spanPastEnd; i++)
                    Assert.Equal(0, newData[i]);
                for (int i = 0; i < bytes.Length; i++)
                    Assert.Equal(bytes[i], newData[i + spanPastEnd]);
            }
        }

    public static void WriteWithEncoding()
    {
        Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

        XmlWriterSettings settings = new XmlWriterSettings();
        settings.OmitXmlDeclaration = true;
        settings.ConformanceLevel = ConformanceLevel.Fragment;
        settings.CloseOutput = false;
        settings.Encoding = Encoding.GetEncoding("Windows-1252");
        MemoryStream strm = new MemoryStream();

        using (XmlWriter writer = XmlWriter.Create(strm, settings))
        {
            writer.WriteElementString("orderID", "1-456-ab\u0661");
            writer.WriteElementString("orderID", "2-36-00a\uD800\uDC00\uD801\uDC01");
            writer.Flush();
        }

        strm.Seek(0, SeekOrigin.Begin);
        byte[] bytes = new byte[strm.Length];
        int bytesCount = strm.Read(bytes, 0, (int)strm.Length);
        string s = settings.Encoding.GetString(bytes, 0, bytesCount);

        Assert.Equal("<orderID>1-456-ab&#x661;</orderID><orderID>2-36-00a&#x10000;&#x10401;</orderID>", s);
    }

        public static void SerializeToLocalStorage(this object value, string fullPath)
        {
            if (value == null)
                throw (new ArgumentNullException("Value cannot be NULL.", "value"));

            string file = null;
            string[] paths = fullPath.Split('\\');

            if (paths.Length < 1 || string.IsNullOrWhiteSpace(paths[0]))
                throw (new ArgumentException("This is not a valid path for LocalStorage.", "filename"));

            file = paths[paths.Length - 1];
            
            MemoryStream stream = new MemoryStream();
            
            DataContractSerializer serializer = new DataContractSerializer(value.GetType());
            serializer.WriteObject(stream, value);
            stream.Seek(0, SeekOrigin.Begin);

            byte[] buffer = new byte[stream.Length];
            stream.Read(buffer, 0, (int)stream.Length);

            File.WriteAllBytes(fullPath, buffer);

            stream.Flush();
            stream.Close();
        }

 private static byte[] DecodeLzma(byte[] lzmaByteArray)
 {
     byte[] result = null;
     Decoder decoder = new Decoder();
     using (MemoryStream memoryStream = new MemoryStream(lzmaByteArray))
     {
         memoryStream.Seek(0L, SeekOrigin.Begin);
         using (MemoryStream memoryStream2 = new MemoryStream())
         {
             byte[] array = new byte[5];
             if (memoryStream.Read(array, 0, 5) != 5)
             {
                 throw new Exception("input .lzma is too short");
             }
             long num = 0L;
             for (int i = 0; i < 8; i++)
             {
                 int num2 = memoryStream.ReadByte();
                 if (num2 < 0)
                 {
                     throw new Exception("Can't Read 1");
                 }
                 num |= (long)((long)((ulong)((byte)num2)) << 8 * i);
             }
             decoder.SetDecoderProperties(array);
             long inSize = memoryStream.Length - memoryStream.Position;
             decoder.Code(memoryStream, memoryStream2, inSize, num, null);
             result = memoryStream2.ToArray();
         }
     }
     return result;
 }

    public void VerifyCreatedCode()
    {
        var semanticVersion = new SemanticVersion
        {
            Major = 1,
            Minor = 2,
            Patch = 3,
            PreReleaseTag = "unstable4",
            BuildMetaData = new SemanticVersionBuildMetaData(5,
                "feature1", "commitSha", DateTimeOffset.Parse("2014-03-06 23:59:59Z"))
        };
        var assemblyInfoBuilder = new AssemblyInfoBuilder();
        var versionVariables = VariableProvider.GetVariablesFor(semanticVersion, AssemblyVersioningScheme.MajorMinorPatch, VersioningMode.ContinuousDelivery, "ci", false);
        var assemblyInfoText = assemblyInfoBuilder.GetAssemblyInfoText(versionVariables, "Fake");
        Approvals.Verify(assemblyInfoText);

        var compilation = CSharpCompilation.Create("Fake.dll")
            .WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
            .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
            .AddSyntaxTrees(CSharpSyntaxTree.ParseText(assemblyInfoText));

        using (var stream = new MemoryStream())
        {
            var emitResult = compilation.Emit(stream);

            Assert.IsTrue(emitResult.Success, string.Join(Environment.NewLine, emitResult.Diagnostics.Select(x => x.Descriptor)));

            stream.Seek(0, SeekOrigin.Begin);
            var assembly = Assembly.Load(stream.ToArray());
            VerifyGitVersionInformationAttribute(assembly, versionVariables);
        }
    }

    /// <summary>
    /// Save the current <see cref="SessionState"/>.  Any <see cref="Frame"/> instances
    /// registered with <see cref="RegisterFrame"/> will also preserve their current
    /// navigation stack, which in turn gives their active <see cref="Page"/> an opportunity
    /// to save its state.
    /// </summary>
    /// <returns>An asynchronous task that reflects when session state has been saved.</returns>
    public static async Task SaveAsync()
    {
        try
        {
            // Save the navigation state for all registered frames
            foreach (var weakFrameReference in _registeredFrames)
            {
                Frame frame;
                if (weakFrameReference.TryGetTarget(out frame))
                {
                    SaveFrameNavigationState(frame);
                }
            }

            // Serialize the session state synchronously to avoid asynchronous access to shared
            // state
            MemoryStream sessionData = new MemoryStream();
            DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, object>), _knownTypes);
            serializer.WriteObject(sessionData, _sessionState);
        
            // Get an output stream for the SessionState file and write the state asynchronously
            StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(sessionStateFilename, CreationCollisionOption.ReplaceExisting);
            using (Stream fileStream = await file.OpenStreamForWriteAsync())
            {
                sessionData.Seek(0, SeekOrigin.Begin);
                await sessionData.CopyToAsync(fileStream);
            }
        }
        catch (Exception e)
        {
            throw new SuspensionManagerException(e);
        }
    }