Problems understanding LINQ syntax. returned error

The cause of your error has nothing to do with Distinct(), nor with ToList(). The error is reported here, because this is the moment that the query that you defined is executed.

I think the problem is in the Select, this looks a bit weird to me.

You have to debug to find out if the problem is in the dbContext, the Where or the Select.

Add some intermediate test code, every time execute the query.

var a = context.COMP_REC_ENC.ToList();
var b = context.COMP_REC_ENC
        .Where(m => m.Year == currYear)
        .ToList();
var c = context.COMP_REC_ENC
        .Where(m => m.Year == currYear)
        .Select(m => new PoolManager
        {
            Planning_manager_ID = COMP_REC_ENC.Planning_Manager_ID
        })
        .ToList();

In words: the context has a sequence of items with the cryptical name COMP_REC_ENC. Every item in this sequence has a property Year. Keep only those COMP_REC_ENC from the sequence that have a value for this property equal to currYear

First of all: currYear is an int. Is property Year also an int? If so, the problem is not in the Where.

Next, from every item in the remaining sequence of COMP_REC_ENC objects, make one new PoolManager. Only property Planning_manager_ID is filled. The value used to fill Planning_manager_ID is COMP_REC_ENC.Planning_Manager_ID

Here comes the strange part: I had expected that you would use one of the properties of the current COMP_REC_ENC to fill the Planning_Manager_ID. I think you will find the problem here.

Planning_manager_ID = 

How to prevent this kind of problems in future

I have several advices for you:

• Don't mix LINQ method syntax with LINQ query syntax, people coming from SQL world like the query syntax more. People coming from C# world probably prefer method syntax. Method syntax is more flexible, because it is easy to add new LINQ-like methods.
• Try to give your identifiers meaningful names, so every reader will know immediately what they stand for. Use plural nouns for sequences of similar items, use singular nouns for elements from these sequences.
• Don't think that saving on typing by using short identifiers will finish your project earlier. The saved time is nothing compared to the time needed for others to understand the code when they have to change / test / reuse it.

If the dbContext class is already used widely, I can understand that it will be hard to convince your project leader to change the dbContext. So you'll have to stick with that.

I haven't got a clue what items are stored in your dbSet COMP_REC_ENC, so I'll just give an example to show how much clearer your query will be if you stick to these rules

class ComputerPlanning
{
    public int Id {get; set; }                 // primary key
    ...

    public int Year {get; set;}   
    public int PlanningManagerId {get; set;}   // The foreign key to the planning manager
                                               // who created this planning
}

class PlanningDbContext : DbContext
{
    public DbSet<ComputerPlanning> ComputerPlannings {get; set;}
}
    

Your query according to the guidelines:

Requirement: from all computer plannings in the table of ComputerPlannings, keep only those computer plannings that have a Year equal to currentYear. From every remaining ComputerPlanning make one PoolManager with a value of PlanningManagerId equal to the computer planning PlanningManagerId. Remove duplicates and put it all in a list.

int currentYear = ...
List<PoolManager> poolManagers = planningContext.ComputerPlannings
    .Where(computerPlanning => computerPlanning.Year == currentYear)
    .Select(computerPlanning => new PoolManager
    {
         PlanningManagerId = computerPlanning.PlanningManagerId,
    })
    .Distinct()
    .ToList();

Because I stuck to the conventions, it is easy to see for everyone whoe reads the code to see that the code does what the requirement says.

By the way, if you had made an error in Planning_manager_ID = ..., your compiler would probably have found the problem already, instead of run time.