您可以使用类似构建器模式的东西：

public class PipelineBuilder<TMessage,TMessageHandler>() where TMessage: IMessage, TMessageHandler : IMessageHandler
{
   private List<Type> filters = new List<Type>();

   public PipeLineBuilder<TMessage,TMessageHandler> WithFilter<TFilter>() where TFilter : BaseFilter
   {
      filters.Add(typeof(TFilter));
      return this;
   }

   public void Register()
   {
      var pipeLine = new PipeLine()
      {
          Filters = filters,
          MessageHandler = typeof(TMessageHandler)
      };
      pipeLines[typeof(TMessage)] = pipeLine;
   }
}

用法是

 new PipelineBuilder<Message2, MessageHandler2>()
       .WithFilter<LogFilter>()
       .WithFilter<ValidFilter>()
       .Register();

Why don’t you prefer to use params keyword? If you do so, we can handle multiple filters without creating separate overloads for each number of filters.

internal static void RegisterPipeLine<TMessage, THandler>(params Type[] filterTypes)
    where TMessage : IMessage
    where THandler : IMessageHandler
{
    var pipeLine = new PipeLine()
    {
        Filters = filterTypes,
        MessageHandler = typeof(THandler)
    };
    pipeLines[typeof(TMessage)] = pipeLine;
}

We can call as such.

Mediator.RegisterPipeLine<Message1, MessageHandler1>(typeof(LogFilter), typeof(ValidFilter));

By doing so, we can call with any number of filter types.

I think this would work with adding a helper class and an interface (for covariance) to achieve full compile time safety.
The cost for me is negligible as we instantiate empty objects that won’t put too much pressure on the GC.

public class TypeOf<T> : ITypeOf<T> {
    public Type Type => typeof(T);
    public static TypeOf<T> Get => new TypeOf<T>(); // convenience
}

public interface ITypeOf<out T> {
    Type Type { get; }
}

internal static void RegisterPipeLine<T1, T2, T3>(params ITypeOf<T2>[] baseFilters)
      where T1 : IMessage
      where T2 : BaseFilter
      where T3 : IMessageHandler
  {
      var pipeLine = new PipeLine()
      {
          Filters = baseFilters.Select(x => x.Type).ToList()
          MessageHandler = typeof(T3)
      };
      pipeLines[typeof(T1)] = pipeLine;
  }

Usage is

RegisterPipeLine<,BaseFilter,>(TypeOf<LogFilter>.Get, TypeOf<ValidFilter>.Get);

Here is my take on it. Using two builders.

static void Main(string[] args)
{
    var builder = new PipelineBuilder();
    builder
        .AddPipeLine<Message1, MessageHandler1>()
            .WithFilter<LogFilter>()
            .WithFilter<ValidFilter>();
    builder
        .AddPipeLine<Message2, MessageHandler2>()
            .WithFilter<LogFilter>();

    var pipelines = builder.Build();
}

public class PipelineBuilder()
{
    private List<(Type message, Type handler, FilterBuilder builder)> items = new();

    public IFilterBuilder AddPipeLine<T1, T2>()
         where T1 : IMessage
         where T2 : IMessageHandler
    {
        var filterBuilder = new FilterBuilder();
        items.Add((typeof(T1), typeof(T2), filterBuilder));

        return filterBuilder;
    }

    public IReadOnlyDictionary<Type, PipeLine> Build()
    {
        var pipelines = new Dictionary<Type, PipeLine>();
        foreach (var (message, handler, builder) in items) 
        {
            pipelines.Add(
                message, 
                new PipeLine()
                {
                    Filters = builder.Filters,
                    MessageHandler = handler
                });
        }
        return pipelines;
    }
}

public class FilterBuilder : IFilterBuilder
{
    public List<Type> Filters { get; } = new();

    public IFilterBuilder WithFilter<T>() where T : BaseFilter
    {
        Filters.Add(typeof(T));
        return this;
    }
}

public interface IFilterBuilder
{
    IFilterBuilder WithFilter<T>() where T : BaseFilter;
}

If I were you, I would prefer to use the Chain of Responsibility pattern for filter. It’s more nature for your implementation example.

public abstract class BaseFilter
{
    public abstract bool Filter();
}

public abstract class BaseFilter<T>: BaseFilter where T : BaseFilter, new()
{
    private readonly T _innerFilter;

    protected BaseFilter()
    {
        _innerFilter = new T();
    }

    public override bool Filter(IMessage message) 
    {
        _innerFilter.Filter(message);
        return true; //// e.g.
    }
}

This will give you flexibility of using different filters in conjunction with each other.
As for example

public bool Filter(IMessage message)
{
    return _innerFilter.Filter(message) && message.Contains("test"); //// e.g.
}

Your call side of the code won’t change, and it might look like

Mediator.RegisterPipeLine<Message1, ValidFilter<LogFilter>, MessageHandler1>();

. The implementation of this pattern for your case might be different and look like builder that also described here.