public void Attach(object o, string propertyName)
        {
            Detach();
            PropertyInfo property = GetProperty(o, propertyName);

            if (property != null)
            {
                MethodInfo setMethod = property.GetSetMethod(true);
                if (setMethod != null)
                {
                    setter = Delegate.CreateDelegate(typeof(PropertySetter), o, setMethod) as PropertySetter;
                }
                MethodInfo getMethod = property.GetGetMethod(true);
                if (getMethod != null)
                {
                    getter = Delegate.CreateDelegate(typeof(PropertyGetter), o, getMethod) as PropertyGetter;
                }

                if (setter == null || getMethod == null)
                {
                    Detach();
                }
                else
                {
                    attached = true;
                }
            }
        }
        public void PropertyGetter2WorksWithBoxing()
        {
            var bar = new Bar {
                Baz = new Baz(123)
            };
            var property = typeof(Bar).GetProperty(nameof(Bar.Baz));

            var getter = new PropertyGetter <Bar, IBaz>(property);

            getter.Func.Target.Should().BeSameAs(getter);
            getter.Func.Method.Name.Should().Be(nameof(getter.GetValueReflection));
            getter.Func.Method.DeclaringType.Should().Be(typeof(PropertyGetter <Bar, IBaz>));

            var  reflectionTimer = Stopwatch.StartNew();
            IBaz reflectionValue = getter.GetValue(bar);

            reflectionTimer.Stop();

            getter.SetOptimizedFunc();

            getter.Func.Target.Should().NotBeSameAs(getter);
            getter.Func.Method.Name.Should().Be(PropertyGetter.GetValueOptimized);
            getter.Func.Method.DeclaringType.Should().NotBe(typeof(PropertyGetter <Bar, IBaz>));

            var  optimizedTimer = Stopwatch.StartNew();
            IBaz optimizedValue = getter.GetValue(bar);

            optimizedTimer.Stop();

            optimizedValue.Should().Be(reflectionValue);
            optimizedTimer.Elapsed.Should().BeLessThan(reflectionTimer.Elapsed);
        }
        public VirtualPropertyInfo(
            string name,
            Type propertyType,
            Func <object, object> getter,
            Action <object, object> setter,
            IEnumerable <Attribute> propertyAttributes,
            IEnumerable <Attribute> getterAttributes,
            IEnumerable <Attribute> setterAttributes,
            CustomReflectionContext context)
            : base(propertyType, name, context)
        {
            if (getter == null && setter == null)
            {
                throw new ArgumentException(SR.ArgumentNull_GetterOrSetterMustBeSpecified);
            }

            CustomType rcType = propertyType as CustomType;

            if (rcType == null || rcType.ReflectionContext != context)
            {
                throw new ArgumentException(SR.Argument_PropertyTypeFromDifferentContext);
            }

            if (getter != null)
            {
                _getter = new PropertyGetter(this, getter, getterAttributes);
            }

            if (setter != null)
            {
                _setter = new PropertySetter(this, setter, setterAttributes);
            }

            _attributes = propertyAttributes ?? CollectionServices.Empty <Attribute>();
        }
        public void PropertyGetterWorksWithStatic()
        {
            var property = typeof(Garply).GetProperty(nameof(Garply.Bar));

            var getter = new PropertyGetter(property);

            getter.Func.Target.Should().BeSameAs(property);
            getter.Func.Method.Name.Should().Be(nameof(property.GetValue));
            getter.Func.Method.DeclaringType.Should().Be(typeof(PropertyInfo));

            var    reflectionTimer = Stopwatch.StartNew();
            object reflectionValue = getter.GetValue(null);

            reflectionTimer.Stop();

            getter.SetOptimizedFunc();

            getter.Func.Target.Should().NotBeSameAs(property);
            getter.Func.Method.Name.Should().Be(PropertyGetter.GetValueOptimized);
            getter.Func.Method.DeclaringType.Should().NotBe(typeof(PropertyInfo));

            var    optimizedTimer = Stopwatch.StartNew();
            object optimizedValue = getter.GetValue(null);

            optimizedTimer.Stop();

            optimizedValue.Should().Be(reflectionValue);
            optimizedTimer.Elapsed.Should().BeLessThan(reflectionTimer.Elapsed);
        }
Exemple #5
0
        /// <summary>
        /// Método que genera los Getters de un determinado tipo de objeto (clase) y los
        /// devuelve en un diccionario que contiene todas las propiedades de la clase
        /// junto con los métodos creados dinámicamente.
        /// </summary>
        /// <param name="type">Tipo (Clase) del que se obtendran las propiedades.</param>
        /// <param name="cache">Si es true, el Diccionario creado se alamacenará en caché,
        /// en caso contrario, no se almacenará en caché.</param>
        /// <returns>Diccionario de duplas (NombrePropiedad, MétodoGetDinámico).</returns>
        public static IPropertyGetterDictionary GetPropertyGetters(Type type, bool cache)
        {
            //Si los Getters ya habian sido creados se devuelven
            PropertyGetterDictionary getters = GetGettersFromCache(type);

            if (getters != null)
            {
                return(getters);
            }

            //Lo primero obtengo las propiedades de ese tipo (clase).
            //Cada PropertyInfo contiene el tipo y el nombre de una propiedad de la clase (type).
            PropertyInfo[] props = type.GetProperties();

            //Diccionario en el que la clave es el Nombre de la propiedad y el valor el método Get obtenido por reflection
            Dictionary <string, PropertyGetter> internalGetters = new Dictionary <string, PropertyGetter>(props.Length);

            foreach (PropertyInfo pi in props)
            {
                //Obtenemos en 'setter' el método Get dinámico para el atributo o propiedad 'pi'.
                PropertyGetter getter = GetPropertyGetter(pi);
                if (getter != null)
                {
                    internalGetters.Add(pi.Name.ToLower(), getter);
                }
            }
            getters = new PropertyGetterDictionary(internalGetters);

            if (cache)
            {
                AddGettersToCache(getters, type);
            }
            return(getters);
        }
            /// <summary>
            /// 属性
            /// </summary>
            /// <param name="property">属性信息</param>
            private PropertyDescriptor(PropertyInfo property)
            {
                var aliasAsAttribute = property.GetAttribute <AliasAsAttribute>(true);

                if (aliasAsAttribute != null && aliasAsAttribute.IsDefinedScope(keyValueFormatScope))
                {
                    this.Name = aliasAsAttribute.Name;
                }
                else
                {
                    this.Name = property.Name;
                }

                var datetimeFormatAttribute = property.GetCustomAttribute <DateTimeFormatAttribute>();

                if (datetimeFormatAttribute != null && datetimeFormatAttribute.IsDefinedScope(keyValueFormatScope))
                {
                    this.DateTimeFormat = datetimeFormatAttribute.Format;
                }

                if (property.CanRead == true)
                {
                    this.getter       = new PropertyGetter(property);
                    this.IsSupportGet = true;
                }

                this.IgnoreSerialized = property.IsDefinedFormatScope <IgnoreSerializedAttribute>(keyValueFormatScope);
                this.IgnoreWhenNull   = property.IsDefinedFormatScope <IgnoreWhenNullAttribute>(keyValueFormatScope);
            }
        public static void AssignPropertiesFrom(this object target, object source)
        {
            if (target == null)
            {
                throw new ArgumentNullException("target");
            }
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            Type targetType = target.GetType();
            Type sourceType = source.GetType();

            var setters = PropertyHelper.GetPropertySetters(targetType);
            var getters = PropertyHelper.GetPropertyGetters(sourceType);

            foreach (var kvSetter in setters)
            {
                string         propertyName = kvSetter.Key;
                PropertySetter setter       = kvSetter.Value;
                PropertyGetter getter       = null;
                if (getters.TryGetValue(propertyName, out getter))
                {
                    setter(target, getter(source));
                }
            }
        }
Exemple #8
0
        /// <summary>
        /// Representa un mapeo entre los ordinales de los campos del IDataReader y los Getters.
        /// Devuelve un array en el que su índice y el de los ordinales de los campos del
        /// IDataReader tienen que coincidir.
        /// </summary>
        /// <param name="reader">Estructura de datos que contiene los datos obtenidos de la BD.</param>
        /// <param name="itemType">Tipo de datos cuyas propiedades deben estar mapeadas con los
        /// campos de la BD.</param>
        /// <returns>Vector de Getters.</returns>
        private static PropertyGetter[] GetPropertyGetters(IDataReader reader, Type itemType)
        {
            int fieldCount = reader.FieldCount;

            PropertyGetter[] propertyGetters = new PropertyGetter[fieldCount];

            //Posiblemente esta en la cache y lo devuelve, sino se crea y se devuelve.
            IPropertyGetterDictionary gettersDictionary = PropertyHelper.GetPropertyGetters(itemType);

            //Recorremos todos los campos del IDataReader
            for (int fieldOrdinal = 0; fieldOrdinal < fieldCount; fieldOrdinal++)
            {
                PropertyGetter getter;

                //Mapeo entre ordinal del campo y el nombre de la propiedad de la clase.
                //Aqui es importante que los campos del IDataReader se llamen exactamente
                //igual que las propiedades de la clase. Puesto que se buscará el nombre del
                //campo en el diccionario creado a partir de las propiedades de la clase.
                if (gettersDictionary.TryGetValue(reader.GetName(fieldOrdinal), out getter))
                {
                    propertyGetters[fieldOrdinal] = getter;
                }
            }
            return(propertyGetters);
        }
Exemple #9
0
        public void PropertyObjectTypeConversion()
        {
            var          inst     = new PropertyTests();
            Type         instType = inst.GetType();
            PropertyInfo propRO   = instType.GetProperty("MyReadOnlyProperty");
            PropertyInfo propRW   = instType.GetProperty("MyProperty");

            Assert.IsNotNull(propRO);

            inst.MyWriteOnlyProperty = 999;

            PropertyGetter <PropertyTests, object> getter = propRO.CreatePropertyGetter <PropertyTests, object>();

            Assert.IsNotNull(getter);

            object actual = getter(inst);

            Assert.IsNotNull(actual);

            Assert.AreEqual("999", actual);

            PropertySetter <PropertyTests, object> setter = propRW.CreatePropertySetter <PropertyTests, object>();

            Assert.IsNotNull(setter);

            setter(inst, 123);

            Assert.AreEqual(123, inst.MyProperty);
        }
        internal static IDictionary <string, PropertyGetter> GetTypePropertyGetters(Type type)
        {
            IDictionary <string, PropertyGetter> getters = new Dictionary <string, PropertyGetter>();

            PropertyInfo[] props = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
            foreach (PropertyInfo p in props)
            {
                if (!p.CanWrite)
                {
                    continue;
                }

                object[] att = p.GetCustomAttributes(typeof(JsonIgnoreAttribute), false);
                if (att != null && att.Length > 0)
                {
                    continue;
                }

                PropertyGetter g = CreatePeropertyGetter(p);
                if (g != null)
                {
                    getters.Add(p.Name, g);
                }
            }

            return(getters);
        }
        public void Fixture_Thing2()
        {
            var getter = new PropertyGetter();


            var fixture = new Fixture_Thing2()
            {
                Thing1 = new Fixture_Thing()
                {
                    A = "123",
                    B = 1,
                    C = null
                },
                D = 123,
                E = 1234L
            };

            var value = getter.Get(fixture, "Thing1.A");

            value.Should().Be("123");

            value = getter.Get(fixture, "Thing1.B");
            value.Should().Be(1);

            value = getter.Get(fixture, "Thing1.C");
            value.Should().BeNull();

            value = getter.Get(fixture, "D");
            value.Should().Be(123);

            value = getter.Get(fixture, "E");
            value.Should().Be(1234L);
        }
        /// <summary>
        /// Factory method to create an <see cref="IValidationRule"/> based on this attribute.
        /// </summary>
        public IValidationRule CreateRule(PropertyInfo property, IResourceResolver resourceResolver)
        {
            PropertyGetter getter        = CreatePropertyGetter(property);
            string         customMessage = GetLocalizedCustomMessage(resourceResolver);

            return(CreateRule(property, getter, customMessage));
        }
		/// <summary>
		/// Factory method to create an <see cref="IValidationRule"/> based on this attribute.
		/// </summary>
		/// <param name="property">The property on which the attribute is applied.</param>
		/// <param name="getter">A delegate that, when invoked, returns the current value of the property.</param>
		/// <param name="customMessage">A custom message to be displayed, or null if none was supplied.</param>
		/// <returns></returns>
		protected override IValidationRule CreateRule(PropertyInfo property, PropertyGetter getter, string customMessage)
		{
			CheckPropertyIsType(property, typeof(IComparable));
			if (_referenceProperty != null)
			{
				// check that reference property is same type as validating property
				PropertyInfo refProp = property.DeclaringType.GetProperty(_referenceProperty);
				if (refProp.PropertyType != property.PropertyType)
					throw new ValidationAttributeException(SR.ExceptionReferencePropertyMustBeOfSameType);

				PropertyGetter refPropGetter = CreatePropertyGetter(refProp);
				return new ValidationRule(property.Name,
					delegate(IApplicationComponent c)
					{
						IComparable value = (IComparable)getter(c);
						object refValue = refPropGetter(c);
						return new ValidationResult(Compare(value, refValue, _inclusive), customMessage ?? GetDefaultMessage(refValue));
					});
			}
			else
			{
				// check that reference value is same type as validating property
				if (_referenceValue.GetType() != property.PropertyType)
					throw new ValidationAttributeException(SR.ExceptionReferenceValueMustBeOfSameType);

				// compare against fixed reference value
				return new ValidationRule(property.Name,
					delegate(IApplicationComponent c)
					{
						IComparable value = (IComparable)getter(c);
						return new ValidationResult(Compare(value, _referenceValue, _inclusive), customMessage ?? GetDefaultMessage(_referenceValue));
					});
			}
		}
Exemple #14
0
        public static void GetDelegates(object obj, string displayName, out PropertyGetter <T> getter, out PropertySetter <T> setter)
        {
            var inspector = new PropertyDelegateInspector <T>(obj, displayName);

            getter = inspector.Getter;
            setter = inspector.Setter;
        }
        /// <summary>
        /// Factory method to create an <see cref="IValidationRule"/> based on this attribute.
        /// </summary>
        /// <param name="property">The property on which the attribute is applied.</param>
        /// <param name="getter">A delegate that, when invoked, returns the current value of the property.</param>
        /// <param name="customMessage">A custom message to be displayed, or null if none was supplied.</param>
        /// <returns></returns>
        protected override IValidationRule CreateRule(PropertyInfo property, PropertyGetter getter, string customMessage)
        {
            CheckPropertyIsType(property, typeof(string));
            string message = customMessage;

            if (message == null)
            {
                if (_maxLength == -1)
                {
                    message = string.Format(SR.FormatMoreThanXCharactersRequired, _minLength);
                }
                else
                {
                    message = string.Format(SR.FormatRangeCharactersRequired, _minLength, _maxLength);
                }
            }

            return(new ValidationRule(property.Name,
                                      delegate(IApplicationComponent component)
            {
                // convert null string to ""
                string value = ((string)getter(component)) ?? "";
                return new ValidationResult(value.Length >= _minLength && (_maxLength == -1 || value.Length <= _maxLength), message);
            }));
        }
Exemple #16
0
 public AProperty(string name, PropertyGetter <T> getter, PropertySetter <T> setter)
 {
     Dirty  = false;
     Name   = name;
     Getter = getter;
     Setter = setter;
 }
        public void PropertyGetter2Works()
        {
            var foo      = new Foo("abc");
            var property = typeof(Foo).GetProperty(nameof(Foo.Bar));

            var getter = new PropertyGetter <Foo, string>(property);

            getter.Func.Target.Should().BeSameAs(getter);
            getter.Func.Method.Name.Should().Be(nameof(getter.GetValueReflection));
            getter.Func.Method.DeclaringType.Should().Be(typeof(PropertyGetter <Foo, string>));

            var    reflectionTimer = Stopwatch.StartNew();
            string reflectionValue = getter.GetValue(foo);

            reflectionTimer.Stop();

            getter.SetOptimizedFunc();

            getter.Func.Target.Should().NotBeSameAs(getter);
            getter.Func.Method.Name.Should().Be(PropertyGetter.GetValueOptimized);
            getter.Func.Method.DeclaringType.Should().NotBe(typeof(PropertyGetter <Foo, string>));

            var    optimizedTimer = Stopwatch.StartNew();
            string optimizedValue = getter.GetValue(foo);

            optimizedTimer.Stop();

            optimizedValue.Should().Be(reflectionValue);
            optimizedTimer.Elapsed.Should().BeLessThan(reflectionTimer.Elapsed);
        }
Exemple #18
0
 public PropertyEnumeration Get(PropertyGetter getter)
 {
     foreach (Amendment.Property property in this)
     {
         property.GetterMethod = getter.Method;
     }
     return(this);
 }
Exemple #19
0
        public void ValueTypePropertyGetterObjectTest(string propertyName)
        {
            PropertyGetter <TestStruct, object> getInt32 = DynamicType <TestStruct> .CreatePropertyGetter <object>(propertyName);

            TestStruct obj = TestStruct.Default;

            Assert.IsTrue(getInt32(obj).GetType() == typeof(object));
        }
        public void Fixture_IndexInvalid(object fixture, string path)
        {
            var getter = new PropertyGetter();

            Action a = () => getter.Get(fixture, path);

            a.Should().Throw <ArgumentException>();
        }
 public CustomerService(ICustomerRepository customerRepository, IPurchaseRepository purchaseRepository,
                        IProductRepository productRepository, IConfiguration config)
 {
     _customerRepository = customerRepository;
     _purchaseRepository = purchaseRepository;
     _productRepository  = productRepository;
     _propertyGetter     = new PropertyGetter(config.GetConnectionString("ChainStoreDBVer2"));
 }
Exemple #22
0
        public void ValueTypePropertyGetterStringTest(string propertyName, object expected)
        {
            PropertyGetter <TestStruct, string> getInt32 = DynamicType <TestStruct> .CreatePropertyGetter <string>(propertyName);

            TestStruct obj = TestStruct.Default;

            Assert.AreEqual(expected, getInt32(obj));
        }
        public void Fixture_Dictionary(object fixture, string path, object expected)
        {
            var getter = new PropertyGetter();

            var result = getter.Get(fixture, path);

            result.Should().Be(expected);
        }
Exemple #24
0
        public void PropertyGetterIntTest(string propertyName, object expected)
        {
            PropertyGetter <TestClass, int> getInt32 = DynamicType <TestClass> .CreatePropertyGetter <int>(propertyName);

            TestClass obj = new TestClass();

            Assert.AreEqual(expected, getInt32(obj));
        }
        public void Fixture_Enumerable_WithSeperator(object fixture, string path, object expected)
        {
            var getter = new PropertyGetter("__");

            var result = getter.Get(fixture, path);

            result.Should().Be(expected);
        }
Exemple #26
0
        public void PropertyGetterObjectTest(string propertyName)
        {
            PropertyGetter <TestClass, object> getInt32 = DynamicType <TestClass> .CreatePropertyGetter <object>(propertyName);

            TestClass obj = new TestClass();

            Assert.IsTrue(getInt32(obj).GetType() == typeof(object));
        }
Exemple #27
0
        public void ReferenceTypePropertyGetterGetHashCode()
        {
            TestClass obj = new TestClass();

            PropertyGetter <TestClass, int> getHashCode = DynamicType <TestClass> .CreatePropertyGetterGetHashCode("PublicPhone");

            Assert.AreEqual(obj.PublicPhone.GetHashCode(), getHashCode(obj));
        }
Exemple #28
0
        public void ValueTypePropertyGetterGetHashCode()
        {
            PropertyGetter <TestStruct, int> getHashCode = DynamicType <TestStruct> .CreatePropertyGetterGetHashCode("PublicPhone");

            TestStruct testStruct = TestStruct.Default;

            Assert.AreEqual(testStruct.PublicPhone.GetHashCode(), getHashCode(testStruct));
        }
Exemple #29
0
        public void ReferenceTypePropertyGetterAsObject(string propertyName, object expected)
        {
            PropertyGetter <TestClass, object> getObject = DynamicType <TestClass> .CreatePropertyGetterAsObject(propertyName);

            TestClass obj = new TestClass();

            Assert.AreEqual(expected, getObject(obj));
        }
Exemple #30
0
        public void ValueTypePropertyGetterAsObject(string propertyName, object expected)
        {
            PropertyGetter <TestStruct, object> getObject = DynamicType <TestStruct> .CreatePropertyGetterAsObject(propertyName);

            TestStruct testStruct = TestStruct.Default;

            Assert.AreEqual(expected, getObject(testStruct));
        }
Exemple #31
0
        public void PropertyGetterStringTest(string propertyName, object expected)
        {
            PropertyGetter <TestClass, string> getString = DynamicType <TestClass> .CreatePropertyGetter <string>(propertyName);

            TestClass obj = new TestClass();

            Assert.AreEqual(expected, getString(obj));
        }
		/// <summary>
		/// Factory method to create an <see cref="IValidationRule"/> based on this attribute.
		/// </summary>
		/// <param name="property">The property on which the attribute is applied.</param>
		/// <param name="getter">A delegate that, when invoked, returns the current value of the property.</param>
		/// <param name="customMessage">A custom message to be displayed, or null if none was supplied.</param>
		/// <returns></returns>
		protected override IValidationRule CreateRule(PropertyInfo property, PropertyGetter getter, string customMessage)
		{
			string message = customMessage ?? SR.MessageValueRequired;
			return new ValidationRule(property.Name,
			   delegate(IApplicationComponent component)
			   {
				   object value = getter(component);
				   return new ValidationResult((value is string) ? !string.IsNullOrEmpty(value as string) : value != null, message);
			   });
		}
 /// <summary>
 /// Constructs the property manager.
 /// </summary>
 /// <param name="platformType">The platform type to represent.</param>
 /// <param name="getter">Receives property get requests and returns mock values.</param>
 /// <param name="setter">Receives property set requests and checks them.</param>
 public MockPropertyManager(
     ProjectPlatformType platformType, PropertyGetter getter, PropertySetter setter)
 {
   this.PlatformType = platformType;
   if (platformType == ProjectPlatformType.NaCl)
     this.PlatformName = Strings.NaCl64PlatformName;
   else
     this.PlatformName = Strings.PepperPlatformName;
   getter_ = getter;
   setter_ = setter;
 }
Exemple #34
0
		/// <summary>
		/// Factory method to create an <see cref="IValidationRule"/> based on this attribute.
		/// </summary>
		/// <param name="property">The property on which the attribute is applied.</param>
		/// <param name="getter">A delegate that, when invoked, returns the current value of the property.</param>
		/// <param name="customMessage">A custom message to be displayed, or null if none was supplied.</param>
		/// <returns></returns>
		protected override IValidationRule CreateRule(PropertyInfo property, PropertyGetter getter, string customMessage)
		{
			CheckPropertyIsType(property, typeof(string));
			string message = customMessage ?? SR.MessageUnrecognizedFormat;

			return new ValidationRule(property.Name,
				delegate(IApplicationComponent component)
				{
					string value = (string)getter(component);
					if (_allowNull && string.IsNullOrEmpty(value))
						return new ValidationResult(true, "");
					else
						return new ValidationResult(Regex.Match(value ?? "", _pattern).Success == SuccessOnMatch, message);
				});
		}
		/// <summary>
		/// Factory method to create an <see cref="IValidationRule"/> based on this attribute.
		/// </summary>
		/// <param name="property">The property on which the attribute is applied.</param>
		/// <param name="getter">A delegate that, when invoked, returns the current value of the property.</param>
		/// <param name="customMessage">A custom message to be displayed, or null if none was supplied.</param>
		/// <returns></returns>
		protected override IValidationRule CreateRule(PropertyInfo property, PropertyGetter getter, string customMessage)
		{
			CheckPropertyIsType(property, typeof(string));
			string message = customMessage;
			if (message == null)
			{
				if (_maxLength == -1)
					message = string.Format(SR.FormatMoreThanXCharactersRequired, _minLength);
				else
					message = string.Format(SR.FormatRangeCharactersRequired, _minLength, _maxLength);
			}

			return new ValidationRule(property.Name,
			   delegate(IApplicationComponent component)
			   {
				   // convert null string to ""
				   string value = ((string)getter(component)) ?? "";
				   return new ValidationResult(value.Length >= _minLength && (_maxLength == -1 || value.Length <= _maxLength), message);
			   });
		}
Exemple #36
0
        /// <summary>
        /// 생성자
        /// </summary>
        public SqlCommandSet() {
            if(IsDebugEnabled)
                log.Debug("{0}를 동적으로 생성하고, 내부 함수를 Delegate로 이용하여, 노출시킵니다.", SqlCommandSetTypeName);

            _sqlCommandSetInstance = ActivatorTool.CreateInstance(_sqlCommandSetType, true);

            _sqlCommandSetInstance.ShouldNotBeNull(SqlCommandSetTypeName);

            _connectionSettter =
                (PropertySetter<SqlConnection>)CreateDelegate(typeof(PropertySetter<SqlConnection>),
                                                              _sqlCommandSetInstance,
                                                              "set_Connection");
            _transactionSetter =
                (PropertySetter<SqlTransaction>)CreateDelegate(typeof(PropertySetter<SqlTransaction>),
                                                               _sqlCommandSetInstance,
                                                               "set_Transaction");
            _commandTimeoutSetter =
                (PropertySetter<int>)CreateDelegate(typeof(PropertySetter<int>),
                                                    _sqlCommandSetInstance,
                                                    "set_CommandTimeout");

            _connectionGetter =
                (PropertyGetter<SqlConnection>)CreateDelegate(typeof(PropertyGetter<SqlConnection>),
                                                              _sqlCommandSetInstance,
                                                              "get_Connection");

            _batchCommandGetter =
                (PropertyGetter<SqlCommand>)CreateDelegate(typeof(PropertyGetter<SqlCommand>),
                                                           _sqlCommandSetInstance,
                                                           "get_BatchCommand");

            _doAppend = (AppendCommand)CreateDelegate(typeof(AppendCommand), _sqlCommandSetInstance, "Append");
            _doExecuteNonQuery =
                (ExecuteNonQueryCommand)CreateDelegate(typeof(ExecuteNonQueryCommand), _sqlCommandSetInstance, "ExecuteNonQuery");
            _doDispose = (DisposeCommand)CreateDelegate(typeof(DisposeCommand), _sqlCommandSetInstance, "Dispose");
        }
        /// <summary>
        /// Collects a property of a tool across across multiple property sheets
        /// with inheritance (i.e. respecting $(Inherit) and $(NoInherit) macros).
        /// </summary>
        /// <param name="configuration">The project configuration.</param>
        /// <param name="toolName">The name of the tool, e.g. "VCCLCompilerTool".</param>
        /// <param name="propGetter">The getter that retrieves the property.</param>
        /// <remarks>
        /// This method tries to emulate Visual Studio, since the Extensibility API
        /// doesn't seem to provide anything like this.
        /// </remarks>
        public static List<string> Get(VCConfiguration configuration, string toolName, PropertyGetter propGetter)
        {
            ArgData data = new ArgData();
            data.conf = configuration;
            data.sheets = Utils.call(() => (data.conf.PropertySheets as IVCCollection));
            data.numSheets = Utils.call(() => (data.sheets.Count));
            data.toolName = toolName;
            data.propGetter = propGetter;
            data.result = new List<string>();

            _Get(data, 0);

            return data.result;
        }
		/// <summary>
		/// Factory method to create an <see cref="IValidationRule"/> based on this attribute.
		/// </summary>
		/// <param name="property">The property on which the attribute is applied.</param>
		/// <param name="getter">A delegate that, when invoked, returns the current value of the property.</param>
		/// <param name="customMessage">A custom message to be displayed, or null if none was supplied.</param>
		/// <returns></returns>
		protected abstract IValidationRule CreateRule(PropertyInfo property, PropertyGetter getter, string customMessage);