In this post, we’ll build a simple Find in Files utility in Xojo that:

• searches the files in a folder
• reads each file line by line
• performs a plain-text, case-insensitive match
• returns the file path, line number, and matching line

The goal is simple: build something useful while leaving the door open for the fancier stuff.

What this Find in Files function will do

Let’s keep the scope clear:

• search one folder
• search plain text only
• skip subfolders for now
• return the matching file path, line number, and line contents

Step 1: A class in a module and some properties

Before touching the file system, let’s define what a match looks like.

You could return raw strings, but that gets messy fast. A small class keeps the code readable and gives us an obvious place to extend later. In this version, I like keeping that class inside the same module as the search function. It keeps the entire utility self-contained instead of spraying helper types all over the project.

So, we start by adding a module SearchUtils and inside the module we will add a class SearchHit.

Module SearchUtils

  Class SearchHit

    Public Property FilePath As String
    Public Property LineNumber As Integer
    Public Property LineText As String

    Public Sub Constructor(filePath As String, lineNumber As Integer, lineText As String)
      Self.FilePath = filePath
      Self.LineNumber = lineNumber
      Self.LineText = lineText
    End Sub

  End Class

End Module

Each result stores three things:

1. the file path
2. the line number
3. the matching line

Step 2: Walk through the folder

FolderItem.Children lets us loop through a folder with a For Each loop, which keeps the code clear.

We’ll also reject bad input early:

• the folder is Nil
• the folder does not exist
• the item passed is not actually a folder
• the search term is empty

This process is simple, fast and effective.

Step 3: Read files line by line

For text files, TextInputStream.Open is the right tool. From there, we can call ReadLine until EndOfFile becomes True.

I prefer this over ReadAll for a utility like this. ReadAll is fine when the file is small and you know what you’re doing, but line-by-line reading is a better default here. It keeps memory use in check and gives us line numbers for free.

For the sample code, I’m explicitly using UTF-8:

input.Encoding = Encodings.UTF8

That keeps the sample predictable. It does not mean this code can gracefully decode every text file you throw at it. Files with unknown encodings or binary-ish content are a separate problem, and they deserve their own solution.

Step 4: Match the text

For a plain-text search, String.Contains does exactly what we need:

line.Contains(searchTerm, ComparisonOptions.CaseInsensitive)

It handles the case-insensitivity without the overhead, or the headache, of regex.

Step 5: The full module and class and function

Module SearchUtils

  Public Class SearchHit
    Public Property FilePath As String
    Public Property LineNumber As Integer
    Public Property LineText As String

    Public Sub Constructor(filePath As String, lineNumber As Integer, lineText As String)
      Self.FilePath = filePath
      Self.LineNumber = lineNumber
      Self.LineText = lineText
    End Sub
  End Class

  Public Function FindInFiles(targetFolder As FolderItem, searchTerm As String) As SearchHit()
    Var hits() As SearchHit

    If targetFolder Is Nil Then
      Return hits
    End If

    If Not targetFolder.Exists Or Not targetFolder.IsFolder Then
      Return hits
    End If

    If searchTerm.IsEmpty Then
      Return hits
    End If

    For Each item As FolderItem In targetFolder.Children
      If item Is Nil Then Continue
      If item.IsFolder Then Continue
      If Not item.Exists Then Continue
      If Not item.IsReadable Then Continue

      Try
        Var input As TextInputStream = TextInputStream.Open(item)
        input.Encoding = Encodings.UTF8

        Var lineNumber As Integer = 0

        While Not input.EndOfFile
          Var line As String = input.ReadLine
          lineNumber = lineNumber + 1

          If line.Contains(searchTerm, ComparisonOptions.CaseInsensitive) Then
            hits.Add(New SearchHit(item.NativePath, lineNumber, line))
          End If
        Wend

        input.Close

      Catch error As IOException
        ' Skip files that cannot be read as text.
        Continue
      End Try
    Next

    Return hits
  End Function

End Module

How it works

Let’s break down the important parts.

Input validation

This block prevents pointless work and avoids avoidable runtime problems:

If targetFolder Is Nil Then
  Return hits
End If

If Not targetFolder.Exists Or Not targetFolder.IsFolder Then
  Return hits
End If

If searchTerm.IsEmpty Then
  Return hits
End If

Rule of thumb: reject bad input early.

Folder iteration

This is the core loop:

For Each item As FolderItem In targetFolder.Children

We’re only scanning the folder’s immediate contents. If an item is another folder, we skip it.

If item.IsFolder Then Continue

Safe text reading

Each file is opened with TextInputStream.Open inside a Try...Catch block:

Try
  Var input As TextInputStream = TextInputStream.Open(item)
  input.Encoding = Encodings.UTF8
  ...
Catch error As IOException
  Continue
End Try

That way, one unreadable file does not take down the whole search. It gets skipped and the rest of the folder still gets processed.

Line-by-line matching

This is where the actual work happens:

While Not input.EndOfFile
  Var line As String = input.ReadLine
  lineNumber = lineNumber + 1

  If line.Contains(searchTerm, ComparisonOptions.CaseInsensitive) Then
    hits.Add(New SearchHit(item.NativePath, lineNumber, line))
  End If
Wend

Because we’re reading one line at a time, attaching the correct line number is trivial.

Why keep SearchHit inside the module?

Because it belongs to this utility. The search function and its result type are part of the same little unit of behavior, so keeping them together makes the project easier to scan and easier to transform it to a Library.

It also means code outside the module uses the namespaced type:

Var results() As SearchUtils.SearchHit = SearchUtils.FindInFiles(folder, "xojo")

Using the function

Here’s a simple example that lets the user choose a folder and then writes the results to the debug log:

Var folder As FolderItem = FolderItem.ShowSelectFolderDialog
If folder Is Nil Then Return

Var results() As SearchUtils.SearchHit = SearchUtils.FindInFiles(folder, "error")

For Each hit As SearchUtils.SearchHit In results
  System.DebugLog(hit.FilePath + " | line " + hit.LineNumber.ToString + " | " + hit.LineText)
Next

If you want to display the results in a DesktopListBox, that works nicely too:

Var folder As FolderItem = FolderItem.ShowSelectFolderDialog
If folder Is Nil Then Return

Var results() As SearchUtils.SearchHit = FindInFiles(folder, "error")

ListBox1.RemoveAllRows
ListBox1.ColumnCount = 3

For Each hit As SearchUtils.SearchHit In results
  ListBox1.AddRow(hit.FilePath)
  ListBox1.CellTextAt(ListBox1.LastAddedRowIndex, 1) = hit.LineNumber.ToString
  ListBox1.CellTextAt(ListBox1.LastAddedRowIndex, 2) = hit.LineText
Next

A few sample results might look like this:

C:\Logs\app.log | line 18 | Error connecting to database
C:\Logs\app.log | line 42 | Error writing audit record
C:\Configs\service.txt | line 7 | Last error message: timeout

Practical limitations of this version

This utility is useful, but limited.

It assumes UTF-8

That is fine for plenty of modern text files, but not all of them. If you’re dealing with mixed encodings, you’ll need a smarter approach that detects the file encoding.

It doesn’t recurse into subfolders

That is deliberate. Recursive search is useful, but it adds another layer of behavior and another place to make the code harder to read.

Final thoughts

A basic Find in Files function is one of those utilities that looks small but pays off quickly. This is a base-layer utility. Once you have this working, adding recursion or regex is a much smaller lift.

Let’s discuss in the forums.

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

Why Read and Write in Chunks?

Loading or writing a large file in one go can overwhelm your application’s memory and degrade performance. Processing files in smaller, manageable chunks allows for better memory management and more responsive applications.

Reading Files in Chunks

To read a large file in chunks, you can repeatedly read smaller portions of the file until you reach the end. Here’s an example:

Var file As FolderItem = FolderItem.ShowOpenFileDialog("text/plain")
If file <> Nil Then
  Const kChunkSize As Integer = 1024  ' 1 KB chunks

  Var inputStream As TextInputStream = TextInputStream.Open(file)
  Var buffer As String

  While Not inputStream.EndOfFile
    buffer = inputStream.Read(kChunkSize)
    // Process the buffer (for demonstration, we'll just print it)
    System.DebugLog(buffer)
 Wend

  inputStream.Close
Else
  MessageBox("No file selected.")
End If

In this example:

• A TextInputStream is created to read the file.
• The kChunkSize defines how much data is read at a time.
• The file is read in a loop until the end is reached, processing each chunk.

Writing Files in Chunks

Writing large files in chunks involves writing smaller portions incrementally. Here’s an example using String.Bytes and String.MiddleBytes for better performance:

Var file As FolderItem = FolderItem.ShowSaveFileDialog("text/plain", "example.txt")
If file <> Nil Then
  Const kChunkSize As Integer = 1024  ' 1 KB chunks

  Var outputStream As TextOutputStream = TextOutputStream.Create(file)
  Var data As String = "Large data string here..." // Your data source
  Var totalBytes As Integer = data.Bytes

  For i As Integer = 0 To totalBytes Step kChunkSize
    Var chunk As String = data.MiddleBytes(i, kChunkSize)
    outputStream.Write(chunk)
  Next

  // Write any remaining data
  If totalBytes Mod kChunkSize <> 0 Then
    Var remainingBytes As Integer = totalBytes Mod kChunkSize
    Var chunk As String = data.MiddleBytes(totalBytes - remainingBytes, remainingBytes)
    outputStream.Write(chunk)
  End If

  outputStream.Close
  MessageBox("File written successfully.")
Else
  MessageBox("No file specified.")
End If

In this example:

• A TextOutputStream is created to write to a file.
• The total bytes of the string are calculated for iteration.
• Data is written in chunks defined by kChunkSize using String.MiddleBytes for improved performance.
• After the loop, any remaining data that didn’t fit into a full chunk is written.

Practical Example: Processing Large Log Files

Processing large log files line by line in chunks can be done as follows:

Var file As FolderItem = FolderItem.ShowOpenFileDialog("text/plain")
If file <> Nil Then
  Const kChunkSize As Integer = 4096 ' 4 KB chunks
  Var inputStream As TextInputStream = TextInputStream.Open(file)
  Var buffer, remaining As String
  While Not inputStream.EndOfFile
    buffer = inputStream.Read(kChunkSize)
    buffer = remaining + buffer
    Var lines() As String = buffer.ToArray(EndOfLine)
    // Process all but the last line
    For i As Integer = lines.FirstIndex To lines.LastIndex - 1
      System.DebugLog(lines(i))
    Next
    // Save the last line for the next chunk
    remaining = lines(lines.LastIndex)
  Wend
  // Process any remaining content
  If Not remaining.IsEmpty Then
    System.DebugLog(remaining)
  End If
  inputStream.Close
Else
  MessageBox("No file selected.")
End If

In this example:

• The file is read in larger chunks (4 KB).
• The buffer is split into lines, and all but the last line are processed.
• The last line is saved and appended to the next chunk to ensure no data is lost.

Advanced Techniques: Handling Binary Files

Reading and writing binary files also benefits from chunk processing. Here’s a basic example of reading binary files in chunks:

Var file As FolderItem = FolderItem.ShowOpenFileDialog("")
If file <> Nil Then
  Const kChunkSize As Integer = 1024 ' 1 KB chunks
  Var binaryStream As BinaryStream = BinaryStream.Open(file, False)
  Var buffer As MemoryBlock
  While Not binaryStream.EndOfFile
    buffer = binaryStream.Read(kChunkSize)
    // Process the buffer (for demonstration, we'll just print its size)
    System.DebugLog(buffer.Size.ToString)
  Wend
  binaryStream.Close
Else
  MessageBox("No file selected.")
End If

In this example:

• A BinaryStream is created to read the file.
• Data is read in chunks and processed accordingly.

Writing Binary Files in Chunks

You can also write binary files in chunks. Here’s a basic example:

Var file As FolderItem = FolderItem.ShowSaveFileDialog("text/plain", "example.txt")
If file <> Nil Then
  Var binaryStream As BinaryStream = BinaryStream.Create(file, True)
  Const kChunkSize As Integer = 1024 ' 1 KB chunks
  Var data As MemoryBlock = ...  ' Your binary data source
  Var totalBytes As Integer = data.Size
  For i As Integer = 0 To totalBytes Step kChunkSize
    Var chunk As MemoryBlock = data.MidB(i, kChunkSize)
    binaryStream.Write(chunk)
  Next
  // Write any remaining data
  If totalBytes Mod kChunkSize <> 0 Then
    Var remainingBytes As Integer = totalBytes Mod kChunkSize
    Var chunk As MemoryBlock = data.MidB(totalBytes - remainingBytes, remainingBytes)
    binaryStream.Write(chunk)
  End If
  binaryStream.Close
  MessageBox("Binary file written successfully.")
Else
  MessageBox("No file specified.")
End If

In this example:

• A BinaryStream is created to write to a file.
• Data is written in chunks using MemoryBlock.MidB to handle binary data.
• After the loop, any remaining data that didn’t fit into a full chunk is written.

Using Threads for Large File Operations

When working with large files, consider using a Thread to perform read and write operations. This keeps the user interface responsive while the file operations are running in the background.

Example of reading a large file in a thread:

Class FileReadThread Inherits Thread
  Private mFile As FolderItem
  Sub Constructor(file As FolderItem)
    mFile = file
  End Sub
  Sub Run()
    Const kChunkSize As Integer = 1024 ' 1 KB chunks
    Var inputStream As TextInputStream = TextInputStream.Open(mFile)
    Var buffer As String
    While Not inputStream.EndOfFile
      buffer = inputStream.Read(kChunkSize)
      // Process the buffer (for demonstration, we'll just print it)
      System.DebugLog(buffer)
    Wend
    inputStream.Close
  End Sub
End Class

// Usage
Var file As FolderItem = FolderItem.ShowOpenFileDialog("text/plain")
If file <> Nil Then
  Var fileThread As New FileReadThread(file)
  fileThread.Run
Else
  MessageBox("No file selected.")
End If

In this example:

• A Thread subclass is created to handle file reading.
• The main UI remains responsive while the thread processes the file in the background.

Conclusion

Handling large files efficiently is crucial for developing robust Xojo applications. By reading and writing files in chunks, you can manage memory usage better and ensure your application remains responsive even when dealing with large datasets. Experiment with these techniques in your projects to experience the benefits.

Happy coding!

Martin T. is a Xojo MVP and has been very involved in testing Android support.

In this article, we will make use of the key Xojo classes and techniques for working with text files. We will start by looking at how to read the contents of text files using the TextInputStream class. You will learn how to read an entire file into a string and how to process the file line-by-line.

Next, we will cover writing to text files using the TextOutputStream class. You will see examples of how to write a complete string to a file and how to write individual lines one-by-one, useful when logging information or saving user preferences.

By the end of this post, you will understand the core techniques for accessing, reading, and writing text files in your Xojo applications. These skills will help you build more robust and flexible software that can work with a wide range of data sources and formats.

Reading Text Files

When it comes to reading the contents of text files in Xojo, the TextInputStream class is the primary tool you’ll use. This class provides methods for both reading the entire file at once, as well as reading it line-by-line.

Using TextInputStream to Open and Read Text Files

Here is an example that demonstrates how to read an entire file into a string:

// Step 1: Open the File
Var file As FolderItem
file = FolderItem.ShowOpenFileDialog("text/plain") // Show an open file dialog to select the file

If file <> Nil Then
  // Step 2: Create a TextInputStream
  Var inputStream As TextInputStream
  inputStream = TextInputStream.Open(file)
  
  // Step 3: Read the File
  Var fileContents As String
  fileContents = inputStream.ReadAll
  
  // Step 4: Close the Stream
  inputStream.Close
  
  // Output the file contents (for demonstration purposes)
  MessageBox(fileContents)
Else
  MessageBox("No file selected.")
End If

In this example:

• The FolderItem.ShowOpenFileDialog method is used to display a file dialog, allowing the user to select a text file.
• The TextInputStream.Open method opens the selected file for reading.
• The ReadAll method reads the entire contents of the file into the fileContents string.
• The Close method closes the TextInputStream.

This approach is useful when you need to process the entire contents of a text file at once. However, for larger files, you may want to read the file line-by-line to manage memory usage more efficiently, which we will cover in the next section.

Using TextInputStream to Read Line-by-Line

Reading a file line-by-line is often more efficient, especially for large files. This method allows you to process each line individually, reducing memory usage and enabling you to handle large datasets more effectively.

Here is an example that demonstrates how to read a file line-by-line in Xojo:

// Step 1: Open the File
Var file As FolderItem
file = FolderItem.ShowOpenFileDialog("text/plain") // Show an open file dialog to select the file

If file <> Nil Then
  // Step 2: Create a TextInputStream
  Var inputStream As TextInputStream
  inputStream = TextInputStream.Open(file)
  
  // Step 3: Read Each Line
  Var line As String
  While Not inputStream.EndOfFile
    line = inputStream.ReadLine
    // Process each line (for demonstration purposes, we'll just output each line in a MessageBox)
    MessageBox(line)
  Wend
  
  // Step 4: Close the Stream
  inputStream.Close
Else
  MessageBox("No file selected.")
End If

This approach is particularly useful when you need to process or analyze each line of a text file individually, such as when parsing log files or reading configuration settings.

Writing Text Files

Writing text files in Xojo is just as straightforward as reading them. The TextOutputStream class allows you to write data to text files, either all at once or line-by-line and it’s quite easy.

Using TextOutputStream to Write Entire Files

To write an entire string to a file, follow these steps:

// Step 1: Allow the user to set the path and name of the text file we are about to create
Var file As FolderItem
file = FolderItem.ShowSaveFileDialog("text/plain", "example.txt") // Show a save file dialog to specify the file

If file <> Nil Then
  // Step 2: Create a TextOutputStream
  Var outputStream As TextOutputStream
  outputStream = TextOutputStream.Create(file)
  
  // Step 3: Write to the File
  Var fileContents As String = "Hello, Xojo!"
  outputStream.Write(fileContents)
  
  // Step 4: Close the Stream
  outputStream.Close
  
  MessageBox("File written successfully.")
Else
  MessageBox("No file specified.")
End If

In this example:

• The FolderItem.ShowSaveFileDialog method is used to display a save file dialog, allowing the user to specify the file name and location.
• The TextOutputStream.Create method creates a new file or overwrites an existing file.
• The Write method writes the fileContents string to the file.
• The Close method closes the TextOutputStream.

Using TextOutputStream to Write Line-by-Line

Writing a file line-by-line is useful when you need to write data incrementally or when dealing with large datasets.

To write a file line-by-line, follow these steps:

// Step 1: Allow the user to set the path and name of the text file we are about to create
Var file As FolderItem
file = FolderItem.ShowSaveFileDialog("text/plain", "example.txt") // Show a save file dialog to specify the file

If file <> Nil Then
  // Step 2: Create a TextOutputStream
  Var outputStream As TextOutputStream
  outputStream = TextOutputStream.Create(file)
  
  // Step 3: Write Each Line
  Var lines() As String = Array("Line 1", "Line 2", "Line 3")
  For Each line As String In lines
    outputStream.WriteLine(line)
  Next
  
  // Step 4: Close the Stream
  outputStream.Close
  
  MessageBox("File written successfully.")
Else
  MessageBox("No file specified.")
End If

In this example:

• The FolderItem.ShowSaveFileDialog method is used to display a save file dialog, allowing the user to specify the file.
• The TextOutputStream.Create method creates a new file or overwrites an existing file.
• The WriteLine method writes each line from the lines array to the file.
• The Close method closes the TextOutputStream.

By understanding these methods, you can choose the one that best fits your needs. Writing the entire file at once is useful for smaller datasets or when you need to write all data simultaneously. Writing line-by-line is more efficient for larger datasets or when you need to write data incrementally.

Conclusion

This article has provided you with the skills to handle text files in Xojo using the TextInputStream and TextOutputStream classes. We covered the following essential techniques:

Reading Text Files:

• Reading entire files into a string using TextInputStream.ReadAll
• Reading files line-by-line using TextInputStream.ReadLine

Writing Text Files:

• Writing entire strings to a file using TextOutputStream.Write
• Writing lines to a file using TextOutputStream.WriteLine

Try applying these techniques in your own projects. Experiment with different methods to see how they can help you manage text files more effectively. The official Xojo documentation on working with text files is a great resource for further reading.

Ready to get started? Download Xojo for free and begin building your applications today!

Happy coding!

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

• Facebook
• X
• LinkedIn
• GitHub
• YouTube