C#获取进程打开关联的文件集合

最新推荐文章于 2024-06-07 12:27:53 发布
最新推荐文章于 2024-06-07 12:27:53 发布
阅读量689 收藏
点赞数
分类专栏： c# 文章标签： c# string struct byte system object
国外一位大牛写的，本身自己在开发中遇到需要获取java打开的jar包，一直苦找没找到，偶然翻阅stackoverflow 帖子时发现，收藏下！只在win7 旗舰版上测试通过，其他没试过！ 
        /// <summary>
        /// 获取经常打开的文件集合，类似于windows资源监视器 进程关联的句柄列表
        /// </summary>
        public static List<string> GetFilesLockedBy(Process process)
        {
            var outp = new List<string>();


            ThreadStart ts = delegate
            {
                try
                {
                    outp = UnsafeGetFilesLockedBy(process);
                }
                catch
                {
                }
            };
            try
            {
                var t = new Thread(ts);
                t.Start();
                if (!t.Join(250))
                {
                    try
                    {
                        t.Abort();
                    }
                    catch { }
                }
            }
            catch
            {
            }
            return outp;
        }


        #region 内部实现代码
        private static List<string> UnsafeGetFilesLockedBy(Process process)
        {
            try
            {
                var handles = GetHandles(process);
                var files = new List<string>();


                foreach (var handle in handles)
                {
                    var file = GetFilePath(handle, process);
                    if (file != null) files.Add(file);
                }


                return files;
            }
            catch
            {
                return new List<string>();
            }
        }


        const int CNST_SYSTEM_HANDLE_INFORMATION = 16;
        const uint STATUS_INFO_LENGTH_MISMATCH = 0xc0000004;
        private static string GetFilePath(Win32API.SYSTEM_HANDLE_INFORMATION sYSTEM_HANDLE_INFORMATION, Process process)
        {
            IntPtr m_ipProcessHwnd = Win32API.OpenProcess(Win32API.ProcessAccessFlags.All, false, process.Id);
            IntPtr ipHandle = IntPtr.Zero;
            var objBasic = new Win32API.OBJECT_BASIC_INFORMATION();
            IntPtr ipBasic = IntPtr.Zero;
            var objObjectType = new Win32API.OBJECT_TYPE_INFORMATION();
            IntPtr ipObjectType = IntPtr.Zero;
            var objObjectName = new Win32API.OBJECT_NAME_INFORMATION();
            IntPtr ipObjectName = IntPtr.Zero;
            string strObjectTypeName = "";
            string strObjectName = "";
            int nLength = 0;
            int nReturn = 0;
            IntPtr ipTemp = IntPtr.Zero;


            if (!Win32API.DuplicateHandle(m_ipProcessHwnd, sYSTEM_HANDLE_INFORMATION.Handle, Win32API.GetCurrentProcess(), out ipHandle, 0, false, Win32API.DUPLICATE_SAME_ACCESS))
                return null;


            ipBasic = Marshal.AllocHGlobal(Marshal.SizeOf(objBasic));
            Win32API.NtQueryObject(ipHandle, (int)Win32API.ObjectInformationClass.ObjectBasicInformation, ipBasic, Marshal.SizeOf(objBasic), ref nLength);
            objBasic = (Win32API.OBJECT_BASIC_INFORMATION)Marshal.PtrToStructure(ipBasic, objBasic.GetType());
            Marshal.FreeHGlobal(ipBasic);




            ipObjectType = Marshal.AllocHGlobal(objBasic.TypeInformationLength);
            nLength = objBasic.TypeInformationLength;
            while ((uint)(nReturn = Win32API.NtQueryObject(ipHandle, (int)Win32API.ObjectInformationClass.ObjectTypeInformation, ipObjectType, nLength, ref nLength)) == Win32API.STATUS_INFO_LENGTH_MISMATCH)
            {
                Marshal.FreeHGlobal(ipObjectType);
                ipObjectType = Marshal.AllocHGlobal(nLength);
            }


            objObjectType = (Win32API.OBJECT_TYPE_INFORMATION)Marshal.PtrToStructure(ipObjectType, objObjectType.GetType());
            if (Is64Bits())
            {
                ipTemp = new IntPtr(Convert.ToInt64(objObjectType.Name.Buffer.ToString(), 10) >> 32);
            }
            else
            {
                ipTemp = objObjectType.Name.Buffer;
            }


            strObjectTypeName = Marshal.PtrToStringUni(ipTemp, objObjectType.Name.Length >> 1);
            Marshal.FreeHGlobal(ipObjectType);
            if (strObjectTypeName != "File")
                return null;


            nLength = objBasic.NameInformationLength;


            ipObjectName = Marshal.AllocHGlobal(nLength);
            while ((uint)(nReturn = Win32API.NtQueryObject(ipHandle, (int)Win32API.ObjectInformationClass.ObjectNameInformation, ipObjectName, nLength, ref nLength)) == Win32API.STATUS_INFO_LENGTH_MISMATCH)
            {
                Marshal.FreeHGlobal(ipObjectName);
                ipObjectName = Marshal.AllocHGlobal(nLength);
            }
            objObjectName = (Win32API.OBJECT_NAME_INFORMATION)Marshal.PtrToStructure(ipObjectName, objObjectName.GetType());


            if (Is64Bits())
            {
                ipTemp = new IntPtr(Convert.ToInt64(objObjectName.Name.Buffer.ToString(), 10) >> 32);
            }
            else
            {
                ipTemp = objObjectName.Name.Buffer;
            }


            if (ipTemp != IntPtr.Zero)
            {


                byte[] baTemp = new byte[nLength];
                try
                {
                    Marshal.Copy(ipTemp, baTemp, 0, nLength);


                    strObjectName = Marshal.PtrToStringUni(Is64Bits() ? new IntPtr(ipTemp.ToInt64()) : new IntPtr(ipTemp.ToInt32()));
                }
                catch (AccessViolationException)
                {
                    return null;
                }
                finally
                {
                    Marshal.FreeHGlobal(ipObjectName);
                    Win32API.CloseHandle(ipHandle);
                }
            }


            string path = GetRegularFileNameFromDevice(strObjectName);
            try
            {
                return path;
            }
            catch
            {
                return null;
            }
        }


        private static string GetRegularFileNameFromDevice(string strRawName)
        {
            string strFileName = strRawName;
            foreach (string strDrivePath in Environment.GetLogicalDrives())
            {
                StringBuilder sbTargetPath = new StringBuilder(Win32API.MAX_PATH);
                if (Win32API.QueryDosDevice(strDrivePath.Substring(0, 2), sbTargetPath, Win32API.MAX_PATH) == 0)
                {
                    return strRawName;
                }
                string strTargetPath = sbTargetPath.ToString();
                if (strFileName.StartsWith(strTargetPath))
                {
                    strFileName = strFileName.Replace(strTargetPath, strDrivePath.Substring(0, 2));
                    break;
                }
            }
            return strFileName;
        }


        private static List<Win32API.SYSTEM_HANDLE_INFORMATION> GetHandles(Process process)
        {
            uint nStatus;
            int nHandleInfoSize = 0x10000;
            IntPtr ipHandlePointer = Marshal.AllocHGlobal(nHandleInfoSize);
            int nLength = 0;
            IntPtr ipHandle = IntPtr.Zero;


            while ((nStatus = Win32API.NtQuerySystemInformation(CNST_SYSTEM_HANDLE_INFORMATION, ipHandlePointer, nHandleInfoSize, ref nLength)) == STATUS_INFO_LENGTH_MISMATCH)
            {
                nHandleInfoSize = nLength;
                Marshal.FreeHGlobal(ipHandlePointer);
                ipHandlePointer = Marshal.AllocHGlobal(nLength);
            }


            byte[] baTemp = new byte[nLength];
            Marshal.Copy(ipHandlePointer, baTemp, 0, nLength);


            long lHandleCount = 0;
            if (Is64Bits())
            {
                lHandleCount = Marshal.ReadInt64(ipHandlePointer);
                ipHandle = new IntPtr(ipHandlePointer.ToInt64() + 8);
            }
            else
            {
                lHandleCount = Marshal.ReadInt32(ipHandlePointer);
                ipHandle = new IntPtr(ipHandlePointer.ToInt32() + 4);
            }


            Win32API.SYSTEM_HANDLE_INFORMATION shHandle;
            List<Win32API.SYSTEM_HANDLE_INFORMATION> lstHandles = new List<Win32API.SYSTEM_HANDLE_INFORMATION>();


            for (long lIndex = 0; lIndex < lHandleCount; lIndex++)
            {
                shHandle = new Win32API.SYSTEM_HANDLE_INFORMATION();
                if (Is64Bits())
                {
                    shHandle = (Win32API.SYSTEM_HANDLE_INFORMATION)Marshal.PtrToStructure(ipHandle, shHandle.GetType());
                    ipHandle = new IntPtr(ipHandle.ToInt64() + Marshal.SizeOf(shHandle) + 8);
                }
                else
                {
                    ipHandle = new IntPtr(ipHandle.ToInt64() + Marshal.SizeOf(shHandle));
                    shHandle = (Win32API.SYSTEM_HANDLE_INFORMATION)Marshal.PtrToStructure(ipHandle, shHandle.GetType());
                }
                if (shHandle.ProcessID != process.Id) continue;
                lstHandles.Add(shHandle);
            }
            return lstHandles;


        }


        private static bool Is64Bits()
        {
            return Marshal.SizeOf(typeof(IntPtr)) == 8 ? true : false;
        }


        internal class Win32API
        {
            [DllImport("ntdll.dll")]
            public static extern int NtQueryObject(IntPtr ObjectHandle, int
                ObjectInformationClass, IntPtr ObjectInformation, int ObjectInformationLength,
                ref int returnLength);


            [DllImport("kernel32.dll", SetLastError = true)]
            public static extern uint QueryDosDevice(string lpDeviceName, StringBuilder lpTargetPath, int ucchMax);


            [DllImport("ntdll.dll")]
            public static extern uint NtQuerySystemInformation(int
                SystemInformationClass, IntPtr SystemInformation, int SystemInformationLength,
                ref int returnLength);


            [DllImport("kernel32.dll")]
            public static extern IntPtr OpenProcess(ProcessAccessFlags dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, int dwProcessId);
            [DllImport("kernel32.dll")]
            public static extern int CloseHandle(IntPtr hObject);
            [DllImport("kernel32.dll", SetLastError = true)]
            [return: MarshalAs(UnmanagedType.Bool)]
            public static extern bool DuplicateHandle(IntPtr hSourceProcessHandle,
               ushort hSourceHandle, IntPtr hTargetProcessHandle, out IntPtr lpTargetHandle,
               uint dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, uint dwOptions);
            [DllImport("kernel32.dll")]
            public static extern IntPtr GetCurrentProcess();


            public enum ObjectInformationClass : int
            {
                ObjectBasicInformation = 0,
                ObjectNameInformation = 1,
                ObjectTypeInformation = 2,
                ObjectAllTypesInformation = 3,
                ObjectHandleInformation = 4
            }


            [Flags]
            public enum ProcessAccessFlags : uint
            {
                All = 0x001F0FFF,
                Terminate = 0x00000001,
                CreateThread = 0x00000002,
                VMOperation = 0x00000008,
                VMRead = 0x00000010,
                VMWrite = 0x00000020,
                DupHandle = 0x00000040,
                SetInformation = 0x00000200,
                QueryInformation = 0x00000400,
                Synchronize = 0x00100000
            }


            [StructLayout(LayoutKind.Sequential)]
            public struct OBJECT_BASIC_INFORMATION
            { // Information Class 0
                public int Attributes;
                public int GrantedAccess;
                public int HandleCount;
                public int PointerCount;
                public int PagedPoolUsage;
                public int NonPagedPoolUsage;
                public int Reserved1;
                public int Reserved2;
                public int Reserved3;
                public int NameInformationLength;
                public int TypeInformationLength;
                public int SecurityDescriptorLength;
                public System.Runtime.InteropServices.ComTypes.FILETIME CreateTime;
            }


            [StructLayout(LayoutKind.Sequential)]
            public struct OBJECT_TYPE_INFORMATION
            { // Information Class 2
                public UNICODE_STRING Name;
                public int ObjectCount;
                public int HandleCount;
                public int Reserved1;
                public int Reserved2;
                public int Reserved3;
                public int Reserved4;
                public int PeakObjectCount;
                public int PeakHandleCount;
                public int Reserved5;
                public int Reserved6;
                public int Reserved7;
                public int Reserved8;
                public int InvalidAttributes;
                public GENERIC_MAPPING GenericMapping;
                public int ValidAccess;
                public byte Unknown;
                public byte MaintainHandleDatabase;
                public int PoolType;
                public int PagedPoolUsage;
                public int NonPagedPoolUsage;
            }


            [StructLayout(LayoutKind.Sequential)]
            public struct OBJECT_NAME_INFORMATION
            { // Information Class 1
                public UNICODE_STRING Name;
            }


            [StructLayout(LayoutKind.Sequential, Pack = 1)]
            public struct UNICODE_STRING
            {
                public ushort Length;
                public ushort MaximumLength;
                public IntPtr Buffer;
            }


            [StructLayout(LayoutKind.Sequential)]
            public struct GENERIC_MAPPING
            {
                public int GenericRead;
                public int GenericWrite;
                public int GenericExecute;
                public int GenericAll;
            }


            [StructLayout(LayoutKind.Sequential, Pack = 1)]
            public struct SYSTEM_HANDLE_INFORMATION
            { // Information Class 16
                public int ProcessID;
                public byte ObjectTypeNumber;
                public byte Flags; // 0x01 = PROTECT_FROM_CLOSE, 0x02 = INHERIT
                public ushort Handle;
                public int Object_Pointer;
                public UInt32 GrantedAccess;
            }


            public const int MAX_PATH = 260;
            public const uint STATUS_INFO_LENGTH_MISMATCH = 0xC0000004;
            public const int DUPLICATE_SAME_ACCESS = 0x2;
        }
        #endregion


 

左脚绕右脚
关注
专栏目录
C#文件操作从入门到精通（1）——INI文件操作
qq_34059233的博客
07-30 2469
本文详细介绍ini文件在winform中的应用，纯属项目实战经验！
C#学习笔记——进程篇
qq_46113712的博客
04-14 1254
C#进程 1. 简单介绍： 进程： 进程是操作系统级别的一个基本概念，可以将其简单地理解为“正在运行的程序”,例： 1.qq程序 VS 正在运行的qq进程； 2.火车 VS 正在驶过的一辆火车； 进程是资源调度和分配的基本单位。 进程之间是相互独立的。 在操作系统级别的管理中，利用Process类可启动、停止本机或远程进程。 进程和线程的关系： 一个车间相当于一个进程，车间内工人相当于线程 ...
C#获取双击文件用关联应用程序打开时的文件名
无名剑
12-16 1781
 string PathFileName = Environment.CommandLine;            string[] para=PathFileName.Split(/");            if (para.Length > 3)            {                               string filename=para[3];  
C# 进程管理器 例子，主要功能显示出进程的详细信息
07-19
进程名称：svchost， ID：1132 进程优先级8（优先级别：Normal） 文件名：C:\Windows\system32\svchost.exe 版本：6.1.7600.16385 (win7_rtm.090713-1255) 描述：Windows 服务主进程 语言：中文(简体，中国) -------------------------------- 调用的模块（.dll）： 模块名：ntdll.dll 版本：6.1.7600.16385 (win7_rtm.090713-1255) 描述：NT 层 DLL 模块名：kernel32.dll 版本：6.1.7600.16385 (win7_rtm.090713-1255) 描述：Windows NT 基本 API 客户端 DLL 大概信息是这个样子 的详细信息，。 并且列表出当前计算机所有的进程
枚举当前系统的所有已打开文件的句柄handle及句柄对应的文件路径.zip
03-19
枚举当前系统的所有已打开文件的句柄及路径.zip
c# 窗口句柄有关的常见问题
simonezhlx的专栏
02-25 3398
1、如何获得一个窗口的句柄？例如获取窗口PictureBox控件（其他控件也可以）的句柄，IntPtr handle = pictureBox.Handle;2、注意：窗口创建和窗口创建完毕即有句柄完全是两回事！！！窗口创建时，窗口并没有创建句柄，只有Application.Run(form)或者form.Show()之后才有句柄，即窗口只有显示或者启动消息循环后才有句柄！如果创建form
C#获取进程或线程相关信息的方法
09-03
以下将详细阐述如何利用C#获取进程和线程的各类属性。 首先，我们需要引入`System.Diagnostics`命名空间，该命名空间包含了处理进程和诊断的类，例如`Process`类，用于表示运行在操作系统中的进程。下面是一些关键...
C#关闭指定名字进程的方法
09-03
1. **获取进程列表**：使用`Process.GetProcesses()`方法获取系统中所有正在运行的进程。如果想获取特定名字的进程，可以使用`Process.GetProcessesByName(name)`，其中`name`是你要查找的进程名称（不包括.exe后缀...
C#最常用的100多个类库集合分享
01-09
7. IO操作：除了文件操作，C#的System.IO还包含了DirectoryInfo、FileInfo等类，用于处理文件系统信息，如获取目录内容、查找文件等。 8. JSON操作：Json.NET是常用的C# JSON序列化和反序列化库，可以轻松地将JSON...
C#编写的进程管理器
08-31
这个C#编写的进程管理器通过遍历Process.GetProcesses()返回的进程集合，将每个进程的关键信息展示给用户。它可能包括但不限于以下几点： 1. **进程ID**：每个进程都有唯一的标识符，方便用户识别和区分不同的进程...
进程遍历-NtQuerySystemInformation枚举
最新发布
hide_in_darkness的博客
06-07 619
​ 数组中下一项的开头是上一项的地址加上 NextEntryOffset 成员中的值。​ HandleCount 成员包含有问题的进程正在使用的句柄总数;​ PeakWorkingSetSize 成员包含进程的工作集的峰值大小（以 KB 为单位）​ BasePriority 成员包含进程的基优先级，即在关联进程中创建的线程的起始优先级。​ PeakVirtualSize 成员包含进程使用的虚拟内存的峰值大小（以字节为单位）​ VirtualSize 成员包含进程使用的虚拟内存的当前大小（以字节为单位）
NtQuerySystemInformation判断线程是否被挂起/判断线程状态
killalarm的专栏
09-23 6184
http://www.buguw.com/ntquerysysteminformation%e5%88%a4%e6%96%ad%e7%ba%bf%e7%a8%8b%e6%98%af%e5%90%a6%e8%a2%ab%e6%8c%82%e8%b5%b7%e5%88%a4%e6%96%ad%e7%ba%bf%e7%a8%8b%e7%8a%b6%e6%80%81.html
NtQueryObject 函数
93Storm
04-25 4170
若翻译出现错误，请指出，本人会即时改正。 这个函数未来可能会改变或者从windows中移除，但是不会通告你。（微软有多贱，我嘞个草了） 函数声明： NTSTATUS NtQueryObject( _In_opt_  HANDLE  Handle, _In_        OBJECT_INFORMATION_CLASS objectInformationClass, _Out_opt_
WINDOWS API函数说明
thanklife的专栏
10-10 1605
Windows API函数大全，从事软件开发的朋友可以参考下 1. API之网络函数 WNetAddConnection 创建同一个网络资源的永久性连接 WNetAddConnection2 创建同一个网络资源的连接 WNetAddConnection3 创建同一个网络资源的连接 WNetCancelConnection 结束一个网络连接 WNetCancelConnection2 结束一个网络连接 WNetCloseEnum 结束一次枚举操作 WNetConnectionDialog 启动一...
C# 获取 PC 序列号
lindexi
09-02 2130
在 C++ 需要使用 GetSystemFirmwareTable 的方法来获得 PC 的序列号，需要写的代码很多，但是在 C# 可以使用 WMI 来拿到序列号 首先是安装 System.Management ，安装了这个库，在 dotnet framework 和 dotnet core 都可以使用本文的方法获取 PC 的序列号 安装 System.Management 的方法是通过 N...
Windows 句柄泄露学习总结
bcbobo21cn的专栏
03-19 8610
句柄泄露实例分析 http://www.cnblogs.com/Leo_wl/p/5397274.html 在上篇文章.NET对象与Windows句柄（二）：句柄分类和.NET句柄泄露的例子中，我们有一个句柄泄露的 例子。例子中多次创建和Dispose了DataReceiver和DataAnalyzer对象，但由于忘记调用DataAnalyzer的 Stop方法，导
c# 很多代码是用c# 写的
weixin_30633405的博客
11-26 458
代码 1//GeneratedbyReflectorfromC:\WINDOWS\assembly\GAC_32\mscorlib\2.0.0.0__b77a5c561934e089\mscorlib.dll2namespaceMicrosoft.Win323{4usingMicrosoft.Win32.SafeHandles;5...
NtQueryObject遍历进程(死锁)与管道冲突的解决方案
waykd的博客
03-31 1224
在一次注入使用命名管道进行进程间通讯的案例中需要使用NtQueryObject遍历进程互斥锁情况，期间发现一个问题，NtQueryObject查询到管道时候会死锁，网上也有很多资料介绍NtQueryObject死锁的情况，不过解决方案不是很明确这里记录下解决办法在时候NtQueryObject打开进程关联句柄时，先使用CreateFileMapping假定创建文件句柄，如果创建成功，返回，当然假如...
C#编程：设置文件关联与默认打开程序
"C# 设置文件的默认打开程序建立关联" 在C#编程中，你可以创建一个应用程序并将其与特定的文件类型关联，以便当用户尝试打开这种类型的文件时，系统会自动使用你的应用程序来处理。例如，创建一个名为 OPEN.EXE 的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值