Comparteix a través de

File.Open Método

  • Referencia

Definición

Espacio de nombres:
System.IO
Ensamblados:
mscorlib.dll, System.IO.FileSystem.dll
Ensamblado:
System.IO.FileSystem.dll
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Abre un FileStream en la ruta de acceso especificada.

Sobrecargas

Open(String, FileMode, FileAccess, FileShare)

Abre un FileStream en la ruta de acceso especificada con el modo especificado, con acceso de lectura, escritura o ambos, y la opción de uso compartido especificada.
Open(String, FileMode)

Abre un elemento FileStream en la ruta de acceso especificada con acceso de lectura y escritura y sin posibilidad de compartir.
Open(String, FileStreamOptions)

Inicializa una nueva instancia de la FileStream clase con la ruta de acceso especificada, el modo de creación, el permiso de lectura y escritura y uso compartido, el acceso a otros FileStreams puede tener en el mismo archivo, el tamaño del búfer, las opciones de archivo adicionales y el tamaño de asignación.
Open(String, FileMode, FileAccess)

Abre un elemento FileStream en la ruta de acceso especificada, con el modo y acceso especificados y sin posibilidad de compartir.

Open(String, FileMode, FileAccess, FileShare)

Source:
File.cs
Source:
File.cs
Source:
File.cs

Abre un FileStream en la ruta de acceso especificada con el modo especificado, con acceso de lectura, escritura o ambos, y la opción de uso compartido especificada.

public:
 static System::IO::FileStream ^ Open(System::String ^ path, System::IO::FileMode mode, System::IO::FileAccess access, System::IO::FileShare share);
public static System.IO.FileStream Open (string path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share);
static member Open : string * System.IO.FileMode * System.IO.FileAccess * System.IO.FileShare -> System.IO.FileStream
Public Shared Function Open (path As String, mode As FileMode, access As FileAccess, share As FileShare) As FileStream

Parámetros

path
String

Archivo que se va a abrir.

mode
FileMode

Valor FileMode que especifica si se crea un archivo si no existe uno y determina si el contenido de los archivos existentes se conserva o se sobrescribe.

access
FileAccess

Valor FileAccess que especifica las operaciones que se pueden realizar en el archivo.

share
FileShare

Valor FileShare que especifica el tipo de acceso que otros subprocesos tienen en este archivo.

Devoluciones

FileStream

FileStream en la ruta de acceso especificada con el modo especificado, con acceso de lectura, escritura o ambos, y la opción de uso compartido especificada.

Excepciones

ArgumentException

Versiones de .NET Framework y .NET Core anteriores a 2.1: path es una cadena de longitud cero, solo contiene espacios en blanco o contiene uno o varios caracteres no válidos. Puede consultar los caracteres no válidos con el método GetInvalidPathChars().

O bien

access especificó Read y mode especificó Create, CreateNew, Truncate o Append.

ArgumentNullException

path es null.

PathTooLongException

La ruta de acceso especificada, el nombre de archivo o ambos superan la longitud máxima definida por el sistema.

DirectoryNotFoundException

La ruta de acceso especificada no es válida (por ejemplo, está en una unidad no asignada).

IOException

Se produjo un error de E/S al abrir el archivo.

UnauthorizedAccessException

path especificó un archivo que es de solo lectura y access no es Read.

o bien

path especificó un directorio.

o bien

El llamador no dispone del permiso requerido.

o bien

mode es Create y el archivo especificado es un archivo oculto.

ArgumentOutOfRangeException

mode, access o share especificó un valor no válido.

FileNotFoundException

No se encontró el archivo especificado en path.

NotSupportedException

path está en un formato no válido.

Ejemplos

En el ejemplo siguiente se abre un archivo con acceso de solo lectura y con el uso compartido de archivos no permitido.

using namespace System;
using namespace System::IO;
using namespace System::Text;

int main()
{
   String^ path = "c:\\temp\\MyTest.txt";
   
   // Create the file if it does not exist.
   if (  !File::Exists( path ) )
   {
      // Create the file.
      FileStream^ fs = File::Create( path );
      try
      {
         array<Byte>^info = (gcnew UTF8Encoding( true ))->GetBytes( "This is some text in the file." );
         
         // Add some information to the file.
         fs->Write( info, 0, info->Length );
      }
      finally
      {
         if ( fs )
                  delete (IDisposable^)fs;
      }
   }
   
   // Open the stream and read it back.
   FileStream^ fs = File::Open( path, FileMode::Open, FileAccess::Read, FileShare::None );
   try
   {
      array<Byte>^b = gcnew array<Byte>(1024);
      UTF8Encoding^ temp = gcnew UTF8Encoding( true );
      while ( fs->Read( b, 0, b->Length ) > 0 )
      {
         Console::WriteLine( temp->GetString( b ) );
      }
      try
      {
         // Try to get another handle to the same file.
         FileStream^ fs2 = File::Open( path, FileMode::Open );
         try
         {
            // Do some task here.
         }
         finally
         {
            if ( fs2 )
                        delete (IDisposable^)fs2;
         }
      }
      catch ( Exception^ e ) 
      {
         Console::Write( "Opening the file twice is disallowed." );
         Console::WriteLine( ", as expected: {0}", e );
      }
   }
   finally
   {
      if ( fs )
            delete (IDisposable^)fs;
   }
}

using System;
using System.IO;
using System.Text;

class Test
{
    public static void Main()
    {
        string path = @"c:\temp\MyTest.txt";

        // Create the file if it does not exist.
        if (!File.Exists(path))
        {
            // Create the file.
            using (FileStream fs = File.Create(path))
            {
                Byte[] info = new UTF8Encoding(true).GetBytes("This is some text in the file.");

                // Add some information to the file.
                fs.Write(info, 0, info.Length);
            }
        }

        // Open the stream and read it back.
        using (FileStream fs = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.None))
        {
            byte[] b = new byte[1024];
            UTF8Encoding temp = new UTF8Encoding(true);

            while (fs.Read(b,0,b.Length) > 0)
            {
                Console.WriteLine(temp.GetString(b));
            }

            try
            {
                // Try to get another handle to the same file.
                using (FileStream fs2 = File.Open(path, FileMode.Open))
                {
                    // Do some task here.
                }
            }
            catch (Exception e)
            {
                Console.Write("Opening the file twice is disallowed.");
                Console.WriteLine(", as expected: {0}", e.ToString());
            }
        }
    }
}

open System.IO
open System.Text

let path = @"c:\temp\MyTest.txt"

// Create the file if it does not exist.
if File.Exists path |> not then
    // Create the file.
    use fs = File.Create path

    let info =
        UTF8Encoding(true)
            .GetBytes "This is some text in the file."

    // Add some information to the file.
    fs.Write(info, 0, info.Length)

// Open the stream and read it back.
do
    use fs =
        File.Open(path, FileMode.Open, FileAccess.Read, FileShare.None)

    let b = Array.zeroCreate 1024
    let temp = UTF8Encoding true

    while fs.Read(b, 0, b.Length) > 0 do
        printfn $"{temp.GetString b}"

    try
        // Try to get another handle to the same file.
        use fs2 = File.Open(path, FileMode.Open)
        // Do some task here.
        ()
    with
    | e -> printf "Opening the file twice is disallowed, as expected: {e}"

Imports System.IO
Imports System.Text

Public Class Test
  Public Shared Sub Main()
    Dim path As String = "c:\temp\MyTest.txt"

    ' Create the file if it does not exist. 
    If Not File.Exists(path) Then
      ' Create the file.
      Using fs As FileStream = File.Create(path)
        Dim info As Byte() = New UTF8Encoding(True).GetBytes("This is some text in the file.")

        ' Add some information to the file.
        fs.Write(info, 0, info.Length)
      End Using
    End If

    ' Open the stream and read it back.
    Using fs As FileStream = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.None)
      Dim b(1023) As Byte
      Dim temp As UTF8Encoding = New UTF8Encoding(True)

      Do While fs.Read(b, 0, b.Length) > 0
        Console.WriteLine(temp.GetString(b))
      Loop

      Try
        ' Try to get another handle to the same file. 
        Using fs2 As FileStream = File.Open(path, FileMode.Open)
          ' Do some task here.
        End Using
      Catch e As Exception
        Console.Write("Opening the file twice is disallowed.")
        Console.WriteLine(", as expected: {0}", e.ToString())
      End Try

    End Using

  End Sub
End Class

Comentarios

El path parámetro puede especificar información de ruta de acceso relativa o absoluta. La información de ruta de acceso relativa se interpreta como relativa al directorio de trabajo actual. Para obtener el directorio de trabajo actual, consulte GetCurrentDirectory.

Para obtener una lista de tareas de E/S comunes, consulte Tareas de E/S comunes.

Consulte también

Se aplica a

Open(String, FileMode)

Source:
File.cs
Source:
File.cs
Source:
File.cs

Abre un elemento FileStream en la ruta de acceso especificada con acceso de lectura y escritura y sin posibilidad de compartir.

public:
 static System::IO::FileStream ^ Open(System::String ^ path, System::IO::FileMode mode);
public static System.IO.FileStream Open (string path, System.IO.FileMode mode);
static member Open : string * System.IO.FileMode -> System.IO.FileStream
Public Shared Function Open (path As String, mode As FileMode) As FileStream

Parámetros

path
String

Archivo que se va a abrir.

mode
FileMode

Valor FileMode que especifica si se crea un archivo si no existe uno y determina si el contenido de los archivos existentes se conserva o se sobrescribe.

Devoluciones

FileStream

FileStream abierto en el modo y ruta de acceso especificados, con acceso de lectura y escritura y de uso no compartido.

Excepciones

ArgumentException

Versiones de .NET Framework y .NET Core anteriores a 2.1: path es una cadena de longitud cero, solo contiene espacios en blanco o contiene uno o varios caracteres no válidos. Puede consultar los caracteres no válidos con el método GetInvalidPathChars().

ArgumentNullException

path es null.

PathTooLongException

La ruta de acceso especificada, el nombre de archivo o ambos superan la longitud máxima definida por el sistema.

DirectoryNotFoundException

La ruta de acceso especificada no es válida (por ejemplo, está en una unidad no asignada).

IOException

Se produjo un error de E/S al abrir el archivo.

UnauthorizedAccessException

path especificó un archivo que es de solo lectura.

o bien

Esta operación no es compatible con la plataforma actual.

o bien

path especificó un directorio.

o bien

El llamador no dispone del permiso requerido.

o bien

mode es Create y el archivo especificado es un archivo oculto.

ArgumentOutOfRangeException

mode especifica un valor no válido.

FileNotFoundException

No se encontró el archivo especificado en path.

NotSupportedException

path está en un formato no válido.

Ejemplos

En el ejemplo de código siguiente se crea un archivo temporal y se escribe texto en él. A continuación, se abre el archivo con T:System.IO.FileMode.Open; es decir, si el archivo aún no existía, no se crearía.

using namespace System;
using namespace System::IO;
using namespace System::Text;

int main()
{
   // Create a temporary file, and put some data into it.
   String^ path = Path::GetTempFileName();
   FileStream^ fs = File::Open( path, FileMode::Open, FileAccess::Write, FileShare::None );
   try
   {
      array<Byte>^info = (gcnew UTF8Encoding( true ))->GetBytes( "This is some text in the file." );
      
      // Add some information to the file.
      fs->Write( info, 0, info->Length );
   }
   finally
   {
      if ( fs )
            delete (IDisposable^)fs;
   }

   // Open the stream and read it back.
   fs = File::Open( path, FileMode::Open );
   try
   {
      array<Byte>^b = gcnew array<Byte>(1024);
      UTF8Encoding^ temp = gcnew UTF8Encoding( true );
      while ( fs->Read( b, 0, b->Length ) > 0 )
      {
         Console::WriteLine( temp->GetString( b ) );
      }
   }
   finally
   {
      if ( fs )
            delete (IDisposable^)fs;
   }
}

using System;
using System.IO;
using System.Text;

class Test
{
    public static void Main()
    {
        // Create a temporary file, and put some data into it.
        string path = Path.GetTempFileName();
        using (FileStream fs = File.Open(path, FileMode.Open, FileAccess.Write, FileShare.None))
        {
            Byte[] info = new UTF8Encoding(true).GetBytes("This is some text in the file.");
            // Add some information to the file.
            fs.Write(info, 0, info.Length);
        }

        // Open the stream and read it back.
        using (FileStream fs = File.Open(path, FileMode.Open))
        {
            byte[] b = new byte[1024];
            UTF8Encoding temp = new UTF8Encoding(true);

            while (fs.Read(b,0,b.Length) > 0)
            {
                Console.WriteLine(temp.GetString(b));
            }
        }
    }
}

open System.IO
open System.Text

// Create a temporary file, and put some data into it.
let path = Path.GetTempFileName()

do
    use fs =
        File.Open(path, FileMode.Open, FileAccess.Write, FileShare.None)

    let info =
        UTF8Encoding(true)
            .GetBytes "This is some text in the file."
    // Add some information to the file.
    fs.Write(info, 0, info.Length)

// Open the stream and read it back.
do
    use fs = File.Open(path, FileMode.Open)
    let b = Array.zeroCreate 1024
    let temp = UTF8Encoding true

    while fs.Read(b, 0, b.Length) > 0 do
        printfn $"{temp.GetString b}"

Imports System.IO
Imports System.Text

Public Class Test
  Public Shared Sub Main()
  
    ' Create a temporary file, and put some data into it. 
    Dim path1 As String = Path.GetTempFileName()
    Using fs As FileStream = File.Open(path1, FileMode.Open, FileAccess.Write, FileShare.None)
      Dim info As Byte() = New UTF8Encoding(True).GetBytes("This is some text in the file.")
      ' Add some information to the file.
      fs.Write(info, 0, info.Length)
    End Using

    ' Open the stream and read it back. 
    Using fs As FileStream = File.Open(path1, FileMode.Open)
      Dim b(1023) As Byte
      Dim temp As UTF8Encoding = New UTF8Encoding(True)
      Do While fs.Read(b, 0, b.Length) > 0
        Console.WriteLine(temp.GetString(b))
      Loop
    End Using

  End Sub
End Class

Comentarios

El path parámetro puede especificar información de ruta de acceso relativa o absoluta. La información de ruta de acceso relativa se interpreta como relativa al directorio de trabajo actual. Para obtener el directorio de trabajo actual, consulte GetCurrentDirectory.

Para obtener una lista de tareas de E/S comunes, consulte Tareas de E/S comunes.

Consulte también

Se aplica a

Open(String, FileStreamOptions)

Source:
File.cs
Source:
File.cs
Source:
File.cs

Inicializa una nueva instancia de la FileStream clase con la ruta de acceso especificada, el modo de creación, el permiso de lectura y escritura y uso compartido, el acceso a otros FileStreams puede tener en el mismo archivo, el tamaño del búfer, las opciones de archivo adicionales y el tamaño de asignación.

public:
 static System::IO::FileStream ^ Open(System::String ^ path, System::IO::FileStreamOptions ^ options);
public static System.IO.FileStream Open (string path, System.IO.FileStreamOptions options);
static member Open : string * System.IO.FileStreamOptions -> System.IO.FileStream
Public Shared Function Open (path As String, options As FileStreamOptions) As FileStream

Parámetros

path
String

Ruta de acceso del archivo que se va a abrir.

options
FileStreamOptions

Objeto que describe parámetros opcionales FileStream que se van a usar.

Devoluciones

FileStream

Instancia FileStream de que encapsula el archivo abierto.

Comentarios

FileStream(String, FileStreamOptions) para obtener información sobre las excepciones.

Se aplica a

Open(String, FileMode, FileAccess)

Source:
File.cs
Source:
File.cs
Source:
File.cs

Abre un elemento FileStream en la ruta de acceso especificada, con el modo y acceso especificados y sin posibilidad de compartir.

public:
 static System::IO::FileStream ^ Open(System::String ^ path, System::IO::FileMode mode, System::IO::FileAccess access);
public static System.IO.FileStream Open (string path, System.IO.FileMode mode, System.IO.FileAccess access);
static member Open : string * System.IO.FileMode * System.IO.FileAccess -> System.IO.FileStream
Public Shared Function Open (path As String, mode As FileMode, access As FileAccess) As FileStream

Parámetros

path
String

Archivo que se va a abrir.

mode
FileMode

Valor FileMode que especifica si se crea un archivo si no existe uno y determina si el contenido de los archivos existentes se conserva o se sobrescribe.

access
FileAccess

Valor FileAccess que especifica las operaciones que se pueden realizar en el archivo.

Devoluciones

FileStream

FileStream de uso no compartido que proporciona acceso al archivo especificado, con el modo y el acceso especificados.

Excepciones

ArgumentException

Versiones de .NET Framework y .NET Core anteriores a 2.1: path es una cadena de longitud cero, solo contiene espacios en blanco o contiene uno o varios caracteres no válidos. Puede consultar los caracteres no válidos con el método GetInvalidPathChars().

O bien

access especificó Read y mode especificó Create, CreateNew, Truncate o Append.

ArgumentNullException

path es null.

PathTooLongException

La ruta de acceso especificada, el nombre de archivo o ambos superan la longitud máxima definida por el sistema.

DirectoryNotFoundException

La ruta de acceso especificada no es válida (por ejemplo, está en una unidad no asignada).

IOException

Se produjo un error de E/S al abrir el archivo.

UnauthorizedAccessException

path especificó un archivo que es de solo lectura y access no es Read.

o bien

path especificó un directorio.

o bien

El llamador no dispone del permiso requerido.

o bien

mode es Create y el archivo especificado es un archivo oculto.

ArgumentOutOfRangeException

mode o access especificó un valor no válido.

FileNotFoundException

No se encontró el archivo especificado en path.

NotSupportedException

path está en un formato no válido.

Ejemplos

En el ejemplo siguiente se abre un archivo con acceso de solo lectura.


using namespace System;
using namespace System::IO;
using namespace System::Text;

int main()
{
    // This sample assumes that you have a folder named "c:\temp" on your computer.
    String^ filePath = "c:\\temp\\MyTest.txt";
    // Delete the file if it exists.
    if (File::Exists( filePath ))
    {
        File::Delete( filePath );
    }
    // Create the file.
    FileStream^ fs = File::Create( filePath );
    try
    {
        array<Byte>^ info = ( gcnew UTF8Encoding( true ))->GetBytes( "This is some text in the file." );
        
        // Add some information to the file.
        fs->Write( info, 0, info->Length );
    }
    finally
    {
        if ( fs )
            delete (IDisposable^)fs;
    }

    // Open the stream and read it back.
    fs = File::Open( filePath, FileMode::Open, FileAccess::Read );
    try
    {
        array<Byte>^ b = gcnew array<Byte>(1024);
        UTF8Encoding^ temp = gcnew UTF8Encoding( true );
        while ( fs->Read( b, 0, b->Length ) > 0 )
        {
            Console::WriteLine( temp->GetString( b ) );
        }
        try
        {
            // Try to write to the file.
            fs->Write( b, 0, b->Length );
        }
        catch ( Exception^ e ) 
        {
            Console::WriteLine( "Writing was disallowed, as expected: {0}", e->ToString() );
        }
    }
    finally
    {
        if ( fs )
            delete (IDisposable^)fs;
    }
}

using System;
using System.IO;
using System.Text;

class Test
{
    public static void Main()
    {
        // This sample assumes that you have a folder named "c:\temp" on your computer.
        string filePath = @"c:\temp\MyTest.txt";

        // Delete the file if it exists.
        if (File.Exists(filePath))
        {
            File.Delete(filePath);
        }

        // Create the file.
        using (FileStream fs = File.Create(filePath))
        {
            Byte[] info = new UTF8Encoding(true).GetBytes("This is some text in the file.");
            // Add some information to the file.
            fs.Write(info, 0, info.Length);
        }

        // Open the stream and read it back.
        using (FileStream fs = File.Open(filePath, FileMode.Open, FileAccess.Read))
        {
            byte[] b = new byte[1024];
            UTF8Encoding temp = new UTF8Encoding(true);

            while (fs.Read(b,0,b.Length) > 0)
            {
                Console.WriteLine(temp.GetString(b));
            }

            try
            {
                // Try to write to the file.
                fs.Write(b,0,b.Length);
            }
            catch (Exception e)
            {
                Console.WriteLine("Writing was disallowed, as expected: {0}", e.ToString());
            }
        }
    }
}

open System.IO
open System.Text

// This sample assumes that you have a folder named "c:\temp" on your computer.
let filePath = @"c:\temp\MyTest.txt"

// Delete the file if it exists.
if File.Exists filePath then
    File.Delete filePath

// Create the file.
do
    use fs = File.Create filePath

    let info =
        UTF8Encoding(true)
            .GetBytes "This is some text in the file."
    // Add some information to the file.
    fs.Write(info, 0, info.Length)

// Open the stream and read it back.
do
    use fs =
        File.Open(filePath, FileMode.Open, FileAccess.Read)

    let b = Array.zeroCreate 1024
    let temp = UTF8Encoding true

    while fs.Read(b, 0, b.Length) > 0 do
        printfn $"{temp.GetString b}"

    try
        // Try to write to the file.
        fs.Write(b, 0, b.Length)
    with
    | e -> printfn $"Writing was disallowed, as expected: {e}"

Imports System.IO
Imports System.Text

Public Class Test
  Public Shared Sub Main()
    ' This sample assumes that you have a folder named "c:\temp" on your computer. 
    Dim filePath As String = "c:\temp\MyTest.txt"

    ' Delete the file if it exists. 
    If File.Exists(filePath) Then
      File.Delete(filePath)
    End If

    ' Create the file.
    Using fs As FileStream = File.Create(filePath)
      Dim info As Byte() = New UTF8Encoding(True).GetBytes("This is some text in the file.")

      ' Add some information to the file.
      fs.Write(info, 0, info.Length)
    End Using

    ' Open the stream and read it back.
    Using fs As FileStream = File.Open(filePath, FileMode.Open, FileAccess.Read)
      Dim b(1023) As Byte
      Dim temp As UTF8Encoding = New UTF8Encoding(True)

      ' Display the information on the console. 
      Do While fs.Read(b, 0, b.Length) > 0
        Console.WriteLine(temp.GetString(b))
      Loop

      Try
        ' Try to write to the file
        fs.Write(b, 0, b.Length)
      Catch e As Exception
        Console.WriteLine("Writing was disallowed, as expected: " & e.ToString())
      End Try

    End Using

  End Sub
End Class

Comentarios

El path parámetro puede especificar información de ruta de acceso relativa o absoluta. La información de ruta de acceso relativa se interpreta como relativa al directorio de trabajo actual. Para obtener el directorio de trabajo actual, consulte GetCurrentDirectory.

Consulte también

Se aplica a