/// <summary> /// See <see cref="ITypeResolutionService.GetType(string, bool, bool)"/>. /// </summary> public override Type GetType(string name, bool throwOnError, bool ignoreCase) { if (name == null) { throw new ArgumentNullException("name"); } object value = typeAliases[name]; if (value != null) { string stringValue = value as string; if (stringValue != null) { // In this case, we haven't loaded the type yet. Ask the parent loader. Type type = parentLoader.GetType(stringValue, throwOnError, ignoreCase); if (type != null) { typeAliases[name] = type; } return(type); } else { // We already have the type. return((Type)value); } } else { return(parentLoader.GetType(name, throwOnError, ignoreCase)); } }
private Type ResolveType(string typeName, ITypeResolutionService typeResolver) { Type resolvedType = null; if (typeResolver != null) { // If we cannot find the strong-named type, then try to see // if the TypeResolver can bind to partial names. For this, // we will strip out the partial names and keep the rest of the // strong-name information to try again. resolvedType = typeResolver.GetType(typeName, false); if (resolvedType == null) { string[] typeParts = typeName.Split(','); // Break up the type name from the rest of the assembly strong name. if (typeParts != null && typeParts.Length >= 2) { string partialName = typeParts[0].Trim(); string assemblyName = typeParts[1].Trim(); partialName = partialName + ", " + assemblyName; resolvedType = typeResolver.GetType(partialName, false); } } } if (resolvedType == null) { resolvedType = Type.GetType(typeName, false); } return(resolvedType); }
public void GetAndSetType() { Expect.Call( _typeResolutionServiceMock.GetType( "Remotion.ObjectBinding.UnitTests.TestDomain.SimpleBusinessObjectClass, Remotion.ObjectBinding.UnitTests", true)) .Return(typeof(SimpleBusinessObjectClass)); _mockRepository.ReplayAll(); Assert.That(_dataSource.Type, Is.Null); _dataSource.Type = typeof(SimpleBusinessObjectClass); Assert.That(_dataSource.Type, Is.SameAs(typeof(SimpleBusinessObjectClass))); _mockRepository.VerifyAll(); }
private Type ResolveType(string typeName, ITypeResolutionService typeResolver) { if (!typeName.Contains(", System.Drawing.Common") && typeName.Contains(", System.Drawing")) { typeName = typeName.Replace(", System.Drawing", ", System.Drawing.Common"); } Type t = null; if (typeResolver != null) { // If we cannot find the strong-named type, then try to see // if the TypeResolver can bind to partial names. For this, // we will strip out the partial names and keep the rest of the // strong-name information to try again. t = typeResolver.GetType(typeName, false); if (t == null) { string[] typeParts = typeName.Split(','); // Break up the type name from the rest of the assembly strong name. // if (typeParts.Length >= 2) { string partialName = typeParts[0].Trim(); string assemblyName = typeParts[1].Trim(); partialName = partialName + ", " + assemblyName; t = typeResolver.GetType(partialName, false); } } } if (t == null) { t = Type.GetType(typeName, false); if (t == null) { var testTypeName = string.Join(",", typeName.Split(',').Take(2)); if (testTypeName.Length > 0) { t = Type.GetType(testTypeName, false); } } } return(t); }
private T GetInstance <T>(ITypeResolutionService resolution, string concreteType) { Type instanceType = resolution.GetType(concreteType, true); ReflectionHelper.EnsureAssignableTo(instanceType, typeof(T)); return((T)Activator.CreateInstance(instanceType)); }
public override bool OnNext() { TypeItem selectedTypeItem = this.SelectedTypeItem; System.Type type = selectedTypeItem.Type; if (type == null) { ITypeResolutionService service = (ITypeResolutionService)base.ServiceProvider.GetService(typeof(ITypeResolutionService)); if (service == null) { return(false); } try { type = service.GetType(selectedTypeItem.TypeName, true, true); } catch (Exception exception) { UIServiceHelper.ShowError(base.ServiceProvider, exception, System.Design.SR.GetString("ObjectDataSourceDesigner_CannotGetType", new object[] { selectedTypeItem.TypeName })); return(false); } } if (type == null) { return(false); } if (type != this._previousSelectedType) { (base.NextPanel as ObjectDataSourceChooseMethodsPanel).SetType(type); this._previousSelectedType = type; } return(true); }
/// <summary> /// Creates the unbound reference and registers /// the reference with the Recipe Framework /// </summary> public override void Execute() { ITypeResolutionService typeLoader = GetService <ITypeResolutionService>(true); Type assetType = typeLoader.GetType(this.referenceType, true); if (!typeof(IUnboundAssetReference).IsAssignableFrom(assetType)) { throw new ArgumentException(String.Format( System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.CreateUnboundReferenceAction_WrongType, assetType)); } ConstructorInfo ctor = assetType.GetConstructor(new Type[] { typeof(string) }); if (ctor == null) { throw new NotSupportedException(String.Format( System.Globalization.CultureInfo.CurrentCulture, Properties.Resources.CreateUnboundReferenceAction_UnsupportedConstructor, assetType)); } reference = (IAssetReference)ctor.Invoke(new object[] { this.assetName }); if (reference is IAttributesConfigurable) { ((IAttributesConfigurable)reference).Configure(this.attributes); } IAssetReferenceService service = GetService <IAssetReferenceService>(true); service.Add(reference); }
internal static System.Type GetType(IServiceProvider serviceProvider, string typeName, bool silent) { ITypeResolutionService service = null; if (serviceProvider != null) { service = (ITypeResolutionService)serviceProvider.GetService(typeof(ITypeResolutionService)); } if (service == null) { return(null); } try { return(service.GetType(typeName, true, true)); } catch (Exception exception) { if (!silent) { UIServiceHelper.ShowError(serviceProvider, exception, System.Design.SR.GetString("ObjectDataSourceDesigner_CannotGetType", new object[] { typeName })); } return(null); } }
private void InitializeDataNode(string basePath) { System.Type type = null; if (!string.IsNullOrEmpty(this.nodeInfo.TypeName)) { type = internalTypeResolver.GetType(this.nodeInfo.TypeName, false, true); } if ((type != null) && type.Equals(typeof(ResXFileRef))) { string[] strArray = ResXFileRef.Converter.ParseResxFileRefString(this.nodeInfo.ValueData); if ((strArray != null) && (strArray.Length > 1)) { if (!Path.IsPathRooted(strArray[0]) && (basePath != null)) { this.fileRefFullPath = Path.Combine(basePath, strArray[0]); } else { this.fileRefFullPath = strArray[0]; } this.fileRefType = strArray[1]; if (strArray.Length > 2) { this.fileRefTextEncoding = strArray[2]; } } } }
/// <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); }
private Type GetTypeFromName(IServiceProvider serviceProvider, string typeName) { ITypeResolutionService typeResolutionSvc = (ITypeResolutionService)serviceProvider .GetService(typeof(ITypeResolutionService)); return(typeResolutionSvc.GetType(typeName)); }
private void EnsureInitializeMetadataForCurrentRecipe() { if (!argumentsMetaDataByRecipe.ContainsKey(currentRecipe.Configuration.Name)) { Dictionary <string, ValueInfo> infos; if (currentRecipe.Configuration.Arguments == null) { infos = new Dictionary <string, ValueInfo>(0); } else { infos = new Dictionary <string, ValueInfo>(currentRecipe.Configuration.Arguments.Length); foreach (Config.Argument argument in currentRecipe.Configuration.Arguments) { ITypeResolutionService resolution = currentRecipe.GetService <ITypeResolutionService>(true); Type argumentType = resolution.GetType(argument.Type, true); TypeConverter converter = null; if (argument.Converter != null) { converter = CreateAndConfigureConverter(argument, resolution, converter); } else { converter = GetBuiltInConverter(argumentType, converter); } infos.Add(argument.Name, new ValueInfo(argument.Name, argument.Required, argumentType, converter)); } } argumentsMetaDataByRecipe.Add(currentRecipe.Configuration.Name, infos); } }
/// <summary> /// Returns schema information for each property on /// the object. /// </summary> /// <remarks>All public properties on the object /// will be reflected in this schema list except /// for those properties where the /// <see cref="BrowsableAttribute">Browsable</see> attribute /// is False. /// </remarks> public System.Web.UI.Design.IDataSourceFieldSchema[] GetFields() { ITypeResolutionService typeService = null; List <ObjectFieldInfo> result = new List <ObjectFieldInfo>(); if (_designer != null) { Type objectType = null; try { typeService = (ITypeResolutionService)(_designer.Site.GetService(typeof(ITypeResolutionService))); objectType = typeService.GetType(_typeName, true, false); if (typeof(IEnumerable).IsAssignableFrom(objectType)) { // this is a list so get the item type objectType = Utilities.GetChildItemType(objectType); } PropertyDescriptorCollection props = TypeDescriptor.GetProperties(objectType); foreach (PropertyDescriptor item in props) { if (item.IsBrowsable) { result.Add(new ObjectFieldInfo(item)); } } } catch { /* do nothing - just swallow exception */ } } return(result.ToArray()); }
private void InitializeDataNode(string basePath) { // we can only use our internal type resolver here // because we only want to check if this is a ResXFileRef node // and we can't be sure that we have a typeResolutionService that can // recognize this. It's not very clean but this should work. Type nodeType = null; if (!string.IsNullOrEmpty(nodeInfo.TypeName)) // can be null if we have a string (default for string is TypeName == null) { nodeType = internalTypeResolver.GetType(nodeInfo.TypeName, false, true); } if (nodeType != null && nodeType.Equals(typeof(ResXFileRef))) { // we have a fileref, split the value data and populate the fields string[] fileRefDetails = ResXFileRef.Converter.ParseResxFileRefString(nodeInfo.ValueData); if (fileRefDetails != null && fileRefDetails.Length > 1) { if (!Path.IsPathRooted(fileRefDetails[0]) && basePath != null) { fileRefFullPath = Path.Combine(basePath, fileRefDetails[0]); } else { fileRefFullPath = fileRefDetails[0]; } fileRefType = fileRefDetails[1]; if (fileRefDetails.Length > 2) { fileRefTextEncoding = fileRefDetails[2]; } } } }
internal static Microsoft.Practices.ComponentModel.ServiceContainer CreateFilter(IServiceProvider provider, string filterTypeName, StringDictionary attributes, out ICodeModelEditorFilter filter) { Microsoft.Practices.ComponentModel.ServiceContainer editorServiceProvider = new Microsoft.Practices.ComponentModel.ServiceContainer(true); editorServiceProvider.Site = new Site(provider, editorServiceProvider, editorServiceProvider.GetType().FullName); editorServiceProvider.AddService(typeof(IDictionaryService), new DictionaryWrapper(attributes)); if (string.IsNullOrEmpty(filterTypeName)) { filter = null; } else { ITypeResolutionService typeResService = (ITypeResolutionService)provider.GetService(typeof(ITypeResolutionService)); Type filterType = typeResService.GetType(filterTypeName); if (filterType == null) { filter = null; } else { filter = (ICodeModelEditorFilter)Activator.CreateInstance(filterType); if (filter is IComponent) { editorServiceProvider.Add((IComponent)filter); } } } return(editorServiceProvider); }
/// <summary> /// Sets the properties of the current action using the values provided, if possible. /// </summary> /// <param name="attributes">A <see cref="StringDictionary"/> containing the set of attributes /// to use to set the properties of the action.</param> public virtual void Configure(StringDictionary attributes) { PropertyDescriptorCollection props; ISite mysite = this.Site; try { // Must remove the site temporarily because // otherwise the TypeDescriptor doesn't work properly. this.Site = null; props = TypeDescriptor.GetProperties(this); } finally { this.Site = mysite; } foreach (string key in attributes.Keys) { PropertyDescriptor prop = props[key]; if (prop == null || prop.IsReadOnly) { continue; } TypeConverter converter = null; TypeConverterAttribute convattr = (TypeConverterAttribute)prop.Attributes[typeof(TypeConverterAttribute)]; if (convattr != null && !string.IsNullOrEmpty(convattr.ConverterTypeName)) { ITypeResolutionService resolutionService = (ITypeResolutionService) ServiceHelper.GetService(this, typeof(ITypeResolutionService)); Type type = resolutionService.GetType(convattr.ConverterTypeName, true); converter = (TypeConverter)Activator.CreateInstance(type); } else { converter = TypeDescriptor.GetConverter(prop.PropertyType); } object value; try { // Perform minimum conversion if necessary. if (!prop.PropertyType.IsAssignableFrom(typeof(string))) { value = converter.ConvertFromString(new CustomDescriptor(this, prop), attributes[key]); } else { value = attributes[key]; } prop.SetValue(this, value); } catch (TargetInvocationException e) { throw e.InnerException; } } }
/// <summary> /// This method sets various values on the newly created component. /// </summary> private IComponent[] RunWizard(IDesignerHost host, IComponent[] comps) { DialogResult result = DialogResult.No; IVsUIShell uiShell = null; if (host != null) { uiShell = (IVsUIShell)host.GetService(typeof(IVsUIShell)); } // Always use the UI shell service to show a messagebox if possible. // There are also some useful helper methods for this in VsShellUtilities. if (uiShell != null) { int nResult = 0; Guid emptyGuid = Guid.Empty; uiShell.ShowMessageBox(0, ref emptyGuid, "Question", "Do you want to set the Text property?", null, 0, OLEMSGBUTTON.OLEMSGBUTTON_YESNO, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_SECOND, OLEMSGICON.OLEMSGICON_QUERY, 0, out nResult); if (nResult == IDYES) { result = DialogResult.Yes; } } else { result = MessageBox.Show("Do you want to set the Text property?", "Question", MessageBoxButtons.YesNo); } if (result == DialogResult.Yes) { if (comps.Length > 0) { // Use Types from the ITypeResolutionService. Do not use locally defined types. ITypeResolutionService typeResolver = (ITypeResolutionService)host.GetService(typeof(ITypeResolutionService)); if (typeResolver != null) { Type t = typeResolver.GetType(typeof(MyCustomTextBoxWithPopup).FullName); // Check to ensure we got the right Type. if (t != null && comps[0].GetType().IsAssignableFrom(t)) { // Use a property descriptor instead of direct property access. // This will allow the change to appear in the undo stack and it will get // serialized correctly. PropertyDescriptor pd = TypeDescriptor.GetProperties(comps[0])["Text"]; if (pd != null) { pd.SetValue(comps[0], "Text Property was initialized!"); } } } } } return(comps); }
private Type FindType(string typeName) { #if CONFIG_COMPONENT_MODEL_DESIGN if (typeResolver == null) { return(Type.GetType(typeName)); } else #endif return(typeResolver.GetType(typeName)); }
public override Type BindToType(string assemblyName, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] string typeName) { if (_typeResolver is null) { return(null); } typeName = typeName + ", " + assemblyName; Type type = _typeResolver.GetType(typeName); if (type is null) { string[] typeParts = typeName.Split(','); // Break up the assembly name from the rest of the assembly strong name. // we try 1) FQN 2) FQN without a version 3) just the short name if (typeParts is not null && typeParts.Length > 2) { string partialName = typeParts[0].Trim(); for (int i = 1; i < typeParts.Length; ++i) { string typePart = typeParts[i].Trim(); if (!typePart.StartsWith("Version=") && !typePart.StartsWith("version=")) { partialName = partialName + ", " + typePart; } } type = _typeResolver.GetType(partialName); if (type is null) { type = _typeResolver.GetType(typeParts[0].Trim()); } } } // Binder couldn't handle it, let the default loader take over. return(type); }
public override Type BindToType(string assemblyName, string typeName) { if (typeResolver == null) { return(null); } typeName = typeName + ", " + assemblyName; Type t = typeResolver.GetType(typeName); if (t == null) { string[] typeParts = typeName.Split(','); // Break up the assembly name from the rest of the assembly strong name. // we try 1) FQN 2) FQN without a version 3) just the short name if (typeParts.Length > 2) { string partialName = typeParts[0].Trim(); for (int i = 1; i < typeParts.Length; ++i) { string s = typeParts[i].Trim(); if (!s.StartsWith("Version=") && !s.StartsWith("version=")) { partialName = partialName + ", " + s; } } t = typeResolver.GetType(partialName); if (t == null) { t = typeResolver.GetType(typeParts[0].Trim()); } } } // Binder couldn't handle it, let the default loader take over. return(t); }
/// <summary> /// Allows to change the value of the Editor /// </summary> /// <param name="context"></param> /// <param name="provider"></param> /// <param name="value"></param> /// <returns></returns> public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value) { if (referenceType != null && reference == null) { ITypeResolutionService resolver = (ITypeResolutionService)ServiceHelper.GetService(provider, typeof(ITypeResolutionService), this); Type type = resolver.GetType(referenceType, true); ReflectionHelper.EnsureAssignableTo(type, typeof(IUnboundAssetReference)); reference = (IUnboundAssetReference)Activator.CreateInstance(type, String.Empty); } DTE vs = (DTE)ServiceHelper.GetService(provider, typeof(DTE), this); using (SolutionPickerControl control = new SolutionPickerControl( vs, reference, value, context.PropertyDescriptor.PropertyType)) { // Set site so the control can find the IWindowsFormsEditorService control.Site = new Site(provider, control, control.GetType().FullName); //control.SelectionChanged += new SelectionChangedEventHandler(OnSelectionChanged); first = true; initialValue = value; formsService = (IWindowsFormsEditorService)ServiceHelper.GetService( provider, typeof(IWindowsFormsEditorService), this); formsService.DropDownControl(control); formsService = null; if (reference != null) { bool enabled; try { enabled = reference.IsEnabledFor(control.SelectedTarget); } catch (Exception ex) { throw new RecipeExecutionException(reference.AssetName, Properties.Resources.Reference_FailEnabledFor, ex); } if (enabled) { return(control.SelectedTarget); } else { return(null); } } else { return(control.SelectedTarget); } } }
public bool HasField(string fullTypeName, string fieldName) { if (_resolution != null) { Type type = _resolution.GetType(fullTypeName); if (type != null) { return(type.GetField(fieldName) != null); } } return(false); }
private void InitializeDataNode(string basePath) { // we can only use our internal type resolver here // because we only want to check if this is a ResXFileRef node // and we can't be sure that we have a typeResolutionService that can // recognize this. It's not very clean but this should work. Type nodeType = null; if (nodeInfo.TypeName != null) { if (nodeInfo.TypeName.Contains("ResXFileRef")) { nodeType = typeof(ResXFileRef); } else if (nodeInfo.TypeName.Contains("ResXNullRef")) { nodeType = typeof(ResXNullRef); } else { nodeType = internalTypeResolver.GetType(nodeInfo.TypeName, false, true); } } else { nodeType = typeof(string); } if (nodeType != null && nodeType == typeof(ResXFileRef)) { // we have a fileref, split the value data and populate the fields string[] fileRefDetails = ResxFileRefStringConverter.ParseResxFileRefString(nodeInfo.ValueData); if (fileRefDetails != null && fileRefDetails.Length > 1) { if (!Path.IsPathRooted(fileRefDetails[0]) && basePath != null) { fileRefFullPath = Path.Combine(basePath, fileRefDetails[0]); } else { fileRefFullPath = fileRefDetails[0]; } fileRefType = Type.GetType(string.Join(",", fileRefDetails[1].Split(',').Take(2)), true) .AssemblyQualifiedName; if (fileRefDetails.Length > 2) { fileRefTextEncoding = fileRefDetails[2]; } } } }
private Type GetValidFilterType(ITypeResolutionService resolution, string filterTypeName) { Type ft = resolution.GetType(filterTypeName, true); if (!typeof(ITypeFilterProvider).IsAssignableFrom(ft)) { throw new ArgumentException(String.Format( CultureInfo.CurrentCulture, Properties.Resources.InvalidTypeFilter, ft, typeof(ITypeFilterProvider))); } return(ft); }
public System.Type GetType(string typeName) { ITypeResolutionService typeResolver = (ITypeResolutionService)GetService(typeof(ITypeResolutionService)); if (typeResolver == null) { return(Type.GetType(typeName)); } else { return(typeResolver.GetType(typeName)); } }
private Type ResolveType(string typeName) { if (string.IsNullOrEmpty(typeName)) { return(null); } typeName = typeName.Trim(); var type = _typeResolutionService.GetType(typeName); if (type == null) { type = CsTypeToClrType(typeName); if (type == null) { type = _typeResolutionService.GetType("System." + typeName); } } return(type); }
/// <summary> /// Loads the type. /// </summary> /// <param name="typeName">Name of the type.</param> /// <returns></returns> private Type LoadType(string typeName) { if (DataGridView.Site != null) { ITypeResolutionService typeResolution = (ITypeResolutionService)DataGridView.Site.GetService(typeof(ITypeResolutionService)); if (typeResolution != null) { return(typeResolution.GetType(typeName, true)); } } return(Type.GetType(typeName, true)); }
/// <summary> /// This function is the callback used to execute the command when the menu item is clicked. /// See the constructor to see how the menu item is associated with this function using /// OleMenuCommandService service and MenuCommand class. /// </summary> /// <param name="sender">Event sender.</param> /// <param name="e">Event args.</param> private void MenuItemCallback(object sender, EventArgs e) { var userConfig = this._dte2.SelectedItems.Item(1).ProjectItem.ContainingProject.GetProjectConfiguration(); DynamicTypeService typeService; IVsSolution solutionService; IVsHierarchy projectHierarchy; using (ServiceProvider serviceProvider = new ServiceProvider((Microsoft.VisualStudio.OLE.Interop.IServiceProvider) this._dte2.DTE)) { typeService = (DynamicTypeService)serviceProvider.GetService(typeof(DynamicTypeService)); solutionService = (IVsSolution)serviceProvider.GetService(typeof(SVsSolution)); } int uniqueProjectName = solutionService.GetProjectOfUniqueName(this._dte2.SelectedItems.Item(1).ProjectItem.ContainingProject.UniqueName, out projectHierarchy); if (uniqueProjectName != 0) { throw Marshal.GetExceptionForHR(uniqueProjectName); } ITypeResolutionService resolutionService = typeService.GetTypeResolutionService(projectHierarchy); try { var itemNamespace = this._dte2.SelectedItems.Item(1)?.ProjectItem?.GetNameSpace(); Type type = resolutionService.GetType($"{itemNamespace.FullName}.{_fileName}"); var dbContextInfo = new DbContextInfo(type, userConfig); var filePath = $"{_fileDirectory}\\{_fileName}.edmx"; using (var writer = new XmlTextWriter(filePath, Encoding.Default)) { EdmxWriter.WriteEdmx(dbContextInfo.CreateInstance(), writer); } _dte2.ItemOperations.OpenFile(filePath); } catch (Exception ex) { IVsUIShell uiShell = (IVsUIShell)Package.GetGlobalService(typeof(SVsUIShell)); Guid clsid = Guid.Empty; int result; uiShell.ShowMessageBox(0, ref clsid, "Ef Model Generator", string.Format(CultureInfo.CurrentCulture, "Inside {0}.Initialize()", this.GetType().FullName), ex.ToString(), 0, OLEMSGBUTTON.OLEMSGBUTTON_OK, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST, OLEMSGICON.OLEMSGICON_INFO, 0, out result); } }
internal static System.Web.Compilation.ExpressionBuilder GetExpressionBuilder(string expressionPrefix, VirtualPath virtualPath, IDesignerHost host) { if (expressionPrefix.Length == 0) { if (dataBindingExpressionBuilder == null) { dataBindingExpressionBuilder = new DataBindingExpressionBuilder(); } return(dataBindingExpressionBuilder); } CompilationSection compilationConfig = null; if (host != null) { IWebApplication application = (IWebApplication)host.GetService(typeof(IWebApplication)); if (application != null) { compilationConfig = application.OpenWebConfiguration(true).GetSection("system.web/compilation") as CompilationSection; } } if (compilationConfig == null) { compilationConfig = MTConfigUtil.GetCompilationConfig(virtualPath); } System.Web.Configuration.ExpressionBuilder builder = compilationConfig.ExpressionBuilders[expressionPrefix]; if (builder == null) { throw new HttpParseException(System.Web.SR.GetString("InvalidExpressionPrefix", new object[] { expressionPrefix })); } Type c = null; if (host != null) { ITypeResolutionService service = (ITypeResolutionService)host.GetService(typeof(ITypeResolutionService)); if (service != null) { c = service.GetType(builder.Type); } } if (c == null) { c = builder.TypeInternal; } if (!typeof(System.Web.Compilation.ExpressionBuilder).IsAssignableFrom(c)) { throw new HttpParseException(System.Web.SR.GetString("ExpressionBuilder_InvalidType", new object[] { c.FullName })); } return((System.Web.Compilation.ExpressionBuilder)HttpRuntime.FastCreatePublicInstance(c)); }
public Type GetType(string typeName) { Type type = null; ITypeResolutionService typeResolverService = (ITypeResolutionService)GetService(typeof(ITypeResolutionService)); if (typeResolverService != null) { type = typeResolverService.GetType(typeName); } else { type = Type.GetType(typeName); } return(type); }
private Type ResolveType(string typeName, ITypeResolutionService typeResolver) { Type t = null; if (typeResolver != null) { // If we cannot find the strong-named type, then try to see // if the TypeResolver can bind to partial names. For this, // we will strip out the partial names and keep the rest of the // strong-name information to try again. // t = typeResolver.GetType(typeName, false); if (t == null) { string[] typeParts = typeName.Split(new char[] {','}); // Break up the type name from the rest of the assembly strong name. // if (typeParts != null && typeParts.Length >= 2) { string partialName = typeParts[0].Trim(); string assemblyName = typeParts[1].Trim(); partialName = partialName + ", " + assemblyName; t = typeResolver.GetType(partialName, false); } } } if (t == null) { t = Type.GetType(typeName, false); } return t; }
private System.Type ResolveType(string typeName, ITypeResolutionService typeResolver) { System.Type type = null; if (typeResolver != null) { type = typeResolver.GetType(typeName, false); if (type == null) { string[] strArray = typeName.Split(new char[] { ',' }); if ((strArray != null) && (strArray.Length >= 2)) { string name = strArray[0].Trim(); string str2 = strArray[1].Trim(); name = name + ", " + str2; type = typeResolver.GetType(name, false); } } } if (type == null) { type = System.Type.GetType(typeName, false); } return type; }
protected Type ResolveType (string typeString, ITypeResolutionService typeResolver) { Type result = null; if (typeResolver != null) result = typeResolver.GetType (typeString); if (result == null) result = ResolveType (typeString); return result; }
public static ComponentDesigner GetComponentDesignerForType(ITypeResolutionService tr, System.Type type) { ComponentDesigner designer = null; DesignerAttribute attribute = null; AttributeCollection attributes = TypeDescriptor.GetAttributes(type); for (int i = 0; i < attributes.Count; i++) { DesignerAttribute attribute2 = attributes[i] as DesignerAttribute; if (attribute2 != null) { System.Type type2 = System.Type.GetType(attribute2.DesignerBaseTypeName); if ((type2 != null) && (type2 == iDesignerType)) { attribute = attribute2; break; } } } if (attribute != null) { System.Type c = null; if (tr != null) { c = tr.GetType(attribute.DesignerTypeName); } else { c = System.Type.GetType(attribute.DesignerTypeName); } if ((c != null) && typeof(ComponentDesigner).IsAssignableFrom(c)) { designer = (ComponentDesigner) Activator.CreateInstance(c); } } return designer; }