public static void Main(string[] args)
{
    // NLog: setup the logger first to catch all errors
    var logger = LogManager.LoadConfiguration("nlog.config").GetCurrentClassLogger();
    try
    {
        logger.Debug("init main");
        BuildWebHost(args).Run();
    }
    catch (Exception ex)
    {
        //NLog: catch setup errors
        logger.Error(ex, "Stopped program because of exception");
        throw;
    }
}

public static IWebHost BuildWebHost(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
        .UseStartup<Startup>()
        .ConfigureLogging((hostingContext, logging) =>
        {
            logging.ClearProviders();
            logging.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
        })
        .UseNLog()  // NLog: setup NLog for Dependency injection
        .Build();
}

// Add Versioning and versioned documentation using swagger
config.AddApiVersioning(
        o =>
        {
            o.AssumeDefaultVersionWhenUnspecified = true;
            o.DefaultApiVersion = new ApiVersion(1, 0);
            o.ReportApiVersions = true;
        }
    );
var apiExplorer = config.AddVersionedApiExplorer(o => o.GroupNameFormat = "F");
var virtualPath = HostingEnvironment.ApplicationHost.GetVirtualPath();
config.EnableSwagger(
    SwaggerRootTemplate,
    swagger =>
    {
        swagger.RootUrl(req => req.RequestUri.GetLeftPart(UriPartial.Authority) + req.GetConfiguration().VirtualPathRoot.TrimEnd('/') + virtualPath);
        swagger.IncludeXmlComments(XmlCommentsPath);
        swagger.MultipleApiVersions(
            (apiDescription, version) => apiDescription.GetGroupName() == version,
            info =>
            {
                foreach (var group in apiExplorer.ApiDescriptions)
                {
                    info.Version(group.Name, $"My API {group.ApiVersion}");
                }
            });
    })
    .EnableSwaggerUi(swagger =>
    {
        swagger.EnableDiscoveryUrlSelector();
        swagger.DisableValidator();
    });

// Add Versioning and versioned documentation using swagger
services.AddMvcCore().AddVersionedApiExplorer(o =>
{
    o.GroupNameFormat = "F";
    // note: this option is only necessary when versioning by url segment. the SubstitutionFormat
    // can also be used to control the format of the API version in route templates
    o.SubstituteApiVersionInUrl = true;
});
services.AddMvc();

services.AddApiVersioning(
    o =>
    {
        o.AssumeDefaultVersionWhenUnspecified = true;
        o.DefaultApiVersion = new ApiVersion(1, 0);
        o.ReportApiVersions = true;
    });

// Register the Swagger generator, defining one or more Swagger documents
services.AddSwaggerGen(c =>
{
    var provider = services.BuildServiceProvider().GetRequiredService<IApiVersionDescriptionProvider>();

    foreach (var description in provider.ApiVersionDescriptions)
    {
        c.SwaggerDoc(description.GroupName, new Info()
            {
                Title = $"My API {description.ApiVersion}",
                Version = description.ApiVersion.ToString()
            });
    }

    // Set the comments path for the Swagger JSON and UI.
    var basePath = AppContext.BaseDirectory;
    c.IncludeXmlComments(Path.Combine(basePath, XmlComments));
});

// Enable middleware to serve generated Swagger as a JSON endpoint.
app.UseSwagger();

// Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.), specifying the Swagger JSON endpoint.
app.UseSwaggerUI(c =>
{
    foreach (var description in provider.ApiVersionDescriptions)
    {
        c.SwaggerEndpoint($"{description.GroupName}/swagger.json", description.GroupName.ToUpperInvariant());
    }
});

private ApiVersion RequestedApiVersion => HttpContext.ApiVersionProperties()?.ApiVersion;

var validators = AssemblyScanner.FindValidatorsInAssemblyContaining<MyValidator>();
validators.ForEach(validator => unityContainer.RegisterType(validator.InterfaceType, validator.ValidatorType, new HierarchicalLifetimeManager()));
FluentValidationModelValidatorProvider.Configure(config, provider =>
{
    provider.ValidatorFactory = new UnityValidatorFactory(unityContainer);
});

services.AddMvc().AddFluentValidation(fv =>
{
    fv.RegisterValidatorsFromAssemblyContaining<MyValidator>();
    fv.ImplicitlyValidateChildProperties = true;
}
);

    /// <summary>
    /// Validates model state before executing the method.
    /// </summary>
    public class ValidateCommandAttribute : ActionFilterAttribute
    {

        /// <summary>
        /// Occurs before the action method is invoked.
        /// </summary>
        /// <param name="actionContext"> The action context. </param>
        public override void OnActionExecuting(ActionExecutingContext actionContext)
        {
            if (!actionContext.ModelState.IsValid)
            {
                var controller = actionContext.Controller as ControllerBase;
                if (controller != null)
                {
                    actionContext.Result = controller.BadRequest(actionContext.ModelState);
                    return;
                }
            }
            base.OnActionExecuting(actionContext);
        }
    }

public class MyListBinder : IModelBinder
{
    public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
    {
        var value = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
        var result = new List<string>();
        if (!string.IsNullOrEmpty(value?.AttemptedValue))
        {
            var values = value.AttemptedValue.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
            result.AddRange(values);
        }
        bindingContext.Model = result;

        return true;
    }
}

public class MyListBinder : IModelBinder
{
    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        if (bindingContext == null)
            throw new ArgumentNullException(nameof(bindingContext));

        var modelName = bindingContext.ModelName;
        var valueProviderResult = bindingContext.ValueProvider.GetValue(modelName);

        if (valueProviderResult == ValueProviderResult.None || valueProviderResult.Length == 0)
            return Task.CompletedTask;

        var model = valueProviderResult.Values
            .SelectMany(x => x?.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
            .Where(y => !string.IsNullOrEmpty(y))
            .Distinct()
            .ToList();

        bindingContext.Result = ModelBindingResult.Success(model);

        return Task.CompletedTask;
    }
}

public class MyListBinderProvider : IModelBinderProvider
{
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context == null)
            throw new ArgumentNullException(nameof(context));

        if (context.Metadata.ModelType == typeof(IList<string>))
            return new MyListBinder();

        return null;
    }
}

 public class MyCustomBodyModelBinder : HttpParameterBinding
    {
        public MyCustomBodyModelBinder(HttpParameterDescriptor descriptor) : base(descriptor)
        {
        }

        public override Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            var binding = actionContext.ActionDescriptor.ActionBinding;

            var content = actionContext.Request.Content;

            return content.ReadAsStringAsync().ContinueWith(task =>
            {
                var json = task.Result;
                var bindingParameter = binding.ParameterBindings.OfType<MyCustomBodyModelBinder>().FirstOrDefault();
                if (bindingParameter != null)
                {
                    var type = bindingParameter.Descriptor.ParameterType;
                    var name = bindingParameter.Descriptor.ParameterName;
                    var converted = CustomConvert(json, type);

                    SetValue(actionContext, converted);
                    var modelMetadataProvider = Descriptor.Configuration.Services.GetModelMetadataProvider();
                    var validator = Descriptor.Configuration.Services.GetBodyModelValidator();
                    validator.Validate(converted, type, modelMetadataProvider, actionContext, name);                    
                }
            });
        }

        public override bool WillReadBody => true;
    }
}

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
public sealed class FromMyCustomBodyAttribute : ParameterBindingAttribute
{
    public override HttpParameterBinding GetBinding(HttpParameterDescriptor parameter)
    {
        if (parameter == null)
            throw new ArgumentNullException(nameof(parameter));

        return new MyCustomBodyModelBinder(parameter);
    }
}

public class MyCustomInputFormatter : InputFormatter
{
    public MyCustomInputFormatter()
    {
        SupportedMediaTypes.Add("application/json");
    }
    public override async Task<InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
    {
        var request = context.HttpContext.Request;
        using (var reader = new StreamReader(request.Body))
        {
            var content = await reader.ReadToEndAsync();
            var type = context.ModelType;
            var converted = CustomConvert(content, type);
            return await InputFormatterResult.SuccessAsync(converted);
        }
    }
    protected override bool CanReadType(Type type)
    {
        return type.Assembly == typeof(MyType).Assembly;
    }
}

public class GlobalExceptionFilter : ExceptionFilterAttribute
{
    public override void OnException(HttpActionExecutedContext context)
    {
        var exception = context.Exception as ApiException;
        var httpError = new HttpError(...) {....};
        var statusCode = ....;
        context.Response = context.Request.CreateErrorResponse(statusCode, httpError);
    }
}

public class ErrorHandlingMiddleware
{
    private readonly RequestDelegate _next;

    public ErrorHandlingMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            await HandleExceptionAsync(context, ex);
        }
    }

    private Task HandleExceptionAsync(HttpContext context, Exception exception)
    {
       var result = JsonConvert.SerializeObject(new { Error = exception.Message, ... });
        context.Response.ContentType = "application/json";
        context.Response.StatusCode = ...;
        return context.Response.WriteAsync(result);
    }
}

public class LoggingMessageHandler : DelegatingHandler
{
    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        var requestUri = request.RequestUri.ToString();
        var stopwatch = Stopwatch.StartNew();
        string responseContent = null;
        string statusCode = null;
        string statusReason = null;

        try
        {
            var response = await base.SendAsync(request, cancellationToken);

            responseContent = response.Content == null ? null : await response.Content.ReadAsStringAsync();

            statusCode = ((int)response.StatusCode).ToString();
            statusReason = response.ReasonPhrase;

            return response;
        }
        finally
        {
            stopwatch.Stop();
            var elapsed = stopwatch.Elapsed.ToString();
            var requestContent = request.Content == null ? null : await request.Content.ReadAsStringAsync();
            //Log here
        }
    }
}

public class LoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger _logger;

    public LoggingMiddleware(RequestDelegate next, ILogger<LoggingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task Invoke(HttpContext context)
    {
        var request = context.Request;
        var requestUri = request.GetDisplayUrl();
        var stopwatch = Stopwatch.StartNew();
        string statusCode = null;

        try
        {
            await _next(context);
            var response = context.Response;
            statusCode = response.StatusCode.ToString();
        }
        finally
        {
            stopwatch.Stop();
            _logger.LogDebug($"RequestMethod={request.Method};RequestUri={requestUri};ResponseCode={statusCode};ElapsedTime={stopwatch.Elapsed}");
        }
    }
}

        [HttpGet]
        [ProducesResponseType(typeof(List<Vehicle>), 200)]
        [Route("", Name = RouteNameSearch)]
        public async Task<IActionResult> GetVehiclesAsync()

    [KnownType(typeof(Bike))]
    [KnownType(typeof(Car))]
    public class Vehicle

        [HttpPost]
        [ValidateCommand]
        [ProducesResponseType(typeof(Vehicle), 201)]
        [Route("")]
        public async Task<IActionResult> Post([FromBody] Vehicle vehicle)

    /// <summary>
    /// Converter used to parse a vehicle.
    /// </summary>
    public class VehicleConverter : JsonConverter
    {
        /// <summary>
        /// Determines whether this instance can convert the specified object type.
        /// </summary>
        public override bool CanConvert(Type objectType)
        {
            return typeof(Vehicle).GetTypeInfo().IsAssignableFrom(objectType);
        }

        /// <summary>
        /// Gets a value indicating whether this Newtonsoft.Json.JsonConverter can write.
        /// </summary>
        public override bool CanWrite => false;

        /// <summary>
        /// Reads the JSON representation of the object.
        /// </summary>
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
                return null;

            var item = JObject.Load(reader);
            var vehicleType = item["VehicleType"]?.ToString(); // Here, we assume that vehicle has a property called VehicleType containing vehicle type.
            switch (vehicleType)
            {
                case "Bike":
                    return item.ToObject<Bike>();
                case "Car":
                    return item.ToObject<Car>();
                default:
                    throw new ArgumentException($"Unknown vehicle type '{vehicleType}'");
            }
        }

        /// <summary>
        /// Writes the JSON representation of the object.
        /// </summary>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            //Not used because CanWrite is set to false
        }
    }

    public class BodyInheritanceInputFormatter : InputFormatter
    {
        public BodyInheritanceInputFormatter()
        {
            SupportedMediaTypes.Add("application/json");
        }
        public override async Task<InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
        {
            var request = context.HttpContext.Request;
            using (var reader = new StreamReader(request.Body))
            {
                var content = await reader.ReadToEndAsync();
                var type = context.ModelType;

                var converters = new JsonConverter[] { new VehicleConverter() }; // Add other converters here

                var converted = JsonConvert.DeserializeObject(content, type, converters);
                return await InputFormatterResult.SuccessAsync(converted);
            }
        }
        protected override bool CanReadType(Type type)
        {
            return type.Assembly == typeof(Vehicle).Assembly;
        }
    }

            services.AddMvc(options =>
            {
                options.InputFormatters.Insert(0, new BodyInheritanceInputFormatter()); // Add custom formatter to parse body into derived class
            })
            .AddJsonOptions(options => options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore) // Ignore null values in response

public class PolymorphismDocumentFilter : IDocumentFilter
{
    private static void RegisterSubClasses(ISchemaRegistry schemaRegistry)
    {
        var assembly = typeof(Vehicle).Assembly;
        var allTypes = assembly.GetTypes();

        var allBaseClassDtoTypes = allTypes
                                    .Where(x => x.IsDefined(typeof(KnownTypeAttribute), false))
                                    .ToList();

        var derivedTypes = allTypes
            .Where(x => allBaseClassDtoTypes.Any(abstractType => abstractType != x && abstractType.IsAssignableFrom(x)))
            .ToList();

        foreach (var item in derivedTypes)
        {
            schemaRegistry.GetOrRegister(item);
        }
    }

    public void Apply(SwaggerDocument swaggerDoc, DocumentFilterContext context)
    {
        RegisterSubClasses(context.SchemaRegistry);
    }
}

public class ValidatorBase<TBase> : AbstractValidator<TBase>
{
    public void MapDerivedValidator<TType, TValidatorType>() where TValidatorType : IEnumerable<IValidationRule>, IValidator<TType>, new() where TType : TBase
    {
        When(t => t.GetType() == typeof(TType), () => AddDerivedRules<TValidatorType>());
    }

    private void AddDerivedRules<T>() where T : IEnumerable<IValidationRule>, new()
    {
        IEnumerable<IValidationRule> validator = new T();
        foreach (var rule in validator)
        {
            AddRule(rule);
        }
    }
}

public class VehicleValidator : ValidatorBase<Vehicle>
{
    public VehicleValidator()
    {
        RuleFor(request => request.VehicleType)
            .NotEmpty();

        // Add rules for common properties here

        MapDerivedValidator<Bike, BikeValidator>();
    }
}

public class BikeValidator : ValidatorBase<Bike>
{
    public BikeValidator()
    {
        // Add rules for properties specific to a bike
    }
}

public enum ApiErrorCode
{
    InternalError,
    UserNotFound,
    UserAlreadyExists,
    UserWrongPassword,
    UserDisabled
}

public class ApiException : Exception
{
    public ApiErrorCode ApiErrorCode { get; set; }

    public ApiException(ApiErrorCode errorCode, string message, Exception innerException = null)
        : base(message, innerException)
    {
        ApiErrorCode = errorCode;
    }
}

public class ValidationApiException : ApiException
{
    public ValidationApiException(ApiErrorCode errorCode, string message, Exception innerException = null)
        : base(errorCode, message, innerException)
    {
    }
}

[HttpGet]
[ProducesResponseType(typeof(UserDto), 200)]
[Route("{id}", Name = RouteNameGetById)]
public async Task<IActionResult> GetAsync(string id)
{
    if (string.IsNullOrEmpty(id))
        throw new ValidationApiException(ApiErrorCode.MissingInformation, $"Parameter {nameof(id)} must be provided.");

    var user = await _userService.GetUserByIdAsync(id);

    if (user == null)
        throw new ResourceNotFoundApiException(ApiErrorCode.UserNotFound, $"Cannot find user with id=\"{id}\"");

    var userDto = Mapper.Map<UserDto>(user);

    return Ok(userDto);
}

public class ErrorHandlingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger _logger;

    public ErrorHandlingMiddleware(RequestDelegate next, ILogger<ErrorHandlingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task Invoke(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            await HandleExceptionAsync(context, ex);
        }
    }

    private Task HandleExceptionAsync(HttpContext context, Exception exception)
    {
        var code = HttpStatusCode.InternalServerError; // 500 if unexpected
        _logger.LogWarning(exception.Message);
        _logger.LogTrace($"Stacktrace: {exception.StackTrace}");
        while (exception.InnerException != null)
        {
            exception = exception.InnerException;
            _logger.LogWarning($"Inner exception: {exception.Message}");
            _logger.LogTrace($"Stacktrace: {exception.StackTrace}");
        }

        var apiException = exception as ApiException;
        if (apiException != null)
            code = GetHttpStatusCodeFromException(apiException);

        var apiErrorCode = apiException?.ApiErrorCode ?? ApiErrorCode.InternalError;

        var result = JsonConvert.SerializeObject(new { Error = exception.Message, ApiErrorCode = apiErrorCode.ToString() });
        context.Response.ContentType = "application/json";
        context.Response.StatusCode = (int)code;
        return context.Response.WriteAsync(result);
    }

    private HttpStatusCode GetHttpStatusCodeFromException(ApiException exception)
    {
        if (exception is ResourceNotFoundApiException)
            return HttpStatusCode.NotFound;

        if (exception is ValidationApiException)
            return HttpStatusCode.BadRequest;

        // Add here other exceptions

        return HttpStatusCode.InternalServerError;
    }
}

app.UseMiddleware(typeof(ErrorHandlingMiddleware));

public class MyProfile : Profile
{
    public override string ProfileName => nameof(MyProfile);

    public MyProfile()
    {
        CreateMap<Item, ItemDto>();
    }
}

public class AutoMapperConfig
{
    public static IMapper Configure()
    {
        var config = new MapperConfiguration(x =>
        {
            x.AddProfile(new MyProfile());
            x.AllowNullCollections = true;
        });

        var mapper = config.CreateMapper();
        mapper.ConfigurationProvider.AssertConfigurationIsValid();

        return mapper;
    }
}

var mapper = AutoMapperConfig.Configure();
services.AddTransient<IMapper, IMapper>(c => mapper);

public MyController(MyService myService, IMapper mapper, ILogger<MyController> logger)
{
    _myService = myService;
    _mapper = mapper;
    _logger = logger;
}

[HttpGet]
[ProducesResponseType(typeof(List<ItemDto>), 200)]
public List<ItemDto> Get()
{
    var items = _itemsService.GetAllItems();
    return _mapper.Map<List<ItemDto>>(items);
}

[Fact]
public void MyTest()
{
    // Arrange
    var fixture = new Fixture();
    var expectedItem = fixture.Create<MyClass>();
    // Additional arrange stuff

    // Act
    // Call operation here

    // Assert
    // Add assertions here
}

[Theory, AutoData]
public void MyTest(MyClass expectedItem)
{
    // Arrange
    // Additional arrange stuff

    // Act
    // Call operation here

    // Assert
    // Add assertions here
}

internal class AutoFixtureConventions : CompositeCustomization
{
    public AutoFixtureConventions()
        : base(new MongoObjectIdCustomization())
    {
    }

    private class MongoObjectIdCustomization : ICustomization
    {
        public void Customize(IFixture fixture)
        {
            fixture.Register(ObjectId.GenerateNewId);
        }
    }
}

var fixture = new Fixture().Customize(new AutoFixtureConventions());

public class CustomAutoDataAttribute : AutoDataAttribute
{
    public CustomAutoDataAttribute()
        : base(() => new Fixture().Customize(new AutoFixtureConventions()))
    {
    }
}

[Fact]
public async Task GetByIdReturnsExpectedItem()
{
    // Arrange
    var itemsRepositoryMock = new Mock<IItemsRepository>();
    var itemsService = new ItemsService(itemsRepositoryMock.Object);
    var expectedItem = new Item();
    var id = ObjectId.GenerateNewId();
    itemsRepositoryMock.Setup(x => x.GetById(id)).ReturnsAsync(expectedItem);

    // Act
    var result = await itemsService.GetById(id.ToString());

    // Assert
    Assert.Equal(result, expectedItem);
    itemsRepositoryMock.VerifyAll();
}

internal class AutoFixtureConventions : CompositeCustomization
{
    public AutoFixtureConventions()
        : base(new MongoObjectIdCustomization(), new AutoMoqCustomization())
    {
    }

    private class MongoObjectIdCustomization : ICustomization
    {
        public void Customize(IFixture fixture)
        {
            fixture.Register(ObjectId.GenerateNewId);
        }
    }
}

[Theory, CustomAutoData]
public async Task GetByIdReturnsExpectedItem(Item expectedItem, ObjectId id,  [Frozen]Mock<IItemsRepository> itemsRepositoryMock, ItemsService itemsService)
{
    // Arrange
    itemsRepositoryMock.Setup(x => x.GetById(id)).ReturnsAsync(expectedItem);

    // Act
    var result = await itemsService.GetById(id.ToString());

    // Assert
    Assert.Equal(result, expectedItem);
    itemsRepositoryMock.VerifyAll();
}

[TestFixture]
public class ItemDtoValidatorTest
{
	[TestCase("")]
	[TestCase(null)]
	public void ValidateItemDto_ReturnsError_WhenNameIsNotProvided(string name)
	{
		// Arrange
		var validator = new ItemDtoValidator();
		var testItems = new Faker<ItemDto>()
			.RuleFor(x => x.Name, f => name)
			.RuleFor(x => x.Id, f => Guid.NewGuid().ToString())
			.RuleFor(x => x.Description, f => f.Lorem.Paragraph())
			.RuleFor(x => x.Owner, f => f.Name.FindName())
			.RuleFor(x => x.Tags, f => f.Lorem.Words().ToList());

		var item = testItems.Generate();

		// Act
		var result = validator.Validate(item);

		// Assert
		Assert.That(result.Errors.Count, Is.EqualTo(1));
		Assert.That(result.Errors.Any(x => x.ErrorMessage.Contains(nameof(item.Name))), Is.True);
	}
}

public static class PaginationExtensions
{
    public static IPagedList<T> ToPagedList<T>(this IEnumerable<T> list, int skip, int limit, int totalCount)
    {
        var pageNumber = (skip / limit) + 1;
        return new StaticPagedList<T>(list, pageNumber, limit, totalCount);
    }
}

var query = collection.Find(filter)
    .SortBy(acc => acc.Id)
    .Skip(searchParameters.Skip)
    .Limit(searchParameters.Limit);

var items = await query.ToListAsync();
var totalRows = (int)await collection.CountAsync(filter);
return items.ToPagedList(searchParameters.Skip, searchParameters.Limit, totalRows);

public class PagedListDto<T> : ResourceBase
{
    public IList<T> Items { get; set; }
    public int FirstItemOnPage { get; set; }
    public bool HasNextPage { get; set; }
    public bool HasPreviousPage { get; set; }
    public bool IsFirstPage { get; set; }
    public bool IsLastPage { get; set; }
    public int LastItemOnPage { get; set; }
    public int PageCount { get; set; }
    public int PageNumber { get; set; }
    public int PageSize { get; set; }
    public int TotalItemCount { get; set; }
}

public class PagedListToDtoConverter<T1, T2> : ITypeConverter<IPagedList<T1>, PagedListDto<T2>>
{
    public PagedListDto<T2> Convert(IPagedList<T1> source, PagedListDto<T2> destination, ResolutionContext context)
    {
        var items = context.Mapper.Map<List<T2>>(source);

        return new PagedListDto<T2>
        {
            Items = items,
            FirstItemOnPage = source.FirstItemOnPage,
            HasNextPage = source.HasNextPage,
            HasPreviousPage = source.HasPreviousPage,
            IsFirstPage = source.IsFirstPage,
            IsLastPage = source.IsLastPage,
            LastItemOnPage = source.LastItemOnPage,
            PageCount = source.PageCount,
            PageNumber = source.PageNumber,
            PageSize = source.PageSize,
            TotalItemCount = source.TotalItemCount
        };
    }
}

[HttpGet]
[ProducesResponseType(typeof(PagedListDto<ItemDto>), 200)]
public async Task<IActionResult> Get(ItemSearchParameter search)
{
    var items = await _itemsService.GetItems(search);
    var itemDtos = _mapper.Map<PagedListDto<ItemDto>>(items);
    return Ok(itemDtos);
}

public class SearchBase
{
    private const int DefaultLimit = 100;

    private int? _skip;

    public int Skip
    {
        get { return _skip.GetValueOrDefault(0); }
        set { _skip = value; }
    }

    private int? _limit;

    public int Limit
    {
        get { return _limit.GetValueOrDefault(DefaultLimit); }
        set { _limit = value; }
    }
}

public abstract class ResourceBase
{
    public const string RelationNameSelf = "self";
    public const string RelationNamePrevious = "previous";
    public const string RelationNameNext = "next";
    public Dictionary<string, string> Links { get; set; }
    protected ResourceBase()
    {
        Links = new Dictionary<string, string>();
    }
}

public static class PagedListExtensions
{
    public static void BuildNavigationLinks<T>(this PagedListDto<T> pagedList, Uri currentUri)
    {
        pagedList.Links[ResourceBase.RelationNameSelf] = currentUri.AbsoluteUri;
        var queryString = HttpUtility.ParseQueryString(currentUri.Query);
        SearchBase searchParam;
        var skipParameterName = nameof(searchParam.Skip);

        if (pagedList.HasNextPage)
        {
            var nbElementsToSkip = pagedList.LastItemOnPage;
            queryString.Set(skipParameterName, nbElementsToSkip.ToString());
            var newUri = new UriBuilder(currentUri) { Query = queryString.ToString() }.Uri;
            pagedList.Links[ResourceBase.RelationNameNext] = newUri.AbsoluteUri;
        }

        if (pagedList.HasPreviousPage)
        {
            var nbElementsToSkip = pagedList.FirstItemOnPage - 1 - pagedList.PageSize;
            queryString.Set(skipParameterName, nbElementsToSkip.ToString());
            var newUri = new UriBuilder(currentUri) { Query = queryString.ToString() }.Uri;
            pagedList.Links[ResourceBase.RelationNamePrevious] = newUri.AbsoluteUri;
        }
    }

    public static void BuildNavigationLinks<T>(this PagedListDto<T> pagedList, string currentUri)
    {
        pagedList.BuildNavigationLinks(new Uri(currentUri));
    }
}

[HttpGet]
[ProducesResponseType(typeof(PagedListDto<ItemDto>), 200)]
public async Task<IActionResult> Get(ItemSearchParameter search)
{
    var items = await _itemsService.GetItems(search);
    var itemDtos = _mapper.Map<PagedListDto<ItemDto>>(items);
    itemDtos.BuildNavigationLinks(Request.GetDisplayUrl());
    return Ok(itemDtos);
}

services.AddSingleton<IActionContextAccessor, ActionContextAccessor>();
services.AddScoped<IUrlHelper>(factory =>
{
    var actionContext = factory.GetService<IActionContextAccessor>().ActionContext;
    return new UrlHelper(actionContext);
});

var serviceProvider = services.BuildServiceProvider();
var mapper = AutoMapperConfig.Configure(serviceProvider);

CreateMap<Item, ItemDto>()
    .ForMember(dest => dest.Links, opt => opt.Ignore())
    .AfterMap((src, dest) =>
    {
        if (dest.Id != null)
        {
            var urlHelper = (IUrlHelper)serviceProvider.GetService(typeof(IUrlHelper));
            dest.Links[ResourceBase.RelationNameOperations] = urlHelper.Link(OperationsController.RouteNameGetAsync, new OperationSearchParameter { EntityId = dest.Id });
            dest.Links[ResourceBase.RelationNameSelf] = urlHelper.Link(ItemsController.RouteNameGetById, new { id = dest.Id });
        }
    });

services.AddMvc().AddJsonOptions(options => options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore);

[HttpGet]
[ProducesResponseType(typeof(VersionDto), 200)]
public IActionResult Get()
{
    var assemblyVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
    var apiDescriptions = _apiVersionDescriptionProvider.ApiVersionDescriptions;
    var versionDto = new VersionDto
    {
        AssemblyVersion = assemblyVersion,
        SupportedApiVersions = _mapper.Map<List<VersionDescriptionDto>>(apiDescriptions)
    };

    return Ok(versionDto);
}