如何通过WPF，C#关闭未知进程对文件的访问？

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using System.Windows;

namespace ProcessFileAccess
{
    public partial class MainWindow : Window
    {
        [DllImport("kernel32.dll")]
        private static extern bool CloseHandle(IntPtr hObject);

        public MainWindow()
        {
            InitializeComponent();
        }

        private void CloseFileAccessButton_Click(object sender, RoutedEventArgs e)
        {
            string filePath = FilePathTextBox.Text;

            // 获取所有进程
            Process[] processes = Process.GetProcesses();

            foreach (Process process in processes)
            {
                try
                {
                    // 获取进程打开的文件句柄列表
                    List<ProcessHandleInfo> handles = GetProcessHandles(process);

                    // 检查每个文件句柄，关闭匹配的文件句柄
                    foreach (ProcessHandleInfo handle in handles)
                    {
                        if (handle.FileName.Equals(filePath, StringComparison.OrdinalIgnoreCase))
                        {
                            CloseHandle(handle.Handle);
                        }
                    }
                }
                catch (Exception ex)
                {
                    // 处理异常情况
                    Console.WriteLine("Error: " + ex.Message);
                }
            }
        }

        private List<ProcessHandleInfo> GetProcessHandles(Process process)
        {
            IntPtr processHandle = IntPtr.Zero;
            try
            {
                // 打开进程获取句柄
                processHandle = OpenProcess(ProcessAccessFlags.All, false, process.Id);

                // 创建新的文件句柄列表
                List<ProcessHandleInfo> handles = new List<ProcessHandleInfo>();

                // 获取进程所有打开的文件句柄
                NtStatus status = NtQuerySystemInformation(SystemInformationClass.SystemHandleInformation, IntPtr.Zero, 0, out int returnLength);
                IntPtr handleInfoPtr = Marshal.AllocHGlobal(returnLength);
                status = NtQuerySystemInformation(SystemInformationClass.SystemHandleInformation, handleInfoPtr, returnLength, out returnLength);

                if (status != NtStatus.Success)
                {
                    throw new Exception("Failed to retrieve handle information.");
                }

                // 解析句柄信息
                IntPtr handleInfoCurrentPtr = handleInfoPtr;
                int handleCount = Marshal.ReadInt32(handleInfoCurrentPtr);
                handleInfoCurrentPtr = IntPtr.Add(handleInfoCurrentPtr, Marshal.SizeOf(typeof(int)));

                for (int i = 0; i < handleCount; i++)
                {
                    SystemHandleInformation handleInfo = Marshal.PtrToStructure<SystemHandleInformation>(handleInfoCurrentPtr);
                    IntPtr objectNamePtr = IntPtr.Zero;
                    IntPtr handleDuplicate = IntPtr.Zero;

                    // 判断是否是当前进程的句柄
                    if (handleInfo.ProcessId == process.Id)
                    {
                        try
                        {
                            // 复制句柄
                            DuplicateHandle(processHandle, handleInfo.Handle, GetCurrentProcess(), out handleDuplicate, 0, false, DuplicateOptions.DuplicateSameAccess);

                            // 获取文件名
                            objectNamePtr = Marshal.AllocHGlobal(MaximumObjectNameLength);
                            NtQueryObject(handleDuplicate, ObjectInformationClass.ObjectNameInformation, objectNamePtr, MaximumObjectNameLength, out returnLength);

                            string objectName = Marshal.PtrToStringUni(Marshal.ReadIntPtr(objectNamePtr));
                            handles.Add(new ProcessHandleInfo(handleDuplicate, objectName));
                        }
                        catch (Exception ex)
                        {
                            // 处理异常情况
                            Console.WriteLine("Error: " + ex.Message);
                        }
                        finally
                        {
                            // 释放内存
                            Marshal.FreeHGlobal(objectNamePtr);
                            CloseHandle(handleDuplicate);
                        }
                    }

                    handleInfoCurrentPtr = IntPtr.Add(handleInfoCurrentPtr, Marshal.SizeOf(typeof(SystemHandleInformation)));
                }

                return handles;
            }
            finally
            {
                // 关闭进程句柄
                CloseHandle(processHandle);
            }
        }

        #region Native Methods

        [DllImport("kernel32.dll", SetLastError = true)]
        private static extern IntPtr OpenProcess(ProcessAccessFlags processAccess, bool bInheritHandle, int processId);

        [DllImport("kernel32.dll", SetLastError = true)]
        private static extern IntPtr GetCurrentProcess();

        [DllImport("ntdll.dll")]
        private static extern NtStatus NtQuerySystemInformation(SystemInformationClass systemInformationClass, IntPtr systemInformation, int systemInformationLength, out int returnLength);

        [DllImport("ntdll.dll")]
        private static extern NtStatus NtQueryObject(IntPtr objectHandle, ObjectInformationClass objectInformationClass, IntPtr objectInformation, int objectInformationLength, out int returnLength);

        [DllImport("kernel32.dll")]
        private static extern bool DuplicateHandle(IntPtr hSourceProcessHandle, IntPtr hSourceHandle, IntPtr hTargetProcessHandle, out IntPtr lpTargetHandle, uint dwDesiredAccess, bool bInheritHandle, DuplicateOptions dwOptions);

        #endregion

        #region Enums and Structs

        [Flags]
        private enum ProcessAccessFlags : uint
        {
            All = 0x1F0FFF,
            Terminate = 0x1,
            CreateThread = 0x2,
            VMOperation = 0x8,
            VMRead = 0x10,
            VMWrite = 0x20,
            DupHandle = 0x40,
            SetInformation = 0x200,
            QueryInformation = 0x400,
            Synchronize = 0x100000
        }

        private enum SystemInformationClass
        {
            SystemHandleInformation = 0x10
        }

        private enum ObjectInformationClass
        {
            ObjectNameInformation = 1
        }

        private enum NtStatus : uint
        {
            Success = 0x00000000
        }

        [StructLayout(LayoutKind.Sequential)]
        private struct SystemHandleInformation
        {
            public int ProcessId;
            public byte ObjectTypeNumber;
            public byte Flags;
            public ushort Handle;
            public int ObjectPointer;
            public UInt32 GrantedAccess;
        }

        private const int MaximumObjectNameLength = 256;

        private struct ProcessHandleInfo
        {
            public IntPtr Handle;
            public string FileName;

            public ProcessHandleInfo(IntPtr handle, string fileName)
            {
                Handle = handle;
                FileName = fileName;
            }
        }

        [Flags]
        private enum DuplicateOptions : uint
        {
            DuplicateCloseSource = (0x00000001),
            DuplicateSameAccess = (0x00000002)
        }

        #endregion
    }
}