/// <summary> /// Builds an Instruction using the information stored in the InstructionBlueprint. /// </summary> /// <param name="target">The object that the returned Instruction will execute on</param> /// <param name="currentTime">The current time to use as an offset for the Instruction's Time of execution</param> /// <throws exception="ArgumentException">If target's type is not this InstructionBlueprint's TargetType</throws> /// <throws exception="NullReferenceException">If this InstructionBlueprint was fully initialized before this call to BuildInstruction.</throws> /// <returns>An Instruction created from this InstructionBlueprint's information</returns> #endregion public GenericInstruction BuildInstruction(object target, double currentTime) { GenericInstruction toReturn; //Make sure the target is a compatible type #if WINDOWS_8 if (!TargetType.GetTypeInfo().IsAssignableFrom(target.GetType().GetTypeInfo())) #else if (!TargetType.IsInstanceOfType(target)) #endif { throw new ArgumentException("This InstructionBlueprint's TargetType is " + TargetType + " and doesn't match the argument's type, " + target.GetType()); } else if (String.IsNullOrEmpty(MemberName) || MemberType == null) { throw new NullReferenceException("The InstructionBlueprint " + " has not been fully initialized and therefore cannot be made into an Instruction."); } else { mFourObjectArray[0] = target; mFourObjectArray[1] = MemberName; mFourObjectArray[2] = MemberValue; mFourObjectArray[3] = Time + currentTime; toReturn = mCurrentConstructor.Invoke(mFourObjectArray) as GenericInstruction; } return(toReturn); }
/// <summary> /// Create a new bridge to a property for a bindable object. /// </summary> /// <param name="targetPropertyName">The name of the property that is going to be bound to with.</param> /// <param name="getter">Gets the value of the property.</param> /// <param name="setter">Sets the value of the property.</param> /// <param name="defaultValue">The default value of the property.</param> public BindableProperty(string targetPropertyName, Func <TOwner, TProperty> getter, Action <TOwner, TProperty> setter, TProperty defaultValue = default(TProperty)) { TargetType = typeof(TProperty); TargetProperty = TargetType.GetTypeInfo().GetDeclaredProperty(targetPropertyName); Getter = getter; Setter = setter; DefaultValue = defaultValue; }
public object Deserialize(JSValue deserializedJson, object resultContainer = null) { if (deserializedJson == null) { throw new ArgumentNullException(nameof(deserializedJson)); } if (deserializedJson._valueType < JSValueType.Object) { return(deserializedJson.Value); } #if NETSTANDARD1_3 var result = resultContainer ?? TargetType.GetTypeInfo().DeclaredConstructors.Where(x => x.IsPublic).First(x => x.GetParameters().Length == 0).Invoke(new object[0]); #else var result = resultContainer ?? TargetType.GetConstructor(Type.EmptyTypes).Invoke(new object[0]); #endif var tempSrcObject = deserializedJson._oValue as JSObject; foreach (var property in tempSrcObject._fields) { var prop = getProperty(property.Key); if (prop != null) { object value = property.Value; var deserializer = GetSerializer(value, Context.CurrentGlobalContext); if (deserializer != null) { value = deserializer.Deserialize(property.Value); } else { value = Convert.ChangeType(property.Value.Value, prop.PropertyType); } prop.SetValue(result, value, null); continue; } var field = getField(property.Key); if (field != null) { object value = property.Value; var deserializer = GetSerializer(value, Context.CurrentGlobalContext); if (deserializer != null) { value = deserializer.Deserialize(property.Value); } else { value = Convert.ChangeType(property.Value.Value, field.FieldType); } field.SetValue(result, Convert.ChangeType(property.Value, field.FieldType)); continue; } } return(result); }
public virtual bool CanSerialize(object value) { if (value == null) { throw new ArgumentNullException(nameof(value)); } return(TargetType.GetTypeInfo().IsAssignableFrom(value.GetType().GetTypeInfo())); }
public void Apply(DependencyObject d) { if (!TargetType.GetTypeInfo().IsAssignableFrom(d.GetType().GetTypeInfo())) { throw new InvalidOperationException($"This style cannot be applied to {d.GetType()}, Target type is {TargetType}."); } Seal(); d.ValueStorage[StyleDependencyValueStorage.Key] = new StyleDependencyValueStorage(this, d); }
/// <inheritdoc/> protected override SelectorMatch Evaluate(IStyleable control, bool subscribe) { if (TargetType != null) { var controlType = control.StyleKey ?? control.GetType(); if (IsConcreteType) { if (controlType != TargetType) { return(SelectorMatch.False); } } else { if (!TargetType.GetTypeInfo().IsAssignableFrom(controlType.GetTypeInfo())) { return(SelectorMatch.False); } } } if (Name != null && control.Name != Name) { return(SelectorMatch.False); } if (_classes.IsValueCreated && _classes.Value.Count > 0) { if (subscribe) { var observable = Observable.FromEventPattern < NotifyCollectionChangedEventHandler, NotifyCollectionChangedEventArgs>( x => control.Classes.CollectionChanged += x, x => control.Classes.CollectionChanged -= x) .StartWith((EventPattern <NotifyCollectionChangedEventArgs>)null) .Select(_ => Matches(control.Classes)) .DistinctUntilChanged(); return(new SelectorMatch(observable)); } else { return(new SelectorMatch(Matches(control.Classes))); } } else { return(SelectorMatch.True); } }
/// <inheritdoc/> protected override SelectorMatch Evaluate(IStyleable control, bool subscribe) { if (TargetType != null) { var controlType = control.StyleKey ?? control.GetType(); if (IsConcreteType) { if (controlType != TargetType) { return(SelectorMatch.NeverThisType); } } else { if (!TargetType.GetTypeInfo().IsAssignableFrom(controlType.GetTypeInfo())) { return(SelectorMatch.NeverThisType); } } } if (Name != null) { return(control.Name == Name ? SelectorMatch.AlwaysThisInstance : SelectorMatch.NeverThisInstance); } if (_classes.IsValueCreated && _classes.Value.Count > 0) { if (subscribe) { var observable = new ClassObserver(control.Classes, _classes.Value); return(new SelectorMatch(observable)); } else { return(Matches(control.Classes) ? SelectorMatch.AlwaysThisInstance : SelectorMatch.NeverThisInstance); } } else { return(SelectorMatch.AlwaysThisType); } }