C# - Lock file until browser is closed, user navigates away from page, or session expires

Question

Is there any way to lock a file until a browser is closed, the user leaves the current page, or their session expires?

I have a java app that reads annotations from a text file and lets a user modify or add more annotations to a pdf through the java app. Once they do, they click 'save' and the full annotation file is returned to it's original data file.

The issue is that 2 people can open the same annotation file and perform different updates. Then, when each saves, they overwrite the existing file so that only the 2nd user's changes are saved.

The ideal solution is to let 1 person 'check-out' the file for edit, make their modifications until either they close the window, navigate away from the page, or their session expires, then the file would automatically 'check-in'. Any way of doing this in C#? Thanks!

Answer 1

You can use my library for accessing files from multiple apps.

You can install it from nuget: Install-Package Xabe.FileLock

If you want more information about it check https://github.com/tomaszzmuda/Xabe.FileLock

ILock fileLock = new FileLock(file);
if(fileLock.Acquire(TimeSpan.FromSeconds(15), true))
{
    using(fileLock)
    {
        // file operations here
    }
}

fileLock.Acquire method will return true only if can lock file exclusive for this object. But app which uploading file must do it in file lock too. If object is inaccessible metod returns false.

So if you want use it, you create lock when first user open file to edit and dispose it after session expired or user change page.

Answer 2

Well is there is no simple built in way to do this , what you can do is create a {username}.lock file in the same folder as the annotations folder. Then before you read or save check if there is a .lock file in the directory.

If there is a file tell the user its been locked and can not be updated. Obviously you need to make sure that you delete the .lock file otherwise after first access no one will ever be able to access the annotations file.

Answer 3

You could put your lock code in the Session_Start and your release code in the Session_End methods of the Global.asax file. However, trying to determine when the user has really left the session in order to trigger these events without waiting on the Session timeout is difficult to detect but it can be done via AJAX and some Javascript.

Example

protected void Application_Start()
{
    Application("AnnotationFileLocked") = False;
}
...

protected void Session_End()
{
    if ((bool)Application("AnnotationFileLocked"))
    {
         // Session("UserName") could be set on Login
         if ((string)Application("AnnotationFileLockedBy") == (string)Session("UserName"))
         {
             Application("AnnotationFileLocked") = False;
             Application.Remove("AnnotationFileLockedBy");
         }
    }
}

Then wherever in your code you check out the file:

public void CheckOutFile()
{
    if (!(bool)Application("AnnotationFileLocked"))
    {
        Application("AnnotationFileLocked") = True
        Application("AnnotationFileLockedBy") = (string)Session("UserName");
        // do stuff
    }
}

Answer 4

If two users being able to edit is the way the app works, does it not maybe make more sense to take a temporary copy of the file per user for editing?

Answer 5

There is really no good way to do locks like that. Though you can put code into Session_End to clean up the locks, that event is not guaranteed to fire. For instance, the server might crash during a session. You'd be left with a permanently locked file.

Since you want simplicity, you might consider using timeout-based locking. When user A starts editing the file, they get exclusive access to it for 60 minutes (or whatever span you choose). You put an entry in your data store, saying the most recent edit lock is for user A and expires at 12:42pm. User A can edit as much as he likes in that time. If he's done earlier, he can click a "finished" button that removes the lock entry. You might even give him a "more time" button that updates the lock-expiry timestamp to 60 minutes from now.

If user B comes along and tries to edit the file, your app checks the list and sees that this file is locked until 12:42pm today. If user A goes away and never finishes, or saves and forgets to unlock, or if the app crashes, you don't need to worry about unlocking or cleaning up. User B just has to wait around until past 12:42, and then your app will ignore the existing lock entry because it's expired.

A lot of wikis use a method similar to this. It may not be perfect, but it's easy for users to understand, and doesn't require any operator maintenance.