Có cách nào để kiểm tra nếu một tập tin đang được sử dụng?

Tôi đang viết một chương trình bằng C # cần liên tục truy cập 1 tệp hình ảnh. Hầu hết thời gian nó hoạt động, nhưng nếu máy tính của tôi chạy nhanh, nó sẽ cố truy cập tệp trước khi nó được lưu lại vào hệ thống tệp và đưa ra lỗi: "Tệp được sử dụng bởi một quy trình khác" .

Tôi muốn tìm cách khắc phục điều này, nhưng tất cả Google của tôi chỉ mang lại việc tạo séc bằng cách sử dụng xử lý ngoại lệ. Điều này là trái với tôn giáo của tôi, vì vậy tôi đã tự hỏi nếu có ai có cách làm tốt hơn?

LƯU Ý đã cập nhật về giải pháp này : Việc kiểm tra với FileAccess.ReadWritesẽ thất bại đối với các tệp Chỉ đọc để giải pháp đã được sửa đổi để kiểm tra FileAccess.Read. Mặc dù giải pháp này hoạt động vì cố gắng kiểm tra FileAccess.Readsẽ thất bại nếu tệp có khóa Ghi hoặc Đọc trên đó, tuy nhiên, giải pháp này sẽ không hoạt động nếu tệp không có khóa Ghi hoặc Đọc trên đó, tức là nó đã được mở (để đọc hoặc viết) với quyền truy cập FileShare.Read hoặc FileShare.Write.

NGUỒN GỐC: Tôi đã sử dụng mã này trong nhiều năm qua và tôi không gặp vấn đề gì với nó.

Hiểu được sự do dự của bạn về việc sử dụng ngoại lệ, nhưng bạn không thể tránh chúng mọi lúc:

protected virtual bool IsFileLocked(FileInfo file)
{
    try
    {
        using(FileStream stream = file.Open(FileMode.Open, FileAccess.Read, FileShare.None))
        {
            stream.Close();
        }
    }
    catch (IOException)
    {
        //the file is unavailable because it is:
        //still being written to
        //or being processed by another thread
        //or does not exist (has already been processed)
        return true;
    }

    //file is not locked
    return false;
}

Bạn có thể bị một điều kiện chạy đua về vấn đề này, trong đó có các ví dụ được chứng minh về việc này đang được sử dụng như một lỗ hổng bảo mật. Nếu bạn kiểm tra xem tệp có sẵn không, nhưng sau đó thử và sử dụng nó, bạn có thể ném vào thời điểm đó, một người dùng độc hại có thể sử dụng để ép buộc và khai thác mã của bạn.

Đặt cược tốt nhất của bạn là thử bắt / cuối cùng cố gắng xử lý tệp.

try
{
   using (Stream stream = new FileStream("MyFilename.txt", FileMode.Open))
   {
        // File/Stream manipulating code here
   }
} catch {
  //check here why it failed and ask user to retry if the file is in use.
}

Sử dụng điều này để kiểm tra nếu một tập tin bị khóa:

using System.IO;
using System.Runtime.InteropServices;
internal static class Helper
{
const int ERROR_SHARING_VIOLATION = 32;
const int ERROR_LOCK_VIOLATION = 33;

private static bool IsFileLocked(Exception exception)
{
    int errorCode = Marshal.GetHRForException(exception) & ((1 << 16) - 1);
    return errorCode == ERROR_SHARING_VIOLATION || errorCode == ERROR_LOCK_VIOLATION;
}

internal static bool CanReadFile(string filePath)
{
    //Try-Catch so we dont crash the program and can check the exception
    try {
        //The "using" is important because FileStream implements IDisposable and
        //"using" will avoid a heap exhaustion situation when too many handles  
        //are left undisposed.
        using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None)) {
            if (fileStream != null) fileStream.Close();  //This line is me being overly cautious, fileStream will never be null unless an exception occurs... and I know the "using" does it but its helpful to be explicit - especially when we encounter errors - at least for me anyway!
        }
    }
    catch (IOException ex) {
        //THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
        if (IsFileLocked(ex)) {
            // do something, eg File.Copy or present the user with a MsgBox - I do not recommend Killing the process that is locking the file
            return false;
        }
    }
    finally
    { }
    return true;
}
}

Vì lý do hiệu suất, tôi khuyên bạn nên đọc nội dung tệp trong cùng một thao tác. Dưới đây là một số ví dụ:

public static byte[] ReadFileBytes(string filePath)
{
    byte[] buffer = null;
    try
    {
        using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
        {
            int length = (int)fileStream.Length;  // get file length
            buffer = new byte[length];            // create buffer
            int count;                            // actual number of bytes read
            int sum = 0;                          // total number of bytes read

            // read until Read method returns 0 (end of the stream has been reached)
            while ((count = fileStream.Read(buffer, sum, length - sum)) > 0)
                sum += count;  // sum is a buffer offset for next reading

            fileStream.Close(); //This is not needed, just me being paranoid and explicitly releasing resources ASAP
        }
    }
    catch (IOException ex)
    {
        //THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
        if (IsFileLocked(ex))
        {
            // do something? 
        }
    }
    catch (Exception ex)
    {
    }
    finally
    {
    }
    return buffer;
}

public static string ReadFileTextWithEncoding(string filePath)
{
    string fileContents = string.Empty;
    byte[] buffer;
    try
    {
        using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
        {
            int length = (int)fileStream.Length;  // get file length
            buffer = new byte[length];            // create buffer
            int count;                            // actual number of bytes read
            int sum = 0;                          // total number of bytes read

            // read until Read method returns 0 (end of the stream has been reached)
            while ((count = fileStream.Read(buffer, sum, length - sum)) > 0)
            {
                sum += count;  // sum is a buffer offset for next reading
            }

            fileStream.Close(); //Again - this is not needed, just me being paranoid and explicitly releasing resources ASAP

            //Depending on the encoding you wish to use - I'll leave that up to you
            fileContents = System.Text.Encoding.Default.GetString(buffer);
        }
    }
    catch (IOException ex)
    {
        //THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
        if (IsFileLocked(ex))
        {
            // do something? 
        }
    }
    catch (Exception ex)
    {
    }
    finally
    { }     
    return fileContents;
}

public static string ReadFileTextNoEncoding(string filePath)
{
    string fileContents = string.Empty;
    byte[] buffer;
    try
    {
        using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
        {
            int length = (int)fileStream.Length;  // get file length
            buffer = new byte[length];            // create buffer
            int count;                            // actual number of bytes read
            int sum = 0;                          // total number of bytes read

            // read until Read method returns 0 (end of the stream has been reached)
            while ((count = fileStream.Read(buffer, sum, length - sum)) > 0) 
            {
                sum += count;  // sum is a buffer offset for next reading
            }

            fileStream.Close(); //Again - this is not needed, just me being paranoid and explicitly releasing resources ASAP

            char[] chars = new char[buffer.Length / sizeof(char) + 1];
            System.Buffer.BlockCopy(buffer, 0, chars, 0, buffer.Length);
            fileContents = new string(chars);
        }
    }
    catch (IOException ex)
    {
        //THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
        if (IsFileLocked(ex))
        {
            // do something? 
        }
    }
    catch (Exception ex)
    {
    }
    finally
    {
    }

    return fileContents;
}

Hãy tự mình thử:

byte[] output1 = Helper.ReadFileBytes(@"c:\temp\test.txt");
string output2 = Helper.ReadFileTextWithEncoding(@"c:\temp\test.txt");
string output3 = Helper.ReadFileTextNoEncoding(@"c:\temp\test.txt");

Chỉ cần sử dụng ngoại lệ như dự định. Chấp nhận rằng tệp đang được sử dụng và thử lại, lặp đi lặp lại cho đến khi hành động của bạn được hoàn thành. Đây cũng là cách hiệu quả nhất vì bạn không lãng phí bất kỳ chu kỳ nào kiểm tra trạng thái trước khi hành động.

Sử dụng chức năng dưới đây, ví dụ

TimeoutFileAction(() => { System.IO.File.etc...; return null; } );

Phương pháp tái sử dụng hết thời gian sau 2 giây

private T TimeoutFileAction<T>(Func<T> func)
{
    var started = DateTime.UtcNow;
    while ((DateTime.UtcNow - started).TotalMilliseconds < 2000)
    {
        try
        {
            return func();                    
        }
        catch (System.IO.IOException exception)
        {
            //ignore, or log somewhere if you want to
        }
    }
    return default(T);
}

Có lẽ bạn có thể sử dụng FileSystemWatcher và theo dõi sự kiện Thay đổi.

Tôi đã không sử dụng điều này bản thân mình, nhưng nó có thể đáng giá một shot. Nếu bộ xử lý tập tin hóa ra hơi nặng đối với trường hợp này, tôi sẽ đi vòng lặp thử / bắt / ngủ.

Bạn có thể trả về một tác vụ cung cấp cho bạn một luồng ngay khi nó có sẵn. Đó là một giải pháp đơn giản hóa, nhưng nó là một điểm khởi đầu tốt. Đó là chủ đề an toàn.

private async Task<Stream> GetStreamAsync()
{
    try
    {
        return new FileStream("sample.mp3", FileMode.Open, FileAccess.Write);
    }
    catch (IOException)
    {
        await Task.Delay(TimeSpan.FromSeconds(1));
        return await GetStreamAsync();
    }
}

Bạn có thể sử dụng luồng này như bình thường:

using (var stream = await FileStreamGetter.GetStreamAsync())
{
    Console.WriteLine(stream.Length);
}

cách duy nhất tôi biết là sử dụng API khóa độc quyền Win32 không quá nhanh, nhưng vẫn tồn tại các ví dụ.

Hầu hết mọi người, cho một giải pháp đơn giản cho việc này, chỉ đơn giản là thử / bắt / ngủ vòng.

static bool FileInUse(string path)
    {
        try
        {
            using (FileStream fs = new FileStream(path, FileMode.OpenOrCreate))
            {
                fs.CanWrite
            }
            return false;
        }
        catch (IOException ex)
        {
            return true;
        }
    }

string filePath = "C:\\Documents And Settings\\yourfilename";
bool isFileInUse;

isFileInUse = FileInUse(filePath);

// Then you can do some checking
if (isFileInUse)
   Console.WriteLine("File is in use");
else
   Console.WriteLine("File is not in use");

Hi vọng điêu nay co ich!

Các câu trả lời được chấp nhận ở trên gặp phải một vấn đề trong đó nếu tệp đã được mở để ghi với chế độ FileShare.Read hoặc nếu tệp có thuộc tính Chỉ đọc thì mã sẽ không hoạt động. Giải pháp sửa đổi này hoạt động đáng tin cậy nhất, với hai điều cần lưu ý (cũng đúng với giải pháp được chấp nhận):

1. Nó sẽ không hoạt động đối với các tệp đã được mở với chế độ chia sẻ ghi
2. Điều này không tính đến các vấn đề luồng, vì vậy bạn sẽ cần phải khóa nó hoặc xử lý các vấn đề luồng riêng biệt.

Hãy ghi nhớ những điều trên, việc này sẽ kiểm tra xem tệp có bị khóa để ghi hoặc khóa để tránh đọc không :

public static bool FileLocked(string FileName)
{
    FileStream fs = null;

    try
    {
        // NOTE: This doesn't handle situations where file is opened for writing by another process but put into write shared mode, it will not throw an exception and won't show it as write locked
        fs = File.Open(FileName, FileMode.Open, FileAccess.ReadWrite, FileShare.None); // If we can't open file for reading and writing then it's locked by another process for writing
    }
    catch (UnauthorizedAccessException) // https://msdn.microsoft.com/en-us/library/y973b725(v=vs.110).aspx
    {
        // This is because the file is Read-Only and we tried to open in ReadWrite mode, now try to open in Read only mode
        try
        {
            fs = File.Open(FileName, FileMode.Open, FileAccess.Read, FileShare.None);
        }
        catch (Exception)
        {
            return true; // This file has been locked, we can't even open it to read
        }
    }
    catch (Exception)
    {
        return true; // This file has been locked
    }
    finally
    {
        if (fs != null)
            fs.Close();
    }
    return false;
}

Ngoài việc làm việc 3 lớp và chỉ để tham khảo: Nếu bạn muốn thông tin đầy đủ - có một dự án nhỏ trên Microsoft Dev Center:

https://code.msdn.microsoft.com/windowsapps/How-to-ledge-the- process-704839f4

Từ phần giới thiệu:

Mã mẫu C # được phát triển trong .NET Framework 4.0 sẽ giúp tìm ra quy trình nào có khóa trên tệp. Hàm RmStartSession được bao gồm trong rstrtmgr.dll đã được sử dụng để tạo phiên quản lý khởi động lại và theo kết quả trả về, một phiên bản mới của đối tượng Win32Exception được tạo. Sau khi đăng ký tài nguyên cho phiên Khởi động lại Trình quản lý thông qua chức năng RmRegisterRescource , chức năng RmGetList được gọi để kiểm tra các ứng dụng đang sử dụng một tệp cụ thể bằng cách liệt kê mảng RM_PROCESS_INFO .

Nó hoạt động bằng cách kết nối với "Phiên khởi động lại trình quản lý".

Trình quản lý khởi động lại sử dụng danh sách các tài nguyên đã đăng ký với phiên để xác định ứng dụng và dịch vụ nào phải được tắt và khởi động lại. Tài nguyên có thể được xác định bằng tên tệp, tên dịch vụ ngắn hoặc cấu trúc RM_UNIQUE_PROCESS mô tả các ứng dụng đang chạy.

Nó có thể là một chút overengineered cho các nhu cầu cụ thể của bạn ... Nhưng nếu đó là những gì bạn muốn, đi trước và lấy vs dự án.

Theo kinh nghiệm của tôi, bạn thường muốn làm điều này, sau đó 'bảo vệ' các tệp của bạn để làm một cái gì đó lạ mắt và sau đó sử dụng các tệp 'được bảo vệ'. Nếu bạn chỉ có một tệp bạn muốn sử dụng như thế này, bạn có thể sử dụng mẹo được giải thích trong câu trả lời của Jeremy Thompson. Tuy nhiên, nếu bạn cố gắng thực hiện việc này trên nhiều tệp (ví dụ: khi bạn đang viết trình cài đặt), bạn sẽ gặp khá nhiều tổn thương.

Một cách rất hay mà điều này có thể được giải quyết là sử dụng thực tế là hệ thống tệp của bạn sẽ không cho phép bạn thay đổi tên thư mục nếu một trong các tệp ở đó được sử dụng. Giữ thư mục trong cùng một hệ thống tệp và nó sẽ hoạt động như một lá bùa.

Hãy lưu ý rằng bạn nên biết về những cách rõ ràng mà điều này có thể được khai thác. Rốt cuộc, các tập tin sẽ không bị khóa. Ngoài ra, hãy lưu ý rằng có những lý do khác có thể khiến Movehoạt động của bạn bị lỗi. Rõ ràng việc xử lý lỗi thích hợp (MSDN) có thể giúp đỡ ở đây.

var originalFolder = @"c:\myHugeCollectionOfFiles"; // your folder name here
var someFolder = Path.Combine(originalFolder, "..", Guid.NewGuid().ToString("N"));

try
{
    Directory.Move(originalFolder, someFolder);

    // Use files
}
catch // TODO: proper exception handling
{
    // Inform user, take action
}
finally
{
    Directory.Move(someFolder, originalFolder);
}

Đối với các tệp riêng lẻ, tôi sẽ sử dụng đề xuất khóa được đăng bởi Jeremy Thompson.

Đây là một số mã mà theo như tôi có thể nói tốt nhất làm điều tương tự như câu trả lời được chấp nhận nhưng với ít mã hơn:

    public static bool IsFileLocked(string file)
    {
        try
        {
            using (var stream = File.OpenRead(file))
                return false;
        }
        catch (IOException)
        {
            return true;
        }        
    }

Tuy nhiên tôi nghĩ sẽ mạnh mẽ hơn khi làm theo cách sau:

    public static void TryToDoWithFileStream(string file, Action<FileStream> action, 
        int count, int msecTimeOut)
    {
        FileStream stream = null;
        for (var i = 0; i < count; ++i)
        {
            try
            {
                stream = File.OpenRead(file);
                break;
            }
            catch (IOException)
            {
                Thread.Sleep(msecTimeOut);
            }
        }
        action(stream);
    }

Bạn có thể sử dụng thư viện của tôi để truy cập các tệp từ nhiều ứng dụng.

Bạn có thể cài đặt nó từ nuget: Cài đặt-Gói Xabe.FileLock

Nếu bạn muốn biết thêm thông tin về nó, hãy kiểm tra https://github.com/tomaszzmuda/Xabe.FileLock

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

Phương thức fileLock.Acquire sẽ trả về true chỉ khi có thể khóa tệp độc quyền cho đối tượng này. Nhưng ứng dụng tải lên tập tin cũng phải làm điều đó trong khóa tập tin. Nếu đối tượng không thể truy cập metod trả về false.

Tôi đã từng cần phải tải tệp PDF lên một kho lưu trữ sao lưu trực tuyến. Nhưng sao lưu sẽ thất bại nếu người dùng mở tệp trong một chương trình khác (chẳng hạn như trình đọc PDF). Trong sự vội vàng của mình, tôi đã thử một vài câu trả lời hàng đầu trong chủ đề này nhưng không thể khiến chúng hoạt động được. Những gì đã làm cho tôi là cố gắng di chuyển tệp PDF vào thư mục riêng của nó . Tôi thấy rằng điều này sẽ thất bại nếu tệp được mở trong một chương trình khác và nếu việc di chuyển thành công thì sẽ không có thao tác khôi phục cần thiết như sẽ có nếu nó được chuyển sang một thư mục riêng. Tôi muốn đăng giải pháp cơ bản của mình trong trường hợp nó có thể hữu ích cho các trường hợp sử dụng cụ thể của người khác.

string str_path_and_name = str_path + '\\' + str_filename;
FileInfo fInfo = new FileInfo(str_path_and_name);
bool open_elsewhere = false;
try
{
    fInfo.MoveTo(str_path_and_name);
}
catch (Exception ex)
{
    open_elsewhere = true;
}

if (open_elsewhere)
{
    //handle case
}

Tôi quan tâm xem liệu điều này có kích hoạt bất kỳ phản xạ WTF nào không. Tôi có một quy trình tạo và sau đó khởi chạy một tài liệu PDF từ ứng dụng bảng điều khiển. Tuy nhiên, tôi đã xử lý một điểm yếu trong đó nếu người dùng chạy quy trình nhiều lần, tạo cùng một tệp mà không đóng tệp được tạo trước đó, ứng dụng sẽ ném ngoại lệ và chết. Đây là một sự xuất hiện khá thường xuyên vì tên tệp dựa trên số báo giá bán hàng.

Thay vì thất bại theo cách vô duyên như vậy, tôi quyết định dựa vào phiên bản tệp tăng tự động:

private static string WriteFileToDisk(byte[] data, string fileName, int version = 0)
{
    try
    {
        var versionExtension = version > 0 ? $"_{version:000}" : string.Empty;
        var filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"{fileName}{versionExtension}.pdf");
        using (var writer = new FileStream(filePath, FileMode.Create))
        {
            writer.Write(data, 0, data.Length);
        }
        return filePath;
    }
    catch (IOException)
    {
        return WriteFileToDisk(data, fileName, ++version);
    }
}

Có lẽ một số chăm sóc khác có thể được cung cấp cho catchkhối để đảm bảo tôi bắt được IOException (s) chính xác. Có lẽ tôi cũng sẽ xóa bộ nhớ ứng dụng khi khởi động vì các tệp này được dự định là tạm thời.

Tôi nhận ra điều này vượt ra ngoài phạm vi câu hỏi của OP chỉ đơn giản là kiểm tra xem tệp có được sử dụng hay không nhưng đây thực sự là vấn đề tôi đang tìm cách giải quyết khi đến đây nên có lẽ nó sẽ hữu ích cho người khác.

Một cái gì đó như thế này sẽ giúp?

var fileWasWrittenSuccessfully = false;
while (fileWasWrittenSuccessfully == false)
{
    try
    {
        lock (new Object())
        {
            using (StreamWriter streamWriter = new StreamWriter(filepath.txt"), true))
            {
                streamWriter.WriteLine("text");
            }
        }

        fileWasWrittenSuccessfully = true;
    }
    catch (Exception)
    {

    }
}

Hãy thử và di chuyển / sao chép tệp vào một thư mục tạm thời. Nếu bạn có thể, nó không có khóa và bạn có thể làm việc một cách an toàn trong thư mục tạm thời mà không cần khóa. Khác chỉ cần cố gắng di chuyển nó một lần nữa trong x giây.

Tôi sử dụng cách giải quyết này, nhưng tôi có khoảng thời gian giữa khi tôi kiểm tra khóa tệp bằng chức năng IsFileLocked và khi tôi mở tệp. Trong thời gian này, một số luồng khác có thể mở tệp, vì vậy tôi sẽ nhận được IOException.

Vì vậy, tôi đã thêm mã bổ sung cho việc này. Trong trường hợp của tôi, tôi muốn tải XDocument:

        XDocument xDoc = null;

        while (xDoc == null)
        {
            while (IsFileBeingUsed(_interactionXMLPath))
            {
                Logger.WriteMessage(Logger.LogPrioritet.Warning, "Deserialize can not open XML file. is being used by another process. wait...");
                Thread.Sleep(100);
            }
            try
            {
                xDoc = XDocument.Load(_interactionXMLPath);
            }
            catch
            {
                Logger.WriteMessage(Logger.LogPrioritet.Error, "Load working!!!!!");
            }
        }

Bạn nghĩ sao? Tôi có thể thay đổi một số thứ? Có lẽ tôi không phải sử dụng chức năng IsFileByingUsed?

Cảm ơn