c# - 该进程无法访问文件，因为该文件正在被另一个进程使用

Question

我有两个服务。 1个客户端2个服务器。两种服务都通过套接字进行通信。
客户端包含文件系统监视程序。每当文件系统监视程序在指定的文件夹中检测到新文件时，它就会建立与服务器的连接，并将该文件发送到服务器。
服务器监听特定端口并接受请求并接收文件，然后将详细信息保存到DB。然后将成功/错误消息发送给客户端。

整个系统第一次运行良好。但是，当filesystemwatcher获取第二个文件时，应用程序将生成异常“该进程无法访问该文件。它正在被另一个进程使用”。同样，当我调试服务时，也不异常(exception)。无法获得问题的确切原因。

任何帮助将不胜感激。

客户代码:

namespace WindowsService1
{
public partial class Client : ServiceBase
{
    string hostIPAddress = string.Empty;
    string processedFilePath = string.Empty;
    int hostPort;
    Socket socketClient;
    IPEndPoint remoteEndPoint;
    FileStream fs;

    public PCMParserClient()
    {
        InitializeComponent();
    }

    protected override void OnStart(string[] args)
    {
        hostIPAddress = ConfigurationManager.AppSettings["HostIP"];
        hostPort = int.Parse(ConfigurationManager.AppSettings["HostPort"]);
        //File system watcher
        FsWatcher.Path = ConfigurationManager.AppSettings["FileWatcherPath"];
        processedFilePath = ConfigurationManager.AppSettings["ProcessedFilePath"];
    }

    protected override void OnStop()
    {
    }

    private void FsWatcher_Created(object sender, System.IO.FileSystemEventArgs e)
    {
        try
        {
            socketClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);               
            IPAddress remoteIPAddress = IPAddress.Parse(hostIPAddress);
            remoteEndPoint = new IPEndPoint(remoteIPAddress, hostPort);
            //Establish the connection to server
            socketClient.Connect(remoteEndPoint);
            EventLog.WriteEntry(e.Name+"before");

                **//the below line generates teh exception for 2nd time onwards**
                 using (fs = new FileStream(e.FullPath, FileMode.Open, FileAccess.Read, FileShare.Read))
                 {
                     EventLog.WriteEntry("1");
                     //Convert the file name in form of byte
                     byte[] fileNameByte = Encoding.ASCII.GetBytes(e.Name);
                     EventLog.WriteEntry(e.Name);

                     //4- to store the filename length(as int - 4bytes)
                     //8- to store the file content length(as long take 8 bytes)
                     int totalLength = 4 + fileNameByte.Length + 8;

                     //Clientdata[] reprents the data to sent to the server 
                     //which represent the file details
                     byte[] clientData = new byte[totalLength];
                     byte[] fileNameLength = BitConverter.GetBytes(fileNameByte.Length);
                     byte[] fileContentLength = BitConverter.GetBytes(fs.Length);

                     //Copy all the data ClientData array
                     fileNameLength.CopyTo(clientData, 0);
                     fileNameByte.CopyTo(clientData, 4);
                     fileContentLength.CopyTo(clientData, 4 + fileNameByte.Length);

                     //Send the data to server
                     socketClient.Send(clientData);

                     int byteRead = 0;
                     int bytesToRead = (int)fs.Length;

                     while (bytesToRead > 0)
                     {
                         byte[] data = new Byte[1500];
                         byteRead = bytesToRead > 1500 ? 1500 : bytesToRead;
                         int n = fs.Read(data, 0, byteRead);

                         //Send the data to server
                         socketClient.Send(data);
                         bytesToRead -= n;
                     }

                     fs.Flush();
                     //fs.Close();
                     //fs.Dispose();
                 }


                //Code block to get the success/failure message from server
                byte[] message = new byte[5];
                int msg = socketClient.Receive(message);

                else if (Encoding.ASCII.GetString(message).Contains("Error"))
                {
                    throw new Exception("Error occured while processing the file " + e.Name);
                }

        }
        catch (SocketException ex)
        {
            ExceptionLogger.LogException(ex);
        }
        catch (IOException ex)
        {
            ExceptionLogger.LogException(ex);
        }
        catch (Exception ex)
        {
            ExceptionLogger.LogException(ex);
        }
        finally
        {
            if (socketClient != null && socketClient.Connected)
            {
                socketClient.Close(); 
            }
        }
    }
}

}

服务器代码:

namespace PCMParserService
{
public partial class ParserServer : ServiceBase
{
    Socket serverSocket = null;
    public Timer timer1;
    IPEndPoint ipEndPoint;

    public HL7ParserService()
    {
        InitializeComponent();
        timer1 = new Timer(1000);
        timer1.Elapsed += new ElapsedEventHandler(timer1_Elapsed);
    }

    void timer1_Elapsed(object sender, ElapsedEventArgs e)
    {
        Socket handler = null;
        try
        {
            // The program is suspended while waiting for an incoming connection.
            // This is a synchronous TCP application
            handler = serverSocket.Accept();

            byte[] fileDetails = new byte[1500];
            //Recieve the file details
            handler.Receive(fileDetails);
            int fileNameLength = BitConverter.ToInt32(fileDetails, 0);
            string fileName = Encoding.ASCII.GetString(fileDetails, 4, fileNameLength);
            EventLog.WriteEntry(fileNameLength.ToString(), System.Diagnostics.EventLogEntryType.Information);
            int fileLength = BitConverter.ToInt32(fileDetails, 4 + fileNameLength);

            filePath = ConfigurationManager.AppSettings["ProcessedDirectory"];

            FileStream fs = new FileStream(filePath + fileName, FileMode.Create, FileAccess.Write);
            int byteRead = 0;

            while (byteRead < fileLength)
            {
                byte[] data = new Byte[1500];
                //Recieve the data and write to the file
                int r = handler.Receive(data);
                fs.Write(data, 0, r);
                byteRead += r;
            }
            fs.Flush();
            fs.Close();
            fs.Dispose();


            //-Code to Parse text file and save to db
            FileStream fileStream = new FileStream(filePath + fileName, FileMode.Open, FileAccess.Read);
            StreamReader sr = new StreamReader(fileStream);
            ///Code   
            fileStream.Close();
            fileStream.Dispose();
            sr.Close();
            sbMessage.Append("</Message>");
            saveFileDetails(sbMessage.ToString());

            //-- End of File Parsing code
            handler.Send(Encoding.ASCII.GetBytes("Done"));
        }
        catch (SocketException ex)
        {
            ExceptionLogger.LogException(ex, "Error occured while processing the file + " + filePath);
            handler.Send(Encoding.ASCII.GetBytes("Error"));
        }
        catch (IOException ex)
        {
            ExceptionLogger.LogException(ex, "Error occured while processing the file + " + filePath);
            handler.Send(Encoding.ASCII.GetBytes("Error"));
        }
        catch (SqlException ex)
        {
            ExceptionLogger.LogException(ex, "Error occured while processing the file + " + filePath);
            handler.Send(Encoding.ASCII.GetBytes("Error"));
        }
        catch (Exception ex)
        {
            ExceptionLogger.LogException(ex, "Error occured while processing the file + " + filePath);
            handler.Send(Encoding.ASCII.GetBytes("Error"));
        }
    }

    protected override void OnStart(string[] args)
    {
        try
        {
            //The port on which the server listens
            ipEndPoint = new IPEndPoint(IPAddress.Any, 8030);

            //Defines the kind of socket we want :TCP
            serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            //Bind the socket to the local end point(associate the socket to local end point)
            serverSocket.Bind(ipEndPoint);

            //listen for incoming connection attempt
            // Start listening, only allow 100 connection to queue at the same time
            serverSocket.Listen(100);

            timer1.Start();
        }
        catch (SocketException ex)
        {
            ExceptionLogger.LogException(ex, string.Empty);
        }
        catch (Exception ex)
        {
            ExceptionLogger.LogException(ex, string.Empty);
        }
    }

    protected override void OnStop()
    {
        timer1.Stop();
    }

    protected override void OnPause()
    {
        timer1.Stop();
    }

    protected override void OnContinue()
    {
        timer1.Start();
    }

    protected override void OnShutdown()
    {
        timer1.Stop();
    }

}
}

Answer 1

这通常是由于FileSystemWatcher通知您监视的目录中有新文件时，写入文件的过程尚未完成写入文件，然后释放文件所致。

减轻这种情况的选择包括:

在处理文件

之前，通知后会有延迟

立即处理文件，但将导致“该进程无法访问该文件。另一进程正在使用该文件”的任何文件放入队列中，以进行定期重试。

在调试/测试过程中，通常不会出现此问题，因为您将手动将文件复制到受监视的目录中，或者缓慢地逐步执行代码，以使文件在尝试打开之前已完成写入。