public void Test()
{
Assert.IsFalse(fp.GetDirectoryContents("/nonexisting").Exists);
Assert.IsTrue(fp.GetDirectoryContents("/tmp").Exists);
Assert.IsTrue(fp.GetDirectoryContents("/tmp/dir").Exists);
Assert.IsTrue(fp.GetDirectoryContents("c:").Exists);
Assert.IsFalse(fp.GetDirectoryContents("/tmp/helloworld.txt").Exists);
Assert.IsTrue(fp.GetFileInfo("/tmp/helloworld.txt").Exists);
Assert.IsFalse(fp.GetFileInfo("/tmp").Exists);
// Read file
using (Stream s = fp.GetFileInfo("/tmp/helloworld.txt").CreateReadStream())
{
byte[] data = new byte[100];
int c = s.Read(data, 0, 100);
Assert.AreEqual(c, HelloWorld.Length);
for (int i = 0; i < c; i++)
{
Assert.AreEqual(data[i], HelloWorld[i]);
}
}
// Observe
IChangeToken token = fp.Watch("/tmp/**");
Semaphore semaphore = new Semaphore(0, int.MaxValue);
IDisposable disposable = token.RegisterChangeCallback(o => semaphore.Release(), null);
// Test, not activated
Assert.IsFalse(semaphore.WaitOne(300));
Assert.IsFalse(token.HasChanged);
// Test, not activated
ram.CreateFile("/not-monited-path.txt");
Assert.IsFalse(semaphore.WaitOne(300));
Assert.IsFalse(token.HasChanged);
// Test, not activated
disposable.Dispose();
ram.CreateFile("/tmp/monited-path.txt");
Assert.IsFalse(semaphore.WaitOne(300));
Assert.IsTrue(token.HasChanged);
// Observe again
token = fp.Watch("/tmp/**");
semaphore = new Semaphore(0, int.MaxValue);
disposable = token.RegisterChangeCallback(o => semaphore.Release(), null);
ram.CreateFile("/tmp/monited-path-again.txt");
Assert.IsTrue(semaphore.WaitOne(300));
Assert.IsTrue(token.HasChanged);
// Shouldn't activate any more
ram.CreateFile("/tmp/monited-path-again-one-more-time.txt");
Assert.IsFalse(semaphore.WaitOne(300));
}
public void Initialize()
{
ram = new MemoryFileSystem();
ram.CreateDirectory("/tmp");
ram.CreateDirectory("/tmp/dir");
ram.CreateDirectory("/mnt");
ram.CreateDirectory("/usr/lex");
ram.CreateDirectory("c:/dir/dir");
ram.CreateFile("/tmp/helloworld.txt", HelloWorld);
ram.CreateFile("/tmp/helloworld_100.txt", HelloWorld_x100);
ram.CreateFile("/tmp/helloworld_10000.txt", HelloWorld_x10000);
ram.CreateDirectory("file://");
}
public static void Main(string[] args)
{
{
#region Snippet_1
IFileSystem ram = new MemoryFileSystem();
ram.CreateDirectory("/tmp/");
ram.CreateDirectory("/mnt/");
ram.CreateDirectory("/usr/lex/");
ram.CreateDirectory("c:/dir/dir/");
ram.CreateFile("/tmp/helloworld.txt", Encoding.UTF8.GetBytes("Hello World!\r\n"));
ram.CreateDirectory("file://c:/temp");
foreach (TreeVisit.Line line in ram.VisitTree())
{
Console.WriteLine(line);
}
#endregion Snippet_1
#region Snippet_2
foreach (TreeVisit.Line line in ram.VisitTree(depth: 1))
{
Console.WriteLine(line);
}
#endregion Snippet_2
#region Snippet_3
foreach (TreeVisit.Line line in ram.VisitTree(path: "/tmp/"))
{
Console.WriteLine(line);
}
#endregion Snippet_3
}
}
static void CreateMemoryFile()
{
FileSystemPath MemRootFilePath = FileSystemPath.Root.AppendFile("x");
var MemFileSystem = new MemoryFileSystem();
// File shouldn’t exist prior to creation.
Assert.False(MemFileSystem.Exists(MemRootFilePath));
var content = new byte[] { 0xde, 0xad, 0xbe, 0xef, };
using (var xStream = MemFileSystem.CreateFile(MemRootFilePath))
{
// File now should exist.
Assert.True(MemFileSystem.Exists(MemRootFilePath));
xStream.Write(content, 0, content.Length);
}
// File should still exist and have content.
Assert.True(MemFileSystem.Exists(MemRootFilePath));
using (var xStream = MemFileSystem.OpenFile(MemRootFilePath, FileAccess.Read))
{
var readContent = new byte[2 * content.Length];
Assert.Equal(content.Length, xStream.Read(readContent, 0, readContent.Length));
Assert.Equal(
content,
// trim to the length that was read.
readContent.Take(content.Length).ToArray());
// Trying to read beyond end of file should return 0.
Assert.Equal(0, xStream.Read(readContent, 0, readContent.Length));
}
}
public virtual void Test()
{
var fs = new MemoryFileSystem();
var path = new FileSystemPath().AppendFile("test");
// Write
using (var outStream = fs.CreateFile(path))
{
BeginWrite(outStream);
int i = 0;
foreach (var value in Values)
{
Serialize(value, Field(i++));
}
EndWrite();
}
// Read
using (var inStream = fs.OpenFile(path, FileAccess.Read))
{
BeginRead(inStream);
int i = 0;
foreach (var expected in Values)
{
var actual = Deserialize(expected.GetType(), Field(i++));
Assert.Equal(expected, actual);
}
EndRead();
}
}
public void 列舉根路徑內的子資料夾()
{
using var fileSystem = new MemoryFileSystem();
Console.WriteLine("建立資料夾");
fileSystem.CreateDirectory("dir1/dir2/dir3/");
fileSystem.PrintTo(Console.Out);
var content = "This is test string";
var contentBytes = Encoding.UTF8.GetBytes($"{content}");
Console.WriteLine("dir1 底下建立檔案");
using (var outputStream =
fileSystem.Open("dir1/1.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite))
{
var bytes = Encoding.UTF8.GetBytes(content);
outputStream.Write(bytes, 0, bytes.Length);
}
Console.WriteLine("dir2 底下建立檔案");
fileSystem.CreateFile("dir1/dir2/2.txt", contentBytes);
foreach (var entry in fileSystem.Browse(""))
{
var path = entry.Path;
Console.WriteLine(path);
}
}
public void 列舉根路徑底下所有結構()
{
using var fileSystem = new MemoryFileSystem();
Console.WriteLine("建立資料夾");
fileSystem.CreateDirectory("dir1/dir2/dir3/");
fileSystem.PrintTo(Console.Out);
var content = "This is test string";
var contentBytes = Encoding.UTF8.GetBytes($"{content}");
Console.WriteLine("dir1 底下建立檔案");
using (var outputStream =
fileSystem.Open("dir1/1.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite))
{
var bytes = Encoding.UTF8.GetBytes(content);
outputStream.Write(bytes, 0, bytes.Length);
}
Console.WriteLine("dir2 底下建立檔案");
fileSystem.CreateFile("dir1/dir2/2.txt", contentBytes);
var tree = fileSystem.VisitTree();
foreach (var line in tree)
{
Console.WriteLine($"name:{line.Name},path:{line.Path}");
}
}
public void 修改檔案日期()
{
using var fileSystem = new MemoryFileSystem();
Console.WriteLine("建立資料夾");
fileSystem.CreateDirectory("dir1/dir2/dir3/");
fileSystem.PrintTo(Console.Out);
var content = "This is test string";
var contentBytes = Encoding.UTF8.GetBytes($"{content}");
Console.WriteLine("dir2 底下建立檔案");
fileSystem.CreateFile("dir1/dir2/2.txt", contentBytes);
var entry = fileSystem.GetEntry("dir1/dir2/2.txt");
Console.WriteLine("檔案修改前的日期");
Console.WriteLine($"LastAccess:{entry.LastAccess}");
Console.WriteLine($"LastModified:{entry.LastModified}");
var type = entry.GetType();
var now = new DateTimeOffset(DateTime.UtcNow.AddDays(-30));
var lastAccessPropertyInfo = type.GetProperty("LastAccess");
var lastModifiedPropertyInfo = type.GetProperty("LastModified");
lastAccessPropertyInfo.SetValue(entry, now);
lastModifiedPropertyInfo.SetValue(entry, now);
Console.WriteLine("檔案修改後的日期");
Console.WriteLine($"LastAccess:{entry.LastAccess}");
Console.WriteLine($"LastModified:{entry.LastModified}");
}
public static void Main(string[] args)
{
{
#region Snippet_1
IFileSystem ram = new MemoryFileSystem();
IFileSystem os = FileSystem.OS;
IFileSystem fp = new PhysicalFileProvider(AppDomain.CurrentDomain.BaseDirectory).ToFileSystem()
.AddDisposeAction(fs => fs.FileProviderDisposable?.Dispose());
IFileSystem embedded = new EmbeddedFileSystem(typeof(Composition_Examples).Assembly);
IFileSystem composition = FileSystemExtensions.Concat(ram, os, fp, embedded)
.AddDisposable(embedded)
.AddDisposable(fp)
.AddDisposable(os);
#endregion Snippet_1
#region Snippet_2
foreach (var entry in composition.VisitTree(depth: 1))
{
Console.WriteLine(entry);
}
#endregion Snippet_2
#region Snippet_3
using (Stream s = composition.Open("docs.example-file.txt", FileMode.Open, FileAccess.Read, FileShare.Read))
{
Console.WriteLine(s.Length);
}
#endregion Snippet_3
}
{
#region Snippet_4
IFileSystem ram1 = new MemoryFileSystem();
IFileSystem ram2 = new MemoryFileSystem();
IFileSystem composition = FileSystemExtensions.Concat(ram1, ram2);
// Create file of 1024 bytes
ram1.CreateFile("file.txt", new byte[1024]);
// Create file of 10 bytes
ram2.CreateFile("file.txt", new byte[10]);
// Get only one entry size of 1024 bytes.
composition.PrintTo(Console.Out, format: PrintTree.Format.Default | PrintTree.Format.Length);
#endregion Snippet_4
}
{
#region Snippet_5
IFileSystem filesystem = FileSystem.Application;
IFileSystem overrides = new MemoryFileSystem();
IFileSystem composition = FileSystemExtensions.Concat(
(filesystem, null),
(overrides, Option.ReadOnly)
);
#endregion Snippet_5
}
}
public static void Main(string[] args)
{
{
#region Snippet_1
IFileSystem ram = new MemoryFileSystem();
ram.CreateDirectory("/tmp/");
ram.CreateDirectory("/mnt/");
ram.CreateDirectory("/usr/lex/");
ram.CreateDirectory("c:/dir/dir/");
ram.CreateFile("/tmp/helloworld.txt", Encoding.UTF8.GetBytes("Hello World!\r\n"));
ram.CreateDirectory("file://c:/temp/");
ram.PrintTo(Console.Out);
#endregion Snippet_1
#region Snippet_2
StringBuilder sb = new StringBuilder();
ram.PrintTo(sb);
#endregion Snippet_2
Console.WriteLine(sb);
#region Snippet_3
Console.WriteLine(ram.Print());
#endregion Snippet_3
#region Snippet_4
Console.WriteLine(ram.Print(depth: 1));
#endregion Snippet_4
#region Snippet_5
Console.WriteLine(ram.Print(path: "/tmp/"));
#endregion Snippet_5
#region Snippet_6
string tree = ram.Print(format: PrintTree.Format.Tree | PrintTree.Format.Path |
PrintTree.Format.Length | PrintTree.Format.Error);
#endregion Snippet_6
Console.WriteLine(tree);
}
{
#region Snippet_10
#endregion Snippet_10
}
{
#region Snippet_11
#endregion Snippet_11
}
{
#region Snippet_12
#endregion Snippet_12
}
}
private static async ValueTask <ISingletonFileSystem> TestFileSystem()
{
var fileSystem = new MemoryFileSystem(new NullFileEventService());
var root = await fileSystem.CreateFileHandle(Url.Parse("file://test/"));
var foo = await fileSystem.CreateDirectory(root, "foo");
var bar = await fileSystem.CreateDirectory(foo, "bar");
var dir = await fileSystem.CreateDirectory(bar, "dir");
await fileSystem.CreateFile(bar, "a", Convert.FromHexString("010203"));
await fileSystem.CreateFile(bar, "b", Convert.FromHexString("010203"));
await fileSystem.CreateFile(bar, "c", Convert.FromHexString("010203"));
await fileSystem.CreateFile(dir, "a", Convert.FromHexString("010203"));
await fileSystem.CreateFile(dir, "b", Convert.FromHexString("010203"));
return(fileSystem);
}
public void Initialize()
{
ram = new MemoryFileSystem();
ram.CreateDirectory("/tmp");
ram.CreateDirectory("/tmp/dir");
ram.CreateDirectory("/mnt");
ram.CreateDirectory("/usr/lex");
ram.CreateDirectory("c:/dir/dir");
ram.CreateFile("/tmp/helloworld.txt", HelloWorld);
ram.CreateFile("/tmp/helloworld_100.txt", HelloWorld_x100);
ram.CreateFile("/tmp/helloworld_10000.txt", HelloWorld_x10000);
ram.CreateDirectory("file://");
ram2 = new MemoryFileSystem();
ram2.CreateDirectory("/ram2");
ram2.CreateDirectory("/ram2/dir");
ram2.CreateFile("/ram2/dir/helloworld.txt", HelloWorld);
ram2.CreateFile("/ram2/dir/helloworld_100.txt", HelloWorld_x100);
ram2.CreateFile("/ram2/dir/helloworld_10000.txt", HelloWorld_x10000);
fs = ram.Concat(ram2);
fs.Observe("**", observer = new Observer());
observer.events.Clear();
}
public void GetEntry()
{
// Union of entries
{
MemoryFileSystem ram = new MemoryFileSystem();
MemoryFileSystem zip = new MemoryFileSystem();
ram.CreateFile("myfile.zip", new byte[1000]);
zip.CreateFile("content.txt", new byte[10000]);
VirtualFileSystem vfs = new VirtualFileSystem()
.Mount("", ram)
.Mount("myfile.zip", zip);
IEntry e = vfs.GetEntry("myfile.zip");
Assert.IsTrue(e.IsFile());
Assert.IsTrue(e.IsDirectory());
Assert.IsTrue(e.IsMountPoint());
Assert.AreEqual("myfile.zip/", e.Path);
}
}
public static void Main(string[] args)
{
{
#region Snippet_1
IFileSystem vfs = new VirtualFileSystem();
#endregion Snippet_1
}
{
#region Snippet_2a
IFileSystem vfs = new VirtualFileSystem()
.Mount("", FileSystem.OS);
#endregion Snippet_2a
}
{
#region Snippet_2b
IFileSystem urls = new VirtualFileSystem()
.Mount("tmp/", FileSystem.Temp)
.Mount("ram/", MemoryFileSystem.Instance);
#endregion Snippet_2b
}
{
#region Snippet_2c
IFileSystem vfs = new VirtualFileSystem()
.Mount("", FileSystem.OS)
.Mount("/tmp/", new MemoryFileSystem());
vfs.Browse("/tmp/");
#endregion Snippet_2c
}
{
#region Snippet_3a
IFileSystem vfs = new VirtualFileSystem();
vfs.Mount("/tmp/", FileSystem.Temp);
vfs.Unmount("/tmp/");
#endregion Snippet_3a
}
{
#region Snippet_3b
IFileSystem vfs = new VirtualFileSystem();
vfs.Mount("/tmp/", FileSystem.Temp);
vfs.Mount("/tmp/", new MemoryFileSystem());
#endregion Snippet_3b
}
{
#region Snippet_4a
IFileSystem vfs = new VirtualFileSystem();
vfs.Mount("/app/", FileSystem.Application, Option.ReadOnly);
#endregion Snippet_4a
}
{
#region Snippet_4b
IFileSystem vfs = new VirtualFileSystem();
IFileSystem overrides = new MemoryFileSystem();
overrides.CreateFile("important.dat", new byte[] { 12, 23, 45, 67, 89 });
vfs.Mount("/app/", overrides, FileSystem.Application);
#endregion Snippet_4b
}
{
#region Snippet_4c
IFileSystem overrides = new MemoryFileSystem();
IFileSystem vfs = new VirtualFileSystem();
vfs.Mount("/app/",
(overrides, Option.ReadOnly),
(FileSystem.Application, Option.ReadOnly)
);
#endregion Snippet_4c
}
{
#region Snippet_4d
IFileSystem vfs = new VirtualFileSystem();
string appDir = AppDomain.CurrentDomain.BaseDirectory.Replace('\\', '/');
vfs.Mount("/app/", FileSystem.OS, Option.SubPath(appDir));
#endregion Snippet_4d
}
{
#region Snippet_5a
IFileSystem vfs = new VirtualFileSystem();
vfs.Mount("/tmp/", filesystem: null);
#endregion Snippet_5a
vfs.PrintTo(Console.Out);
}
// Observing
{
#region Snippet_6a
IFileSystem vfs = new VirtualFileSystem();
vfs.Observe("**", new PrintObserver());
IFileSystem ram = new MemoryFileSystem();
ram.CreateDirectory("/dir/");
ram.CreateFile("/dir/file.txt", new byte[] { 32, 65, 66 });
vfs.Mount("", ram);
#endregion Snippet_6a
}
{
#region Snippet_6b
IFileSystem vfs = new VirtualFileSystem();
vfs.Observe("/dir/*.txt", new PrintObserver());
IFileSystem ram = new MemoryFileSystem();
ram.CreateDirectory("/dir/");
ram.CreateFile("/dir/file.txt", new byte[] { 32, 65, 66 });
ram.CreateFile("/dir/file.dat", new byte[] { 255, 255, 255 });
vfs.Mount("", ram);
#endregion Snippet_6b
#region Snippet_6c
vfs.Unmount("");
#endregion Snippet_6c
}
{
IFileSystem vfs = new VirtualFileSystem();
vfs.Observe("**", new PrintObserver());
IFileSystem ram = new MemoryFileSystem();
ram.CreateDirectory("/dir/");
ram.CreateFile("/dir/file.txt", new byte[] { 32, 65, 66 });
#region Snippet_6d
vfs.Mount("", ram, Option.NoObserve);
#endregion Snippet_6d
}
{
VirtualFileSystem vfs = new VirtualFileSystem();
#region Snippet_6e
IDisposable observerHandle = vfs.Observe("**", new PrintObserver());
observerHandle.Dispose();
#endregion Snippet_6e
vfs.Dispose();
}
{
#region Snippet_6f
VirtualFileSystem vfs = new VirtualFileSystem();
IDisposable observerHandle = vfs.Observe("**", new PrintObserver());
vfs.Dispose();
#endregion Snippet_6f
}
{
#region Snippet_10a
// Init
object obj = new ReaderWriterLockSlim();
IFileSystemDisposable vfs = new VirtualFileSystem().AddDisposable(obj);
// ... do work ...
// Dispose both
vfs.Dispose();
#endregion Snippet_10a
}
{
#region Snippet_10b
IFileSystemDisposable vfs = new VirtualFileSystem()
.AddDisposeAction(f => Console.WriteLine("Disposed"));
#endregion Snippet_10b
}
{
#region Snippet_10c
VirtualFileSystem vfs = new VirtualFileSystem().Mount("", FileSystem.OS);
vfs.Browse("");
// Postpone dispose
IDisposable belateDisposeHandle = vfs.BelateDispose();
// Start concurrent work
Task.Run(() =>
{
// Do work
Thread.Sleep(1000);
vfs.GetEntry("");
// Release belate handle. Disposes here or below, depending which thread runs last.
belateDisposeHandle.Dispose();
});
// Start dispose, but postpone it until belatehandle is disposed in another thread.
vfs.Dispose();
#endregion Snippet_10c
}
{
#region Snippet_10d
IFileSystemDisposable vfs =
new VirtualFileSystem()
.Mount("", new FileSystem(""))
.Mount("/tmp/", new MemoryFileSystem())
.AddMountsToBeDisposed();
#endregion Snippet_10d
vfs.Dispose();
}
{
#region Snippet_12a
#endregion Snippet_12a
#region Snippet_12b
VirtualFileSystem.Url.PrintTo(Console.Out, "config://", 2, PrintTree.Format.DefaultPath);
VirtualFileSystem.Url.PrintTo(Console.Out, "data://", 1, PrintTree.Format.DefaultPath);
VirtualFileSystem.Url.PrintTo(Console.Out, "program-data://", 1, PrintTree.Format.DefaultPath);
VirtualFileSystem.Url.PrintTo(Console.Out, "home://", 1, PrintTree.Format.DefaultPath);
VirtualFileSystem.Url.PrintTo(Console.Out, "https://github.com/tagcode/Lexical.FileSystem/tree/master/");
#endregion Snippet_12b
#region Snippet_12c
string config = "[Config]\nUser=ExampleUser\n";
VirtualFileSystem.Url.CreateDirectory("config://ApplicationName/");
VirtualFileSystem.Url.CreateFile("config://ApplicationName/config.ini", UTF8Encoding.UTF8.GetBytes(config));
#endregion Snippet_12c
#region Snippet_12d
byte[] cacheData = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
VirtualFileSystem.Url.CreateDirectory("data://ApplicationName/");
VirtualFileSystem.Url.CreateFile("data://ApplicationName/cache.db", cacheData);
#endregion Snippet_12d
#region Snippet_12e
string saveGame = "[Save]\nLocation=12.32N 43.43W\n";
VirtualFileSystem.Url.CreateDirectory("document://ApplicationName/");
VirtualFileSystem.Url.CreateFile("document://ApplicationName/save1.txt", UTF8Encoding.UTF8.GetBytes(saveGame));
#endregion Snippet_12e
#region Snippet_12f
byte[] programData = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
VirtualFileSystem.Url.CreateDirectory("program-data://ApplicationName/");
VirtualFileSystem.Url.CreateFile("program-data://ApplicationName/index.db", programData);
#endregion Snippet_12f
#region Snippet_12g
VirtualFileSystem.Url.PrintTo(Console.Out, "application://", format: PrintTree.Format.DefaultPath);
#endregion Snippet_12g
}
}
public static void Main(string[] args)
{/*
* {
#region Snippet_1
* // Get filesystem
* IFileSystem filesystem = FileSystem.OS;
*
* // Create scanner
* FileScanner filescanner = new FileScanner(filesystem)
* .AddWildcard("c:/Windows/System32/**.dll")
* .SetReturnDirectories(true)
* .SetDirectoryEvaluator(dir => true);
*
* // Scan files
* foreach (var entry in filescanner)
* {
* Console.WriteLine(entry.Path);
* }
#endregion Snippet_1
* }
*/
{
#region Snippet_1a
IFileSystem fs = new MemoryFileSystem();
fs.CreateDirectory("myfile.zip/folder");
fs.CreateFile("myfile.zip/folder/somefile.txt");
FileScanner filescanner = new FileScanner(fs);
#endregion Snippet_1a
#region Snippet_1b
filescanner.AddWildcard("*.zip");
#endregion Snippet_1b
#region Snippet_1c
filescanner.AddRegex(path: "", pattern: new Regex(@".*\.zip"));
#endregion Snippet_1c
#region Snippet_1d
filescanner.AddGlobPattern("**.zip/**.txt");
#endregion Snippet_1d
#region Snippet_1d2
filescanner.AddGlobPattern("myfile.zip/**.txt");
#endregion Snippet_1d2
#region Snippet_1e
foreach (IEntry entry in filescanner)
{
Console.WriteLine(entry.Path);
}
#endregion Snippet_1e
#region Snippet_1f
// Collect errors
filescanner.errors = new ConcurrentBag <Exception>();
// Run scan
IEntry[] entries = filescanner.ToArray();
// View errors
foreach (Exception e in filescanner.errors)
{
Console.WriteLine(e);
}
#endregion Snippet_1f
#region Snippet_1g
filescanner.ReturnDirectories = true;
#endregion Snippet_1g
#region Snippet_1h
filescanner.SetDirectoryEvaluator(e => e.Name != "tmp");
#endregion Snippet_1h
}
{
#region Snippet_10a
Regex globPattern = new GlobPatternRegex("**/*.dll/**.resources", "/");
#endregion Snippet_10a
#region Snippet_10b
string[] files = new[]
{
"somefile.zip",
"somefile.zip/somefile.ext",
"somefile.zip/somefile.ext/someresource",
"somefile.zip/somelib.dll",
"somefile.zip/somelib.dll/someresource.resources",
"somelib.dll",
"somelib.dll/someresource.resources",
};
foreach (string filename in files.Where(fn => globPattern.IsMatch(fn)))
{
Console.WriteLine(filename);
}
#endregion Snippet_10b
}
}
public static void Main(string[] args)
{
{
#region Snippet_1a
IFileSystem ram = new MemoryFileSystem();
IFileSystem rom = ram.Decorate(Option.ReadOnly);
#endregion Snippet_1a
}
{
IFileSystem ram = new MemoryFileSystem();
#region Snippet_1b
IFileSystem rom = ram.AsReadOnly();
#endregion Snippet_1b
}
{
IFileSystem ram = new MemoryFileSystem();
#region Snippet_2a
IFileSystem invisible = ram.Decorate(Option.NoOpen);
#endregion Snippet_2a
}
{
IFileSystem ram = new MemoryFileSystem();
#region Snippet_2b
IFileSystem invisible = ram.Decorate(Option.NoBrowse);
#endregion Snippet_2b
}
{
#region Snippet_3
IFileSystem ram = new MemoryFileSystem();
ram.CreateDirectory("tmp/dir/");
ram.CreateFile("tmp/dir/file.txt", new byte[] { 32, 32, 32, 32, 32, 32, 32, 32, 32 });
IFileSystem tmp = ram.Decorate(Option.SubPath("tmp/"));
tmp.PrintTo(Console.Out, format: PrintTree.Format.DefaultPath);
#endregion Snippet_3
}
{
#region Snippet_4a
MemoryFileSystem ram = new MemoryFileSystem();
IFileSystemDisposable rom = ram.Decorate(Option.ReadOnly).AddSourceToBeDisposed();
// Do work ...
rom.Dispose();
#endregion Snippet_4a
}
{
#region Snippet_4b
MemoryFileSystem ram = new MemoryFileSystem();
ram.CreateDirectory("tmp/dir/");
ram.CreateFile("tmp/dir/file.txt", new byte[] { 32, 32, 32, 32, 32, 32, 32, 32, 32 });
IFileSystemDisposable rom = ram.Decorate(Option.ReadOnly).AddDisposable(ram);
// Do work ...
rom.Dispose();
#endregion Snippet_4b
}
{
#region Snippet_4c
// Create ram filesystem
MemoryFileSystem ram = new MemoryFileSystem();
ram.CreateDirectory("tmp/dir/");
ram.CreateFile("tmp/dir/file.txt", new byte[] { 32, 32, 32, 32, 32, 32, 32, 32, 32 });
// Create decorations
IFileSystemDisposable rom = ram.Decorate(Option.ReadOnly).AddDisposable(ram.BelateDispose());
IFileSystemDisposable tmp = ram.Decorate(Option.SubPath("tmp/")).AddDisposable(ram.BelateDispose());
ram.Dispose(); // <- is actually postponed
// Do work ...
// Dispose rom1 and tmp, disposes ram as well
rom.Dispose();
tmp.Dispose();
#endregion Snippet_4c
}
}
public static void Main(string[] args)
{
{
// <Snippet_1>
IFileSystem ms = new MemoryFileSystem();
ms.CreateFile("file", new byte[1024 * 1024]);
using (var s = new OperationSession())
{
new CopyFile(s, ms, "file", ms, "file.copy")
.Estimate()
.AssertCanRollback()
.Run()
.AssertSuccessful();
}
// </Snippet_1>
ms.PrintTo(Console.Out, format: PrintTree.Format.Default | PrintTree.Format.Length);
}
{
IFileSystem ms = new MemoryFileSystem();
ms.CreateFile("file", new byte[1024 * 1024]);
// <Snippet_1b>
var s = new OperationSession();
var op = new CopyFile(s, ms, "file", ms, "file.copy");
op.Estimate();
// </Snippet_1b>
// <Snippet_1b1>
Console.WriteLine(op.CanRollback);
// </Snippet_1b1>
// <Snippet_1b2>
op.Estimate().AssertCanRollback();
// </Snippet_1b2>
// <Snippet_1c>
op.Run();
// </Snippet_1c>
// <Snippet_1c1>
if (op.CurrentState == OperationState.Completed)
{
Console.WriteLine("ok");
}
// </Snippet_1c1>
ms.Delete("file.copy");
op = (CopyFile) new CopyFile(s, ms, "file", ms, "file.copy").Estimate();
// <Snippet_1c2>
op.Run().AssertSuccessful();
// </Snippet_1c2>
ms.Delete("file.copy");
op = (CopyFile) new CopyFile(s, ms, "file", ms, "file.copy").Estimate();
// <Snippet_1c3>
try
{
op.Run();
}
catch (Exception)
{
// Rollback
op.CreateRollback()?.Run();
}
// </Snippet_1c3>
// <Snippet_1c4>
op.Run(rollbackOnError: true);
// </Snippet_1c4>
}
{
// <Snippet_2>
IFileSystem ms = new MemoryFileSystem();
ms.CreateDirectory("dir/dir/dir/");
ms.CreateFile("dir/dir/dir/file", new byte[1024 * 1024]);
using (var s = new OperationSession())
{
var op = new CopyTree(s, ms, "dir", ms, "dir.copy");
op.Estimate().AssertCanRollback().Run().AssertSuccessful();
}
// </Snippet_2>
ms.PrintTo(Console.Out);
}
{
// <Snippet_3>
IFileSystem ms = new MemoryFileSystem();
using (var s = new OperationSession(policy: OperationPolicy.EstimateOnRun /*important*/))
{
Batch batch = new Batch(s, OperationPolicy.Unset);
batch.Ops.Add(new CreateDirectory(s, ms, "dir/dir/dir"));
batch.Ops.Add(new CopyTree(s, ms, "dir", ms, "dir.copy"));
batch.Ops.Add(new Delete(s, ms, "dir/dir", true, policy: OperationPolicy.EstimateOnRun));
batch.Estimate().Run().AssertSuccessful();
}
// </Snippet_3>
ms.PrintTo(Console.Out);
}
{
// <Snippet_4>
IFileSystem ms_src = new MemoryFileSystem();
ms_src.CreateDirectory("dir/dir/dir/");
ms_src.CreateFile("dir/dir/dir/file", new byte[1024 * 1024]);
IFileSystem ms_dst = new MemoryFileSystem();
using (var s = new OperationSession())
{
var op = new TransferTree(s, ms_src, "dir", ms_dst, "dir.elsewhere");
op.Estimate().AssertCanRollback().Run().AssertSuccessful();
}
// </Snippet_4>
ms_dst.PrintTo(Console.Out);
}
{
// <Snippet_5>
IFileSystem ms = new MemoryFileSystem();
ms.CreateFile("file", new byte[1024 * 1024]);
using (var s = new OperationSession())
{
new CopyFile(s, ms, "file", ms, "file.copy")
.Estimate()
.AssertCanRollback()
.Run()
.AssertSuccessful();
foreach (var @event in s.Events)
{
Console.WriteLine(@event);
}
}
ms.PrintTo(Console.Out);
// </Snippet_5>
}
{
// <Snippet_6>
IFileSystem ms = new MemoryFileSystem();
ms.CreateFile("file", new byte[1024 * 20]);
using (var s = new OperationSession().SetProgressInterval(1024))
{
s.Subscribe(new OpEventPrinter());
new CopyFile(s, ms, "file", ms, "file.copy")
.Estimate()
.AssertCanRollback()
.Run()
.AssertSuccessful();
}
ms.PrintTo(Console.Out);
// </Snippet_6>
}
{
try
{
// <Snippet_7>
IFileSystem ms = new MemoryFileSystem();
ms.CreateFile("file", new byte[1024 * 10]);
CancellationTokenSource cancelSrc = new CancellationTokenSource();
using (var s = new OperationSession(cancelSrc: cancelSrc))
{
cancelSrc.Cancel();
new Move(s, ms, "file", ms, "file.moved")
.Estimate()
.AssertCanRollback()
.Run()
.AssertSuccessful();
}
// </Snippet_7>
} catch (Exception e)
{
}
}
{
// <Snippet_8>
// </Snippet_8>
}
{
// <Snippet_9>
// </Snippet_9>
}
{
// <Snippet_10>
// </Snippet_10>
}
{
// <Snippet_11>
// </Snippet_11>
}
{
// <Snippet_12>
// </Snippet_12>
}
{
// <Snippet_13>
// </Snippet_13>
}
{
// <Snippet_14>
// </Snippet_14>
}
{
// <Snippet_15>
// </Snippet_15>
}
{
// <Snippet_16>
// </Snippet_16>
}
}
public static void Main(string[] args)
{
{
#region Snippet_1
IFileSystem filesystem = new MemoryFileSystem();
#endregion Snippet_1
}
{
#region Snippet_1b
IFileSystem filesystem = new MemoryFileSystem(blockSize: 4096);
#endregion Snippet_1b
}
{
IFileSystem filesystem = new MemoryFileSystem();
#region Snippet_2
foreach (var entry in filesystem.Browse(""))
{
Console.WriteLine(entry.Path);
}
#endregion Snippet_2
}
{
IFileSystem filesystem = new MemoryFileSystem();
filesystem.CreateFile("file.txt");
#region Snippet_3a
using (Stream s = filesystem.Open("file.txt", FileMode.Open, FileAccess.Read, FileShare.Read))
{
Console.WriteLine(s.Length);
}
#endregion Snippet_3a
}
{
IFileSystem filesystem = new MemoryFileSystem();
filesystem.CreateFile("file.txt");
#region Snippet_3b
using (Stream s = filesystem.Open("file.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite))
{
s.WriteByte(32);
}
#endregion Snippet_3b
}
{
IFileSystem filesystem = new MemoryFileSystem();
#region Snippet_4
IObserver <IEvent> observer = new Observer();
using (IDisposable handle = filesystem.Observe("**", observer))
{
}
#endregion Snippet_4
}
{
IFileSystem filesystem = new MemoryFileSystem();
#region Snippet_5
filesystem.CreateDirectory("dir/");
#endregion Snippet_5
}
{
IFileSystem filesystem = new MemoryFileSystem();
#region Snippet_5a
filesystem.CreateDirectory("dir1/dir2/dir3/");
filesystem.PrintTo(Console.Out);
#endregion Snippet_5a
}
{
IFileSystem filesystem = new MemoryFileSystem();
#region Snippet_5b
filesystem.CreateDirectory("/tmp/dir/");
#endregion Snippet_5b
filesystem.PrintTo(Console.Out);
}
{
IFileSystem filesystem = new MemoryFileSystem();
#region Snippet_5c
filesystem.CreateDirectory("/tmp/dir/");
#endregion Snippet_5c
filesystem.PrintTo(Console.Out);
}
{
IFileSystem filesystem = new MemoryFileSystem();
#region Snippet_5d
filesystem.CreateDirectory("file://");
#endregion Snippet_5d
filesystem.PrintTo(Console.Out);
}
{
IFileSystem filesystem = new MemoryFileSystem();
filesystem.CreateDirectory("dir/");
#region Snippet_6
filesystem.Delete("dir/", recurse: true);
#endregion Snippet_6
}
{
IFileSystem filesystem = new MemoryFileSystem();
filesystem.CreateDirectory("dir/");
#region Snippet_7
filesystem.CreateDirectory("dir/");
filesystem.Move("dir/", "new-name/");
#endregion Snippet_7
filesystem.Delete("new-name/");
}
{
#region Snippet_8a
IFileSystem filesystem = new MemoryFileSystem();
#endregion Snippet_8a
foreach (var entry in filesystem.Browse(""))
{
Console.WriteLine(entry.Path);
}
}
{
#region Snippet_8b
#endregion Snippet_8b
}
{
#region Snippet_10a
// Init
object obj = new ReaderWriterLockSlim();
IFileSystemDisposable filesystem = new FileSystem("").AddDisposable(obj);
// ... do work ...
// Dispose both
filesystem.Dispose();
#endregion Snippet_10a
}
{
#region Snippet_10b
IFileSystemDisposable filesystem = new FileSystem("")
.AddDisposeAction(f => Console.WriteLine("Disposed"));
#endregion Snippet_10b
}
{
#region Snippet_10c
MemoryFileSystem filesystem = new MemoryFileSystem();
filesystem.CreateDirectory("/tmp/dir/");
// Postpone dispose
IDisposable belateDisposeHandle = filesystem.BelateDispose();
// Start concurrent work
Task.Run(() =>
{
// Do work
Thread.Sleep(1000);
filesystem.GetEntry("");
// Release belate handle. Disposes here or below, depending which thread runs last.
belateDisposeHandle.Dispose();
});
// Start dispose, but postpone it until belatehandle is disposed in another thread.
filesystem.Dispose();
#endregion Snippet_10c
}
{
// <Snippet_20a>
IFileSystem ms = new MemoryFileSystem(blockSize: 1024, maxSpace: 1L << 34);
// </Snippet_20a>
}
{
// <Snippet_20b>
IFileSystem ms = new MemoryFileSystem(blockSize: 1024, maxSpace: 1L << 34);
ms.CreateFile("file", new byte[1 << 30]);
ms.PrintTo(Console.Out, format: PrintTree.Format.AllWithName);
// </Snippet_20b>
}
{
try
{
// <Snippet_20c>
IFileSystem ms = new MemoryFileSystem(blockSize: 1024, maxSpace: 2048);
ms.CreateFile("file1", new byte[1024]);
ms.CreateFile("file2", new byte[1024]);
// throws FileSystemExceptionOutOfDiskSpace
ms.CreateFile("file3", new byte[1024]);
// </Snippet_20c>
}
catch (FileSystemExceptionOutOfDiskSpace) { }
}
{
try
{
// <Snippet_20d>
IBlockPool pool = new BlockPool(blockSize: 1024, maxBlockCount: 3, maxRecycleQueue: 3);
IFileSystem ms1 = new MemoryFileSystem(pool);
IFileSystem ms2 = new MemoryFileSystem(pool);
// Reserve 2048 from shared pool
ms1.CreateFile("file1", new byte[2048]);
// Not enough for another 3072, throws FileSystemExceptionOutOfDiskSpace
ms2.CreateFile("file2", new byte[2048]);
// </Snippet_20d>
}
catch (FileSystemExceptionOutOfDiskSpace) { }
}
{
try
{
// <Snippet_20e>
IBlockPool pool = new BlockPool(blockSize: 1024, maxBlockCount: 3, maxRecycleQueue: 3);
IFileSystem ms = new MemoryFileSystem(pool);
Stream s = ms.Open("file", FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);
s.Write(new byte[3072], 0, 3072);
ms.Delete("file");
Console.WriteLine(pool.BytesAvailable); // Prints 0
s.Dispose();
Console.WriteLine(pool.BytesAvailable); // Prints 3072
// </Snippet_20e>
}
catch (FileSystemExceptionOutOfDiskSpace) { }
}
}
