C# FieldInfo.GetCustomAttributesData方法代码示例

        public virtual IEnumerable<string> GetAttributesTextFor(FieldInfo field, Usage defaultUsage, ParsingPolicyAttribute[] parsingPolicies)
        {
            var result = new List<string>();
            var fieldType = field.FieldType;
            string usageAttribute = null;
            bool isForcedUsage = defaultUsage == Usage.ForceRequired || defaultUsage == Usage.ForceOptional;
            if (isForcedUsage)
            {
                if (defaultUsage == Usage.ForceRequired) usageAttribute = AttributeBuilder.GetTextFor<RequiredAttribute>();
                else if (defaultUsage == Usage.ForceOptional) usageAttribute = AttributeBuilder.GetTextFor<OptionalAttribute>();
            }
            else if (fieldType.IsValueType && Nullable.GetUnderlyingType(field.FieldType) == null)
            {
                usageAttribute = AttributeBuilder.GetTextFor<RequiredAttribute>();
            }
            else if (Nullable.GetUnderlyingType(field.FieldType) != null)
            {
                usageAttribute = AttributeBuilder.GetTextFor<OptionalAttribute>();
            }
            else if (!field.IsDefined<RequiredAttribute>() && !field.IsDefined<OptionalAttribute>())
            {
                if (defaultUsage == Usage.Required) usageAttribute = AttributeBuilder.GetTextFor<RequiredAttribute>();
                else if (defaultUsage == Usage.Optional) usageAttribute = AttributeBuilder.GetTextFor<OptionalAttribute>();
            }
            if (usageAttribute != null)
                result.Add(usageAttribute);

            var attributes = field.GetCustomAttributes().ToArray();
            var attributesData = field.GetCustomAttributesData();
            for (int i = 0; i < attributes.Length; i++)
            {
                // Skip any usage attributes, if field usage is forced by the calling method.
                bool isUsageAttribute = attributes[i] is OptionalAttribute || attributes[i] is RequiredAttribute;
                if (isForcedUsage && isUsageAttribute) continue;
                // Get c# compatible attribute text.
                string attributeText = CommonAttributeTranslator.Translate(attributes[i], attributesData[i], field);
                if (attributeText != null)
                    result.Add(attributeText);
            }
            return result;
        }

        private int _getStringLength(FieldInfo fieldInfo)
        {
            try
            {
                int length = 0;
                foreach (Attribute attr in fieldInfo.GetCustomAttributes(false))
                {
                    if (attr is MaxLengthAttribute)
                    {

                        var attributeData = fieldInfo.GetCustomAttributesData();
                        CustomAttributeData cd = attributeData[0];
                        length = (int)cd.ConstructorArguments[0].Value;
                    }

                }
                return length;
            }
            catch (Exception)
            {
                throw;
            }
        }

        static private void AppendFieldInfo(FieldInfo field, StringBuilder sb)
        {
            sb.Append(".field ");

            foreach (var attribute in field.GetCustomAttributesData())
            {
                AppendCustomAttributeData(attribute, sb);
                sb.Append(" ");
            }
            foreach (var modreq in field.GetRequiredCustomModifiers())
            {
                sb.Append("modreq(");
                AppendType(modreq, sb);
                sb.Append(") ");
            }
            foreach (var modopt in field.GetOptionalCustomModifiers())
            {
                sb.Append("modopt(");
                AppendType(modopt, sb);
                sb.Append(") ");
            }

            if (field.IsPrivate) sb.Append("private ");
            if (field.IsPublic) sb.Append("public ");
            if (field.IsFamily) sb.Append("family ");
            if (field.IsAssembly) sb.Append("assembly ");
            if (field.IsFamilyOrAssembly) sb.Append("famorassem ");
            if (field.IsFamilyAndAssembly) sb.Append("famandassem ");

            if (field.IsInitOnly) sb.Append("initonly ");
            if (field.IsLiteral) sb.Append("literal ");
            if (field.IsNotSerialized) sb.Append("notserialized ");
            if (field.Attributes.HasFlag(FieldAttributes.SpecialName)) sb.Append("specialname ");
            if (field.Attributes.HasFlag(FieldAttributes.RTSpecialName)) sb.Append("rtspecialname ");
            if (field.IsPinvokeImpl) sb.Append("pinvokeimpl ");

            sb.Append(field.IsStatic ? "static " : "instance ");
            AppendType(field.FieldType, sb);
            sb.Append(" ");
            sb.Append(field.Name);

            if (field.IsLiteral)
            {
                AppendValue(field.GetRawConstantValue(), sb);
            }
        }

 public void EnrichField(IProcessingContext context, FieldInfo fieldInfo)
 {
     GenerateAttributeElements(context, fieldInfo.GetCustomAttributesData());
 }

        public void validateAttribute(Attribute attr, FieldInfo fInfo)
        {
            try
            {
                object obj = fInfo.GetValue(this);

                if (attr is RequiredAttribute)
                {
                    if (obj == null)
                        throw new Exception("RequiredAttribute exception. Required Fields must not equal to null");

                    if (obj.ToString().Length == 0 )
                        throw new Exception("RequiredAttribute exception. string lengths  must not equal to zero");

                }

                if (attr is MaxLengthAttribute)
                {
                    var attributeData = fInfo.GetCustomAttributesData();
                    CustomAttributeData cd = attributeData[0];
                    int uzunluk = (int)cd.ConstructorArguments[0].Value;

                    string objString = (string)obj;

                    if (objString.Length > uzunluk)
                        throw new Exception("MaxLengthAttribute exception.");
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        /// <summary>
        /// Convert simple type object to TreeNode
        /// </summary>
        /// <param name="obj">The object which need to convert</param>
        /// <param name="parentobj">The parent object of the object which need to convert</param>
        /// <param name="Info">The field Info of the object in parent object</param>
        /// <param name="startIndex">The start index of this object in message stream</param>
        /// <param name="offset">The offset of this object</param>
        /// <returns>The TreeNode with object value information</returns>
        public static TreeNode SimpleTypeObjectToNode(object obj, object parentobj, FieldInfo Info, ref int startIndex, out int offset)
        {
            int os = 0;
            TreeNode tn = new TreeNode(string.Format("{0}:{1}", Info.Name, obj.ToString()));
            Type type = obj.GetType();
            if (Info.GetCustomAttributesData().Count != 0 && Info.GetCustomAttributes(typeof(BitAttribute), false) != null)
            {
                Type parentType = parentobj.GetType();
                FieldInfo[] FieldsInparent = parentType.GetFields();
                List<int> FieldsWithBitAttribute = new List<int>();
                foreach (FieldInfo f in FieldsInparent)
                {
                    if (f.GetCustomAttributesData().Count != 0 && f.GetCustomAttributes(typeof(BitAttribute), false) != null)
                    {
                        BitAttribute attribute = (BitAttribute)f.GetCustomAttributes(typeof(BitAttribute), false)[0];
                        FieldsWithBitAttribute.Add(attribute.BitLength);

                        if (f == Info)
                            break;
                    }
                }
                int FieldsBitLength = FieldsWithBitAttribute.Sum();
                int[] Fields = FieldsWithBitAttribute.ToArray();

                int n = FieldsBitLength / 8;
                int r = FieldsBitLength % 8;
                int thisFieldBitLength = Fields[Fields.Length - 1];
                int thisn = thisFieldBitLength / 8;
                int forntEleSum = FieldsBitLength - thisFieldBitLength; // This value indicate the fields sum before this field.
                for (int i = FieldsWithBitAttribute.Count - 2; i > 0; i--) // This loop is used to update n and r, if there are fields sum is xompleted bytes, so n and r should subtract the byte length.
                {
                    forntEleSum -= Fields[i];
                    if (forntEleSum % 8 == 0)
                    {
                        n = (FieldsBitLength - forntEleSum) / 8;
                        r = (FieldsBitLength - forntEleSum) % 8;
                    }
                }
                if (FieldsWithBitAttribute.Count != 1 && (FieldsBitLength - thisFieldBitLength) % 8 != 0)
                {
                    startIndex -= 1;
                }
                if (thisn < n)
                {
                    if ((FieldsBitLength - thisFieldBitLength) % 8 == 0)// This is for bit field which is start from a new byte, but is not the first bit filed in parent field.
                    {
                        os += (thisn + 1);
                    }
                    else
                    {
                        if (r != 0)
                            os += (thisn + 2);
                        else
                            os += (thisn + 1);
                    }
                }
                else
                {
                    os += (thisn + 1);
                }
            }
            else
            {
                if (type.Name == "String")
                {
                    os = ((string)obj).Length * 2;
                }
                else if (type.Name != "Boolean")
                {
                    os = Marshal.SizeOf(type);
                }
                else
                {
                    os = sizeof(Boolean);
                }
            }

            Position ps = new Position(startIndex, os);
            tn.Tag = ps;
            startIndex += os;
            offset = os;
            return tn;
        }