Is it possible to bypass a file lock in C# when another thread/process is unecessarily using an exclusive lock?

Question

Is there a way to bypass or remove the file lock held by another thread without killing the thread?

I am using a third-party library in my app that is performing

Answer 1

This doesn't address your situation directly, but a tool like Unlocker acheieves what you're trying to do, but via a Windows UI.

Answer 2

Any low level hack to do this may result in a thread crashing, file corruption or etc.

Hence I thought I'd mention the next best thing, just wait your turn and poll until the file is not locked: https://stackoverflow.com/a/11060322/495455

---

I dont think this 2nd advice will help but the closest thing (that I know of) would be DemandReadFileIO:

IntSecurity.DemandReadFileIO(filename);

internal static void DemandReadFileIO(string fileName) 
{
   string full = fileName;            
   full = UnsafeGetFullPath(fileName); 
   new FileIOPermission(FileIOPermissionAccess.Read, full).Demand();
}

Answer 3

If the file is locked and isn't being used, then you have a problem with the way your file locking/unlocking mechanism works. You should only lock a file when you are modifying it, and should then immediately unlock it to avoid situations like this.

Answer 4

In short, you cannot do anything about the locking of the file by a third-party. You can get away with Richard E's answer above that mentions the utility Unlocker.

Once the third-party opens a file and sets the lock on it, the underlying system will give that third-party a lock to ensure no other process can access it. There are two trains of thought on this.

• Using DLL injection to patch up the code to explicitly set the lock or unset it. This can be dangerous as you would be messing with another process's stability, and possibly end up crashing the process and rendering grief. Think about it, the underlying system is keeping track of files opened by a process..DLL injection at the point and patch up the code - this requires technical knowledge to determine which process you want to inject into at run-time and alter the flags upon interception of the Win32 API call OpenFile(...).
• Since this was tagged as .NET, why not disassemble the source of the third-party into .il files, and alter the flag for the lock to shared, rebuild the library by recompiling all .il files back together into a DLL. This of course, would require to root around the code where the opening of the file is taking place in some class somewhere.

Have a look at the podcast here. And have a look here that explains how to do the second option highlighted above, here.

Hope this helps, Best regards, Tom.

Answer 5

Have you tried making a dummy copy of the file before your third-party library gets a hold of it... then using the actual copy for your manipulations, logically this would only be considered if the file we are talking about is fairly small. but it is a kind of a cheat :) good luck

Answer 6

If you start messing with the underlying file handle you may be able to unlock portions, the trouble is that the thread accessing the file is not designed to handle this kind of tampering and may end up crashing.

My strong recommendation would be to patch the third party library, anything you do can and probably will blow up in real world conditions.