FileStream.Seek(Int64, SeekOrigin) Método

Definição

Namespace:

System.IO

Assembly:

System.Runtime.dll

Origem:

FileStream.cs

Define a posição atual do fluxo para o valor especificado.

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

Parâmetros

offset

Int64

O ponto relativo a origin do qual começar a busca.

origin

SeekOrigin

Especifica a posição inicial, final ou atual como um ponto de referência para offset usando um valor do tipo SeekOrigin.

Retornos

Int64

A nova posição no fluxo.

Exceções

IOException

Ocorreu um erro de E/S.

NotSupportedException

O fluxo não dá suporte a busca, como se o FileStream fosse construído por meio de uma saída do console ou pipe.

ArgumentException

A busca é tentada antes do início do fluxo.

ObjectDisposedException

Foram chamados métodos depois que o fluxo foi fechado.

Exemplos

O exemplo a seguir mostra como gravar dados em um arquivo, byte por byte e verificar se os dados foram gravados corretamente.

using namespace System;
using namespace System::IO;
int main()
{
   String^ fileName =  "Test@##@.dat";
   
   // Create random data to write to the file.
   array<Byte>^dataArray = gcnew array<Byte>(100000);
   (gcnew Random)->NextBytes( dataArray );
   FileStream^ fileStream = gcnew FileStream( fileName,FileMode::Create );
   try
   {
      
      // 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  -1;
         }

      }
      Console::WriteLine( "The data was written to {0} "
      "and verified.", fileStream->Name );
   }
   finally
   {
      fileStream->Close();
   }

}

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

O exemplo a seguir lê o texto na direção inversa, do final do arquivo até o início do arquivo, usando os vários SeekOrigin valores com o Seek método .

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

Comentários

Este método substitui Stream.Seek.

Observação

Use a FileStream.CanSeek propriedade para determinar se a instância atual dá suporte à busca. Para obter mais informações, consulte: Stream.CanSeek.

Você pode procurar qualquer local além do comprimento do fluxo. Quando você busca além do comprimento do arquivo, o tamanho do arquivo aumenta. Os dados adicionados ao final do arquivo são definidos como zero.

Para obter uma lista de operações comuns de arquivo e diretório, consulte Tarefas comuns de E/S.

Confira também

• E/S de arquivo e de fluxo
• Como ler texto de um arquivo
• Como gravar texto em um arquivo