Mês: julho 2015

.Net: Classe para pesquisa de arquivos assíncrona e com múltiplos filtros – C#

Olá Pessoal,

Esse é o meu último dia de férias do trabalho (choro eterno), e acabei escrevendo um código para uma contribuição no MSDN que achei que seria interessante publicar.

É uma classe para pesquisa de arquivos assíncrona e que permite o uso de múltiplos filtros (de forma simultânea, na qual só serão retornados os resultados que satisfizerem a todos os filtros, de forma normal, onde serão retornados os arquivos que atendem a qualquer um dos filtros, mesmo que só um).

É um código simples, mas que na pressa, vale um Ctrl + C Ctrl + V. Enfim, segue o código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.IO;

namespace HL.IO
{
    public class FileSearch
    {
        private string[] _Filters;
        public string[] Filters
        {
            get { return _Filters; }
            set { _Filters = value; }
        }

        private SearchOptions _SearchOption;
        public SearchOptions SearchOption
        {
            get { return _SearchOption; }
            set { _SearchOption = value; }
        }

        public FileSearch(SearchOptions SearchOption, params string[] Filters)
        {
            _Filters = Filters;
            _SearchOption = SearchOption;
        }
        public FileSearch()
        {
            _SearchOption = SearchOptions.AllDirectories | SearchOptions.MatchAllFilters;
            _Filters = null;
        }
        public IEnumerable<string> Search(string RootFolder)
        {
            if (_SearchOption.HasFlag(SearchOptions.AllDirectories))
            {
                IEnumerable<string> result = Directory.EnumerateFiles(RootFolder, "*.*", System.IO.SearchOption.AllDirectories);
                if (_SearchOption.HasFlag(SearchOptions.MatchAllFilters))
                    return result.Where(s => Path.GetFileName(s).ContainsAll(_Filters,
                        _SearchOption.HasFlag(SearchOptions.CaseSensitive)));
                else
                    return result.Where(s => Path.GetFileName(s).ContainsAny(_Filters,
                        _SearchOption.HasFlag(SearchOptions.CaseSensitive)));
            }
            else
            {
                IEnumerable<string> result = Directory.EnumerateFiles(RootFolder, "*.*", System.IO.SearchOption.TopDirectoryOnly);
                if (_SearchOption.HasFlag(SearchOptions.MatchAllFilters))
                    return result.Where(s => Path.GetFileName(s).ContainsAll(_Filters,
                        _SearchOption.HasFlag(SearchOptions.CaseSensitive)));
                else
                    return result.Where(s => Path.GetFileName(s).ContainsAny(_Filters,
                        _SearchOption.HasFlag(SearchOptions.CaseSensitive)));
            }
        }

        #region Async
        public void AsyncSearch(string RootFolder)
        {
            SynchronizationContext context = SynchronizationContext.Current;
            if (context == null)
            {
                context = new System.Threading.SynchronizationContext();
            }
            Thread th = new Thread(new ThreadStart(() =>
            {
                IEnumerable<string> result = Search(RootFolder);
                context.Send(new SendOrPostCallback((object state) =>
                {
                    OnAsyncSearchCompleted((IEnumerable<string>)state);
                }), result);
            }));
            th.IsBackground = false;
            th.SetApartmentState(ApartmentState.STA);
            th.Start();
        }
        public event AsyncSearchCompletedEventHandler AsyncSearchCompleted;
        protected virtual void OnAsyncSearchCompleted(IEnumerable<string> Result)
        {
            if (AsyncSearchCompleted != null)
            {
                AsyncSearchCompleted(this, new AsyncSearchCompletedEventArgs(Result));
            }
        }
        #endregion
    }

    public delegate void AsyncSearchCompletedEventHandler(object sender, AsyncSearchCompletedEventArgs e);

    public class AsyncSearchCompletedEventArgs
    {
        private IEnumerable<string> _result;
        public IEnumerable<string> Result
        {
            get { return _result; }
        }
        public AsyncSearchCompletedEventArgs(IEnumerable<string> Result)
        {
            _result = Result;
        }
    }
    public enum SearchOptions : int
    {
        /// <summary>
        /// The search engine will seach only on top level of the given root folder.
        /// </summary>
        TopDirectoryOnly = 1,
        /// <summary>
        /// The search engine will search in all the directory tree starting from the given root folder
        /// </summary>
        AllDirectories = 2,
        /// <summary>
        /// The search engine will use case sensitive approach.
        /// </summary>
        CaseSensitive = 4,
        /// <summary>
        /// If set, the search engine will return only the results matching all the filters.
        /// </summary>
        MatchAllFilters = 8
    };
    public static class StringExtensions
    {
        public static bool ContainsAll(this string Source, string[] strs, bool CaseSensitive)
        {
            foreach (string str in strs)
            {
                if (CaseSensitive)
                {
                    if (!Source.Contains(str)) return false;
                }
                else
                {
                    if (!Source.ToLower().Contains(str.ToLower())) return false;
                }
            }
            return true;
        }

        public static bool ContainsAny(this string Source, string[] strs, bool CaseSensitive)
        {
            foreach (string str in strs)
            {
                if (CaseSensitive)
                {
                    if (Source.Contains(str)) return true;
                }
                else
                {
                    if (Source.ToLower().Contains(str.ToLower())) return true;
                }
            }
            return false;
        }
    }
}

Mostrarei também um pequeno exemplo:

        private void btnSearch_Click(object sender, EventArgs e)
        {
            FolderBrowserDialog dialog = new FolderBrowserDialog();
            dialog.ShowDialog();
            FileSearch searcher = new FileSearch(SearchOptions.AllDirectories, ".png", ".bmp", ".jpeg");
            searcher.AsyncSearchCompleted += searcher_AsyncSearchCompleted;
            searcher.AsyncSearch(dialog.SelectedPath);
        }

        private void searcher_AsyncSearchCompleted(object sender, AsyncSearchCompletedEventArgs e)
        {
            listBox1.Items.Clear();
            listBox1.Items.AddRange(e.Result.ToArray());
        }

No exemplo acima a classe FileSearch é usada para encontrar todos os arquivos PNG, BMP e JPEG da pasta informada. Isso é bem básico, mas dá para fazer bastante coisa. Incluir uma palavra chave que o nome do arquivo deve conter também é uma opção. E o melhor de tudo, assíncrono. Não irá congelar a interface de usuário enquanto realiza a busca.

That’s all folks!!!

Win Forms: Teclas de atalho globais – C#

Fala aí galera. Tudo certo?!

Já faz um certo tempo que não posto aqui no blog, e também um tempinho que eu não contribuo no MSDN.

Então, receba esse post!!!

Já ouviu falar das teclas de atalho globais, ou Global Hot Keys? Se não segue uma explicação curta:

Teclas de atalho globais são combinações de teclas, sempre usando um modificador (Ctrl ou/e Alt ou/e Shift), que executam ações na sua aplicação, mesmo ela estando minimizada ou oculta! Por isso o Globais.

Baseado em .net – Set global hotkeys using C# – Stack Overflow, eu fiz alguns pequenos ajustes, para conseguir o código final abaixo. Uma classe que permite registrar ou remover Global Hot Keys para sua aplicação:

/*
O código foi obtido na thread abaixo, e modificado por mim, Herbert Lausmann:
http://stackoverflow.com/questions/2450373/set-global-hotkeys-using-c-sharp
Créditos ao criador, AaronLS.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace System.Windows.Forms
{
    public sealed class KeyboardHotKeys : IDisposable
    {
        #region Class Code
        // Registers a hot key with Windows.
        [DllImport("user32.dll")]
        private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
        // Unregisters the hot key with Windows.
        [DllImport("user32.dll")]
        private static extern bool UnregisterHotKey(IntPtr hWnd, int id);

        /// <summary>
        /// Represents the window that is used internally to get the messages.
        /// </summary>
        private class Window : NativeWindow, IDisposable
        {
            private static int WM_HOTKEY = 0x0312;

            public Window()
            {
                // create the handle for the window.
                this.CreateHandle(new CreateParams());
            }

            /// <summary>
            /// Overridden to get the notifications.
            /// </summary>
            /// <param name="m"></param>
            protected override void WndProc(ref Message m)
            {
                base.WndProc(ref m);

                // check if we got a hot key pressed.
                if (m.Msg == WM_HOTKEY)
                {
                    // get the keys.
                    Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);
                    ModifierKeys modifier = (ModifierKeys)((int)m.LParam & 0xFFFF);

                    // invoke the event to notify the parent.
                    if (KeyPressed != null)
                        KeyPressed(this, new KeyPressedEventArgs(modifier, key));
                }
            }

            public event EventHandler<KeyPressedEventArgs> KeyPressed;

            #region IDisposable Members

            public void Dispose()
            {
                this.DestroyHandle();
            }

            #endregion
        }

        private Window _window = new Window();
        private int _currentId;

        public KeyboardHotKeys()
        {
            // register the event of the inner native window.
            _window.KeyPressed += delegate(object sender, KeyPressedEventArgs args)
            {
                if (KeyPressed != null)
                    KeyPressed(this, args);
            };
        }

        /// <summary>
        /// Registers a hot key in the system.
        /// </summary>
        /// <param name="modifier">The modifiers that are associated with the hot key.</param>
        /// <param name="key">The key itself that is associated with the hot key.</param>
        public void RegisterHotKey(ModifierKeys modifier, Keys key)
        {
            // increment the counter.
            _currentId = _currentId + 1;

            // register the hot key.
            if (!RegisterHotKey(_window.Handle, _currentId, (uint)modifier, (uint)key))
                throw new InvalidOperationException("Couldn’t register the hot key.");
        }

        /// <summary>
        /// A hot key has been pressed.
        /// </summary>
        public event EventHandler<KeyPressedEventArgs> KeyPressed;

        #region IDisposable Members

        public void Dispose()
        {
            // unregister all the registered hot keys.
            for (int i = _currentId; i > 0; i--)
            {
                UnregisterHotKey(_window.Handle, i);
            }

            // dispose the inner native window.
            _window.Dispose();
        }

        #endregion

        #region Others

        /// <summary>
        /// Event Args for the event that is fired after the hot key has been pressed.
        /// </summary>
        public class KeyPressedEventArgs : EventArgs
        {
            private ModifierKeys _modifier;
            private Keys _key;

            internal KeyPressedEventArgs(ModifierKeys modifier, Keys key)
            {
                _modifier = modifier;
                _key = key;
            }

            public ModifierKeys Modifier
            {
                get { return _modifier; }
            }

            public Keys Key
            {
                get { return _key; }
            }
        }

        /// <summary>
        /// The enumeration of possible modifiers.
        /// </summary>
        [Flags]
        public enum ModifierKeys : uint
        {
            Alt = 1,
            Control = 2,
            Shift = 4,
            Win = 8
        }
        #endregion
        #endregion
        #region Singleton
        private static KeyboardHotKeys _Current;
        public static KeyboardHotKeys Current
        {
            get
            {
                if (_Current == null)
                    _Current = new KeyboardHotKeys();
                return _Current;
            }
        }
        #endregion
    }
}

Dessa forma, você poderá criar teclas de atalho globais para sua aplicação, de uma maneira extremamente simples. Exemplo abaixo:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Global_Hot_Keys
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            KeyboardHotKeys.Current.KeyPressed += Current_KeyPressed;
            KeyboardHotKeys.Current.RegisterHotKey(KeyboardHotKeys.ModifierKeys.Control | KeyboardHotKeys.ModifierKeys.Alt, Keys.T);
        }

        void Current_KeyPressed(object sender, KeyboardHotKeys.KeyPressedEventArgs e)
        {
            if (e.Modifier == (KeyboardHotKeys.ModifierKeys.Control | KeyboardHotKeys.ModifierKeys.Alt))
            {
                if (e.Key == Keys.T)
                {
                    this.WindowState = FormWindowState.Normal;
                    MessageBox.Show("Você pressionou o atalho Ctrl + Alt + T !!!!!!!!!!!!!!!!!!");
                }
            }
        }
    }
}

Espero que possa ser útil à alguém!