Winify – Diff between revs 28 and 30

Subversion Repositories:

?pathlinks?

Rev 28 – Rev 38 – Go to most recent revision – Details – Blame – Last modification – View Log

 ï»¿using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Drawing;
 using System.IO;
 using System.Reflection;
-using System.Runtime.InteropServices;
+using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Forms;
 using Microsoft.Win32;
 namespace Winify.Utilities
+{
     public static class Miscellaneous
+    {
         #region Public Methods
-        public static TimeSpan GetIdleTime()
-        {
+        public static bool LaunchOnBootSet(bool enable)
-            var lastInPut = new Natives.LASTINPUTINFO();
+        {
-            lastInPut.cbSize = (uint)Marshal.SizeOf(lastInPut);
+            using var key = Registry.CurrentUser.OpenSubKey
-            Natives.GetLastInputInfo(ref lastInPut);
+                ("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
-            return TimeSpan.FromMilliseconds((uint)Environment.TickCount - lastInPut.dwTime);
-        }
         public static bool LaunchOnBootSet(bool enable)
-        {
-            using (var key = Registry.CurrentUser.OpenSubKey
-                       ("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true))
-            {
-                if (key == null) return false;
+            if (key == null) return false;
-                switch (enable)
+            switch (enable)
-                {
+            {
-                    case true:
+                case true:
-                        key.SetValue(Constants.AssemblyName, Assembly.GetEntryAssembly().Location);
+                    key.SetValue(Constants.AssemblyName, Assembly.GetEntryAssembly().Location);
-                        break;
-                    default:
+                    break;
-                        key.DeleteValue(Constants.AssemblyName, false);
+                default:
-                        break;
+                    key.DeleteValue(Constants.AssemblyName, false);
                     break;
+            }
             return true;
         }
-        public static bool LaunchOnBootGet()
         public static bool LaunchOnBootGet()
             using (var key = Registry.CurrentUser.OpenSubKey
-                       ("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true))
+            using var key = Registry.CurrentUser.OpenSubKey
                 ("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", true);
                 return key?.GetValue(Constants.AssemblyName) != null;
             return key?.GetValue(Constants.AssemblyName) != null;
+        }
         /// <summary>
+        ///     Enable double buffering for an arbitrary control.
-        ///     Enable double buffering for an arbitrary control.
+        /// </summary>
-        /// </summary>
+        /// <param name="control">the control to enable double buffering for</param>
-        /// <param name="control">the control to enable double buffering for</param>
+        /// <returns>true on success</returns>
-        /// <returns>true on success</returns>
+        /// <remarks>Do not enable double buffering on RDP: https://devblogs.microsoft.com/oldnewthing/20060103-12/?p=32793</remarks>
-        /// <remarks>Do not enable double buffering on RDP: https://devblogs.microsoft.com/oldnewthing/20060103-12/?p=32793</remarks>
+        public static void SetDoubleBuffered(this Control control)
-        public static bool SetDoubleBuffered(this Control control)
-        {
-            if (SystemInformation.TerminalServerSession) return false;
+        {
-            var dgvType = control.GetType();
+            // Double buffering can make DGV slow in remote desktop
-            var pi = dgvType.GetProperty("DoubleBuffered",
+            if (!SystemInformation.TerminalServerSession)
                 BindingFlags.Instance | BindingFlags.NonPublic);
-            if (pi == null) return false;
+                var dgvType = control.GetType();
                 var pi = dgvType.GetProperty("DoubleBuffered",
-            pi.SetValue(control, true, null);
+                    BindingFlags.Instance | BindingFlags.NonPublic);
-            return true;
+                pi.SetValue(control, true, null);
-        }
+            }
+        }
-        public static async Task<Icon> CreateIconFromResource(string resource)
-        {
-            var iconBytes = await LoadResource(resource);
+        public static async Task<Icon> CreateIconFromResource(string resource)
             using (var iconMemoryStream = new MemoryStream(iconBytes))
             var iconBytes = await LoadResource(resource);
-                var bitmap = (Bitmap)Image.FromStream(iconMemoryStream);
+            using var iconMemoryStream = new MemoryStream(iconBytes);
-                var bitmapIntPtr = bitmap.GetHicon();
+            var bitmap = (Bitmap)Image.FromStream(iconMemoryStream);
-                var icon = Icon.FromHandle(bitmapIntPtr);
-                return icon;
-            }
+            var bitmapIntPtr = bitmap.GetHicon();
-        }
+            var icon = Icon.FromHandle(bitmapIntPtr);
+            return icon;
-        public static async Task<byte[]> LoadResource(string resource)
+        }
-        {
+        public static async Task<byte[]> LoadResource(string resource)
             var assembly = Assembly.GetExecutingAssembly();
             var assembly = Assembly.GetExecutingAssembly();
             using (var manifestResourceStream = assembly.GetManifestResourceStream(resource))
             using var manifestResourceStream = assembly.GetManifestResourceStream(resource);
+            }
             action(control);
+        }
-        }
+        /// <summary>
-        public static T MapValueToRange<T>(this T value, T xMin, T xMax, T yMin, T yMax)
+        ///     Attempts to access a file within <see cref="timeout" /> milliseconds by retrying to access the file every
-            where T : struct, IComparable<T>, IConvertible
+        ///     <see cref="retry" /> milliseconds.
-        {
+        /// </summary>
-            return (dynamic)yMin +
+        /// <param name="path">the path to the file</param>
-                   ((dynamic)yMax - (dynamic)yMin) * ((dynamic)value - (dynamic)xMin) /
+        /// <param name="mode">the file mode used to access the file</param>
-                   ((dynamic)xMax - (dynamic)xMin);
+        /// <param name="access">the file access to use</param>
+        /// <param name="share">the file share to use</param>
+        /// <param name="cancellationToken">a cancellation token</param>
+        /// <param name="retry">the amount of milliseconds to retry between accesses to the file</param>
-        }
+        /// <param name="timeout">the amount of time in milliseconds to attempt and access the file</param>
+        /// <returns>a file stream if the file could be accessed within the allotted time</returns>
-        public static IEnumerable<TU> SequenceSubtract<TU, TV>(this IEnumerable<TU> a,
+        public static async Task<FileStream> GetFileStream(string path, FileMode mode, FileAccess access,
-            IEnumerable<TV> b,
+            FileShare share, CancellationToken cancellationToken,
-            Func<TU, TV, bool> cmp)
+            int retry = 1000, int timeout = 60000)
         {
-            var eb = new List<TV>(b);
+            var time = Stopwatch.StartNew();
-            using (var ea = a.GetEnumerator())
+            while (time.ElapsedMilliseconds < timeout && !cancellationToken.IsCancellationRequested)
-            {
-                while (ea.MoveNext())
-                {
-                    if (ea.Current == null) continue;
+            {
-                    foreach (var ib in eb)
-                    {
-                        if (cmp.Invoke(ea.Current, ib)) continue;
-                        yield return ea.Current;
                 try
+                {
+                    return new FileStream(path, mode, access, share);
+                }
+                catch (IOException e)
+                {
+                    // access error
+                    if (e.HResult != -2147024864) throw;
                         break;
+                await Task.Delay(retry, cancellationToken);
+            }
             throw new TimeoutException($"Failed to get a access to {path} within {timeout}ms.");
+        }