AsyncEnumerable | Defines IAsyncEnumerable , IAsyncEnumerator , ForEachAsync | Reactive Programming library

I am getting the following error when using .NET Core 2.2 and SQL Always Encrypted. Is this supported in 2.2?

Keyword not supported: 'column encryption setting'.

Actually, I run DB migration in my AppContext constructor as you can see there.

Hi I am having issues with assigning roles to users with Identity Framework 5.0.5, .net5.0.5 and a Postgres SQL db.

The code used to assign the roles to users can be seen below with the error below it.

Please help if possible.

Thanks so much!

I have a question about how high memory usage problems are solved in C#.

Let's say I am having a lot of item data in the database. I want to read it all then write that data to separate files and archive it to a zip file. If I get all items data from database at one time, app would timeout cause all memory is used.
What we did in our node js application we found a convenient library and used AsyncEnumerable and streamed items data in smaller pieces to a write stream.
So my question is how it is done in C#? Because I haven't found an option how data could be streamed via Entity Framework? How it is solved and could anybody give some code snippets/examples of what could be used, is it IQueryable or something else? I'm interested in how data could be read from stream by 10000 elements at the time.

I am using the latest version of .NET Core (.NET 5) and Entity Framework Core 6 (preview) to connect to a MySQL database. I am trying to use GroupBy to generate a group by query to execute on the DB server, as described here. Unfortunately, this fails to compile with the error

The call is ambiguous between the following methods or properties: 'System.Linq.Queryable.GroupBy(System.Linq.IQueryable, System.Linq.Expressions.Expression>)' and 'System.Linq.AsyncEnumerable.GroupBy(System.Collections.Generic.IAsyncEnumerable, System.Func)

This error is related to LINQ and EF Core sharing the same methods, and is discussed in detail here. I have tried the suggested workaround of creating extension methods for each LINQ call, with the following code:

We have created a .NET Core API which uses Odata to filter, select, and expand the data. The data is stored in a Microsoft SQL Server database and retrieved through EntityFramework Core (code first). We use Linq projection so the Odata filter is applied directly to the query, but this gives an error in the following situation:

When retrieving a list of results, e.g. authors expanded with books, everything works fine. It gives an error when filtering inside the expanded books e.g.: https://localhost:44316/odata/authors?$expand=Books($filter=Id eq 1)

I have an IAsyncEnumerable stream that contains data downloaded from the web, and I want to save asynchronously each piece of data in a SQL database. So I used the ForEachAwaitAsync extension method from the System.Linq.Async library. My problem is that downloading and saving each piece of data is happening sequentially, while I would prefer if it happened concurrently.

To clarify, I don't want to download more than one pieces of data at the same time, neither I want to save more than one pieces of data at the same time. What I want is that while I am saving a piece of data in the database, the next piece of data should be concurrently downloaded from the web.

Below is a minimal (contrived) example of my current solution. Five items are downloaded and then are saved in the database. Downloading each item takes 1 second, and saving it takes another 1 second:

I have a repository for albums table (album entity) and I do filtering and paging in repository as you see:

I can get objects from EF with request like this:

For a while I've been trying to get my head around the whole async/await model that C# uses for asynchronous code. The addition of async streams (the IAsyncEnumerable type) seemed really cool, especially for some code that I was writing.

Best practice when creating an async method is to include a CancellationToken parameter and use it for cancelling your async processes. (Ideally by passing it to the underlying async method calls used in your method.)

When creating a method that returns an async stream (an IAsyncEnumerable) the documentation states that your CancellationToken parameter should be decorated with the [EnumeratorCancellation] attribute and then the token passed using the .WithCancellation() method on the IAsyncEnumerable itself.

However, I must be doing something wrong because this still triggers warning:

CA2016: Forward the CancellationToken parameter to methods that take one

This warning appears regardless of if I do it the more standard way: