/// <summary> /// Initializes a new instance of the <see cref="SharedValueMemberInfo"/>. /// </summary> /// <param name="reflectionManager">The <see cref="SharedReflectionManager"/> used for the reflection.</param> /// <param name="declaringType">The <see cref="SharedTypeInfo"/> of the declaring type.</param> /// <param name="member">The member which is represented.</param> /// <param name="valueType">The type of the value hold by the member.</param> /// <param name="canWrite">Specifies if the member can be written.</param> internal SharedValueMemberInfo(SharedReflectionManager reflectionManager, SharedTypeInfo declaringType, MemberInfo member, Type valueType, Boolean canWrite, Object defaultValue) : base(declaringType, member) { if (reflectionManager == null) { throw new ArgumentNullException(nameof(reflectionManager)); } if (valueType == null) { throw new ArgumentNullException(nameof(valueType)); } CanWrite = canWrite; ValueType = reflectionManager.GetInfo(valueType.GetTypeInfo()); _DefaultValue = ((member.GetCustomAttribute <DefaultValueAttribute>() is DefaultValueAttribute defaultAttribute) ? defaultAttribute.Value : defaultValue) ?? (ValueType.IsValueType ? Activator.CreateInstance(valueType) : null); }
internal SharedTypeInfo(SharedReflectionManager reflectionManager, SharedReflectionManager.RegisterAction registerCallback, TypeInfo type) { if (reflectionManager == null) { throw new ArgumentNullException(nameof(reflectionManager)); } if (registerCallback == null) { throw new ArgumentNullException(nameof(registerCallback)); } // Basic initialization Type = type ?? throw new ArgumentNullException(nameof(type)); IsStatic = type.IsSealed && type.IsAbstract; // Generate a sample object if possible if (!type.IsAbstract) { try { // Search for a matching constructor if (type.DeclaredConstructors.FirstOrDefault(p => !p.IsStatic && p.IsPublic && p.GetParameters().Length == 0) is ConstructorInfo constructor) { // Generate a default value DefaultValue = constructor.Invoke(null); } } // Catch all exceptions catch { } } // Registers the current type in the manager registerCallback(this); // Get the basetype of the current type if (Type.BaseType != null) { BaseType = reflectionManager.GetInfo(Type.BaseType.GetTypeInfo()); } // Start a new task which initializes the type Task.Factory.StartNew(() => InitializeType(reflectionManager), TaskCreationOptions.LongRunning); }
/// <summary> /// Initializes the current type. /// </summary> void InitializeType(SharedReflectionManager reflectionManager) { using (_ObjectParseCompletion) { List <SharedPropertyInfo> properties = new List <SharedPropertyInfo>(); Dictionary <String, DependencyProperty> propertyLookup = DependencyType.GetDependencyType(Type, false).Properties.ToDictionary(p => p.Name); // Go through all declared properties and generate the property infos foreach (PropertyInfo item in Type.DeclaredProperties) { propertyLookup.TryGetValue(item.Name, out DependencyProperty dependencyProperty); properties.Add(new SharedPropertyInfo(reflectionManager, this, item, dependencyProperty, DefaultValue)); } // Assign properties to the object _DeclaredProperties = properties.ToImmutableArray(); _DeclaredPropertiesLookup = _DeclaredProperties.ToImmutableDictionary(p => p.Name); // Set parsing to finished _ObjectParseCompletion.Set(); } _ObjectParseCompletion = null; }
public SharedPropertyInfo(SharedReflectionManager reflectionManager, SharedTypeInfo declaringType, PropertyInfo property, DependencyProperty dependencyProperty, Object defaultValueSample) : base(reflectionManager, declaringType, property, dependencyProperty?.PropertyType.AsType() ?? property.PropertyType, CanWriteProperty(property, dependencyProperty), SampleDefault(property, dependencyProperty, defaultValueSample)) { DependencyProperty = dependencyProperty; _Property = property; }