It would be nice is SafeHFILE and SafeHCFFILE were more compatible

[catmanjan]

I'm trying to build an abstraction where a function can return a handle from either createfile or cfopenfilewithoplock, e.g.

        public static HFILE GetHandle(string filePath)
        {
            if (File.Exists(filePath))
            {
                return Kernel32.CreateFile(filePath, 0, 0, dwCreationDisposition: FileMode.Open, dwFlagsAndAttributes: FileFlagsAndAttributes.FILE_ATTRIBUTE_NORMAL);
            }
            else if (Directory.Exists(filePath))
            {
                CfOpenFileWithOplock(filePath, CF_OPEN_FILE_FLAGS.CF_OPEN_FILE_FLAG_NONE, out var protectedHandle);

                return protectedHandle;
            }

            return HFILE.INVALID_HANDLE_VALUE;
        }

Both of these functions return safe___ file objects, so if it were possible to change the return type of the function to be a common type I could then dispose of it more neatly

[catmanjan]

I just discovered SafeHANDLE, but it looks like its not compatible with the rest of cloud api

[dahall]

Would explicit conversion operators between the two work? If so, would you want the newly converted value to hold the disposable value or let the old value hold it? Only one could. My thinking is the new one is likely to stay in scope so it should.

[catmanjan]

@dahall I'm really not sure, I've now done this:

        public static SafeHANDLE GetHandle(string filePath)
        {
            if (File.Exists(filePath))
            {
                return Kernel32.CreateFile(filePath, 0, 0, dwCreationDisposition: FileMode.Open, dwFlagsAndAttributes: FileFlagsAndAttributes.FILE_ATTRIBUTE_NORMAL);
            }
            else if (Directory.Exists(filePath))
            {
                CfOpenFileWithOplock(filePath, CF_OPEN_FILE_FLAGS.CF_OPEN_FILE_FLAG_NONE, out var protectedHandle).ThrowIfFailed();

                return protectedHandle;
            }

            throw new Exception("File or directory does not exist");
        }

and then when consuming the SafeHANDLE I've gone back to having to use DangerousGetHandle()

e.g.

var handle = CloudFilterHelpers.GetHandle(filePath);

using (handle)
{
    var placeholderInfo = CfGetPlaceholderInfo<CF_PLACEHOLDER_STANDARD_INFO>(handle.DangerousGetHandle());
}

Perhaps just adding an implicit operator for SafeHANDLE to HFILE would suffice as you previously did for me for SafeHCFFILE?

[catmanjan]

the only thing I don't like is having to throw an exception rather than returning a safehandle to an invalid file handle (couldnt work out how to do this)

[dahall]

Both SafeHFILE and SafeHCFFILE support the IHandle interface. Could you use that? Each supports a different disposal method, so my earlier idea doesn't work.

[catmanjan]

@dahall I think I'd need an ISafeHandle because IHandle isn't IDisposable, being able to call using on the object is very convenient

[dahall]

I think you can. Something like this should work:

IHandle h = CloudFilterHelpers.GetHandle(filePath);
// do stuff
(h as IDisposable)?.Dispose();

[catmanjan]

Yes that works, but I lose the convenience of using, I have a lot of scoped disposal, having to call dispose explicitly is quite a bit messier :(

[dahall]

Is letting it go out of scope and waiting for garbage disposal a problem?

[catmanjan]

let me do some testing and get back to you on that

[dahall]

What functions can use either handle? From what I read, HCFFILE isn't even a real handle and can only be used with Cloud Filter API methods. Is that right? If so, then type safety shouldn't allow interchangeability.

[catmanjan]

It seems that is only true when you are using cloud filter oplocks, I was surprised too - cloud filter API actually works better without oplocks on files (folders still require oplocks) if you are the cloud provider and handle the concurrency control elsewhere

[catmanjan]

The cloud filter API documentation is very misleading, it seems to imply that you must use oplocks, when in fact you only need to use them in specific scenarios where you are trying to guarantee what is on disk