Instant control over file and folder operations in Windows and .NET applications

Operation Contexts

Contexts is a placeholder for application-defined data. The data, placed to Context, is not used by CallbackFilter in any way.

Why are Contexts useful?
Contexts can be used to store information about the file or directory, and this information can be re-used later to speed-up subsequent operations.
For example, if you open some file on the file system, you can place file handle to Context. Next, when the application handles OnReadFileC callback, it can use this handle instead of the file name. This speeds-up the operation, because there is no need to search some hash tables for a handle of the file.

For file operations contexts live from file open to file close calls. Contexts are stored with other information, related to opened file. For directory enumeration contexts live from the call to OnEnumerateDirectory to the call to OnCloseEnumeration.
Contexts are local to the process in which they were created. They can't be passed to other processes.

Use of Contexts in VCL and C++/Lib API is quite straightforward - you just put pointers to Context.

With .NET API the situation is more complicated, as .NET uses garbage collection and improper typecasting can cause problems with object lifetime. To avoid this problem, we declared Contexts to be IntPtr. If you want to store the reference to the object in Context, you use GCHandle as follows (C# syntax):

Stream stream; // the object we put to Context
GCHandle ctx = GCHandle.Alloc(stream);
Context = (IntPtr) ctx;
To access the stream from Context, use the following code:
GCHandle ctx = (GCHandle) Context;
Stream stream = (Stream ) ctx.Target; // the object we get from Context

To store numbers or other types, that are not objects, use "boxing" (.NET concept, when a value type is "packed" into an object).

Back to top