Hi, I need to order search result by a date field (desc).

This is my custom Examine Index file (with Component, Composer and IndexCreator classes):

/// <summary>
/// AF Examine Index Creator
/// </summary>
public class AFExamineIndexCreator : LuceneIndexCreator, IUmbracoIndexesCreator
{
    /// <summary>_profilingLogger</summary>
    private readonly IProfilingLogger _profilingLogger;
    /// <summary>_localizationService</summary>
    private readonly ILocalizationService _localizationService;
    /// <summary>_publicAccessService</summary>
    private readonly IPublicAccessService _publicAccessService;

    /// <summary>
    /// AFExamineIndexCreator
    /// </summary>
    /// <param name="profilingLogger"></param>
    /// <param name="localizationService"></param>
    /// <param name="publicAccessService"></param>
    public AFExamineIndexCreator(IProfilingLogger profilingLogger, ILocalizationService localizationService, IPublicAccessService publicAccessService)
    {
        _profilingLogger = profilingLogger;
        _localizationService = localizationService;
        _publicAccessService = publicAccessService;
    }

    /// <summary>
    /// Create
    /// </summary>
    /// <returns>IEnumerable(IIndex)</returns>
    public override IEnumerable<IIndex> Create()
    {
        var index = new UmbracoContentIndex("AFExamineRepositoryIndex", // Name of the Indexer
            CreateFileSystemLuceneDirectory("AFExamineRepositoryIndex"), // File System Index
            new FieldDefinitionCollection(
                new FieldDefinition("date", FieldDefinitionTypes.DateTime), 
                new FieldDefinition("title", FieldDefinitionTypes.FullText),
                new FieldDefinition("docCategory", FieldDefinitionTypes.FullText),
                new FieldDefinition("bodyText", FieldDefinitionTypes.FullText),
                new FieldDefinition("docFile", FieldDefinitionTypes.FullText)),
            new StandardAnalyzer(Version.LUCENE_30),
            _profilingLogger,
            _localizationService,
            new ContentValueSetValidator(true, includeItemTypes: new string[] { "doc" },  excludeItemTypes: new string[] { "homepage", "docFolder", "ricerca" })
            );

        return new[] { index };
    }
}

/// <summary>
/// AF Examine Composer
/// </summary>
[RuntimeLevel(MinLevel = RuntimeLevel.Run)]
public class AFExamineComposer : IUserComposer
{
    /// <summary>
    /// Compose
    /// </summary>
    /// <param name="composition"></param>
    public void Compose(Composition composition)
    {
        composition.Components().Append<AFExamineComponent>();
        composition.RegisterUnique<AFExamineIndexCreator>();
    }
}

/// <summary>
/// AF Examine Component
/// </summary>
public class AFExamineComponent : IComponent
{
    /// <summary>_examineManager</summary>
    private readonly IExamineManager _examineManager;
    /// <summary>_afExamineIndexCreator</summary>
    private readonly AFExamineIndexCreator _afExamineIndexCreator;

    /// <summary>
    /// AFExamineComponent
    /// </summary>
    /// <param name="examineManager"></param>
    /// <param name="afExamineIndexCreator"></param>
    public AFExamineComponent(IExamineManager examineManager, AFExamineIndexCreator afExamineIndexCreator)
    {
        _examineManager = examineManager;
        _afExamineIndexCreator = afExamineIndexCreator;
    }

    /// <summary>
    /// Initialize
    /// </summary>
    public void Initialize()
    {
        // Because the Create method returns a collection of indexes,
        // we have to loop through them.
        foreach (var index in _afExamineIndexCreator.Create())
        {
            _examineManager.AddIndex(index);
        }
    }

    /// <summary>
    /// Initialize
    /// </summary>
    public void Terminate() { }
}

The result view:

@inherits Umbraco.Web.Mvc.UmbracoViewPage
@using AFStarterKit.AFBusinessLogic;
@{
    // Get query param
    string searchTerm = (string.IsNullOrEmpty(Request["query"])) ? string.Empty : Request["query"];

    if (!string.IsNullOrEmpty(searchTerm))
    {
        // Perform the search
        if(ExamineManager.Instance.TryGetIndex("AFExamineRepositoryIndex", out var index))
        {
            // Get Searcher
            var searcher = index.GetSearcher();

            // Get Results
            var results = searcher.Search(searchTerm, int.MaxValue).OrderByDescending(x => x.Score); // Here I want to orderbydescending by field date

            // Show results
            if (!results.Any())
            {
                <div class="alert alert-info" role="alert">
                    No results with query "<strong><i>@searchTerm</i></strong>"
                </div>
            }
            else
            {
                <div class="alert alert-success" role="alert">
                    @{ string resultMessage = (@results.Count() == 1) ? "result"  : "results"; }

                    <p>Find <strong><i>@results.Count()</i></strong> @resultMessage with query <strong><i>@searchTerm</i></strong></p>
                </div>

                <ul>
                    @foreach (var result in results)
                    {
                        if (result.Id != null)
                        {
                            var node = Umbraco.Content(result.Id);

                            <li>
                                <a href="@node.Url">@node.Name</a>
                            </li>
                        }
                    }
                </ul>
            }
        }
    }
    else
    {
        <div class="alert alert-warning" role="alert">
            Insert at least one word to start search
        </div>
    }
}

I would to modify (in search view) the code to show results ordered by "date" field (descending)

Can anyone help me?