object oriented design – Can someone suggest what pattern I used mistakenly and is it correct in this situation. Any alternative?

Client_1 uses –> IService_1 and thus Service1_impl

public interface IService_1
{
    void DoTask_1();
}

public class Service1_impl : IService_1
{
    private readonly IDepService_1_v1 _depService_4;
    private readonly IDepService_2_v1 _batchdepService_4;
    private readonly IDepService_3_v1 _depService_2;
    private readonly IDepService_4_v1 _depService_3;

    public Service1_impl(
              IDepService_1_v1 depService_4, 
              IDepService_2_v1 batchdepService_4, 
              IDepService_3_v1 depService_2, 
              IDepService_4_v1 depService_3)
    {
        _depService_1 = depService_1;
        _depService_2 = depService_2;
        _depService_3 = depService_3;
        _depService_4 = depService_4;
    }
    
    public void DoTask_1()
    {
      // perform some work with help of all depServices_with_v1.
    }
}

Some new functionality added for Client_2, so I developed like below.

**Client_2 uses –> IService_1_v2 and thus Service_1_v2_impl **

Service_1_v2_impl now depends on IDepService_1_v2, IDepService_2_v2, IDepService_4_v2 which follow same patter. So IDepService_1_v2 has base interface as IDepService_1_v1 and implementation of IDepService_1_v2 has a base class as implementation of IDepService_1_v1 and so on.

public interface IService_1_v2 : IService_1
{
    void DoTask_2();
}

public class Service_1_v2_impl : Service1_impl, IService_1_v2
{
    private readonly IDepService_1_v2 _depService_1;
    private readonly IDepService_2_v2 _batchdepService_2;
    private readonly IDepService_3_v1 _depService_3;
    private readonly IDepService_4_v2 _depService_4;

    public Service1_impl(
              IDepService_1_v2 depService_1, 
              IDepService_2_v2 batchdepService_2, 
              IDepService_3_v1 depService_3, 
              IDepService_4_v2 depService_4)
    {
        _depService_1 = depService_1;
        _depService_2 = depService_2;
        _depService_3 = depService_3;
        _depService_4 = depService_4;
    }
    
    public void DoTask_2()
    {
      // perform some work with help of all_depServices_with_v1.
      base.DoTask_1();
      
      // perform some work with help of all_depServices_with_v1_OR_v2.
    }
}

I got review comment – this may cause interface explosion. so whenever a new requirement/ client going to be added, new set of interfaces. better patter is builder or bridge pattern.

I read through bridge pattern and to me it’s still going to have interfaces explosion.

I didn’t go through any pattern while writing above code, but wondering if above code represent any pattern.