Constructor taking the name of the file to open and the open mode (with the same semantics as in the C standard library fopen function).

Copying one File object to another results in the two File objects referring to the same underlying file.

The destructor automatically closes the file as soon as no File object refers to it anymore.

Assigns a file to another. The target of the assignment gets detached from whatever file it was attached to, and attaches itself to the new file.

First calls detach (throwing on failure), and then attempts to open file name with mode stdioOpenmode. The mode has the same semantics as in the C standard library fopen function.

Returns true if the file is opened.

Returns true if the file is at end (see feof).

Returns the  name of the last opened file, if any. If a File was created with tmpfile and wrapFile it has no  name.

If the file is not opened, returns false. Otherwise, returns ferror for the file handle.

Detaches from the underlying file. If the sole owner, calls close.

If the file was unopened, succeeds vacuously. Otherwise closes the file (by calling fclose), throwing on error. Even if an exception is thrown, afterwards the File object is empty. This is different from detach in that it always closes the file; consequently, all other File objects referring to the same handle will see a closed file henceforth.

If the file is not opened, succeeds vacuously. Otherwise, returns clearerr for the file handle.

Calls fflush for the file handle.

Calls fread for the file handle. The number of items to read and the size of each item is inferred from the size and type of the input array, respectively.

Calls fwrite for the file handle. The number of items to write and the size of each item is inferred from the size and type of the input array, respectively. An error is thrown if the buffer could not be written in its entirety.

 rawWrite always writes in binary mode on Windows.

Calls fseek for the file handle.

Calls ftell for the managed file handle.

Calls rewind for the file handle.

Calls setvbuf for the file handle.

Calls setvbuf for the file handle.

Writes its arguments in text format to the file.

Writes its arguments in text format to the file, followed by a newline.

Writes its arguments in text format to the file, according to the format in the first argument.

Writes its arguments in text format to the file, according to the format in the first argument, followed by a newline.

Read line from the file handle and return it as a specified type.

This version manages its own read buffer, which means one memory allocation per call. If you are not retaining a reference to the read data, consider the File. readln(buf) version, which may offer better performance as it can reuse its read buffer.

// Reads $(D stdin) and writes it to $(D stdout).

import std.stdio;

void main()
{
    string line;
    while ((line = stdin.readln()) !is null)
        write(line);
}

Read line from the file handle and write it to buf[], including terminating character.

This can be faster than line = File. readln() because you can reuse the buffer for each call. Note that reusing the buffer means that you must copy the previous contents if you wish to retain them.

// Read lines from $(D stdin) into a string

// Ignore lines starting with '#'

// Write the string to $(D stdout)


void main()
{
    string output;
    char[] buf;

    while (stdin.readln(buf))
    {
        if (buf[0] == '#')
            continue;

        output ~= buf;
    }

    write(output);
}

Read data from the file according to the specified format specifier using std.format.formattedRead.

Returns a temporary file by calling tmpfile. Note that the created file has no name .

Unsafe function that wraps an existing FILE*. The resulting File never takes the initiative in closing the file. Note that the created file has no name

Returns the FILE* corresponding to this object.

Returns the file number corresponding to this object.

Returns an input range set up to read from the file handle one line at a time.

The element type for the range will be Char[]. Range primitives may throw StdioException on I/O error.

import std.algorithm, std.stdio, std.string;
// Count words in a file using ranges.

void main()
{
    auto file = File("file.txt"); // Open for reading

    const wordCount = file.byLine()                  // Read lines

                          .map!split                 // Split into words

                          .map!(a => a.length)       // Count words per line

                          .reduce!((a, b) => a + b); // Total word count

    writeln(wordCount);
}

import std.range, std.stdio;
// Read lines using foreach.

void main()
{
    auto file = File("file.txt"); // Open for reading

    auto range = file.byLine();
    // Print first three lines

    foreach (line; range.take(3))
        writeln(line);
    // Print remaining lines beginning with '#'

    foreach (line; range)
    {
        if (!line.empty && line[0] == '#')
            writeln(line);
    }
}

Returns an input range set up to read from the file handle a chunk at a time.

The element type for the range will be ubyte[]. Range primitives may throw StdioException on I/O error.

void main()
{
  foreach (ubyte[] buffer; stdin.byChunk(4096))
  {
    ... use buffer ...
  }
}

import std.algorithm, std.stdio;

void main()
{
    stdin.byChunk(1024).copy(stdout.lockingTextWriter());
}

Returns an output range that locks the file and allows fast writing to it.

See byChunk for an example.

Get the  size of the file, ulong.max if file is not searchable, but still throws if an actual error occurs.

Operating system error code.

Initialize with a message and an error code.

Convenience functions that throw an StdioException.