C# PropertyInfo类代码示例

 public void ShouldGenerateNameWithPropForList()
 {
     var info = new PropertyInfo(new ClassInfo { XmlName = "someClass" });
     info.XmlName = "someClass";
     info.IsList = true;
     Assert.That(info.GetCodeName(), Is.EqualTo("SomeClassProps"));
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="LocalizedPropertyStringLengthRule"/> class.
        /// </summary>
        /// <param name="primaryProperty">
        /// The primary property.
        /// </param>
        /// <param name="mainProperty">
        /// The main property.
        /// </param>
        /// <param name="maxLength">
        /// The max length.
        /// </param>
        /// <param name="propertyDisplayName">
        /// The property display name.
        /// </param>
        /// <param name="resourceManager">
        /// The resource manager.
        /// </param>
        /// <param name="localizationName">
        /// The localization name.
        /// </param>
        /// <exception cref="ArgumentNullException">
        /// The <paramref name="primaryProperty"/> parameter is null.
        /// </exception>
        /// <exception cref="ArgumentOutOfRangeException">
        /// The <paramref name="maxLength"/> is less than zero.
        /// </exception>
        public LocalizedPropertyStringLengthRule(
            PropertyInfo<string> primaryProperty,
            PropertyInfo<string> mainProperty,
            int maxLength,
            string propertyDisplayName,
            ResourceManager resourceManager,
            string localizationName)
            : base(primaryProperty)
        {
            if (primaryProperty == null)
                throw new ArgumentNullException("primaryProperty");

            if (maxLength < 0)
                throw new ArgumentOutOfRangeException("maxLength");

            _primaryProperty = primaryProperty;
            _maxLength = maxLength;
            _propertyDisplayName = propertyDisplayName;
            _resourceManager = resourceManager;
            _mainProperty = mainProperty;
            _localizationName = localizationName;

            InputProperties = InputProperties ?? new List<IPropertyInfo>();
            InputProperties.Add(primaryProperty);

            if (_mainProperty != null)
                AffectedProperties.Add(_mainProperty);
        }

    public static bool CanEdit(PropertyInfo property)
    {
        if (!property.CanRead)
        {
            return false;
        }

        var browsableAttribute = (BrowsableAttribute)Attribute.GetCustomAttribute(property, typeof(BrowsableAttribute), false);
        if (browsableAttribute != null && !browsableAttribute.Browsable)
        {
            return false;
        }

        var designerSerializationVisibilityAttribute = (DesignerSerializationVisibilityAttribute)Attribute.GetCustomAttribute(property, typeof(DesignerSerializationVisibilityAttribute), false);
        if (designerSerializationVisibilityAttribute != null && designerSerializationVisibilityAttribute.Visibility == DesignerSerializationVisibility.Hidden)
        {
            return false;
        }

        if (!property.CanWrite && !typeof(System.Collections.IList).IsAssignableFrom(property.PropertyType))
        {
            return false;
        }

        return true;
    }

 public void ShouldGenerateNameForListWithSAtTheEnd()
 {
     var info = new PropertyInfo(new ClassInfo { XmlName = "someClass" });
     info.XmlName = "tests";
     info.IsList = true;
     Assert.That(info.GetCodeName(), Is.EqualTo("Tests"));
 }

        private static string ConvertToPropertyString(string entityName, PropertyInfo property)
        {
            string typeName = ConvertTypeName(property);

            var propertyString = string.Format(
            @"public static readonly Property<{0}> {1}Property = P<{2}>.Register(e => e.{1});
            ",
            typeName, property.Name, entityName);
            if (!string.IsNullOrEmpty(property.Comment))
            {
                propertyString += string.Format(
            @"/// <summary>
            /// {0}
            /// </summary>
            ", property.Comment);
            }
            propertyString += string.Format(
            @"public {0} {1}
            {{
            get {{ return this.GetProperty({1}Property); }}
            set {{ this.SetProperty({1}Property, value); }}
            }}", typeName, property.Name);

            return propertyString;
        }

 void ProcessRes(PropertyInfo pi)
 {
     var obj = pi.GetValue(null, null);
     var type = obj.GetType();
     if(type == typeof(string))
     {
         var item = new RString();
         item.name = pi.Name;
         item.value = obj as string;
         listString.Add(item);
     }
     else if (type == typeof(Texture2D))
     {
         var item = new RTexture();
         item.name = pi.Name;
         item.value = obj as Texture2D;
         listTexture.Add(item);
     }
     else
     {
         var item = new RUnknown();
         item.name = pi.Name;
         item.type = type.Name;
         item.value = obj.ToString();
         listUnknown.Add(item);
     }
 }

        public Class Parse(String json, String className)
        {
            Class result = new Class(AccessModifier.Public, className);

            var oo = JsonConvert.DeserializeObject(json);
            var c = new ClassInfo(className);
            if (oo is JArray)
            {
                foreach (var jo in (JArray)oo)
                {
                    if (jo is JObject)
                    {
                        SetProperties(c, (JObject)jo);
                    }
                    else if (jo is JValue)
                    {
                        var pi = new PropertyInfo();
                        pi.Validate(jo);
                        return new Class(AccessModifier.Public, pi.GetCSharpTypeName());
                    }
                }
            }
            else if (oo is JObject)
            {
                SetProperties(c, (JObject)oo);
            }
            SetProperties(result, c);

            return result;
        }

 public PropertyAccessor(PropertyInfo propertyInfo)
     : base(propertyInfo)
 {
     _hasSetter = (propertyInfo.GetSetMethod(true) != null);
     if (_hasSetter)
         _lateBoundPropertySet = DelegateFactory.CreateSet(propertyInfo);
 }

        private static string ConvertTypeName(PropertyInfo property)
        {
            Type type = property.Type;
            if (type == typeof(decimal))
            {
                type = typeof(double);
            }

            string typeName = type.Name;
            if (type != typeof(string))
            {
                if (type == typeof(int))
                {
                    typeName = "int";
                }
                else if (type == typeof(double))
                {
                    typeName = "double";
                }
                else if (type == typeof(bool))
                {
                    typeName = "bool";
                }
                typeName += "?";
            }
            else
            {
                typeName = "string";
            }
            return typeName;
        }

 public void boolField(object pObject, PropertyInfo pPropertyInfo)
 {
     bool lValue = (bool)pPropertyInfo.GetValue(pObject, null);
     content.text="";
     bool lNewValue = GUILayout.Toggle(lValue, content);
     if(lValue!=lNewValue)
         pPropertyInfo.SetValue(pObject, lNewValue, null);
 }

 public PropertyOperation(PropertyInfo propertyInfo)
 {
     if (propertyInfo == null)
     {
         throw new ArgumentNullException("pi");
     }
     this.propertyInfo = propertyInfo;
 }

 public ValueTypePropertyAccessor(PropertyInfo propertyInfo)
     : base(propertyInfo)
 {
     var setMethod = propertyInfo.GetSetMethod(true);
     _hasSetter = (setMethod != null);
     if (_hasSetter)
         _lateBoundPropertySet = setMethod;
 }

 public override Property Eval(Property[] args, PropertyInfo pInfo)
 {
     string propName = args[0].GetString();
     if (propName == null)
     {
         throw new PropertyException("Incorrect parameter to inherited-property-value function");
     }
     return pInfo.getPropertyList().GetInheritedProperty(propName);
 }

    /// <summary>
    /// Initializes a new instance of the <see cref="Tween"/> class.
    /// </summary>
    /// <param name='targetObj'>
    /// The objet to perform the Tween on.
    /// </param>
    /// <param name='propertyName'>
    /// Property name, eg. "X", "Y", "ScaleX", "Alpha", etc.
    /// </param>
    /// <param name='endVal'>
    /// The value to tween to.  The tween will run from the property's value at start time to the end value.
    /// </param>
    /// <param name='duration'>
    /// Duration in seconds of the tween.
    /// </param>
    /// <param name='easingType'>
    /// Easing type.  Any function matching the see cref="EaseValue"/> delegate.  
    /// </param>
    /// <param name='delay'>
    /// Delay, in seconds.
    /// </param>
    /// <param name='startCallback'>
    /// Called when tween starts (after any delay).  
    /// </param>
    /// <param name='endCallback'>
    /// Called when tween ends
    /// </param>
    /// <exception cref='Exception'>
    /// Thrown when a Tween is created before Stage
    /// </exception>
    /// <exception cref='ArgumentException'>
    /// Thrown when targetObj param is null or targetObj does not have property referenced by propertyName arg.
    /// </exception>
    public Tween(DisplayObjectContainer targetObj, string propertyName, float endVal, float duration, EaseValue easingType, float delay = 0f, TweenCallback startCallback = null, TweenCallback endCallback = null)
    {
        if (TweenRunner.Instance == null)
            throw new Exception("TweenRunner must be added to Stage before creating Tweens");

        if (targetObj == null)
            throw new ArgumentException("targetObj is null");

        Id = Guid.NewGuid();
        TargetObj = targetObj;
        if (!String.IsNullOrEmpty(propertyName))
        {
            Property = targetObj.GetType().GetProperty(propertyName);
            if (Property == null)
                throw new ArgumentException("targetObj does not have property named " + propertyName);
        }
        //StartVal gets set when tween actually starts running, since the value may change during a delay
        EndVal = endVal;
        StartTime = TweenRunner.Instance.__GetCurrentTime();
        Duration = duration;
        EasingType = easingType;
        Delay = delay;
        StartCallback = startCallback;
        EndCallback = endCallback;

        if (!String.IsNullOrEmpty(propertyName))
            TweenRunner.Instance.__AddTween(this);
    }

	static Reports_RMLauncher()
	{
		_sendEmailMaint = System.Web.Compilation.BuildManager.GetType(_SENDEMAILMAINT_TYPE, false);
		_sendEmailMethod = null;
		MemberInfo[] search = null;
		if (_sendEmailMaint != null)
		{
			_sendEmailMethod = _sendEmailMaint.GetMethod(_SENDEMAIL_METHOD, BindingFlags.Static | BindingFlags.InvokeMethod | BindingFlags.Public);
			search = _sendEmailMaint.GetMember(_SENDEMAILPARAMS_TYPE);
		}
		Type sendEmailParams = search != null && search.Length > 0 && search[0] is Type ? (Type)search[0] : null;
		if (sendEmailParams != null)
		{
			_sendEmailParamsCtor = sendEmailParams.GetConstructor(new Type[0]);
			_fromMethod = sendEmailParams.GetProperty("From");
			_toMethod = sendEmailParams.GetProperty("To");
			_ccMethod = sendEmailParams.GetProperty("Cc");
			_bccMethod = sendEmailParams.GetProperty("Bcc");
			_subjectMethod = sendEmailParams.GetProperty("Subject");
			_bodyMethod = sendEmailParams.GetProperty("Body");
			_activitySourceMethod = sendEmailParams.GetProperty("Source");
			_parentSourceMethod = sendEmailParams.GetProperty("ParentSource");
			_templateIDMethod = sendEmailParams.GetProperty("TemplateID");
			_attachmentsMethod = sendEmailParams.GetProperty("Attachments");
		}

		_canSendEmail = _sendEmailParamsCtor != null && _sendEmailMaint != null && _sendEmailMethod != null &&
			_fromMethod != null && _toMethod != null && _ccMethod != null && _bccMethod != null && 
			_subjectMethod != null && _bodyMethod != null &&
			_activitySourceMethod != null && _parentSourceMethod != null && _templateIDMethod != null && _attachmentsMethod != null;
	}