TagBites.IO 2.0.0

TagBites.IO

TagBites.IO turns any storage into the same thing: a FileSystem browsed with FileLink and DirectoryLink. The local disk, an in-memory tree and a composed virtual tree are built in, and separate packages add FTP, SFTP, SMB, WebDAV, HTTP, ZIP, Dropbox, OneDrive, Google Cloud Storage, Azure Blob Storage and S3. An operation is written once - copy, move, sync, watch, restore a version - and runs wherever the files live, without a provider-specific SDK.

One API, any storage

Restore yesterday's FTP backup to disk:

using var ftp = FtpFileSystem.Create("ftp.example.com", "user", "password");

var backup = ftp.GetDirectory("/backups/2026-07-04");
var restore = FileSystem.Local.GetDirectory("C:/Restore");

backup.CopyTo(restore);

Turn an S3 bucket, a Dropbox account and a local folder into one Windows drive:

var s3 = S3FileSystem.Create(serviceUrl, accessKey, secretKey, "bucket");
var dropbox = DropboxFileSystem.Create(dropboxToken);

var backups = s3.GetDirectory("backups");
var photos = dropbox.GetDirectory("Photos");
var files = FileSystem.Local.GetDirectory("C:/Files");

var merged = new VirtualDirectory
{
    Entries =
    {
        new VirtualDirectoryEntry(backups, "S3"),
        new VirtualDirectoryEntry(photos, "Dropbox"),
        new VirtualDirectoryEntry(files, "Local")
    }
};

using var drive = new WinDrive(merged.ToDirectory()) { Name = "Merged Drive" };
drive.Mount(); // "V:\S3", "V:\Dropbox", "V:\Local"

Install

dotnet add package TagBites.IO

Targets netstandard2.0, netstandard2.1 and net5.0. No dependencies.

Local disk, an in-memory file system and a virtual composed tree are built in. Remote storages ship as separate packages that plug into the same API:

and also allows to create custom file system.

TagBites.IO.WinDrive lets you mount any DirectoryLink - regardless of the underlying file system - as a real Windows drive letter.

Usage

var fs = FileSystem.Local;

var directory = fs.GetDirectory("/some/folder");
directory.Create();

var file = fs.GetFile("/some/folder/file.txt");
file.WriteAllText("Hello world!");

var content = file.ReadAllText(); // "Hello world!"

foreach (var f in directory.GetFiles(recursive: true))
    Console.WriteLine(f.FullName);

Every provider package (TagBites.IO.Ftp, TagBites.IO.S3, ...) exposes the same shape - a static Create(...) method returning a FileSystem - so the code above works unchanged regardless of the storage:

using var fs = FtpFileSystem.Create("ftp.example.com", "user", "password");
var file = fs.GetFile("/reports/2024/summary.csv");

Copy, move and sync

Source and destination can live in different storages:

using var ftp = FtpFileSystem.Create("ftp.example.com", "user", "password");
using var s3 = S3FileSystem.Create(serviceUrl, accessKey, secretKey, "archive");

var reports = ftp.GetDirectory("/reports");
var archive = s3.GetDirectory("/reports");

reports.Copy(archive, overwrite: true);
reports.Move(archive);
reports.SyncWith(archive, FileSystemSynchronizeMode.OneWayWithRemoveNotExisting);

What happens when the destination exists, and what happens when one file in a tree fails, is decided per call - see conflicts and errors.

Live synchronization

SyncWith runs once. FileSystemLinkSynchronizer keeps a pair in step for as long as it is enabled, across two different storages:

using var ftp = FtpFileSystem.Create("ftp.example.com", "user", "password");

var local = FileSystem.Local.GetDirectory("C:/Reports");
var remote = ftp.GetDirectory("/reports");

using var synchronizer = new FileSystemLinkSynchronizer();
synchronizer.Add(local, remote, FileSystemSynchronizeMode.BothWaysUsingLastWriteTime);

synchronizer.SyncFailed += (_, e) =>
    Console.WriteLine($"{e.Source.FullName}: {e.Exception.Message}, retry: {e.WillRetry}");

synchronizer.Enabled = true;

Change detection uses the same watcher the provider reports through FileSystemFeatures.Watcher. A storage without one notices only the changes made through the registered FileSystem instances, so call ForceSyncAsync() on a timer to catch what another client wrote:

await synchronizer.ForceSyncAsync();

See synchronization for what each mode does and what a watcher on a remote storage does not see.

File versions

A file system whose operations implement IFileSystemHistoryOperations exposes previous versions of a file:

var versions = file.GetHistoryVersions();

foreach (var version in versions)
    Console.WriteLine($"{version.ModifyTime} {version.Length}");

var previous = versions[0];

using var stream = previous.Read(); // the content of that version, without restoring it
previous.Restore();

No shipped provider implements file history yet. The API is there for a custom file system built over a storage that keeps versions - see file history and versioning.

Links

• Changelog