Beispiel #1
0
        /// <include file='doc\PropertySheet.uex' path='docs/doc[@for="LanguagePreferences.Init"]/*' />
        public virtual void Init()
        {
            ILocalRegistry3 localRegistry = site.GetService(typeof(SLocalRegistry)) as ILocalRegistry3;
            string          root          = null;

            if (localRegistry != null)
            {
                NativeMethods.ThrowOnFailure(localRegistry.GetLocalRegistryRoot(out root));
            }
            if (root != null)
            {
                using (RegistryKey key = Registry.LocalMachine.OpenSubKey(root, false)) {
                    if (key != null)
                    {
                        InitMachinePreferences(key, name);
                    }
                }
                using (RegistryKey key = Registry.CurrentUser.OpenSubKey(root, false)) {
                    if (key != null)
                    {
                        InitUserPreferences(key, name);
                    }
                }
            }
            Connect();
            localRegistry = null;
        }
Beispiel #2
0
        public virtual void Init()
        {
            ILocalRegistry3 localRegistry = (ILocalRegistry3)site.GetService(typeof(SLocalRegistry));
            string          root          = null;

            if (localRegistry != null)
            {
                localRegistry.GetLocalRegistryRoot(out root);
            }
            if (root != null)
            {
                using (RegistryKey key = Registry.LocalMachine.OpenSubKey(root, false)) {
                    if (key != null)
                    {
                        InitMachinePreferences(key, editorName);
                    }
                }
                using (RegistryKey key = Registry.CurrentUser.OpenSubKey(root, false)) {
                    if (key != null)
                    {
                        InitUserPreferences(key, editorName);
                    }
                }
            }
            localRegistry = null;
        }
Beispiel #3
0
        public virtual void SetSite(Microsoft.VisualStudio.OLE.Interop.IServiceProvider psp)
        {
            this.site = new ServiceProvider(psp);

            extensions = new Hashtable();
            ILocalRegistry3 localRegistry = (ILocalRegistry3)site.QueryService(VsConstants.SID_SLocalRegistry, typeof(ILocalRegistry3));
            string          root          = null;

            if (localRegistry != null)
            {
                localRegistry.GetLocalRegistryRoot(out root);
            }
            using (RegistryKey rootKey = Registry.LocalMachine.OpenSubKey(root)) {
                if (rootKey != null)
                {
                    string relpath = "Editors\\{" + this.GetType().GUID.ToString() + "}\\Extensions";
                    using (RegistryKey key = rootKey.OpenSubKey(relpath, false)) {
                        if (key != null)
                        {
                            foreach (string ext in key.GetValueNames())
                            {
                                extensions.Add(ext.ToLower(), ext);
                            }
                        }
                    }
                }
            }
        }
Beispiel #4
0
        public static string GetMsBuildPath(IServiceProvider serviceProvider)
        {
            string registryPath;

            if (serviceProvider == null)
            {
                return(String.Empty);
            }

            ILocalRegistry3 localRegistry = serviceProvider.GetService(typeof(SLocalRegistry)) as ILocalRegistry3;

            if (localRegistry == null)
            {
                return(String.Empty);
            }

            // first, we need the registry hive currently in use
            ErrorHandler.ThrowOnFailure(localRegistry.GetLocalRegistryRoot(out registryPath));
            // now that we have it, append the subkey we are interested in to it
            if (!registryPath.EndsWith("\\"))
            {
                registryPath += '\\';
            }
            registryPath += "MSBuild";
            // finally, get the value from the registry
            Microsoft.Win32.RegistryKey key = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(registryPath, false);
            string msBuildPath = (string)key.GetValue("MSBuildBinPath", null);

            if (msBuildPath == null || msBuildPath.Length <= 0)
            {
                string error = SR.GetString(SR.ErrorMsBuildRegistration);
                throw new FileLoadException(error);
            }
            return(msBuildPath);
        }
Beispiel #5
0
        public RegistryKey OpenVSUserKey(string name)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            RegistryKey rootKey = null;

            if (VSVersion.VS2005)
            {
                ILocalRegistry3 lr3 = GetService <ILocalRegistry3>(typeof(SLocalRegistry));

                if (lr3 == null)
                {
                    return(null);
                }

                string root;

                if (!VSErr.Succeeded(lr3.GetLocalRegistryRoot(out root)))
                {
                    return(null);
                }

                rootKey = Registry.CurrentUser.OpenSubKey(root);
            }
            else
            {
                IMyLocalRegistry4 lr4 = GetService <IMyLocalRegistry4>(typeof(SLocalRegistry));

                if (lr4 == null)
                {
                    return(null);
                }

                uint       type;
                const uint VsLocalRegistryRootHandle_CURRENT_USER = unchecked ((uint)-2147483647);
                string     root;
                if (!VSErr.Succeeded(lr4.GetLocalRegistryRootEx(1 /* _VsLocalRegistryType.UserSettings */, out type, out root)))
                {
                    return(null);
                }

                rootKey = ((type == VsLocalRegistryRootHandle_CURRENT_USER) ? Registry.CurrentUser : Registry.LocalMachine).OpenSubKey(root);
            }

            if (rootKey == null)
            {
                return(null);
            }
            else if (string.IsNullOrEmpty(name))
            {
                return(rootKey);
            }

            using (rootKey)
            {
                return(rootKey.OpenSubKey(name));
            }
        }
Beispiel #6
0
        static Hashtable GetEditors(IServiceProvider site)
        {
            if (EditorFactory.editors != null)
            {
                return(EditorFactory.editors);
            }

            Hashtable       editors       = new Hashtable();
            ILocalRegistry3 localRegistry = site.GetService(typeof(SLocalRegistry)) as ILocalRegistry3;
            string          root          = null;

            if (localRegistry == null)
            {
                return(editors);
            }
            NativeMethods.ThrowOnFailure(localRegistry.GetLocalRegistryRoot(out root));
            using (RegistryKey rootKey = Registry.LocalMachine.OpenSubKey(root)) {
                if (rootKey != null)
                {
                    RegistryKey editorsKey = rootKey.OpenSubKey("Editors", false);
                    if (editorsKey != null)
                    {
                        using (editorsKey) {
                            foreach (string editorGuid in editorsKey.GetSubKeyNames())
                            {
                                Guid guid = GetGuid(editorGuid);
                                using (RegistryKey editorKey = editorsKey.OpenSubKey(editorGuid, false)) {
                                    object      value      = editorKey.GetValue(null);
                                    string      name       = (value != null) ? value.ToString() : editorGuid.ToString();
                                    RegistryKey extensions = editorKey.OpenSubKey("Extensions", false);
                                    if (extensions != null)
                                    {
                                        foreach (string s in extensions.GetValueNames())
                                        {
                                            if (!string.IsNullOrEmpty(s))
                                            {
                                                EditorInfo ei = new EditorInfo();
                                                ei.name = name;
                                                ei.guid = guid;
                                                object obj = extensions.GetValue(s);
                                                if (obj is int)
                                                {
                                                    ei.priority = (int)obj;
                                                }
                                                string ext = (s == "*") ? s : "." + s;
                                                AddEditorInfo(editors, ext.ToLowerInvariant(), ei);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return(EditorFactory.editors = editors);
        }
Beispiel #7
0
        StringDictionary GetFileExtensionMappings()
        {
            ILocalRegistry3 localRegistry = site.GetService(typeof(SLocalRegistry)) as ILocalRegistry3;
            string          root          = null;

            if (localRegistry != null)
            {
                NativeMethods.ThrowOnFailure(localRegistry.GetLocalRegistryRoot(out root));
            }
            StringDictionary map = new StringDictionary();
            RegistryKey      key = Registry.CurrentUser.OpenSubKey(root + "\\FileExtensionMapping", false);

            if (key != null)
            {
                using (key) {
                    foreach (string name in key.GetSubKeyNames())
                    {
                        using (RegistryKey extkey = key.OpenSubKey(name, false)) {
                            if (extkey != null)
                            {
                                object obj = extkey.GetValue(null);
                                if (obj is string)
                                {
                                    string ext = "." + name;
                                    map[ext] = obj.ToString(); // extension -> editor.
                                }
                            }
                        }
                    }
                }
            }

            // Also pick up the "default editors" information
            key = Registry.CurrentUser.OpenSubKey(root + "\\Default Editors", false);
            if (key != null)
            {
                using (key) {
                    foreach (string name in key.GetSubKeyNames())
                    {
                        using (RegistryKey extkey = key.OpenSubKey(name, false)) {
                            if (extkey != null)
                            {
                                object obj = extkey.GetValue("Custom");
                                if (obj is string)
                                {
                                    string ext = "." + name;
                                    map[ext] = obj.ToString(); // extension -> editor.
                                }
                            }
                        }
                    }
                }
            }
            return(map);
        }
        // =========================================================================================
        // Constructors
        // =========================================================================================

        /// <summary>
        /// Initializes a new instance of the <see cref="WixPackageSettings"/> class.
        /// </summary>
        /// <param name="serviceProvider">The <see cref="IServiceProvider"/> to use.</param>
        public WixPackageSettings(IServiceProvider serviceProvider)
        {
            WixHelperMethods.VerifyNonNullArgument(serviceProvider, "serviceProvider");

            if (serviceProvider != null)
            {
                // get the Visual Studio registry root
                ILocalRegistry3 localRegistry = WixHelperMethods.GetService <ILocalRegistry3, SLocalRegistry>(serviceProvider);
                ErrorHandler.ThrowOnFailure(localRegistry.GetLocalRegistryRoot(out this.visualStudioRegistryRoot));
            }
        }
Beispiel #9
0
        // =========================================================================================
        // Constructors
        // =========================================================================================

        /// <summary>
        /// Initializes a new instance of the <see cref="XPackageSettings"/> class.
        /// </summary>
        /// <param name="serviceProvider">The <see cref="IServiceProvider"/> to use.</param>
        public XPackageSettings(IServiceProvider serviceProvider)
        {
            XHelperMethods.VerifyNonNullArgument(serviceProvider, "serviceProvider");
            ThreadHelper.ThrowIfNotOnUIThread();

            if (serviceProvider != null)
            {
                // get the Visual Studio registry root
                ILocalRegistry3 localRegistry = XHelperMethods.GetService <ILocalRegistry3, SLocalRegistry>(serviceProvider);
                ErrorHandler.ThrowOnFailure(localRegistry.GetLocalRegistryRoot(out this.visualStudioRegistryRoot));
            }
            Instance = this;
        }
        private bool GetValue(out object newValue)
        {
            string          regRoot         = "8.0";
            ILocalRegistry3 registryService = GetService <SLocalRegistry>() as ILocalRegistry3;

            if (registryService != null)
            {
                registryService.GetLocalRegistryRoot(out regRoot);
            }

            newValue = regRoot;
            return(true);
        }
Beispiel #11
0
        /// <summary>
        /// Search the registry fir the tool path for MSBuild.
        /// </summary>
        public static string GetMsBuildPath(IServiceProvider serviceProvider, string msbuildVersion)
        {
            string registryPath;

            if (serviceProvider == null)
            {
                return(String.Empty);
            }

            ILocalRegistry3 localRegistry = serviceProvider.GetService(typeof(SLocalRegistry)) as ILocalRegistry3;

            if (localRegistry == null)
            {
                return(String.Empty);
            }

            // first, we need the registry hive currently in use
            ErrorHandler.ThrowOnFailure(localRegistry.GetLocalRegistryRoot(out registryPath));
            // now that we have it, append the subkey we are interested in to it
            if (!registryPath.EndsWith("\\"))
            {
                registryPath += '\\';
            }
            registryPath += "MSBuild";
            // finally, get the value from the registry
            string msBuildPath = null;

            using (Microsoft.Win32.RegistryKey vsKey = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(registryPath, false))
            {
                msBuildPath = (string)vsKey.GetValue("MSBuildBinPath", null);
            }
            if (!string.IsNullOrEmpty(msBuildPath))
            {
                return(msBuildPath);
            }

            // The path to MSBuild was not found in the VisualStudio's registry hive, so try to
            // find it in the new MSBuild hive.
            registryPath = string.Format(CultureInfo.InvariantCulture, "Software\\Microsoft\\MSBuild\\ToolsVersions\\{0}", msbuildVersion);
            using (Microsoft.Win32.RegistryKey msbuildKey = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(registryPath, false))
            {
                msBuildPath = (string)msbuildKey.GetValue("MSBuildToolsPath", null);
            }
            if (string.IsNullOrEmpty(msBuildPath))
            {
                string error = SR.GetString(SR.ErrorMsBuildRegistration);
                throw new FileLoadException(error);
            }
            return(msBuildPath);
        }
Beispiel #12
0
        // =========================================================================================
        // Constructors
        // =========================================================================================

        /// <summary>
        /// Initializes a new instance of the <see cref="WixPackageSettings"/> class.
        /// </summary>
        /// <param name="serviceProvider">The <see cref="IServiceProvider"/> to use.</param>
        public WixPackageSettings(IServiceProvider serviceProvider)
        {
            WixHelperMethods.VerifyNonNullArgument(serviceProvider, "serviceProvider");

            // get the Visual Studio registry root
            ILocalRegistry3 localRegistry = WixHelperMethods.GetService <ILocalRegistry3, SLocalRegistry>(serviceProvider);

            ErrorHandler.ThrowOnFailure(localRegistry.GetLocalRegistryRoot(out this.visualStudioRegistryRoot));

            this.machineRootPath = WixHelperMethods.RegistryPathCombine(this.visualStudioRegistryRoot, @"InstalledProducts\WiX");

            // initialize all of the machine settings
            this.toolsDirectory = new MachineSettingString(this.machineRootPath, KeyNames.ToolsDirectory, String.Empty);
        }
Beispiel #13
0
        public static object CreateInstance(ServiceProvider provider, ref Guid clsid, ref Guid iid, Type t)
        {
            ILocalRegistry3 localRegistry = (ILocalRegistry3)provider.QueryService(VsConstants.SID_SLocalRegistry, typeof(ILocalRegistry3));

            IntPtr pUnk;

            localRegistry.CreateInstance(clsid, null, ref iid, VsConstants.CLSCTX_INPROC_SERVER, out pUnk);
            localRegistry = null;

            object result = Marshal.GetTypedObjectForIUnknown(pUnk, t);

            Marshal.Release(pUnk);
            return(result);
        }
Beispiel #14
0
        /// <summary>
        /// Return the current vs hive in where gax is executed.
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentVsHive()
        {
            string          regRoot  = null;
            ILocalRegistry3 registry = Package.GetGlobalService(typeof(SLocalRegistry)) as ILocalRegistry3;

            // if we're at design-time try the VS service
            if (registry != null)
            {
                ErrorHandler.ThrowOnFailure(registry.GetLocalRegistryRoot(out regRoot));

                regRoot = regRoot.Replace(VisualStudioRoot, string.Empty);
                return(regRoot.Split('\\')[0]);
            }

            return("14.0_Config");
        }
Beispiel #15
0
        public virtual ILanguageService CreateLanguageService(ref Guid guid)
        {
            ILocalRegistry3 localRegistry = (ILocalRegistry3)this.site.GetService(typeof(SLocalRegistry));
            string          root          = null;

            if (localRegistry != null)
            {
                localRegistry.GetLocalRegistryRoot(out root);
            }
            string guidStr = guid.ToString("B");

            using (RegistryKey rootKey = Registry.LocalMachine.OpenSubKey(root)){
                Debug.Assert(rootKey != null);
                if (rootKey != null)
                {
                    using (RegistryKey clsidKey = rootKey.OpenSubKey("CLSID")){
                        Debug.Assert(clsidKey != null);
                        if (clsidKey != null)
                        {
                            foreach (string clsid in clsidKey.GetSubKeyNames())
                            {
                                if (string.Compare(clsid, guidStr, true) == 0)
                                {
                                    using (RegistryKey classKey = clsidKey.OpenSubKey(clsid)){
                                        Debug.Assert(classKey != null);
                                        if (classKey != null)
                                        {
                                            RegistryKey inProcSvrKey = classKey.OpenSubKey("InprocServer32");
                                            if (inProcSvrKey != null)
                                            {
                                                return(this.CreateLanguageService(localRegistry, inProcSvrKey));
                                            }
                                            else
                                            {
                                                return(this.CreateLanguageService(localRegistry, classKey));
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                return(null);
            }
        }
Beispiel #16
0
        static StringDictionary GetLanguageExtensions(IServiceProvider site)
        {
            if (EditorFactory.languageExtensions != null)
            {
                return(EditorFactory.languageExtensions);
            }

            StringDictionary extensions    = new StringDictionary();
            ILocalRegistry3  localRegistry = site.GetService(typeof(SLocalRegistry)) as ILocalRegistry3;
            string           root          = null;

            if (localRegistry != null)
            {
                NativeMethods.ThrowOnFailure(localRegistry.GetLocalRegistryRoot(out root));
            }
            using (RegistryKey rootKey = Registry.LocalMachine.OpenSubKey(root)) {
                if (rootKey != null)
                {
                    string relpath = "Languages\\File Extensions";
                    using (RegistryKey key = rootKey.OpenSubKey(relpath, false)) {
                        if (key != null)
                        {
                            foreach (string ext in key.GetSubKeyNames())
                            {
                                using (RegistryKey extkey = key.OpenSubKey(ext, false)) {
                                    if (extkey != null)
                                    {
                                        string fe   = ext;
                                        string guid = extkey.GetValue(null) as string; // get default value
                                        if (!extensions.ContainsKey(fe))
                                        {
                                            extensions.Add(fe, guid);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return(EditorFactory.languageExtensions = extensions);
        }
        public override void Execute()
        {
            string vsHive = @"SOFTWARE\Microsoft\VisualStudio\8.0";

            ILocalRegistry3 localRegistry = GetService <SLocalRegistry>() as ILocalRegistry3;

            if (localRegistry != null)
            {
                localRegistry.GetLocalRegistryRoot(out vsHive);
            }

            using (RegistryKey vsdTemplates = Registry.LocalMachine.OpenSubKey(Path.Combine(vsHive, @"Projects\{54435603-DBB4-11D2-8724-00A0C9A8B90C}\AddItemTemplates\TemplateDirs\{66D6F801-B1EC-40A4-BB15-318617E96DAD}")))
            {
                RegistryKey vsdTemplateDir = vsdTemplates.OpenSubKey("/1");
                Template    = ((string)vsdTemplateDir.GetValue("TemplatesDir")) + @"\Setup.vdproj";
                ProjectName = PackageName + "Setup.vdproj";
                EnvDTE.DTE dte       = GetService <EnvDTE.DTE>(true);
                string     slnFolder = (string)(dte.Solution.Properties.Item("Path").Value);
                slnFolder     = slnFolder.Substring(0, slnFolder.LastIndexOf("\\"));
                ProjectFolder = slnFolder + @"\" + PackageName + "Setup";
            }
        }
Beispiel #18
0
        private ILanguageService CreateLanguageService(ILocalRegistry3 localRegistry, RegistryKey classInfo)
        {
            string typeName = classInfo.GetValue("Class") as String;

            Debug.Assert(typeName != null, "Registry value for 'Class' is missing or is not a string");
            string assembly = classInfo.GetValue("Assembly") as String;

            Debug.Assert(assembly != null, "Registry value for 'Assembly' is missing or is not a string");
            string codeBase = classInfo.GetValue("CodeBase") as String;

            Debug.Assert(codeBase != null, "Registry value for 'CodeBase' is missing or is not a string");
            IntPtr pUnk;
            Guid   iid = typeof(ILanguageService).GUID;

            localRegistry.CreateManagedInstance(codeBase, assembly, typeName, ref iid, out pUnk);
            ILanguageService result = null;

            try{
                result = (ILanguageService)Marshal.GetTypedObjectForIUnknown(pUnk, typeof(ILanguageService));
            }finally{
                Marshal.Release(pUnk);
            }
            return(result);
        }
Beispiel #19
0
        public virtual void SetSite(Microsoft.VisualStudio.OLE.Interop.IServiceProvider site)
        {
            this.site          = new ServiceProvider(site);
            this.editorFactory = CreateEditorFactory();
            if (this.editorFactory != null)
            {
                this.editorFactory.SetSite(site);
                Guid editorGuid        = this.editorFactory.GetType().GUID;
                IVsRegisterEditors vre = (IVsRegisterEditors)this.site.QueryService(VsConstants.SID_SVsRegisterEditors, typeof(IVsRegisterEditors));
                vre.RegisterEditor(ref editorGuid, editorFactory, out this.editorFactoryCookie);
            }

            this.projectFactory = CreateProjectFactory();
            if (this.projectFactory != null)
            {
                this.projectFactory.SetSite(site);
                IVsRegisterProjectTypes rpt = (IVsRegisterProjectTypes)this.site.QueryService(VsConstants.SID_IVsRegisterProjectTypes, typeof(IVsRegisterProjectTypes));
                if (rpt != null)
                {
                    Guid projectType = this.projectFactory.GetType().GUID;
                    rpt.RegisterProjectType(ref projectType, this.projectFactory, out this.projectFactoryCookie);
                }
            }

            uint lcid = VsShell.GetProviderLocale(this.site);

            languageServices = new Hashtable();
            string          thisPackage = "{" + this.GetType().GUID.ToString() + "}";
            ServiceProvider thisSite    = new ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider) this);

            ILocalRegistry3 localRegistry = (ILocalRegistry3)this.site.QueryService(VsConstants.SID_SLocalRegistry, typeof(ILocalRegistry3));
            string          root          = null;

            if (localRegistry != null)
            {
                localRegistry.GetLocalRegistryRoot(out root);
            }
            using (RegistryKey rootKey = Registry.LocalMachine.OpenSubKey(root)) {
                if (rootKey != null)
                {
                    using (RegistryKey languages = rootKey.OpenSubKey("Languages\\Language Services")) {
                        if (languages != null)
                        {
                            foreach (string languageName in languages.GetSubKeyNames())
                            {
                                using (RegistryKey langKey = languages.OpenSubKey(languageName)) {
                                    object pkg = langKey.GetValue("Package");
                                    if (pkg is string && string.Compare((string)pkg, thisPackage, false) == 0)
                                    {
                                        object guid = langKey.GetValue(null);
                                        if (guid is string)
                                        {
                                            Guid langGuid = new Guid((string)guid);
                                            if (!this.languageServices.Contains(langGuid.ToString()))
                                            {
                                                ILanguageService svc = CreateLanguageService(ref langGuid);
                                                if (svc != null)
                                                {
                                                    svc.Init(thisSite, ref langGuid, lcid, GetFileExtensions(rootKey, (string)guid));
                                                    this.languageServices.Add(langGuid.ToString(), svc);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            //register with ComponentManager for Idle processing
            this.componentManager = (IOleComponentManager)this.site.QueryService(VsConstants.SID_SOleComponentManager, typeof(IOleComponentManager));
            if (componentID == 0)
            {
                OLECRINFO[] crinfo = new OLECRINFO[1];
                crinfo[0].cbSize = (uint)Marshal.SizeOf(typeof(OLECRINFO));
                crinfo[0].grfcrf = (uint)OLECRF.olecrfNeedIdleTime |
                                   (uint)OLECRF.olecrfNeedPeriodicIdleTime;
                crinfo[0].grfcadvf = (uint)OLECADVF.olecadvfModal |
                                     (uint)OLECADVF.olecadvfRedrawOff |
                                     (uint)OLECADVF.olecadvfWarningsOff;
                crinfo[0].uIdleTimeInterval = 1000;
                this.componentManager.FRegisterComponent(this, crinfo, out componentID);
            }
        }
Beispiel #20
0
 private ILanguageService CreateLanguageService(ILocalRegistry3 localRegistry, RegistryKey classInfo){
   string typeName = classInfo.GetValue("Class") as String;
   Debug.Assert(typeName != null, "Registry value for 'Class' is missing or is not a string");
   string assembly = classInfo.GetValue("Assembly") as String;
   Debug.Assert(assembly != null, "Registry value for 'Assembly' is missing or is not a string");
   string codeBase = classInfo.GetValue("CodeBase") as String;
   Debug.Assert(codeBase != null, "Registry value for 'CodeBase' is missing or is not a string");
   IntPtr pUnk;
   Guid iid = typeof(ILanguageService).GUID;
   localRegistry.CreateManagedInstance(codeBase, assembly, typeName, ref iid, out pUnk);
   ILanguageService result = null; 
   try{
     result = (ILanguageService)Marshal.GetTypedObjectForIUnknown(pUnk, typeof(ILanguageService));
   }finally{
     Marshal.Release(pUnk);
   }
   return result;
 }