C# BsonClassMap.MapMember方法代码示例

 public void TestConvention(BsonType value)
 {
     var convention = new EnumRepresentationConvention(value);
     var classMap = new BsonClassMap<TestClass>();
     var nonEnumMemberMap = classMap.MapMember(x => x.NonEnum);
     var defaultEnumMemberMap = classMap.MapMember(x => x.DefaultEnum);
     var changedEnumMemberMap = classMap.MapMember(x => x.ChangedRepresentationEnum);
     convention.Apply(nonEnumMemberMap);
     convention.Apply(changedEnumMemberMap);
     Assert.AreEqual(value, ((IRepresentationConfigurable)(changedEnumMemberMap.GetSerializer())).Representation);
 }

 public void TestCamelCaseElementNameConvention()
 {
     var convention = new CamelCaseElementNameConvention();
     var classMap = new BsonClassMap<TestClass>();
     convention.Apply(classMap.MapMember(x => x.FirstName));
     convention.Apply(classMap.MapMember(x => x.Age));
     convention.Apply(classMap.MapMember(x => x._DumbName));
     convention.Apply(classMap.MapMember(x => x.lowerCase));
     Assert.AreEqual("firstName", classMap.GetMemberMap(x => x.FirstName).ElementName);
     Assert.AreEqual("age", classMap.GetMemberMap(x => x.Age).ElementName);
     Assert.AreEqual("_DumbName", classMap.GetMemberMap(x => x._DumbName).ElementName);
     Assert.AreEqual("lowerCase", classMap.GetMemberMap(x => x.lowerCase).ElementName);
 }

 public void TestConvention(BsonType value)
 {
     var convention = new EnumRepresentationConvention(value);
     var classMap = new BsonClassMap<TestClass>();
     var nonEnumMemberMap = classMap.MapMember(x => x.NonEnum);
     var defaultEnumMemberMap = classMap.MapMember(x => x.DefaultEnum);
     var changedEnumMemberMap = classMap.MapMember(x => x.ChangedRepresentationEnum);
     convention.Apply(nonEnumMemberMap);
     convention.Apply(changedEnumMemberMap);
     Assert.IsNull(nonEnumMemberMap.SerializationOptions);
     Assert.IsNull(defaultEnumMemberMap.SerializationOptions);
     Assert.AreEqual(value, ((RepresentationSerializationOptions)changedEnumMemberMap.SerializationOptions).Representation);
 }

        public void TestShouldDowncaseOnlyFirstCharByDefault()
        {
            var convention = new CamelCaseElementNameConvention();
            var classMap = new BsonClassMap<TestClass>();
            var firstName = classMap.MapMember(x => x.FirstName);
            var age = classMap.MapMember(x => x.Age);
            var allCaps = classMap.MapMember(x => x.ALLCAPS);

            convention.Apply(firstName);
            convention.Apply(age);
            convention.Apply(allCaps);

            Assert.AreEqual("firstName", firstName.ElementName);
            Assert.AreEqual("age", age.ElementName);
            Assert.AreEqual("aLLCAPS", allCaps.ElementName);
        }

 public void TestConventionOverride()
 {
     var int64Convention = new EnumRepresentationConvention(BsonType.Int64);
     var strConvention = new EnumRepresentationConvention(BsonType.String);
     var classMap = new BsonClassMap<TestClass>();
     var memberMap = classMap.MapMember(x => x.ChangedRepresentationEnum);
     int64Convention.Apply(memberMap);
     strConvention.Apply(memberMap);
     Assert.AreEqual(BsonType.String, ((IRepresentationConfigurable)(memberMap.GetSerializer())).Representation);
 }

        public void TestApply(bool value)
        {
            var subject = new IgnoreIfDefaultConvention(value);
            var classMap = new BsonClassMap<TestClass>();
            var memberMap = classMap.MapMember(x => x.Id);

            subject.Apply(memberMap);

            Assert.AreEqual(value, memberMap.IgnoreIfDefault);
        }

        public void TestCamelCaseElementNameConvention()
        {
            var convention = new CamelCaseElementNameConvention();
            var classMap = new BsonClassMap<TestClass>();
            var firstName = classMap.MapMember(x => x.FirstName);
            var age = classMap.MapMember(x => x.Age);
            var _dumbName = classMap.MapMember(x => x._DumbName);
            var lowerCase = classMap.MapMember(x => x.lowerCase);

            convention.Apply(firstName);
            convention.Apply(age);
            convention.Apply(_dumbName);
            convention.Apply(lowerCase);

            Assert.AreEqual("firstName", firstName.ElementName);
            Assert.AreEqual("age", age.ElementName);
            Assert.AreEqual("_DumbName", _dumbName.ElementName);
            Assert.AreEqual("lowerCase", lowerCase.ElementName);
        }

        public void TestShouldHandleNameStartingWithNonLetter()
        {
            var convention = new CamelCaseElementNameConvention();
            var classMap = new BsonClassMap<TestClass>();
            var _dumbName = classMap.MapMember(x => x._dumbName);

            convention.Apply(_dumbName);

            Assert.AreEqual("_dumbName", _dumbName.ElementName);
        }

        public void TestShouldNotChangeIfAlreadyCamelCased()
        {
            var convention = new CamelCaseElementNameConvention();
            var classMap = new BsonClassMap<TestClass>();
            var lowerCase = classMap.MapMember(x => x.camelCasedName);

            convention.Apply(lowerCase);

            Assert.AreEqual("camelCasedName", lowerCase.ElementName);
        }

        public void TestShouldDowncaseCertainNumberOfChars(int charsToDowncase, string expected)
        {
            var convention = new CamelCaseElementNameConvention(charsToDowncase);
            var classMap = new BsonClassMap<TestClass>();
            var ioStream = classMap.MapMember(x => x.ALLCAPS);

            convention.Apply(ioStream);

            Assert.AreEqual(expected, ioStream.ElementName);
        }

        public void Test()
        {
            var convention = new DelegateMemberMapConvention("test", m => m.SetElementName("blah"));

            Assert.AreEqual("test", convention.Name);

            var classMap = new BsonClassMap<TestClass>();
            var member = classMap.MapMember(x => x.FirstName);

            convention.Apply(member);

            Assert.AreEqual("blah", member.ElementName);
        }

        // private methods
        private void MapField(BsonClassMap classMap, FieldInfo fieldInfo)
        {
            if (fieldInfo.IsInitOnly || fieldInfo.IsLiteral)
            {
                // we can't write
                return;
            }

            classMap.MapMember(fieldInfo);
        }

        private void MapProperty(BsonClassMap classMap, PropertyInfo propertyInfo)
        {
            if (!propertyInfo.CanRead || (!propertyInfo.CanWrite && classMap.ClassType.Namespace != null))
            {
                // we can't write or it is anonymous...
                return;
            }

            // skip indexers
            if (propertyInfo.GetIndexParameters().Length != 0)
            {
                return;
            }

            // skip overridden properties (they are already included by the base class)
            var getMethodInfo = propertyInfo.GetGetMethod(true);
            if (getMethodInfo.IsVirtual && getMethodInfo.GetBaseDefinition().DeclaringType != classMap.ClassType)
            {
                return;
            }

            classMap.MapMember(propertyInfo);
        }

            private void OptInMembersWithBsonMemberMapModifierAttribute(BsonClassMap classMap)
            {
                // let other fields opt-in if they have any IBsonMemberMapAttribute attributes
                foreach (var fieldInfo in classMap.ClassType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly))
                {
                    var hasAttribute = fieldInfo.GetCustomAttributes(typeof(IBsonMemberMapAttribute), false).Any();
                    if (hasAttribute)
                    {
                        classMap.MapMember(fieldInfo);
                    }
                }

                // let other properties opt-in if they have any IBsonMemberMapAttribute attributes
                foreach (var propertyInfo in classMap.ClassType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly))
                {
                    var hasAttribute = propertyInfo.GetCustomAttributes(typeof(IBsonMemberMapAttribute), false).Any();
                    if (hasAttribute)
                    {
                        classMap.MapMember(propertyInfo);
                    }
                }
            }

 public void Apply(BsonClassMap classMap)
 {
     var members = _convention.FindMembers(classMap.ClassType);
     foreach (var member in members)
     {
         classMap.MapMember(member);
     }
 }