Powershell: Windows 10 Modern Apps an Startmenü anheften oder entfernen (Pin oder Unpin)

Add-Type -Path "D:\PinTo10DLL.dll"  
$p = [Pinto10DLL.Utils]::PinUnpinTaskbar("Microsoft Edge", $false, $true);  
$p = [Pinto10DLL.Utils]::PinUnpinTaskbar("Outlook 2013", $false, $true);  

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace Pinto10DLL
{
    static public class Utils
    {
        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true, BestFitMapping = false, ThrowOnUnmappableChar = true)]  
        internal static extern IntPtr LoadLibrary(string lpLibFileName);
        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true, BestFitMapping = false, ThrowOnUnmappableChar = true)]  
        internal static extern int LoadString(IntPtr hInstance, uint wID, StringBuilder lpBuffer, int nBufferMax);

        public static bool PinUnpinTaskbar(string filePath, bool pin, bool taskbar=true)
        {
            bool success = false;
            try
            {
                ChangeImagePathName("explorer.exe");  

                bool isModern = !(filePath.StartsWith(@"\\") || filePath.Substring(1).StartsWith(@":"));  



                if (!isModern && !File.Exists(filePath)) throw new FileNotFoundException(filePath);
                int MAX_PATH = 255;
                // 5386 is the DLL index for"Pin to Tas&kbar", ref. http://www.win7dll.info/shell32_dll.html 
                //uncomment the following line to pin to start instead
                //actionIndex = pin ? 51201 : 51394;
                var actionIndex = 0;
                if (taskbar) { actionIndex = pin ? 5386 : 5387; }
                
                Version os = Environment.OSVersion.Version;
                if (!taskbar && (os.Major == 6 && os.Minor == 1))
                {
                    actionIndex = pin ? 5381 : 5382;
                }
                else if (!taskbar)
                {
                    actionIndex = pin ? 51201 : 51394;
                }


                StringBuilder szPinToStartLocalized = new StringBuilder(MAX_PATH);
                IntPtr hShell32 = LoadLibrary("Shell32.dll");  
                LoadString(hShell32, (uint)actionIndex, szPinToStartLocalized, MAX_PATH);
                string localizedVerb = szPinToStartLocalized.ToString();

                string path = isModern ? "shell:AppsFolder" : Path.GetDirectoryName(filePath);  
                string fileName = isModern ? filePath.Trim().ToUpper() : Path.GetFileName(filePath);

                //Console.WriteLine(filePath + ": " + isModern.ToString()); 
//                Console.WriteLine(path + "\\" + fileName); 
//                Console.ReadLine();

                // create the shell application object
                dynamic shellApplication = Activator.CreateInstance(Type.GetTypeFromProgID("Shell.Application"));  
                dynamic directory = shellApplication.NameSpace(path);
                dynamic link = null; // directory.ParseName(fileName);



                if (!isModern)
                    link = directory.ParseName(fileName);
                else
                {
                    //// modern apps ////
                    var items = directory.Items;
                    foreach (var item in items)
                    {
                        if (item.Name.ToUpper() == fileName.ToUpper())
                        {
                            link = item;
                            break;
                        }
                    }
                    //// modern apps ////
                }


                dynamic verbs = link.Verbs();
                string verbstring = "";  
                for (int i = 0; i < verbs.Count(); i++)
                {
                    dynamic verb = verbs.Item(i);
                    var name = verb.Name;
                    if (verb.Name.Equals(localizedVerb))
                    {
//                        verbstring += "!!!"; 
                        verb.DoIt();
                        success = true;
                    }

                    verbstring += name + Environment.NewLine;
                    

                }
//                Console.WriteLine(verbstring);
//                Console.ReadLine();

            }
            catch
            {
                success=false;
            }
            finally {
                RestoreImagePathName();
            }
            return success;
        }

        static string originalImagePathName;
        static int unicodeSize = IntPtr.Size * 2;
        static bool changed;
        static void GetPointers(out IntPtr imageOffset, out IntPtr imageBuffer)
        {
            IntPtr pebBaseAddress = GetBasicInformation().PebBaseAddress;
            var processParameters = Marshal.ReadIntPtr(pebBaseAddress, 4 * IntPtr.Size);
            imageOffset = processParameters.Increment(4 * 4 + 5 * IntPtr.Size + unicodeSize + IntPtr.Size + unicodeSize);
            imageBuffer = Marshal.ReadIntPtr(imageOffset, IntPtr.Size);
        }
        internal static void ChangeImagePathName(string newFileName)
        {
            IntPtr imageOffset, imageBuffer;
            GetPointers(out imageOffset, out imageBuffer);

            //Read original data
            var imageLen = Marshal.ReadInt16(imageOffset);
            originalImagePathName = Marshal.PtrToStringUni(imageBuffer, imageLen / 2);

            var newImagePathName = Path.Combine(Path.GetDirectoryName(originalImagePathName), newFileName);
            if (newImagePathName.Length > originalImagePathName.Length) throw new Exception("new ImagePathName cannot be longer than the original one");  

            //Write the string, char by char
            var ptr = imageBuffer;
            foreach (var unicodeChar in newImagePathName)
            {
                Marshal.WriteInt16(ptr, unicodeChar);
                ptr = ptr.Increment(2);
            }
            changed = true;
            Marshal.WriteInt16(ptr, 0);

            //Write the new length
            Marshal.WriteInt16(imageOffset, (short)(newImagePathName.Length * 2));
        }
        internal static void RestoreImagePathName()
        {
            if (!changed) return;
            IntPtr imageOffset, ptr;
            GetPointers(out imageOffset, out ptr);

            foreach (var unicodeChar in originalImagePathName)
            {
                Marshal.WriteInt16(ptr, unicodeChar);
                ptr = ptr.Increment(2);
            }
            Marshal.WriteInt16(ptr, 0);
            Marshal.WriteInt16(imageOffset, (short)(originalImagePathName.Length * 2));
        }
        public static ProcessBasicInformation GetBasicInformation()
        {
            uint status;
            ProcessBasicInformation pbi;
            int retLen;
            var handle = System.Diagnostics.Process.GetCurrentProcess().Handle;
            if ((status = NtQueryInformationProcess(handle, 0,
                out pbi, Marshal.SizeOf(typeof(ProcessBasicInformation)), out retLen)) >= 0xc0000000)
                throw new Exception("Windows exception. status=" + status);  
            return pbi;
        }
        public static IntPtr Increment(this IntPtr ptr, int value)
        {
            unchecked
            {
                if (IntPtr.Size == sizeof(Int32))
                    return new IntPtr(ptr.ToInt32() + value);
                else
                    return new IntPtr(ptr.ToInt64() + value);
            }
        }
        [DllImport("ntdll.dll")] public static extern uint NtQueryInformationProcess([In] IntPtr ProcessHandle, [In] int ProcessInformationClass, [Out] out ProcessBasicInformation ProcessInformation, [In] int ProcessInformationLength, [Out] [Optional] out int ReturnLength);  
        [StructLayout(LayoutKind.Sequential)] public struct ProcessBasicInformation
        {
            public uint ExitStatus;
            public IntPtr PebBaseAddress;
            public IntPtr AffinityMask;
            public int BasePriority;
            public IntPtr UniqueProcessId;
            public IntPtr InheritedFromUniqueProcessId;
        }
    }
}