Optimize PrepareCheckoutPickupPointModelAsync with 500 pickuppoints it takes too long to load

With 500 pickup points PrepareCheckoutPickupPointModelAsync takes about 9 seconds to load.
Its the cause which leads client to quit checkout.
I solved it by using cache

My solution if someone needs it :)

 protected virtual async Task<CheckoutPickupPointsModel> PrepareCheckoutPickupPointsModelAsync(IList<ShoppingCartItem> cart)
        {
            var model = new CheckoutPickupPointsModel
            {
                AllowPickupInStore = _shippingSettings.AllowPickupInStore
            };

            if (!model.AllowPickupInStore)
                return model;

            model.DisplayPickupPointsOnMap = _shippingSettings.DisplayPickupPointsOnMap;
            model.GoogleMapsApiKey = _shippingSettings.GoogleMapsApiKey;
            var customer = await _workContext.GetCurrentCustomerAsync();
            var store = await _storeContext.GetCurrentStoreAsync();
            var pickupPointProviders = await _pickupPluginManager.LoadActivePluginsAsync(customer, store.Id);
            if (pickupPointProviders.Any())
            {
                var languageId = (await _workContext.GetWorkingLanguageAsync()).Id;
                var address = customer.BillingAddressId.HasValue
                    ? await _addressService.GetAddressByIdAsync(customer.BillingAddressId.Value)
                    : null;
                var pickupPointsResponse = await _shippingService.GetPickupPointsAsync(cart, address,
                    customer, storeId: store.Id);
                if (pickupPointsResponse.Success)
                    model.PickupPoints = await PrepareCheckoutPickupPointListModelAsync(pickupPointsResponse.PickupPoints, languageId,store,customer);
                else
                    foreach (var error in pickupPointsResponse.Errors)
                        model.Warnings.Add(error);
            }

            //only available pickup points
            var shippingProviders = await _shippingPluginManager.LoadActivePluginsAsync(customer, store.Id);
            if (!shippingProviders.Any())
            {
                if (!pickupPointProviders.Any())
                {
                    model.Warnings.Add(await _localizationService.GetResourceAsync("Checkout.ShippingIsNotAllowed"));
                    model.Warnings.Add(await _localizationService.GetResourceAsync("Checkout.PickupPoints.NotAvailable"));
                }
                model.PickupInStoreOnly = true;
                model.PickupInStore = true;
                return model;
            }

            return model;
        }

Helper functions

protected virtual async Task<List<CheckoutPickupPointModel>> PrepareCheckoutPickupPointListModelAsync(IList<PickupPoint> pickupPoints, int languageId, Store store, Customer customer) {

            var cacheKey = _staticCacheManager.PrepareKeyForDefaultCache(NopModelCacheDefaults.PickUpPointsAllKey);
            var points = await _staticCacheManager.GetAsync(cacheKey, async () => await PrepareCheckoutPickupPointListModelAsync(pickupPoints, languageId, store, customer, string.Empty));
            return points;

        }

        protected virtual async Task<List<CheckoutPickupPointModel>> PrepareCheckoutPickupPointListModelAsync(IList<PickupPoint> pickupPoints, int languageId, Store store, Customer customer, string loaded = null)
        {
            var list = new List<CheckoutPickupPointModel>();
            list =  await pickupPoints.SelectAwait(async point =>
            {
                var country = await _countryService.GetCountryByTwoLetterIsoCodeAsync(point.CountryCode);
                var state = await _stateProvinceService.GetStateProvinceByAbbreviationAsync(point.StateAbbreviation, country?.Id);

                var pickupPointModel = new CheckoutPickupPointModel
                {
                    Id = point.Id,
                    Name = point.Name,
                    Description = point.Description,
                    ProviderSystemName = point.ProviderSystemName,
                    Address = point.Address,
                    City = point.City,
                    County = point.County,
                    StateName = state != null ? await _localizationService.GetLocalizedAsync(state, x => x.Name, languageId) : string.Empty,
                    CountryName = country != null ? await _localizationService.GetLocalizedAsync(country, x => x.Name, languageId) : string.Empty,
                    ZipPostalCode = point.ZipPostalCode,
                    Latitude = point.Latitude,
                    Longitude = point.Longitude,
                    OpeningHours = point.OpeningHours
                };

                var cart = await _shoppingCartService.GetShoppingCartAsync(customer, ShoppingCartType.ShoppingCart, store.Id);
                var amount = await _orderTotalCalculationService.IsFreeShippingAsync(cart) ? 0 : point.PickupFee;
                var currentCurrency = await _workContext.GetWorkingCurrencyAsync();

                if (amount > 0)
                {
                    (amount, _) = await _taxService.GetShippingPriceAsync(amount, customer);
                    amount = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(amount, currentCurrency);
                    pickupPointModel.PickupFee = await _priceFormatter.FormatShippingPriceAsync(amount, true);
                }

                //adjust rate
                var (shippingTotal, _) = await _orderTotalCalculationService.AdjustShippingRateAsync(point.PickupFee, cart, true);
                var (rateBase, _) = await _taxService.GetShippingPriceAsync(shippingTotal, customer);
                var rate = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(rateBase, currentCurrency);
                pickupPointModel.PickupFee = await _priceFormatter.FormatShippingPriceAsync(rate, true);

                return pickupPointModel;
            }).ToListAsync();

            return list;
        }