public void Read(ClrModuleReader reader)
 {
     this.PropertyDefinition = new PropertyDefinition();
     this.PropertyDefinition.Attributes = (PropertyAttributes)reader.Binary.ReadUInt16();
     this.PropertyDefinition.Name = reader.ReadString();
     this.Type = reader.ReadPropertySignature();
 }

 private static IEnumerable<string> GetPropertyTags(ContentData content, PropertyDefinition propertyDefinition)
 {
     var tagNames = content[propertyDefinition.Name] as string;
     return tagNames == null
         ? Enumerable.Empty<string>()
         : tagNames.Split(new[] {','}, StringSplitOptions.RemoveEmptyEntries);
 }

 public override void AssignToProperty(object obj, PropertyDefinition property)
 {
     if (property.CanSet)
         property.SetOn(obj, GetTypedValue(collectionDef));
     else if (property.CanGet)
         PopulateCollection(collectionDef, property.GetFrom(obj));
 }

            private void DoPropertyBind(PropertyTreeBinderImpl parent,
                                        PropertyTreeMetaObject target,
                                        PropertyTreeNavigator navigator,
                                        PropertyDefinition property)
            {
                object ancestor = null;
                PropertyTreeMetaObject ancestorMeta = null;

                if (property.IsExtender) {
                    var ancestorType = property.DeclaringTreeDefinition.SourceClrType;
                    ancestorMeta = target.GetAncestors().Cast<PropertyTreeMetaObject>().FirstOrDefault(
                        t => ancestorType.IsAssignableFrom(t.ComponentType));

                    if (ancestorMeta != null)
                        ancestor = ancestorMeta.Component;
                }

                var component = target.Component;
                PropertyTreeMetaObject propertyTarget = target.CreateChild(property, navigator.QualifiedName, ancestorMeta);

                var services = new PropertyBindContext(
                    component,
                    property,
                    ServiceProvider.Compose(ServiceProvider.FromValue(navigator), parent))
                {
                    LineNumber = navigator.LineNumber,
                    LinePosition = navigator.LinePosition,
                };

                propertyTarget = parent.Bind(propertyTarget, navigator, services);
                target.BindSetMember(property, navigator.QualifiedName, propertyTarget, ancestorMeta, services);
            }

 public PropertyMapDefinition()
 {
     this.Source = new ObjectDefinition();
     this.Target = new ObjectDefinition();
     this.SourceProp = new PropertyDefinition();
     this.TargetProp = new PropertyDefinition();
 }

        public RequiredRule(PropertyDefinition propertyDefinition)
            : base(propertyDefinition)
        {
            base.Assertion = oi => !String.IsNullOrWhiteSpace(oi.GetUntypedValue(propertyDefinition).StringValue);

              base.ErrorMessageStaticGenerator = () => $"'{propertyDefinition.CurrentName}' is required.";
        }

		static PropertyDefinition CreateProperty()
		{
			var prop = new PropertyDefinition(Generate.Name.ForMethod(), PropertyAttributes.None, TestModule.TypeSystem.Boolean);
			TestType.Properties.Add(prop);
			prop.DeclaringType = TestType;
			return prop;
		}

 private IObservable<object> GetObservableFromProperty(PropertyDefinition subscription)
 {
     return Observable.FromEventPattern<PropertyChangedEventHandler, PropertyChangedEventArgs>(
         parentOnPropertyChanged => subscription.Parent.PropertyChanged += parentOnPropertyChanged,
         parentOnPropertyChanged => subscription.Parent.PropertyChanged -= parentOnPropertyChanged)
         .Where(pattern => pattern.EventArgs.PropertyName == subscription.PropertyName)
         .Select(pattern => _mountPoint.Value);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="PropertyBasedScheduleConditionDefinition"/> class.
        /// </summary>
        /// <param name="contractName">The contract name that is used to identify the current condition.</param>
        /// <param name="property">The property that will provide the condition result.</param>
        private PropertyBasedScheduleConditionDefinition(string contractName, PropertyDefinition property)
            : base(contractName)
        {
            {
                Debug.Assert(property != null, "The property object should not be null.");
            }

            m_Property = property;
        }

        /// <summary>
        /// Creates the text block control.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <returns>
        /// 
        /// </returns>
        protected virtual FrameworkElement CreateTextBlockControl(PropertyDefinition property)
        {
            var tb = new TextBlock
                {
                    HorizontalAlignment = property.HorizontalAlignment,
                    VerticalAlignment = VerticalAlignment.Center,
                    Padding = new Thickness(4, 0, 4, 0)
                };

            tb.SetBinding(TextBlock.TextProperty, property.CreateOneWayBinding());
            return tb;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="PropertyBasedExportDefinition"/> class.
        /// </summary>
        /// <param name="contractName">The contract name that is used to identify the current export.</param>
        /// <param name="declaringType">The type that declares the property on which the import is placed.</param>
        /// <param name="property">The property for which the current object stores the serialized data.</param>
        private PropertyBasedExportDefinition(
            string contractName,
            TypeIdentity declaringType,
            PropertyDefinition property)
            : base(contractName, declaringType)
        {
            {
                Debug.Assert(property != null, "The property object shouldn't be null.");
            }

            m_Property = property;
        }

        public override FrameworkElement CreateEditControl(PropertyDefinition propertyDefinition, string bindingPath)
        {
            var control = propertyDefinition.CreateEditControl(bindingPath);
            if (control != null)
                return control;

            var ctl = CreateExtendedToolkitControl(propertyDefinition, bindingPath);
            if (ctl != null)
                return ctl;

            return base.CreateEditControl(propertyDefinition, bindingPath);
        }

 public override void AssignToProperty(object obj, PropertyDefinition property)
 {
     if (property.CanSet)
     {
         property.SetOn(obj, GetTypedValue());
     }
     else if (property.CanGet)
     {
         typedDictionary = property.GetFrom(obj) as IDictionary;
         PopulateDictionary();
     }
 }

        public TypeConvertableRule(PropertyDefinition propertyDefinition)
            : base(propertyDefinition)
        {
            base.Assertion = oi =>
              {
            var propertyValue = oi.GetUntypedValue(propertyDefinition);
            //a type is converted at the time it's string value is set, so all we need to do is check to see if that was successful.
            return propertyValue.TypedValueIsAvailable;
              };

              base.ErrorMessageStaticGenerator = () =>
            $"{propertyDefinition.CurrentName} must be a valid {(App.CurrentContext.IsHumanInterface ? GetHumanNameForType(propertyDefinition.ValueType) : propertyDefinition.ValueType.ToString())}.";
        }

        /// <summary>
        /// Creates the edit control.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <param name="instance">The instance.</param>
        /// <returns>
        /// The control.
        /// </returns>
        public virtual FrameworkElement CreateEditControl(PropertyDefinition property, object instance)
        {
            var propertyType = property.Descriptor.PropertyType;
            if (property.ItemsSourceProperty != null || property.ItemsSource != null)
                return CreateComboBox(property);

            if (propertyType.Is(typeof(Color)))
            {
                return this.CreateColorPickerControl(property);
            }

            return CreateTextBox(property);
        }

        static PropertyDefinition CreateProperty()
		{
			var prop = new PropertyDefinition(Generate.Name.ForMethod(), PropertyAttributes.None, TestModule.TypeSystem.Boolean);
			TestType.Properties.Add(prop);
			prop.DeclaringType = TestType;
			prop.GetMethod = TestType.CreateMethod("get_" + prop.Name)
				.Returns<bool>()
                .AppendIL()
				    .Ldc(true)
				    .Ret()
				    .MethodDefinition;
			return prop;
		}

 internal static CilProperty Create(PropertyDefinition propertyDef, int token, ref CilReaders readers, CilTypeDefinition typeDefinition)
 {
     CilProperty property = new CilProperty();
     property._typeDefinition = typeDefinition;
     property._propertyDef = propertyDef;
     property._readers = readers;
     property._isSignatureInitialized = false;
     property._isDefaultValueInitialized = false;
     property._isGetterInitialized = false;
     property._isSetterInitialized = false;
     property._token = token;
     property._accessors = propertyDef.GetAccessors();
     return property;
 }

        /// <summary>
        /// Creates the display control.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <param name="instance">The instance.</param>
        /// <returns>
        /// The control.
        /// </returns>
        public virtual FrameworkElement CreateDisplayControl(PropertyDefinition property, object instance)
        {
            var propertyType = property.Descriptor.PropertyType;
            if (propertyType.Is(typeof(bool)))
            {
                return this.CreateCheckBoxControl(property);
            }

            if (propertyType.Is(typeof(Color)))
            {
                return this.CreateColorPreviewControl(property);
            }

            return this.CreateTextBlockControl(property);
        }

        public InvalidStringRule(PropertyDefinition propertyDefinition, params string[] invalidStrings)
            : base(propertyDefinition)
        {
            InvalidStrings = invalidStrings;

              base.Assertion = oi =>
              {
            var stringValue = oi.GetUntypedValue(propertyDefinition).StringValue;
            if (stringValue == null)
            {
              return true;
            }
            return !InvalidStrings.Any(ic => stringValue.Contains(ic));
              };

              base.ErrorMessageStaticGenerator = () => $"'{propertyDefinition.CurrentName}' cannot contain any of the following values {string.Join(",", InvalidStrings)}.";
        }

        public RangeRule(PropertyDefinition propertyDefinition, object minValue, object maxValue)
            : base(propertyDefinition)
        {
            MinimumValue = minValue;
              MaximumValue = maxValue;

              base.Assertion = oi =>
              {
            var stringValue = oi.GetUntypedValue(propertyDefinition).StringValue;
            if (stringValue == null)
            {
              return true;
            }

            Type propertyType = propertyDefinition.ValueType;
            object min;
            object max;

            try
            {
              min = Convert.ChangeType(MinimumValue, propertyType);
              max = Convert.ChangeType(MaximumValue, propertyType);
            }
            catch (InvalidCastException cx)
            {
              return false;
            }

            var objValue = oi.GetUntypedValue(propertyDefinition).Value;
            if (propertyType == typeof(int))
            {
              return (int)objValue >= (int)minValue && (int)objValue <= (int)maxValue;
            }
            if (propertyType == typeof(double) || propertyType == typeof(float))
            {
              return (double)objValue >= (double)minValue && (double)objValue <= (double)maxValue;
            }
            if (propertyType == typeof(DateTime) || propertyType == typeof(DateTime))
            {
              return (DateTime)objValue >= (DateTime)minValue && (DateTime)objValue <= (DateTime)maxValue;
            }
            throw new InvalidOperationException("Range type must be one of the following types: int, float, double, DateTime");
              };

              base.ErrorMessageStaticGenerator = () => $"'{propertyDefinition.CurrentName}' must be between {MinimumValue} and {MaximumValue}.";
        }