public void Create (string file_path, string target_path)
 {
     link = (IShellLinkW) new CShellLink ();
     this.link.SetShowCmd (1);        
     this.link.SetPath (target_path);
     (this.link as IPersistFile).Save (file_path, true);
 }

 /// <summary>
 /// Creates an instance of the Shell Link object.
 /// </summary>
 public ShellLink()
 {
     if (System.Environment.OSVersion.Platform == PlatformID.Win32NT) {
         linkW = (IShellLinkW)new CShellLink();
     } else {
         linkA = (IShellLinkA)new CShellLink();
     }
 }

        ///
        /// <param name='linkPath'>
        ///   Path to new or existing shortcut file (.lnk).
        /// </param>
        ///
        public ShellShortcut(string linkPath)
        {
            IPersistFile pf;

            m_sPath = linkPath;
            m_Link = (IShellLinkW) new ShellLink();

            if (File.Exists(linkPath)) {
                pf = (IPersistFile) m_Link;
                pf.Load(linkPath, 0);
            }
        }

 public ShellLink(string lnkPath)
 {
     this.lnkPath = lnkPath;
     if (Unicode)
     {
         _slW = (IShellLinkW)Activator.CreateInstance(Type.GetTypeFromCLSID(new Guid(CLSID_ShellLink)));
         ((IPersistFile)(_slW)).Load(lnkPath, 0);
     }
     else
     {
         _slA = (IShellLinkA)Activator.CreateInstance(Type.GetTypeFromCLSID(new Guid(CLSID_ShellLink)));
         ((IPersistFile)(_slA)).Load(lnkPath, 0);
     }
 }

        /// <summary>
        /// Constructor with creating shell link object and loading shortcut file
        /// </summary>
        /// <param name="shortcutPath">Shortcut file path</param>
        public ShellLink(string shortcutPath)
        {
            try
            {
                shellLink = (IShellLinkW)new CShellLink();
            }
            catch (Exception ex)
            {
                throw new COMException("Failed to create Shell link object.", ex);
            }

            if (shortcutPath != null) // To avoid default constructor
                this.Load(shortcutPath);
        }

 private static extern void _SHAddToRecentDocs_ShellLink(SHARD uFlags, IShellLinkW pv);

 internal static void SHAddToRecentDocs(IShellLinkW shellLink)
 {
     SHAddToRecentDocs_ShellLink(SHARD.LINK, shellLink);
 }

        /// <summary>
        /// Generate a unique string for the ShellLink that can be used for equality checks.
        /// </summary>
        private static string ShellLinkToString(IShellLinkW shellLink)
        {
            var pathBuilder = new StringBuilder((int)Win32Value.MAX_PATH);
            shellLink.GetPath(pathBuilder, pathBuilder.Capacity, null, SLGP.RAWPATH);

            string title = null;
            // Need to use the property store to get the title for the link.
            using (PROPVARIANT pv = new PROPVARIANT())
            {
                var propStore = (IPropertyStore)shellLink;
                PKEY pkeyTitle = PKEY.Title;

                propStore.GetValue(ref pkeyTitle, pv);

                // PKEY_Title should be an LPWSTR if it's not empty.
                title = pv.GetValue() ?? "";
            }

            var argsBuilder = new StringBuilder((int)Win32Value.INFOTIPSIZE);
            shellLink.GetArguments(argsBuilder, argsBuilder.Capacity);

            // Path and title should be case insensitive.
            // Shell treats arguments as case sensitive because apps can handle those differently.
            return pathBuilder.ToString().ToUpperInvariant() + title.ToUpperInvariant() + argsBuilder.ToString();
        }

        public ShellLink(string linkFile)
        {
            try
            {
                if (Environment.OSVersion.Platform == PlatformID.Win32NT)
                {
                    shellLinkW = (IShellLinkW)new ShellLinkObject();
                    shellLinkA = null;
                }
                else
                {
                    shellLinkA = (IShellLinkA)new ShellLinkObject();
                    shellLinkW = null;
                }
            }
            catch
            {
                throw new COMException("cannot create ShellLinkObject");
            }

            if (linkFile != null)
                Load(linkFile);
        }

        public KfSymlink(LinkType shortcutlinkType)
        {
            dataBuffer = new StringBuilder(260);

            // Get a pointer to the IShellLink interface.
            switch (shortcutlinkType)
            {
                case LinkType.File:
                    psl = (IShellLinkW) Activator.CreateInstance(Type.GetTypeFromCLSID(new Guid(ClsidShellLink)), true);
                    break;
                case LinkType.Folder:
                    psl = (IShellLinkW) Activator.CreateInstance(Type.GetTypeFromCLSID(new Guid(ClsidFolderShortcut)), true);
                    break;
            }
        }

        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <exception cref="COMException">IShellLinkインターフェイスを取得できませんでした。</exception>
        public ShellLinkUtility()
        {
            currentFile = "";

            shellLinkW = null;
            shellLinkA = null;

            try
            {
                if (Environment.OSVersion.Platform == PlatformID.Win32NT)
                {
                    // Unicode環境
                    shellLinkW = (IShellLinkW)(new ShellLinkObject());

                    isUnicodeEnvironment = true;
                }
                else
                {
                    // Ansi環境
                    shellLinkA = (IShellLinkA)(new ShellLinkObject());

                    isUnicodeEnvironment = false;
                }
            }
            catch
            {
                throw new COMException("IShellLinkインターフェイスを取得できませんでした。");
            }
        }

 public ShellLink() {
     if (Environment.OSVersion.Platform == PlatformID.Win32NT)
         linkW = (IShellLinkW) new CShellLink();
     else
         linkA = (IShellLinkA) new CShellLink();
 }

 public static extern void SHAddToRecentDocs(SHARD uFlags, IShellLinkW pv);

        private string RemoveCustomCategoryLink(IShellLinkW link)
        {
            string path = null;

            if (customCategoriesCollection != null)
            {
                StringBuilder sb = new StringBuilder(256);
                link.GetPath(sb, sb.Capacity, IntPtr.Zero, 2);

                path = sb.ToString();

                // Remove this item from each category
                foreach (JumpListCustomCategory category in customCategoriesCollection)
                    category.RemoveJumpListItem(path);
            }

            return path;
        }

        /// <summary>
        /// <see cref="ShortcutClass"/> constructor
        /// </summary>
        /// <param name="linkPath">Path to existing shortcut file (.lnk).</param>
        public ShortcutClass(string linkPath)
        {
            try
            {
                Guid CLSID_ShellLink = new Guid("00021401-0000-0000-C000-000000000046");

                Type shellLink = Type.GetTypeFromCLSID(CLSID_ShellLink);
                link = (IShellLinkW)(Activator.CreateInstance(shellLink));

                if (File.Exists(linkPath))
                {
                    var pfile = (IPersistFile)link;
                    pfile.Load(linkPath, 0);
                }
            }
            catch (COMException)
            {
            }
        }

        public ShellLink(string path)
        {
            this.shellLink = Activator.CreateInstance(Type.GetTypeFromCLSID(new Guid("00021401-0000-0000-C000-000000000046"))) as IShellLinkW;
            if (File.Exists(path))
            {
                IntPtr consoleProperties = IntPtr.Zero;
                ((IPersistFile)this.shellLink).Load(path, 0);

                try
                {
                    ((IShellLinkDataList)this.shellLink).CopyDataBlock(0xA0000002, out consoleProperties);
                    this.consoleProperties = (NT_CONSOLE_PROPS)Marshal.PtrToStructure(consoleProperties, typeof(NT_CONSOLE_PROPS));
                }
                catch (Exception)
                {
                }
            }
            else
            {
                ((IPersistFile)this.shellLink).Save(path, true);
            }

            // Initialize default Console Properties (TODO: Fix this bug too)
            if (this.consoleProperties.dwSignature != 0xA0000002)
            {
                this.consoleProperties = new NT_CONSOLE_PROPS();
                this.consoleProperties.cbSize = Marshal.SizeOf(this.consoleProperties);
                this.consoleProperties.dwSignature = 0xA0000002;
                this.consoleProperties.ColorTable = new uint[16];
                for (int i = 0; i < 16; i++)
                {
                    this.consoleProperties.ColorTable[i] = 0xffffffff;
                }
            }
        }

 private void Initialize()
 {
     object obj2 = new CoShellLink();
     this.LinkW = obj2 as IShellLinkW;
     if (this.LinkW == null)
     {
         this.LinkA = obj2 as IShellLinkA;
         if (this.LinkA == null)
         {
             throw new NotSupportedException("IShellLink");
         }
     }
     this.PersistStream = obj2 as Microsoft.COM.IPersistStream;
     if (this.PersistStream == null)
     {
         throw new NotSupportedException("IPersistStream");
     }
 }

 public static void SHAddToRecentDocs(IShellLinkW shellLink)
 {
     _SHAddToRecentDocs_ShellLink(SHARD.LINK, shellLink);
 }

        // Construct with loading shortcut file.
        public ShellLink(string file) {
            try {
                shellLinkW = (IShellLinkW)new CShellLink();
            } catch {
                throw new COMException("Failed to create ShellLink object.");
            }

            if (file != null)
                Load(file);
        }

 public void Dispose () {
     if (this.link == null )
         return;
     
     Marshal.ReleaseComObject (this.link);
     this.link = null;
 }