public class EncryptedPropertiesConvention : ConventionBase, IPostProcessingConvention
{
    public const string ConventionName = "Encryption";
    private readonly IKeyResolver _keyResolver;
    private readonly ConcurrentDictionary<SecretId, AsyncLazy<SymmetricKeyDto[]>> _keyCache;
    private readonly ConcurrentDictionary<Type, IBsonSerializer> _serializerCache;

    private EncryptedPropertiesConvention(IKeyResolver keyResolver)
    {
        this._keyResolver = keyResolver;
        this._keyCache = new ConcurrentDictionary<SecretId, AsyncLazy<SymmetricKeyDto[]>>();
        this._serializerCache = new ConcurrentDictionary<Type, IBsonSerializer>();
    }

    /// <summary>
    /// Applies a post processing modification to the class map.
    /// </summary>
    /// <param name="classMap">The class map.</param>
    public void PostProcess(BsonClassMap classMap)
    {
        foreach (var memberMap in classMap.DeclaredMemberMaps.Where(x => x.MemberInfo.GetCustomAttribute<SensitiveInformationPropertyAttribute>() != null))
        {
            var serializer = memberMap.GetSerializer();
            memberMap.SetSerializer(this.CreateSerializer(serializer));
        }
    }

    public static void Register(IKeyResolver keyResolver)
    {
        // Clear pre-existing encryption before activating new encryption
        ConventionRegistry.Remove(ConventionName);

        ConventionRegistry.Register(
            ConventionName,
            new ConventionPack
            {
                new EncryptedPropertiesConvention(keyResolver),
            },
            EncryptionHelper.HasPropertiesToEncrypt);
    }

    private IBsonSerializer CreateSerializer(IBsonSerializer serializer)
    {
        IBsonSerializer Create(Type t)
        {
            var serializerType = typeof(PropertyEncrypterBsonSerializer<>).MakeGenericType(serializer.ValueType);
            return (IBsonSerializer)Activator.CreateInstance(serializerType, serializer, this._keyResolver, this._keyCache);
        }

        return this._serializerCache.GetOrAdd(serializer.ValueType, Create);
    }
}`
 

public class MyMongoCollection 
{ 
    public Guid PrimaryKey { get; set; } 
    [SensitiveInformationProperty] public IEnumerable<string> UserEnumerable { get; set; } = new List<string>(); 
    [SensitiveInformationProperty] public IReadOnlyCollection<string> UserReadOnly { get; set; } = new List<string>(); 
    [SensitiveInformationProperty] public IList<string> UserList { get; set; } = new List<string>(); } 

    public class User 
    { 
        public User(string name, string email) 
        { 
            this.Name = name; 
            this.Email = email; 
        } 

        public string Name { get; set; } 
        public string Email { get; set; } } 

        private void SimpleUpsert(Guid primaryKey) 
        { 
            var filter = Builders<MyMongoCollection>.Filter.Eq(x => x.PrimaryKey, primaryKey); 
            User[] usersData = { new User("George", "george@email.com") }; 
            var update = Builders<MyMongoCollection>.Update 
                .SetOnInsert(d => d.PrimaryKey, primaryKey) 
                .Set(d => d.UserEnumerable, usersData?.Select(x => x.Email)) 
                .Set(d => d.UserReadOnly, usersData?.Select(x => x.Email)) 
                .Set(d => d.UserList, usersData?.Select(x => x.Email)); 

        // Fetch the collection with the driver 
        // then callls 
        // await collection.UpdateOneAsync(filter, update, new UpdateOptions { IsUpsert = true }); }