File.ReadLines Método

public:
 static System::Collections::Generic::IEnumerable<System::String ^> ^ ReadLines(System::String ^ path);

public static System.Collections.Generic.IEnumerable<string> ReadLines(string path);

static member ReadLines : string -> seq<string>

Public Shared Function ReadLines (path As String) As IEnumerable(Of String)

Parâmetros

Devoluções

Todas as linhas do ficheiro, ou as linhas que resultam de uma consulta.

Exceções

Exemplos

O exemplo seguinte lê as linhas de um ficheiro para encontrar linhas que contenham strings especificadas.

foreach (string line in File.ReadLines(@"d:\data\episodes.txt"))
{
    if (line.Contains("episode") & line.Contains("2006"))
    {
        Console.WriteLine(line);
    }
}

for line in File.ReadLines @"d:\data\episodes.txt" do
    if line.Contains "episode" && line.Contains "2006" then
        printfn $"{line}"

For Each line As String In File.ReadLines("d:\data\episodes.txt")
    If line.Contains("episode") And line.Contains("2006") Then
        Console.WriteLine(line)
    End If
Next line

O exemplo seguinte utiliza o método ReadLines numa consulta LINQ que enumera todos os diretórios de ficheiros com extensão .txt, lê cada linha do ficheiro e apresenta a linha se esta contiver a cadeia "Microsoft".

using System;
using System.IO;
using System.Linq;

partial class Example2
{
    static void SearchOptionExample()
    {
        try
        {
            // Set a variable to the My Documents path.
            string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

            var files = from file in Directory.EnumerateFiles(docPath, "*.txt", SearchOption.AllDirectories)
                        from line in File.ReadLines(file)
                        where line.Contains("Microsoft")
                        select new
                        {
                            File = file,
                            Line = line
                        };

            foreach (var f in files)
            {
                Console.WriteLine($"{f.File}\t{f.Line}");
            }

            Console.WriteLine($"{files.Count()} files found.");
        }
        catch (UnauthorizedAccessException uAEx)
        {
            Console.WriteLine(uAEx.Message);
        }
        catch (PathTooLongException pathEx)
        {
            Console.WriteLine(pathEx.Message);
        }
    }
}

open System
open System.IO

try
    // Set a variable to the My Documents path.
    let docPath =
        Environment.GetFolderPath Environment.SpecialFolder.MyDocuments

    let files =
        query {
            for file in Directory.EnumerateFiles(docPath, "*.txt", SearchOption.AllDirectories) do
            for line in File.ReadLines file do
            where (line.Contains "Microsoft")
            select {| File = file; Line = line |}
        }

    for f in files do
        printfn $"{f.File}\t{f.Line}"
    printfn $"{Seq.length files} files found."

with
| :? UnauthorizedAccessException as uAEx -> printfn $"{uAEx.Message}"
| :? PathTooLongException as pathEx -> printfn $"{pathEx.Message}"

Imports System.IO
Imports System.Xml.Linq

Partial Class Example2
    Shared Sub SearchOptionExample()

        Try
            Dim docPath As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)

            Dim files = From chkFile In Directory.EnumerateFiles(docPath, "*.txt", SearchOption.AllDirectories)
                        From line In File.ReadLines(chkFile)
                        Where line.Contains("Microsoft")
                        Select New With {.curFile = chkFile, .curLine = line}

            For Each f In files
                Console.WriteLine($"{f.curFile}\t{f.curLine}")
            Next

            Console.WriteLine($"{files.Count} files found.")
        Catch uAEx As UnauthorizedAccessException
            Console.WriteLine(uAEx.Message)
        Catch pathEx As PathTooLongException
            Console.WriteLine(pathEx.Message)
        End Try

    End Sub
End Class

Observações

Os ReadLines métodos e ReadAllLines diferem da seguinte forma: Quando usa ReadLines, pode começar a enumerar a coleção de cadeias antes de a coleção completa ser devolvida; quando usar ReadAllLines, deve esperar que o array completo de cadeias seja devolvido antes de poder aceder ao array. Portanto, quando trabalha com ficheiros muito grandes, ReadLines pode ser mais eficiente.

Pode usar o ReadLines método para fazer o seguinte:

• Realizar consultas LINQ para Objetos num ficheiro para obter um conjunto filtrado das suas linhas.
• Escreva a coleção devolvida de linhas num ficheiro com o File.WriteAllLines(String, IEnumerable<String>) método, ou anexe-as a um ficheiro existente com o File.AppendAllLines(String, IEnumerable<String>) método.
• Crie uma instância preenchida imediatamente de uma coleção que tome uma IEnumerable<T> coleção de cadeias como seu construtor, como a IList<T> ou um Queue<T>.

Este método usa UTF8 para o valor de codificação.

Uma linha é definida como uma sequência de caracteres seguida por um retorno de carro ('\r'), um retorno de linha ('\n'), ou um retorno de carruagem imediatamente seguido por um retorno de linha, ou como a sequência final de caracteres no ficheiro ou fluxo se terminar sem sequência de nova linha. Se o ficheiro terminar com uma sequência de nova linha, não é devolvida nenhuma linha vazia adicional. Por exemplo, um ficheiro que contém "line1\nline2\n" produz as mesmas duas linhas ("line1" e "line2") que um ficheiro contendo "line1\nline2".

public:
 static System::Collections::Generic::IEnumerable<System::String ^> ^ ReadLines(System::String ^ path, System::Text::Encoding ^ encoding);

public static System.Collections.Generic.IEnumerable<string> ReadLines(string path, System.Text.Encoding encoding);

static member ReadLines : string * System.Text.Encoding -> seq<string>

Public Shared Function ReadLines (path As String, encoding As Encoding) As IEnumerable(Of String)

Parâmetros

Devoluções

Todas as linhas do ficheiro, ou as linhas que resultam de uma consulta.

Exceções

Observações

Use este método para especificar uma codificação a usar para ler o ficheiro.

Os ReadLines métodos e ReadAllLines diferem da seguinte forma: Quando usa ReadLines, pode começar a enumerar a coleção de cadeias antes de toda a coleção ser devolvida. Quando usa ReadAllLines, tem de esperar que todo o array de strings seja devolvido antes de poder aceder ao array. Portanto, quando trabalha com ficheiros muito grandes, ReadLines pode ser mais eficiente.

Pode usar o ReadLines método para fazer o seguinte:

• Realizar consultas LINQ para Objetos num ficheiro para obter um conjunto filtrado das suas linhas.
• Escreva a coleção devolvida de linhas num ficheiro com o File.WriteAllLines(String, IEnumerable<String>, Encoding) método, ou anexe-as a um ficheiro existente com o File.AppendAllLines(String, IEnumerable<String>, Encoding) método.
• Crie uma instância preenchida imediatamente de uma coleção que tome uma IEnumerable<T> coleção de cadeias como seu construtor, como a IList<T> ou um Queue<T>.

Uma linha é definida como uma sequência de caracteres terminada por um retorno de carro ('\r'), um retorno de linha ('\n'), um retorno de carro imediatamente seguido por um retorno de linha, ou o fim do ficheiro ou fluxo. Se o ficheiro terminar com uma sequência de nova linha, não é devolvida nenhuma linha vazia adicional. Por exemplo, um ficheiro que contém "line1\nline2\n" produz as mesmas duas linhas ("line1" e "line2") que um ficheiro contendo "line1\nline2".