Redigeeri

Jagamisviis:


File.Open Method

Definition

Opens a FileStream on the specified path.

Overloads

Open(String, FileMode, FileAccess, FileShare)

Opens a FileStream on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option.

Open(String, FileMode)

Opens a FileStream on the specified path with read/write access with no sharing.

Open(String, FileStreamOptions)

Initializes a new instance of the FileStream class with the specified path, creation mode, read/write and sharing permission, the access other FileStreams can have to the same file, the buffer size, additional file options and the allocation size.

Open(String, FileMode, FileAccess)

Opens a FileStream on the specified path, with the specified mode and access with no sharing.

Open(String, FileMode, FileAccess, FileShare)

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

Opens a FileStream on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option.

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

Parameters

path
String

The file to open.

mode
FileMode

A FileMode value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten.

access
FileAccess

A FileAccess value that specifies the operations that can be performed on the file.

share
FileShare

A FileShare value specifying the type of access other threads have to the file.

Returns

A FileStream on the specified path, having the specified mode with read, write, or read/write access and the specified sharing option.

Exceptions

.NET Framework and .NET Core versions older than 2.1: path is a zero-length string, contains only white space, or contains one or more invalid characters. You can query for invalid characters by using the GetInvalidPathChars() method.

-or-

access specified Read and mode specified Create, CreateNew, Truncate, or Append.

path is null.

The specified path, file name, or both exceed the system-defined maximum length.

The specified path is invalid, (for example, it is on an unmapped drive).

An I/O error occurred while opening the file.

path specified a file that is read-only and access is not Read.

-or-

path specified a directory.

-or-

The caller does not have the required permission.

-or-

mode is Create and the specified file is a hidden file.

mode, access, or share specified an invalid value.

The file specified in path was not found.

path is in an invalid format.

Examples

The following example opens a file with read-only access and with file sharing disallowed.

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

Remarks

The path parameter is permitted to specify relative or absolute path information. Relative path information is interpreted as relative to the current working directory. To obtain the current working directory, see GetCurrentDirectory.

For a list of common I/O tasks, see Common I/O Tasks.

See also

Applies to

Open(String, FileMode)

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

Opens a FileStream on the specified path with read/write access with no sharing.

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

Parameters

path
String

The file to open.

mode
FileMode

A FileMode value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten.

Returns

A FileStream opened in the specified mode and path, with read/write access and not shared.

Exceptions

.NET Framework and .NET Core versions older than 2.1: path is a zero-length string, contains only white space, or contains one or more invalid characters. You can query for invalid characters by using the GetInvalidPathChars() method.

path is null.

The specified path, file name, or both exceed the system-defined maximum length.

The specified path is invalid, (for example, it is on an unmapped drive).

An I/O error occurred while opening the file.

path specified a file that is read-only.

-or-

This operation is not supported on the current platform.

-or-

path specified a directory.

-or-

The caller does not have the required permission.

-or-

mode is Create and the specified file is a hidden file.

mode specified an invalid value.

The file specified in path was not found.

path is in an invalid format.

Examples

The following code example creates a temporary file and writes some text to it. The example then opens the file, using T:System.IO.FileMode.Open; that is, if the file did not already exist, it would not be created.

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

Remarks

The path parameter is permitted to specify relative or absolute path information. Relative path information is interpreted as relative to the current working directory. To obtain the current working directory, see GetCurrentDirectory.

For a list of common I/O tasks, see Common I/O Tasks.

See also

Applies to

Open(String, FileStreamOptions)

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

Initializes a new instance of the FileStream class with the specified path, creation mode, read/write and sharing permission, the access other FileStreams can have to the same file, the buffer size, additional file options and the allocation size.

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

Parameters

path
String

The path of the file to open.

options
FileStreamOptions

An object that describes optional FileStream parameters to use.

Returns

A FileStream instance that wraps the opened file.

Remarks

FileStream(String, FileStreamOptions) for information about exceptions.

Applies to

Open(String, FileMode, FileAccess)

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

Opens a FileStream on the specified path, with the specified mode and access with no sharing.

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

Parameters

path
String

The file to open.

mode
FileMode

A FileMode value that specifies whether a file is created if one does not exist, and determines whether the contents of existing files are retained or overwritten.

access
FileAccess

A FileAccess value that specifies the operations that can be performed on the file.

Returns

An unshared FileStream that provides access to the specified file, with the specified mode and access.

Exceptions

.NET Framework and .NET Core versions older than 2.1: path is a zero-length string, contains only white space, or contains one or more invalid characters. You can query for invalid characters by using the GetInvalidPathChars() method.

-or-

access specified Read and mode specified Create, CreateNew, Truncate, or Append.

path is null.

The specified path, file name, or both exceed the system-defined maximum length.

The specified path is invalid, (for example, it is on an unmapped drive).

An I/O error occurred while opening the file.

path specified a file that is read-only and access is not Read.

-or-

path specified a directory.

-or-

The caller does not have the required permission.

-or-

mode is Create and the specified file is a hidden file.

mode or access specified an invalid value.

The file specified in path was not found.

path is in an invalid format.

Examples

The following example opens a file with read-only access.


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

Remarks

The path parameter is permitted to specify relative or absolute path information. Relative path information is interpreted as relative to the current working directory. To obtain the current working directory, see GetCurrentDirectory.

See also

Applies to