c # – Encapsulation permit logic, but seeking to avoid circular dependence

I am trying to encapsulate the permission logic for a particular view model so that the permission logic has access to the object of the view model, but it is also exposed within it.

Trivial implementation:

public class ClientViewModel
{
Public customer Client {obtain; set; }

/ * permission section * /
public bool CanVote => Client.Age> 18
public bool CanDrink => Client.Age> 21
}

The implementation is quite clean and simple. The view should take many decisions based on the set of properties available within the permissions. But there will be many permits, so ideally I would like to contain that logic elsewhere.

Right now I can access like this:

var vm = new ClientViewModel () {Client = myClient};
vm.CanVote

But I would like to contain all the logic within a single class and access it like this:

vmPermissions.CanVote

Circular Implementation

So I can put a property of type ClientViewModelPermissions in the own ViewModel. You must have access to the data objects in the ViewModel you are describing, so that you can pass the instance of the model to the permission constructor and update it during the construction of the same model, like this:

public class ClientViewModel
{
Public ClientViewModel ()
{
// create instance of permissions for the current object
Permissions = new ClientViewModelPermissions (this);
}

Public customer Client {obtain; set; }

public permissions ClientViewModelPermissions {get; set; }
}

public class ClientViewModelPermissions
{
Public ClientViewModelPermissions (ClientViewModel clientVm)
{
// the permissions must describe a particular view model
ClientModel = clientVm;
}

private ClientViewModel ClientModel {get; set; }

public bool CanVote => ClientModel.Client.Age> 18
public bool CanDrink => ClientModel.Client.Age> 21
}

So each class contains one reference to the other as a property. Should this be avoided for some reason? Is there a cleaner way to evaluate the properties of a given class, but to keep that logic separate from the real class by decorating it in some way?

Here is an image with the previous code that shows the flow of dependencies between classes.