FileStream.Seek(Int64, SeekOrigin) Method

public:
 override long Seek(long offset, System::IO::SeekOrigin origin);

public override long Seek(long offset, System.IO.SeekOrigin origin);

override this.Seek : int64 * System.IO.SeekOrigin -> int64

Public Overrides Function Seek (offset As Long, origin As SeekOrigin) As Long

Parameters

Returns

The new position in the stream.

Exceptions

Examples

The following example shows how to write data to a file, byte by byte, and then verify that the data was written correctly.

using System;
using System.IO;

class FStream
{
 static void Main()
 {
 const string fileName = "Test#@@#.dat";

 // Create random data to write to the file.
 byte[] dataArray = new byte[100000];
 new Random().NextBytes(dataArray);

 using(FileStream
 fileStream = new FileStream(fileName, FileMode.Create))
 {
 // Write the data to the file, byte by byte.
 for(int i = 0; i < dataArray.Length; i++)
 {
 fileStream.WriteByte(dataArray[i]);
 }

 // Set the stream position to the beginning of the file.
 fileStream.Seek(0, SeekOrigin.Begin);

 // Read and verify the data.
 for(int i = 0; i < fileStream.Length; i++)
 {
 if(dataArray[i] != fileStream.ReadByte())
 {
 Console.WriteLine("Error writing data.");
 return;
 }
 }
 Console.WriteLine("The data was written to {0} " +
 "and verified.", fileStream.Name);
 }
 }
}

open System
open System.IO


let fileName = "Test#@@#.dat"

// Create random data to write to the file.
let dataArray = Array.zeroCreate 100000
Random.Shared.NextBytes dataArray

do
 use fileStream = new FileStream(fileName, FileMode.Create)
 // Write the data to the file, byte by byte.
 for i = 0 to dataArray.Length - 1 do
 fileStream.WriteByte dataArray[i]

 // Set the stream position to the beginning of the file.
 fileStream.Seek(0, SeekOrigin.Begin) |> ignore

 // Read and verify the data.
 for i in 0L .. fileStream.Length - 1L do
 if dataArray[int i] <> (fileStream.ReadByte() |> byte) then
 printfn "Error writing data."
 exit 1

 printfn $"The data was written to {fileStream.Name} and verified."

Imports System.IO
Imports System.Text

Class FStream

 Shared Sub Main()

 Const fileName As String = "Test#@@#.dat"

 ' Create random data to write to the file.
 Dim dataArray(100000) As Byte
 Dim randomGenerator As New Random()
 randomGenerator.NextBytes(dataArray)

 Dim fileStream As FileStream = _
 new FileStream(fileName, FileMode.Create)
 Try

 ' Write the data to the file, byte by byte.
 For i As Integer = 0 To dataArray.Length - 1
 fileStream.WriteByte(dataArray(i))
 Next i

 ' Set the stream position to the beginning of the stream.
 fileStream.Seek(0, SeekOrigin.Begin)

 ' Read and verify the data.
 For i As Integer = 0 To _
 CType(fileStream.Length, Integer) - 1

 If dataArray(i) <> fileStream.ReadByte() Then
 Console.WriteLine("Error writing data.")
 Return
 End If
 Next i
 Console.WriteLine("The data was written to {0} " & _
 "and verified.", fileStream.Name)
 Finally
 fileStream.Close()
 End Try
 
 End Sub
End Class

The following example reads text in the reverse direction, from the end of file to the beginning of the file, by using the various SeekOrigin values with the Seek method.

using System;
using System.IO;

public class FSSeek
{
 public static void Main()
 {
 long offset;
 int nextByte;

 // alphabet.txt contains "abcdefghijklmnopqrstuvwxyz"
 using (FileStream fs = new FileStream(@"c:\temp\alphabet.txt", FileMode.Open, FileAccess.Read))
 {
 for (offset = 1; offset <= fs.Length; offset++)
 {
 fs.Seek(-offset, SeekOrigin.End);
 Console.Write((char)fs.ReadByte());
 }
 Console.WriteLine();

 fs.Seek(20, SeekOrigin.Begin);

 while ((nextByte = fs.ReadByte()) > 0)
 {
 Console.Write((char)nextByte);
 }
 Console.WriteLine();
 }
 }
}
// This code example displays the following output:
//
// zyxwvutsrqponmlkjihgfedcba
// uvwxyz

open System.IO

// alphabet.txt contains "abcdefghijklmnopqrstuvwxyz"
using (new FileStream(@"c:\temp\alphabet.txt", FileMode.Open, FileAccess.Read)) (fun fs ->
 for offset in 1L .. fs.Length do
 fs.Seek(-offset, SeekOrigin.End) |> ignore
 printf $"{fs.ReadByte() |> char}"

 printfn ""

 fs.Seek(20, SeekOrigin.Begin) |> ignore

 let mutable nextByte = fs.ReadByte()

 while nextByte > 0 do
 printf $"{char nextByte}"
 nextByte <- fs.ReadByte())

// This code example displays the following output:
//
// zyxwvutsrqponmlkjihgfedcba
// uvwxyz

Imports System.IO

Public Class FSSeek
 Public Shared Sub Main()
 Dim offset As Long
 Dim nextByte As Integer

 ' alphabet.txt contains "abcdefghijklmnopqrstuvwxyz"
 Using fs As New FileStream("c:\temp\alphabet.txt", FileMode.Open, FileAccess.Read)

 For offset = 1 To fs.Length
 fs.Seek(-offset, SeekOrigin.End)
 Console.Write(Convert.ToChar(fs.ReadByte()))
 Next offset
 Console.WriteLine()

 fs.Seek(20, SeekOrigin.Begin)

 nextByte = fs.ReadByte()
 While (nextByte > 0)
 Console.Write(Convert.ToChar(nextByte))
 nextByte = fs.ReadByte()
 End While
 Console.WriteLine()

 End Using
 End Sub
End Class

' This code example displays the following output:
'
' zyxwvutsrqponmlkjihgfedcba
' uvwxyz

Remarks

This method overrides Stream.Seek.

You can seek to any location beyond the length of the stream. When you seek beyond the length of the file, the file size grows. Data added to the end of the file is set to zero.

For a list of common file and directory operations, see Common I/O Tasks.

See also

• File and Stream I/O
• How to: Read Text from a File
• How to: Write Text to a File