public void WriteDriveInfo(DriveInfo info, FieldStorage storage)
{
if (info == null)
{
throw new ArgumentNullException("info", "info cannot be null");
}
if (storage == null)
{
throw new ArgumentNullException("storage", "storage cannot be null");
}
IndexDocument document = new IndexDocument();
document.Add(new FieldNormal("AvailableFreeSpace", info.AvailableFreeSpace.ToString(), storage.Store, storage.SearchRule, storage.VectorRule));
document.Add(new FieldNormal("DriveFormat", info.DriveFormat, storage.Store, storage.SearchRule, storage.VectorRule));
document.Add(new FieldNormal("DriveType", info.DriveType.ToString(), storage.Store, storage.SearchRule, storage.VectorRule));
document.Add(new FieldNormal("IsReady", info.IsReady.ToString(), storage.Store, storage.SearchRule, storage.VectorRule));
document.Add(new FieldNormal("Name", info.Name, storage.Store, storage.SearchRule, storage.VectorRule));
if (info.RootDirectory != null && !string.IsNullOrEmpty(info.RootDirectory.FullName))
{
document.Add(new FieldNormal("", info.RootDirectory.FullName, storage.Store, storage.SearchRule, storage.VectorRule));
}
document.Add(new FieldNormal("TotalFreeSpace", info.TotalFreeSpace.ToString(), storage.Store, storage.SearchRule, storage.VectorRule));
document.Add(new FieldNormal("TotalSize", info.TotalSize.ToString(), storage.Store, storage.SearchRule, storage.VectorRule));
document.Add(new FieldNormal("VolumeLabel", info.VolumeLabel, storage.Store, storage.SearchRule, storage.VectorRule));
this.Write(document);
}
public void Write <TKey, TValue>(IDictionary <TKey, TValue> values, FieldStorage storage)
{
if (!this.IsOpen)
{
throw new ObjectDisposedException("IndexWriter", "You cannot access this method from a disposed IndexWriter");
}
if (values == null)
{
throw new ArgumentNullException("values", "values cannot be null");
}
if (storage == null)
{
throw new ArgumentNullException("storage", "storage cannot be null");
}
IndexDocument document = new IndexDocument();
foreach (KeyValuePair <TKey, TValue> pair in values)
{
if (pair.Key == null || pair.Value == null)
{
continue;
}
string fieldName = pair.Key.ToString();
string fieldValue = pair.Value.ToString();
if (string.IsNullOrEmpty(fieldName) || string.IsNullOrEmpty(fieldValue))
{
continue;
}
document.Add(new FieldNormal(fieldName, fieldValue, storage.Store, storage.SearchRule, storage.VectorRule));
}
this.Write(document);
}
public void WriteDirectory(FileSystemInfo info, FieldStorage storage)
{
if (info == null)
{
throw new ArgumentNullException("info", "info cannot be null");
}
if (storage == null)
{
throw new ArgumentNullException("storage", "storage cannot be null");
}
IndexDocument document = new IndexDocument();
if (!string.IsNullOrEmpty(info.Attributes.ToString()))
{
document.Add(new FieldNormal("Attributes", info.Attributes.ToString(), storage.Store, storage.SearchRule, storage.VectorRule));
}
document.Add(new FieldNormal("CreationTime", info.CreationTime.ToString("G"), storage.Store, storage.SearchRule, storage.VectorRule));
document.Add(new FieldNormal("Exists", info.Exists.ToString(), storage.Store, storage.SearchRule, storage.VectorRule));
document.Add(new FieldNormal("Extension", info.Extension, storage.Store, storage.SearchRule, storage.VectorRule));
document.Add(new FieldNormal("FullName", info.FullName, storage.Store, storage.SearchRule, storage.VectorRule));
document.Add(new FieldNormal("LastAccessTime", info.LastAccessTime.ToString("G"), storage.Store, storage.SearchRule, storage.VectorRule));
document.Add(new FieldNormal("LastWriteTime", info.LastWriteTime.ToString("G"), storage.Store, storage.SearchRule, storage.VectorRule));
document.Add(new FieldNormal("Name", info.Name, storage.Store, storage.SearchRule, storage.VectorRule));
this.Write(document);
// this.WriteInstance<DirectoryInfo>(info, storage); // could simpify the whole thing
}
public void Write <TKey>(string fieldName, IEnumerable <TKey> values, FieldStorage storage, bool makeSingleDocument)
{
if (!this.IsOpen)
{
throw new ObjectDisposedException("IndexWriter", "You cannot access this method from a disposed IndexWriter");
}
if (string.IsNullOrEmpty(fieldName))
{
throw new ArgumentNullException("fieldName", "fieldName cannot be null");
}
if (values == null)
{
throw new ArgumentNullException("values", "values cannot be null");
}
if (storage == null)
{
throw new ArgumentNullException("storage", "storage cannot be null");
}
if (makeSingleDocument)
{
IndexDocument document = new IndexDocument();
foreach (TKey value in values)
{
if (value == null)
{
continue;
}
string fieldValue = value.ToString();
if (string.IsNullOrEmpty(fieldValue))
{
continue;
}
document.Add(new FieldNormal(fieldName, fieldValue, storage.Store, storage.SearchRule, storage.VectorRule));
}
if (document.TotalFields > 0)
{
this.Write(document);
}
}
else
{
foreach (TKey value in values)
{
if (value == null)
{
continue;
}
string fieldValue = value.ToString();
if (string.IsNullOrEmpty(fieldValue))
{
continue;
}
IndexDocument document = new IndexDocument();
document.Add(new FieldNormal(fieldName, fieldValue, storage.Store, storage.SearchRule, storage.VectorRule));
this.Write(document);
}
}
}
public void WriteDataRow(DataRow dataRow, IndexWriterRuleCollection ruleCollection, AnalyzerType analyzerType)
{
if (dataRow == null)
{
throw new ArgumentNullException("dataRow", "dataRow cannot be null");
}
if (ruleCollection == null)
{
throw new ArgumentNullException("ruleCollection", "ruleCollection cannot be null");
}
DataTable dataTable = dataRow.Table;
int totalColumns = dataTable.Columns.Count;
IndexDocument document = new IndexDocument();
for (int j = 0; j < totalColumns; j++)
{
DataColumn column = dataTable.Columns[j];
if (string.IsNullOrEmpty(column.ColumnName))
{
continue;
}
IndexWriterRule rule = ruleCollection.GetRuleFromType(column.DataType);
if (rule.SkipField(column.DataType, column.ColumnName))
{
continue;
}
FieldStorage storageRule = rule.GetStorageRule(column.ColumnName);
// that's all the field data, now lets get the value data
object rowValue = dataRow[j];
bool isRowNull = rowValue == null || rowValue == DBNull.Value;
if (rule.SkipColumnIfNull && isRowNull)
{
continue;
}
else if (!rule.SkipColumnIfNull && string.IsNullOrEmpty(rule.DefaultValueIfNull))
{
continue;
}
string fieldValue = (isRowNull) ? rule.DefaultValueIfNull : rowValue.ToString();
rowValue = null;
document.Add(new FieldNormal(column.ColumnName, fieldValue, storageRule.Store, storageRule.SearchRule, storageRule.VectorRule));
}
if (document.TotalFields > 0)
{
if (analyzerType == AnalyzerType.None || analyzerType == AnalyzerType.Unknown)
{
this.Write(document);
}
else
{
this.Write(document, analyzerType);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="WriterEventArgs"/> class.
/// </summary>
/// <param name="document">The document to write.</param>
/// <param name="analyzer">The analyzer being used to write.</param>
/// <param name="indexName">Name of the index being written to.</param>
public WriterEventArgs(IndexDocument document, AnalyzerType analyzer, string indexName)
{
if (document == null)
throw new ArgumentNullException("document", "document cannot be null");
if (string.IsNullOrEmpty(indexName))
throw new ArgumentNullException("indexName", "indexName cannot be null or empty");
this.document = document;
this.analyzer = analyzer;
this.index = indexName;
this.cancel = false;
}
public static void WriteInstance <TKey>(this IndexWriter writer, TKey objectToWrite, IEnumerable <string> propertiesToIndex, FieldStorage storage)
where TKey : class
{
if (writer == null)
{
throw new ArgumentNullException("writer", "writer cannot be null");
}
if (!writer.IsOpen)
{
throw new ObjectDisposedException("writer", "You cannot access this method from a disposed IndexWriter");
}
if (objectToWrite == null)
{
throw new ArgumentNullException("objectToWrite", "objectToWrite cannot be null");
}
if (storage == null)
{
throw new ArgumentNullException("storage", "storage cannot be null");
}
List <PropertyInfo> properties = new List <PropertyInfo>(objectToWrite.GetType().GetProperties());
properties.RemoveAll(x => !x.CanRead || !propertiesToIndex.Contains(x.Name));
if (properties.Count == 0)
{
throw new InvalidOperationException("You cannot index a class that doesn't have any publicly accessible (get) properties");
}
//for (int i = (totalProperties -1); i >= 0; i--) if (!propertiesToIndex.Contains(properties[i].Name)) properties.RemoveAt(i);
// now all properties can be indexed
int totalProperties = properties.Count;
IndexDocument document = new IndexDocument();
int addedProperties = 0;
for (int i = 0; i < totalProperties; i++)
{
PropertyInfo info = properties[i];
object propertyValue = info.GetValue(objectToWrite, null);
if (propertyValue == null)
{
continue;
}
document.Add(new FieldNormal(info.Name, propertyValue.ToString(), storage.Store, storage.SearchRule, storage.VectorRule));
++addedProperties;
}
if (addedProperties > 0)
{
writer.Write(document);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="WriterEventArgs"/> class.
/// </summary>
/// <param name="document">The document to write.</param>
/// <param name="analyzer">The analyzer being used to write.</param>
/// <param name="indexName">Name of the index being written to.</param>
public WriterEventArgs(IndexDocument document, AnalyzerType analyzer, string indexName)
{
if (document == null)
{
throw new ArgumentNullException("document", "document cannot be null");
}
if (string.IsNullOrEmpty(indexName))
{
throw new ArgumentNullException("indexName", "indexName cannot be null or empty");
}
this.document = document;
this.analyzer = analyzer;
this.index = indexName;
this.cancel = false;
}
/// <summary>
/// Writes the specified document.
/// </summary>
/// <param name="document">The document to out.</param>
/// <param name="appliedAnalyzer">An analyzer to use against specifically this field.</param>
/// <remarks>
/// This is useful if you have a specific type of field or document that needs special analysis rules;
/// not normally helpful if the analyzer is more complex, usually useful if the analyzer is less complex.
/// </remarks>
public void Write(IndexDocument document, AnalyzerType appliedAnalyzer)
{
if (this.isDisposed)
{
throw new ObjectDisposedException("IndexWriter", "You cannot access this method from a disposed IndexWriter");
}
if (document == null)
{
throw new ArgumentNullException("document", "document cannot be null");
}
OnWriting(new WriterEventArgs(document, (appliedAnalyzer == IndexLibrary.AnalyzerType.None || appliedAnalyzer == IndexLibrary.AnalyzerType.Unknown) ? this.AnalyzerType : appliedAnalyzer, this.index.IndexDirectory.Name));
if (appliedAnalyzer != IndexLibrary.AnalyzerType.None && appliedAnalyzer != IndexLibrary.AnalyzerType.Unknown)
{
this.writer.AddDocument(document.GetLuceneDocument, TypeConverter.GetAnalyzer(appliedAnalyzer));
}
else
{
this.writer.AddDocument(document.GetLuceneDocument);
}
this.totalWrites++;
}
/// <summary>
/// Writes the specified document out to the index.
/// </summary>
/// <param name="document">The document to output.</param>
public void Write(IndexDocument document)
{
this.Write(document, IndexLibrary.AnalyzerType.None);
}
public static void WriteDefinition(this IndexWriter writer, Type typeToOutput, ReflectionTypes dataToExport)
{
if (typeToOutput == null)
{
throw new ArgumentNullException("typeToOutput", "typeToOutput cannot be null");
}
if (writer == null)
{
throw new ArgumentNullException("writer", "writer cannot be null");
}
if (!writer.IsOpen)
{
throw new ObjectDisposedException("writer", "You cannot access this method from a disposed IndexWriter");
}
string assemblyName = typeToOutput.Assembly.FullName;
string codeTypeFieldName = "CodeType";
string assemblyFieldName = "AssemblyName";
string declaringTypeFieldName = "DeclaringType";
string declarationModifiersFieldName = "DeclarationModifiers";
string declarationFieldName = "Declaration";
string parametersFieldName = "Parameters";
bool exportAll = ((dataToExport & ReflectionTypes.All) == ReflectionTypes.All);
int i = 0;
if (exportAll || (dataToExport & ReflectionTypes.Constructors) == ReflectionTypes.Constructors)
{
ConstructorInfo[] constructors = typeToOutput.GetConstructors();
if (constructors != null)
{
int totalConstructors = constructors.Length;
for (i = 0; i < totalConstructors; i++)
{
IndexDocument constructorDocument = new IndexDocument();
constructorDocument.Add(new FieldNormal(codeTypeFieldName, "Constructor", true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
constructorDocument.Add(new FieldNormal(assemblyFieldName, assemblyName, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
constructorDocument.Add(new FieldNormal(declaringTypeFieldName, constructors[i].DeclaringType == null ? NO_VALUE : constructors[i].DeclaringType.Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
constructorDocument.Add(new FieldNormal(declarationModifiersFieldName, GetAccessParameters(constructors[i]), true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
constructorDocument.Add(new FieldNormal(declarationFieldName, constructors[i].Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
constructorDocument.Add(new FieldNormal(parametersFieldName, GetParameterString(constructors[i]), true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
writer.Write(constructorDocument);
}
}
}
if (exportAll || (dataToExport & ReflectionTypes.Properties) == ReflectionTypes.Properties)
{
PropertyInfo[] properties = typeToOutput.GetProperties();
if (properties != null)
{
int totalProperties = properties.Length;
for (i = 0; i < totalProperties; i++)
{
IndexDocument propertyDocument = new IndexDocument();
propertyDocument.Add(new FieldNormal(codeTypeFieldName, "Property", true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
propertyDocument.Add(new FieldNormal(assemblyFieldName, assemblyName, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
propertyDocument.Add(new FieldNormal(declaringTypeFieldName, properties[i].DeclaringType == null ? NO_VALUE : properties[i].DeclaringType.Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
propertyDocument.Add(new FieldNormal(declarationModifiersFieldName, GetAccessParameters(properties[i]), true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
propertyDocument.Add(new FieldNormal(declarationFieldName, properties[i].Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
propertyDocument.Add(new FieldNormal(parametersFieldName, NO_VALUE, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
writer.Write(propertyDocument);
}
}
}
if (exportAll || (dataToExport & ReflectionTypes.NestedTypes) == ReflectionTypes.NestedTypes)
{
Type[] nestedTypes = typeToOutput.GetNestedTypes();
if (nestedTypes != null)
{
int totalNestedTypes = nestedTypes.Length;
for (i = 0; i < totalNestedTypes; i++)
{
IndexDocument nestedDocument = new IndexDocument();
nestedDocument.Add(new FieldNormal(codeTypeFieldName, "NestedType", true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
nestedDocument.Add(new FieldNormal(assemblyFieldName, assemblyName, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
nestedDocument.Add(new FieldNormal(declaringTypeFieldName, nestedTypes[i].DeclaringType == null ? NO_VALUE : nestedTypes[i].DeclaringType.Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
nestedDocument.Add(new FieldNormal(declarationModifiersFieldName, GetAccessParameters(nestedTypes[i]), true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
nestedDocument.Add(new FieldNormal(declarationFieldName, nestedTypes[i].Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
nestedDocument.Add(new FieldNormal(parametersFieldName, NO_VALUE, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
writer.Write(nestedDocument);
}
}
}
if (exportAll || (dataToExport & ReflectionTypes.Methods) == ReflectionTypes.Methods)
{
MethodInfo[] methods = typeToOutput.GetMethods();
if (methods != null)
{
int totalMethods = methods.Length;
for (i = 0; i < totalMethods; i++)
{
IndexDocument methodDocument = new IndexDocument();
methodDocument.Add(new FieldNormal(codeTypeFieldName, "Method", true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
methodDocument.Add(new FieldNormal(assemblyFieldName, assemblyName, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
methodDocument.Add(new FieldNormal(declaringTypeFieldName, methods[i].DeclaringType == null ? NO_VALUE : methods[i].DeclaringType.Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
methodDocument.Add(new FieldNormal(declarationModifiersFieldName, GetAccessParameters(methods[i]), true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
methodDocument.Add(new FieldNormal(declarationFieldName, methods[i].Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
methodDocument.Add(new FieldNormal(parametersFieldName, GetParameterString(methods[i]), true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
writer.Write(methodDocument);
}
}
}
if (exportAll || (dataToExport & ReflectionTypes.Members) == ReflectionTypes.Members)
{
MemberInfo[] members = typeToOutput.GetMembers();
if (members != null)
{
int totalMembers = members.Length;
for (i = 0; i < totalMembers; i++)
{
IndexDocument memberDocument = new IndexDocument();
memberDocument.Add(new FieldNormal(codeTypeFieldName, "Member", true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
memberDocument.Add(new FieldNormal(assemblyFieldName, assemblyName, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
memberDocument.Add(new FieldNormal(declaringTypeFieldName, members[i].DeclaringType == null ? NO_VALUE : members[i].DeclaringType.Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
memberDocument.Add(new FieldNormal(declarationModifiersFieldName, NO_VALUE, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
memberDocument.Add(new FieldNormal(declarationFieldName, members[i].Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
memberDocument.Add(new FieldNormal(parametersFieldName, NO_VALUE, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
writer.Write(memberDocument);
}
}
}
if (exportAll || (dataToExport & ReflectionTypes.Interfaces) == ReflectionTypes.Interfaces)
{
Type[] interfaces = typeToOutput.GetInterfaces();
if (interfaces != null)
{
int totalInterfaces = interfaces.Length;
for (i = 0; i < totalInterfaces; i++)
{
IndexDocument interfaceDocument = new IndexDocument();
interfaceDocument.Add(new FieldNormal(codeTypeFieldName, "Interface", true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
interfaceDocument.Add(new FieldNormal(assemblyFieldName, assemblyName, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
interfaceDocument.Add(new FieldNormal(declaringTypeFieldName, interfaces[i].DeclaringType == null ? NO_VALUE : interfaces[i].DeclaringType.Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
interfaceDocument.Add(new FieldNormal(declarationModifiersFieldName, GetAccessParameters(interfaces[i]), true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
interfaceDocument.Add(new FieldNormal(declarationFieldName, interfaces[i].Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
interfaceDocument.Add(new FieldNormal(parametersFieldName, NO_VALUE, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
writer.Write(interfaceDocument);
}
}
}
if (exportAll || (dataToExport & ReflectionTypes.Fields) == ReflectionTypes.Fields)
{
FieldInfo[] fields = typeToOutput.GetFields();
if (fields != null)
{
int totalFields = fields.Length;
for (i = 0; i < totalFields; i++)
{
IndexDocument fieldDocument = new IndexDocument();
fieldDocument.Add(new FieldNormal(codeTypeFieldName, "Field", true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
fieldDocument.Add(new FieldNormal(assemblyFieldName, assemblyName, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
fieldDocument.Add(new FieldNormal(declaringTypeFieldName, fields[i].DeclaringType == null ? NO_VALUE : fields[i].DeclaringType.Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
fieldDocument.Add(new FieldNormal(declarationModifiersFieldName, NO_VALUE, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
fieldDocument.Add(new FieldNormal(declarationFieldName, fields[i].Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
fieldDocument.Add(new FieldNormal(parametersFieldName, GetAccessParameters(fields[i]), true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
writer.Write(fieldDocument);
}
}
}
if (exportAll || (dataToExport & ReflectionTypes.Events) == ReflectionTypes.Events)
{
EventInfo[] events = typeToOutput.GetEvents();
if (events != null)
{
int totalEvents = events.Length;
for (i = 0; i < totalEvents; i++)
{
IndexDocument eventDocument = new IndexDocument();
eventDocument.Add(new FieldNormal(codeTypeFieldName, "Event", true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
eventDocument.Add(new FieldNormal(assemblyFieldName, assemblyName, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
eventDocument.Add(new FieldNormal(declaringTypeFieldName, events[i].DeclaringType == null ? NO_VALUE : events[i].DeclaringType.Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
eventDocument.Add(new FieldNormal(declarationModifiersFieldName, NO_VALUE, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
eventDocument.Add(new FieldNormal(declarationFieldName, events[i].Name, true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
eventDocument.Add(new FieldNormal(parametersFieldName, GetAccessParameters(events[i].GetRaiseMethod()), true, FieldSearchableRule.Analyzed, FieldVectorRule.No));
writer.Write(eventDocument);
}
}
}
}
public static void WriteInstance <TKey>(this IndexWriter writer, TKey objectToWrite, IndexWriterRuleCollection ruleCollection)
where TKey : class
{
if (writer == null)
{
throw new ArgumentNullException("writer", "writer cannot be null");
}
if (!writer.IsOpen)
{
throw new ObjectDisposedException("writer", "You cannot access this method from a disposed IndexWriter");
}
if (objectToWrite == null)
{
throw new ArgumentNullException("objectToWrite", "objectToWrite cannot be null");
}
if (ruleCollection == null)
{
throw new ArgumentNullException("ruleCollection", "storage cannot be null");
}
List <PropertyInfo> properties = new List <PropertyInfo>(objectToWrite.GetType().GetProperties());
properties.RemoveAll(x => !x.CanRead);
if (properties.Count == 0)
{
throw new InvalidOperationException("You cannot index a class that doesn't have any publicly accessible (get) properties");
}
int totalProperties = properties.Count;
IndexDocument document = new IndexDocument();
int addedProperties = 0;
for (int i = 0; i < totalProperties; i++)
{
PropertyInfo info = properties[i];
IndexWriterRule rule = ruleCollection.GetRuleFromType(info.PropertyType);
object propertyValue = info.GetValue(objectToWrite, null);
if (rule.SkipColumnIfNull && propertyValue == null)
{
continue;
}
else if (!rule.SkipColumnIfNull && string.IsNullOrEmpty(rule.DefaultValueIfNull) && propertyValue == null)
{
continue;
}
string stringValue = string.Empty;
if (propertyValue == null)
{
stringValue = rule.DefaultValueIfNull;
}
else
{
stringValue = propertyValue.ToString();
}
propertyValue = null;
FieldStorage storage = (rule.AppliedColumns.ContainsKey(info.Name)) ? rule.AppliedColumns[info.Name] : rule.DefaultStorageRule;
document.Add(new FieldNormal(info.Name, stringValue, storage.Store, storage.SearchRule, storage.VectorRule));
++addedProperties;
}
if (addedProperties > 0)
{
writer.Write(document);
}
}
