C# PropertyDescriptor.GetValue方法代码示例

 /// <summary>
 /// Processes the property.
 /// </summary>
 /// <param name="value">The value.</param>
 /// <param name="property">The property.</param>
 private static void ProcessProperty(object value, PropertyDescriptor property)
 {
     if (property.Attributes.Contains(AntiXssHtmlText))
     {
         property.SetValue(value, Sanitizer.GetSafeHtmlFragment((string) property.GetValue(value)));
     }
     else if (property.Attributes.Contains(AntiXssIgnore))
     {
         // do nothing this contains special text
     }
     else
     {
         property.SetValue(value, HttpUtility.HtmlDecode(HttpUtility.HtmlEncode((string)property.GetValue(value))));
     }
 }

 private IEnumerable<ValidationError> GetValidationErrorsForProperty(PropertyDescriptor property, object model)
 {
     return property.Attributes
         .OfType<ValidationAttribute>()
         .Where(x => !x.IsValid(property.GetValue(model)))
         .Select(x => new ValidationError(property.Name, x.FormatErrorMessage(string.Empty), model));
 }

 private object GetPropertyValue(IDesignerSerializationManager manager, PropertyDescriptor property, object value, out bool validValue)
 {
     object obj2 = null;
     validValue = true;
     try
     {
         if (!property.ShouldSerializeValue(value))
         {
             AmbientValueAttribute attribute = (AmbientValueAttribute) property.Attributes[typeof(AmbientValueAttribute)];
             if (attribute != null)
             {
                 return attribute.Value;
             }
             DefaultValueAttribute attribute2 = (DefaultValueAttribute) property.Attributes[typeof(DefaultValueAttribute)];
             if (attribute2 != null)
             {
                 return attribute2.Value;
             }
             validValue = false;
         }
         obj2 = property.GetValue(value);
     }
     catch (Exception exception)
     {
         validValue = false;
         manager.ReportError(System.Design.SR.GetString("SerializerPropertyGenFailed", new object[] { property.Name, exception.Message }));
     }
     return obj2;
 }

 /// <summary>
 /// Processes the property.
 /// </summary>
 /// <param name="value">The value.</param>
 /// <param name="property">The property.</param>
 private static void ProcessProperty(object value, PropertyDescriptor property)
 {
     if (property.Attributes.Contains(AntiXssHtmlText))
     {
         property.SetValue(value, AntiXss.GetSafeHtmlFragment((string) property.GetValue(value)));
     }
 }

 public EnumPropertyItem(PropertyDescriptor property, object instance, IEnumerable values)
     : base(property, instance)
 {
     EnumValues = CollectionViewSource.GetDefaultView(values);
     EnumValues.MoveCurrentTo(property.GetValue(instance));
     EnumValues.CurrentChanged += OnEnumValueChanged;
 }

        public RelatedCurrencyManager(BindingManagerBase parent, PropertyDescriptor prop_desc)
            : base(prop_desc.GetValue (parent.Current))
        {
            this.parent = parent;
            this.prop_desc = prop_desc;

            parent.PositionChanged += new EventHandler (parent_PositionChanged);
        }

 public OverlayEditBox(object Obj, string propName, Point position)
 {
     InitializeComponent();
     obj = Obj;
     prop = TypeDescriptor.GetProperties(obj).Find(propName, true);
     Location = position;
     editor.Text = prop.GetValue(obj).ToString();
     InputHook.MouseDown += OnGlobalMouseDown;
 }

        public CommandPropertyItem(PropertyDescriptor property, object instance)
            : base(property, instance)
        {
            _command = property.GetValue(instance) as ICommand;
            if (_command != null)
            {
                _command.CanExecuteChanged += CanExecuteChanged;
            }

            _executeCommand = new Command<object>(o => _command.Execute(GetCommandParameter()), o => _command != null && _command.CanExecute(GetCommandParameter()));
        }

 public static Func<object,bool> Contains(PropertyDescriptor property, string text)
 {
     if (string.IsNullOrEmpty(text))
     {
         return True;
     }
     return row =>
                {
                    var value = property.GetValue(row);
                    return value != null && value.ToString().IndexOf(text) >= 0;
                };
 }

 /// <summary>
 /// Binds a IEnumerable{SelectList}
 /// </summary>
 /// <param name="binder">The binder.</param>
 /// <param name="controllerContext">The controller context.</param>
 /// <param name="bindingContext">The binding context.</param>
 /// <param name="propertyDescriptor">The property descriptor.</param>
 public static void BindSelectList(this StandardModelBinder binder, ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor propertyDescriptor)
 {
     var selectList = (IEnumerable<SelectListItem>)propertyDescriptor.GetValue(bindingContext.Model);
     if (selectList != null)
     {
         //first, need to zero out all selections
         selectList.UnSelectItems();
         binder.SetPropertyValue(controllerContext, bindingContext, propertyDescriptor,
                                 val =>
                                     {
                                         selectList.SelectItems(val.Split(','));
                                         return selectList;
                                     });
     }
 }

		private void SerializeNormalProperty (IDesignerSerializationManager manager, 
											  object value, PropertyDescriptor descriptor, CodeStatementCollection statements)
		{
			CodeExpression leftSide = base.SerializeToExpression (manager, value);
			CodeExpression rightSide = null;

			MemberRelationship relationship = GetRelationship (manager, value, descriptor);
			if (!relationship.IsEmpty) 
				rightSide = new CodePropertyReferenceExpression (base.SerializeToExpression (manager, relationship.Owner), 
																 relationship.Member.Name);
			else
				rightSide = base.SerializeToExpression (manager, descriptor.GetValue (value));

			statements.Add (new CodeAssignStatement (leftSide, rightSide));
		}

        protected override void SetProperty(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor propertyDescriptor, object value)
        {
            ModelMetadata propertyMetadata = bindingContext.PropertyMetadata[propertyDescriptor.Name];
            propertyMetadata.Model = value;
            string modelStateKey = CreateSubPropertyName(bindingContext.ModelName, propertyMetadata.PropertyName);

            // Try to set a value into the property unless we know it will fail (read-only
            // properties and null values with non-nullable types)
            if (!propertyDescriptor.IsReadOnly)
            {
                try
                {
                    if (value == null)
                    {
                        propertyDescriptor.SetValue(bindingContext.Model, value);
                    }
                    else
                    {
                        Type valueType = value.GetType();

                        if (valueType.IsGenericType && valueType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
                        {
                            IListSource ls = (IListSource)propertyDescriptor.GetValue(bindingContext.Model);
                            IList list = ls.GetList();

                            foreach (var item in (IEnumerable)value)
                            {
                                list.Add(item);
                            }
                        }
                        else
                        {
                            propertyDescriptor.SetValue(bindingContext.Model, value);
                        }
                    }

                }
                catch (Exception ex)
                {
                    // Only add if we're not already invalid
                    if (bindingContext.ModelState.IsValidField(modelStateKey))
                    {
                        bindingContext.ModelState.AddModelError(modelStateKey, ex);
                    }
                }
            }
        }

        /// <inheritdoc/>
        protected override void BindProperty(ControllerContext controllerContext,
                                             ModelBindingContext bindingContext,
                                             PropertyDescriptor propertyDescriptor) {
            string fullPropertyKey = CreateSubPropertyName(bindingContext.ModelName, propertyDescriptor.Name);

            // Only bind properties that are part of the request
            if (bindingContext.ValueProvider.DoesAnyKeyHavePrefix(fullPropertyKey)) {
                var innerContext = new ModelBindingContext() {
                    Model = propertyDescriptor.GetValue(bindingContext.Model),
                    ModelName = fullPropertyKey,
                    ModelState = bindingContext.ModelState,
                    ModelType = propertyDescriptor.PropertyType,
                    ValueProvider = bindingContext.ValueProvider
                };
				
                IModelBinder binder = Binders.GetBinder(propertyDescriptor.PropertyType);
                object newPropertyValue = ConvertValue(propertyDescriptor, binder.BindModel(controllerContext, innerContext));
                ModelState modelState = bindingContext.ModelState[fullPropertyKey];

                // Only validate and bind if the property itself has no errors
                if (modelState.Errors.Count == 0) {
                    if (OnPropertyValidating(controllerContext, bindingContext, propertyDescriptor, newPropertyValue)) {
                        SetProperty(controllerContext, bindingContext, propertyDescriptor, newPropertyValue);
                        OnPropertyValidated(controllerContext, bindingContext, propertyDescriptor, newPropertyValue);
                    }
                }

                // There was an error getting the value from the binder, which was probably a format
                // exception (meaning, the data wasn't appropriate for the field)
                else {
                    foreach (var error in modelState.Errors.Where(err => err.ErrorMessage == "" && err.Exception != null).ToList()) {
                        for (var exception = error.Exception; exception != null; exception = exception.InnerException) {
                            if (exception is FormatException) {
                                string displayName = GetDisplayName(propertyDescriptor);
                                string errorMessage = InvalidValueFormatter(propertyDescriptor, modelState.Value.AttemptedValue, displayName);
                                modelState.Errors.Remove(error);
                                modelState.Errors.Add(errorMessage);
                                break;
                            }
                        }
                    }
                }
            }
        }

        public override IDataValue GetDataValue(PropertyDescriptor propertyDescriptor, object data)
        {
            if (propertyDescriptor.PropertyType.IsArray && propertyDescriptor.PropertyType.GetElementType().Equals(typeof(byte)))
            {
                byte[] value = propertyDescriptor.GetValue(data) as byte[];

                if (value != null)
                {
                    return new DataValue(propertyDescriptor.Name, MySqlFunctions.Unhex(ByteArrayToHexString(value)), false);
                }
                else
                {
                    return new DataValue(propertyDescriptor.Name, null);
                }
            }
            else
            {
                return base.GetDataValue(propertyDescriptor, data);
            }
        }

        /// <summary>
        /// Validates the given instance.
        /// </summary>
        /// <param name="instance">The instance that should be validated.</param>
        /// <param name="attribute">The <see cref="ValidationAttribute"/> that should be handled.</param>
        /// <param name="descriptor">A <see cref="PropertyDescriptor"/> instance for the property that is being validated.</param>
        /// <returns>An <see cref="IEnumerable{T}"/> of <see cref="ModelValidationRule"/> instances.</returns>
        public virtual IEnumerable<ModelValidationError> Validate(object instance, ValidationAttribute attribute, PropertyDescriptor descriptor)
        {
            var context =
                new ValidationContext(instance, null, null)
                {
                    MemberName = descriptor == null ? null : descriptor.Name
                };

            if(descriptor != null)
            {
                instance = descriptor.GetValue(instance);
            }

            var result =
                attribute.GetValidationResult(instance, context);

            if (result != null)
            {
                yield return new ModelValidationError(result.MemberNames, string.Join(" ", result.MemberNames.Select(attribute.FormatErrorMessage)));
            }
        }