static bool AssemblyPredicate( Type t ) { return !t.IsAbstract && t.IsSubclassOf( typeof(ScriptableObject) ) && !t.IsSubclassOf( typeof(Editor) ); }
internal static WriteJsonValue GetWriteJsonMethod(Type type) { var t = Reflection.GetJsonDataType (type); if (t == JsonDataType.Primitive) { return typeof (decimal).Equals (type) ? WriteDecimal : typeof (byte).Equals (type) ? WriteByte : typeof (sbyte).Equals (type) ? WriteSByte : typeof (short).Equals (type) ? WriteInt16 : typeof (ushort).Equals (type) ? WriteUInt16 : typeof (uint).Equals (type) ? WriteUInt32 : typeof (ulong).Equals (type) ? WriteUInt64 : typeof (char).Equals (type) ? WriteChar : (WriteJsonValue)WriteUnknown; } else if (t == JsonDataType.Undefined) { return type.IsSubclassOf (typeof (Array)) && type.GetArrayRank () > 1 ? WriteMultiDimensionalArray : type.IsSubclassOf (typeof (Array)) && typeof (byte[]).Equals (type) == false ? WriteArray : typeof (KeyValuePair<string,object>).Equals (type) ? WriteKeyObjectPair : typeof (KeyValuePair<string,string>).Equals (type) ? WriteKeyValuePair : (WriteJsonValue)WriteObject; } else { return _convertMethods[(int)t]; } }
public virtual ICauterizeTypeFormatter GetFormatter(Type t) { ICauterizeTypeFormatter formatter; if (t.IsSubclassOf(typeof (CauterizeComposite))) { formatter = new CauterizeCompositeFormatter(this); } else if (t.IsSubclassOf(typeof (CauterizeGroup))) { formatter = new CauterizeGroupFormatter(this); } else if (t.IsSubclassOf(typeof (CauterizeFixedArray))) { formatter = new CauterizeFixedArrayFormatter(this); } else if (t.IsSubclassOf(typeof (CauterizeVariableArray))) { formatter = new CauterizeVariableArrayFormatter(this); } else if (t.IsSubclassOf(typeof (Enum))) { formatter = new CauterizeEnumFormatter(); } else { formatter = new CauterizePrimitiveFormatter(); } return formatter; }
public static UnityEngine.Object[] GetFiltered(System.Type type, UnityEditor.SelectionMode mode) { ArrayList list = new ArrayList(); if ((type == typeof(Component)) || type.IsSubclassOf(typeof(Component))) { foreach (Transform transform in GetTransforms(mode)) { Component component = transform.GetComponent(type); if (component != null) { list.Add(component); } } } else if ((type == typeof(GameObject)) || type.IsSubclassOf(typeof(GameObject))) { foreach (Transform transform2 in GetTransforms(mode)) { list.Add(transform2.gameObject); } } else { foreach (UnityEngine.Object obj2 in GetObjectsMode(mode)) { if ((obj2 != null) && ((obj2.GetType() == type) || obj2.GetType().IsSubclassOf(type))) { list.Add(obj2); } } } return((UnityEngine.Object[])list.ToArray(typeof(UnityEngine.Object))); }
/// <summary> /// <para>Returns the current selection filtered by type and mode.</para> /// </summary> /// <param name="type">Only objects of this type will be retrieved.</param> /// <param name="mode">Further options to refine the selection.</param> public static UnityEngine.Object[] GetFiltered(System.Type type, SelectionMode mode) { ArrayList arrayList = new ArrayList(); if (type == typeof(Component) || type.IsSubclassOf(typeof(Component))) { foreach (Component transform in Selection.GetTransforms(mode)) { Component component = transform.GetComponent(type); if ((bool)((UnityEngine.Object)component)) { arrayList.Add((object)component); } } } else if (type == typeof(GameObject) || type.IsSubclassOf(typeof(GameObject))) { foreach (Transform transform in Selection.GetTransforms(mode)) { arrayList.Add((object)transform.gameObject); } } else { foreach (UnityEngine.Object @object in Selection.GetObjectsMode(mode)) { if (@object != (UnityEngine.Object)null && (@object.GetType() == type || @object.GetType().IsSubclassOf(type))) { arrayList.Add((object)@object); } } } return((UnityEngine.Object[])arrayList.ToArray(typeof(UnityEngine.Object))); }
static ILockTest CreateTest( Type testType, Type lockType, object[] parameters ) { if ( ! testType.IsSubclassOf(typeof(ILockTest)) ) { throw new InvalidCastException("Test type must be derived from ILockTest"); } if ( null != lockType ) { if ( ! testType.IsSubclassOf(typeof(ISyncLock)) ) { throw new InvalidCastException("Lock type must be derived from ISyncLock"); } } ISyncLock syncLock = (ISyncLock) CreateTypeInstance(lockType); if ( null == syncLock ) { throw new ArgumentException("Unable to construct an ISyncLock instance with specified parameters"); } ILockTest test = (ILockTest) CreateTypeInstance(testType, new object[] {syncLock}); if ( null == test ) { throw new ArgumentException("Unable to construct an ILockTest instance with specified ISyncLock"); } return test; }
public static BulkGenericType Classify( BODType deedType, Type itemType ) { if ( deedType == BODType.Tailor ) { if ( itemType == null || itemType.IsSubclassOf( typeof( BaseArmor ) ) || itemType.IsSubclassOf( typeof( BaseShoes ) ) ) return BulkGenericType.Leather; return BulkGenericType.Cloth; } //else if ( deedType == BODType.Fletcher ) ////////////////////////////////// // Cap & Fletch BOD Addon 2/2 // ////////////////////////////////// else if ( deedType == BODType.Fletcher ) { if ( itemType == null || itemType.IsSubclassOf( typeof( BaseRanged ) ) ) return BulkGenericType.Wood; return BulkGenericType.Wood; } else if ( deedType == BODType.Carpenter ) { if ( itemType == null || itemType.IsSubclassOf( typeof( BaseStaff ) ) || itemType.IsSubclassOf( typeof( BaseShield ) ) ) return BulkGenericType.Wood; return BulkGenericType.Wood; } ////////////////////////////////// // End of Edit 2/2 // ////////////////////////////////// //return BulkGenericType.Wood; return BulkGenericType.Iron; }
private int ReadField(Context context, FieldType field, int fieldIndex, ArrayList fieldValues, out object fieldValue, ref byte bitOffset) { fieldValue = null; System.Type type = field.GetType(); if ((type == typeof(Integer)) || type.IsSubclassOf(typeof(Integer))) { return(this.ReadField(context, (Integer)field, out fieldValue)); } if ((type == typeof(FloatingPoint)) || type.IsSubclassOf(typeof(FloatingPoint))) { return(this.ReadField(context, (FloatingPoint)field, out fieldValue)); } if ((type == typeof(CharString)) || type.IsSubclassOf(typeof(CharString))) { return(this.ReadField(context, (CharString)field, fieldIndex, fieldValues, out fieldValue)); } if ((type == typeof(BitString)) || type.IsSubclassOf(typeof(BitString))) { return(this.ReadField(context, (BitString)field, out fieldValue, ref bitOffset)); } if (type != typeof(TypeReference)) { throw new NotImplementedException("Fields of type '" + type.ToString() + "' are not implemented yet."); } return(this.ReadField(context, (TypeReference)field, out fieldValue)); }
private static bool IsEcommerceType(Type entityType) { return MrCMSApp.AllAppTypes.ContainsKey(entityType) && MrCMSApp.AllAppTypes[entityType] == EcommerceApp.EcommerceAppName && (!entityType.IsSubclassOf(typeof (Document)) && !entityType.IsSubclassOf(typeof (UserProfileData)) && !entityType.IsSubclassOf(typeof (Widget))); }
// Token: 0x060003EE RID: 1006 RVA: 0x0000B1B0 File Offset: 0x0000A1B0 private int WriteField(Context context, FieldType field, int fieldIndex, ComplexValue[] fieldValues, object fieldValue, ref byte bitOffset) { System.Type type = field.GetType(); if (type == typeof(Integer) || type.IsSubclassOf(typeof(Integer))) { return(this.WriteField(context, (Integer)field, fieldValue)); } if (type == typeof(FloatingPoint) || type.IsSubclassOf(typeof(FloatingPoint))) { return(this.WriteField(context, (FloatingPoint)field, fieldValue)); } if (type == typeof(CharString) || type.IsSubclassOf(typeof(CharString))) { return(this.WriteField(context, (CharString)field, fieldIndex, fieldValues, fieldValue)); } if (type == typeof(BitString) || type.IsSubclassOf(typeof(BitString))) { return(this.WriteField(context, (BitString)field, fieldValue, ref bitOffset)); } if (type == typeof(TypeReference) || type.IsSubclassOf(typeof(TypeReference))) { return(this.WriteField(context, (TypeReference)field, fieldValue)); } throw new NotImplementedException("Fields of type '" + type.ToString() + "' are not implemented yet."); }
public override void OnInspectorGUI() { if (target == null || !(target is MonoScript)) { return; } MonoScript script = target as MonoScript; System.Type t = script.GetClass(); if (t == null) { return; } if (!(t.IsSubclassOf(typeof(Editor)) || t.IsSubclassOf(typeof(EditorWindow)))) { if (t.IsSubclassOf(typeof(ScriptableObject)) && GUILayout.Button("Create Asset")) { ScriptableObjectUtility.CreateAsset(t); } } showCode = EditorGUILayout.Foldout(showCode, "Code"); if (showCode) { EditorGUILayout.TextArea(script.text); } }
public static string GetDisplayedName(System.Type type) { var typename = type.FullName; KnownType info; if (KnownType.Register.TryGetValue(typename, out info)) { return(info.GenericName); } if (type.IsSubclassOf(KnownType.AnimControllerType) && KnownType.Register.ContainsKey(KnownType.AnimControllerType.FullName)) { return(type.Name); } if (type.IsSubclassOf(KnownType.ComponentType) && KnownType.Register.ContainsKey(KnownType.ComponentType.FullName)) { return(type.Name); } if (type.IsSubclassOf(KnownType.ScriptableObjectType) && KnownType.Register.ContainsKey(KnownType.ScriptableObjectType.FullName)) { return(type.Name); } return(null); }
void SetBehavioursEnabled(bool b) { foreach (string type in toDisable) { Component c = GetComponent(type) as Component; System.Type t = c.GetType(); if (t.IsSubclassOf(typeof(Behaviour))) { Behaviour behaviour = c as Behaviour; behaviour.enabled = b; } else if (t.IsSubclassOf(typeof(Renderer))) { Renderer renderer = c as Renderer; renderer.enabled = b; } else if (t.IsSubclassOf(typeof(Collider))) { Collider collider = c as Collider; collider.enabled = b; } else if (t.IsSubclassOf(typeof(ParticleEmitter))) { ParticleEmitter emitter = c as ParticleEmitter; emitter.enabled = b; } } }
void AddModType(GameObject go, System.Type name, bool modobj) { if (go) { if (!name.IsSubclassOf(typeof(MegaModifier)) && !name.IsSubclassOf(typeof(MegaWarp))) { go.AddComponent(name); } else { MeshFilter mf = go.GetComponent <MeshFilter>(); if (mf != null) { if (modobj) { if (name.IsSubclassOf(typeof(MegaModifier))) { MegaModifyObject mod = go.GetComponent <MegaModifyObject>(); if (mod == null) { mod = go.AddComponent <MegaModifyObject>(); mod.NormalMethod = NormalMethod; } } } if (name != null) { if (name.IsSubclassOf(typeof(MegaModifier))) { MegaModifier md = (MegaModifier)go.AddComponent(name); if (md) { md.gizCol1 = col1; md.gizCol2 = col2; } } else { if (name.IsSubclassOf(typeof(MegaWarp))) { MegaWarp md = (MegaWarp)go.AddComponent(name); if (md) { md.GizCol1 = col1; md.GizCol2 = col2; } } else { go.AddComponent(name); } } } } } } }
public object GetService(Type serviceType) { return serviceType.IsSubclassOf(typeof (ControllerBase)) ? Activator.CreateInstance(serviceType, new ServiceManager()) : serviceType.IsSubclassOf(typeof (ApiController)) ? Activator.CreateInstance(serviceType) : null; }
public IBsonSerializer GetSerializer(Type type) { if (type == typeof(IGameObject) || type.IsSubclassOf(typeof(IGameObject)) || type.GetInterface(typeof(IGameObject).Name) != null) return new GameObjectSerializer(); if (type == typeof(IDataObject) || type.IsSubclassOf(typeof(IDataObject)) || type.GetInterface(typeof(IDataObject).Name) != null) return new DataObjectSerializer<IDataObject>(); return null; }
private static bool IsTypeCompatible(System.Type type) { if ((type == null) || (!type.IsSubclassOf(typeof(MonoBehaviour)) && !type.IsSubclassOf(typeof(ScriptableObject)))) { return(false); } return(true); }
private static bool IsTypeCompatible(Type type) { if ((type == null) || (!type.IsSubclassOf(typeof(MonoBehaviour)) && !type.IsSubclassOf(typeof(ScriptableObject)))) { return false; } return true; }
public override bool CanConvert(Type objectType) { return objectType == typeof (RavenJToken) || objectType == typeof (DynamicJsonObject) || objectType == typeof (DynamicNullObject) || objectType.IsSubclassOf(typeof (RavenJToken)) || objectType.IsSubclassOf(typeof (DynamicJsonObject)); }
public object Get(string name, System.Type type) { object obj = null; if (type == typeof(UnityEngine.Object) || type.IsSubclassOf(typeof(UnityEngine.Object))) { obj = objects.Get(name); } else if (type == typeof(float)) { obj = floats.Get(name); } else if (type == typeof(int)) { obj = ints.Get(name); } else if (type == typeof(string)) { obj = strings.Get(name) ?? string.Empty; } else if (type == typeof(bool)) { obj = bools.Get(name); } else if (type.IsSubclassOf(typeof(System.Enum))) { obj = enums.Get(name); } else if (type == typeof(Vector3)) { obj = vector3s.Get(name); } else if (type == typeof(Vector2)) { obj = vector2s.Get(name); } else if (type == typeof(Vector4)) { obj = vector4s.Get(name); } else if (type == typeof(Color)) { obj = colors.Get(name); } else if (type == typeof(LayerMaskMap)) { obj = layerMasks.Get(name); } else { throw new NotSupportedException($"Type {type.AssemblyQualifiedName} is not supported. ({name})"); } if (obj == null && type.IsValueType) { return(Activator.CreateInstance(type)); } return(obj); }
protected void BuildPropertySet(Type p, StringCollection propertySet) { if (TypeToLdapPropListMap[this.MappingTableIndex].ContainsKey(p)) { Debug.Assert(TypeToLdapPropListMap[this.MappingTableIndex].ContainsKey(p)); string[] props = new string[TypeToLdapPropListMap[this.MappingTableIndex][p].Count]; TypeToLdapPropListMap[this.MappingTableIndex][p].CopyTo(props, 0); propertySet.AddRange(props); } else { Type baseType; if (p.IsSubclassOf(typeof(UserPrincipal))) { baseType = typeof(UserPrincipal); } else if (p.IsSubclassOf(typeof(GroupPrincipal))) { baseType = typeof(GroupPrincipal); } else if (p.IsSubclassOf(typeof(ComputerPrincipal))) { baseType = typeof(ComputerPrincipal); } else if (p.IsSubclassOf(typeof(AuthenticablePrincipal))) { baseType = typeof(AuthenticablePrincipal); } else { baseType = typeof(Principal); } Hashtable propertyList = new Hashtable(); // Load the properties for the base types... foreach (string s in TypeToLdapPropListMap[this.MappingTableIndex][baseType]) { if (!propertyList.Contains(s)) { propertyList.Add(s, s); } } // Reflect the properties off the extension class and add them to the list. BuildExtensionPropertyList(propertyList, p); foreach (string property in propertyList.Values) { propertySet.Add(property); } // Cache the list for this property type so we don't need to reflect again in the future. this.AddPropertySetToTypePropListMap(p, propertySet); } }
static bool IsAsset(System.Type type) { return(!type.IsSubclassOf(typeof(UnityEngine.Component)) && type.IsSubclassOf(typeof(UnityEngine.Object)) && type.Name != "Component" //exceptions && type.Name != "LightmapSettings" && type.Name != "RenderSettings" ); }
public override bool IsDiscriminated(Type type) { //return true; if (type.IsSubclassOf(typeof(BillingTransaction)) || type.IsSubclassOf(typeof(AccountMeta))) { return true; } return false; }
/// <summary> /// 绑定列表控件和数据 /// </summary> /// <typeparam name="T"></typeparam> /// <typeparam name="T1"></typeparam> /// <param name="list"></param> public void ObserverListAll <T, T1>(UniRx.IReactiveCollection <T1> list, bool autoWidth = false) where T : UIBase where T1 : IViewModel { System.Type type = typeof(T); System.Type vmType = typeof(T1); bool isImpleIViewModelCtrl = vmType.IsSubclassOf(typeof(IViewModelCtrl)); bool isImpleIViewModelPosition = vmType.IsSubclassOf(typeof(IViewModelStyle)); var g = gObject; var u = uiBase; var observeAdd = list.ObserveAdd(); var subAdd = observeAdd.Subscribe((o) => { if (isImpleIViewModelCtrl) { type = (o.Value as IViewModelCtrl).CtrlType; } var ctrl = System.Activator.CreateInstance(type, g, o.Value) as T; ctrl.SetMainViewModel(o.Value as IViewModel); ctrl.CreateUIInstance(false); if (isImpleIViewModelPosition) { var vmPos = (o.Value as IViewModelStyle); var pos = vmPos.LocalPosition; ctrl.gObject.SetPosition(pos.x, pos.y, pos.z); } //g.AddSelection(g.numItems, true); u.TempKv[o.Value] = ctrl; ctrl.AddToPanel(u); }); var it = list.GetEnumerator(); while (it.MoveNext()) { if (isImpleIViewModelCtrl) { type = (it.Current as IViewModelCtrl).CtrlType; } var ctrl = System.Activator.CreateInstance(type, g, it.Current) as T; ctrl.SetMainViewModel(it.Current as IViewModel); ctrl.CreateUIInstance(false); if (isImpleIViewModelPosition) { var vmPos = (it.Current as IViewModelStyle); var pos = vmPos.LocalPosition; ctrl.gObject.SetPosition(pos.x, pos.y, pos.z); } //g.AddSelection(g.numItems, true); u.TempKv[it.Current] = ctrl; ctrl.AddToPanel(uiBase); } uiBase.AddDisposable(subAdd); }
//TODO: If placed in your domain, uncomment and replace MyDbContext with your domain's DbContext/ObjectContext class. //public UniqueAttribute() : this(typeof(MyDbContext)) { } /// <summary> /// Initializes a new instance of <see cref="UniqueAttribute"/>. /// </summary> /// <param name="contextType">The type of <see cref="DbContext"/> or <see cref="ObjectContext"/> subclass that will be used to search for duplicates.</param> public UniqueAttribute(Type contextType) { if (contextType == null) throw new ArgumentNullException("contextType"); if (!contextType.IsSubclassOf(typeof(DbContext)) && !contextType.IsSubclassOf(typeof(ObjectContext))) throw new ArgumentException("The contextType Type must be a subclass of DbContext or ObjectContext.", "contextType"); if (contextType.GetConstructor(Type.EmptyTypes) == null) throw new ArgumentException("The contextType type must declare a public parameterless consructor."); _ContextType = contextType; }
public static BulkGenericType Classify( BODType deedType, Type itemType ) { if ( deedType == BODType.Tailor ) { if ( itemType == null || itemType.IsSubclassOf( typeof( BaseArmor ) ) || itemType.IsSubclassOf( typeof( BaseShoes ) ) ) return BulkGenericType.Leather; return BulkGenericType.Cloth; } return BulkGenericType.Iron; }
internal object DataMarshal(IntPtr data) { object ret = null; if (element_type != null) { if (element_type == typeof(string)) { ret = Marshaller.Utf8PtrToString(data); } else if (element_type == typeof(FilenameString)) { ret = Marshaller.FilenamePtrToString(data); } else if (element_type == typeof(IntPtr)) { ret = data; } else if (element_type.IsSubclassOf(typeof(GLib.Object))) { ret = GLib.Object.GetObject(data, false); } else if (element_type.IsSubclassOf(typeof(GLib.Opaque))) { ret = GLib.Opaque.GetOpaque(data, element_type, elements_owned); } else if (element_type == typeof(int)) { ret = (int)data; } else if (element_type.IsValueType) { ret = Marshal.PtrToStructure(data, element_type); } else if (element_type.IsInterface) { Type adapter_type = element_type.Assembly.GetType(InterfaceToAdapterTypeName(element_type)); System.Reflection.MethodInfo method = adapter_type.GetMethod("GetObject", new Type[] { typeof(IntPtr), typeof(bool) }); ret = method.Invoke(null, new object[] { data, false }); } else { ret = Activator.CreateInstance(element_type, new object[] { data }); } } else if (Object.IsObject(data)) { ret = GLib.Object.GetObject(data, false); } return(ret); }
/// <summary> /// Factory method which creates declaration corresponding to given type. /// </summary> public static IDecl ToDecl(System.Type type, CommentNavigator navigator, ProjectNavigator projNavigator) { if (type.IsSubclassOf(typeof(Enum))) { return(EnumToDecl(type, navigator, projNavigator)); } if (type.IsSubclassOf(typeof(Data))) { return(TypeToDecl(type, navigator, projNavigator)); } throw new ArgumentException($"{type.FullName} is not subclass of Enum or Data", nameof(type)); }
/// <summary> /// Checks if type could be used in declaration. /// Namely, it checks if it is one of the following: is primitive, is enum or derived from Data /// </summary> private static bool IsAllowedType(System.Type type) { if (IsRoot(type)) { return(false); } type = GetListArgument(type); type = GetNullableArgument(type); return(AllowedPrimitiveTypes.Contains(type) || type.IsSubclassOf(typeof(Data)) || type.IsSubclassOf(typeof(Enum))); }
protected override void GenerateCodeFor(Type type) { var codeNamespace = GetNamespace(type); Action<Action<Type>> run = action => { AppendUsings(UsingNamespaces); sb.AppendLine(); cw.Indented("namespace "); sb.AppendLine(codeNamespace); cw.InBrace(delegate { action(type); }); }; if (type.GetIsEnum()) run(GenerateEnum); else if (type.IsSubclassOf(typeof(Controller))) run(GenerateService); else { var formScriptAttr = type.GetCustomAttribute<FormScriptAttribute>(); if (formScriptAttr != null) { run(t => GenerateForm(t, formScriptAttr)); EnqueueTypeMembers(type); if (type.IsSubclassOf(typeof(ServiceRequest))) { AddFile(RemoveRootNamespace(codeNamespace, this.fileIdentifier + (IsTS() ? ".ts" : ".cs"))); this.fileIdentifier = type.Name; run(GenerateBasicType); } return; } else if (type.GetCustomAttribute<ColumnsScriptAttribute>() != null) { //GenerateColumns(type); run(EnqueueTypeMembers); return; } else run(GenerateBasicType); } }
public static SqlCodeGeneratorBase CreateCodeGenerator(Type t) { if (t == typeof(Schema.SqlServer.SqlServerDataset) || t.IsSubclassOf(typeof(Schema.SqlServer.SqlServerDataset))) { return new SqlServerCodeGenerator(); } else if (t == typeof(Schema.MySql.MySqlDataset) || t.IsSubclassOf(typeof(Schema.MySql.MySqlDataset))) { return new MySqlCodeGenerator(); } else { return new PostgreSqlCodeGenerator(); } }
public static KnownType GetKnownType(System.Type type) { if (type == null) { return(null); } var typename = type.FullName; KnownType info; if (KnownType.Register.TryGetValue(typename, out info)) { return(info); } if (type.IsSubclassOf(KnownType.AnimControllerType)) { typename = KnownType.AnimControllerType.FullName; if (KnownType.Register.TryGetValue(typename, out info)) { return(info); } } if (type.IsSubclassOf(KnownType.ComponentType)) { typename = KnownType.ComponentType.FullName; if (KnownType.Register.TryGetValue(typename, out info)) { return(info); } } if (type.IsSubclassOf(KnownType.ScriptableObjectType)) { typename = KnownType.ScriptableObjectType.FullName; if (KnownType.Register.TryGetValue(typename, out info)) { return(info); } } return(null); }
public DynamicMetaObject ConvertWorker(DynamicMetaObjectBinder binder, Type toType, ConversionResultKind kind) { if (toType.IsSubclassOf(typeof(Delegate))) { return MakeDelegateTarget(binder, toType, Restrict(typeof(Method))); } return FallbackConvert(binder); }
/// <summary> /// This code was taken from Mike Bouck's July 31st, 2005 blog post located here: http://blog.gatosoft.com/ /// Many thanks to Mike for this updated .NET 2.0-compatible code. /// </summary> /// <param name="type"></param> /// <param name="priority"></param> /// <param name="group"></param> private static void RegisterSoapExtension(Type type, int priority, PriorityGroup group) { if (!type.IsSubclassOf(typeof(SoapExtension))) { throw new ArgumentException("Type must be derived from SoapException.", "type"); } if (priority < 1) { throw new ArgumentOutOfRangeException("priority", priority, "Priority must be greater or equal to 1."); } // get the current web services settings... WebServicesSection wss = WebServicesSection.Current; // set SoapExtensionTypes collection to read/write... FieldInfo readOnlyField = typeof(System.Configuration.ConfigurationElementCollection).GetField("bReadOnly", BindingFlags.NonPublic | BindingFlags.Instance); readOnlyField.SetValue(wss.SoapExtensionTypes, false); // inject SoapExtension... wss.SoapExtensionTypes.Add(new SoapExtensionTypeElement(type, priority, group)); // set SoapExtensionTypes collection back to readonly and clear modified flags... MethodInfo resetModifiedMethod = typeof(System.Configuration.ConfigurationElement).GetMethod("ResetModified", BindingFlags.NonPublic | BindingFlags.Instance); resetModifiedMethod.Invoke(wss.SoapExtensionTypes, null); MethodInfo setReadOnlyMethod = typeof(System.Configuration.ConfigurationElement).GetMethod("SetReadOnly", BindingFlags.NonPublic | BindingFlags.Instance); setReadOnlyMethod.Invoke(wss.SoapExtensionTypes, null); }
public SessionBuilderAttribute(Type sessionBuilderType) { if (!(sessionBuilderType.IsSubclassOf(typeof(SingletonSessionBuilder)))) throw new ArgumentException("SessionBuilderType must derive from SingletonSessionBuilder"); SessionBuilderType = sessionBuilderType; }
// internal ConnectionPoint(MethodInfo callbackMethod, Type interfaceType, Type controlType, string displayName, string id, bool allowsMultipleConnections) { if (callbackMethod == null) { throw new ArgumentNullException("callbackMethod"); } if (interfaceType == null) { throw new ArgumentNullException("interfaceType"); } if (controlType == null) { throw new ArgumentNullException("controlType"); } if (!controlType.IsSubclassOf(typeof(Control))) { throw new ArgumentException(SR.GetString(SR.ConnectionPoint_InvalidControlType), "controlType"); } if (String.IsNullOrEmpty(displayName)) { throw new ArgumentNullException("displayName"); } _callbackMethod = callbackMethod; _interfaceType = interfaceType; _controlType = controlType; _displayName = displayName; _id = id; _allowsMultipleConnections = allowsMultipleConnections; }
private IGuiStyle FindDefaultStyle(StyleTypeNode root, System.Type elementType) { IGuiStyle result = null; if (root != null) { if (root.RegisteredType == elementType) { result = root.DefaultStyle; } else { foreach (StyleTypeNode child in root.Children) { if (elementType.IsSubclassOf(child.RegisteredType)) { result = FindDefaultStyle(child, elementType); } else if (elementType == child.RegisteredType) { result = child.DefaultStyle; } } if (result == null) { result = root.DefaultStyle; } } } return(result); }
private static Attribute[] InternalGetCustomAttributes(PropertyInfo element, Type type, bool inherit) { Contract.Requires(element != null); Contract.Requires(type != null); Contract.Requires(type.IsSubclassOf(typeof(Attribute)) || type == typeof(Attribute)); // walk up the hierarchy chain Attribute[] attributes = (Attribute[])element.GetCustomAttributes(type, inherit); if (!inherit) return attributes; // create the hashtable that keeps track of inherited types Dictionary<Type, AttributeUsageAttribute> types = new Dictionary<Type, AttributeUsageAttribute>(11); // create an array list to collect all the requested attibutes List<Attribute> attributeList = new List<Attribute>(); CopyToArrayList(attributeList, attributes, types); //if this is an index we need to get the parameter types to help disambiguate Type[] indexParamTypes = GetIndexParameterTypes(element); PropertyInfo baseProp = GetParentDefinition(element, indexParamTypes); while (baseProp != null) { attributes = GetCustomAttributes(baseProp, type, false); AddAttributesToList(attributeList, attributes, types); baseProp = GetParentDefinition(baseProp, indexParamTypes); } Array array = CreateAttributeArrayHelper(type, attributeList.Count); Array.Copy(attributeList.ToArray(), 0, array, 0, attributeList.Count); return (Attribute[])array; }
/// <summary> /// /// </summary> /// <param name="decoratorType"></param> public void AddDecorator(System.Type decoratorType) { if (decoratorType.IsSubclassOf(typeof(LineDecorator))) { this.Items.Add(new DecoratorEntry(decoratorType)); } }
/// <summary> /// Use to ensure certain aspect is used when method is intercepted. /// </summary> /// <param name="aspectType"></param> /// <param name="missingAspectOption"></param> /// <param name="constructorArgs"></param> public RequiredAspectAttribute(Type aspectType, WhenRequiredAspectIsMissing missingAspectOption, params object[] constructorArgs) { if(aspectType == null) throw new ArgumentNullException("aspectType"); if(!aspectType.IsSubclassOf(typeof(Aspect))) throw new ArgumentException("aspectType must be a subclass of the Aspect class."); this.AspectClassType = aspectType; if(missingAspectOption != WhenRequiredAspectIsMissing.DontInstantiate) { // Need to instantiate missing aspect Func<object> rawActivator = aspectType.GetFastActivatorWithEmbeddedArgs(constructorArgs); if(rawActivator != null) { this.activator = () => (Aspect)rawActivator(); } else { // No activator found string strErrorMsg = "Unable to find {0}({1}) constructor necessary to instantiate required missing aspect {0}." .SmartFormat(aspectType.FormatCSharp(), string.Join(", ", constructorArgs.Select(arg => arg == null ? "[ANY]" : arg.GetType().FormatCSharp())) ); throw new ArgumentException(strErrorMsg, "aspectType"); } } this.InstantiateIfMissing = missingAspectOption; }
// The main method used public static bool UseBluePower( Mobile from, Type t ) { if ( t == null ) return false; else if ( Array.IndexOf( m_Spells, t ) == -1 ) return false; else if ( t.IsSubclassOf( typeof( BlueMove ) ) ) { BlueMove bluemove = NewMove( t, from ); if ( bluemove != null ) { BlueMove.SetCurrentMove( from, bluemove ); from.SendMessage( "You prepare to use a monster's special attack" ); return true; } } else if ( t.IsSubclassOf( typeof( BlueSpell ) ) ) { BlueSpell bluespell = BlueSpellInfo.NewSpell( t, from ); if ( bluespell != null ) { bluespell.Cast(); return true; } } return false; }
static bool GetBaseType(System.Type type, System.Type baseType) { if (type == null || baseType == null || type == baseType) { return(false); } if (baseType.IsGenericType == false) { if (type.IsGenericType == false) { return(type.IsSubclassOf(baseType)); } } else { baseType = baseType.GetGenericTypeDefinition(); } type = type.BaseType; System.Type objectType = typeof(object); while (type != objectType && type != null) { System.Type curentType = type.IsGenericType ? type.GetGenericTypeDefinition() : type; if (curentType == baseType) { return(true); } type = type.BaseType; } return(false); }
/// <summary> /// 指定されたビューモデルのインスタンスの IWindowCloseCommand インターフェイス の /// WindowClose メソッドを実行します。 /// </summary> /// <returns></returns> public static void CloseViewModels(Type type) { if (!type.IsSubclassOf(typeof(ViewModelBase))) throw new ArgumentException( string.Format("引数の型が ViewModelBase の派生クラスになっていません(引数の型:{0})。", type.Name)); if (Count(type) == 0) return; var list = GetViewModels(type); if (list.First() as IWindowCloseCommand == null) { throw new InvalidCastException( "オブジェクトは IWindowCloseCommand インターフェイスを実装していません。: " + type.ToString()); } // ウィンドウが閉じることのできる状態か確認 if (!isReadyCloseWindows(list)) { throw new WindowPendingProcessException( string.Format("ViewModel:{0} が閉じることの出来る状態にありません。", type.Name)); } // ウィンドウを閉じる foreach (var n in list) { (n as IWindowCloseCommand).WindowClose(); } }
/// <summary> /// Deserialize a previously serialized game object. /// </summary> static void DeserializeComponents(this GameObject go, DataNode root) { DataNode scriptNode = root.GetChild("Components"); if (scriptNode == null) { return; } for (int i = 0; i < scriptNode.children.size; ++i) { DataNode node = scriptNode.children[i]; System.Type type = UnityTools.GetType(node.name); if (type != null && type.IsSubclassOf(typeof(Component))) { Component comp = go.GetComponent(type); if (comp == null) { comp = go.AddComponent(type); } comp.Deserialize(node); } } }
public static bool IsUserDefinedBehaviour(System.Type type) { return(type == typeof(UdonSharpBehaviour) || type.IsSubclassOf(typeof(UdonSharpBehaviour)) || (type.IsArray && (type.GetElementType() == typeof(UdonSharpBehaviour) || type.GetElementType().IsSubclassOf(typeof(UdonSharpBehaviour)) || type.GetElementType() == typeof(UdonBehaviour) || type.GetElementType().IsSubclassOf(typeof(UdonBehaviour))))); }
public List <AssetReferenceMeta> GetAssociatedResourcesMeta(System.Type InType) { if ((InType != typeof(BaseEvent)) && !InType.IsSubclassOf(typeof(BaseEvent))) { return(null); } List <AssetReferenceMeta> list = null; if (!this.Repositories.TryGetValue(InType, out list)) { list = new List <AssetReferenceMeta>(); this.Repositories.Add(InType, list); for (System.Type type = InType; (type == typeof(BaseEvent)) || type.IsSubclassOf(typeof(BaseEvent)); type = type.BaseType) { FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance); if (fields != null) { for (int i = 0; i < fields.Length; i++) { FieldInfo element = fields[i]; AssetReference customAttribute = Attribute.GetCustomAttribute(element, typeof(AssetReference)) as AssetReference; if (customAttribute != null) { AssetReferenceMeta item = new AssetReferenceMeta { MetaFieldInfo = element, Reference = customAttribute }; list.Add(item); } } } } } return(list); }
internal static string GetTypeIdentity(Type type) { Assumes.NotNull(type); string typeIdentity = null; if (!TypeIdentityCache.TryGetValue(type, out typeIdentity)) { if (!type.IsAbstract && type.IsSubclassOf(typeof(Delegate))) { MethodInfo method = type.GetMethod("Invoke"); typeIdentity = ContractNameServices.GetTypeIdentityFromMethod(method); } else { StringBuilder typeIdentityStringBuilder = new StringBuilder(); WriteTypeWithNamespace(typeIdentityStringBuilder, type); typeIdentity = typeIdentityStringBuilder.ToString(); } Assumes.IsTrue(!string.IsNullOrEmpty(typeIdentity)); TypeIdentityCache.Add(type, typeIdentity); } return typeIdentity; }
public static string[] GetAddresses(Type bindingType,string mexAddress,Type contractType,string issuer,string secret) { Debug.Assert(bindingType.IsSubclassOf(typeof(Binding)) || bindingType == typeof(Binding)); if(contractType.IsInterface == false) { Debug.Assert(false,contractType + " is not an interface"); return new string[]{}; } object[] attributes = contractType.GetCustomAttributes(typeof(ServiceContractAttribute),false); if(attributes.Length == 0) { Debug.Assert(false,"Interface " + contractType + " does not have the ServiceContractAttribute"); return new string[]{}; } ServiceEndpoint[] endpoints = GetEndpoints(mexAddress,issuer,secret); List<string> addresses = new List<string>(); foreach(ServiceEndpoint endpoint in endpoints) { if(bindingType.IsInstanceOfType(endpoint.Binding)) { ContractDescription description = ContractDescription.GetContract(contractType); if(endpoint.Contract.Name == description.Name && endpoint.Contract.Namespace == description.Namespace) { Debug.Assert(addresses.Contains(endpoint.Address.Uri.AbsoluteUri) == false); addresses.Add(endpoint.Address.Uri.AbsoluteUri); } } } return addresses.ToArray(); }
/// <summary> /// Initializes a new instance of the <see cref="TerminalType"/> class. /// </summary> /// <param name="type">The <see cref="Type"/> of the <see cref="Terminal"/> described by this <see cref="TerminalType"/>.</param> public TerminalType(Type type) : base(LanguageElementTypes.Terminal) { if (!type.IsSubclassOf(typeof(Terminal))) { throw new ArgumentException("Type must be a subclass of Terminal.", "type"); } _fullName = type.AssemblyQualifiedName; _name = GetName(type); _constructor = () => (Terminal) Activator.CreateInstance(type); var attributes = type.GetCustomAttributes(typeof(TerminalAttribute), false); foreach (var terminalAttribute in attributes.Cast<TerminalAttribute>()) { if (terminalAttribute.IsStop) { IsStop = true; } if (terminalAttribute.Ignore) { Ignore = true; } Pattern = terminalAttribute.Pattern; } }
public static bool DoObjectFieldProxy(ref System.Type objType, SerializedProperty property, ref object validator) { if (validator == null) { if (objType != null && (objType == typeof(UdonSharpBehaviour) || objType.IsSubclassOf(typeof(UdonSharpBehaviour)))) { validator = validationDelegate; } else if (property != null) { if (getFieldInfoFunc == null) { Assembly editorAssembly = AppDomain.CurrentDomain.GetAssemblies().First(e => e.GetName().Name == "UnityEditor"); System.Type scriptAttributeUtilityType = editorAssembly.GetType("UnityEditor.ScriptAttributeUtility"); MethodInfo fieldInfoMethod = scriptAttributeUtilityType.GetMethod("GetFieldInfoFromProperty", BindingFlags.NonPublic | BindingFlags.Static); getFieldInfoFunc = (GetFieldInfoDelegate)Delegate.CreateDelegate(typeof(GetFieldInfoDelegate), fieldInfoMethod); } getFieldInfoFunc(property, out System.Type fieldType); if (fieldType != null && (fieldType == typeof(UdonSharpBehaviour) || fieldType.IsSubclassOf(typeof(UdonSharpBehaviour)))) { objType = fieldType; validator = validationDelegate; } } } return(true); }
public static void RegisterNewAttributeType(string key, Type attributType) { if(!attributType.IsSubclassOf(typeof(Attribut))) throw new ArgumentException("Type must be subclass of Rtsp.Sdp.Attribut","attributType"); attributMap[key] = attributType; }
private static void DoEditRegularParameters(AnimationEvent evt, System.Type selectedParameter) { if ((selectedParameter == typeof(AnimationEvent)) || (selectedParameter == typeof(float))) { evt.floatParameter = EditorGUILayout.FloatField("Float", evt.floatParameter, new GUILayoutOption[0]); } if (selectedParameter.IsEnum) { evt.intParameter = EnumPopup("Enum", selectedParameter, evt.intParameter); } else if ((selectedParameter == typeof(AnimationEvent)) || (selectedParameter == typeof(int))) { evt.intParameter = EditorGUILayout.IntField("Int", evt.intParameter, new GUILayoutOption[0]); } if ((selectedParameter == typeof(AnimationEvent)) || (selectedParameter == typeof(string))) { evt.stringParameter = EditorGUILayout.TextField("String", evt.stringParameter, new GUILayoutOption[0]); } if (((selectedParameter == typeof(AnimationEvent)) || selectedParameter.IsSubclassOf(typeof(UnityEngine.Object))) || (selectedParameter == typeof(UnityEngine.Object))) { System.Type objType = typeof(UnityEngine.Object); if (selectedParameter != typeof(AnimationEvent)) { objType = selectedParameter; } bool allowSceneObjects = false; evt.objectReferenceParameter = EditorGUILayout.ObjectField(ObjectNames.NicifyVariableName(objType.Name), evt.objectReferenceParameter, objType, allowSceneObjects, new GUILayoutOption[0]); } }
public static void Register( int spellID, Type type ) { if ( spellID < 0 || spellID >= m_Types.Length ) return; if ( m_Types[spellID] == null ) ++m_Count; m_Types[spellID] = type; if( !m_IDsFromTypes.ContainsKey( type ) ) m_IDsFromTypes.Add( type, spellID ); if( type.IsSubclassOf( typeof( SpecialMove ) ) ) { SpecialMove spm = null; try { spm = Activator.CreateInstance( type ) as SpecialMove; } catch { } if( spm != null ) m_SpecialMoves.Add( spellID, spm ); } }
public Delegate GetStaticMethod(string name, System.Type delegShape) { if (!delegShape.IsSubclassOf(typeof(Delegate))) { throw new ArgumentException("Type must inherit from Delegate.", "delegShape"); } var binding = PUBLIC_STATIC_MEMBERS; if (_includeNonPublic) { binding |= BindingFlags.NonPublic; } var invokeMeth = delegShape.GetMethod("Invoke"); var paramTypes = (from p in invokeMeth.GetParameters() select p.ParameterType).ToArray(); var meth = _wrappedType.GetMethod(name, binding, null, paramTypes, null); if (meth != null) { try { return(Delegate.CreateDelegate(delegShape, meth)); } catch (Exception ex) { throw new InvalidOperationException("A method matching the name and shape requested could not be found.", ex); } } else { throw new InvalidOperationException("A method matching the name and shape requested could not be found."); } }
private Script InstantiateScript(System.Type scripttype) { if (scripttype.IsSubclassOf(typeof(Script))) { string[] message = new string[] { "Instantiating script '", scripttype.FullName, "' in script domain '", this.Name, "' ..." }; GTA.Log("[INFO]", message); try { return((Script)Activator.CreateInstance(scripttype)); } catch (MissingMethodException) { string[] strArray4 = new string[] { "Failed to instantiate script '", scripttype.FullName, "' because no public default constructor was found." }; GTA.Log("[ERROR]", strArray4); } catch (TargetInvocationException exception1) { string[] strArray2 = new string[] { "Failed to instantiate script '", scripttype.FullName, "' because constructor threw an exception:", Environment.NewLine, exception1.InnerException.ToString() }; GTA.Log("[ERROR]", strArray2); } catch (Exception exception3) { string[] strArray = new string[] { "Failed to instantiate script '", scripttype.FullName, "':", Environment.NewLine, exception3.ToString() }; GTA.Log("[ERROR]", strArray); } } return(null); }
protected void CustomValidator1_ServerValidate(object source, ServerValidateEventArgs args) { CustomValidator validator = (CustomValidator)source; args.IsValid = false; try { string fullClassName = BuildFullClassName(); System.Type classType = System.Web.Compilation.BuildManager.GetType(fullClassName, true); //now that we have the type, make sure it has the proper base class. if (classType.IsSubclassOf(typeof(Commerce.Promotions.Coupon))) { args.IsValid = true; } else { validator.ErrorMessage = "The specified class does not inherit from Commerce.Promotions.Coupon"; } } catch (TypeLoadException tlx) { validator.ErrorMessage = "The class could not be loaded. " + tlx.Message; } catch (ArgumentException argEx) { validator.ErrorMessage = "The type name specified is invalid. " + argEx.Message; } catch (Exception) { validator.ErrorMessage = "An unspecified error occured while loading the type"; } }
private static void InsertStyleDefault(StyleTypeNode root, System.Type type, IGuiStyle style) { if (type.IsSubclassOf(root.RegisteredType)) { // Construct the branch to this type StyleTypeNode newBranchRoot = root.Find(type); if (newBranchRoot == null) { newBranchRoot = new StyleTypeNode(type, style); // Create empty elements up a known point in the tree StyleTypeNode ancestor = FindClosestAncestor(root, type); while (newBranchRoot.RegisteredType.BaseType != ancestor.RegisteredType) { StyleTypeNode oldBranchRoot = new StyleTypeNode(newBranchRoot); newBranchRoot = new StyleTypeNode(oldBranchRoot.RegisteredType.BaseType, null); oldBranchRoot.Parent = newBranchRoot; newBranchRoot.Children.Add(oldBranchRoot); } newBranchRoot.Parent = ancestor; ancestor.Children.Add(newBranchRoot); } } else { throw new ArgumentException("Argument type(" + type.Name + ") must be a subclass of root.RegisteredType(" + root.RegisteredType.Name + ")"); } }
internal static object GetValue(object value, System.Type type) { if (value == System.DBNull.Value) { value = null; } System.Type type2 = type; object result; if (value != null && EntityFactory.IsPrimitiveType(type, out type2)) { result = EntityFactory.ChangeType(value, type2); } else if (value != null && type2.IsEnum && !value.GetType().IsEnum) { result = System.Enum.ToObject(type2, value); } else if (value == null && type2.IsSubclassOf(typeof(System.ValueType))) { result = EntityFactory.GetDefaultValue(type); } else { result = value; } return(result); }
private void ValidateExceptionType(Type expectedExceptionType) { if( !expectedExceptionType.IsSubclassOf(typeof(Exception)) && !(expectedExceptionType == typeof(Exception))) { throw new ArgumentException("Argument value must refer to System.Exception or a type derived from it."); } _expectedExceptionType = expectedExceptionType; }
private static string[] GetTaggedPropertyNames() { var properties = new HashSet <string>(); var movements = from assembly in AppDomain.CurrentDomain.GetAssemblies() from type in assembly.GetTypes() where type.IsSubclassOf(typeof(Movement)) select type; foreach (Type type in movements) { System.Reflection.FieldInfo[] fields = type.GetFields(); foreach (System.Reflection.FieldInfo field in fields) { TaggedProperty[] attributes = (TaggedProperty[])field.GetCustomAttributes(typeof(TaggedProperty), true); foreach (TaggedProperty attribute in attributes) { properties.Add(attribute.name); } } } return(properties.ToArray()); }