public static System.Type FindType(string typeName, System.Type baseType, bool useFullName = false, bool ignoreCase = false) { if (string.IsNullOrEmpty(typeName)) return null; if (baseType == null) throw new System.ArgumentNullException("baseType"); StringComparison e = (ignoreCase) ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal; if(useFullName) { foreach (var assemb in System.AppDomain.CurrentDomain.GetAssemblies()) { foreach (var t in assemb.GetTypes()) { if (baseType.IsAssignableFrom(t) && string.Equals(t.FullName, typeName, e)) return t; } } } else { foreach (var assemb in System.AppDomain.CurrentDomain.GetAssemblies()) { foreach (var t in assemb.GetTypes()) { if (baseType.IsAssignableFrom(t) && (string.Equals(t.Name, typeName, e) || string.Equals(t.FullName, typeName, e))) return t; } } } return null; }
public static IEnumerable<Type> GetTypesAssignableFrom(System.Reflection.Assembly assemb, System.Type rootType) { foreach (var tp in assemb.GetTypes()) { if (rootType.IsAssignableFrom(tp) && rootType != tp) yield return tp; } }
public static Component ComponentField(Rect position, GUIContent label, Component value, System.Type inheritsFromType, bool allowSceneObjects, System.Type targetComponentType) { if (inheritsFromType == null) inheritsFromType = typeof(Component); else if (!typeof(Component).IsAssignableFrom(inheritsFromType) && !typeof(IComponent).IsAssignableFrom(inheritsFromType)) throw new TypeArgumentMismatchException(inheritsFromType, typeof(IComponent), "Type must inherit from IComponent or Component.", "inheritsFromType"); if (targetComponentType == null) throw new System.ArgumentNullException("targetComponentType"); if (!typeof(Component).IsAssignableFrom(targetComponentType)) throw new TypeArgumentMismatchException(targetComponentType, typeof(Component), "targetComponentType"); if (value != null && !targetComponentType.IsAssignableFrom(value.GetType())) throw new TypeArgumentMismatchException(value.GetType(), inheritsFromType, "value must inherit from " + inheritsFromType.Name, "value"); if (TypeUtil.IsType(inheritsFromType, typeof(Component))) { return EditorGUI.ObjectField(position, label, value, inheritsFromType, true) as Component; } else { value = EditorGUI.ObjectField(position, label, value, typeof(Component), true) as Component; var go = GameObjectUtil.GetGameObjectFromSource(value); if (go != null) { foreach (var c in go.GetComponents(inheritsFromType)) { if (TypeUtil.IsType(c.GetType(), targetComponentType)) { return c as Component; } } } } return null; }
public static IEnumerable<Type> GetTypesAssignableFrom(System.Type rootType) { foreach (var assemb in System.AppDomain.CurrentDomain.GetAssemblies()) { foreach (var tp in assemb.GetTypes()) { if (rootType.IsAssignableFrom(tp)) yield return tp; } } }
public override object PickRegistration(System.Type type, string identifier) { if (type.IsInterface) { Type[] implementingTypes = AppDomain.CurrentDomain.GetAssemblies().ToList().SelectMany(s => s.GetTypes()).Where(prop => !prop.Equals(type) && type.IsAssignableFrom(prop)).ToArray(); if (implementingTypes.Count() == 1) { return implementingTypes.First(); } } if ((this.NextStep != null)) { return this.NextStep.PickRegistration(type, identifier); } return null; }
override public void Map(System.Type type, System.Type mapper, object instance) { if ((instance is MonoBehaviour) == false) base.Map(type, mapper, instance); else { DesignByContract.Check.Require(instance != null); DesignByContract.Check.Require(type.IsAssignableFrom(instance.GetType()), "Trying to register an invalid instance"); KeyValuePair<WeakReference, bool> valuePair = new KeyValuePair<WeakReference, bool>(new WeakReference(instance), false); _mbcache[type] = valuePair; } }
private static IEnumerable<System.Type> ClassList(Assembly assembly, System.Type type) { IList<System.Type> result = new List<System.Type>(); if (assembly != null) { System.Type[] types = assembly.GetTypes(); foreach (System.Type tp in types) { if (tp != type && type.IsAssignableFrom(tp) && !tp.IsInterface) result.Add(tp); } } return result; }
public static IEnumerable<System.Type> FindSubclassesOf(System.Type t) { var subclasses = new List<System.Type>(); foreach(var asm in System.AppDomain.CurrentDomain.GetAssemblies()) { foreach (var type in asm.GetTypes()) { if (type.IsAbstract == false && t.IsAssignableFrom(type)) { subclasses.Add(type); } } } return subclasses; }
public ResourceAssociationSetEnd(System.Data.Services.Providers.ResourceSet resourceSet, System.Data.Services.Providers.ResourceType resourceType, System.Data.Services.Providers.ResourceProperty resourceProperty) { WebUtil.CheckArgumentNull<System.Data.Services.Providers.ResourceSet>(resourceSet, "resourceSet"); WebUtil.CheckArgumentNull<System.Data.Services.Providers.ResourceType>(resourceType, "resourceType"); if ((resourceProperty != null) && ((resourceType.TryResolvePropertyName(resourceProperty.Name) == null) || (resourceProperty.TypeKind != ResourceTypeKind.EntityType))) { throw new ArgumentException(Strings.ResourceAssociationSetEnd_ResourcePropertyMustBeNavigationPropertyOnResourceType); } if (!resourceSet.ResourceType.IsAssignableFrom(resourceType) && !resourceType.IsAssignableFrom(resourceSet.ResourceType)) { throw new ArgumentException(Strings.ResourceAssociationSetEnd_ResourceTypeMustBeAssignableToResourceSet); } if ((resourceProperty != null) && (DataServiceProviderWrapper.GetDeclaringTypeForProperty(resourceType, resourceProperty, null) != resourceType)) { throw new ArgumentException(Strings.ResourceAssociationSetEnd_ResourceTypeMustBeTheDeclaringType(resourceType.FullName, resourceProperty.Name)); } this.resourceSet = resourceSet; this.resourceType = resourceType; this.resourceProperty = resourceProperty; }
private static object FormatObjectInternal(object value, System.Type targetType, TypeConverter sourceConverter, TypeConverter targetConverter, string formatString, IFormatProvider formatInfo, object formattedNullValue) { if ((value == DBNull.Value) || (value == null)) { if (formattedNullValue != null) { return formattedNullValue; } if (targetType == stringType) { return string.Empty; } if (targetType == checkStateType) { return CheckState.Indeterminate; } return null; } if (((targetType == stringType) && (value is IFormattable)) && !string.IsNullOrEmpty(formatString)) { return (value as IFormattable).ToString(formatString, formatInfo); } System.Type type = value.GetType(); TypeConverter converter = TypeDescriptor.GetConverter(type); if (((sourceConverter != null) && (sourceConverter != converter)) && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } TypeConverter converter2 = TypeDescriptor.GetConverter(targetType); if (((targetConverter != null) && (targetConverter != converter2)) && targetConverter.CanConvertFrom(type)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } if (targetType == checkStateType) { if (type == booleanType) { return (((bool) value) ? CheckState.Checked : CheckState.Unchecked); } if (sourceConverter == null) { sourceConverter = converter; } if ((sourceConverter != null) && sourceConverter.CanConvertTo(booleanType)) { return (((bool) sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, booleanType)) ? CheckState.Checked : CheckState.Unchecked); } } if (targetType.IsAssignableFrom(type)) { return value; } if (sourceConverter == null) { sourceConverter = converter; } if (targetConverter == null) { targetConverter = converter2; } if ((sourceConverter != null) && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } if ((targetConverter != null) && targetConverter.CanConvertFrom(type)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } if (!(value is IConvertible)) { throw new FormatException(GetCantConvertMessage(value, targetType)); } return ChangeType(value, targetType, formatInfo); }
/// <summary> /// Checks whether the proxy representing the specified object type can be cast to the type represented by the IRemotingTypeInfo interface /// </summary> /// <param name="toType">The Type we wish to cast to</param> /// <param name="obj">The object we wish to cast</param> /// <returns>True if the strict property is false, otherwise the list of supportedTypes is checked.<br> /// The proxy targets type(s) are automatically supported</br></returns> public bool CanCastTo(System.Type toType, object obj) { // Assume we can (which is the default unless strict is true) bool canCast = true; if (strict) { // First check if the proxyTarget supports the cast if (toType.IsAssignableFrom(proxyTarget.GetType())) { canCast = true; } else if (supportedTypes != null) { canCast = false; // Check if the list of supported interfaces supports the cast foreach(Type type in supportedTypes) { if (toType == type) { canCast = true; break; } } } else { canCast = false; } } return canCast; }
/// <summary> /// Added to solve a problem with SessionImpl.Find( CriteriaImpl ), /// see the comment there for an explanation. /// </summary> /// <param name="clazz"></param> /// <returns></returns> public System.Type[] GetImplementorClasses(System.Type clazz) { ArrayList results = new ArrayList(); foreach (IEntityPersister p in classPersisters.Values) { if (p is IQueryable) { IQueryable q = (IQueryable) p; bool isMappedClass = clazz.Equals(q.MappedClass); if (q.IsExplicitPolymorphism) { if (isMappedClass) { return new System.Type[] {q.MappedClass}; } } else { if (isMappedClass) { results.Add(q.MappedClass); } else if ( clazz.IsAssignableFrom(q.MappedClass) && (!q.IsInherited || !clazz.IsAssignableFrom(q.MappedSuperclass))) { results.Add(q.MappedClass); } } } } return (System.Type[]) results.ToArray(typeof(System.Type)); }
private static object ParseObjectInternal(object value, System.Type targetType, System.Type sourceType, TypeConverter targetConverter, TypeConverter sourceConverter, IFormatProvider formatInfo, object formattedNullValue) { if (EqualsFormattedNullValue(value, formattedNullValue, formatInfo) || (value == DBNull.Value)) { return DBNull.Value; } TypeConverter converter = TypeDescriptor.GetConverter(targetType); if (((targetConverter != null) && (converter != targetConverter)) && targetConverter.CanConvertFrom(sourceType)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } TypeConverter converter2 = TypeDescriptor.GetConverter(sourceType); if (((sourceConverter != null) && (converter2 != sourceConverter)) && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } if (value is string) { object obj2 = InvokeStringParseMethod(value, targetType, formatInfo); if (obj2 != parseMethodNotFound) { return obj2; } } else if (value is CheckState) { CheckState state = (CheckState) value; if (state == CheckState.Indeterminate) { return DBNull.Value; } if (targetType == booleanType) { return (state == CheckState.Checked); } if (targetConverter == null) { targetConverter = converter; } if ((targetConverter != null) && targetConverter.CanConvertFrom(booleanType)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), state == CheckState.Checked); } } else if ((value != null) && targetType.IsAssignableFrom(value.GetType())) { return value; } if (targetConverter == null) { targetConverter = converter; } if (sourceConverter == null) { sourceConverter = converter2; } if ((targetConverter != null) && targetConverter.CanConvertFrom(sourceType)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } if ((sourceConverter != null) && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } if (!(value is IConvertible)) { throw new FormatException(GetCantConvertMessage(value, targetType)); } return ChangeType(value, targetType, formatInfo); }
private void ValidateCurrentBehaviourClass(System.Type myType) { if (myTarget.Behaviour == null) { object o = CreateInstance(myType); myTarget.Behaviour = (A_InteractBehaviour)o; } else { // If Different Behaviour Type if ( !(myType.IsAssignableFrom( myTarget.Behaviour.GetType() ) ) ) { // Creates New Instance Of Type And Assigns It object o = CreateInstance(myType); myTarget.Behaviour = (A_InteractBehaviour)o; } } }
/// <summary>Sets the value of the <code>name</code> property to the name of a class. /// First checks that the class implements the named interface. /// </summary> public virtual void SetClass(System.String propertyName, System.Type theClass, System.Type xface) { if (!xface.IsAssignableFrom(theClass)) { throw new System.SystemException(theClass + " not " + xface.FullName); } SetProperty(propertyName, theClass.FullName); }
private static object ConvertType(object value, System.Type type) { if (value == null) return null; if (type.IsAssignableFrom(value.GetType())) return value; if (IsNullableOfT(type)) type = Nullable.GetUnderlyingType(type); if (type.IsEnum) return Enum.ToObject(type, value); if (type.IsPrimitive) return Convert.ChangeType(value, type); throw new Exception("Cannot convert '" + value.ToString() + "' to " + type.ToString()); }
public static bool IsType(System.Type tp, System.Type assignableType) { return assignableType.IsAssignableFrom(tp); }
public bool ContainsSymbol(string name, System.Type symbol_type) { return this.symbols.ContainsKey(name) && symbol_type.IsAssignableFrom(this.symbols[name].GetType()); }
private static bool ApplyPropertyToExistingNode(ProjectionNode existingNode, ResourceProperty property, System.Data.Services.Providers.ResourceType targetResourceType) { if (((property == null) || (existingNode.Property == null)) || (property == existingNode.Property)) { ExpandedProjectionNode node = existingNode as ExpandedProjectionNode; if (targetResourceType.IsAssignableFrom(existingNode.TargetResourceType)) { VerifyPropertyMismatchAndExpandSelectMismatchScenario(existingNode, property, targetResourceType, node != null); existingNode.TargetResourceType = targetResourceType; return true; } if (existingNode.TargetResourceType.IsAssignableFrom(targetResourceType)) { VerifyPropertyMismatchAndExpandSelectMismatchScenario(existingNode, property, targetResourceType, node != null); return true; } } return false; }
private ArrayList FindControls(System.Type baseType, bool searchAllChildren, Control.ControlCollection controlsToLookIn, ArrayList foundControls) { if ((controlsToLookIn == null) || (foundControls == null)) { return null; } try { for (int i = 0; i < controlsToLookIn.Count; i++) { if ((controlsToLookIn[i] != null) && baseType.IsAssignableFrom(controlsToLookIn[i].GetType())) { foundControls.Add(controlsToLookIn[i]); } } if (!searchAllChildren) { return foundControls; } for (int j = 0; j < controlsToLookIn.Count; j++) { if (((controlsToLookIn[j] != null) && !(controlsToLookIn[j] is Form)) && ((controlsToLookIn[j].Controls != null) && (controlsToLookIn[j].Controls.Count > 0))) { foundControls = this.FindControls(baseType, searchAllChildren, controlsToLookIn[j].Controls, foundControls); } } } catch (Exception exception) { if (System.Windows.Forms.ClientUtils.IsCriticalException(exception)) { throw; } } return foundControls; }
internal static UnityEngine.Object ValidateObjectFieldAssignment(UnityEngine.Object[] references, System.Type objType, SerializedProperty property) { if (references.Length > 0) { bool flag1 = DragAndDrop.objectReferences.Length > 0; bool flag2 = references[0] != (UnityEngine.Object) null && references[0].GetType() == typeof (Texture2D); if (objType == typeof (Sprite) && flag2 && flag1) return (UnityEngine.Object) SpriteUtility.TextureToSprite(references[0] as Texture2D); if (property != null) { if (references[0] != (UnityEngine.Object) null && property.ValidateObjectReferenceValue(references[0])) return references[0]; if ((property.type == "PPtr<Sprite>" || property.type == "PPtr<$Sprite>" || property.type == "vector") && (flag2 && flag1)) return (UnityEngine.Object) SpriteUtility.TextureToSprite(references[0] as Texture2D); } else { if (references[0] != (UnityEngine.Object) null && references[0].GetType() == typeof (GameObject) && typeof (Component).IsAssignableFrom(objType)) references = (UnityEngine.Object[]) ((GameObject) references[0]).GetComponents(typeof (Component)); foreach (UnityEngine.Object reference in references) { if (reference != (UnityEngine.Object) null && objType.IsAssignableFrom(reference.GetType())) return reference; } } } return (UnityEngine.Object) null; }
public static System.Type[] GetCreatableObjects(System.Type parentType, string path) { var retval = new ArrayList(); var al = LoadAllAssembliesForPath(path); try { foreach (System.Reflection.Assembly assembly in al) { System.Diagnostics.Debug.WriteLine(assembly.Location); foreach (var t in assembly.GetTypes()) { if (parentType.IsAssignableFrom(t) && !t.IsAbstract && !t.IsInterface) retval.Add(t); else if (t.IsAssignableFrom(parentType) && !t.IsAbstract && !t.IsInterface) retval.Add(t); } } } catch (Exception ex) { throw; } return (System.Type[])retval.ToArray(typeof(System.Type)); }
private static bool IsMatchingImplementor(string entityOrClassName, System.Type entityClass, IQueryable implementor) { var implementorClass = implementor.GetMappedClass(EntityMode.Poco); if (implementorClass == null) { return false; } if (entityClass.Equals(implementorClass)) { // It is possible to have multiple mappings for the same entity class, but with different entity names. // When querying for a specific entity name, we should only return entities for the requested entity name // and not return entities for any other entity names that may map to the same entity class. bool isEntityName = !entityOrClassName.Equals(entityClass.FullName); return !isEntityName || entityOrClassName.Equals(implementor.EntityName); } return entityClass.IsAssignableFrom(implementorClass); }
bool IRemotingTypeInfo.CanCastTo(System.Type toType, object o) { if (!toType.IsAssignableFrom(this.proxiedType)) { return this.serviceChannel.CanCastTo(toType); } return true; }
public static void AssertClassAssignability(System.Type source, System.Type target) { Assert.IsTrue(target.IsAssignableFrom(source), "Classes were not assignment-compatible : source<" + source.FullName + "> target<" + target.FullName + ">" ); }
public static MdaMvc4Net.Reflect.MdaFieldCategory defaultTypeToFieldType(System.Type type) { MdaMvc4Net.Reflect.MdaFieldCategory res; if (type.IsPrimitive || type==typeof(string) || type.IsValueType // TODO ... also use all immutable ref type ) { res = MdaMvc4Net.Reflect.MdaFieldCategory.FIELD_VALUE; } else { if (type.IsArray) { res = MdaMvc4Net.Reflect.MdaFieldCategory.FIELD_ARRAY; } else { if (type.IsAssignableFrom(typeof(System.Collections.IList))) { res = MdaMvc4Net.Reflect.MdaFieldCategory.FIELD_LIST; } else { // TODO how to detect Collection<> as Set<> : containing unique objects, no doublons // if (type.IsAssignableFrom((typeof(java.util.Set)))) // { // res = MdaMvc4Net.Reflect.MdaFieldCategory.FIELD_SET; // } // else { if (type.IsAssignableFrom(typeof(System.Collections.ICollection))) { res = MdaMvc4Net.Reflect.MdaFieldCategory.FIELD_COLLECTION; } else { if (type.IsAssignableFrom(typeof(System.Collections.IDictionary))) { res = MdaMvc4Net.Reflect.MdaFieldCategory.FIELD_MAP; } else { res = MdaMvc4Net.Reflect.MdaFieldCategory.FIELD_REF; } } } } } } // unknown ref! TODO use IOC / see post validate to decide more precisely?? return res; }
public StyleCollectionEditor(System.Type type) : base(type) { this.isRowCollection = type.IsAssignableFrom(typeof(TableLayoutRowStyleCollection)); }
public static UnityEngine.Object ReadUnityReference (AstarSerializer serializer, string name, int instanceID, System.Type type) { Object ob1 = EditorUtility.InstanceIDToObject (instanceID); //Discard if not the correct type if (ob1 != null && !type.IsAssignableFrom (ob1.GetType ())) { ob1 = null; } Object ob2 = null; if (ob1 != null && ob1.name == name) { //Debug.Log ("Loading from InstanceID + name"); return ob1; } string guid = serializer.readerStream.ReadString (); if (guid != "") { string path = AssetDatabase.GUIDToAssetPath (guid); ob2 = AssetDatabase.LoadMainAssetAtPath (path); //Discard if not the correct type if (ob2 != null && !type.IsAssignableFrom (ob2.GetType ())) { ob2 = null; } //Debug.Log ("Got path "+path+" Got Object "+(ob2 != null)); if (ob2 != null) { if (ob2 == ob1) { return ob2; } if (ob2.name == name) { return ob2; } } } //If any were found, return them in priority order if (ob2 != null) { return ob2; } if (ob1 != null) { return ob1; } return null; }
public override AttributeImpl CreateAttributeInstance(System.Type attClass) { return attClass.IsAssignableFrom(typeof(TokenWrapper))?new TokenWrapper():delegate_Renamed.CreateAttributeInstance(attClass); }
/// <summary>Returns the value of the <code>name</code> property as a Class. If no /// such property is specified, then <code>defaultValue</code> is returned. /// An error is thrown if the returned class does not implement the named /// interface. /// </summary> public virtual System.Type GetClass(System.String propertyName, System.Type defaultValue, System.Type xface) { try { System.Type theClass = GetClass(propertyName, defaultValue); if (theClass != null && !xface.IsAssignableFrom(theClass)) { throw new System.SystemException(theClass + " not " + xface.FullName); } return theClass; } catch (System.Exception e) { throw new ParserException("Failed to get class type", e); } }