internal static Analyzer GetAnalyzer()
{
//var masterAnalyzer = new PerFieldAnalyzerWrapper(new KeywordAnalyzer());
////TODO: Lucene_FullText2 is failed with new WhitespaceAnalyzer
////masterAnalyzer.AddAnalyzer(LucObject.FieldName.AllText, new WhitespaceAnalyzer());
//masterAnalyzer.AddAnalyzer(LucObject.FieldName.AllText, new StandardAnalyzer());
//return masterAnalyzer;
// Field Analyzer
// -----------------------------------------------------------------
// Name Lucene.Net.Analysis.KeywordAnalyzer
// Path Lucene.Net.Analysis.KeywordAnalyzer
// Keywords Lucene.Net.Analysis.StopAnalyzer
// _Text Lucene.Net.Analysis.Standard.StandardAnalyzer
// -----------------------------------------------------------------
// Default Lucene.Net.Analysis.WhitespaceAnalyzer
var masterAnalyzer = new PerFieldAnalyzerWrapper(new KeywordAnalyzer());
foreach (var item in SenseNet.ContentRepository.Storage.StorageContext.Search.SearchEngine.GetAnalyzers())
{
masterAnalyzer.AddAnalyzer(item.Key, (Analyzer)Activator.CreateInstance(item.Value));
}
masterAnalyzer.AddAnalyzer(LucObject.FieldName.AllText, new StandardAnalyzer());
//masterAnalyzer.AddAnalyzer(LucObject.FieldName.AllText, new StandardAnalyzer(SenseNet.Search.Indexing.LuceneManager.LuceneVersion));
return(masterAnalyzer);
}
private void CreateIndexer()
{
ServiceLocator.Resolve <UIPackage>();
ServiceLocator.RegisterInstance(new IndexFilterManager());
PerFieldAnalyzerWrapper analyzer = new PerFieldAnalyzerWrapper(new SnowballAnalyzer("English"));
analyzer.AddAnalyzer(SandoField.Source.ToString(), new KeywordAnalyzer());
analyzer.AddAnalyzer(SandoField.AccessLevel.ToString(), new KeywordAnalyzer());
analyzer.AddAnalyzer(SandoField.ProgramElementType.ToString(), new KeywordAnalyzer());
ServiceLocator.RegisterInstance <Analyzer>(analyzer);
var currentIndexer = new DocumentIndexer(TimeSpan.FromSeconds(10), GetTimeToCommit());
ServiceLocator.RegisterInstance(currentIndexer);
ServiceLocator.RegisterInstance(new IndexUpdateManager());
currentIndexer.ClearIndex();
ServiceLocator.Resolve <InitialIndexingWatcher>().InitialIndexingStarted();
var dictionary = new DictionaryBasedSplitter();
dictionary.Initialize(PathManager.Instance.GetIndexPath(ServiceLocator.Resolve <SolutionKey>()));
var reformer = new QueryReformerManager(dictionary);
reformer.Initialize(null);
ServiceLocator.RegisterInstance(reformer);
var history = new SearchHistory();
history.Initialize(PathManager.Instance.GetIndexPath
(ServiceLocator.Resolve <SolutionKey>()));
ServiceLocator.RegisterInstance(history);
}
protected override Analyzer GetAnalyzer(Net.Util.Version version)
{
analyzer = new PerFieldAnalyzerWrapper(base.GetAnalyzer(version));
analyzer.AddAnalyzer <SampleDocument>(t => t.Id, new KeywordAnalyzer());
analyzer.AddAnalyzer <SampleDocument>(t => t.Key, new LowercaseKeywordAnalyzer());
return(analyzer);
}
private void configureBexisIndexing(bool recreateIndex)
{
configXML = new XmlDocument();
configXML.Load(FileHelper.ConfigFilePath);
LoadBeforeIndexing();
pathIndex = FSDirectory.Open(new DirectoryInfo(luceneIndexPath));
autoCompleteIndex = FSDirectory.Open(new DirectoryInfo(autoCompleteIndexPath));
using (var bexisAnalyzer = new BexisAnalyzer())
using (var nGramAnalyzer = new NGramAnalyzer())
using (PerFieldAnalyzerWrapper analyzer = new PerFieldAnalyzerWrapper(bexisAnalyzer))
{
indexWriter = new IndexWriter(pathIndex, analyzer, recreateIndex, IndexWriter.MaxFieldLength.UNLIMITED);
autoCompleteIndexWriter = new IndexWriter(autoCompleteIndex, nGramAnalyzer, recreateIndex, IndexWriter.MaxFieldLength.UNLIMITED);
foreach (XmlNode a in categoryXmlNodeList)
{
analyzer.AddAnalyzer("ng_" + a.Attributes.GetNamedItem("lucene_name").Value, nGramAnalyzer);
}
analyzer.AddAnalyzer("ng_all", nGramAnalyzer);
isIndexConfigured = true;
}
}
protected override Analyzer GetAnalyzer(Net.Util.Version version)
{
var analyzer = new PerFieldAnalyzerWrapper(base.GetAnalyzer(version));
analyzer.AddAnalyzer("Path", new CaseInsensitiveKeywordAnalyzer());
analyzer.AddAnalyzer("Key", new KeywordAnalyzer());
return(analyzer);
}
public bool Open()
{
_writer = new IndexWriter(_index_path, new StandardAnalyzer(), _create_index);
_default_analyzer = new PerFieldAnalyzerWrapper(new StandardAnalyzer());
_default_analyzer.AddAnalyzer("contents", new SourceCodeAnalyzer());
_default_analyzer.AddAnalyzer("path2", new PathAnalyzer());
return(true);
}
protected override Analyzer GetAnalyzer(Net.Util.Version version)
{
var a = new PerFieldAnalyzerWrapper(base.GetAnalyzer(version));
a.AddAnalyzer("Version", new KeywordAnalyzer());
a.AddAnalyzer("Flag", new KeywordAnalyzer());
return(a);
}
public PerFieldAnalyzerWrapper CreateAnalyzer(Analyzer defaultAnalyzer, ICollection <Action> toDispose, bool forQuerying = false)
{
toDispose.Add(defaultAnalyzer.Close);
//string value;
//if (indexDefinition.Analyzers.TryGetValue(Constants.AllFields, out value))
//{
// defaultAnalyzer = IndexingExtensions.CreateAnalyzerInstance(Constants.AllFields, value);
// toDispose.Add(defaultAnalyzer.Close);
//}
var perFieldAnalyzerWrapper = new PerFieldAnalyzerWrapper(defaultAnalyzer);
foreach (var analyzer in indexDefinition.Analyzers)
{
//Analyzer analyzerInstance = IndexingExtensions.CreateAnalyzerInstance(analyzer.Key, analyzer.Value);
//toDispose.Add(analyzerInstance.Close);
//if (forQuerying)
//{
// var customAttributes = analyzerInstance.GetType().GetCustomAttributes(typeof(NotForQueryingAttribute), false);
// if (customAttributes.Length > 0)
// continue;
//}
//perFieldAnalyzerWrapper.AddAnalyzer(analyzer.Key, analyzerInstance);
}
StandardAnalyzer standardAnalyzer = null;
KeywordAnalyzer keywordAnalyzer = null;
foreach (var fieldIndexing in indexDefinition.Indexes)
{
switch (fieldIndexing.Value)
{
case FieldIndexing.NotAnalyzed:
if (keywordAnalyzer == null)
{
keywordAnalyzer = new KeywordAnalyzer();
toDispose.Add(keywordAnalyzer.Close);
}
perFieldAnalyzerWrapper.AddAnalyzer(fieldIndexing.Key, keywordAnalyzer);
break;
case FieldIndexing.Analyzed:
if (indexDefinition.Analyzers.ContainsKey(fieldIndexing.Key))
{
continue; // already added
}
if (standardAnalyzer == null)
{
standardAnalyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
toDispose.Add(standardAnalyzer.Close);
}
perFieldAnalyzerWrapper.AddAnalyzer(fieldIndexing.Key, standardAnalyzer);
break;
}
}
return(perFieldAnalyzerWrapper);
}
private Analyzer GetAnalyzer()
{
PerFieldAnalyzerWrapper analyzer = new PerFieldAnalyzerWrapper(new SnowballAnalyzer("English"));
analyzer.AddAnalyzer(SandoField.Source.ToString(), new KeywordAnalyzer());
analyzer.AddAnalyzer(SandoField.AccessLevel.ToString(), new KeywordAnalyzer());
analyzer.AddAnalyzer(SandoField.ProgramElementType.ToString(), new KeywordAnalyzer());
return(analyzer);
}
private Analyzer CreateAnalyzerWrapper()
{
Analyzer analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
PerFieldAnalyzerWrapper analyzerWrapper = new PerFieldAnalyzerWrapper(analyzer);
analyzerWrapper.AddAnalyzer("Name", new PanGuAnalyzer());
analyzerWrapper.AddAnalyzer("Age", new PanGuAnalyzer());
return(analyzerWrapper);
}
public PerFieldAnalyzerWrapper CreateAnalyzer(Analyzer defaultAnalyzer, ICollection <Action> toDispose, bool forQuerying = false)
{
toDispose.Add(defaultAnalyzer.Close);
var perFieldAnalyzerWrapper = new PerFieldAnalyzerWrapper(defaultAnalyzer);
foreach (var analyzer in indexDefinition.Analyzers)
{
Analyzer analyzerInstance = IndexingExtensions.CreateAnalyzerInstance(analyzer.Key, analyzer.Value);
if (analyzerInstance == null)
{
continue;
}
toDispose.Add(analyzerInstance.Close);
if (forQuerying)
{
var customAttributes = analyzerInstance.GetType().GetCustomAttributes(typeof(NotForQueryingAttribute), false);
if (customAttributes.Length > 0)
{
continue;
}
}
perFieldAnalyzerWrapper.AddAnalyzer(analyzer.Key, analyzerInstance);
}
StandardAnalyzer standardAnalyzer = null;
KeywordAnalyzer keywordAnalyzer = null;
foreach (var fieldIndexing in indexDefinition.Indexes)
{
switch (fieldIndexing.Value)
{
case FieldIndexing.NotAnalyzed:
if (keywordAnalyzer == null)
{
keywordAnalyzer = new KeywordAnalyzer();
toDispose.Add(keywordAnalyzer.Close);
}
perFieldAnalyzerWrapper.AddAnalyzer(fieldIndexing.Key, keywordAnalyzer);
break;
case FieldIndexing.Analyzed:
if (indexDefinition.Analyzers.ContainsKey(fieldIndexing.Key))
{
continue;
}
if (standardAnalyzer == null)
{
standardAnalyzer = new StandardAnalyzer(Version.LUCENE_29);
toDispose.Add(standardAnalyzer.Close);
}
perFieldAnalyzerWrapper.AddAnalyzer(fieldIndexing.Key, standardAnalyzer);
break;
}
}
return(perFieldAnalyzerWrapper);
}
private Analyzer GetAnalyzer()
{
var analyzer = new PerFieldAnalyzerWrapper(_defaultAnalyzer);
analyzer.AddAnalyzer(LogicalNameFieldName, new KeywordAnalyzer());
analyzer.AddAnalyzer(PrimaryKeyFieldName, new KeywordAnalyzer());
analyzer.AddAnalyzer(PrimaryKeyLogicalNameFieldName, new KeywordAnalyzer());
return(analyzer);
}
/// <summary>
/// 创建分析器
/// </summary>
/// <returns></returns>
private PerFieldAnalyzerWrapper CreateAnalyzerWrapper()
{
Analyzer analyzer = new StandardAnalyzer(LuceneUtil.Version.LUCENE_30);
PerFieldAnalyzerWrapper analyzerWrapper = new PerFieldAnalyzerWrapper(analyzer);
analyzerWrapper.AddAnalyzer("title", new PanGuAnalyzer());
analyzerWrapper.AddAnalyzer("categoryid", new StandardAnalyzer(LuceneUtil.Version.LUCENE_30));
return(analyzerWrapper);
}
public LuceneIndexer(string indexPath)
{
Analyzer whitespaceAnalyzer = new Lucene.Net.Analysis.WhitespaceAnalyzer();
Analyzer nGramAnalyzer = new NGramAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
analyzerWrapper = new PerFieldAnalyzerWrapper(new Lucene.Net.Analysis.WhitespaceAnalyzer());
analyzerWrapper.AddAnalyzer("Name", whitespaceAnalyzer);
analyzerWrapper.AddAnalyzer("Mobile", nGramAnalyzer);
luceneIndexDirectory = FSDirectory.Open(indexPath);
indexWriter = new IndexWriter(luceneIndexDirectory, analyzerWrapper, IndexWriter.MaxFieldLength.UNLIMITED);
}
public void Search(string keyword)
{
IndexReader reader = null;
IndexSearcher searcher = null;
try
{
reader = IndexReader.Open(FSDirectory.Open(new DirectoryInfo(indexDirectory)), true);
searcher = new IndexSearcher(reader);
//创建查询
PerFieldAnalyzerWrapper wrapper = new PerFieldAnalyzerWrapper(analyzer);
wrapper.AddAnalyzer("FileName", analyzer);
wrapper.AddAnalyzer("Author", analyzer);
wrapper.AddAnalyzer("Content", analyzer);
string[] fields = { "FileName", "Author", "Content" };
QueryParser parser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30, fields, wrapper);
Query query = parser.Parse(keyword);
TopScoreDocCollector collector = TopScoreDocCollector.Create(NumberHits, true);
searcher.Search(query, collector);
var hits = collector.TopDocs().ScoreDocs;
int numTotalHits = collector.TotalHits;
//以后就可以对获取到的collector数据进行操作
for (int i = 0; i < hits.Count(); i++)
{
var hit = hits[i];
Document doc = searcher.Doc(hit.Doc);
Field fileNameField = doc.GetField("FileName");
Field authorField = doc.GetField("Author");
Field pathField = doc.GetField("Path");
}
}
finally
{
if (searcher != null)
{
searcher.Dispose();
}
if (reader != null)
{
reader.Dispose();
}
}
}
public PerFieldAnalyzerWrapper CreateAnalyzer(Analyzer defaultAnalyzer, ICollection <Action> toDispose)
{
toDispose.Add(defaultAnalyzer.Close);
var perFieldAnalyzerWrapper = new PerFieldAnalyzerWrapper(defaultAnalyzer);
foreach (var analyzer in indexDefinition.Analyzers)
{
var analyzerInstance = IndexingExtensions.CreateAnalyzerInstance(analyzer.Key, analyzer.Value);
if (analyzerInstance == null)
{
continue;
}
toDispose.Add(analyzerInstance.Close);
perFieldAnalyzerWrapper.AddAnalyzer(analyzer.Key, analyzerInstance);
}
StandardAnalyzer standardAnalyzer = null;
KeywordAnalyzer keywordAnalyzer = null;
foreach (var fieldIndexing in indexDefinition.Indexes)
{
switch (fieldIndexing.Value)
{
case FieldIndexing.NotAnalyzed:
case FieldIndexing.NotAnalyzedNoNorms:
if (keywordAnalyzer == null)
{
keywordAnalyzer = new KeywordAnalyzer();
toDispose.Add(keywordAnalyzer.Close);
}
perFieldAnalyzerWrapper.AddAnalyzer(fieldIndexing.Key, keywordAnalyzer);
break;
case FieldIndexing.Analyzed:
if (indexDefinition.Analyzers.ContainsKey(fieldIndexing.Key))
{
continue;
}
if (standardAnalyzer == null)
{
standardAnalyzer = new StandardAnalyzer(Version.LUCENE_29);
toDispose.Add(standardAnalyzer.Close);
}
perFieldAnalyzerWrapper.AddAnalyzer(fieldIndexing.Key, standardAnalyzer);
break;
}
}
return(perFieldAnalyzerWrapper);
}
/**
* @param language
* @return
*/
protected Analyzer GetAnalyzerForLanguage(string language)
{
Analyzer contentAnalyzer = null;
Analyzer defaultAnalyzer = null;
PerFieldAnalyzerWrapper perFieldAnalyzer = null;
switch (language)
{
case "de":
contentAnalyzer = new GermanAnalyzer();
break;
case "eo":
contentAnalyzer = new EsperantoAnalyzer();
break;
case "ru":
contentAnalyzer = new RussianAnalyzer();
break;
}
if (contentAnalyzer == null)
{
contentAnalyzer = new EnglishAnalyzer();
}
if (defaultAnalyzer == null)
{
defaultAnalyzer = new SimpleAnalyzer();
}
perFieldAnalyzer = new PerFieldAnalyzerWrapper(defaultAnalyzer);
perFieldAnalyzer.AddAnalyzer("contents", contentAnalyzer);
return(perFieldAnalyzer);
}
public static IndexWriter GetIndexWriter(string indexpath, Dictionary <string, Analyzer> customAnalyzerDict = null)
{
#region initialize analyzer
Analyzer analyzer;
if (customAnalyzerDict == null)
{
analyzer = standardAnalyzer;
}
else
{
var perFieldAnalyzer = new PerFieldAnalyzerWrapper(standardAnalyzer);
foreach (var kvp in customAnalyzerDict)
{
perFieldAnalyzer.AddAnalyzer(kvp.Key, kvp.Value);
}
analyzer = perFieldAnalyzer;
}
#endregion
FileOperations.EnsureFileFolderExist(indexpath);
IndexWriter indexwriter = new IndexWriter(FSDirectory.Open(new DirectoryInfo(indexpath)),
analyzer, true, IndexWriter.MaxFieldLength.UNLIMITED);
return(indexwriter);
}
static void Main(string[] args)
{
RAMDirectory dir = new RAMDirectory();
var perFieldAnalyzer = new PerFieldAnalyzerWrapper(new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30));
perFieldAnalyzer.AddAnalyzer("ExactTitle", new LowercaseKeywordAnalyzer());
IndexWriter indexWriter = new IndexWriter(dir, perFieldAnalyzer, IndexWriter.MaxFieldLength.UNLIMITED);
Document reportDoc = new Document();
Field exactTitleField = new Field("ExactTitle",
"Test Abc",
Field.Store.NO,
Field.Index.ANALYZED);
reportDoc.Add(exactTitleField);
indexWriter.AddDocument(reportDoc);
indexWriter.Commit();
IndexSearcher searcher = new IndexSearcher(indexWriter.GetReader());
var term = new Term("ExactTitle", "test abc"); //note: for this to work this way you need to always lower case the search too
var exactQuery = new TermQuery(term);
var hits = searcher.Search(exactQuery, null, 25, Sort.RELEVANCE);
Console.WriteLine(hits.TotalHits); // prints "1"
Console.ReadLine();
indexWriter.Close();
}
/// <summary>
/// Detects untokenized fields and sets as NotAnalyzed in analyzer
/// </summary>
private static string PreProcessUntokenizedTerms(PerFieldAnalyzerWrapper analyzer, string query, Analyzer keywordAnlyzer)
{
var untokenizedMatches = untokenizedQuery.Matches(query);
if (untokenizedMatches.Count < 1)
{
return(query);
}
var sb = new StringBuilder(query);
// KeywordAnalyzer will not tokenize the values
// process in reverse order to leverage match string indexes
for (int i = untokenizedMatches.Count; i > 0; i--)
{
Match match = untokenizedMatches[i - 1];
// specify that term for this field should not be tokenized
analyzer.AddAnalyzer(match.Groups[1].Value, keywordAnlyzer);
Group term = match.Groups[2];
// remove enclosing "[[" "]]" from term value (again in reverse order)
sb.Remove(term.Index + term.Length - 2, 2);
sb.Remove(term.Index, 2);
}
return(sb.ToString());
}
private void AddFieldsAnalyzer(PerFieldAnalyzerWrapper analyzer, Analyzer fanalyzer, String[] fields)
{
foreach (var f in fields)
{
analyzer.AddAnalyzer(f, fanalyzer);
}
}
public void Where_ExactMatch_CaseInsensitive()
{
analyzer.AddAnalyzer <SampleDocument>(t => t.Id, new LowercaseKeywordAnalyzer());
AddDocument(new SampleDocument {
Name = "Other Document", Key = "X.Y.1.2"
});
AddDocument(new SampleDocument {
Name = "My Document", Key = "X.Z.1.3"
});
var documents = provider.AsQueryable <SampleDocument>();
var result = from doc in documents where doc.Key == "x.z.1.3" select doc;
Assert.That(result.Single().Name, Is.EqualTo("My Document"));
}
protected void Initialize(ILuceneIndex index, bool close)
{
Assert.ArgumentNotNull(index, "index");
PerFieldAnalyzerWrapper aw = new PerFieldAnalyzerWrapper(index.Analyzer);
aw.AddAnalyzer("_language", new KeywordAnalyzer());
this._analyzer = aw;
Assert.IsNotNull(this._analyzer, "Failed to request analyzer from the index");
}
/// <summary>
/// This method will index the contents present in the dictionary
/// </summary>
/// <param name="keyValueDic">Dictionary object holding the key value pairs </param>
public void Index(StringDictionary keyValueDic)
{
Document doc = new Document();
foreach (string key in keyValueDic.Keys)
{
if (keyValueDic[key] != null)
{
if (key == "content")
{
try
{
if (keyValueDic["type"] == ".rar" || keyValueDic["type"] == ".zip" || keyValueDic["type"] == ".gz" || keyValueDic["type"] == ".bz2" || keyValueDic["type"] == ".tar")
{
pfaw.AddAnalyzer("content", standardAnalyzer); //for archive files v use standard analyzer
}
else
{
pfaw.AddAnalyzer("content", stopAnalyzer);
}
doc.Add(new Field(key, new StreamReader(keyValueDic[key])));
}
catch { }
}
//else if (key == "path") doc.Add(new Field(key, keyValueDic[key], Field.Store.YES, Field.Index.NO));
else if (key == "size")
{
doc.Add(new Field(key, keyValueDic[key].PadLeft(12, '0'), Field.Store.YES, Field.Index.NO_NORMS));
}
else
{
doc.Add(new Field(key, keyValueDic[key].ToLower(), Field.Store.YES, Field.Index.NO_NORMS));
}
}
}
try
{
if (keyValueDic["attr"].ToLower().Contains("hidden"))
{
doc.SetBoost(.5f); //setting the ranking or boosting factor of the document
}
index.AddDocument(doc);
}
catch (Exception ex) { /* Console.WriteLine(keyValueDic["path"] + e.Message + " == " + e.StackTrace + " " + e.Source); */ }
}
/// <summary>
/// Gets the customized Analyzer used for indexing and searching.
/// </summary>
/// <returns>Customized analyzer</returns>
private PerFieldAnalyzerWrapper getAnalyzer()
{
PerFieldAnalyzerWrapper analyzer = new PerFieldAnalyzerWrapper(new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30));
// Use WhitespaceAnalyzer for flags field so underscored terms are not split apart
analyzer.AddAnalyzer("flag", new WhitespaceAnalyzer());
return(analyzer);
}
public void FileProcessor1(bool isStart, bool isFinished, string filePath)
{
if (isStart)
{
OpenIndex(true);
return;
}
if (isFinished)
{
writer.Commit();
CloseIndex();
return;
}
UInt64 ms = NTFS.InfoFromPath(filePath);
if (ms >= 0)
{
num_indexed_file++;
PerFieldAnalyzerWrapper analyzer = new PerFieldAnalyzerWrapper(new StandardAnalyzer());
analyzer.AddAnalyzer("contents", new SourceCodeAnalyzer());
analyzer.AddAnalyzer("path2", new PathAnalyzer());
//SourceCodeAnalyzer analyzer = new SourceCodeAnalyzer();
writer.AddDocument(FileDocument.Document(filePath, ms), analyzer);
if (num_indexed_file % 20 == 1)
{
writer.Commit();
}
}
/*
* lock (dispatch_queue)
* {
* if (dispatch_queue == null)
* {
* dispatch_queue = new Queue<string>();
* }
* dispatch_queue.Enqueue(filePath);
* }
* */
}
public static Analyzer CreateAnalyzer()
{
var analyzer = new PerFieldAnalyzerWrapper(new SimpleAnalyzer());
analyzer.AddAnalyzer(Fields.Base, new CSharpAnalyzer());
analyzer.AddAnalyzer(Fields.Class, new CSharpAnalyzer());
analyzer.AddAnalyzer(Fields.Code, new CSharpAnalyzer());
analyzer.AddAnalyzer(Fields.Comment, new CSharpAnalyzer());
analyzer.AddAnalyzer(Fields.Interface, new CSharpAnalyzer());
analyzer.AddAnalyzer(Fields.Method, new CSharpAnalyzer());
analyzer.AddAnalyzer(Fields.Parameter, new CSharpAnalyzer());
analyzer.AddAnalyzer(Fields.Return, new CSharpAnalyzer());
analyzer.AddAnalyzer(Fields.Using, new CSharpAnalyzer());
return(analyzer);
}
/// <summary>
/// 创建对象字段的分析器
/// </summary>
/// <returns></returns>
private PerFieldAnalyzerWrapper CreateAnalyzerWrapper()
{
Analyzer analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
PerFieldAnalyzerWrapper analyzerWrapper = new PerFieldAnalyzerWrapper(analyzer);
foreach (var item in Properties)
{
AnalyzedAttribute attr = item.GetCustomAttribute <AnalyzedAttribute>();
if (attr != null && attr.IsAnalyzed)
{
analyzerWrapper.AddAnalyzer(item.Name, new PanGuAnalyzer());
}
else
{
analyzerWrapper.AddAnalyzer(item.Name, analyzer);
}
}
return(analyzerWrapper);
}
/// <summary>
/// Defines an analyzer to use for the specified field in a strongly typed manner
/// </summary>
/// <typeparam name="TDocument">Type of the stored Lucene document</typeparam>
/// <param name="this"></param>
/// <param name="fieldName">field name requiring a non-default analyzer as a member expression</param>
/// <param name="analyzer">non-default analyzer to use for field</param>
public static void AddAnalyzer<TDocument>(this PerFieldAnalyzerWrapper @this, Expression<Func<TDocument, object>> fieldName, Analyzer analyzer)
{
try
{
@this.AddAnalyzer(((MemberExpression)fieldName.Body).Member.Name, analyzer);
}
catch (Exception ex)
{
throw new ArgumentException("Field name must be specified as a lambda to a member property, ex. doc => doc.FirstName", ex);
}
}
internal static void OptimizeAllIndexes()
{
PerFieldAnalyzerWrapper pfaw = new PerFieldAnalyzerWrapper(new KeywordAnalyzer());
pfaw.AddAnalyzer("content", new StopAnalyzer());
foreach (string dir in Directory.GetDirectories(GlobalData.IndexRootPath))
{
IndexWriter writer = new IndexWriter(dir, pfaw, false);
writer.Optimize();
writer.Close();
}
}
