private static string CheckForMentions(IMessageChannel channel, string message) { var words = message.Split().Where(x => x.StartsWith("@")); if (!words.Any()) { return(message); } var users = AsyncEnumerableExtensions.Flatten(channel.GetUsersAsync()); users.Select(x => $"@{x.Username}").Intersect(words.ToAsyncEnumerable()).ForEach(async x => { var user = await users.First(y => y.Username == x.Substring(1)); message = message.Replace(x, user.Mention); }); if (channel is SocketTextChannel) { var castChannel = (SocketTextChannel)channel; var roles = castChannel.Guild.Roles; roles.Select(x => $"@{x.Name}").Intersect(words).ToList().ForEach(x => { var role = roles.First(y => y.Name == x.Substring(1)); message = message.Replace(x, role.Mention); }); } return(message); }
//delete number of messages public static async Task RoutineDelete(SocketCommandContext context, SocketUserMessage msg) { //get number of messages to delete int del_num = 0; String[] msg_array = msg.ToString().Split(' '); if (msg_array.Length < 3) { //use default number del_num = 1; } else if (!(int.TryParse(msg_array[2], out del_num) && del_num >= 0 && del_num <= 1000)) { //failed to get specified number throw new CommandException("invalid number of messages"); } var messages_pages = context.Channel.GetMessagesAsync(msg, Direction.Before, del_num); var messages = await AsyncEnumerableExtensions.FlattenAsync <IMessage>(messages_pages); var i = 0; foreach (var message in messages) { await context.Channel.DeleteMessageAsync(message); //don't send more than 1 request per second await Task.Delay(1000); i += 1; } await context.Channel.SendMessageAsync(i.ToString() + " message(s) deleted."); }
private async IAsyncEnumerable <BlobLease> LeaseRenewInterval(BlobLeaseClient client, BlobRequestConditions condition, [EnumeratorCancellation] CancellationToken token = default) { await foreach (var _ in AsyncEnumerableExtensions.Interval(LeaseRenewDuration, token)) { yield return(await client.RenewAsync(condition, token)); } }
public async ValueTask <int> Hyperlinq_AsyncEnumerable_Value() { var sum = 0; await foreach (var item in AsyncEnumerableExtensions .AsAsyncValueEnumerable <TestAsyncEnumerable.AsyncEnumerable, TestAsyncEnumerable.AsyncEnumerable.AsyncEnumerator, int>(asyncEnumerableValue, (enumerable, cancellationToken) => enumerable.GetAsyncEnumerator(cancellationToken)) .Where((item, _) => new ValueTask <bool>((item & 0x01) == 0))) { sum += item; } return(sum); }
public async Task StartAsync() { this.ThrowIfDisposed(); this._cancellationToken.ThrowIfCancellationRequested(); SignalTask oldReadTask = (SignalTask)null; CancellationTokenSource cancellationTokenSource = (CancellationTokenSource)null; bool lockTaken = false; object obj; try { Monitor.Enter(obj = this._segmentLock, ref lockTaken); if (!this._isRunning) { if (this._abortTokenSource.IsCancellationRequested) { cancellationTokenSource = this._abortTokenSource; this._abortTokenSource = CancellationTokenSource.CreateLinkedTokenSource(this._cancellationToken); oldReadTask = this._readTask; this._readTask = new SignalTask(new Func <Task>(this.ReadSubList), this._abortTokenSource.Token); } this._isRunning = true; } else { goto label_15; } } finally { if (lockTaken) { Monitor.Exit(obj); } } await HlsPlaylistSegmentManager.CleanupReader(oldReadTask, cancellationTokenSource).ConfigureAwait(false); if (this._programStream.Segments != null && this._programStream.Segments.Count > 0) { this.UpdatePlaylist(); } ISegment segment = await AsyncEnumerableExtensions.FirstOrDefaultAsync <ISegment>(this.Playlist).ConfigureAwait(false); if (null == segment) { Debug.WriteLine("HlsPlaylistSegmentManager.StartAsync() no segments found"); throw new FileNotFoundException("Unable to find the first segment"); } this.ContentType = await this._programStream.GetContentTypeAsync(this._cancellationToken).ConfigureAwait(false); this.WebReader = WebReaderExtensions.CreateChild(this._programStream.WebReader, (Uri)null, ContentKind.AnyMedia, this.ContentType); label_15 :; }
private static IAsyncEnumerable <Result <LevelSelectors> > GetLevelSelectorsEnumerableAsync( this IReadOnlyMemoizationSessionWithLevelSelectors session, Context context, Fingerprint weakFingerprint, CancellationToken cts, int level) { return(AsyncEnumerableExtensions.CreateSingleProducerTaskAsyncEnumerable <Result <LevelSelectors> >( async() => { var result = await session.GetLevelSelectorsAsync(context, weakFingerprint, cts, level); return new[] { result }; })); }
private static Async::System.Collections.Generic.IAsyncEnumerable <Result <LevelSelectors> > GetLevelSelectorsEnumerableAsync( this ILevelSelectorsProvider session, Context context, Fingerprint weakFingerprint, CancellationToken cts, int level) { return(AsyncEnumerableExtensions.CreateSingleProducerTaskAsyncEnumerable <Result <LevelSelectors> >( async() => { var result = await session.GetLevelSelectorsAsync(context, weakFingerprint, cts, level); return new[] { result }; })); }
private static IAsyncQueryable <NuGetPackage> Synchronized(IAsyncQueryable <NuGetPackage> async, Func <IQueryable <NuGetPackage>, IQueryable <NuGetPackage> > getNotEvaluated) { var syncTask = AsyncEnumerableExtensions.ToList(async); syncTask.Wait(); var completedList = syncTask.Result; var withFilter = getNotEvaluated(completedList.AsQueryable()); var completedEnumer = new CompletedAsyncEnumerator <NuGetPackage>(withFilter); return(AsyncEnumerable.FromResult(completedEnumer)); }
internal static async Task <Lookup <TKey, TElement> > CreateForJoinAsync(IAsyncEnumerable <TElement> source, Func <TElement, TKey> keySelector, IEqualityComparer <TKey> comparer, CancellationToken cancellationToken) { var lookup = new Lookup <TKey, TElement>(comparer); await foreach (var item in AsyncEnumerableExtensions.WithCancellation(source, cancellationToken).ConfigureAwait(false)) { var key = keySelector(item); if (key != null) { lookup.GetGrouping(key, create: true).Add(item); } } return(lookup); }
public void Method() { var a0 = new OptimizedAsyncEnumerable <TestType>().FirstAsync(); var b0 = new OptimizedAsyncEnumerable <TestType>().FirstOrDefaultAsync(); var c0 = AsyncEnumerableExtensions.FirstAsync(new OptimizedAsyncEnumerable <TestType>()); var d0 = AsyncEnumerableExtensions.FirstOrDefaultAsync(new OptimizedAsyncEnumerable <TestType>()); var a1 = new TestType().SingleAsync(); var b1 = new TestType().SingleOrDefaultAsync(); var c1 = NotAsyncEnumerableExtensions.SingleAsync(new TestType()); var d1 = NotAsyncEnumerableExtensions.SingleOrDefaultAsync(new TestType()); var c2 = SingleAsync(new TestType()); var d2 = SingleOrDefaultAsync(new TestType()); }
public void AsAsyncValueEnumerable_With_ValidData_Must_Succeed(int[] source) { // Arrange var wrapped = Wrap .AsAsyncEnumerable(source); // Act var result = AsyncEnumerableExtensions .AsAsyncValueEnumerable(wrapped); // Assert _ = result.Must() .BeAsyncEnumerableOf <int>() .BeEqualTo(source); }
public void AsAsyncValueEnumerable_GetEnumerator_With_ValidData_Must_Succeed(int[] source) { // Arrange var wrapped = Wrap .AsAsyncEnumerable(source); // Act var result = AsyncEnumerableExtensions .AsAsyncValueEnumerable <Wrap.AsyncEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, (enumerable, _) => enumerable.GetAsyncEnumerator()); // Assert _ = result.Must() .BeAsyncEnumerableOf <int>() .BeEqualTo(source); }
internal static async Task <LookupWithTask <TKey, TElement> > CreateAsync(IAsyncEnumerable <TElement> source, Func <TElement, CancellationToken, ValueTask <TKey> > keySelector, IEqualityComparer <TKey> comparer, CancellationToken cancellationToken) { Debug.Assert(source != null); Debug.Assert(keySelector != null); var lookup = new LookupWithTask <TKey, TElement>(comparer); await foreach (var item in AsyncEnumerableExtensions.WithCancellation(source, cancellationToken).ConfigureAwait(false)) { var key = await keySelector(item, cancellationToken).ConfigureAwait(false); lookup.GetGrouping(key, create: true).Add(item); } return(lookup); }
/// <summary> /// Enumerate known selectors for a given weak fingerprint. /// </summary> internal IAsyncEnumerable <GetSelectorResult> GetSelectors(Context context, Fingerprint weakFingerprint, CancellationToken cts) { return(AsyncEnumerableExtensions.CreateSingleProducerTaskAsyncEnumerable(() => getSelectorsCore())); async Task <IEnumerable <GetSelectorResult> > getSelectorsCore() { var selectors = await GetSelectorsCoreAsync(context, weakFingerprint); if (!selectors) { return(new GetSelectorResult[] { new GetSelectorResult(selectors) }); } return(selectors.Value.Select(s => new GetSelectorResult(s))); } }
async Task ValidateAllReactionsAndRolesForGuild(TownGuild guildSettings) { try { SocketGuild guild = client.GetGuild(guildSettings.GuildId); foreach (var messageSettings in guildSettings.RoleGrantingSettings.MessageSettings) { var channel = guild.GetChannel(messageSettings.Channel); var message = await(channel as ISocketMessageChannel).GetMessageAsync(messageSettings.MessageToMonitor) as IUserMessage; foreach (var reaction in message.Reactions) { if (messageSettings.ReactionsToRoles.TryGetValue(reaction.Key.Name, out GrantingRoleSettings grantingSettings)) { var reactedUsers = message.GetReactionUsersAsync(reaction.Key, 1000); var flattenedUsers = await AsyncEnumerableExtensions.FlattenAsync(reactedUsers); foreach (var reactedUser in flattenedUsers) { if (client.CurrentUser.Id == reactedUser.Id) { continue; } await GrantUserRoleBasedOnReaction(reaction.Key, message, guild, guildSettings, guild.GetUser(reactedUser.Id)); } } } await message.RemoveAllReactionsAsync(); Emoji[] emojis = messageSettings.ReactionsToRoles.Select(item => new Emoji(item.Key)).ToArray(); await message.AddReactionsAsync(emojis); } } catch (Exception e) { Console.WriteLine(e); Console.WriteLine("Failed validating all emotes on startup"); } }
public async ValueTask AsAsyncValueEnumerable_With_ToArrayAsync_Must_Succeed(int[] source) { // Arrange var wrapped = Wrap .AsAsyncEnumerable(source); var expected = Enumerable .ToArray(source); // Act var result = await AsyncEnumerableExtensions .AsAsyncValueEnumerable <int>(wrapped) .ToArrayAsync(); // Assert _ = result.Must() .BeArrayOf <int>() .BeEqualTo(expected); }
public async ValueTask ToListAsync_With_ValidData_Must_Succeed(int[] source) { // Arrange var wrapped = Wrap .AsAsyncEnumerable(source); var expected = Enumerable .ToList(source); // Act var result = await AsyncEnumerableExtensions .AsAsyncValueEnumerable(wrapped) .ToListAsync(); // Assert _ = result.Must() .BeOfType <List <int> >() .BeEnumerableOf <int>() .BeEqualTo(expected); }
private static string CheckForMentions(IMessageChannel channel, string message) { var words = message.Split().Where(x => x.StartsWith("@")); if (!words.Any()) { return(message); } var users = AsyncEnumerableExtensions.Flatten(channel.GetUsersAsync()); users.Select(x => $"@{x.Username}").Intersect(words.ToAsyncEnumerable()).ForEach(async x => { var user = await users.First(y => y.Username == x.Substring(1)); message = message.Replace(x, user.Mention); }); return(message); }
private async Task IncludeAsync( object entity, IReadOnlyList <INavigation> navigationPath, IReadOnlyList <AsyncRelatedEntitiesLoader> relatedEntitiesLoaders, CancellationToken cancellationToken, int currentNavigationIndex, bool queryStateManager) { if (entity == null || currentNavigationIndex == navigationPath.Count) { return; } var navigation = navigationPath[currentNavigationIndex]; var keyComparer = IncludeCore(entity, navigation); var key = navigation.GetTargetType().FindPrimaryKey(); LoadNavigationProperties( entity, navigationPath, currentNavigationIndex, await AsyncEnumerableExtensions.Select(relatedEntitiesLoaders[currentNavigationIndex](keyComparer), async(eli, ct) => { var targetEntity = GetEntity(key, eli, queryStateManager, throwOnNullKey: false); await IncludeAsync( targetEntity, navigationPath, relatedEntitiesLoaders, ct, currentNavigationIndex + 1, queryStateManager); return(targetEntity); }) .Where(e => e != null) .ToList(cancellationToken)); }
public async static Task <string[]> BasicallyRun( this Pipeline.Function fun, string token, int i = 0, string[]?tokens = null !) { var result = new List <string>(); var cancellationToken = new CancellationToken(); await foreach (Token t in fun( new Token(token), i, tokens is null ? AsyncEnumerableExtensions.Empty <Token>() : tokens .Select(s => new Token(s)) .ToAsyncEnumerable(cancellationToken), cancellationToken)) { result.Add(t.String); } return(result.ToArray()); }
public IAsyncEnumerable <SearchResult> SearchAsync(string query, CancellationToken cancellationToken = default) { return(AsyncEnumerableExtensions.Empty <SearchResult>()); }
public ValueTask <TestType> Test_SingleAsync_Method() => AsyncEnumerableExtensions.FirstAsync(new OptimizedAsyncEnumerable <TestType>());
public async Task PurgeAsync(int count, bool self = true, bool silent = false) { var channel = Context.Channel as ITextChannel; var request = await AsyncEnumerableExtensions.FlattenAsync( channel.GetMessagesAsync(Context.Message.Id, Direction.Before, count) ); if (!request.Any()) { await Context.Message.AddReactionAsync(new Emoji("❌")); return; } var messageCount = 0; var filtered = request .Where(m => { if (!self) { return(false); } try { return(m is IUserMessage && (DateTimeOffset.UtcNow - m.CreatedAt).TotalDays < 14); } finally { messageCount++; } }); var messages = filtered as IMessage[] ?? filtered.ToArray(); if (self) { await Context.Message.DeleteAsync(); } await channel.DeleteMessagesAsync(messages).ConfigureAwait(false); if (silent) { return; } var sb = new StringBuilder(); sb.AppendLine($"Deleted `{messageCount}` messages."); sb.AppendLine(); foreach (var author in messages.GroupBy(b => b.Author.Id)) { var u = Context.Guild.GetUser(author.Key); sb.AppendLine($"**{u?.ToString() ?? author.Key.ToString()}**: {author.Count()} messages"); } var ok = await EmbedResponseAsync(ResponseFormat.Success, description : sb.ToString()); await Task.Delay(3000); await ok.DeleteAsync(); }
/// <inheritdoc /> public Async::System.Collections.Generic.IAsyncEnumerable <StructResult <StrongFingerprint> > EnumerateStrongFingerprints(Context context) { var ctx = new OperationContext(context); return(AsyncEnumerableExtensions.CreateSingleProducerTaskAsyncEnumerable <StructResult <StrongFingerprint> >(() => _database.EnumerateStrongFingerprintsAsync(ctx))); }
public ValueTask <int[]> Hyperlinq_AsyncEnumerable_Value() => AsyncEnumerableExtensions.AsAsyncValueEnumerable <TestAsyncEnumerable.AsyncEnumerable, TestAsyncEnumerable.AsyncEnumerable.AsyncEnumerator, int>( asyncEnumerableValue, (enumerable, cancellationToken) => enumerable.GetAsyncEnumerator(cancellationToken)) .ToArrayAsync();
private async Task IncludeAsync( object entity, IReadOnlyList <INavigation> navigationPath, IReadOnlyList <AsyncRelatedEntitiesLoader> relatedEntitiesLoaders, CancellationToken cancellationToken, int currentNavigationIndex, bool queryStateManager) { if (entity == null || currentNavigationIndex == navigationPath.Count) { return; } EntityKey primaryKey; Func <ValueBuffer, EntityKey> relatedKeyFactory; var targetEntityType = IncludeCore( entity, navigationPath[currentNavigationIndex], out primaryKey, out relatedKeyFactory); var keyProperties = targetEntityType.GetPrimaryKey().Properties; var entityKeyFactory = _entityKeyFactorySource .GetKeyFactory(targetEntityType.GetPrimaryKey()); LoadNavigationProperties( entity, navigationPath, currentNavigationIndex, await AsyncEnumerableExtensions.Select(relatedEntitiesLoaders[currentNavigationIndex](primaryKey, relatedKeyFactory), async(eli, ct) => { var entityKey = entityKeyFactory .Create(keyProperties, eli.ValueBuffer); object targetEntity = null; if (entityKey != EntityKey.InvalidEntityKey) { targetEntity = GetEntity( targetEntityType, entityKey, eli, queryStateManager); } await IncludeAsync( targetEntity, navigationPath, relatedEntitiesLoaders, ct, currentNavigationIndex + 1, queryStateManager); return(targetEntity); }) .Where(e => e != null) .ToList(cancellationToken)); }
public IAsyncEnumerable <StructResult <StrongFingerprint> > EnumerateStrongFingerprints(Context context) { var ctx = new OperationContext(context); return(AsyncEnumerableExtensions.CreateSingleProducerTaskAsyncEnumerable(() => EnumerateStrongFingerprintsAsync(ctx))); }
public static Task <List <T> > EvalAsync <T>(this IQueryable <T> source) => AsyncEnumerableExtensions.ToListAsync(source);