FileStream.Seek(Int64, SeekOrigin) FileStream.Seek(Int64, SeekOrigin) FileStream.Seek(Int64, SeekOrigin) FileStream.Seek(Int64, SeekOrigin) Method

Definición

Establece la posición actual de esta secuencia actual en el valor dado.Sets the current position of this stream to the given value.

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 Int64 Int64 Int64

El punto relativo a origin desde el que comienza la operación Seek.The point relative to origin from which to begin seeking.

origin
SeekOrigin SeekOrigin SeekOrigin SeekOrigin

Especifica el comienzo, el final o la posición actual como un punto de referencia para offset, mediante el uso de un valor de tipo SeekOrigin.Specifies the beginning, the end, or the current position as a reference point for offset, using a value of type SeekOrigin.

Devoluciones

Nueva posición en la secuencia.The new position in the stream.

Excepciones

Error de E/S.An I/O error occurred.

La secuencia no admite búsquedas, por ejemplo, si el FileStream se construye a partir de una canalización o una consola de salida.The stream does not support seeking, such as if the FileStream is constructed from a pipe or console output.

La búsqueda se intenta antes del comienzo de la secuencia.Seeking is attempted before the beginning of the stream.

Se efectuó una llamada a los métodos después de cerrar la secuencia.Methods were called after the stream was closed.

Ejemplos

En el ejemplo siguiente se muestra cómo escribir datos en un archivo, byte por byte y, a continuación, comprobar que los datos se escribieron correctamente.The following example shows how to write data to a file, byte by byte, and then verify that the data was written correctly.

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);
        }
    }
}
Imports Microsoft.VisualBasic
Imports System
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

En el ejemplo siguiente se lee texto en dirección inversa, desde el final del archivo hasta el principio del archivo, utilizando los distintos SeekOrigin valores con el Seek método.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(Convert.ToChar(fs.ReadByte()));
            }
            Console.WriteLine();

            fs.Seek(20, SeekOrigin.Begin);

            while ((nextByte = fs.ReadByte()) > 0)
            {
                Console.Write(Convert.ToChar(nextByte));
            }
            Console.WriteLine();
        }
    }
}
// This code example displays the following output:
//
// zyxwvutsrqponmlkjihgfedcba
// uvwxyz
Imports System
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

Comentarios

Este método invalida Stream.Seek.This method overrides Stream.Seek.

Nota

Utilice la FileStream.CanSeek propiedad para determinar si la instancia actual admite búsquedas.Use the FileStream.CanSeek property to determine whether the current instance supports seeking. Para obtener información adicional, vea Stream.CanSeek.For additional information, see Stream.CanSeek.

Puede buscar en cualquier ubicación más allá de la longitud de la secuencia.You can seek to any location beyond the length of the stream. Cuando busca más allá de la longitud del archivo, el tamaño del archivo aumenta.When you seek beyond the length of the file, the file size grows. En Windows NT y versiones posteriores, los datos agregados al final del archivo se establecen en cero.In Windows NT and later versions, data added to the end of the file is set to zero. En Windows 98 o versiones anteriores, los datos agregados al final del archivo no se establecen en cero, lo que significa que los datos eliminados anteriormente son visibles para la secuencia.In Windows 98 or earlier versions, data added to the end of the file is not set to zero, which means that previously deleted data is visible to the stream.

Para obtener una lista de operaciones comunes de archivos y directorios, vea tareas de e/s comunes.For a list of common file and directory operations, see Common I/O Tasks.

Se aplica a

Consulte también: