ExamineComponent.cs

public class ProductComponent : IComponent
{
    private readonly IExamineManager _examineManager;
    private readonly ProductIndexCreator _productIndexCreator;

    public ProductComponent (IExamineManager examineManager, ProductIndexCreator productIndexCreator)
    {
        _examineManager = examineManager;
        _productIndexCreator = productIndexCreator;
    }

    public void Initialize()
    {      
        foreach (var index in _productIndexCreator.Create())
            _examineManager.AddIndex(index);
    }

    public void Terminate() { }
}

ProductComposer.cs

[RuntimeLevel(MinLevel = RuntimeLevel.Run)]
public class ProductComposer : IUserComposer
{
    public void Compose(Composition composition)
    {
        composition.Components().Append<ProductComponent>();

        composition.RegisterUnique<ProductIndexValueSetBuilder>();
        composition.Register<ProductIndexPopulator>(Lifetime.Singleton);
        composition.RegisterUnique<ProductIndexCreator>();
    }
}

ProductIndexCreator.cs

public class ProductIndexCreator : LuceneIndexCreator
{
    public override IEnumerable<IIndex> Create()
    {
        var index = new LuceneIndex("ProductIndex",
            CreateFileSystemLuceneDirectory("ProductIndex"),
            new FieldDefinitionCollection(
                new FieldDefinition("name", FieldDefinitionTypes.FullTextSortable),
                new FieldDefinition("price", FieldDefinitionTypes.FullText)
            ),
            new StandardAnalyzer(Version.LUCENE_30));

        return new[] { index };
    }
}

ProductIndexPopulator.cs

public class ProductIndexPopulator : IndexPopulator
{
    private readonly ProductIndexValueSetBuilder _productValueSetBuilder;
    private readonly IProductService _productService;

    public ProductIndexPopulator(ProductIndexValueSetBuilder productValueSetBuilder, IProductService productService)
    {
        _productValueSetBuilder = productValueSetBuilder;
        _productService = productService;

        RegisterIndex("ProductIndex");
    }

    protected override void PopulateIndexes(IReadOnlyList<IIndex> indexes)
    {
        var products = _productService.GetAll();
        if (products != null && products.Any())
        {
            foreach (var index in indexes)
            {
                index.IndexItems(_productValueSetBuilder.GetValueSets(products));
            }
        }
    }
}

ProductIndexValueBuilder.cs

public class ProductIndexValueSetBuilder : IValueSetBuilder<Product>
{
    public IEnumerable<ValueSet> GetValueSets(params Product[] products)
    {
        foreach (var product in products)
        {
            var indexValues = new Dictionary<string, object>
            {
                ["name"] = product.Name,
                ["price"] = product.Price
            };

            var valueSet = new ValueSet(product.Id.ToString(), "product", indexValues);

            yield return valueSet;
        }
    }
}