internal IContentSerializer GetSerializer(Type storageType, Type objectType) { lock (contentSerializers) { // Process serializer attributes of objectType foreach (var contentSerializer in GetSerializers(objectType)) { if (objectType.GetTypeInfo().IsAssignableFrom(contentSerializer.ActualType.GetTypeInfo()) && (storageType == null || contentSerializer.SerializationType == storageType)) return contentSerializer; } // Process serializer attributes of storageType if (storageType != null) { foreach (var contentSerializer in GetSerializers(storageType)) { if (objectType.GetTypeInfo().IsAssignableFrom(contentSerializer.ActualType.GetTypeInfo()) && contentSerializer.SerializationType == storageType) return contentSerializer; } } //foreach (var contentSerializerGroup in contentSerializers) //{ // if (contentSerializerGroup.Key.GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo())) // { // return GetSerializer(contentSerializerGroup.Value, storageType); // } //} } return null; }
public ActionsGroupNode ReadController(Type type, AssemblyNode assemblyNode) { var controller = new ActionsGroupNode { Assembly = assemblyNode }; string routePrefix = null; var routePrefixAttribute = type.GetTypeInfo().GetCustomAttribute<RouteAttribute>(false) ?? type.GetTypeInfo().GetCustomAttribute<RouteAttribute>(); if (routePrefixAttribute != null) { routePrefix = routePrefixAttribute.Template; } controller.Name = type.Name.Replace("Controller", string.Empty); controller.Name = NameCleaner.Replace(controller.Name, string.Empty); controller.Documentation = documentation.GetDocumentation(type); foreach (var methodInfo in type.GetMethods().Where(x => x.IsPublic)) { if (methodInfo.GetCustomAttribute<NonActionAttribute>() != null) continue; if (methodInfo.IsSpecialName) continue; var action = ReadAction(routePrefix, methodInfo, controller); if (action != null) { controller.Actions.Add(action); } } return controller; }
private static object InvokeMemberOnType(Type type, object target, string name, object[] args) { BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic; try { // Try to invokethe method return type.InvokeMember( name, BindingFlags.InvokeMethod | bindingFlags, null, target, args); } catch (MissingMethodException) { // If we couldn't find the method, try on the base class if (type.GetTypeInfo().BaseType != null) { return InvokeMemberOnType(type.GetTypeInfo().BaseType, target, name, args); } //Don't care if the method don't exist. return null; } }
public EnumDescriptor(Type type) { _type = type; _enum2name = new Dictionary<object, string>(); _name2enum = new Dictionary<string, object>(); var names = Enum.GetNames(type); foreach (string name in names) { #if NET40 var member = type.GetFields().Single(x => x.Name == name); #elif !PCL var member = type.GetTypeInfo().GetRuntimeFields().Single((x) => x.Name == name); #else var member = type.GetTypeInfo().GetDeclaredField(name); #endif var value = Enum.Parse(type, name); var realName = name; #if NET40 var attr = (EnumValueAttribute)member.GetCustomAttributes(typeof(EnumValueAttribute), false).FirstOrDefault(); #else var attr = member.GetCustomAttribute<EnumValueAttribute>(); #endif if (attr != null) realName = attr.Value; _enum2name[value] = realName; _name2enum[realName] = value; } }
/// <summary> /// Gets the type converter for the specified type. /// </summary> /// <returns>The type converter, or null if the type has no defined converter.</returns> /// <param name="type">Type to get the converter for.</param> public static TypeConverter GetConverter(Type type) { var attr = type.GetTypeInfo().GetCustomAttribute<TypeConverterAttribute>(); Type converterType = null; if (attr != null) converterType = Type.GetType(attr.ConverterTypeName); if (converterType == null) { if (!converters.TryGetValue(type, out converterType)) { if (type.GetTypeInfo().IsGenericType && type.GetTypeInfo().GetGenericTypeDefinition() == typeof(Nullable<>)) return new NullableConverter(type); if (type.GetTypeInfo().IsEnum) return new EnumConverter(type); if (typeof(Delegate).GetTypeInfo().IsAssignableFrom(type.GetTypeInfo())) return new EventConverter(); } } if (converterType != null) { if (converterType.GetTypeInfo().GetConstructors().Any(r => r.GetParameters().Select(p => p.ParameterType).SequenceEqual(new [] { typeof(Type) }))) return Activator.CreateInstance(converterType, type) as TypeConverter; return Activator.CreateInstance(converterType) as TypeConverter; } return null; }
private static bool checkGenericType(Type pluggedType, Type pluginType) { if (pluginType.GetTypeInfo().IsAssignableFrom(pluggedType.GetTypeInfo())) return true; // check interfaces foreach (var type in pluggedType.GetInterfaces()) { if (!type.GetTypeInfo().IsGenericType) { continue; } if (type.GetGenericTypeDefinition() == pluginType) { return true; } } if (pluggedType.GetTypeInfo().BaseType.GetTypeInfo().IsGenericType) { var baseType = pluggedType.GetTypeInfo().BaseType.GetGenericTypeDefinition(); if (baseType == pluginType) { return true; } else { return CanBeCast(pluginType, baseType); } } return false; }
/// <summary> /// Initializes a new instance of the <see cref="EnumTypeConfiguration"/> class. /// </summary> public EnumTypeConfiguration(ODataModelBuilder builder, Type clrType) { if (builder == null) { throw Error.ArgumentNull("builder"); } if (clrType == null) { throw Error.ArgumentNull("clrType"); } if (!clrType.GetTypeInfo().IsEnum) { throw Error.Argument("clrType", SRResources.TypeCannotBeEnum, clrType.FullName); } ClrType = clrType; IsFlags = clrType.GetTypeInfo().GetCustomAttributes(typeof(FlagsAttribute), false).Any(); UnderlyingType = Enum.GetUnderlyingType(clrType); ModelBuilder = builder; _name = clrType.EdmName(); _namespace = clrType.Namespace ?? DefaultNamespace; ExplicitMembers = new Dictionary<Enum, EnumMemberConfiguration>(); RemovedMembers = new List<Enum>(); }
private static ProxyGeneratorResult GenerateProxy( Type typeOfProxy, ProxyGenerationOptions options, IEnumerable<Type> additionalInterfacesToImplement, IEnumerable<object> argumentsForConstructor, IFakeCallProcessorProvider fakeCallProcessorProvider) { Guard.AgainstNull(typeOfProxy, nameof(typeOfProxy)); Guard.AgainstNull(additionalInterfacesToImplement, nameof(additionalInterfacesToImplement)); Guard.AgainstNull(fakeCallProcessorProvider, nameof(fakeCallProcessorProvider)); if (typeOfProxy.GetTypeInfo().IsValueType) { return GetProxyResultForValueType(typeOfProxy); } if (typeOfProxy.GetTypeInfo().IsSealed) { return new ProxyGeneratorResult(DynamicProxyResources.ProxyIsSealedTypeMessage.FormatInvariant(typeOfProxy)); } GuardAgainstConstructorArgumentsForInterfaceType(typeOfProxy, argumentsForConstructor); return CreateProxyGeneratorResult(typeOfProxy, options, additionalInterfacesToImplement, argumentsForConstructor, fakeCallProcessorProvider); }
private Tuple<IList<MethodInfo>, IList<MethodInfo>> FindGetters(Type viewModelType) { Tuple<IList<MethodInfo>, IList<MethodInfo>> methodInfos; if (!_knownTypes.TryGetValue(viewModelType, out methodInfos)) { var commandTypeInfo = typeof(ICommand).GetTypeInfo(); var observablePropertyType = typeof(IObservableProperty<>); var ovvmTypeTypeInfo = typeof(IObservableViewModel).GetTypeInfo(); var propertieGetters = viewModelType.GetTypeInfo() .DeclaredProperties .Where(p => commandTypeInfo.IsAssignableFrom(p.PropertyType.GetTypeInfo()) || ovvmTypeTypeInfo.IsAssignableFrom(p.PropertyType.GetTypeInfo()) || IsGenericTypeDefinitionProperty(p.PropertyType, observablePropertyType)) .Select(p => p.GetMethod) .ToList(); //find inner view models recursively var viewModelTypeInfo = typeof(IViewModel).GetTypeInfo(); var childrenGetters = viewModelType.GetTypeInfo() .DeclaredProperties .Where(p => viewModelTypeInfo.IsAssignableFrom(p.PropertyType.GetTypeInfo())) .Select(p => p.GetMethod) .ToList(); methodInfos = new Tuple<IList<MethodInfo>, IList<MethodInfo>>(propertieGetters, childrenGetters); _knownTypes.Add(viewModelType, methodInfos); } return methodInfos; }
private static ITypeDetails CreateNew(Type type) { var readibles = new List<IPropertyReader>(); var writables = new List<IPropertyWriter>(); foreach (var pi in type.GetTypeInfo().GetProperties()) { var propertyInfo = CreatePropertyAccessor(type, pi); if (propertyInfo == null) { continue; } var propertyReader = propertyInfo as IPropertyReader; if (propertyReader != null) { readibles.Add(propertyReader); } var propertyWriter = propertyInfo as IPropertyWriter; if (propertyWriter != null) { writables.Add(propertyWriter); } } var defaultValue = type.GetTypeInfo().IsValueType ? Activator.CreateInstance(type) : null; return new TypeDetails(type, defaultValue, readibles.ToArray(), writables.ToArray()); }
private static Type FindIEnumerable(Type seqType) { if (seqType == null || seqType == typeof(string)) return null; if (seqType.IsArray) return typeof(IEnumerable<>).MakeGenericType(seqType.GetElementType()); if (seqType.GetTypeInfo().IsGenericType) { foreach (Type arg in seqType.GetGenericArguments()) { Type ienum = typeof(IEnumerable<>).MakeGenericType(arg); if (ienum.IsAssignableFrom(seqType)) { return ienum; } } } Type[] ifaces = seqType.GetInterfaces(); if (ifaces != null && ifaces.Length > 0) { foreach (Type iface in ifaces) { Type ienum = FindIEnumerable(iface); if (ienum != null) return ienum; } } var basetype = seqType.GetTypeInfo().BaseType; if (basetype != null && basetype != typeof(object)) { return FindIEnumerable(basetype); } return null; }
private static object CreateDictionary(Type dictionaryType) { Type keyType = dictionaryType.GetTypeInfo().GenericTypeArguments[0]; Type valueType = dictionaryType.GetTypeInfo().GenericTypeArguments[1]; var type = typeof(Dictionary<,>).MakeGenericType(keyType, valueType); return DelegateFactory.CreateCtor(type)(); }
/// <summary> /// A helper to check to see if a generic parameter type meets the specified constraints /// </summary> /// <param name="genericParameterType">The generic parameter type</param> /// <param name="exported">The type parameter on the exported class</param> /// <returns>True if the type meets the constraints, otherwise false</returns> public static bool DoesTypeMeetGenericConstraints(Type genericParameterType, Type exported) { bool meets = true; var constraints = genericParameterType.GetTypeInfo().GetGenericParameterConstraints(); foreach (Type constraint in constraints) { if (constraint.GetTypeInfo().IsInterface) { if (exported.GetTypeInfo().GUID == constraint.GetTypeInfo().GUID) { continue; } if (exported.GetTypeInfo().ImplementedInterfaces.Any(x => x.GetTypeInfo().GUID == constraint.GetTypeInfo().GUID)) { continue; } meets = false; break; } if (!constraint.GetTypeInfo().IsAssignableFrom(exported.GetTypeInfo())) { meets = false; break; } } return meets; }
/// <summary> /// Returns any bindings from the specified collection that match the specified service. /// </summary> /// <param name="bindings">The multimap of all registered bindings.</param> /// <param name="service">The service in question.</param> /// <returns>The series of matching bindings.</returns> public IEnumerable<IBinding> Resolve(IDictionary<Type, IEnumerable<IBinding>> bindings, Type service) { if (!service.GetTypeInfo().IsGenericType || service.GetTypeInfo().IsGenericTypeDefinition || !bindings.ContainsKey(service.GetGenericTypeDefinition())) return Enumerable.Empty<IBinding>(); return bindings[service.GetGenericTypeDefinition()]; }
internal IContentSerializer GetSerializer(Type storageType, Type objectType) { lock (contentSerializers) { // Process serializer attributes of objectType foreach (var contentSerializer in GetSerializers(objectType)) { if (objectType.GetTypeInfo().IsAssignableFrom(contentSerializer.ActualType.GetTypeInfo()) && (storageType == null || contentSerializer.SerializationType == storageType)) return contentSerializer; } // Process serializer attributes of storageType if (storageType != null) { foreach (var contentSerializer in GetSerializers(storageType)) { if (objectType.GetTypeInfo().IsAssignableFrom(contentSerializer.ActualType.GetTypeInfo()) && contentSerializer.SerializationType == storageType) return contentSerializer; } } //foreach (var contentSerializerGroup in contentSerializers) //{ // if (contentSerializerGroup.Key.GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo())) // { // return GetSerializer(contentSerializerGroup.Value, storageType); // } //} } throw new Exception(string.Format("Could not find a serializer for the type [{0}, {1}]", storageType == null ? null : storageType.Name, objectType == null ? null : objectType.Name)); }
public Type GetGenericInterface(Type type, Type interfaceType) { if (!interfaceType.GetTypeInfo().IsGenericTypeDefinition) { throw new ArgumentException( "The interface must be a generic interface definition: " + interfaceType.Name, "interfaceType"); } // our contract states that we will not return generic interface definitions without generic type arguments if (type == interfaceType) return null; if (type.GetTypeInfo().IsGenericType) { if (type.GetGenericTypeDefinition() == interfaceType) return type; } Type[] interfaces = type.GetTypeInfo().ImplementedInterfaces.ToArray(); for (int i = 0; i < interfaces.Length; i++) { if (interfaces[i].GetTypeInfo().IsGenericType) { if (interfaces[i].GetGenericTypeDefinition() == interfaceType) return interfaces[i]; } } return null; }
/// <summary> /// Calls GenerateManifest() on the event source passed in, saves the output to a file under 'folder' /// and returns the filename under which the manifest was saved. /// </summary> /// <param name="eventSourceType">The EventSource derived class whose manifest we want saved</param> /// <param name="folder">The folder where the manifest will be saved</param> /// <returns>The filename under 'folder' that contains the ETW manifest</returns> private string SaveEventSourceManifest(Type eventSourceType, string folder) { var manfilename = Path.Combine(folder, GetPrefixFromType(eventSourceType) + eventSourceType.Name + ".man"); using (var manfile = new System.IO.StreamWriter(new System.IO.MemoryStream(Encoding.Unicode.GetBytes(manfilename)))) { string man = null; string dllName = Path.GetFileName(eventSourceType.GetTypeInfo().Assembly.Location); //if (!eventSourceType.GetTypeInfo().Assembly.ReflectionOnly) //{ var baseAssm = eventSourceType.GetTypeInfo().BaseType.GetTypeInfo().Assembly; var tyGmf = (baseAssm != null) ? baseAssm.GetType(eventSourceType.GetTypeInfo().BaseType.Namespace + ".EventManifestOptions") : null; MethodInfo mi = null; if (tyGmf != null) { //mi = eventSourceType.GetTypeInfo().GetMethod("GenerateManifest", BindingFlags.Static | BindingFlags.FlattenHierarchy | BindingFlags.Public, // null, new Type[] { typeof(Type), typeof(string), tyGmf }, null); mi = eventSourceType.GetTypeInfo().GetDeclaredMethod("GenerateManifest"); } if (mi != null) { man = (string)mi.Invoke(null, new object[] { eventSourceType, dllName, 2 }); } manfile.Write(man); } return manfilename; }
// public methods /// <inheritdoc/> public override IBsonSerializer GetSerializer(Type type, IBsonSerializerRegistry serializerRegistry) { if (type == null) { throw new ArgumentNullException("type"); } var typeInfo = type.GetTypeInfo(); if (typeInfo.IsGenericType && typeInfo.ContainsGenericParameters) { var message = string.Format("Generic type {0} has unassigned type parameters.", BsonUtils.GetFriendlyTypeName(type)); throw new ArgumentException(message, "type"); } Type serializerType; if (_serializerTypes.TryGetValue(type, out serializerType)) { return CreateSerializer(serializerType, serializerRegistry); } if (typeInfo.IsGenericType && !typeInfo.ContainsGenericParameters) { Type serializerTypeDefinition; if (_serializerTypes.TryGetValue(type.GetGenericTypeDefinition(), out serializerTypeDefinition)) { return CreateGenericSerializer(serializerTypeDefinition, type.GetTypeInfo().GetGenericArguments(), serializerRegistry); } } return null; }
/// <summary> /// Coerces the provided value to the destination type. /// </summary> /// <param name="destinationType">The destination type.</param> /// <param name="providedValue">The provided value.</param> /// <returns>The coerced value.</returns> public static object CoerceValue(Type destinationType, object providedValue) { if (providedValue == null) return GetDefaultValue(destinationType); if (destinationType.GetTypeInfo().IsAssignableFrom(providedValue.GetType().GetTypeInfo())) return providedValue; Func<object, object> customConverter; if (CustomConverters.TryGetValue(destinationType, out customConverter)) return customConverter(providedValue); if (destinationType.GetTypeInfo().IsEnum) { var stringValue = providedValue as string; if (stringValue != null) return Enum.Parse(destinationType, stringValue, true); return Enum.ToObject(destinationType, providedValue); } if (typeof(Guid).GetTypeInfo().IsAssignableFrom(destinationType.GetTypeInfo())) { var stringValue = providedValue as string; if (stringValue != null) return new Guid(stringValue); } return Convert.ChangeType(providedValue, destinationType, CultureInfo.CurrentCulture); }
/// <summary> /// Determines whether this instance can convert the specified object type. /// </summary> /// <param name="objectType">Type of the object.</param> /// <returns></returns> public override bool CanConvert(Type objectType) { if (typeof(IMessageNotification).GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo())) return true; return typeof(ICommentNotification).GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo()); }
public PluginFamily Build(Type type) { if (!type.GetTypeInfo().IsGenericType) return null; var basicType = type.GetGenericTypeDefinition(); if (!_graph.Families.Has(basicType)) { // RIGHT HERE: do the connections thing HERE! var connectingTypes = _graph.ConnectedConcretions.Where(x => x.CanBeCastTo(type)).ToArray(); if (connectingTypes.Any()) { var family = new PluginFamily(type); connectingTypes.Each(family.AddType); return family; } return _graph.Families.ToArray().FirstOrDefault(x => type.GetTypeInfo().IsAssignableFrom(x.PluginType.GetTypeInfo())); } var basicFamily = _graph.Families[basicType]; var templatedParameterTypes = type.GetGenericArguments(); return basicFamily.CreateTemplatedClone(templatedParameterTypes.ToArray()); }
/// <summary> /// Creates an instace of type <paramref name="nodeType"/>. /// </summary> /// <exception cref="ExpressionNodeInstantiationException"> /// Thrown if the <paramref name="parseInfo"/> or the <paramref name="additionalConstructorParameters"/> /// do not match expected constructor parameters of the <paramref name="nodeType"/>. /// </exception> public static IExpressionNode CreateExpressionNode( Type nodeType, MethodCallExpressionParseInfo parseInfo, object[] additionalConstructorParameters) { ArgumentUtility.CheckNotNull ("nodeType", nodeType); ArgumentUtility.CheckTypeIsAssignableFrom ("nodeType", nodeType, typeof (IExpressionNode)); ArgumentUtility.CheckNotNull ("additionalConstructorParameters", additionalConstructorParameters); #if NETFX_CORE var constructors = nodeType.GetTypeInfo().DeclaredConstructors.Where (c => c.IsPublic).ToArray(); #else var constructors = nodeType.GetTypeInfo().GetConstructors().Where (c => c.IsPublic).ToArray(); #endif if (constructors.Length > 1) { var message = string.Format ( "Expression node type '{0}' contains too many constructors. It must only contain a single constructor, allowing null to be passed for any optional arguments.", nodeType.FullName); throw new ArgumentException (message, "nodeType"); } object[] constructorParameterArray = GetParameterArray (constructors[0], parseInfo, additionalConstructorParameters); try { return (IExpressionNode) constructors[0].Invoke (constructorParameterArray); } catch (ArgumentException ex) { var message = GetArgumentMismatchMessage (ex); throw new ExpressionNodeInstantiationException (message); } }
public static bool IsValidRazorFileInfoCollection(Type type) { return RazorFileInfoCollectionType.IsAssignableFrom(type) && !type.GetTypeInfo().IsAbstract && !type.GetTypeInfo().ContainsGenericParameters; }
public static Type GetInterface(this Type type, Type lookInterfaceType) { if (type == null) throw new ArgumentNullException("type"); if (lookInterfaceType == null) throw new ArgumentNullException("lookInterfaceType"); var typeinfo = lookInterfaceType.GetTypeInfo(); if (typeinfo .IsGenericTypeDefinition) { if (typeinfo.IsInterface) foreach (var interfaceType in type.GetTypeInfo().ImplementedInterfaces) if (interfaceType.GetTypeInfo().IsGenericType && interfaceType.GetGenericTypeDefinition() == lookInterfaceType) return interfaceType; for (Type t = type; t != null; t = t.GetTypeInfo().BaseType) if (t.GetTypeInfo().IsGenericType && t.GetGenericTypeDefinition() == lookInterfaceType) return t; } else { if (lookInterfaceType.GetTypeInfo().IsAssignableFrom(type.GetTypeInfo())) return lookInterfaceType; } return null; }
public static bool IsAnonymousType(Type t) { return (t.GetTypeInfo().GetCustomAttributes(typeof(CompilerGeneratedAttribute), false).FirstOrDefault() as CompilerGeneratedAttribute) != null && t.GetTypeInfo().IsGenericType && (t.Name.Contains("AnonymousType") || t.Name.Contains("AnonType")) && (t.Name.StartsWith("<>") || t.Name.StartsWith("VB$")) && t.GetTypeInfo().IsNotPublic; }
public override bool CanConvert(Type objectType) { #if NETFX_CORE return objectType.GetTypeInfo().IsEnum; #else return objectType.GetTypeInfo().IsEnum; #endif }
private static IEnumerable<Type> GetAllBaseTypes(Type type) { while (type.GetTypeInfo().BaseType != null) { yield return type; type = type.GetTypeInfo().BaseType; } }
private void InitTestData() { string filePath = Path.Combine(@"TestFiles\", FilePathUtil.GetTestDataPath(), @"xsltc\precompiled\Scripting28.dll"); _asm = AssemblyLoadContext.Default.LoadFromAssemblyPath(Path.GetFullPath(filePath)); _type = _asm.GetType("Scripting28"); _meth = ReflectionTestCaseBase.GetStaticMethod(_type, "Execute"); _staticData = (Byte[])_type.GetTypeInfo().GetField("staticData", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static).GetValue(_type); _ebTypes = (Type[])_type.GetTypeInfo().GetField("ebTypes", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static).GetValue(_type); }
public static bool IsAnonymousType(Type t) { return t.GetTypeInfo().GetCustomAttribute<CompilerGeneratedAttribute>() != null && t.GetTypeInfo().IsGenericType && (t.Name.Contains("AnonymousType") || t.Name.Contains("AnonType")) && (t.Name.StartsWith("<>") || t.Name.StartsWith("VB$")) && (t.GetTypeInfo().Attributes & AnonymousTypeAttributes) == AnonymousTypeAttributes; }
/// <inheritdoc /> public bool CanConvertFromHttpContent(Type typeToConvertTo, HttpContent httpContent) { if (!typeToConvertTo.GetTypeInfo().IsClass && !typeToConvertTo.GetTypeInfo().IsInterface) { return false; } var httpBehaviour = HttpBehaviour.Current; return !httpBehaviour.ValidateResponseContentType || SupportedContentTypes.Contains(httpContent.GetContentType()); }
///<summary> /// We calculate the start property indices, based on the type and it's class hierarchy, for example, DateView (70,000)- > Spin (60,000) -> View (50,000). /// </summary> private void GetPropertyStartRange(System.Type viewType, ref PropertyRange range) { const int maxCountPerDerivation = 1000; // For child and animatable properties we use a gap of 1000 between each // views property range in the hierarchy // custom views start there property index, at view_PROPERTY_END_INDEX // we add 1000, just incase View class (our C# custom view base) starts using scriptable properties int startEventPropertyIndex = (int)View.PropertyRange.CONTROL_PROPERTY_END_INDEX + maxCountPerDerivation; // for animatable properties current range starts at ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX, // we add 1000, just incase View class starts using animatable properties int startAnimatablePropertyIndex = (int)Tizen.NUI.PropertyRanges.ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + maxCountPerDerivation; while (viewType?.GetTypeInfo()?.BaseType?.Name != "CustomView") // custom view is our C# view base class. we don't go any deeper. { // for every base class increase property start index startEventPropertyIndex += (int)Tizen.NUI.PropertyRanges.DEFAULT_PROPERTY_MAX_COUNT_PER_DERIVATION; // DALi uses 10,000 startAnimatablePropertyIndex += maxCountPerDerivation; if (viewType != null) { NUILog.Debug("getStartPropertyIndex = " + viewType.Name + "current index " + startEventPropertyIndex); viewType = viewType.GetTypeInfo()?.BaseType; } } range.startEventIndex = startEventPropertyIndex; range.lastUsedEventIndex = startEventPropertyIndex; range.startAnimationIndex = startAnimatablePropertyIndex; range.lastUsedAnimationIndex = startAnimatablePropertyIndex; }
public static Type?TryGetElementType(this Type type, Type interfaceOrBaseType) { if (type.GetTypeInfo().IsGenericTypeDefinition) { return(null); } var types = GetGenericTypeImplementations(type, interfaceOrBaseType); Type?singleImplementation = null; foreach (var implementation in types) { if (singleImplementation == null) { singleImplementation = implementation; } else { singleImplementation = null; break; } } return(singleImplementation?.GetTypeInfo().GenericTypeArguments.FirstOrDefault()); }
static public PacketAttribute GetAttr(System.Type packetType) { foreach (object attribute in packetType.GetTypeInfo().GetCustomAttributes(typeof(PacketAttribute), false)) { return((PacketAttribute)attribute); } throw new System.Exception("packet type is wrong"); }
public static System.Type[] GetInterfaces(System.Type pType) { #if UNITY_EDITOR || !UNITY_METRO return(pType.GetInterfaces()); #else return(pType.GetTypeInfo().ImplementedInterfaces.ToArray()); #endif }
public static bool IsEnum(System.Type type) { #if NETFX_CORE return(type.GetTypeInfo().IsEnum); #else return(type.IsEnum); #endif }
public static TP GetTypeInfo(System.Type type) { #if NETFX_CORE return(type.GetTypeInfo()); #else return(type); #endif }
private static Dictionary <object, string> GetNameMapping(System.Type enumType) => enumType.GetTypeInfo().DeclaredFields .Where(f => f.IsStatic) .ToDictionary(f => f.GetValue(null), f => f.GetCustomAttributes <OriginalNameAttribute>() .FirstOrDefault() // If the attribute hasn't been applied, fall back to the name of the field. ?.Name ?? f.Name);
internal static bool IsEnumType(System.Type t) { #if NEW_REFLECTION return(t.GetTypeInfo().IsEnum); #else return(t.IsEnum); #endif }
static public bool IsCaching(System.Type packetType) { foreach (object attribute in packetType.GetTypeInfo().GetCustomAttributes(typeof(PacketAttribute), false)) { return(((PacketAttribute)attribute).Caching); } return(true); }
public static Type BaseType(this System.Type type) { #if NETFX_CORE return(type.GetTypeInfo().BaseType); #else return(type.BaseType); #endif }
/** * Just forward this call to the proper spot */ public static bool IsAssignableFrom(this System.Type type, System.Type other) { #if NETFX_CORE return(type.GetTypeInfo().IsAssignableFrom(other.GetTypeInfo())); #else return(type.IsAssignableFrom(other)); #endif }
public static PropertyInfo[] GetProperties(System.Type pType) { #if UNITY_EDITOR || !UNITY_METRO return(pType.GetProperties()); #else return(pType.GetTypeInfo().DeclaredProperties.ToArray()); #endif }
public static bool IsClass(System.Type pType) { #if UNITY_EDITOR || !UNITY_METRO return(pType.IsClass); #else return(pType.GetTypeInfo().IsClass); #endif }
public static FieldInfo[] GetFields(System.Type pType) { #if UNITY_EDITOR || !UNITY_METRO return(pType.GetFields()); #else return(pType.GetTypeInfo().DeclaredFields.ToArray()); #endif }
/** * Missing IsSubclassOf, this works well */ public static bool IsSubclassOf(this Type type, System.Type parent) { #if NETFX_CORE return(parent.GetTypeInfo().IsAssignableFrom(type.GetTypeInfo())); #else throw new NotImplementedException(); #endif }
/** * Missing IsSubclassOf, this works well */ public static bool IsSubclassOf(this System.Type type, System.Type parent) { #if NETFX_CORE return(parent.GetTypeInfo().IsAssignableFrom(type.GetTypeInfo())); #else return(type.IsSubclassOf(parent)); #endif }
public static TypeR Convert(this System.Type type) { #if UNITY_WSA return(type.GetTypeInfo()); #else return(type); #endif }
public override bool CanConvert(System.Type objectType) { #if NETSTANDARD1_3 return(typeof(T).GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo())); #else return(typeof(T).IsAssignableFrom(objectType)); #endif }
//private HashSet<Type> typeHasTypeHintCache; #endregion Fields #region Properties public static TP GetTypeInfo(System.Type tp) { #if WINDOWS_STORE return(tp.GetTypeInfo()); #else return(tp); #endif }
internal static Array GetEnumValues(System.Type enumType) { if (!enumType.GetTypeInfo().IsEnum) { throw new ArgumentException("Not an enumeration type", "enumType"); } return(Enum.GetValues(enumType)); }
public static bool IsPrimitive(System.Type type, bool includeEnums) { if (type.GetTypeInfo().IsPrimitive) { return(true); } if (includeEnums && type.GetTypeInfo().IsEnum) { return(true); } return(type == typeof(string) || type == typeof(decimal) || type == typeof(DateTime) || type == typeof(DateTimeOffset) || type == typeof(TimeSpan) || type == typeof(Guid)); }
internal static PrimitiveConverter ForType(BclType type) { TypeCode underlyingTypeCode = BclType.GetTypeCode(type.GetTypeInfo().GetEnumUnderlyingType()); if (!s_genericTypes.TryGetValue(underlyingTypeCode, out var genericConverterType)) { throw new InvalidOperationException($"Unexpected underlying type code for enum: {underlyingTypeCode}"); } return((PrimitiveConverter)Activator.CreateInstance(genericConverterType.MakeGenericType(type))); }
private static bool HandleEnum(Type type, Value value, object propValue, IEntityFactory entityFactory) { if (type.GetTypeInfo().IsEnum) { value.StringValue = propValue.ToString(); return(true); } return(false); }
/// <summary> /// Load the enum helper class against a given enum type /// </summary> /// <param name="enumType">The enum type to locate the helper</param> /// <returns>System.Type of the helper class for the given enum type</returns> private static System.Type loadEnumHelperType(System.Type enumType) { #if WINDOWS_UWP || DNXCORE50 || NETSTANDARD1_3 bool isNullableGeneric = enumType.GetTypeInfo().IsGenericType&& enumType.GetGenericTypeDefinition() == typeof(Nullable <>); Assembly assembly = enumType.GetTypeInfo().Assembly; #else bool isNullableGeneric = enumType.IsGenericType && enumType.GetGenericTypeDefinition() == typeof(Nullable <>); Assembly assembly = enumType.Assembly; #endif string enumHelperClassName = string.Format("{0}Helper", isNullableGeneric ? Nullable.GetUnderlyingType(enumType).FullName : enumType.FullName); System.Type enumHelperType = assembly.GetType(enumHelperClassName); if (enumHelperType == null) { throw new InvalidCastException("Unable to load enum helper for casting value"); } return(enumHelperType); }
private static bool HandleComplexType(Type type, Value value, object propValue, IEntityFactory entityFactory, IList <string> recursionPath) { if (type.GetTypeInfo().IsClass) { value.EntityValue = entityFactory.EmbeddedEntityFromPoco(propValue, recursionPath); return(true); } return(false); }
private static IFirestoreInternalConverter CreateConverter(BclType targetType) { var targetTypeInfo = targetType.GetTypeInfo(); if (targetType.IsArray) { return(new ArrayConverter(targetType.GetElementType())); } if (targetTypeInfo.IsDefined(typeof(FirestoreDataAttribute))) { return(AttributedTypeConverter.ForType(targetType)); } // Simple way of checking for an anonymous type. Far from foolproof, but a reasonable start. if (targetTypeInfo.IsDefined(typeof(CompilerGeneratedAttribute))) { return(new AnonymousTypeConverter(targetType)); } if (targetTypeInfo.IsEnum) { return(new EnumConverter(targetType)); } if (TryGetStringDictionaryValueType(targetType, out var dictionaryElementType)) { var method = s_createDictionaryConverter.MakeGenericMethod(dictionaryElementType); try { return((IFirestoreInternalConverter)method.Invoke(null, new object[] { targetType })); } catch (TargetInvocationException e) when(e.InnerException != null) { throw e.InnerException; } } if (typeof(IList).IsAssignableFrom(targetType)) { return(new ListConverter(targetType)); } throw new ArgumentException($"Unable to create converter for type {targetType.GetTypeInfo().FullName}"); }
public static Guid?TypeGuid(System.Type type) { var attrs = type.GetTypeInfo().GetCustomAttributes(typeof(GuidAttribute), false); var attr = attrs.FirstOrDefault() as GuidAttribute; if (attr == null) { return(null); } return(Guid.Parse(attr.Value)); }
public static Assembly[] GetAssembly() { #if UNITY_EDITOR || !UNITY_METRO return(AppDomain.CurrentDomain.GetAssemblies()); #else Assembly[] a = new Assembly[1]; System.Type t = typeof(int); a[0] = t.GetTypeInfo().Assembly; return(a); #endif }
internal ListConverter(BclType targetType) : base(targetType) { // We could make this type generic, like DictionaryConverter. There's a difference // in that we don't need a generic interface in the conversion code here. var interfaces = targetType.GetTypeInfo().GetInterfaces(); var genericListInterface = interfaces.Select(t => t.GetTypeInfo()).FirstOrDefault(iface => iface.IsGenericType && iface.GetGenericTypeDefinition() == typeof(IList <>)); // Just use object if the type isn't actually generic. _elementType = genericListInterface?.GenericTypeArguments[0] ?? typeof(object); }
/// <summary> /// Factory method to construct a converter for an attributed type. /// </summary> internal static IFirestoreInternalConverter ForType(BclType targetType) { var typeInfo = targetType.GetTypeInfo(); var attribute = typeInfo.GetCustomAttribute <FirestoreDataAttribute>(inherit: false); // This would be an internal library bug. We shouldn't be calling it in this case. GaxPreconditions.CheckState(attribute != null, "Type {0} is not decorated with {1}.", targetType.FullName, nameof(FirestoreDataAttribute)); return(attribute.ConverterType == null ? new AttributedTypeConverter(targetType, attribute) : CustomConverter.ForConverterType(attribute.ConverterType, targetType)); }