private NemerleCodeBehindEventBinder GetBinder(EnvDTE.ProjectItem projectItem) { if (projectItem == null) { return(null); } if (projectItem.FileCodeModel == null) { return(null); } ITypeResolutionService typeResolutionService = null; if (this._serviceProvider != null) { DynamicTypeService typeService = this._serviceProvider.GetService(typeof(DynamicTypeService)) as DynamicTypeService; if (typeService != null) { typeResolutionService = typeService.GetTypeResolutionService(this._hierarchy); } } return(new NemerleCodeBehindEventBinder(projectItem.FileCodeModel, typeResolutionService)); }
/// <summary> /// Initializes a new instance of the <see cref="T:CustomTypeProvider"/> class. /// </summary> /// <param name="provider">The provider.</param> public CustomTypeProvider(IServiceProvider provider, List <Project> additionalProjects, bool useProjectItemWrapper) { this.useProjectItemWrapper = useProjectItemWrapper; DynamicTypeService typeService = (DynamicTypeService)provider.GetService(typeof(DynamicTypeService)); Debug.Assert(typeService != null, "No dynamic type service registered."); availableTypes = new Dictionary <string, Type>(); if (additionalProjects != null && additionalProjects.Count > 0) { foreach (Project project in additionalProjects) { IVsHierarchy additionalHierarchy = DteHelper.GetVsHierarchy(provider, project); ITypeDiscoveryService additionalDiscovery = typeService.GetTypeDiscoveryService(additionalHierarchy); AddTypes(additionalDiscovery, project); } } else { IVsHierarchy hier = DteHelper.GetCurrentSelection(provider); Debug.Assert(hier != null, "No active hierarchy is selected."); ITypeDiscoveryService discovery = typeService.GetTypeDiscoveryService(hier); Project dteProject = VSHelper.ToDteProject(hier); AddTypes(discovery, dteProject); } if (availableTypes.Count > 0 && TypesChanged != null) { TypesChanged(this, new EventArgs()); } }
/// <summary> /// Retrieves the <see cref="Type"/> corresponding to the <paramref name="codeClass"/>. /// </summary> /// <exception cref="InvalidOperationException">An <see cref="ITypeDiscoveryService"/> cannot be /// retrieved for the project the class lives in.</exception> /// <exception cref="InvalidOperationException">The <paramref name="codeClass"/> has not been /// compiled into the project still.</exception> public static Type ToType(CodeClass codeClass) { Guard.ArgumentNotNull(codeClass, "codeClass"); string typeFullName = codeClass.FullName; Type returnType = null; IServiceProvider provider = ToServiceProvider(codeClass.DTE); DynamicTypeService typeService = VsHelper.GetService <DynamicTypeService>(provider, true); IVsHierarchy hier = ToHierarchy(codeClass.ProjectItem.ContainingProject); ITypeResolutionService typeResolution = typeService.GetTypeResolutionService(hier); if (typeResolution == null) { throw new InvalidOperationException(String.Format( CultureInfo.CurrentCulture, Properties.Resources.ServiceMissing, typeof(ITypeResolutionService))); } returnType = typeResolution.GetType(typeFullName); if (returnType == null) { throw new InvalidOperationException(String.Format( CultureInfo.CurrentCulture, Properties.Resources.ClassNotCompiledYet, typeFullName, codeClass.ProjectItem.get_FileNames(1))); } return(returnType); }
/// <summary> /// Returns a collection of standard values for the data type this type converter is designed for when provided with a format context. /// </summary> /// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext"></see> that provides a format context that can be used to extract additional information about the environment from which this converter is invoked. This parameter or properties of this parameter can be null.</param> /// <returns> /// A <see cref="T:System.ComponentModel.TypeConverter.StandardValuesCollection"></see> that holds a standard set of valid values, or null if the data type does not support a standard set of values. /// </returns> public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { DynamicTypeService typeService = (DynamicTypeService)context.GetService(typeof(DynamicTypeService)); Debug.Assert(typeService != null, "No dynamic type service registered."); IVsHierarchy hier = DteHelper.GetCurrentSelection(context); Debug.Assert(hier != null, "No active hierarchy is selected."); ITypeDiscoveryService typeDiscovery = typeService.GetTypeDiscoveryService(hier); if (typeDiscovery != null) { List <string> types = new List <string>(); foreach (Type type in typeDiscovery.GetTypes(typeof(object), false)) { if (ShouldInclude(type)) { types.Add(type.FullName); } } types.Sort(StringComparer.CurrentCulture); return(new StandardValuesCollection(types)); } else { return(new StandardValuesCollection(new List <string>())); } }
/// <summary> /// Initializes a new instance of the <see cref="T:CustomTypeProvider"/> class. /// </summary> /// <param name="provider">The provider.</param> public CustomTypeProvider(IServiceProvider provider) { DynamicTypeService typeService = (DynamicTypeService)provider.GetService(typeof(DynamicTypeService)); System.Diagnostics.Debug.Assert(typeService != null, "No dynamic type service registered."); IVsHierarchy hier = DteHelper2.GetCurrentSelection(provider); System.Diagnostics.Debug.Assert(hier != null, "No active hierarchy is selected."); ITypeDiscoveryService discovery = typeService.GetTypeDiscoveryService(hier); Project dteProject = VsHelper.ToDteProject(hier); availableTypes = new Dictionary <string, Type>(); LoadTypes(availableTypes, discovery.GetTypes(typeof(object), false), dteProject); // Try loading Project references LoadProjectReferenceTypesFromCurrentProject(availableTypes, provider, dteProject); // If we don't get any type loaded, try with the rest of the projects in the current sln if (availableTypes.Count == 0) { LoadTypesFromSolution(availableTypes, provider, dteProject); } EnsureKnownTypes(availableTypes); if (availableTypes.Count > 0 && TypesChanged != null) { TypesChanged(this, new EventArgs()); } }
/// <summary> /// Returns the discovered types for autocomplete /// </summary> protected virtual IEnumerable <Type> DiscoverTypes() { DynamicTypeService typeService = (DynamicTypeService)DataGridView.Site.GetService(typeof(DynamicTypeService)); IVsHierarchy hier = DteHelper.GetCurrentSelection(DataGridView.Site); ITypeDiscoveryService typeDiscoveryService = typeService.GetTypeDiscoveryService(hier); return((IEnumerable <Type>)typeDiscoveryService.GetTypes(typeof(object), false)); }
public NemerleContainedLanguage(IVsTextBufferCoordinator bufferCoordinator, NemerleIntellisenseProvider intellisenseProject, uint itemId, IVsHierarchy pHierarchy) { if (null == bufferCoordinator) { throw new ArgumentNullException("bufferCoordinator"); } if (null == intellisenseProject) { throw new ArgumentNullException("intellisenseProject"); } _hierarchy = pHierarchy; object projectItem = null; pHierarchy.GetProperty(itemId, (int)__VSHPROPID.VSHPROPID_ExtObject, out projectItem); _projectItem = projectItem as EnvDTE.ProjectItem; EnvDTE.Property prop = _projectItem.Properties.Item("FullPath"); if (prop != null) { _filePath = prop.Value as string; } var project = _projectItem.ContainingProject as NemerleOAProject; if (project != null) { _projectInfo = ((NemerleProjectNode)project.Project).ProjectInfo; } _typeResolutionService = null; DynamicTypeService typeService = LanguageService.GetService(typeof(DynamicTypeService)) as DynamicTypeService; if (typeService != null) { _typeResolutionService = typeService.GetTypeResolutionService(this._hierarchy); } this.bufferCoordinator = bufferCoordinator; this.intellisenseProject = intellisenseProject; this.itemId = itemId; // Make sure that the secondary buffer uses the IronPython language service. IVsTextLines buffer; ErrorHandler.ThrowOnFailure(bufferCoordinator.GetSecondaryBuffer(out buffer)); Guid languageGuid; this.GetLanguageServiceID(out languageGuid); ErrorHandler.ThrowOnFailure(buffer.SetLanguageServiceID(ref languageGuid)); _documentClosingEventHandler = new _dispDocumentEvents_DocumentClosingEventHandler(OnDocumentClosing); }
private void InitTypeDiscoveryService() { if (_discovery != null) { return; } DynamicTypeService typeService = _services.TypeService; if (typeService != null) { _discovery = typeService.GetTypeDiscoveryService(GetHierarchy()); } }
string GetModuleType(Project project, CodeClass codeClass) { IVsSolution solution = (IVsSolution)GetService(typeof(IVsSolution)); DynamicTypeService typeResolver = (DynamicTypeService)GetService(typeof(DynamicTypeService)); IVsHierarchy hierarchy = null; solution.GetProjectOfUniqueName(project.UniqueName, out hierarchy); var typeResolutionService = typeResolver.GetTypeResolutionService(hierarchy); return(typeResolutionService.GetType(codeClass.FullName).AssemblyQualifiedName); }
public Type GetTypeFromString(string type) { IServiceProvider serviceProvider = new ServiceProvider(_dte2 as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); DynamicTypeService typeService = serviceProvider.GetService(typeof(DynamicTypeService)) as DynamicTypeService; IVsSolution sln = serviceProvider.GetService(typeof(IVsSolution)) as IVsSolution; IVsHierarchy hier; sln.GetProjectOfUniqueName(_dte2.ActiveDocument.ProjectItem.ContainingProject.UniqueName, out hier); return(typeService.GetTypeResolutionService(hier).GetType(type, true)); }
/// <summary> /// Returns the type discovery service for the given project /// </summary> /// <param name="project">The project to use for the vsHierarchy</param> /// <returns>The type discovery service or null if it cannot be found</returns> /// <exception cref="WizardCancelledException"> is thrown if no hierarchy is available.</exception> private ITypeDiscoveryService GetTypeDiscoveryService(Project project) { DynamicTypeService dts = this.GetService(typeof(DynamicTypeService)) as DynamicTypeService; if (dts == null) { return(null); } // Get the hierarchy. Throws if not available. IVsHierarchy vsHierarchy = this.GetVsHierarchy(project); ITypeDiscoveryService tds = dts.GetTypeDiscoveryService(vsHierarchy); return(tds); }
private void LoadTypesFromProjects(List <EnvDTE.Project> projects, Dictionary <string, Type> availableTypes, IServiceProvider provider, Project currentProject) { DynamicTypeService typeService = (DynamicTypeService)provider.GetService(typeof(DynamicTypeService)); foreach (Project project in projects) { if (project.UniqueName != currentProject.UniqueName) { IVsHierarchy hier = DteHelper2.GetVsHierarchy(provider, project); System.Diagnostics.Debug.Assert(hier != null, "No active hierarchy is selected."); ITypeDiscoveryService discovery = typeService.GetTypeDiscoveryService(hier); LoadTypes(availableTypes, discovery.GetTypes(typeof(object), false), project); } } }
private void Initialize() { if (!initialized) { this.dynamicTypeService = serviceProvider.GetService(typeof(DynamicTypeService)) as DynamicTypeService; //this.dynamicTypeService.AssemblyRefreshed += new AssemblyRefreshedEventHandler(dynamicTypeService_AssemblyRefreshed); //this.dynamicTypeService.AssemblyDeleted += new AssemblyDeletedEventHandler(dynamicTypeService_AssemblyDeleted); var vs = this.serviceProvider.GetService(typeof(EnvDTE.DTE)) as EnvDTE.DTE; this.buildEvents = vs.Events.BuildEvents; //this.buildEvents.OnBuildDone += new _dispBuildEvents_OnBuildDoneEventHandler(BuildEvents_OnBuildDone); initialized = true; //LoadTypes(); } }
private void ValidateTypeName(string typeName) { DynamicTypeService typeService = (DynamicTypeService)site.GetService(typeof(DynamicTypeService)); Debug.Assert(typeService != null, "No dynamic type service registered."); IVsHierarchy hier = DteHelper.GetCurrentSelection(site); Debug.Assert(hier != null, "No active hierarchy is selected."); ITypeResolutionService resolution = typeService.GetTypeResolutionService(hier); Type type = resolution.GetType(TypeHelper.ParseGenericType(typeName)); if (type == null) { throw new TypeLoadException(string.Format(CultureInfo.CurrentUICulture, Resources.TypeNameValidatorTypeNotFound, typeName)); } }
private Type ResolveType(Project prj, CodeType codeType) { try { DynamicTypeService typeService = this.serviceProvider.GetService(typeof(DynamicTypeService)) as DynamicTypeService; IVsSolution solution = this.serviceProvider.GetService(typeof(IVsSolution)) as IVsSolution; IVsHierarchy hierarchy; solution.GetProjectOfUniqueName(prj.UniqueName, out hierarchy); ITypeResolutionService resolutionService = typeService.GetTypeResolutionService(hierarchy); return(resolutionService.GetType(codeType.FullName)); } catch { return(null); } }
private ITypeResolutionService GetResolutionService(Project currentProject) { DynamicTypeService typeService = ServiceProvider.GetService(typeof(DynamicTypeService)) as DynamicTypeService; if (typeService == null) { throw new InvalidOperationException("No dynamic type service registered."); } IVsSolution vsSolution = (IVsSolution)ServiceProvider.GetService(typeof(IVsSolution)); vsSolution.GetProjectOfUniqueName(currentProject.UniqueName, out IVsHierarchy vsHierarchy); if (vsHierarchy == null) { throw new InvalidOperationException("No active hierarchy is selected."); } return(typeService.GetTypeResolutionService(vsHierarchy)); }
public Type GetTypeFromString(string type) { IServiceProvider serviceProvider = new ServiceProvider(_dte2 as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); DynamicTypeService typeService = serviceProvider.GetService(typeof(DynamicTypeService)) as DynamicTypeService; IVsSolution solution = serviceProvider.GetService(typeof(IVsSolution)) as IVsSolution; if (solution == null) { return(null); } IVsHierarchy hierarchy; solution.GetProjectOfUniqueName(_dte2.ActiveDocument.ProjectItem.ContainingProject.UniqueName, out hierarchy); Type returnType = typeService?.GetTypeResolutionService(hierarchy)?.GetType(type, false); return(returnType); }
/// <summary> /// Converts the specified value object to a <see cref="T:System.String"></see> object. /// </summary> /// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext"></see> that provides a format context.</param> /// <param name="culture">The <see cref="T:System.Globalization.CultureInfo"></see> to use.</param> /// <param name="value">The <see cref="T:System.Object"></see> to convert.</param> /// <returns> /// An <see cref="T:System.Object"></see> that represents the converted value. /// </returns> /// <exception cref="T:System.NotSupportedException">The conversion could not be performed. </exception> public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { if (value is string) { DynamicTypeService typeService = (DynamicTypeService)context.GetService(typeof(DynamicTypeService)); Debug.Assert(typeService != null, "No dynamic type service registered."); IVsHierarchy hier = DteHelper.GetCurrentSelection(context); Debug.Assert(hier != null, "No active hierarchy is selected."); ITypeResolutionService resolution = typeService.GetTypeResolutionService(hier); Type type = resolution.GetType(value.ToString()); return(type); } else { return(base.ConvertFrom(context, culture, value)); } }
public static List <Type> GetProjectTypes(Type baseType, IServiceProvider serviceProvider, Projects projects) { IVsSolution solution = (IVsSolution)serviceProvider.GetService(typeof(IVsSolution)); DynamicTypeService typeResolver = (DynamicTypeService)serviceProvider.GetService(typeof(DynamicTypeService)); List <Type> result = new List <Type>(); for (int i = 1; i <= projects.Count; i++) { Project project = projects.Item(i); IVsHierarchy hierarchy = null; solution.GetProjectOfUniqueName(project.UniqueName, out hierarchy); //_typeResolutionService = typeResolver.GetTypeResolutionService(hierarchy); var typeDiscoveryService = typeResolver.GetTypeDiscoveryService(hierarchy); System.Collections.ICollection fined = typeDiscoveryService.GetTypes(baseType, true); foreach (Type t in fined) { result.Add(t); } } return(result); }
/// <summary> /// Edits the specified object's value using the editor style indicated by the <see cref="M:System.Drawing.Design.UITypeEditor.GetEditStyle"></see> method. /// </summary> /// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext"></see> that can be used to gain additional context information.</param> /// <param name="provider">An <see cref="T:System.IServiceProvider"></see> that this editor can use to obtain services.</param> /// <param name="value">The object to edit.</param> /// <returns> /// The new value of the object. If the value of the object has not changed, this should return the same object it was passed. /// </returns> public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, IServiceProvider provider, object value) { DynamicTypeService typeService = (DynamicTypeService)provider.GetService(typeof(DynamicTypeService)); IVsHierarchy hier = DteHelper.GetCurrentSelection(provider); ITypeDiscoveryService typeDiscovery = typeService.GetTypeDiscoveryService(hier); Project project = ToDteProject(hier); if (DteHelper.IsWebProject(project)) { VSWebSite vsProject = (VSWebSite)project.Object; List <string> assemblies = new List <string>(); foreach (AssemblyReference reference in vsProject.References) { if (!string.IsNullOrEmpty(reference.FullPath)) { assemblies.Add(reference.FullPath); } } MethodInfo setAsssembliesMethod = typeDiscovery.GetType().GetMethod(SetAssembliesMethodName, BindingFlags.NonPublic | BindingFlags.Instance); setAsssembliesMethod.Invoke(typeDiscovery, new object[] { assemblies.ToArray() }); } if (typeDiscovery != null) { List <string> assembliesAdded = new List <string>(); List <Assembly> assemblies = new List <Assembly>(); List <Type> types = new List <Type>(); foreach (Type type in typeDiscovery.GetTypes(typeof(object), false)) { if (ShouldInclude(type)) { if (!assembliesAdded.Contains(type.Assembly.FullName)) { assembliesAdded.Add(type.Assembly.FullName); assemblies.Add(type.Assembly); } types.Add(type); } } IWindowsFormsEditorService svc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService)); ClassBrowserEditorForm form = new ClassBrowserEditorForm(assemblies, types); DialogResult result; if (svc != null) { result = svc.ShowDialog(form); } else { result = form.ShowDialog(); } if (result == DialogResult.OK) { return(form.TypeFullName); } else { return(value); } } else { return(null); } }
/// <summary> /// This function is the callback used to execute a command when the a menu item is clicked. /// See the Initialize method to see how the menu item is associated to this function using /// the OleMenuCommandService service and the MenuCommand class. /// </summary> private void MenuItemCallback(object sender, EventArgs e) { DynamicTypeService typeResolverService = (DynamicTypeService)GetService(typeof(DynamicTypeService)); if (GetService(typeof(IToolboxService)) is IVsToolboxService2 toolBoxService) { try { var items = new List <Tuple <string, ToolboxItem, IEnumerable <FrameworkName>, Guid> >(); HashSet <string> processedAssemblies = new HashSet <string>(); foreach (var directory in GetReferenceDirectories()) { foreach (string fileName in Directory.GetFiles(directory, "*.dll", SearchOption.AllDirectories)) { var assembly = typeResolverService.CreateDynamicAssembly(fileName); if (assembly != null && !processedAssemblies.Contains(assembly.FullName)) { processedAssemblies.Add(assembly.FullName); try { foreach (Type type in assembly.GetTypes()) { if (!type.IsAbstract && !type.IsGenericTypeDefinition && IsToolboxItem(type)) { if (typeof(IComponent).IsAssignableFrom(type)) { items.Add(new Tuple <string, ToolboxItem, IEnumerable <FrameworkName>, Guid>( "VSAssemblyResolver", new ResolverToolboxItem(type), null, Guid.Empty)); } } } } catch (ReflectionTypeLoadException) { } catch (TypeLoadException) { } catch (FileNotFoundException) { } } } } toolBoxService.AddToolboxItems(items, null); } catch (Exception ex) { Debug.WriteLine(ex.ToString()); } } // Show a Message Box to prove we were here IVsUIShell uiShell = (IVsUIShell)GetService(typeof(SVsUIShell)); Guid clsid = Guid.Empty; ErrorHandler.ThrowOnFailure(uiShell.ShowMessageBox( 0, ref clsid, "VSAssemblyResolver", string.Format(CultureInfo.CurrentCulture, "Inside {0}.MenuItemCallback()", this), string.Empty, 0, OLEMSGBUTTON.OLEMSGBUTTON_OK, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST, OLEMSGICON.OLEMSGICON_INFO, 0, // false out int result)); }