static Storyboard() { PropertyMetadata targetPropertyMetadata = new PropertyMetadata(); targetPropertyMetadata.FreezeValueCallback = TargetFreezeValueCallback; TargetProperty = DependencyProperty.RegisterAttached("Target", typeof(DependencyObject), typeof(Storyboard), targetPropertyMetadata); }
/// <summary> /// Registers a new attached property. /// </summary> /// <param name="name">The attached property's name.</param> /// <param name="uvssName">The attached property's name within the UVSS styling system.</param> /// <param name="propertyType">The attached property's value type.</param> /// <param name="ownerType">The attached property's owner type.</param> /// <param name="metadata">The attached property's metadata.</param> /// <returns>A <see cref="DependencyProperty"/> instance which represents the registered attached property.</returns> public static DependencyProperty RegisterAttached(String name, String uvssName, Type propertyType, Type ownerType, PropertyMetadata metadata = null) { Contract.Require(name, "name"); Contract.Require(propertyType, "propertyType"); Contract.Require(ownerType, "ownerType"); var dp = new DependencyProperty(dpid++, name, uvssName, propertyType, ownerType, metadata, isAttached: true); RegisterInternal(dp, ownerType); return dp; }
public void ShouldReturnFalseWhenPropertyIsNotPublic() { // Given var publicProperty = typeof(Exception).GetProperties(BindingFlags.Public | BindingFlags.Instance).First(); var metadata = new PropertyMetadata(publicProperty, true); // When var isNotPublic = metadata.IsNotPublic; // Then isNotPublic.Should().BeFalse(); }
private static ArgumentException CreatePrimaryKeyTypeUnsupportedException( PropertyMetadata primaryKeyPropertyMetadata) { return new ArgumentException(string.Format( "Only nullable ints, longs, or GUIDs can be used as primary key properties. " + "Property {0} is not a valid primary key property because it is of type {1}. " + "Choose a property of a supported type to mark with the [PrimaryKey] attribute. " + "If the underlying database table has a primary key of a different type, you " + "must change the primary key definition.", primaryKeyPropertyMetadata.Prop.Name, primaryKeyPropertyMetadata.Prop.PropertyType.FullName)); }
private static void CheckHasPrimaryKeyProperty( DtoMetadata dtoMetadata, PropertyMetadata primaryKeyPropertyMetadata) { if (null == primaryKeyPropertyMetadata) { throw new ArgumentException(string.Format( "Type {0} cannot be written to the database because it has no primary key defined on it. " + "Add a [PrimaryKey] attribute to the property representing the primary key column. " + "If no primary key is defined on the underlying database table, add a primary key first.", dtoMetadata.DtoType.FullName)); } }
public static PropertyMetadata GetDocs(this PropertyInfo propInfo, XPathNavigator docs) { var node = docs.SelectSingleNode(propInfo.XPathQuery()); var rtn = new PropertyMetadata { Name = propInfo.Name, DataType = Utils.GetCleanTypeName(propInfo.PropertyType), Remarks = Utils.GetNodeValue(node, "remarks"), Summary = Utils.GetNodeValue(node, "summary") }; return rtn; }
/// <summary> /// Initializes a new instance of the <see cref="DependencyProperty"/> class. /// </summary> /// <param name="id">The dependency property's unique identifier.</param> /// <param name="name">The dependency property's name.</param> /// <param name="uvssName">The dependency property's name within the UVSS styling system.</param> /// <param name="propertyType">The dependency property's value type.</param> /// <param name="ownerType">The dependency property's owner type.</param> /// <param name="metadata">The dependency property's metadata.</param> /// <param name="isReadOnly">A value indicating whether this is a read-only dependency property.</param> /// <param name="isAttached">A value indicating whether this is an attached property.</param> internal DependencyProperty(Int64 id, String name, String uvssName, Type propertyType, Type ownerType, PropertyMetadata metadata, Boolean isReadOnly = false, Boolean isAttached = false) { this.id = id; this.name = name; this.uvssName = uvssName ?? UvssNameGenerator.GenerateUvssName(name); this.propertyType = propertyType; this.underlyingType = Nullable.GetUnderlyingType(propertyType); this.ownerType = ownerType; this.defaultMetadata = metadata ?? (PropertyMetadata)typeof(PropertyMetadata<>).MakeGenericType(propertyType).GetField("Empty").GetValue(null); this.isReadOnly = isReadOnly; this.isAttached = isAttached; this.styleSetter = CreateStyleSetter(); this.changeNotificationServer = new DependencyPropertyChangeNotificationServer(this); }
public void Foreign_Key_Metadata_Is_Correct() { //Arrange var productEntity = TestModel.Model.GetEntityType(typeof(Product)); var productCategoryIdProperty = productEntity.GetProperty("ProductCategoryId"); //Act var propertyMetadata = new PropertyMetadata(productCategoryIdProperty); //Assert Assert.Equal("ProductCategoryId", propertyMetadata.PropertyName); Assert.Equal(false, propertyMetadata.IsPrimaryKey); Assert.Equal(true, propertyMetadata.IsForeignKey); Assert.Equal(typeof(int).FullName, propertyMetadata.TypeName); Assert.Equal(false, propertyMetadata.IsEnum); }
public void String_Property_Metadata_Is_Correct() { //Arrange var productEntity = TestModel.Model.GetEntityType(typeof(Product)); var productNameProperty = productEntity.GetProperty("ProductName"); //Act var propertyMetadata = new PropertyMetadata(productNameProperty); //Assert Assert.Equal("ProductName", propertyMetadata.PropertyName); Assert.Equal(false, propertyMetadata.IsPrimaryKey); Assert.Equal(false, propertyMetadata.IsForeignKey); Assert.Equal(typeof(string).FullName, propertyMetadata.TypeName); Assert.Equal(false, propertyMetadata.IsEnum); }
public async Task AddPropertyAsync(string entityName, [FromQuery] string propertyName, [FromQuery] PropertyType propertyType, [FromQuery] bool isNullable) { var dbEntiy = _db.Model.FindEntityType(entityName); MetadataModel model = null; var customization = await _db.Customizations.OrderByDescending(p => p.Id).FirstOrDefaultAsync(); if (customization != null) { var entities = JsonSerializer.Deserialize <IEnumerable <EntityMetadata> >(customization.Metadata); model = new MetadataModel(customization.Id, entities); } else { model = new MetadataModel(0, new EntityMetadata[] { }); } EntityMetadata entity = model.Entities.FirstOrDefault(p => p.EntityName == entityName); if (entity == null) { entity = new EntityMetadata(entityName, new PropertyMetadata[] { }); model.Entities.Add(entity); } var prop = new PropertyMetadata(propertyName, isNullable, propertyType); entity.Properties.Add(prop); var addColumn = new AddColumnOperation { Name = propertyName, ClrType = CrmContext.GetClrType(prop), IsNullable = prop.IsNullable, Table = dbEntiy.GetTableName(), Schema = dbEntiy.GetSchema(), }; var generator = ((IInfrastructure <IServiceProvider>)_db).Instance.GetRequiredService <IMigrationsSqlGenerator>(); var scripts = generator.Generate(new[] { addColumn }); await using (var transaction = await _db.Database.BeginTransactionAsync()) { foreach (var script in scripts) { await _db.Database.ExecuteSqlRawAsync(script.CommandText); } var dbCustomization = new Customization { Created = DateTime.UtcNow, Metadata = JsonSerializer.Serialize(model.Entities) }; _db.Add(dbCustomization); await _db.SaveChangesAsync(); var newId = dbCustomization.Id; var newModel = new MetadataModel(newId, model.Entities); await transaction.CommitAsync(); _setter.SetModel(newModel); } }
protected bool IsFieldValid(string fieldName) { PropertyMetadata propertyMetadata = null; return(QueryLite.EntityType.GetEntityMetadata().Properties.TryGetValue(fieldName, out propertyMetadata) && propertyMetadata.SqlField != null); }
protected override void OnPropertyInvalidated(DependencyProperty dp, PropertyMetadata metadata) {}
/// <summary> /// Check to see if there is a complex path that started with the /// given target object and property. If so, process the complex path /// information and return the results. /// </summary> internal static void GetComplexPathValue( DependencyObject targetObject, DependencyProperty targetProperty, ref EffectiveValueEntry entry, PropertyMetadata metadata) { CloneCacheEntry cacheEntry = GetComplexPathClone(targetObject, targetProperty); if (cacheEntry != null) { object baseValue = entry.Value; if (baseValue == DependencyProperty.UnsetValue) { // If the incoming baseValue is DependencyProperty.UnsetValue, that // means the current property value is the default value. Either // the cacheEntry.Clone was a clone of a default value (and should be // returned to the caller) or someone called ClearValue() (and // cacheEntry.Clone should be cleared accordingly). // To distinguish these cases we must check the cached source // against the default value. // // We don't have to handle the ClearValue case in this clause; // the comparison with the cached source to the base value // will fail in that case (since the cached source won't be UnsetValue) // and we'll clear out the cache. Debug.Assert(cacheEntry.Source != DependencyProperty.UnsetValue, "Storyboard complex path’s clone cache should never contain DependencyProperty.UnsetValue. Either something went wrong in Storyboard.ProcessComplexPath() or somebody else is messing with the Storyboard clone cache."); if (cacheEntry.Source == metadata.GetDefaultValue(targetObject, targetProperty)) { // The cacheEntry.Clone is the clone of the default value. In normal // non-Storyboard code paths, BaseValueSourceInternal is Unknown for default // values at this time, so we need to switch it over explicitly. // // And to prevent DependencyObject.UpdateEffectiveValue from misconstruing this // as an unaltered default value (which would result in UEV thinking no change // in value occurred and discarding this new value), we will go ahead and set the // animated value modifier on this value entry. (jeffbog: B#1616678 5/19/2006) // // In all other cases, valueSource should have the correct // valueSource corresponding to the object we cloned from, // so we don't need to do anything. entry.BaseValueSourceInternal = BaseValueSourceInternal.Default; entry.SetAnimatedValue(cacheEntry.Clone, DependencyProperty.UnsetValue); return; } } // If the incoming baseValue is a deferred object, we need to get the // real value to make a valid comparison against the cache entry source. DeferredReference deferredBaseValue = baseValue as DeferredReference; if (deferredBaseValue != null) { baseValue = deferredBaseValue.GetValue(entry.BaseValueSourceInternal); entry.Value = baseValue; } // If the incoming baseValue is different from the original source object that // we cloned and cached then we need to invalidate this cache. Otherwise we use // the value in the cache as is. if (cacheEntry.Source == baseValue) { CloneEffectiveValue(ref entry, cacheEntry); return; } else { // Setting to DependencyProperty.UnsetValue is how FrugalMap does delete. SetComplexPathClone( targetObject, targetProperty, DependencyProperty.UnsetValue, DependencyProperty.UnsetValue); } } }
private string GetUserProperty(PropertyMetadata property, InMemoryUser user) { string value; if (property.TryGet(user, out value)) { return value; } switch (property.Type) { case "role.admin": return user.Claims.HasValue(Constants.ClaimTypes.Role, "admin").ToString().ToLower(); case "gravatar": return user.Claims.GetValue("gravatar"); } throw new Exception("Invalid property type " + property.Type); }
/// <summary> /// GetCurrentPropertyValue /// </summary> /// <returns></returns> internal static object GetCurrentPropertyValue( AnimationStorage storage, DependencyObject d, DependencyProperty dp, PropertyMetadata metadata, object baseValue) { Debug.Assert(storage != null, "The 'storage' parameter cannot be passed into the GetCurrentPropertyValue method as null."); // If changes have been made to the snapshot value since the last tick // that value represents the current value of the property until the // next tick when the flag will be cleared. We will only take one // snapshot value between ticks. // // Since CurrentTimeInvaliated is raised before CurrentStateInvalidated // we need to check the state of the first clock as well to avoid // potential first frame issues. In this case _hasStickySnapshotValue // will be updated to false shortly. if ( storage._hasStickySnapshotValue && storage._animationClocks[0].CurrentState == ClockState.Stopped) { return storage._snapshotValue; } if ( storage._animationClocks == null && storage._propertyTriggerLayers == null) { Debug.Assert(storage._snapshotValue != DependencyProperty.UnsetValue); return storage._snapshotValue; } object currentPropertyValue = baseValue; if (currentPropertyValue == DependencyProperty.UnsetValue) { currentPropertyValue = metadata.GetDefaultValue(d, dp); } Debug.Assert(currentPropertyValue != DependencyProperty.UnsetValue); // // Process property trigger animations. // if (storage._propertyTriggerLayers != null) { int count = storage._propertyTriggerLayers.Count; Debug.Assert(count > 0); IList<AnimationLayer> layers = storage._propertyTriggerLayers.Values; for (int i = 0; i < count; i++) { currentPropertyValue = layers[i].GetCurrentValue(currentPropertyValue); } } // // Process local animations // if (storage._animationClocks != null) { FrugalObjectList<AnimationClock> clocks = storage._animationClocks; int clocksCount = clocks.Count; bool hasActiveOrFillingClock = false; // default destination value will be the current property value // calculated by the previous layer. object defaultDestinationValue = currentPropertyValue; object currentLayerValue = currentPropertyValue; // if we have a snapshot value, then that will be the new // initial current property value. if (storage._snapshotValue != DependencyProperty.UnsetValue) { currentLayerValue = storage._snapshotValue; } Debug.Assert(clocksCount > 0); Debug.Assert(defaultDestinationValue != DependencyProperty.UnsetValue); for (int i = 0; i < clocksCount; i++) { if (clocks[i].CurrentState != ClockState.Stopped) { hasActiveOrFillingClock = true; currentLayerValue = clocks[i].GetCurrentValue(currentLayerValue, defaultDestinationValue); // An animation may not return DependencyProperty.UnsetValue as its // current value. if (currentLayerValue == DependencyProperty.UnsetValue) { throw new InvalidOperationException(SR.Get( SRID.Animation_ReturnedUnsetValueInstance, clocks[i].Timeline.GetType().FullName, dp.Name, d.GetType().FullName)); } } } // The currentLayerValue only applies when there is at least one // active or filling clock. if (hasActiveOrFillingClock) { currentPropertyValue = currentLayerValue; } } // We have a calculated currentPropertyValue, so return it if the type matches. if (DependencyProperty.IsValidType(currentPropertyValue, dp.PropertyType)) { return currentPropertyValue; } else { // If the animation(s) applied to the property have calculated an // invalid value for the property then raise an exception. throw new InvalidOperationException( SR.Get( SRID.Animation_CalculatedValueIsInvalidForProperty, dp.Name, (currentPropertyValue == null ? "null" : currentPropertyValue.ToString()))); } }
protected override void UpdateEntity(Entity entity, ICollection <PropertyAggregatorUpdate> updates, PropertyMetadata property, decimal newValue) { _result.Update(entity, updates, property, newValue); }
private static object ReadValue(Type inst_type, JsonReader reader) { reader.Read(); if (reader.Token == JsonToken.ArrayEnd) { return(null); } Type underlying_type = Nullable.GetUnderlyingType(inst_type); Type value_type = underlying_type ?? inst_type; if (reader.Token == JsonToken.Null) { if (inst_type.IsClass || underlying_type != null) { return(null); } throw new JsonException(String.Format( "Can't assign null to an instance of type {0}", inst_type)); } if (reader.Token == JsonToken.Double || reader.Token == JsonToken.Int || reader.Token == JsonToken.Long || reader.Token == JsonToken.String || reader.Token == JsonToken.Boolean) { Type json_type = reader.Value.GetType(); if (value_type.IsAssignableFrom(json_type)) { return(reader.Value); } // If there's a custom importer that fits, use it if (custom_importers_table.ContainsKey(json_type) && custom_importers_table[json_type].ContainsKey( value_type)) { ImporterFunc importer = custom_importers_table[json_type][value_type]; return(importer(reader.Value)); } // Maybe there's a base importer that works if (base_importers_table.ContainsKey(json_type) && base_importers_table[json_type].ContainsKey( value_type)) { ImporterFunc importer = base_importers_table[json_type][value_type]; return(importer(reader.Value)); } // Maybe it's an enum if (value_type.IsEnum) { return(Enum.ToObject(value_type, reader.Value)); } // Try using an implicit conversion operator MethodInfo conv_op = GetConvOp(value_type, json_type); if (conv_op != null) { return(conv_op.Invoke(null, new object[] { reader.Value })); } // No luck throw new JsonException(String.Format( "Can't assign value '{0}' (type {1}) to type {2}", reader.Value, json_type, inst_type)); } object instance = null; if (reader.Token == JsonToken.ArrayStart) { AddArrayMetadata(inst_type); ArrayMetadata t_data = array_metadata[inst_type]; if (!t_data.IsArray && !t_data.IsList) { throw new JsonException(String.Format( "Type {0} can't act as an array", inst_type)); } IList list; Type elem_type; if (!t_data.IsArray) { list = (IList)Activator.CreateInstance(inst_type); elem_type = t_data.ElementType; } else { list = new ArrayList(); elem_type = inst_type.GetElementType(); } while (true) { object item = ReadValue(elem_type, reader); if (item == null && reader.Token == JsonToken.ArrayEnd) { break; } list.Add(item); } if (t_data.IsArray) { int n = list.Count; instance = Array.CreateInstance(elem_type, n); for (int i = 0; i < n; i++) { ((Array)instance).SetValue(list[i], i); } } else { instance = list; } } else if (reader.Token == JsonToken.ObjectStart) { AddObjectMetadata(value_type); ObjectMetadata t_data = object_metadata[value_type]; instance = Activator.CreateInstance(value_type); while (true) { reader.Read(); if (reader.Token == JsonToken.ObjectEnd) { break; } string property = (string)reader.Value; if (t_data.Properties.ContainsKey(property)) { PropertyMetadata prop_data = t_data.Properties[property]; if (prop_data.IsField) { ((FieldInfo)prop_data.Info).SetValue( instance, ReadValue(prop_data.Type, reader)); } else { PropertyInfo p_info = (PropertyInfo)prop_data.Info; if (p_info.CanWrite) { p_info.SetValue( instance, ReadValue(prop_data.Type, reader), null); } else { ReadValue(prop_data.Type, reader); } } } else { if (!t_data.IsDictionary) { if (!reader.SkipNonMembers) { throw new JsonException(String.Format( "The type {0} doesn't have the " + "property '{1}'", inst_type, property)); } else { ReadSkip(reader); continue; } } ((IDictionary)instance).Add( property, ReadValue( t_data.ElementType, reader)); } } } return(instance); }
private static void AddObjectMetadata(Type type) { if (object_metadata.ContainsKey(type)) { return; } ObjectMetadata data = new ObjectMetadata(); if (type.GetInterface("System.Collections.IDictionary") != null) { data.IsDictionary = true; } data.Properties = new Dictionary <string, PropertyMetadata>(); foreach (PropertyInfo p_info in type.GetProperties()) { if (p_info.Name == "Item") { ParameterInfo[] parameters = p_info.GetIndexParameters(); if (parameters.Length != 1) { continue; } if (parameters[0].ParameterType == typeof(string)) { data.ElementType = p_info.PropertyType; } continue; } PropertyMetadata p_data = new PropertyMetadata(); p_data.Info = p_info; p_data.Type = p_info.PropertyType; data.Properties.Add(p_info.Name, p_data); } foreach (FieldInfo f_info in type.GetFields()) { PropertyMetadata p_data = new PropertyMetadata(); p_data.Info = f_info; p_data.IsField = true; p_data.Type = f_info.FieldType; data.Properties.Add(f_info.Name, p_data); } lock (object_metadata_lock) { try { object_metadata.Add(type, data); } catch (ArgumentException) { return; } } }
/// <summary> /// GetCurrentPropertyValue /// </summary> /// <returns></returns> internal static object GetCurrentPropertyValue( AnimationStorage storage, DependencyObject d, DependencyProperty dp, PropertyMetadata metadata, object baseValue) { Debug.Assert(storage != null, "The 'storage' parameter cannot be passed into the GetCurrentPropertyValue method as null."); // If changes have been made to the snapshot value since the last tick // that value represents the current value of the property until the // next tick when the flag will be cleared. We will only take one // snapshot value between ticks. // // Since CurrentTimeInvaliated is raised before CurrentStateInvalidated // we need to check the state of the first clock as well to avoid // potential first frame issues. In this case _hasStickySnapshotValue // will be updated to false shortly. if (storage._hasStickySnapshotValue && storage._animationClocks[0].CurrentState == ClockState.Stopped) { return(storage._snapshotValue); } if (storage._animationClocks == null && storage._propertyTriggerLayers == null) { Debug.Assert(storage._snapshotValue != DependencyProperty.UnsetValue); return(storage._snapshotValue); } object currentPropertyValue = baseValue; if (currentPropertyValue == DependencyProperty.UnsetValue) { currentPropertyValue = metadata.GetDefaultValue(d, dp); } Debug.Assert(currentPropertyValue != DependencyProperty.UnsetValue); // // Process property trigger animations. // if (storage._propertyTriggerLayers != null) { int count = storage._propertyTriggerLayers.Count; Debug.Assert(count > 0); IList <AnimationLayer> layers = storage._propertyTriggerLayers.Values; for (int i = 0; i < count; i++) { currentPropertyValue = layers[i].GetCurrentValue(currentPropertyValue); } } // // Process local animations // if (storage._animationClocks != null) { FrugalObjectList <AnimationClock> clocks = storage._animationClocks; int clocksCount = clocks.Count; bool hasActiveOrFillingClock = false; // default destination value will be the current property value // calculated by the previous layer. object defaultDestinationValue = currentPropertyValue; object currentLayerValue = currentPropertyValue; // if we have a snapshot value, then that will be the new // initial current property value. if (storage._snapshotValue != DependencyProperty.UnsetValue) { currentLayerValue = storage._snapshotValue; } Debug.Assert(clocksCount > 0); Debug.Assert(defaultDestinationValue != DependencyProperty.UnsetValue); for (int i = 0; i < clocksCount; i++) { if (clocks[i].CurrentState != ClockState.Stopped) { hasActiveOrFillingClock = true; currentLayerValue = clocks[i].GetCurrentValue(currentLayerValue, defaultDestinationValue); // An animation may not return DependencyProperty.UnsetValue as its // current value. if (currentLayerValue == DependencyProperty.UnsetValue) { throw new InvalidOperationException(SR.Get( SRID.Animation_ReturnedUnsetValueInstance, clocks[i].Timeline.GetType().FullName, dp.Name, d.GetType().FullName)); } } } // The currentLayerValue only applies when there is at least one // active or filling clock. if (hasActiveOrFillingClock) { currentPropertyValue = currentLayerValue; } } // We have a calculated currentPropertyValue, so return it if the type matches. if (DependencyProperty.IsValidType(currentPropertyValue, dp.PropertyType)) { return(currentPropertyValue); } else { // If the animation(s) applied to the property have calculated an // invalid value for the property then raise an exception. throw new InvalidOperationException( SR.Get( SRID.Animation_CalculatedValueIsInvalidForProperty, dp.Name, (currentPropertyValue == null ? "null" : currentPropertyValue.ToString()))); } }
private void OnCurrentTimeInvalidated(object sender, EventArgs args) { object target = _dependencyObject.Target; if (target == null) { // If the target has been garbage collected, remove this handler // from the AnimationClock so that this collection can be // released also. DetachAnimationClock((AnimationClock)sender, _removeRequestedHandler); } else { // recompute animated value try { DependencyObject targetDO = ((DependencyObject)target); // fetch the existing entry EffectiveValueEntry oldEntry = targetDO.GetValueEntry( targetDO.LookupEntry(_dependencyProperty.GlobalIndex), _dependencyProperty, null, RequestFlags.RawEntry); EffectiveValueEntry newEntry; object value; // create a copy of that entry, removing animated & coerced values if (!oldEntry.HasModifiers) { // no modifiers; just use it, removing deferred references newEntry = oldEntry; value = newEntry.Value; if (newEntry.IsDeferredReference) { value = ((DeferredReference)value).GetValue(newEntry.BaseValueSourceInternal); newEntry.Value = value; } } else { // else entry has modifiers; preserve expression but throw away // coerced & animated values, since we'll be recomputing an animated value newEntry = new EffectiveValueEntry(); newEntry.BaseValueSourceInternal = oldEntry.BaseValueSourceInternal; newEntry.PropertyIndex = oldEntry.PropertyIndex; newEntry.HasExpressionMarker = oldEntry.HasExpressionMarker; value = oldEntry.ModifiedValue.BaseValue; if (oldEntry.IsDeferredReference) { DeferredReference dr = value as DeferredReference; if (dr != null) { value = dr.GetValue(newEntry.BaseValueSourceInternal); } } newEntry.Value = value; if (oldEntry.IsExpression) { value = oldEntry.ModifiedValue.ExpressionValue; if (oldEntry.IsDeferredReference) { DeferredReference dr = value as DeferredReference; if (dr != null) { value = dr.GetValue(newEntry.BaseValueSourceInternal); } } newEntry.SetExpressionValue(value, newEntry.Value); } } // compute the new value for the property PropertyMetadata metadata = _dependencyProperty.GetMetadata(targetDO.DependencyObjectType); object animatedValue = AnimationStorage.GetCurrentPropertyValue(this, targetDO, _dependencyProperty, metadata, value); if (_dependencyProperty.IsValidValueInternal(animatedValue)) { // update the new entry to contain the new animated value newEntry.SetAnimatedValue(animatedValue, value); // call UpdateEffectiveValue to put the new entry in targetDO's effective values table targetDO.UpdateEffectiveValue( targetDO.LookupEntry(_dependencyProperty.GlobalIndex), _dependencyProperty, metadata, oldEntry, ref newEntry, false /* coerceWithDeferredReference */, false /* coerceWithCurrentValue */, OperationType.Unknown); if (_hadValidationError) { if (TraceAnimation.IsEnabled) { TraceAnimation.TraceActivityItem( TraceAnimation.AnimateStorageValidationNoLongerFailing, this, animatedValue, target, _dependencyProperty); _hadValidationError = false; } } } else if (!_hadValidationError) { if (TraceAnimation.IsEnabled) { TraceAnimation.TraceActivityItem( TraceAnimation.AnimateStorageValidationFailed, this, animatedValue, target, _dependencyProperty); } _hadValidationError = true; } } catch (Exception e) { // Catch all exceptions thrown during the InvalidateProperty callstack // and wrap them in an AnimationException throw new AnimationException( (AnimationClock)sender, _dependencyProperty, (IAnimatable)target, SR.Get( SRID.Animation_Exception, _dependencyProperty.Name, target.GetType().FullName, ((AnimationClock)sender).Timeline.GetType().FullName), e); } } }
private static void AppendJoinConditionArgument(StringBuilder fromAndJoinsBuff, PropertyMetadata property, string alias) { AppendJoinConditionArgument(fromAndJoinsBuff, property.ColumnName, alias); }
protected virtual void Merge (PropertyMetadata baseMetadata, DependencyProperty dp) { if (defaultValue == null) defaultValue = baseMetadata.defaultValue; if (propertyChangedCallback == null) propertyChangedCallback = baseMetadata.propertyChangedCallback; if (coerceValueCallback == null) coerceValueCallback = baseMetadata.coerceValueCallback; }
protected override object GetValueCore(DependencyProperty property, object baseValue, PropertyMetadata metadata) { throw new NotImplementedException(); }
public virtual IdentityManagerMetadata GetStandardMetadata(bool includeAccountProperties = true) { var update = new List <PropertyMetadata>(); if (userAccountService.Configuration.EmailIsUsername) { update.AddRange(new PropertyMetadata[] { PropertyMetadata.FromFunctions <TAccount, string>(Constants.ClaimTypes.Username, GetUsername, SetUsername, name: "Email", dataType: PropertyDataType.Email, required: true), PropertyMetadata.FromFunctions <TAccount, string>(Constants.ClaimTypes.Password, x => null, SetPassword, name: "Password", dataType: PropertyDataType.Password, required: true), }); } else { update.AddRange(new PropertyMetadata[] { PropertyMetadata.FromFunctions <TAccount, string>(Constants.ClaimTypes.Username, GetUsername, SetUsername, name: "Username", dataType: PropertyDataType.String, required: true), PropertyMetadata.FromFunctions <TAccount, string>(Constants.ClaimTypes.Password, x => null, SetPassword, name: "Password", dataType: PropertyDataType.Password, required: true), PropertyMetadata.FromFunctions <TAccount, string>(Constants.ClaimTypes.Email, GetEmail, SetConfirmedEmail, name: "Email", dataType: PropertyDataType.Email, required: userAccountService.Configuration.RequireAccountVerification), }); } var create = new List <PropertyMetadata>(); if (!userAccountService.Configuration.EmailIsUsername && !userAccountService.Configuration.RequireAccountVerification) { create.AddRange(update.Where(x => x.Required).ToArray()); create.AddRange(new PropertyMetadata[] { PropertyMetadata.FromFunctions <TAccount, string>(Constants.ClaimTypes.Email, GetEmail, SetConfirmedEmail, name: "Email", dataType: PropertyDataType.Email, required: false), }); } update.AddRange(new PropertyMetadata[] { PropertyMetadata.FromFunctions <TAccount, string>(Constants.ClaimTypes.Phone, GetPhone, SetConfirmedPhone, name: "Phone", dataType: PropertyDataType.String, required: false), PropertyMetadata.FromFunctions <TAccount, bool>("IsLoginAllowed", GetIsLoginAllowed, SetIsLoginAllowed, name: "Is Login Allowed", dataType: PropertyDataType.Boolean, required: false), }); if (includeAccountProperties) { update.AddRange(PropertyMetadata.FromType <TAccount>()); } var user = new UserMetadata { SupportsCreate = true, SupportsDelete = true, SupportsClaims = true, CreateProperties = create, UpdateProperties = update }; var meta = new IdentityManagerMetadata { UserMetadata = user }; if (this.groupService != null && this.groupQuery != null) { meta.RoleMetadata.SupportsCreate = true; meta.RoleMetadata.SupportsDelete = true; meta.RoleMetadata.RoleClaimType = Constants.ClaimTypes.Role; meta.RoleMetadata.CreateProperties = new PropertyMetadata[] { new PropertyMetadata { Name = "Name", Type = Constants.ClaimTypes.Name, DataType = PropertyDataType.String, Required = true } }; } return(meta); }
protected string GetScopeProperty(PropertyMetadata propMetadata, Data.StoredScope scope) { string val; if (propMetadata.TryGet(scope, out val)) { return val; } throw new Exception("Invalid property type " + propMetadata.Type); }
public virtual PropertyMetadata GetMetadataForClaim(string type, string name = null, PropertyDataType dataType = PropertyDataType.String, bool required = false) { return(PropertyMetadata.FromFunctions <TAccount, string>(type, GetForClaim(type), SetForClaim(type), name, dataType, required)); }
private static bool TargetFreezeValueCallback( DependencyObject d, DependencyProperty dp, EntryIndex entryIndex, PropertyMetadata metadata, bool isChecking) { // We allow the object to which the Target property is attached to be // frozen, even though the value of the Target property is not usable // from other threads. Clocks clone & freeze copies of their original // timelines because the clocks will not respond to changes to those // timelines. return true; }
public INTERNAL_PropertyStorage(DependencyObject owner, DependencyProperty property, PropertyMetadata typeMetadata) { //_defaultValue = INTERNAL_NoValue.NoValue; Owner = owner; Property = property; TypeMetadata = typeMetadata; if (property == FrameworkElement.IsEnabledProperty || property == FrameworkElement.IsHitTestVisibleProperty) { _isIsEnabledOrIsHitTestVisibleProperty = true; } CoercedValue = INTERNAL_NoValue.NoValue; VisualStateValue = INTERNAL_NoValue.NoValue; ActiveLocalValue = new INTERNAL_LocalValue(); LocalStyleValue = INTERNAL_NoValue.NoValue; ImplicitStyleValue = INTERNAL_NoValue.NoValue; InheritedValue = INTERNAL_NoValue.NoValue; // The default value is used initially for the Actual Value: ActualValue = typeMetadata != null ? typeMetadata.DefaultValue : null; }
private void AppendPropertyToInsertStatement( StringBuilder colBuff, StringBuilder valBuff, PropertyMetadata property, ref int index, BaseInsertDeleteOperation operation, ArrayList values, MethodInfo getter) { if (property.HasAttribute<ForeignKeyReferenceAttribute>() && null != operation.OwnerMetadata && _dtoMetadataCache.GetValidatedMetadataFor( property.GetAttribute<ForeignKeyReferenceAttribute>().ReferencedDto).TableName == operation.OwnerMetadata.TableName) { values.Add( new Func<object>(() => operation.OwnerPrimaryKeyAsObject)); } else if (property.HasAttribute<ManyToOneAttribute>() && property.GetAttribute<ManyToOneAttribute>().ForeignKeyTargetColumnName != null) { var propValue = property.GetValue(operation.Value); var propTypeMetadata = _dtoMetadataCache.GetValidatedMetadataFor(property.Prop.PropertyType); if (null != propValue && null != propTypeMetadata) { var targetName = property.GetAttribute<ManyToOneAttribute>().ForeignKeyTargetColumnName; var fkTargetProperty = propTypeMetadata[targetName]; if (fkTargetProperty == null) { throw new ArgumentException(string.Format( "Cannot INSERT foreign key value for non existent target column '{0}'" + " specified from column '{1}'.", targetName, property.ColumnName)); } values.Add(new Func<object>(() => fkTargetProperty.GetValue(propValue))); } else { values.Add(new Func<object>(() => null)); } } else if (property.HasAttribute<ManyToOneAttribute>() || property.HasAttribute<OneToOneAttribute>()) { if (property.HasAttribute<OneToOneAttribute>() && !property.HasAttribute<ForeignKeyReferenceAttribute>()) { // One to one relationship where child table references parent rather than the other way around. // This will be saved along with the child object. return; } object propValue = property.GetValue(operation.Value); DtoMetadata propMetadata = _dtoMetadataCache.GetValidatedMetadataFor(property.Prop.PropertyType); values.Add( new Func<object>( () => propValue == null || propMetadata == null ? null : propMetadata.GetPrimaryKeyValueAsObject(propValue))); } else { values.Add(getter.Invoke(operation.Value, new object[0])); } if (colBuff.Length > 0) { colBuff.Append(@", "); valBuff.Append(@", "); } colBuff.Append("[" + property.ColumnName + "]"); valBuff.Append("{"); valBuff.Append(index); valBuff.Append("}"); ++index; }
public static DependencyProperty RegisterAttached(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata) { DependencyProperty property = Register(name, propertyType, ownerType, typeMetadata); property._isAttached = true; return(property); }
/// <summary> /// Overrides the property's metadata for the specified type. /// </summary> /// <param name="forType">The type for which to override property metadata.</param> /// <param name="typeMetadata">The property metadata for the specified type.</param> public void OverrideMetadata(Type forType, PropertyMetadata typeMetadata) { Contract.Require(ownerType, "ownerType"); if (metadataOverrides.ContainsKey(forType)) throw new InvalidOperationException(PresentationStrings.DependencyPropertyAlreadyRegistered); var merged = false; var currentType = forType.BaseType; while (currentType != null) { PropertyMetadata currentTypeMetadata; if (metadataOverrides.TryGetValue(currentType, out currentTypeMetadata)) { if (typeMetadata == null) { typeMetadata = currentTypeMetadata; } else { typeMetadata.Merge(currentTypeMetadata, this); } merged = true; break; } currentType = currentType.BaseType; } if (!merged) { var baseMetadata = GetMetadataForOwner(ownerType); if (typeMetadata == null) { typeMetadata = baseMetadata; } else { typeMetadata.Merge(baseMetadata, this); } merged = true; } metadataOverrides[forType] = typeMetadata; }
/// <summary> /// Registers a dependency property with the specified property name, property type, owner type, and property metadata. /// </summary> /// <param name="name">The property name.</param> /// <param name="propertyType">The type of the property.</param> /// <param name="ownerType">The type of the property's owner.</param> /// <param name="typeMetadata">The property metadata.</param> /// <returns>The DependencyProperty.</returns> public static DependencyProperty Register(string name, Type propertyType, Type ownerType, PropertyMetadata typeMetadata) { #if PERFSTAT var t = Performance.now(); #endif PropertyMetadata defaultMetadata = typeMetadata; if (defaultMetadata == null) { //Create metadata if not set defaultMetadata = new PropertyMetadata(); } // Make sure typeMetadata default value is valid. EnsureDefaultValue(defaultMetadata, propertyType, name, ownerType); var newDependencyProperty = new DependencyProperty() { Name = name, PropertyType = propertyType, OwnerType = ownerType, _typeMetadata = defaultMetadata //Store = INTERNAL_PropertyStore.Instance }; // Add the dependency property to the list of all the dependency properties of the object: INTERNAL_TypeToDependencyProperties.Add(ownerType, newDependencyProperty); // Add the dependency property to the list that is used to know whether to always call "PropertyChanged" when the UI element is loaded into the Visual Tree: if (typeMetadata != null && typeMetadata.CallPropertyChangedWhenLoadedIntoVisualTree == WhenToCallPropertyChangedEnum.Always) { INTERNAL_TypeToDependencyPropertiesThatRequirePropertyChanged.Add(ownerType, newDependencyProperty); } //Add the dependencyProperty's name to the dictionary that allows to get the dependencyProperty from its name: Dictionary <string, DependencyProperty> stringsToDependencyProperties = INTERNAL_TypeToStringsToDependencyProperties.GetDictionaryForType(ownerType); if (stringsToDependencyProperties.ContainsKey(name)) { #if !MIGRATION // THE FOLLOWING CHECK IS DISABLED IN THE SILVERLIGHT COMPATIBLE VERSION // BECAUSE IT APPEARS THAT SILVERLIGHT IS TOLERANT TO DECLARING TWICE // THE SAME DEPENDENCY PROPERTY OR ATTACHED PROPERTY. FOR AN EXAMPLE OF // USE, SEE THE CLASS "RatingsView" IN THE CLIENT APPLICATION "STAR". if (stringsToDependencyProperties[name] != null) { throw new Exception("Cannot register multiple properties with the same PropertyName"); } #endif stringsToDependencyProperties[name] = newDependencyProperty; } else { stringsToDependencyProperties.Add(name, newDependencyProperty); } #if PERFSTAT Performance.Counter("DependencyProperty.Register", t); #endif return(newDependencyProperty); }
public PropertyTreeView(PropertyMetadata property) { _property = property; Name = property.Name; TypeOfMetadata = "property"; }
void OnDPSelectionChanged(object sender, SelectionChangedEventArgs e) { ListBoxItem selected = (ListBoxItem)e.AddedItems[0]; // we won't handle multiselect PropertyMetadata pm; DependencyProperty dp = null; switch (selected.Content.ToString()) { case ("ToggleButton.IsChecked"): dp = ToggleButton.IsCheckedProperty; break; case ("Control.Background"): dp = Control.BackgroundProperty; break; case ("Storyboard.TargetName"): dp = Storyboard.TargetNameProperty; break; case ("FrameworkElement.DataContext"): dp = FrameworkElement.DataContextProperty; break; case ("FrameworkElement.Margin"): dp = FrameworkElement.MarginProperty; break; case ("ToolBar.Orientation"): dp = ToolBar.OrientationProperty; break; case ("UIElement.Visibility"): dp = UIElement.VisibilityProperty; break; } //<SnippetDPProps> //<SnippetDPGetMetadataSingle> pm = dp.GetMetadata(dp.OwnerType); //</SnippetDPGetMetadataSingle> MetadataClass.Text = pm.GetType().Name; TypeofPropertyValue.Text = dp.PropertyType.Name; DefaultPropertyValue.Text = (pm.DefaultValue != null) ? pm.DefaultValue.ToString() : "null"; HasCoerceValue.Text = (pm.CoerceValueCallback == null) ? "No" : pm.CoerceValueCallback.Method.Name; HasPropertyChanged.Text = (pm.PropertyChangedCallback == null) ? "No" : pm.PropertyChangedCallback.Method.Name; ReadOnly.Text = (dp.ReadOnly) ? "Yes" : "No"; //</SnippetDPProps> //<SnippetFPMProperties> FrameworkPropertyMetadata fpm = pm as FrameworkPropertyMetadata; if (fpm != null) { AffectsArrange.Text = (fpm.AffectsArrange) ? "Yes" : "No"; AffectsMeasure.Text = (fpm.AffectsMeasure) ? "Yes" : "No"; AffectsRender.Text = (fpm.AffectsRender) ? "Yes" : "No"; Inherits.Text = (fpm.Inherits) ? "Yes" : "No"; IsDataBindingAllowed.Text = (fpm.IsDataBindingAllowed) ? "Yes" : "No"; BindsTwoWayByDefault.Text = (fpm.BindsTwoWayByDefault) ? "Yes" : "No"; } //</SnippetFPMProperties> else { AffectsArrange.Text = "N/A"; AffectsMeasure.Text = "N/A"; AffectsRender.Text = "N/A"; Inherits.Text = "N/A"; IsDataBindingAllowed.Text = "N/A"; BindsTwoWayByDefault.Text = "N/A"; } //<SnippetDPDefaultValue> PropertyMetadata pmDefault = dp.DefaultMetadata; //</SnippetDPDefaultValue> }
public ForeignKeyMappingInfo(PropertyMetadata metadata, PropertyMetadata metadataForSave, NavigationPropertyMetadata navPropertyMetadata, PropertyMetadata keyPropertyMetadata) : base(metadata, metadataForSave) { NavPropertyMetadata = navPropertyMetadata ?? throw new ArgumentNullException(nameof(navPropertyMetadata)); KeyPropertyMetadata = keyPropertyMetadata ?? throw new ArgumentNullException(nameof(keyPropertyMetadata)); KeyType = GetKeyType(keyPropertyMetadata); }
static void RenderElementsAndRaiseChangedEventOnAllDependencyProperties(DependencyObject dependencyObject) { //-------------------------------------------------------------- // RAISE "PROPERTYCHANGED" FOR ALL THE PROPERTIES THAT HAVE // A VALUE THAT HAS BEEN SET, INCLUDING ATTACHED PROPERTIES, // AND CALL THE "METHOD TO UPDATE DOM" //-------------------------------------------------------------- // This is used to force a redraw of all the properties that are // set on the object (including Attached Properties!). For // example, if a Border has a colored background, this is the // moment when that color will be applied. Properties that have // no value set by the user are not concerned (their default // state is rendered elsewhere). #if PERFSTAT var t0 = Performance.now(); #endif // we copy the Dictionary so that the foreach doesn't break when // we modify a DependencyProperty inside the Changed of another // one (which causes it to be added to the Dictionary). // we exclude properties where source is set to default because // it means they have been set at some point, and unset afterward, // so we should not call the PropertyChanged callback. var list = dependencyObject.INTERNAL_PropertyStorageDictionary .Where(s => s.Value.BaseValueSourceInternal > BaseValueSourceInternal.Default) .ToList(); #if PERFSTAT Performance.Counter("VisualTreeManager: Copy list of properties", t0); #endif foreach (KeyValuePair <DependencyProperty, INTERNAL_PropertyStorage> propertiesAndTheirStorage in list) { // Read the value: DependencyProperty property = propertiesAndTheirStorage.Key; #if PERFSTAT var t1 = Performance.now(); #endif PropertyMetadata propertyMetadata = property.GetTypeMetaData(dependencyObject.GetType()); if (propertyMetadata != null) { INTERNAL_PropertyStorage storage = propertiesAndTheirStorage.Value; object value = null; bool valueWasRetrieved = false; //-------------------------------------------------- // Call "Apply CSS", which uses "GetCSSEquivalent/s" //-------------------------------------------------- if (propertyMetadata.GetCSSEquivalent != null || propertyMetadata.GetCSSEquivalents != null) { if (!valueWasRetrieved) { value = INTERNAL_PropertyStore.GetEffectiveValue(storage); valueWasRetrieved = true; } INTERNAL_PropertyStore.ApplyCssChanges(value, value, propertyMetadata, storage.Owner); } //-------------------------------------------------- // Call "MethodToUpdateDom" //-------------------------------------------------- if (propertyMetadata.MethodToUpdateDom != null) { if (!valueWasRetrieved) { value = INTERNAL_PropertyStore.GetEffectiveValue(storage); valueWasRetrieved = true; } // Call the "Method to update DOM" propertyMetadata.MethodToUpdateDom(storage.Owner, value); } //-------------------------------------------------- // Call PropertyChanged //-------------------------------------------------- if (propertyMetadata.PropertyChangedCallback != null && propertyMetadata.CallPropertyChangedWhenLoadedIntoVisualTree != WhenToCallPropertyChangedEnum.Never) { if (!valueWasRetrieved) { value = INTERNAL_PropertyStore.GetEffectiveValue(storage); valueWasRetrieved = true; } // Raise the "PropertyChanged" event propertyMetadata.PropertyChangedCallback(storage.Owner, new DependencyPropertyChangedEventArgs(value, value, property)); } } #if PERFSTAT Performance.Counter("VisualTreeManager: RaisePropertyChanged for property '" + property.Name + "'", t1); #endif } }
internal void DoMerge (PropertyMetadata baseMetadata, DependencyProperty dp, Type targetType) { Merge (baseMetadata, dp); OnApply (dp, targetType); isSealed = true; }
protected IDbDataParameter CreateParameter(PropertyMetadata property, string fieldName) { var field = property.SqlField; string parameterName = DataService.EntityLiteProvider.ParameterPrefix + fieldName; IDbDataParameter parameter = DataService.DbProviderFactory.CreateParameter(); parameter.ParameterName = parameterName; Type propertyType = property.PropertyInfo.PropertyType.UndelyingType(); if (typeof(System.Data.SqlTypes.INullable).IsAssignableFrom(propertyType)) { parameter.DbType = DbType.String; if (propertyType == typeof(Microsoft.SqlServer.Types.SqlHierarchyId)) { parameter.Size = 4000; } else { parameter.Size = 1073741823; } return parameter; } parameter.DbType = field.DbType; parameter.Size = field.Size; parameter.SourceColumn = fieldName; if (field.Precision != 255 && field.Precision != 0) { parameter.Precision = field.Precision; } if (field.Scale != 255 && field.Scale != 0) { parameter.Scale = field.Scale; } return parameter; }
internal static INTERNAL_PropertyStorage GetInheritedPropertyStorageOrCreateNewIfNotFound(DependencyObject dependencyObject, DependencyProperty dependencyProperty) { // Create the dictionary of it does not already exist: if (dependencyObject.INTERNAL_AllInheritedProperties == null) { dependencyObject.INTERNAL_AllInheritedProperties = new Dictionary <DependencyProperty, INTERNAL_PropertyStorage>(); } // Create the Storage if it does not already exist, and if "createAndSaveNewStorageIfNotExists" is True: INTERNAL_PropertyStorage storage; if (!dependencyObject.INTERNAL_AllInheritedProperties.TryGetValue(dependencyProperty, out storage)) { // Create the dictionary of it does not already exist: if (dependencyObject.INTERNAL_PropertyStorageDictionary == null) { dependencyObject.INTERNAL_PropertyStorageDictionary = new Dictionary <DependencyProperty, INTERNAL_PropertyStorage>(); } // Get the storage or create a new one: if (dependencyObject.INTERNAL_PropertyStorageDictionary.ContainsKey(dependencyProperty)) { storage = dependencyObject.INTERNAL_PropertyStorageDictionary[dependencyProperty]; } else { // Get the type metadata (if any): PropertyMetadata typeMetadata = dependencyProperty.GetTypeMetaData(dependencyObject.GetType()); // Create the storage: storage = new INTERNAL_PropertyStorage(dependencyObject, dependencyProperty, typeMetadata); } dependencyObject.INTERNAL_AllInheritedProperties.Add(dependencyProperty, storage); //----------------------- // CHECK IF THE PROPERTY BELONGS TO THE OBJECT (OR TO ONE OF ITS ANCESTORS): //----------------------- //below: we check if the property is useful to the current DependencyObject, in which case we set it as its inheritedValue in "PropertyStorageDictionary" if (dependencyProperty.OwnerType.IsAssignableFrom(dependencyObject.GetType())) { //----------------------- // ADD THE STORAGE TO "INTERNAL_PropertyStorageDictionary" IF IT IS NOT ALREADY THERE: //----------------------- if (dependencyObject.INTERNAL_PropertyStorageDictionary == null) { dependencyObject.INTERNAL_PropertyStorageDictionary = new Dictionary <DependencyProperty, INTERNAL_PropertyStorage>(); } if (!dependencyObject.INTERNAL_PropertyStorageDictionary.ContainsKey(dependencyProperty)) { dependencyObject.INTERNAL_PropertyStorageDictionary.Add(dependencyProperty, storage); } } } return(storage); #region OldStuff /* * // This method ensures that the two dictionaries ("INTERNAL_PropertyStorageDictionary" and "INTERNAL_AllInheritedProperties") always share the same instances of Storages (for properties that are in common): * // This is how it works: * // - If both in INTERNAL_PropertyStorageDictionary and in INTERNAL_AllInheritedProperties, return any one * // - If in INTERNAL_PropertyStorageDictionary but not in INTERNAL_AllInheritedProperties, copy it to INTERNAL_AllInheritedProperties and return it * // - If in INTERNAL_AllInheritedProperties but not in INTERNAL_PropertyStorageDictionary, AND the property belongs to the object (or one of its ancestors), copy it to INTERNAL_PropertyStorageDictionary and return it * // - If in neither INTERNAL_PropertyStorageDictionary nor INTERNAL_AllInheritedProperties, create it in INTERNAL_AllInheritedProperties, and, if the property belongs to the object (or one of its ancestors), copy it to INTERNAL_PropertyStorageDictionary and return it * * if (dependencyObject.INTERNAL_PropertyStorageDictionary != null && dependencyObject.INTERNAL_PropertyStorageDictionary.ContainsKey(dependencyProperty)) * { * if (dependencyObject.INTERNAL_AllInheritedProperties != null && dependencyObject.INTERNAL_AllInheritedProperties.ContainsKey(dependencyProperty)) * { * //-------------------------------------------- * // The property storage is in both INTERNAL_PropertyStorageDictionary and INTERNAL_AllInheritedProperties, so we return any one: * //-------------------------------------------- * return dependencyObject.INTERNAL_AllInheritedProperties[dependencyProperty]; * } * else * { * //-------------------------------------------- * // The property storage is in INTERNAL_PropertyStorageDictionary but not in INTERNAL_AllInheritedProperties, so we copy it to INTERNAL_AllInheritedProperties and return it: * //-------------------------------------------- * var storage = dependencyObject.INTERNAL_PropertyStorageDictionary[dependencyProperty]; * if (createAndSaveNewStorageIfNotExists) * { * if (dependencyObject.INTERNAL_AllInheritedProperties == null) * dependencyObject.INTERNAL_AllInheritedProperties = new Dictionary<DependencyProperty,INTERNAL_PropertyStorage>(); * dependencyObject.INTERNAL_AllInheritedProperties.Add(dependencyProperty, storage); * } * return storage; * } * } * else * { * if (dependencyObject.INTERNAL_AllInheritedProperties != null && dependencyObject.INTERNAL_AllInheritedProperties.ContainsKey(dependencyProperty)) * { * //-------------------------------------------- * // The property storage is in INTERNAL_AllInheritedProperties but not in INTERNAL_PropertyStorageDictionary, therefore, if the property belongs to the object (or one of its ancestors), we copy it to INTERNAL_PropertyStorageDictionary and we return it * //-------------------------------------------- * var storage = dependencyObject.INTERNAL_AllInheritedProperties[dependencyProperty]; * if (createAndSaveNewStorageIfNotExists && dependencyProperty.OwnerType.IsAssignableFrom(dependencyObject.GetType())) // The second condition checks if the property belongs to the object (or one of its ancestors) * { * if (dependencyObject.INTERNAL_PropertyStorageDictionary == null) * dependencyObject.INTERNAL_PropertyStorageDictionary = new Dictionary<DependencyProperty,INTERNAL_PropertyStorage>(); * dependencyObject.INTERNAL_PropertyStorageDictionary.Add(dependencyProperty, storage); * } * return storage; * } * else * { * //-------------------------------------------- * // The property storage is in neither INTERNAL_PropertyStorageDictionary nor INTERNAL_AllInheritedProperties, therefore, we create it in INTERNAL_AllInheritedProperties, and, if the property belongs to the object (or one of its ancestors), we copy it to INTERNAL_PropertyStorageDictionary and return it: * //-------------------------------------------- * var storage = new INTERNAL_PropertyStorage(dependencyObject, dependencyProperty); * if (createAndSaveNewStorageIfNotExists) * { * if (dependencyObject.INTERNAL_AllInheritedProperties == null) * dependencyObject.INTERNAL_AllInheritedProperties = new Dictionary<DependencyProperty,INTERNAL_PropertyStorage>(); * dependencyObject.INTERNAL_AllInheritedProperties.Add(dependencyProperty, storage); * * if (dependencyProperty.OwnerType.IsAssignableFrom(dependencyObject.GetType())) // This checks if the property belongs to the object (or one of its ancestors) * { * if (dependencyObject.INTERNAL_PropertyStorageDictionary == null) * dependencyObject.INTERNAL_PropertyStorageDictionary = new Dictionary<DependencyProperty,INTERNAL_PropertyStorage>(); * dependencyObject.INTERNAL_PropertyStorageDictionary.Add(dependencyProperty, storage); * } * } * return storage; * } * } */ #endregion }
internal void EvaluateAnimatedValue( PropertyMetadata metadata, ref EffectiveValueEntry entry) { DependencyObject d = (DependencyObject)_dependencyObject.Target; if (d == null) { return; } object value = entry.GetFlattenedEntry(RequestFlags.FullyResolved).Value; if (entry.IsDeferredReference) { DeferredReference dr = (DeferredReference)value; value = dr.GetValue(entry.BaseValueSourceInternal); // Set the baseValue back into the entry entry.SetAnimationBaseValue(value); } object animatedValue = GetCurrentPropertyValue(this, d, _dependencyProperty, metadata, value); if (!_dependencyProperty.IsValidValueInternal(animatedValue)) { // If the animation(s) applied to the property have calculated an // invalid value for the property then raise an exception. throw new InvalidOperationException( SR.Get( SRID.Animation_CalculatedValueIsInvalidForProperty, _dependencyProperty.Name, null)); } entry.SetAnimatedValue(animatedValue, value); }
private static void SetDecomposedProperty(IReadOnlyDictionary <string, object> source, object target, string decompositionPrefix, PropertyMetadata property) { object child = null; if (property.CanRead) { child = property.InvokeGet(target); } if (child == null && property.CanWrite && property.PropertyType.GetConstructor(new Type[0]) != null) { child = Activator.CreateInstance(property.PropertyType); property.InvokeSet(target, child); } if (child != null) { PopulateComplexObject(source, child, decompositionPrefix + property.DecompositionPrefix); } }
protected string GetClientProperty(PropertyMetadata propMetadata, Data.StoredClient client) { string val; if (propMetadata.TryGet(client, out val)) { return val; } throw new Exception("Invalid property type " + propMetadata.Type); }
private static object SetProperty <T>(T target, PropertyMetadata property, object value, OrdinalMappedProperty <T> mapper) { var targetType = property.PropertyType; if (value != null && targetType != value.GetType()) { var targetTypeInfo = targetType.GetTypeInfo(); //var isNullable = !targetTypeInfo.IsValueType; //For Nullable<T>, we only care about the type parameter if (targetType.Name == "Nullable`1" && targetTypeInfo.IsGenericType) { //isNullable = true; targetType = targetType.GenericTypeArguments[0]; targetTypeInfo = targetType.GetTypeInfo(); } //some database return strings when we want strong types if (value is string) { if (targetType == typeof(XElement)) { value = XElement.Parse((string)value); } else if (targetType == typeof(XDocument)) { value = XDocument.Parse((string)value); } else if (targetTypeInfo.IsEnum) { value = Enum.Parse(targetType, (string)value); } else if (targetType == typeof(bool)) { value = bool.Parse((string)value); } else if (targetType == typeof(short)) { value = short.Parse((string)value); } else if (targetType == typeof(int)) { value = int.Parse((string)value); } else if (targetType == typeof(long)) { value = long.Parse((string)value); } else if (targetType == typeof(float)) { value = float.Parse((string)value); } else if (targetType == typeof(double)) { value = double.Parse((string)value); } else if (targetType == typeof(decimal)) { value = decimal.Parse((string)value); } else if (targetType == typeof(DateTime)) { value = DateTime.Parse((string)value); } else if (targetType == typeof(DateTimeOffset)) { value = DateTimeOffset.Parse((string)value); } } else { if (targetTypeInfo.IsEnum) { value = Enum.ToObject(targetType, value); } } //this will handle numeric conversions if (value != null && targetType != value.GetType()) { try { value = Convert.ChangeType(value, targetType); } catch (Exception ex) { throw new MappingException($"Cannot map value of type {value.GetType().FullName} to property {property.Name} of type {targetType.Name}.", ex); } } } if (mapper == null || value == null) { property.InvokeSet(target, value); } else { mapper.InvokeSet(target, value); } return(value); }
/// <summary> /// 构造方法。 /// </summary> /// <param name="screen">屏幕枚举</param> /// <param name="metadata">视图模型的属性元数据信息</param> public CustomControl(Screen screen, PropertyMetadata metadata) : base(screen, metadata) { this.Class = string.Empty; }
public MappedProperty(string mappedColumnName, PropertyMetadata propertyMetadata) { MappedColumnName = mappedColumnName; PropertyMetadata = propertyMetadata; }
private string GetRoleProperty(PropertyMetadata property, InMemoryRole role) { string value; if (property.TryGet(role, out value)) { return value; } throw new Exception("Invalid property type " + property.Type); }
public virtual void InvokeSet(TTarget target, object value) { PropertyMetadata.InvokeSet(target, value); }
internal override void Stop(FrameworkElement frameworkElement, string groupName, bool revertToFormerValue = false) { base.Stop(frameworkElement, groupName, revertToFormerValue); DependencyObject target; PropertyPath propertyPath; GetTargetElementAndPropertyInfo(frameworkElement, out target, out propertyPath); Type lastElementType = target.GetType(); PropertyInfo propertyInfo = lastElementType.GetProperty(propertyPath.INTERNAL_DependencyPropertyName); //todo: find out why we put the test on target and put it back? (I removed it because id kept ScaleTransform from working properly) if (To != null)// && target is FrameworkElement) //todo: "To" can never be "null", fix this. { Type dependencyPropertyContainerType = propertyInfo.DeclaringType; FieldInfo dependencyPropertyField = dependencyPropertyContainerType.GetField(propertyPath.INTERNAL_DependencyPropertyName + "Property"); // - Get the DependencyProperty #if MIGRATION DependencyProperty dp = (global::System.Windows.DependencyProperty)dependencyPropertyField.GetValue(null); #else DependencyProperty dp = (global::Windows.UI.Xaml.DependencyProperty)dependencyPropertyField.GetValue(null); #endif // - Get the propertyMetadata from the property PropertyMetadata propertyMetadata = dp.GetTypeMetaData(target.GetType()); // - Get the cssPropertyName from the PropertyMetadata //we make a specific name for this animation: string specificGroupName = groupName + animationInstanceSpecificName.ToString(); if (propertyMetadata.GetCSSEquivalent != null) { CSSEquivalent cssEquivalent = propertyMetadata.GetCSSEquivalent(target); UIElement uiElement = cssEquivalent.UIElement ?? (target as UIElement); // If no UIElement is specified, we assume that the property is intended to be applied to the instance on which the PropertyChanged has occurred. bool hasTemplate = (uiElement is Control) && ((Control)uiElement).HasTemplate; if (!hasTemplate || cssEquivalent.ApplyAlsoWhenThereIsAControlTemplate) { if (cssEquivalent.DomElement == null && uiElement != null) { cssEquivalent.DomElement = uiElement.INTERNAL_OuterDomElement; // Default value } if (cssEquivalent.DomElement != null) { CSHTML5.Interop.ExecuteJavaScriptAsync(@" Velocity($0, ""stop"", $1);", cssEquivalent.DomElement, specificGroupName); } } } if (propertyMetadata.GetCSSEquivalents != null) { List <CSSEquivalent> cssEquivalents = propertyMetadata.GetCSSEquivalents(target); foreach (CSSEquivalent equivalent in cssEquivalents) { if (equivalent.DomElement != null) { CSHTML5.Interop.ExecuteJavaScriptAsync(@" Velocity($0, ""stop"", $1);", equivalent.DomElement, specificGroupName); } } } } else { propertyPath.INTERNAL_PropertySetVisualState(target, To); //To = null here --> Is it really what we want to do? } if (revertToFormerValue) //todo: check if this is sufficient or if we need to put stuff into the GetCSSEquivalents thing like for ColorAnimation: { object formerValue = propertyInfo.GetValue(target); propertyInfo.SetValue(target, formerValue); } }
/// <summary> /// Registers a new dependency property. /// </summary> /// <param name="name">The dependency property's name.</param> /// <param name="uvssName">The dependency property's name within the UVSS styling system.</param> /// <param name="propertyType">The dependency property's value type.</param> /// <param name="ownerType">The dependency property's owner type.</param> /// <param name="metadata">The dependency property's metadata.</param> /// <returns>A <see cref="DependencyProperty"/> instance which represents the registered dependency property.</returns> public static DependencyProperty Register(String name, String uvssName, Type propertyType, Type ownerType, PropertyMetadata metadata = null) { return DependencyPropertySystem.Register(name, uvssName, propertyType, ownerType, metadata); }
public void OverrideMetadata(Type forType, PropertyMetadata typeMetadata) { dependencyProperty.OverrideMetadata (forType, typeMetadata, this); }
protected virtual void GenerateFilterForCondition(DbCommand cmd, ConditionLite condition, StringBuilder sb, ref int paramIndex, ref bool firstCondition, int indentation) { if (condition == null) { throw new ArgumentNullException(nameof(condition)); } if (cmd == null) { throw new ArgumentNullException(nameof(cmd)); } if (sb == null) { throw new ArgumentNullException(nameof(sb)); } string parameterName = null; if (condition.Filter != null && condition.Filter.IsEmpty()) { return; } if (firstCondition) { ; } else if (condition.LogicalOperator == LogicalOperatorLite.And) { sb.NewIndentedLine(indentation).Append("AND "); } else if (condition.LogicalOperator == LogicalOperatorLite.Or) { sb.NewIndentedLine(indentation).Append("OR "); } else { throw new NotImplementedException("Logical operator " + condition.LogicalOperator.ToString() + " not implemented"); } firstCondition = false; if (condition.Filter != null) { sb.Append(GetFilter(cmd, ref paramIndex, condition.Filter, indentation, true)); return; } IEnumerable values = condition.FieldValue as IEnumerable; IQueryBuilder queryBuilder = condition.SubQuery == null ? null : condition.SubQuery.QueryBuilder; if (condition.Operator == OperatorLite.In || condition.Operator == OperatorLite.NotIn) { if (values == null && queryBuilder == null) { throw new ArgumentException("The value for In and NotIn operators must be enumerable or a subquery", nameof(condition)); } if (values != null) { bool hasAnyValue = values.AreThereMoreThan(0); if (!hasAnyValue) { if (condition.Operator == OperatorLite.In) { sb.Append(" 1=0"); } else { sb.Append(" 1=1"); } return; } } } PropertyMetadata propertyMetadata = null; string fieldName = condition.FieldName; string quotedColumnName = null; if (fieldName == null && condition.Operator != OperatorLite.Exists && condition.Operator != OperatorLite.NotExists) { throw new InvalidOperationException("Field Name must be not null for condition"); } if (fieldName != null) { propertyMetadata = GetPropertyMetadata(this.QueryLite.EntityType, fieldName); quotedColumnName = this.QueryLite.DataService.EntityLiteProvider.StartQuote + propertyMetadata.SqlField.ColumnName + this.QueryLite.DataService.EntityLiteProvider.EndQuote; if (condition.Operator != OperatorLite.In && condition.Operator != OperatorLite.NotIn) { sb.Append(quotedColumnName); } } if (condition.Operator == OperatorLite.IsNull) { sb.Append(" IS NULL"); return; } if (condition.Operator == OperatorLite.IsNotNull) { sb.Append(" IS NOT NULL"); return; } if (condition.Operator == OperatorLite.In || condition.Operator == OperatorLite.NotIn) { AddListCondition(cmd, condition, sb, ref paramIndex, ref indentation, values, queryBuilder, propertyMetadata, quotedColumnName); return; } else if (condition.Operator == OperatorLite.Exists || condition.Operator == OperatorLite.NotExists) { if (condition.Operator == OperatorLite.Exists) { sb.Append("EXISTS (\n"); } else { sb.Append("NOT EXISTS (\n"); } sb.Append(queryBuilder.GetSelectQuery(cmd, ref paramIndex, ++indentation)); sb.NewIndentedLine(--indentation).Append(')'); return; } var fieldReference = condition.FieldValue as FieldReference; if (fieldReference == null) { var parameter = CreateParameter(propertyMetadata, condition.FieldValue, ref paramIndex, out parameterName); cmd.Parameters.Add(parameter); } else { var fieldReferenceEntityType = fieldReference.Alias?.EntityType ?? this.QueryLite.EntityType; string fieldReferenceName = fieldReference.FieldName; PropertyMetadata fieldReferencePropertyMetadata = GetPropertyMetadata(fieldReferenceEntityType, fieldReferenceName); var aliasName = fieldReference.Alias?.Name ?? this.QueryLite.Alias?.Name; if (!string.IsNullOrEmpty(aliasName)) { parameterName = aliasName + "."; } else { parameterName = string.Empty; } parameterName += this.QueryLite.DataService.EntityLiteProvider.StartQuote + fieldReferencePropertyMetadata.SqlField.ColumnName + this.QueryLite.DataService.EntityLiteProvider.EndQuote; } switch (condition.Operator) { case OperatorLite.Contains: sb.Append(" LIKE " + QueryLite.DataService.EntityLiteProvider.Concat("'%'", parameterName, "'%'")); break; case OperatorLite.FbContaining: sb.Append(" CONTAINING ").Append(parameterName); break; case OperatorLite.FbNotContaining: sb.Append(" NOT CONTAINING ").Append(parameterName); break; case OperatorLite.Equals: sb.Append(" = ").Append(parameterName); break; case OperatorLite.Greater: sb.Append(" > ").Append(parameterName); break; case OperatorLite.GreaterOrEquals: sb.Append(" >= ").Append(parameterName); break; case OperatorLite.Less: sb.Append(" < ").Append(parameterName); break; case OperatorLite.LessOrEquals: sb.Append(" <= ").Append(parameterName); break; case OperatorLite.NotContains: sb.Append(" NOT LIKE " + QueryLite.DataService.EntityLiteProvider.Concat("'%'", parameterName, "'%'")); break; case OperatorLite.NotEquals: sb.Append(" <> ").Append(parameterName); break; case OperatorLite.NotStartsWith: sb.Append(" NOT LIKE " + QueryLite.DataService.EntityLiteProvider.Concat(parameterName, "'%'")); break; case OperatorLite.StartsWith: sb.Append(" LIKE " + QueryLite.DataService.EntityLiteProvider.Concat(parameterName, "'%'")); break; case OperatorLite.IsDescendantOf: sb.Append(".IsDescendantOf(" + parameterName + ") = 1"); break; case OperatorLite.IsChildOf: sb.Append(".GetAncestor(1) = " + parameterName); break; case OperatorLite.IsGrandChildOf: sb.Append(".GetAncestor(2) = " + parameterName); break; case OperatorLite.HierarchyLevelEquals: sb.Append(".GetLevel() = " + parameterName); break; case OperatorLite.STEquals: sb.Append(".STEquals(" + parameterName + ") = 1"); break; case OperatorLite.STIntersects: sb.Append(".STIntersects(" + parameterName + ") = 1"); break; case OperatorLite.STDistanceLess: case OperatorLite.STDistanceLessOrEquals: string pname = QueryLite.DataService.EntityLiteProvider.ParameterPrefix + "P" + paramIndex.ToString(CultureInfo.InvariantCulture); cmd.Parameters.AddWithValue(pname, condition.Parameter); paramIndex++; sb.Append(".STDistance(" + parameterName + ") " + (condition.Operator == OperatorLite.STDistanceLess ? "< " : "<= ") + pname); break; default: throw new NotImplementedException("operator " + condition.Operator.ToString() + " not implemented yet"); } }
internal sealed override void EvaluateAnimatedValueCore( DependencyProperty dp, PropertyMetadata metadata, ref EffectiveValueEntry entry) { if (IAnimatable_HasAnimatedProperties) { AnimationStorage storage = AnimationStorage.GetStorage(this, dp); if (storage != null) { storage.EvaluateAnimatedValue(metadata, ref entry); } } }
bool IsPropertyGuid(PropertyMetadata property) { return(String.Equals("System.Guid", property.TypeName, StringComparison.OrdinalIgnoreCase)); }
/// <summary> /// Adds a new owning type to this dependency property. /// </summary> /// <param name="ownerType">The owner type to add to this dependency property.</param> /// <param name="typeMetadata">The property metadata for this owning type, which will override the default metadata.</param> /// <returns>A reference to this dependency property instance.</returns> public DependencyProperty AddOwner(Type ownerType, PropertyMetadata typeMetadata) { Contract.Require(ownerType, "ownerType"); DependencyPropertySystem.AddOwner(this, ownerType); OverrideMetadata(ownerType, typeMetadata); return this; }
protected IDbDataParameter CreateParameter(PropertyMetadata propertyMetadata, object paramValue, ref int paramIndex, out string parameterName) { if (propertyMetadata == null) { throw new ArgumentNullException(nameof(propertyMetadata)); } parameterName = QueryLite.DataService.EntityLiteProvider.ParameterPrefix + "P" + paramIndex.ToString(CultureInfo.InvariantCulture); IDbDataParameter parameter = QueryLite.DataService.DbProviderFactory.CreateParameter(); parameter.ParameterName = parameterName; parameter.Size = propertyMetadata.SqlField.Size; Type propertyType = propertyMetadata.PropertyInfo.PropertyType.UndelyingType(); var sqlParam = parameter as SqlParameter; if (propertyType.FullName.StartsWith("Microsoft.SqlServer.Types.Sql", StringComparison.Ordinal)) { if (sqlParam != null) { sqlParam.SqlDbType = SqlDbType.Udt; //TODO: En .NET Core no va a funcionar porque no existe la propiedad "UdtTypeName" y dará un error en tiempo de ejecución. #pragma warning disable CA1308 // Normalize strings to uppercase udtTypeNameSetter?.Invoke(sqlParam, propertyType.Name.ToLowerInvariant()); #pragma warning restore CA1308 // Normalize strings to uppercase } else { parameter.DbType = DbType.String; if (propertyType.Name.StartsWith("SqlHierarchyId", StringComparison.Ordinal)) { parameter.Size = 4000; } else { parameter.Size = 1073741823; } } } else { if (propertyMetadata.SqlField.ProviderType != int.MaxValue) { this.QueryLite.DataService.EntityLiteProvider.SetProviderTypeToParameter(parameter, propertyMetadata.SqlField.ProviderType); } else if (propertyMetadata.SqlField.DbType == DbType.AnsiStringFixedLength) { parameter.DbType = DbType.AnsiString; } else if (propertyMetadata.SqlField.DbType == DbType.StringFixedLength) { parameter.DbType = DbType.String; } else if (propertyMetadata.SqlField.DbType == DbType.Time && sqlParam != null) { sqlParam.SqlDbType = SqlDbType.Time; } else { parameter.DbType = propertyMetadata.SqlField.DbType; } parameter.SourceColumn = propertyMetadata.PropertyInfo.Name; if (propertyMetadata.SqlField.Precision != 255 && propertyMetadata.SqlField.Precision != 0) { parameter.Precision = propertyMetadata.SqlField.Precision; } if (propertyMetadata.SqlField.Scale != 255) { parameter.Scale = propertyMetadata.SqlField.Scale; } } if (paramValue != null && (parameter.DbType == DbType.String || parameter.DbType == DbType.AnsiString) && !(paramValue is string)) { var convertible = paramValue as IConvertible; if (convertible != null) { paramValue = convertible.ToString(CultureInfo.InvariantCulture); } else { paramValue = paramValue.ToString(); } } INullable sqlNullable = paramValue as INullable; parameter.Value = (paramValue == null || (sqlNullable != null && sqlNullable.IsNull)) ? DBNull.Value : paramValue; paramIndex++; return(parameter); }
// A foreign key, e.g. CategoryID, will have an association name of Category string GetAssociationName(PropertyMetadata property) { RelatedModelMetadata propertyModel = GetRelatedModelMetadata(property); return(propertyModel != null ? propertyModel.AssociationPropertyName : property.PropertyName); }
private void AddListCondition(DbCommand cmd, ConditionLite condition, StringBuilder sb, ref int paramIndex, ref int indentation, IEnumerable values, IQueryBuilder queryBuilder, PropertyMetadata propertyMetadata, string quotedColumnName) { if (values != null) { bool firstValue = true; var isNumericField = propertyMetadata.PropertyInfo.PropertyType.IsNumericType(); var undelyingFieldType = propertyMetadata.PropertyInfo.PropertyType.UndelyingType(); var isStringField = propertyMetadata.PropertyInfo.PropertyType == typeof(string); if ((isNumericField || isStringField) && values.AreThereMoreThan(8)) { bool firstChunk = true; int valueCount = 0; sb.Append('('); foreach (object v in values) { object value = v; if (valueCount % 1000 == 0) { firstValue = true; if (firstChunk) { firstChunk = false; } else { sb.Append(") ").Append(condition.Operator == OperatorLite.In ? " OR " : " AND "); } sb.Append(quotedColumnName).Append(condition.Operator == OperatorLite.In ? " IN (" : " NOT IN ("); } string valueStr = null; if (value == null) { valueStr = "NULL"; } else { if (isNumericField && !value.IsNumeric()) { try { value = Convert.ChangeType(value, undelyingFieldType, CultureInfo.InvariantCulture); } catch (Exception ex) { throw new ArgumentException($"A non numeric value has been found for {condition.Operator} operator and field {propertyMetadata.PropertyInfo.Name}", ex); } } valueStr = Convert.ToString(value, CultureInfo.InvariantCulture); if (isStringField) { valueStr = "'" + valueStr.Replace("'", "''") + "'"; } } if (firstValue) { firstValue = false; } else { sb.Append(", "); } sb.Append(valueStr); valueCount++; } sb.Append("))"); } else { sb.Append(quotedColumnName).Append(condition.Operator == OperatorLite.In ? " IN (": " NOT IN ("); string parameterName; foreach (object value in values) { var param = CreateParameter(propertyMetadata, value, ref paramIndex, out parameterName); cmd.Parameters.Add(param); if (firstValue) { firstValue = false; } else { sb.Append(", "); } sb.Append(parameterName); } sb.Append(')'); } } else { sb.Append(quotedColumnName).Append(condition.Operator == OperatorLite.In ? " IN (" : " NOT IN ("); sb.Append('\n').Append(queryBuilder.GetSelectQuery(cmd, ref paramIndex, ++indentation)); sb.NewIndentedLine(--indentation); sb.Append(')'); } }
/// <summary> /// Registers a new read-only dependency property. /// </summary> /// <param name="name">The dependency property's name.</param> /// <param name="propertyType">The dependency property's value type.</param> /// <param name="ownerType">The dependency property's owner type.</param> /// <param name="metadata">The dependency property's metadata.</param> /// <returns>A <see cref="DependencyPropertyKey"/> instance which provides access to the read-only dependency property.</returns> public static DependencyPropertyKey RegisterReadOnly(String name, Type propertyType, Type ownerType, PropertyMetadata metadata = null) { return DependencyPropertySystem.RegisterReadOnly(name, null, propertyType, ownerType, metadata); }
// A foreign key, e.g. CategoryID, will have a value expression of Category.CategoryID string GetValueExpression(PropertyMetadata property) { RelatedModelMetadata propertyModel = GetRelatedModelMetadata(property); return(propertyModel != null ? propertyModel.AssociationPropertyName + "." + propertyModel.DisplayPropertyName : property.PropertyName); }