public static bool Delete(string Path) { try { if (File.Exists(Path)) { File.Delete(Path); } else if (Directory.Exists(Path)) { Directory.Delete(Path, true); } else { return(false); } string ExtraInfoFilePath = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(Path), System.IO.Path.GetFileName(Path).Replace("$R", "$I")); if (File.Exists(ExtraInfoFilePath)) { File.Delete(ExtraInfoFilePath); } return(true); } catch (Exception ex) { LogTracer.Log(ex, $"An exception was threw in {nameof(Delete)}"); return(false); } }
public static bool EmptyRecycleBin() { try { RecycleBin.Empty(false); return(true); } catch (Exception ex) { LogTracer.Log(ex, $"An exception was threw in {nameof(EmptyRecycleBin)}"); return(false); } }
public static string GetMIMEFromPath(string Path) { if (!File.Exists(Path)) { throw new FileNotFoundException($"\"{Path}\" not found"); } byte[] Buffer = new byte[256]; using (FileStream Stream = new FileStream(Path, FileMode.Open, FileAccess.Read)) { Stream.Read(Buffer, 0, 256); } IntPtr Pointer = Marshal.AllocHGlobal(256); try { Marshal.Copy(Buffer, 0, Pointer, 256); if (UrlMon.FindMimeFromData(null, null, Pointer, 256, null, UrlMon.FMFD.FMFD_DEFAULT, out string MIMEResult) == HRESULT.S_OK) { return(MIMEResult); } else { MimeType MIME = new MimeTypes().GetMimeTypeFromFile(Path); if (MIME != null) { return(MIME.Name); } else { return("unknown/unknown"); } } } catch (Exception ex) { LogTracer.Log(ex, $"An exception was threw in {nameof(GetMIMEFromPath)}"); return("unknown/unknown"); } finally { Marshal.FreeHGlobal(Pointer); } }
public static bool EjectDevice(string Path) { if (string.IsNullOrEmpty(Path) || string.IsNullOrEmpty(System.IO.Path.GetPathRoot(Path))) { throw new ArgumentNullException(nameof(Path), "Argument is not legal"); } try { int DeviceNumber = 0; using (Kernel32.SafeHFILE hVolume = Kernel32.CreateFile($@"\\.\{Path.Substring(0, 2)}", 0, FileShare.ReadWrite, null, FileMode.Open, FileFlagsAndAttributes.SECURITY_ANONYMOUS)) { if (hVolume.IsNull || hVolume.IsInvalid) { return(false); } DeviceNumber = GetDeviceNumber(hVolume); } if (DeviceNumber >= 0) { uint DevInst = GetDrivesDevInstByDeviceNumber(DeviceNumber, Kernel32.GetDriveType(Path)); if (DevInst == 0) { return(false); } if (CfgMgr32.CM_Get_Parent(out uint DevInstParent, DevInst) == CfgMgr32.CONFIGRET.CR_SUCCESS) { for (int i = 0; i < 5; i++) { if (CfgMgr32.CM_Request_Device_Eject(DevInstParent, out CfgMgr32.PNP_VETO_TYPE Result, null, 0) == CfgMgr32.CONFIGRET.CR_SUCCESS) { return(true); } else { LogTracer.Log($"Could not reject the USB device, PNP_VETO reason: {Enum.GetName(typeof(CfgMgr32.PNP_VETO_TYPE), Result)}"); } Thread.Sleep(300); } }
public static bool CheckQuicklookIsAvaliable() { try { NamedPipeClientStream Client = new NamedPipeClientStream(".", PipeName, PipeDirection.Out, PipeOptions.WriteThrough); Client.Connect(500); using (StreamWriter Writer = new StreamWriter(Client)) { Writer.WriteLine($"{SwitchCommand}|"); Writer.Flush(); } return(true); } catch (Exception ex) { LogTracer.Log(ex, $"An exception was threw in {nameof(CheckQuicklookIsAvaliable)}"); return(false); } }
public static Task <bool> InvokeVerbAsync(string[] RelatedPath, string Verb, int Id, bool IncludeExtensionItem) { if (RelatedPath.Length > 0) { return(Helper.ExecuteOnSTAThreadAsync(() => { try { if (Array.TrueForAll(RelatedPath, (Path) => File.Exists(Path) || Directory.Exists(Path))) { Shell32.IContextMenu ContextObject = GetContextMenuObject(RelatedPath); using (User32.SafeHMENU Menu = User32.CreatePopupMenu()) { if (ContextObject.QueryContextMenu(Menu, 0, 0, 0x7FFF, (IncludeExtensionItem ? Shell32.CMF.CMF_EXTENDEDVERBS : Shell32.CMF.CMF_NORMAL) | Shell32.CMF.CMF_SYNCCASCADEMENU).Succeeded) { if (!string.IsNullOrEmpty(Verb)) { using (SafeResourceId VerbId = new SafeResourceId(Verb)) { Shell32.CMINVOKECOMMANDINFOEX VerbInvokeCommand = new Shell32.CMINVOKECOMMANDINFOEX { lpVerb = VerbId, lpVerbW = Verb, nShow = ShowWindowCommand.SW_SHOWNORMAL, fMask = Shell32.CMIC.CMIC_MASK_FLAG_NO_UI | Shell32.CMIC.CMIC_MASK_UNICODE | Shell32.CMIC.CMIC_MASK_ASYNCOK, cbSize = Convert.ToUInt32(Marshal.SizeOf(typeof(Shell32.CMINVOKECOMMANDINFOEX))) }; if (ContextObject.InvokeCommand(VerbInvokeCommand).Succeeded) { return true; } } } using (SafeResourceId ResSID = new SafeResourceId(Id)) { Shell32.CMINVOKECOMMANDINFOEX IdInvokeCommand = new Shell32.CMINVOKECOMMANDINFOEX { lpVerb = ResSID, nShow = ShowWindowCommand.SW_SHOWNORMAL, fMask = Shell32.CMIC.CMIC_MASK_FLAG_NO_UI | Shell32.CMIC.CMIC_MASK_ASYNCOK, cbSize = Convert.ToUInt32(Marshal.SizeOf(typeof(Shell32.CMINVOKECOMMANDINFOEX))) }; return ContextObject.InvokeCommand(IdInvokeCommand).Succeeded; } } else { return false; } } } else { return false; } } catch (Exception ex) { LogTracer.Log(ex, "Exception was threw when invoke the context menu item"); return false; } })); } else { return(Task.FromResult(false)); } }
private static ContextMenuPackage[] FetchContextMenuCore(Shell32.IContextMenu Context, HMENU Menu, string[] RelatedPath, bool IncludeExtensionItem) { int MenuItemNum = User32.GetMenuItemCount(Menu); List <ContextMenuPackage> MenuItems = new List <ContextMenuPackage>(MenuItemNum); for (uint i = 0; i < MenuItemNum; i++) { IntPtr DataHandle = Marshal.AllocCoTaskMem(BufferSize); try { User32.MENUITEMINFO Info = new User32.MENUITEMINFO { cbSize = Convert.ToUInt32(Marshal.SizeOf(typeof(User32.MENUITEMINFO))), fMask = User32.MenuItemInfoMask.MIIM_ID | User32.MenuItemInfoMask.MIIM_SUBMENU | User32.MenuItemInfoMask.MIIM_FTYPE | User32.MenuItemInfoMask.MIIM_STRING | User32.MenuItemInfoMask.MIIM_STATE | User32.MenuItemInfoMask.MIIM_BITMAP, dwTypeData = DataHandle, cch = CchMax }; if (User32.GetMenuItemInfo(Menu, i, true, ref Info)) { if (Info.fType.IsFlagSet(User32.MenuItemType.MFT_STRING) && !Info.fState.IsFlagSet(User32.MenuItemState.MFS_DISABLED)) { IntPtr VerbWHandle = IntPtr.Zero; IntPtr VerbAHandle = IntPtr.Zero; string Verb = null; try { VerbWHandle = Marshal.AllocCoTaskMem(BufferSize); if (Context.GetCommandString(new IntPtr(Info.wID), Shell32.GCS.GCS_VERBW, IntPtr.Zero, VerbWHandle, CchMax).Succeeded) { Verb = Marshal.PtrToStringUni(VerbWHandle); } if (string.IsNullOrEmpty(Verb)) { VerbAHandle = Marshal.AllocCoTaskMem(BufferSize); if (Context.GetCommandString(new IntPtr(Info.wID), Shell32.GCS.GCS_VERBA, IntPtr.Zero, VerbAHandle, CchMax).Succeeded) { Verb = Marshal.PtrToStringAnsi(VerbAHandle); } } } catch (AccessViolationException AVE) { Verb = null; LogTracer.Log(AVE, "Could not get verb from context menu item"); } finally { if (VerbAHandle != IntPtr.Zero) { Marshal.FreeCoTaskMem(VerbAHandle); } if (VerbWHandle != IntPtr.Zero) { Marshal.FreeCoTaskMem(VerbWHandle); } } Verb ??= string.Empty; if (!VerbFilterHashSet.Contains(Verb.ToLower())) { try { string Name = Marshal.PtrToStringUni(DataHandle); if (!string.IsNullOrEmpty(Name) && !NameFilterHashSet.Contains(Name)) { ContextMenuPackage Package = new ContextMenuPackage { Name = Regex.Replace(Name, @"\(&\S*\)|&", string.Empty), Id = Convert.ToInt32(Info.wID), Verb = Verb, IncludeExtensionItem = IncludeExtensionItem, RelatedPath = RelatedPath }; if (Info.hbmpItem != HBITMAP.NULL && ((IntPtr)Info.hbmpItem).ToInt64() != -1) { using (Bitmap OriginBitmap = Info.hbmpItem.ToBitmap()) { BitmapData OriginData = OriginBitmap.LockBits(new Rectangle(0, 0, OriginBitmap.Width, OriginBitmap.Height), ImageLockMode.ReadOnly, OriginBitmap.PixelFormat); try { using (Bitmap ArgbBitmap = new Bitmap(OriginBitmap.Width, OriginBitmap.Height, OriginData.Stride, PixelFormat.Format32bppArgb, OriginData.Scan0)) using (MemoryStream Stream = new MemoryStream()) { ArgbBitmap.Save(Stream, ImageFormat.Png); Package.IconData = Stream.ToArray(); } } finally { OriginBitmap.UnlockBits(OriginData); } } } else { Package.IconData = Array.Empty <byte>(); } if (Info.hSubMenu != HMENU.NULL) { Package.SubMenus = FetchContextMenuCore(Context, Info.hSubMenu, RelatedPath, IncludeExtensionItem); } else { Package.SubMenus = Array.Empty <ContextMenuPackage>(); } MenuItems.Add(Package); } } catch { continue; } } } } } catch (Exception ex) { LogTracer.Log(ex, "Exception was threw when fetching the context menu item"); } finally { Marshal.FreeCoTaskMem(DataHandle); } } return(MenuItems.ToArray()); }
private static Shell32.IContextMenu GetContextMenuObject(params string[] PathArray) { try { if (PathArray.Count() > 1) { ShellItem[] Items = PathArray.Select((Path) => new ShellItem(Path)).ToArray(); ShellFolder[] ParentFolders = Items.Select((Item) => Item.Parent).ToArray(); try { if (ParentFolders.Skip(1).All((Folder) => Folder == ParentFolders[0])) { return(ParentFolders[0].GetChildrenUIObjects <Shell32.IContextMenu>(null, Items)); } else { throw new ArgumentException("All items must have the same parent"); } } finally { Array.ForEach(Items, (It) => It.Dispose()); Array.ForEach(ParentFolders, (It) => It.Dispose()); } } else { using (ShellItem Item = new ShellItem(PathArray.First())) { if (Item is ShellFolder Folder) { return(Folder.IShellFolder.CreateViewObject <Shell32.IContextMenu>(HWND.NULL)); } else { if (Item.Parent is ShellFolder ParentFolder) { try { return(ParentFolder.GetChildrenUIObjects <Shell32.IContextMenu>(null, Item)); } finally { ParentFolder?.Dispose(); } } else { return(Item.GetHandler <Shell32.IContextMenu>(Shell32.BHID.BHID_SFUIObject)); } } } } } catch (Exception ex) { LogTracer.Log(ex, "Exception was threw when getting the context menu COM object"); return(null); } }
public static bool Restore(params string[] OriginPathList) { Dictionary <string, ShellItem> PathDic = new Dictionary <string, ShellItem>(); try { foreach (ShellItem Item in RecycleBin.GetItems()) { if (File.Exists(Item.FileSystemPath)) { if (Path.GetExtension(Item.Name).Equals(Item.FileInfo.Extension, StringComparison.OrdinalIgnoreCase)) { PathDic.TryAdd(Item.Name, Item); } else { PathDic.TryAdd(Item.Name + Item.FileInfo.Extension, Item); } } else if (Directory.Exists(Item.FileSystemPath)) { PathDic.TryAdd(Item.Name, Item); } } bool HasError = false; foreach (string OriginPath in OriginPathList) { if (PathDic.TryGetValue(OriginPath, out ShellItem SourceItem)) { Directory.CreateDirectory(Path.GetDirectoryName(SourceItem.Name)); if (File.Exists(SourceItem.FileSystemPath)) { File.Move(SourceItem.FileSystemPath, StorageController.GenerateUniquePath(OriginPath)); } else if (Directory.Exists(SourceItem.FileSystemPath)) { Directory.Move(SourceItem.FileSystemPath, StorageController.GenerateUniquePath(OriginPath)); } string ExtraInfoPath = Path.Combine(Path.GetDirectoryName(SourceItem.FileSystemPath), Path.GetFileName(SourceItem.FileSystemPath).Replace("$R", "$I")); if (File.Exists(ExtraInfoPath)) { File.Delete(ExtraInfoPath); } } else { HasError = true; } } return(!HasError); } catch (Exception ex) { LogTracer.Log(ex, $"An exception was threw in {nameof(Restore)}"); return(false); } finally { foreach (ShellItem Item in PathDic.Values) { Item.Dispose(); } } }
public static string GenerateRecycleItemsByJson() { try { List <Dictionary <string, string> > RecycleItemList = new List <Dictionary <string, string> >(); foreach (ShellItem Item in RecycleBin.GetItems()) { try { Dictionary <string, string> PropertyDic = new Dictionary <string, string> { { "ActualPath", Item.FileSystemPath } }; try { PropertyDic.Add("DeleteTime", (Item.IShellItem as Shell32.IShellItem2).GetFileTime(Ole32.PROPERTYKEY.System.Recycle.DateDeleted).ToInt64().ToString()); } catch { PropertyDic.Add("DeleteTime", default(FILETIME).ToInt64().ToString()); } if (File.Exists(Item.FileSystemPath)) { PropertyDic.Add("StorageType", Enum.GetName(typeof(StorageItemTypes), StorageItemTypes.File)); if (Path.GetExtension(Item.Name).Equals(Item.FileInfo.Extension, StringComparison.OrdinalIgnoreCase)) { PropertyDic.Add("OriginPath", Item.Name); } else { PropertyDic.Add("OriginPath", Item.Name + Item.FileInfo.Extension); } } else if (Directory.Exists(Item.FileSystemPath)) { PropertyDic.Add("OriginPath", Item.Name); PropertyDic.Add("StorageType", Enum.GetName(typeof(StorageItemTypes), StorageItemTypes.Folder)); } else { continue; } RecycleItemList.Add(PropertyDic); } finally { Item.Dispose(); } } return(JsonSerializer.Serialize(RecycleItemList)); } catch (Exception ex) { LogTracer.Log(ex, $"An exception was threw in {nameof(GenerateRecycleItemsByJson)}"); return(string.Empty); } }
/// <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> public static IReadOnlyList <Process> GetLockingProcesses(string path) { StringBuilder SessionKey = new StringBuilder(Guid.NewGuid().ToString()); if (RstrtMgr.RmStartSession(out uint SessionHandle, 0, SessionKey).Succeeded) { try { string[] ResourcesFileName = new string[] { path }; if (RstrtMgr.RmRegisterResources(SessionHandle, (uint)ResourcesFileName.Length, ResourcesFileName, 0, null, 0, null).Succeeded) { uint pnProcInfo = 0; //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. Win32Error Error = RstrtMgr.RmGetList(SessionHandle, out uint pnProcInfoNeeded, ref pnProcInfo, null, out _); if (Error == Win32Error.ERROR_MORE_DATA) { // Create an array to store the process results RstrtMgr.RM_PROCESS_INFO[] ProcessInfo = new RstrtMgr.RM_PROCESS_INFO[pnProcInfoNeeded]; pnProcInfo = pnProcInfoNeeded; // Get the list if (RstrtMgr.RmGetList(SessionHandle, out pnProcInfoNeeded, ref pnProcInfo, ProcessInfo, out _).Succeeded) { List <Process> LockProcesses = 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 { LockProcesses.Add(Process.GetProcessById(Convert.ToInt32(ProcessInfo[i].Process.dwProcessId))); } catch (Exception ex) { // catch the error -- in case the process is no longer running LogTracer.Log(ex, "Process is no longer running"); } } return(LockProcesses); } else { LogTracer.Log("Could not list processes locking resource"); return(new List <Process>(0)); } } else if (Error != Win32Error.ERROR_SUCCESS) { LogTracer.Log("Could not list processes locking resource. Failed to get size of result."); return(new List <Process>(0)); } else { LogTracer.Log("Unknown error"); return(new List <Process>(0)); } } else { LogTracer.Log("Could not register resource"); return(new List <Process>(0)); } } finally { RstrtMgr.RmEndSession(SessionHandle); } }