1. Why Only 10 Entries Are Returned

By default, ABP uses PagedAndSortedResultRequestDto, which has the following default values:

• MaxResultCount = 10 (meaning it will only return 10 items per page if you do not override it).
• SkipCount = 0 (the starting index).
• Sorting = null (no default sort order).

Hence, if you call the standard methods (e.g., GetListAsync) without specifying a bigger page size, you’ll only see 10 records in the returned DTO.

2. Returning All Entries

Option A: Pass a Larger MaxResultCount from the Front-End

If you want to continue using GetListAsync from your Blazor page, you can explicitly pass a larger (or effectively unbounded) page size in the PagedAndSortedResultRequestDto:

csharp
Copy code
// Pseudocode from your Blazor component or service:

var queryParams = new PagedAndSortedResultRequestDto
{
    MaxResultCount = 1000,   // Or int.MaxValue if you really want "all"
    SkipCount = 0,
    Sorting = "Name ASC"     // or "CountryName ASC", depends on your entity property
};

var countries = await CountryAppService.GetListAsync(queryParams);

// 'countries' now contains up to 1000 records, sorted as requested.

• Pro: You stick to ABP’s standard CRUD pattern (GetListAsync), just adjusting the page size.
• Con: If you have a very large number of countries, returning them all at once may have performance implications. But for smaller datasets (e.g., a typical list of countries in the world), this is usually fine.

Option B: Create a Custom Method to Return All

If you want to keep GetListAsync as-is, but also have a quick way to get everything in one shot, you can add a custom method to your service:

1. Extend the Interface

csharp
Copy code
using System.Collections.Generic;
using System.Threading.Tasks;

public interface ICountryAppService : 
    ICrudAppService<CountryDto, Guid, PagedAndSortedResultRequestDto, CreateUpdateCountryDto>
{
    Task<List<CountryDto>> GetAllCountriesOrderedAsync();
}

2. Implement in the AppService

csharp
Copy code
public class CountryAppService :
    CrudAppService<Country, CountryDto, Guid, PagedAndSortedResultRequestDto, CreateUpdateCountryDto>,
    ICountryAppService
{
    public CountryAppService(IRepository<Country, Guid> repository)
        : base(repository)
    {
    }

    // Custom method
    public async Task<List<CountryDto>> GetAllCountriesOrderedAsync()
    {
        // Query the repository (no paging)
        var query = await Repository.GetQueryableAsync();
        
        // Order by your Country property, e.g. Name
        query = query.OrderBy(x => x.Name); // Adjust property name as needed

        var allCountries = query.ToList();

        // Convert to DTO
        return ObjectMapper.Map<List<Country>, List<CountryDto>>(allCountries);
    }
}

3. Call the Method

In your Blazor front-end, you can now do:

csharp
Copy code
var countries = await CountryAppService.GetAllCountriesOrderedAsync();
// countries will be a list of all countries in ascending order by Name

• Pro: Clear semantic method for “all in ascending order.”
• Con: Additional custom code that deviates from the standard CrudAppService pattern.

Tip: ABP’s recommended approach is to still use pagination in most scenarios (for large data sets). However, if you truly want all data for a drop-down, this custom approach is perfectly valid.

3. Sorting Alphabetically

Using GetListAsync with Sorting

If you continue using the standard GetListAsync method, simply set the Sorting property in PagedAndSortedResultRequestDto to your entity’s property name:

csharp
Copy code
var queryParams = new PagedAndSortedResultRequestDto
{
    MaxResultCount = 1000,         // or any large number
    Sorting = "Name ASC"           // or "YourProperty ASC"
};

var countries = await CountryAppService.GetListAsync(queryParams);

• If your entity has a property named CountryName, you’d do "CountryName ASC".
• This will return results in ascending order.

Setting a Default Sort on the Server Side

Another trick is to override the CreateFilteredQueryAsync in your CountryAppService to force a default sort if the caller hasn’t specified one:

csharp
Copy code
protected override async Task<IQueryable<Country>> CreateFilteredQueryAsync(PagedAndSortedResultRequestDto input)
{
    var query = await base.CreateFilteredQueryAsync(input);

    // If no Sorting is specified, default to alphabetical by Name:
    if (string.IsNullOrWhiteSpace(input.Sorting))
    {
        query = query.OrderBy(x => x.Name);
    }
    return query;
}

This way, if your front-end doesn’t specify a sorting parameter, the default becomes alphabetical.

Summary (Root Cause and Solution)

• Root Cause:
  • ABP’s built-in CRUD service returns paged results by default, capped at 10 records.
  • The sorting is undefined unless you explicitly provide the Sorting parameter.
• Solution:
  1. Increase the MaxResultCount (e.g., int.MaxValue if needed) in your request to fetch all.
  2. Specify a sort parameter (Sorting = "Name ASC") to get alphabetical results.
  3. (Optionally) create a custom method (e.g., GetAllCountriesOrderedAsync) to bypass paging and return sorted data if you prefer a more direct approach.