C# Documents.Field类代码示例

        protected override Document BuildLuceneDocument(Document document)
        {
            Field.Store storeContent = Field.Store.YES;
            #if DEBUG
            storeContent = Field.Store.YES;
            #endif
            var fieldTitle = new Field("title", photo.Title, storeContent, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS);
            document.Add(fieldTitle);

            var fieldTitleSort = new Field("title_sort", photo.Title, storeContent, Field.Index.NOT_ANALYZED_NO_NORMS);
            document.Add(fieldTitleSort);

            var fieldAuthor = new Field("owner", photo.Owner ?? String.Empty, storeContent, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS);
            document.Add(fieldAuthor);

            var ownerId = new Field("owner_id", photo.OwnerId.ToString(), storeContent, Field.Index.NOT_ANALYZED_NO_NORMS);
            document.Add(ownerId);

            var fieldAuthorIndex = new Field("owner_index", photo.Owner ?? String.Empty, Field.Store.NO, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS);
            document.Add(fieldAuthorIndex);

            var fieldDescription = new Field("description", photo.Description ?? String.Empty, storeContent, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS);
            document.Add(fieldDescription);

            return document;
        }

        public static IndexWriter CreateIndex(Content[] contents)
        {
            var v = Lucene.Net.Util.Version.LUCENE_30;
            var l = Lucene.Net.Index.IndexWriter.MaxFieldLength.UNLIMITED;
            var d = FSDirectory.Open(new DirectoryInfo(IndexPath));

            IndexWriter writer = new IndexWriter(d, new StandardAnalyzer(v), l);

            try
            {
                foreach (var item in contents)
                {
                    Document doc = new Document();

                    Field id = new Field("id", item.Id.ToString(), Field.Store.YES, Field.Index.NOT_ANALYZED);
                    Field title = new Field("title", item.Title, Field.Store.YES, Field.Index.ANALYZED);
                    Field username = new Field("username", item.User.UserName, Field.Store.YES, Field.Index.ANALYZED);
                    doc.Add(id);
                    doc.Add(title);
                    doc.Add(username);
                    writer.AddDocument(doc);
                }
                writer.Optimize();
                writer.Dispose();
            }
            catch (System.Exception ex)
            {

            }

            return writer;
        }

        internal static void AddField(this Document doc, string propertyName, string propertyValue, Field.Store fieldStore, Field.Index fieldIndex)
        {
            if (string.IsNullOrWhiteSpace(propertyValue))
                return;

            doc.Add(new Field(propertyName, propertyValue, fieldStore, fieldIndex));
        }

		public static Field.Index GetIndex(this IndexDefinition self, string name, Field.Index? defaultIndex)
		{
			if (self.Indexes == null)
				return defaultIndex ?? Field.Index.ANALYZED_NO_NORMS;
			FieldIndexing value;
			if (self.Indexes.TryGetValue(name, out value) == false)
			{
				if (self.Indexes.TryGetValue(Constants.AllFields, out value) == false)
				{
					string ignored;
					if (self.Analyzers.TryGetValue(name, out ignored) ||
						self.Analyzers.TryGetValue(Constants.AllFields, out ignored))
					{
						return Field.Index.ANALYZED; // if there is a custom analyzer, the value should be analyzed
					}
					return defaultIndex ?? Field.Index.ANALYZED_NO_NORMS;
				}
			}
			switch (value)
			{
				case FieldIndexing.No:
					return Field.Index.NO;
				case FieldIndexing.Analyzed:
					return Field.Index.ANALYZED_NO_NORMS;
				case FieldIndexing.NotAnalyzed:
					return Field.Index.NOT_ANALYZED_NO_NORMS;
				case FieldIndexing.Default:
					return defaultIndex ?? Field.Index.ANALYZED_NO_NORMS;
				default:
					throw new ArgumentOutOfRangeException();
			}
		}

		public virtual void  TestMultiValueSource()
		{
			Directory dir = new MockRAMDirectory();
			IndexWriter w = new IndexWriter(dir, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED);
			Document doc = new Document();
			Field f = new Field("field", "", Field.Store.NO, Field.Index.NOT_ANALYZED);
			doc.Add(f);
			
			for (int i = 0; i < 17; i++)
			{
				f.SetValue("" + i);
				w.AddDocument(doc);
				w.Commit();
			}
			
			IndexReader r = w.GetReader();
			w.Close();
			
			Assert.IsTrue(r.GetSequentialSubReaders().Length > 1);
			
			ValueSource s1 = new IntFieldSource("field");
			DocValues v1 = s1.GetValues(r);
			DocValues v2 = new MultiValueSource(s1).GetValues(r);
			
			for (int i = 0; i < r.MaxDoc(); i++)
			{
				Assert.AreEqual(v1.IntVal(i), i);
				Assert.AreEqual(v2.IntVal(i), i);
			}
			
			Lucene.Net.Search.FieldCache_Fields.DEFAULT.PurgeAllCaches();
			
			r.Close();
			dir.Close();
		}

        public Document ToDocument()
        {
            var document = new Document();

            var hash = new Field(ExtensionHashField, ModelHelpers.GetMD5Hash(ToString()), Field.Store.NO, Field.Index.ANALYZED, Field.TermVector.NO);
            hash.Boost = ExtensionHashFieldBoost;
            var name = new Field(ExtensionNameField, Name, Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.NO);
            name.Boost = ExtensionNameFieldBoost;
            var fullName = new Field(ExtensionFullNameField, FullName, Field.Store.YES, Field.Index.NO, Field.TermVector.NO);
            var ns = new Field(ExtensionNamespaceField, Namespace, Field.Store.YES, Field.Index.NO, Field.TermVector.NO);
            var assemblyName = new Field(ExtensionAssemblyNameField, AssemblyName, Field.Store.YES, Field.Index.NO, Field.TermVector.NO);
            var packageName = new Field(ExtensionPackageNameField, PackageName, Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.NO);
            var packageVersion = new Field(ExtensionPackageVersionField, PackageVersion, Field.Store.YES, Field.Index.NO, Field.TermVector.NO);
            var targetFrameworks = new Field(ExtensionTargetFrameworksField, GetTargetFrameworksString(), Field.Store.YES, Field.Index.NO, Field.TermVector.NO);

            document.Add(hash);
            document.Add(name);
            document.Add(fullName);
            document.Add(ns);
            document.Add(assemblyName);
            document.Add(packageName);
            document.Add(packageVersion);
            document.Add(targetFrameworks);

            return document;
        }

 /// <summary>
 /// Кастомизация индекса
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void InsertExternalFields(object sender, Examine.LuceneEngine.DocumentWritingEventArgs e)
 {
     if (!e.Fields.ContainsKey("criteria")) return;
     var criteriaString = e.Fields["criteria"];
     var xCriteriaField = new Field("xCriteria", criteriaString.Replace(',', ' '), Field.Store.YES, Field.Index.ANALYZED_NO_NORMS, Field.TermVector.NO);
     e.Document.Add(xCriteriaField);
 }

		public IEnumerable<AbstractField> Index(RavenJObject document, Field.Store defaultStorage)
		{
			return from property in document
				   where property.Key != Constants.DocumentIdFieldName
				   from field in CreateFields(property.Key, GetPropertyValue(property.Value), defaultStorage)
			       select field;
		}

        public static Field CreateInstance(object data, XmlNode node)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }

            if (node == null)
            {
                throw new ArgumentNullException("node");
            }

            String name = node.Attributes["name"].Value.ToLower();
            String datasource = node.Attributes["datasource"].Value;
            String store = node.Attributes["store"].Value;
            String index = node.Attributes["index"].Value;

            Lucene.Net.Documents.Field.Store st;
            Enum.TryParse<Lucene.Net.Documents.Field.Store>(store,out st);

            Lucene.Net.Documents.Field.Index idx ;
            Enum.TryParse<Lucene.Net.Documents.Field.Index>(index,out idx);

            String value = getData(data,datasource);

            //name = name.ToLower();
            Field ret = new Field(name,value,st,idx);

            return ret;
        }

        public void TestReadersWriters()
        {
            Directory dir;
            
            using(dir = new RAMDirectory())
            {
                Document doc;
                IndexWriter writer;
                IndexReader reader;

                using (writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED))
                {
                    Field field = new Field("name", "value", Field.Store.YES,Field.Index.ANALYZED);
                    doc = new Document();
                    doc.Add(field);
                    writer.AddDocument(doc);
                    writer.Commit();

                    using (reader = writer.GetReader())
                    {
                        IndexReader r1 = reader.Reopen();
                    }

                    Assert.Throws<AlreadyClosedException>(() => reader.Reopen(), "IndexReader shouldn't be open here");
                }
                
                Assert.Throws<AlreadyClosedException>(() => writer.AddDocument(doc), "IndexWriter shouldn't be open here");

                Assert.IsTrue(dir.isOpen_ForNUnit, "RAMDirectory");
            }
            Assert.IsFalse(dir.isOpen_ForNUnit, "RAMDirectory");
        }

        public void Save(SearchDocument doc)
        {
            if (doc == null) throw new ArgumentNullException(nameof(doc));

            if (doc.Fields == null || doc.Fields.Count == 0)
                return;

            var document = new Document();
            foreach (var docField in doc.Fields)
            {
                if (string.IsNullOrWhiteSpace(docField.FieldName))
                    throw new Exception("Field name cannot be empty");

                if (string.IsNullOrWhiteSpace(docField.Value))
                    continue;

                var field = new Field(docField.FieldName, docField.Value, Field.Store.YES, Field.Index.ANALYZED);
                document.Add(field);
            }

            var writer = new IndexWriter(
                _directory,
                new StandardAnalyzer(global::Lucene.Net.Util.Version.LUCENE_30),
                !_created,
                IndexWriter.MaxFieldLength.UNLIMITED);

            using (writer)
            {
                writer.AddDocument(document);
            }

            _created = true;
        }

        /// <summary>
        /// Adds a field to the index, bit more configurable than the other helper methods, but more verbose as a consequence.
        /// </summary>
        /// <param name="document">The document to add the field to </param>
        /// <param name="fieldName">The name of the field to add</param>
        /// <param name="value">The value of the field</param>
        /// <param name="store">A boolean denoting whether to store the value in the index - allows retrieval of the original value from the index</param>
        /// <param name="caseSensitive">Whether to store the value in its original case</param>
        /// <param name="index">The type of indexing to apply to the field</param>
        /// <returns>The input document object</returns>
        public static Document AddField(this Document document, string fieldName, string value, bool caseSensitive, Field.Store store, Field.Index index)
        {
            if (value == null)
            {
                return document;
            }

            if (store == null)
            {
                store = Field.Store.NO;
            }

            if (!caseSensitive)
            {
                value = value.ToLower();
            }

            if (index == null)
            {
                index = Field.Index.ANALYZED;
            }

            Field field = new Field(fieldName, value, store, index);
            document.Add(field);
            return document;
        }

        protected override Document BuildLuceneDocument(Document document)
        {
            Field.Store storeContent = Field.Store.YES;
            #if DEBUG
            storeContent = Field.Store.YES;
            #endif

            var name = new Field("author_name", author.Name, storeContent, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS);
            document.Add(name);

            var fieldNameSort = new Field("author_sort", author.Name, storeContent, Field.Index.NOT_ANALYZED_NO_NORMS);
            document.Add(fieldNameSort);

            var fieldName = new Field("author_firstName", author.FirstName, storeContent, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS);
            document.Add(fieldName);

            var lastName = new Field("author_lastName", author.LastName, storeContent, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS);
            document.Add(lastName);

            var fieldBiography = new Field("biography", author.Biography ?? String.Empty, storeContent, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS);
            document.Add(fieldBiography);

            var fieldAuthorId = new Field("author_id", author.ElanId.ToString(), storeContent, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS);
            document.Add(fieldAuthorId);

            return document;
        }

        public void Set(string name, object value, Document document, Field.Store store, Field.Index index, float? boost)
        {
            DateTime date = (DateTime) value;

            int year = date.Year;
            int month = date.Month;
            int day = date.Day;

            // set year
            Field field = new Field(name + ".year", year.ToString(), store, index);
            if (boost != null)
            {
                field.SetBoost(boost.Value);
            }
            document.Add(field);

            // set month and pad it if necessary
            field = new Field(name + ".month", month.ToString("D2"), store, index);
            if (boost != null)
            {
                field.SetBoost(boost.Value);
            }
            document.Add(field);

            // set day and pad it if necessary
            field = new Field(name + ".day", day.ToString("D2"), store, index);
            if (boost != null)
            {
                field.SetBoost(boost.Value);
            }
            document.Add(field);

            throw new NotImplementedException();
        }

        public void CreateIndex()
        {
            IProductService productService = new ProductService();
            int count = productService.GetProductCount(string.Empty);
            var data = productService.GetProducts(count, 1, string.Empty);

            //设置为多文件索引的格式，默认情况下为true，会建立复合索引的文件结构，这里为了分析，先设置为false，生成多文件的索引结构
            //this.indexWriter.SetUseCompoundFile(false);

            foreach (var productInfo in data)
            {
                var doc = new Document();
                var field1 = new Field("title", productInfo.Title, Field.Store.YES, Field.Index.ANALYZED);
                // 向文档中添加域
                doc.Add(field1);
                field1 = new Field("Category", productInfo.CategoryName, Field.Store.YES, Field.Index.ANALYZED);
                doc.Add(field1);
                field1 = new Field("Desc", productInfo.Desc??"", Field.Store.YES, Field.Index.ANALYZED);
                doc.Add(field1);
                this.indexWriter.AddDocument(doc);
            }

            // 优化索引结构
            this.indexWriter.Optimize();

            this.indexWriter.Commit();
            // 关闭写入
            this.indexWriter.Close();
        }