An exFAT accessor library.
ExFat allows to manipulate an exFAT formatted partition (provided as a System.IO.Stream
).
It comes with two packages:
ExFat.Core
available from NuGet, which allows simple exFAT management at three different levels (partition, entry and path).ExFat.DiscUtils
available from NuGet, which depends on DiscUtils
package.Currently, ExFat.Core
does what it says: files/directories manipulation at any level.
DiscUtils support is on its way and should be released in the very next few days.
ExFat.Core
works at three levels:
ExFat.DiscUtils
is also a high-level access (using paths) with implementation for DiscUtils
.
Because it is still under development, you can see pending features state here.
All examples assume you have a Stream
containing an exFAT partition.
// Access at partition-level. Most efficient, most dangerous.
// Integrity is not guaranteed at this level,
// user needs to make all neceassary operations in right order.
using(var partition = new ExFatPartition(partitionStream))
{
// returns all entries (including bitmap, volume label, etc.) from root directory
var entries = partition.GetEntries(partition.RootDirectoryDataDescriptor);
// returns all files/directories meta entries
var metaEntries = partition.GetMetaEntries(partition.RootDirectoryDataDescriptor);
// assuming there is one, of course (but we're in a sample)
var someDirectory = metaEntries.First(e => e.IsDirectory);
var directoryMetaEntries = partition.GetMetaEntries(someDirectory.DataDescriptor);
var someFile = metaEntries.First(e => !e.IsDirectory);
using(var dataStream = partition.OpenDataStream(someFile.DataDescriptor, FileAccess.Read))
{ }
}
// Access at entry level. Quite fast, since user has to track entries.
// Integrity is guaranteed. File attributes are not honored (maybe one day...)
using(var entryFilesystem = new ExFatEntryFilesystem(partitionStream))
{
var someFileEntry = entryFilesystem.FindChild(filesystem.RootDirectory, "someFile");
using(var fileStream = entryFilesystem.OpenFile(someFileEntry, FileAccess.Read)
{ }
// finding one file in a directory requires two steps
var someDirectoryEntry = entryFilesystem.FindChild(filesystem.RootDirectory, "someDirectory");
var someChildFileEntry = entryFilesystem.FindChild(someDirectoryEntry, "someDirectory");
}
// Access at path level. Uses a path cache to retrieve entries,
// so speed is not as good (but not that bad either)
// since there is not drive, paths only specify the directory chain
// (so "a\b\c" for example)
using(var pathFilesystem = new ExFatPathFilesystem(partitionStream))
{
var rootEntries = pathFilesystem.EnumerateEntries("\"); // "" works too for root
var childEntries = pathFilesystem.EnumerateEntries(@"\somedir"); // "somedir" works too
using(var s = pathFilesystem.Open(@"a\b\c", FileMode.Open, FileAccess.Read)
{ }
}
Current build status (for people who care... If you ever meet one):