System.Threading.Tasks.Task.FromResult(double)

Here are the examples of the csharp api System.Threading.Tasks.Task.FromResult(double) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

62 Examples 7

19 Source : EmptyDeviceAccessor.cs
with MIT License
from aguang-xyz

public Task<double> GetPlaybackRateAsync()
        {
            return Task.FromResult(1.0);
        }

19 Source : DlnaDeviceAccessor.cs
with MIT License
from aguang-xyz

public Task<double> GetPlaybackRateAsync()
        {
            // TODO Support playback rate for DLNA devices in the future.
            return Task.FromResult(1.0);
        }

19 Source : QueryableExtensions.cs
with MIT License
from ansel86castro

public static Task<double> AverageAsync<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double>> selector, CancellationToken cancellationToken = default)
        {
            if (IAsyncQueryExecutioner.Executioner == null)
                return Task.FromResult(source.Average(selector));

            return IAsyncQueryExecutioner.Executioner.AverageAsync(source, selector);
        }

19 Source : QueryableExtensions.cs
with MIT License
from ansel86castro

public static Task<double?> AverageAsync<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double?>> selector, CancellationToken cancellationToken = default)
        {
            if (IAsyncQueryExecutioner.Executioner == null)
                return Task.FromResult(source.Average(selector));

            return IAsyncQueryExecutioner.Executioner.AverageAsync(source, selector);
        }

19 Source : QueryableExtensions.cs
with MIT License
from ansel86castro

public static Task<double> AverageAsync<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int>> selector, CancellationToken cancellationToken = default)
        {
            if (IAsyncQueryExecutioner.Executioner == null)
                return Task.FromResult(source.Average(selector));

            return IAsyncQueryExecutioner.Executioner.AverageAsync(source, selector);
        }

19 Source : QueryableExtensions.cs
with MIT License
from ansel86castro

public static Task<double?> AverageAsync<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int?>> selector, CancellationToken cancellationToken = default)
        {
            if (IAsyncQueryExecutioner.Executioner == null)
                return Task.FromResult(source.Average(selector));

            return IAsyncQueryExecutioner.Executioner.AverageAsync(source, selector);
        }

19 Source : QueryableExtensions.cs
with MIT License
from ansel86castro

public static Task<double?> AverageAsync<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long?>> selector, CancellationToken cancellationToken = default)
        {
            if (IAsyncQueryExecutioner.Executioner == null)
                return Task.FromResult(source.Average(selector));

            return IAsyncQueryExecutioner.Executioner.AverageAsync(source, selector);
        }

19 Source : QueryableExtensions.cs
with MIT License
from ansel86castro

public static Task<double> AverageAsync<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long>> selector, CancellationToken cancellationToken = default)
        {
            if (IAsyncQueryExecutioner.Executioner == null)
                return Task.FromResult(source.Average(selector));

            return IAsyncQueryExecutioner.Executioner.AverageAsync(source, selector);
        }

19 Source : QueryableExtensions.cs
with MIT License
from ansel86castro

public static Task<double> SumAsync<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double>> selector, CancellationToken cancellationToken = default)
        {
            if (IAsyncQueryExecutioner.Executioner == null)
                return Task.FromResult(source.Sum(selector));

            return IAsyncQueryExecutioner.Executioner.SumAsync(source, selector);
        }

19 Source : QueryableExtensions.cs
with MIT License
from ansel86castro

public static Task<double?> SumAsync<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double?>> selector, CancellationToken cancellationToken = default)
        {
            if (IAsyncQueryExecutioner.Executioner == null)
                return Task.FromResult(source.Sum(selector));

            return IAsyncQueryExecutioner.Executioner.SumAsync(source, selector);
        }

19 Source : BindAsyncTests.cs
with MIT License
from bert2

private static Task<double?> Divide(double dividend, double divisor) => Task.FromResult(divisor == 0 ? (double?)null : dividend / divisor);

19 Source : BindAsyncTests.cs
with MIT License
from bert2

[Fact] public async Task ReturnsNullWhenGivenNull()
                    => await Task.FromResult<double?>(null).BindAsync(x => Divide(x, 3)).ShouldBeNull();

19 Source : BindAsyncTests.cs
with MIT License
from bert2

[Fact] public async Task ReturnsNullWhenBinderReturnsNull()
                    => await Task.FromResult<double?>(6).BindAsync(x => Divide(x, 0)).ShouldBeNull();

19 Source : BindAsyncTests.cs
with MIT License
from bert2

[Fact] public async Task ReturnsBinderResult()
                    => await Task.FromResult<double?>(6).BindAsync(x => Divide(x, 3)).ShouldBe(2);

19 Source : BindTests.cs
with MIT License
from bert2

[Fact] public async Task ReturnsNullWhenGivenNull()
                    => await Task.FromResult<double?>(null).Bind(x => Divide(x, 3)).ShouldBeNull();

19 Source : BindTests.cs
with MIT License
from bert2

[Fact] public async Task ReturnsNullWhenBinderReturnsNull()
                    => await Task.FromResult<double?>(6).Bind(x => Divide(x, 0)).ShouldBeNull();

19 Source : BindTests.cs
with MIT License
from bert2

[Fact] public async Task ReturnsBinderResult()
                    => await Task.FromResult<double?>(6).Bind(x => Divide(x, 3)).ShouldBe(2);

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double> AverageAsync(IQueryable<int> source, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(source);
            return provider != null
                ? provider.AverageAsync(source, cancellationToken)
                : Task.FromResult(source.Average());
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double?> AverageAsync(IQueryable<int?> source, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(source);
            return provider != null
                ? provider.AverageAsync(source, cancellationToken)
                : Task.FromResult(source.Average());
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, int>> selector, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(queryable);
            return provider != null
                ? provider.AverageAsync(queryable, selector, cancellationToken)
                : Task.FromResult(queryable.Average(selector));
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, int?>> selector, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(queryable);
            return provider != null
                ? provider.AverageAsync(queryable, selector, cancellationToken)
                : Task.FromResult(queryable.Average(selector));
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double?> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, double?>> selector, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(queryable);
            return provider != null
                ? provider.SumAsync(queryable, selector, cancellationToken)
                : Task.FromResult(queryable.Sum(selector));
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double> AverageAsync(IQueryable<long> source, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(source);
            return provider != null
                ? provider.AverageAsync(source, cancellationToken)
                : Task.FromResult(source.Average());
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double?> AverageAsync(IQueryable<long?> source, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(source);
            return provider != null
                ? provider.AverageAsync(source, cancellationToken)
                : Task.FromResult(source.Average());
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, long>> selector, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(queryable);
            return provider != null
                ? provider.AverageAsync(queryable, selector, cancellationToken)
                : Task.FromResult(queryable.Average(selector));
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, long?>> selector, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(queryable);
            return provider != null
                ? provider.AverageAsync(queryable, selector, cancellationToken)
                : Task.FromResult(queryable.Average(selector));
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double> AverageAsync(IQueryable<double> source, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(source);
            return provider != null
                ? provider.AverageAsync(source, cancellationToken)
                : Task.FromResult(source.Average());
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double?> AverageAsync(IQueryable<double?> source, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(source);
            return provider != null
                ? provider.AverageAsync(source, cancellationToken)
                : Task.FromResult(source.Average());
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, double>> selector, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(queryable);
            return provider != null
                ? provider.AverageAsync(queryable, selector, cancellationToken)
                : Task.FromResult(queryable.Average(selector));
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double?> AverageAsync<T>(IQueryable<T> queryable, Expression<Func<T, double?>> selector, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(queryable);
            return provider != null
                ? provider.AverageAsync(queryable, selector, cancellationToken)
                : Task.FromResult(queryable.Average(selector));
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double> SumAsync(IQueryable<double> source, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(source);
            return provider != null
                ? provider.SumAsync(source, cancellationToken)
                : Task.FromResult(source.Sum());
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double?> SumAsync(IQueryable<double?> source, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(source);
            return provider != null
                ? provider.SumAsync(source, cancellationToken)
                : Task.FromResult(source.Sum());
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from bing-framework

public Task<double> SumAsync<T>(IQueryable<T> queryable, Expression<Func<T, double>> selector, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(queryable);
            return provider != null
                ? provider.SumAsync(queryable, selector, cancellationToken)
                : Task.FromResult(queryable.Sum(selector));
        }

19 Source : CoinmateAPI.cs
with MIT License
from Crynners

public Task<double> getTakerFee()
        {
            return Task.FromResult(1.0035);
        }

19 Source : HuobiAPI.cs
with MIT License
from Crynners

public Task<double> getWithdrawalFeeAsync(double? amount = null, string destinationAddress = null)
        {
            switch (this.pair_base)
            {
                case "BTC":
                    return Task.FromResult(0.0004);
                case "LTC":
                    return Task.FromResult(0.001);
                case "ETH":
                    return Task.FromResult(0.004);
                default:
                    return Task.FromResult(Double.MaxValue);
            }
        }

19 Source : BittrexAPI.cs
with MIT License
from Crynners

public Task<double> getWithdrawalFeeAsync(double? amount = null, string destinationAddress = null)
        {
            // the method to get the withdrawal fee probably doesn't exist, so you'd better return the maximum double value so that the withdrawal is never performed
            return Task.FromResult(double.MaxValue);
        }

19 Source : CoinbaseAPI.cs
with MIT License
from Crynners

public Task<double> getTakerFee()
        {
            // TODO: Add methods for taker fee
            return Task.FromResult(0.005);
        }

19 Source : CoinbaseAPI.cs
with MIT License
from Crynners

public Task<double> getWithdrawalFeeAsync(double? amount = null, string destinationAddress = null)
        {
            // TODO: Add methods for withdrawal fees
            return Task.FromResult(double.MaxValue);
        }

19 Source : HuobiAPI.cs
with MIT License
from Crynners

public Task<double> getTakerFee()
        {
            return Task.FromResult(1.002);
        }

19 Source : GetPriceByCustomerProductQueryHandler.cs
with GNU General Public License v3.0
from grandnode

public async Task<double?> Handle(GetPriceByCustomerProductQuery request, CancellationToken cancellationToken)
        {
            var key = string.Format(CacheKey.CUSTOMER_PRODUCT_PRICE_KEY_ID, request.CustomerId, request.ProductId);
            var productprice = _cacheBase.Get(key, () =>
            {
                var pp = _customerProductPriceRepository.Table
                .Where(x => x.CustomerId == request.CustomerId && x.ProductId == request.ProductId)
                .FirstOrDefault();
                if (pp == null)
                    return (null, false);
                else
                    return (pp, true);
            });

            if (!productprice.Item2)
                return await Task.FromResult(default(double?));
            else
                return await Task.FromResult(productprice.pp.Price);
        }

19 Source : BrainTreePaymentProvider.cs
with GNU General Public License v3.0
from grandnode

public async Task<double> GetAdditionalHandlingFee(IList<ShoppingCarreplacedem> cart)
        {
            if (_brainTreePaymentSettings.AdditionalFee <= 0)
                return _brainTreePaymentSettings.AdditionalFee;

            double result;
            if (_brainTreePaymentSettings.AdditionalFeePercentage)
            {
                //percentage
                var orderTotalCalculationService = _serviceProvider.GetRequiredService<IOrderCalculationService>();
                var subtotal = await orderTotalCalculationService.GetShoppingCartSubTotal(cart, true);
                result = (double)((((float)subtotal.subTotalWithDiscount) * ((float)_brainTreePaymentSettings.AdditionalFee)) / 100f);
            }
            else
            {
                //fixed value
                result = _brainTreePaymentSettings.AdditionalFee;
            }
            if (result > 0)
            {
                var currencyService = _serviceProvider.GetRequiredService<ICurrencyService>();
                var workContext = _serviceProvider.GetRequiredService<IWorkContext>();
                result = await currencyService.ConvertFromPrimaryStoreCurrency(result, workContext.WorkingCurrency);
            }
            //return result;
            return await Task.FromResult(result);
        }

19 Source : ShippingPointRateProvider.cs
with GNU General Public License v3.0
from grandnode

public Task<double?> GetFixedRate(GetShippingOptionRequest getShippingOptionRequest)
        {
            return Task.FromResult(default(double?));
        }

19 Source : PayPalStandardPaymentProvider.cs
with GNU General Public License v3.0
from grandnode

public async Task<double> GetAdditionalHandlingFee(IList<ShoppingCarreplacedem> cart)
        {
            if (_paypalStandardPaymentSettings.AdditionalFee <= 0)
                return _paypalStandardPaymentSettings.AdditionalFee;

            double result;
            if (_paypalStandardPaymentSettings.AdditionalFeePercentage)
            {
                //percentage
                var orderTotalCalculationService = _serviceProvider.GetRequiredService<IOrderCalculationService>();
                var subtotal = await orderTotalCalculationService.GetShoppingCartSubTotal(cart, true);
                result = (double)((((float)subtotal.subTotalWithDiscount) * ((float)_paypalStandardPaymentSettings.AdditionalFee)) / 100f);
            }
            else
            {
                //fixed value
                result = _paypalStandardPaymentSettings.AdditionalFee;
            }
            if (result > 0)
            {
                var currencyService = _serviceProvider.GetRequiredService<ICurrencyService>();
                result = await currencyService.ConvertFromPrimaryStoreCurrency(result, _workContext.WorkingCurrency);
            }
            //return result;
            return await Task.FromResult(result);
        }

19 Source : ByWeightShippingProvider.cs
with GNU General Public License v3.0
from grandnode

public async Task<double?> GetFixedRate(GetShippingOptionRequest getShippingOptionRequest)
        {
            return await Task.FromResult(default(double?));
        }

19 Source : DeviceInformationServiceMac.cs
with GNU General Public License v3.0
from immense

public new Task<double> GetCpuUtilization()
        {
            try
            {
                var cpuPercentStrings = _processInvoker.InvokeProcessOutput("zsh", "-c \"ps -A -o %cpu\"");

                double cpuPercent = 0;
                cpuPercentStrings
                    .Split(Environment.NewLine)
                    .ToList()
                    .ForEach(x =>
                    {
                        if (double.TryParse(x, out var result))
                        {
                            cpuPercent += result;
                        }
                    });

                return Task.FromResult(cpuPercent / Environment.ProcessorCount / 100);
            }
            catch (Exception ex)
            {
                Logger.Write(ex, "Error while getting CPU utilization.");
            }

            return Task.FromResult((double)0);
        }

19 Source : JavascriptOptimizerTest.cs
with Apache License 2.0
from jameschch

private void Setup()
        {
            _mock = new Mock<IJSRuntime>();
            _formatted = Code + "\r\nabc(1.23,4.56);";
            _mock.Setup(m => m.InvokeAsync<double>(_formatted, It.IsAny<object[]>())).Returns(new ValueTask<double>(Task.FromResult(7.89)));

            _unit = new JavascriptOptimizer(_mock.Object, new BlazorClientConfiguration { EnableOptimizerWorker = false });
            _unit.Initialize(Code, Mock.Of<IActivityLogger>());
        }

19 Source : CSharpCompiler.cs
with Apache License 2.0
from jameschch

public Func<double[], Task<double>> GetDelegate(MemoryStream stream)
        {
            var replacedembly = replacedembly.Load(stream.ToArray());
            var type = replacedembly.GetTypes().Single(s => s.DeclaringType != null && s.BaseType == typeof(object));
            var instance = Activator.CreateInstance(type);

            var objectMethods = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).Select(o => o.Name);

            return (i) =>
            {
                var method = type.GetMethods(BindingFlags.Public | BindingFlags.Instance).Single(n => !objectMethods.Contains(n.Name));

                var returnValue = method.Invoke(instance, new object[] { i });

                if (method.ReturnType != typeof(Task<double>))
                {
                    return Task.FromResult((double)returnValue);
                }

                return (Task<double>)returnValue;
            };
        }

19 Source : MockAccountService.cs
with GNU General Public License v3.0
from LetsCreateSeries

public Task<double> GetCurrentPayRateAsync()
        {
            return Task.FromResult(10.0);
        }

19 Source : AccountService.cs
with GNU General Public License v3.0
from LetsCreateSeries

public Task<double> GetCurrentPayRateAsync()
        {
            return Task.FromResult(10d);
        }

19 Source : AsyncQueryableExecuter.cs
with MIT License
from linfx

public Task<double> SumAsync(IQueryable<double> queryable, CancellationToken cancellationToken = default)
        {
            var provider = FindProvider(queryable);
            return provider != null
                ? provider.SumAsync(queryable, cancellationToken)
                : Task.FromResult(queryable.Sum());
        }

See More Examples