오류는 다른 프로세스가 파일에 액세스하려고 함을 나타냅니다. 글을 쓰려고 시도하는 동안 자신이나 다른 사람이 열었을 수 있습니다. “읽기”또는 “복사”는 일반적으로이를 발생시키지 않지만, 쓰거나 삭제를 호출 할 수 있습니다.

다른 답변에서 언급했듯이 이것을 피할 수있는 몇 가지 기본 사항이 있습니다.

1. 에서 FileStream운영하는에 배치 usingA를 블록 FileShare.ReadWrite액세스 모드.

   예를 들면 다음과 같습니다.

   using (FileStream stream = File.Open(path, FileMode.Open, FileAccess.Write, FileShare.ReadWrite))
   {
   }

   참고 FileAccess.ReadWrite사용이 불가능합니다 FileMode.Append.

2. File.SaveAs파일이 사용 중일 때 입력 스트림을 사용 하여이 문제를 겪었습니다 . 필자의 경우 실제로 파일 시스템에 파일을 다시 저장할 필요가 없으므로 그냥 제거했지만 코드와 같이 using문 에서 FileStream을 만들려고했을 수 FileAccess.ReadWrite있습니다. 위.

3. 더 이상 사용하지 않는 데이터를 다른 파일로 저장하고 이전 파일을 삭제하기 위해 다시 돌아 가면 원래 파일 이름으로 성공적으로 저장된 파일의 이름을 바꾸는 것이 옵션입니다. 사용중인 파일을 테스트하는 방법은

   List<Process> lstProcs = ProcessHandler.WhoIsLocking(file);

   아래 코드 내 라인에 표시되며 Windows 서비스에서 루프로 수행 할 수 있습니다. 파일을 교체 할 때 정기적으로보고 삭제하려는 특정 파일이있는 경우. 항상 같은 파일을 가지고 있지 않은 경우 서비스에서 항상 파일 이름을 확인한 다음 해당 프로세스를 검사하고 그에 따라 프로세스 종료 및 삭제를 수행하도록 텍스트 파일 또는 데이터베이스 테이블을 업데이트 할 수 있습니다. 다음 옵션에서. 물론 프로세스 삭제 및 종료를 수행하려면 주어진 컴퓨터에 대한 관리자 권한이있는 계정 사용자 이름과 비밀번호가 필요합니다.

4. 파일을 저장하려고 할 때 파일이 사용 중인지 알 수없는 경우 저장하기 전에 Word와 같은 경우 파일과 같이 파일을 사용할 수있는 모든 프로세스를 닫을 수 있습니다.

   로컬 인 경우 다음을 수행 할 수 있습니다.

   ProcessHandler.localProcessKill("winword.exe");

   원격 인 경우 다음을 수행 할 수 있습니다.

   ProcessHandler.remoteProcessKill(computerName, txtUserName, txtPassword, "winword.exe");

   여기서는 txtUserName의 형태이다 DOMAIN\user.

5. 파일을 잠그는 프로세스 이름을 모른다고 가정 해 봅시다. 그런 다음이 작업을 수행 할 수 있습니다.

   List<Process> lstProcs = new List<Process>();
   lstProcs = ProcessHandler.WhoIsLocking(file);
   
   foreach (Process p in lstProcs)
   {
       if (p.MachineName == ".")
           ProcessHandler.localProcessKill(p.ProcessName);
       else
           ProcessHandler.remoteProcessKill(p.MachineName, txtUserName, txtPassword, p.ProcessName);
   }

   참고 file:의 UNC 경로 여야합니다 \\computer\share\yourdoc.docx(가)의 순서 Process가에 무엇을 컴퓨터 파악하고 p.MachineName유효.

   다음은이 함수가 사용하는 클래스이며에 대한 참조를 추가해야합니다 System.Management. 이 코드는 원래 Eric J가 작성했습니다 .

   using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Threading.Tasks;
   using System.Runtime.InteropServices;
   using System.Diagnostics;
   using System.Management;
   
   namespace MyProject
   {
       public static class ProcessHandler
       {
           [StructLayout(LayoutKind.Sequential)]
           struct RM_UNIQUE_PROCESS
           {
               public int dwProcessId;
               public System.Runtime.InteropServices.ComTypes.FILETIME ProcessStartTime;
           }
   
           const int RmRebootReasonNone = 0;
           const int CCH_RM_MAX_APP_NAME = 255;
           const int CCH_RM_MAX_SVC_NAME = 63;
   
           enum RM_APP_TYPE
           {
               RmUnknownApp = 0,
               RmMainWindow = 1,
               RmOtherWindow = 2,
               RmService = 3,
               RmExplorer = 4,
               RmConsole = 5,
               RmCritical = 1000
           }
   
           [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
           struct RM_PROCESS_INFO
           {
               public RM_UNIQUE_PROCESS Process;
   
               [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCH_RM_MAX_APP_NAME + 1)]
               public string strAppName;
   
               [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCH_RM_MAX_SVC_NAME + 1)]
               public string strServiceShortName;
   
               public RM_APP_TYPE ApplicationType;
               public uint AppStatus;
               public uint TSSessionId;
               [MarshalAs(UnmanagedType.Bool)]
               public bool bRestartable;
           }
   
           [DllImport("rstrtmgr.dll", CharSet = CharSet.Unicode)]
           static extern int RmRegisterResources(uint pSessionHandle,
                                               UInt32 nFiles,
                                               string[] rgsFilenames,
                                               UInt32 nApplications,
                                               [In] RM_UNIQUE_PROCESS[] rgApplications,
                                               UInt32 nServices,
                                               string[] rgsServiceNames);
   
           [DllImport("rstrtmgr.dll", CharSet = CharSet.Auto)]
           static extern int RmStartSession(out uint pSessionHandle, int dwSessionFlags, string strSessionKey);
   
           [DllImport("rstrtmgr.dll")]
           static extern int RmEndSession(uint pSessionHandle);
   
           [DllImport("rstrtmgr.dll")]
           static extern int RmGetList(uint dwSessionHandle,
                                       out uint pnProcInfoNeeded,
                                       ref uint pnProcInfo,
                                       [In, Out] RM_PROCESS_INFO[] rgAffectedApps,
                                       ref uint lpdwRebootReasons);
   
           /// <summary>
           /// Find out what process(es) have a lock on the specified file.
           /// </summary>
           /// <param name="path">Path of the file.</param>
           /// <returns>Processes locking the file</returns>
           /// <remarks>See also:
           /// http://msdn.microsoft.com/en-us/library/windows/desktop/aa373661(v=vs.85).aspx
           /// http://wyupdate.googlecode.com/svn-history/r401/trunk/frmFilesInUse.cs (no copyright in code at time of viewing)
           /// 
           /// </remarks>
           static public List<Process> WhoIsLocking(string path)
           {
               uint handle;
               string key = Guid.NewGuid().ToString();
               List<Process> processes = new List<Process>();
   
               int res = RmStartSession(out handle, 0, key);
               if (res != 0) throw new Exception("Could not begin restart session.  Unable to determine file locker.");
   
               try
               {
                   const int ERROR_MORE_DATA = 234;
                   uint pnProcInfoNeeded = 0,
                       pnProcInfo = 0,
                       lpdwRebootReasons = RmRebootReasonNone;
   
                   string[] resources = new string[] { path }; // Just checking on one resource.
   
                   res = RmRegisterResources(handle, (uint)resources.Length, resources, 0, null, 0, null);
   
                   if (res != 0) throw new Exception("Could not register resource.");
   
                   //Note: there's a race condition here -- the first call to RmGetList() returns
                   //      the total number of process. However, when we call RmGetList() again to get
                   //      the actual processes this number may have increased.
                   res = RmGetList(handle, out pnProcInfoNeeded, ref pnProcInfo, null, ref lpdwRebootReasons);
   
                   if (res == ERROR_MORE_DATA)
                   {
                       // Create an array to store the process results
                       RM_PROCESS_INFO[] processInfo = new RM_PROCESS_INFO[pnProcInfoNeeded];
                       pnProcInfo = pnProcInfoNeeded;
   
                       // Get the list
                       res = RmGetList(handle, out pnProcInfoNeeded, ref pnProcInfo, processInfo, ref lpdwRebootReasons);
                       if (res == 0)
                       {
                           processes = new List<Process>((int)pnProcInfo);
   
                           // Enumerate all of the results and add them to the 
                           // list to be returned
                           for (int i = 0; i < pnProcInfo; i++)
                           {
                               try
                               {
                                   processes.Add(Process.GetProcessById(processInfo[i].Process.dwProcessId));
                               }
                               // catch the error -- in case the process is no longer running
                               catch (ArgumentException) { }
                           }
                       }
                       else throw new Exception("Could not list processes locking resource.");
                   }
                   else if (res != 0) throw new Exception("Could not list processes locking resource. Failed to get size of result.");
               }
               finally
               {
                   RmEndSession(handle);
               }
   
               return processes;
           }
   
           public static void remoteProcessKill(string computerName, string userName, string pword, string processName)
           {
               var connectoptions = new ConnectionOptions();
               connectoptions.Username = userName;
               connectoptions.Password = pword;
   
               ManagementScope scope = new ManagementScope(@"\\" + computerName + @"\root\cimv2", connectoptions);
   
               // WMI query
               var query = new SelectQuery("select * from Win32_process where name = '" + processName + "'");
   
               using (var searcher = new ManagementObjectSearcher(scope, query))
               {
                   foreach (ManagementObject process in searcher.Get())
                   {
                       process.InvokeMethod("Terminate", null);
                       process.Dispose();
                   }
               }
           }
   
           public static void localProcessKill(string processName)
           {
               foreach (Process p in Process.GetProcessesByName(processName))
               {
                   p.Kill();
               }
           }
   
           [DllImport("kernel32.dll")]
           public static extern bool MoveFileEx(string lpExistingFileName, string lpNewFileName, int dwFlags);
   
           public const int MOVEFILE_DELAY_UNTIL_REBOOT = 0x4;
   
       }
   }

답변

public static SendEmail()
{
           MailMessage mMailMessage = new MailMessage();
           //setup other email stuff

            if (File.Exists(attachmentPath))
            {
                Attachment attachment = new Attachment(attachmentPath);
                mMailMessage.Attachments.Add(attachment);
                attachment.Dispose(); //disposing the Attachment object
            }
} 

using (var wc = new WebClient())
{
   var tskResult = wc.UploadFileTaskAsync(_address, _fileName);
   tskResult.Wait();
}