public void DataContractFieldReader(FieldFunctionInfo ffi, object[] customAttributes)
        {
            if (customAttributes.Any(o => o is IgnoreDataMemberAttribute))
            {
                ffi.Ignore = true;
                return;
            }

            ffi.Function = DefaultFunctionType(ffi.ResultType);

            var dmAttr = customAttributes.Select(o => o as DataMemberAttribute).FirstOrDefault(a => a != null);

            if (dmAttr != null && !string.IsNullOrWhiteSpace(dmAttr.Name))
                ffi.Name = dmAttr.Name;

            if(dmAttr != null)
                ffi.Required = dmAttr.IsRequired;
        }
        private Expression MakeFieldReader(FieldFunctionInfo ffi)
        {
            switch (ffi.Function)
            {
                case FieldFunctionType.Primitive:
                {
                    var mi = ffi.Required ? BuildToolkit.RequiredPrimitiveFieldMI : BuildToolkit.OptionalPrimitiveFieldMI;
                    mi = mi.MakeGenericMethod(ffi.ResultType);
                    return Expression.Call(null, mi, Expression.Constant(ffi.Name), _pCfgNode);
                }

                case FieldFunctionType.Array:
                {
                    var itemType = ffi.ResultType.GetElementType();
                    var mi = BuildToolkit.ArrayMI.MakeGenericMethod(itemType);
                    return Expression.Call(null, mi, Expression.Constant(ffi.Name), _pCfgNode, Expression.Constant(_deserializer));
                };

                case FieldFunctionType.Collection:
                {
                    var itemType = ffi.ResultType.GetGenericArguments()[0];
                    var mi = BuildToolkit.ListMI.MakeGenericMethod(itemType);
                    return Expression.Call(null, mi, Expression.Constant(ffi.Name), _pCfgNode, Expression.Constant(_deserializer));
                };

                case FieldFunctionType.Complex:
                {
                    var mi = ffi.Required ? BuildToolkit.RequiredComplexFieldMI : BuildToolkit.OptionalComplexFieldMI;
                    mi = mi.MakeGenericMethod(ffi.ResultType);
                    return Expression.Call(null, mi, Expression.Constant(ffi.Name), _pCfgNode, Expression.Constant(_deserializer));
                };

                default:
                    throw new InvalidOperationException("unexpected FieldFunctionType");
            }
        }
        public void XmlFieldReader(FieldFunctionInfo ffi, object[] customAttributes)
        {
            if (customAttributes.Any(o => o is XmlIgnoreAttribute))
            {
                ffi.Ignore = true;
                return;
            }

            ffi.Function = DefaultFunctionType(ffi.ResultType);

            var attrAttr = customAttributes.Select(o => o as XmlAttributeAttribute).FirstOrDefault(a => a != null);
            var elAttr = customAttributes.Select(o => o as XmlElementAttribute).FirstOrDefault(a => a != null);

            if (attrAttr != null && elAttr != null)
                throw new ArgumentOutOfRangeException(string.Format("found XmlAttributeAttribute and XmlElementAttribute for member '{0}'", ffi.Name));

            if (attrAttr != null && !string.IsNullOrWhiteSpace(attrAttr.AttributeName))
                ffi.Name = attrAttr.AttributeName;

            if (elAttr != null && !string.IsNullOrWhiteSpace(elAttr.ElementName))
                ffi.Name = elAttr.ElementName;
        }
 public void NativeNameFieldReader(FieldFunctionInfo ffi, object[] customAttributes)
 {
     ffi.Function = DefaultFunctionType(ffi.ResultType);
 }
 private Expression CreateFunction(Type fieldType, string fieldName, object[] customAttributes)
 {
     var ffi = new FieldFunctionInfo(fieldType, fieldName);
     _configureFieldInfo(ffi, customAttributes);
     return ffi.Ignore ? null : MakeFieldReader(ffi);
 }