C# Mapping.MappingManager類代碼示例

 public void AddAndGet()
 {
     var mgr = new MappingManager();
     mgr.Add(typeof (Entity).GetProperty("Id"), "id");
     var fields = mgr.GetFields(typeof (Entity));
     Assert.AreEqual(1, fields.Count);
 }

 private static MappingManager MakeMapper(Type t)
 {
     // See https://github.com/mausch/SolrNet/blob/master/Documentation/Overriding-mapper.md
     var mapper = new MappingManager();
     foreach (var prop in t.GetProperties())
     {
         foreach (Attribute attribute in prop.GetCustomAttributes(true))
         {
             if (attribute is FieldAttribute)
             {
                 var fa = attribute as FieldAttribute;
                 string fieldName = string.IsNullOrWhiteSpace(fa.FieldName) ? prop.Name : fa.FieldName;
                 mapper.Add(prop, fieldName, fa.Boost);
             }
             else if (attribute is SolrFieldAttribute)
             {
                 var fa = attribute as SolrFieldAttribute;
                 string fieldName = string.IsNullOrWhiteSpace(fa.FieldName) ? prop.Name : fa.FieldName;
                 mapper.Add(prop, fieldName, fa.Boost);
             }
             if (attribute is UniqueKeyAttribute)
             {
                 var uka = attribute as UniqueKeyAttribute;
                 mapper.SetUniqueKey(prop);
             }
             if (attribute is SolrUniqueKeyAttribute)
             {
                 var uka = attribute as SolrUniqueKeyAttribute;
                 mapper.SetUniqueKey(prop);
             }
         }
     }
     return mapper;
 }

        private static void SetupSolr() {
            var connection = new SolrConnection(_httpSolrTest);
            Startup.InitContainer();

            Startup.Container.Remove<IReadOnlyMappingManager>();

            var mapper = new MappingManager();
            Mappings(mapper);
            Startup.Container.Register<IReadOnlyMappingManager>(c => mapper);

            Startup.Container.Remove<ISolrDocumentPropertyVisitor>();
            var propertyVisitor = new DefaultDocumentVisitor(mapper, Startup.Container.GetInstance<ISolrFieldParser>());
            Startup.Container.Register<ISolrDocumentPropertyVisitor>(c => propertyVisitor);

            Startup.Init<Child>(connection);
            Startup.Init<Parent>(connection);
            Startup.Init<Dictionary<string,object>>(connection);
            Startup.Container.RemoveAll<ISolrDocumentResponseParser<Dictionary<string, object>>>();
            Startup.Container.Register<ISolrDocumentResponseParser<Dictionary<string, object>>>(c => new SolrDictionaryDocumentResponseParser(c.GetInstance<ISolrFieldParser>()));

            var solr = ServiceLocator.Current.GetInstance<ISolrOperations<Child>>();

            solr.Delete(SolrQuery.All);
            solr.Commit();
        }

 public void MappingTypesAreCompatibleWithSolrTypesRule_with_nonexistant_rule()
 {
     var rule = new MappingTypesAreCompatibleWithSolrTypesRule(new[] {new StringSolrFieldTypeChecker()});
     var mappingManager = new MappingManager();
     mappingManager.Add(typeof (SchemaMappingTestDocument).GetProperty("Name"));
     var validations = rule.Validate(typeof (SchemaMappingTestDocument), new SolrSchema(), mappingManager).ToList();
 }

 public void Add_duplicate_property_overwrites() {
     var mgr = new MappingManager();
     mgr.Add(typeof (Entity).GetProperty("Id"), "id");
     mgr.Add(typeof (Entity).GetProperty("Id"), "id2");
     var fields = mgr.GetFields(typeof (Entity));
     Assert.AreEqual(1, fields.Count);
     Assert.AreEqual("id2", fields.First().Value.FieldName);
 }

        public void ValidatingRuleSetReturnsValidationResults() {
            var mappingManager = new MappingManager();
            var mappingValidationManager = new MappingValidator(mappingManager, new[] {new DummyValidationRuleError()});

            var validationResults = mappingValidationManager.EnumerateValidationResults(typeof(SchemaMappingTestDocument), new SolrSchema()).ToList();

            Assert.AreEqual(1, validationResults.Count);
        }

 public void Add_property_only() {
     var mgr = new MappingManager();
     var property = typeof (Entity).GetProperty("Id");
     mgr.Add(property);
     var fields = mgr.GetFields(typeof (Entity));
     Assert.AreEqual(1, fields.Count);
     Assert.AreEqual("Id", fields.First().Value.FieldName);
 }

 public void MappedPropertiesIsInSolrSchemaRule_ignores_score()
 {
     var rule = new MappedPropertiesIsInSolrSchemaRule();
     var mapper = new MappingManager();
     mapper.Add(typeof (SchemaMappingTestDocument).GetProperty("Score"), "score");
     var results = rule.Validate(typeof (SchemaMappingTestDocument), new SolrSchema(), mapper).ToList();
     Assert.IsNotNull(results);
     Assert.AreEqual(0, results.Count);
 }

        public void UniqueKey_Set_and_get() {
            var mgr = new MappingManager();
            var property = typeof (Entity).GetProperty("Id");
            mgr.Add(property, "id");
            mgr.SetUniqueKey(property);
            var key = mgr.GetUniqueKey(typeof (Entity));

            Assert.AreEqual(property, key.Property);
            Assert.AreEqual("id", key.FieldName);
        }

 public void SwappingMappingManager2() {
     var mapper = new MappingManager();
     Startup.Container.Clear();
     Startup.InitContainer();
     Startup.Container.RemoveAll<IReadOnlyMappingManager>();
     Startup.Container.Register<IReadOnlyMappingManager>(c => mapper);
     ServiceLocator.SetLocatorProvider(() => Startup.Container);
     Startup.Init<Document>("http://localhost");
     var mapperFromFactory = ServiceLocator.Current.GetInstance<IReadOnlyMappingManager>();
     Assert.AreSame(mapper, mapperFromFactory);
 }

 public void DictionaryFields_are_ignored()
 {
     var rule = new MappedPropertiesIsInSolrSchemaRule();
     var mapper = new MappingManager();
     mapper.Add(typeof(SchemaMappingTestDocument).GetProperty("DynamicMapped"), "ma_*");
     var schema = new SolrSchema();
     var fieldType = new SolrFieldType("string", "solr.StrField");
     schema.SolrFields.Add(new SolrField("ma_uaua", fieldType));
     var results = rule.Validate(typeof(SchemaMappingTestDocument), new SolrSchema(), mapper).ToList();
     Assert.AreEqual(0, results.Count);
 }

        public void StringMappedToStringShouldNotReturnError() {
            var mappingTypesCompatibleRule = new MappingTypesAreCompatibleWithSolrTypesRule(new[] {new StringSolrFieldTypeChecker()});

            var mgr = new MappingManager();
            var schemaManager = new MappingValidator(mgr, new[] {mappingTypesCompatibleRule});

            var schemaXmlDocument = EmbeddedResource.GetEmbeddedXml(GetType(), "Resources.solrSchemaMappingTypes.xml");
            var solrSchemaParser = new SolrSchemaParser();
            var schema = solrSchemaParser.Parse(schemaXmlDocument);

            var validationResults = schemaManager.EnumerateValidationResults(typeof (SchemaMappingTestDocument), schema).ToList();
            Assert.AreEqual(0, validationResults.Count);
        }

        public void MultivaluedSolrFieldMappedToCollectionShouldNotReturnError() {
            var mgr = new MappingManager();
            mgr.Add(typeof (SchemaMappingTestDocument).GetProperty("NameCollection"), "name");

            var schemaManager = new MappingValidator(mgr, new[] {new MultivaluedMappedToCollectionRule()});

            var schemaXmlDocument = EmbeddedResource.GetEmbeddedXml(GetType(), "Resources.solrSchemaMultiValuedName.xml");
            var solrSchemaParser = new SolrSchemaParser();
            var schema = solrSchemaParser.Parse(schemaXmlDocument);

            var validationResults = schemaManager.EnumerateValidationResults(typeof (SchemaMappingTestDocument), schema).ToList();
            Assert.AreEqual(0, validationResults.Count);
        }

 public void SchemaNull_MappingNotNull_generates_error() {
     var rule = new UniqueKeyMatchesMappingRule();
     var mapper = new MappingManager();
     var idProperty = typeof (SchemaMappingTestDocument).GetProperty("ID");
     mapper.Add(idProperty);
     mapper.SetUniqueKey(idProperty);
     var validations = rule.Validate(typeof (SchemaMappingTestDocument), new SolrSchema(), mapper).ToList();
     Assert.IsNotNull(validations);
     Assert.AreEqual(1, validations.Count);
     foreach (var v in validations)
         Console.WriteLine("{0}: {1}", v.GetType(), v.Message);
     Assert.IsInstanceOfType<ValidationError>(validations[0]);
 }

        public void MatchingUniqueKeyMappingShouldNotReturnError() {
            var mgr = new MappingManager();
            mgr.Add(typeof (SchemaMappingTestDocument).GetProperty("ID"), "id");
            mgr.SetUniqueKey(typeof (SchemaMappingTestDocument).GetProperty("ID"));

            var schemaManager = new MappingValidator(mgr, new[] {new UniqueKeyMatchesMappingRule()});

            var schemaXmlDocument = EmbeddedResource.GetEmbeddedXml(GetType(), "Resources.solrSchemaBasic.xml");
            var solrSchemaParser = new SolrSchemaParser();
            var schema = solrSchemaParser.Parse(schemaXmlDocument);

            var validationResults = schemaManager.EnumerateValidationResults(typeof (SchemaMappingTestDocument), schema).ToList();
            Assert.AreEqual(0, validationResults.Count);
        }