WPF Apps Screen

public class AppFile
{
    public string Name { get; set; }
    public Icon Icon { get; set; }
    public string Path { get; set; }
}

Public Class AppFile
    Property Name As String
    Property Icon As Icon
    Property Path As String
End Class

public interface IAppsService
{
    IEnumerable<AppFile> GetApps();
    void LaunchApp(string path);
}

Public Interface IAppsService
    Function GetApps() As IEnumerable(Of AppFile)
    Sub LaunchApp(ByVal path As String)
End Interface

public class StartMenuService : IAppsService
{
    private string sharedDir =
        Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonStartMenu), "Programs");
    private string userDir =
        Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.StartMenu), "Programs");

    public IEnumerable<AppFile> GetApps()
    {
        var sharedFiles = Directory.EnumerateFiles(sharedDir, "*", SearchOption.AllDirectories).
            Where((f) => Path.GetExtension(f) == ".lnk");
        var userFiles = Directory.EnumerateFiles(userDir, "*", SearchOption.AllDirectories).
            Where((f) => Path.GetExtension(f) == ".lnk");

        var files = userFiles.Concat(sharedFiles).Select((f) => new FileInfo(f)).Distinct(new FileInfoComparer());
        var apps = files.Select((f) => new AppFile
        {
            Name = Path.GetFileNameWithoutExtension(f.FullName),
            Path = GetTargetPath(f.FullName),
            Icon = GetTargetIcon(GetTargetPath(f.FullName))
        });

        apps = apps.Where((t) => t.Path != string.Empty && t.Icon != null && t.Name.Contains("install") != true &&
        Path.GetExtension(t.Path).Contains(".exe", StringComparison.CurrentCultureIgnoreCase));

        return apps;
    }

    public void LaunchApp(string path)
    {
        if (!String.IsNullOrEmpty(path)) { Process.Start(path); }
    }

    private string GetTargetPath(string lnk)
    {
        WshShell ws = new WshShell();
        IWshShortcut shortcut;
        string target;

        try
        {
            shortcut = (IWshShortcut)ws.CreateShortcut(lnk);
            target = shortcut.TargetPath;
        }
        catch (Exception) { target = null; }
        return target;
    }

    private Icon GetTargetIcon(string target)
    {
        Icon ico;

        if (target != null)
        {
            try { ico = Icon.ExtractAssociatedIcon(target); }
            catch (Exception) { ico = null; }
        }
        else { ico = null; }
        return ico;
    }
}

Public Class StartMenuService
    Implements IAppsService

    Private sharedDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonStartMenu), "Programs")
    Private userDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.StartMenu), "Programs")

    Public Function GetApps() As IEnumerable(Of AppFile) Implements IAppsService.GetApps
        Dim sharedFiles = Directory.EnumerateFiles(sharedDir, "*", SearchOption.AllDirectories).
            Where(Function(f) Path.GetExtension(f) = ".lnk")
        Dim userFiles = Directory.EnumerateFiles(userDir, "*", SearchOption.AllDirectories).
            Where(Function(f) Path.GetExtension(f) = ".lnk")

        Dim files = userFiles.Concat(sharedFiles).Select(Function(f) New FileInfo(f)).Distinct(New FileInfoComparer)
        Dim apps = files.Select(Function(f) New AppFile With {
                                    .Name = Path.GetFileNameWithoutExtension(f.FullName),
                                    .Path = GetTargetPath(f.FullName),
                                    .Icon = GetTargetIcon(GetTargetPath(f.FullName))})

        apps = apps.Where(Function(t) t.Path <> String.Empty AndAlso t.Icon IsNot Nothing AndAlso
                              t.Name.Contains("install") <> True AndAlso
                              Path.GetExtension(t.Path).Contains(".exe", StringComparison.CurrentCultureIgnoreCase))
        Return apps
    End Function

    Public Sub LaunchApp(path As String) Implements IAppsService.LaunchApp
        If Not String.IsNullOrEmpty(path) Then
            Process.Start(path)
        End If
    End Sub

    Private Function GetTargetPath(ByVal lnk As String) As String
        Dim ws As New WshShell
        Dim shortcut As IWshShortcut
        Dim target As String

        Try
            shortcut = CType(ws.CreateShortcut(lnk), IWshShortcut)
            target = shortcut.TargetPath
        Catch ex As Exception
            target = Nothing
        End Try
        Return target
    End Function

    Private Function GetTargetIcon(ByVal target As String) As Icon
        Dim ico As Icon

        If target IsNot Nothing Then
            Try
                ico = Icon.ExtractAssociatedIcon(target)
            Catch ex As Exception
                ico = Nothing
            End Try
        Else
            ico = Nothing
        End If
        Return ico
    End Function
End Class

public class AppsViewModel : ViewModelBase
{
    private ObservableCollection<AppFile> _apps;
    public ObservableCollection<AppFile> Apps
    {
        get { return _apps; }
    }

    private ICommand _startAppCommand;
    public ICommand StartAppCommand
    {
        get
        {
            if (_startAppCommand == null) { _startAppCommand = new RelayCommand(LaunchApp); }
            return _startAppCommand;
        }
    }

    private ICommand _getAppsCommand;
    public ICommand GetAppsCommand
    {
        get
        {
            if (_getAppsCommand == null) { _getAppsCommand = new RelayCommand(GetApps); }
            return _getAppsCommand;
        }
    }

    private string _filter = string.Empty;
    public string Filter
    {
        set
        {
            _filter = value;
            if (appsView != null) { appsView.Refresh(); }
        }
    }

    private IAppsService appsService;
    private ICollectionView appsView;

    public AppsViewModel(IAppsService service)
    {
        appsService = service;
        _apps = new ObservableCollection<AppFile>();
        appsView = CollectionViewSource.GetDefaultView(Apps);
        appsView.Filter = (f) => { return (f as AppFile).Name.Contains(_filter, StringComparison.CurrentCultureIgnoreCase); };
    }

    private void LaunchApp(object o)
    {
        appsService.LaunchApp((o as AppFile).Path);
    }

    private void GetApps(object o)
    {
        if (_apps.Count > 0) { _apps.Clear(); };

        var ob = appsService.GetApps().ToObservable().SubscribeOn(Scheduler.Default).ObserveOn(SynchronizationContext.Current);
        ob.Subscribe((f) => _apps.Add(f));
    }

}

Public Class AppsViewModel
    Inherits ViewModelBase

    Private _apps As ObservableCollection(Of AppFile)
    Public ReadOnly Property Apps As ObservableCollection(Of AppFile)
        Get
            Return _apps
        End Get
    End Property

    Private _startAppCommand As ICommand
    Public ReadOnly Property StartAppCommand As ICommand
        Get
            If _startAppCommand Is Nothing Then
                _startAppCommand = New RelayCommand(AddressOf StartApp)
            End If
            Return _startAppCommand
        End Get
    End Property

    Private _getAppsCommand As ICommand
    Public ReadOnly Property GetAppsCommand As ICommand
        Get
            If _getAppsCommand Is Nothing Then
                _getAppsCommand = New RelayCommand(AddressOf GetApps)
            End If
            Return _getAppsCommand
        End Get
    End Property

    Private _filter As String = String.Empty
    Public WriteOnly Property Filter As String
        Set(value As String)
            _filter = value
            If appsView IsNot Nothing Then
                appsView.Refresh()
            End If
        End Set
    End Property

    Private appsService As IAppsService
    Private appsView As ICollectionView

    Public Sub New(service As IAppsService)
        appsService = service
        _apps = New ObservableCollection(Of AppFile)
        appsView = CollectionViewSource.GetDefaultView(_apps)
        appsView.Filter = Function(f) CType(f, AppFile).Name.Contains(_filter, StringComparison.CurrentCultureIgnoreCase)
    End Sub

    Private Sub StartApp(ByVal o As Object)
        Dim path = CType(o, AppFile).Path
        appsService.LaunchApp(path)
    End Sub

    Private Sub GetApps(ByVal o As Object)
        If _apps.Count > 0 Then
            _apps.Clear()
        End If

        Dim ob = appsService.GetApps().ToObservable().SubscribeOn(Scheduler.Default).ObserveOn(SynchronizationContext.Current)
        ob.Subscribe(Sub(f) _apps.Add(f))
    End Sub
End Class

class ViewModelLocator
{
    private UnityContainer container;

    public ViewModelLocator()
    {
        container = new UnityContainer();
        container.RegisterType<IAppsService, StartMenuService>();
    }

    public AppsViewModel AppsVM
    {
        get { return container.Resolve<AppsViewModel>(); }
    }
}

Public Class ViewModelLocator
    Private container As UnityContainer

    Public Sub New()
        container = New UnityContainer
        container.RegisterType(Of IAppsService, StartMenuService)()
    End Sub

    Public ReadOnly Property AppsVM As AppsViewModel
        Get
            Return container.Resolve(Of AppsViewModel)()
        End Get
    End Property
End Class

public static class Extensions
{        
    public static BitmapSource ToBitmapSource(this Icon ico)
    {
        IntPtr hIcon = ico.Handle;
        BitmapSource bmpSrc = null;

        try
        {
            bmpSrc = Imaging.CreateBitmapSourceFromHIcon(hIcon, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
        }
        catch (Exception)
        {
            bmpSrc = null;
        }

        return bmpSrc;
    }                
    ...
}

Module Extensions
    <Extension()>
    Function ToBitmapSource(ByVal ico As Icon) As BitmapSource
        Dim hIcon As IntPtr = ico.Handle
        Dim bmpSrc As BitmapSource

        Try
            bmpSrc = Imaging.CreateBitmapSourceFromHIcon(hIcon, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions())
        Catch ex As Exception
            bmpSrc = Nothing
        End Try

        Return bmpSrc
    End Function
    ...
End Module

public class MouseWheelScrollBehavior: Behavior<ScrollViewer>
{
    protected override void OnAttached()
    {
        base.OnAttached();
        AssociatedObject.PreviewMouseWheel += AssociatedObject_PreviewMouseWheel;
    }

    protected override void OnDetaching()
    {
        base.OnDetaching();
        AssociatedObject.PreviewMouseWheel -= AssociatedObject_PreviewMouseWheel;
    }

    protected void AssociatedObject_PreviewMouseWheel(object sender, MouseWheelEventArgs e)
    {
        if (e.Delta > 0)
        {
            AssociatedObject.LineLeft();
            e.Handled = true;
        }
        else
        {
            AssociatedObject.LineRight();
            e.Handled = true;
        }
    }
}

Public Class MouseWheelScrollBehavior
    Inherits Behavior(Of ScrollViewer)

    Protected Overrides Sub OnAttached()
        MyBase.OnAttached()
        AddHandler AssociatedObject.PreviewMouseWheel, AddressOf AssociatedObject_PreviewMouseWheel
    End Sub

    Protected Overrides Sub OnDetaching()
        MyBase.OnDetaching()
        AddHandler AssociatedObject.PreviewMouseWheel, AddressOf AssociatedObject_PreviewMouseWheel
    End Sub

    Private Sub AssociatedObject_PreviewMouseWheel(sender As Object, e As MouseWheelEventArgs)
        If e.Delta > 0 Then
            AssociatedObject.LineLeft()
            e.Handled = True
        Else
            AssociatedObject.LineRight()
            e.Handled = True
        End If
    End Sub
End Class

public partial class MainWindow : MetroWindow
{
    ...
    private void MainWindow_PreviewKeyDown(object sender, KeyEventArgs e)
    {
        if (FilterTextBox.IsKeyboardFocused != true)
        {
            Keyboard.Focus(FilterTextBox);
        }
    }
}

Class MainWindow
    Private Sub MainWindow_PreviewKeyDown(sender As Object, e As KeyEventArgs) Handles Me.PreviewKeyDown
        If FilterTextBox.IsKeyboardFocused <> True Then
            Keyboard.Focus(FilterTextBox)
        End If
    End Sub
End Class