Как указать тип параметра как тип производного класса при переопределении абстрактной функции, где параметр является типом базового класса?

У вас есть несколько вариантов. Вероятно, вы хотите указать, что все производные классы, реализующие LimitsPassed, используют параметр, производный от класса Limits.

Пример:

    public abstract class Result
    {
        public abstract bool LimitsPassed<T>(T limits) where T:Limits;
    }

    public class SpecificResult : Result
    {
        public override bool LimitsPassed<T>(T limits)
        {
            throw new NotImplementedException();
        }
    }

    public abstract class Limits
    {

    }

    public class SpecificLimits : Limits
    {

    }

Другой вариант заключается в том, имеет ли объект, переданный в LimitsPassed, логически согласованный контракт, и в этом случае вы можете использовать подход на основе интерфейса.

Пример:

    public abstract class Result
    {
        public abstract bool LimitsPassed(ILimits limits);
    }

    public class SpecificResult : Result
    {
        public override bool LimitsPassed(ILimits limits)
        {
            //specify parameter base type to particular type of derived class
        }
    }

    public interface ILimits
    {

    }

    public class SpecificLimits : ILimits
    {

    }

Обычной практикой является переопределение метода базового класса и определение другого метода для конкретного типа. Проверьте тип параметра в переопределенном методе и передайте его конкретному методу для дальнейшей обработки.

public class SpecificResult : Result
{
    public override bool LimitsPassed(Limits limits)
        => limits is SpecificLimits specificLimits ?
           LimitsPassed(specificLimits) :
           throw new ArgumentException(); // or false

    public bool LimitsPassed(SpecificLimits limits) 
    {
        //specify parameter base type to particular type of derived class
    }
}

Другой подход заключается в использовании отражения для приведения параметра из его базового типа в ожидаемый производный тип. Однако вам все равно придется обрабатывать случай, когда параметр не является ожидаемым типом.

public class SpecificResult : Result
{
    public override bool LimitsPassed(Limits limits) {
        if (limits is SpecificLimits specificLimits) {
            // Do something with specificLimits
        } else {
            // TODO: Handle case where Limits provided are not SpecificLimits
            throw new ArgumentException("Limits must be of type SpecificLimits");
        }
    }
}

Судя по комментариям и вашему вопросу, я не вижу ничего общего с Limits, так что, возможно, у нас может быть базовый Result класс, который будет выглядеть так (я сделал LimitsPassed return null вместо того, чтобы генерировать исключения для недопустимых типов пределов, но это вопрос выбора конечно)

public abstract class Result {
    // can be bool but then we have to throw exceptions
    // when invalid Limits type
    public abstract bool? LimitsPassed(object limits);

    // helps us when we have List<Result>
    // so we can filter the results that support the limit
    // check for certain Limit Types
    public abstract Type[] AllowedLimitTypes { get; }
}

это будет обрабатывать случаи, когда у нас есть несколько возможных типов ограничений в наших производных классах.

У нас также может быть удобная универсальная версия для одного типа лимита, которую легко переопределить.

public abstract class Result<TLimit> : Result {
    Type[] _types = new Type[] { typeof(TLimit) };
    public override Type[] AllowedLimitTypes => _types;

    // default implementation so we don't have to do it every time in our derived classes
    // sealed override doesn't allow derived classes to break the contract 
    // of having just a single limit as generic parameter 
    // (for example by including checks for multiple limits types in this method)
    // those classes should derive from the non-generic Result instead
    public sealed override bool? LimitsPassed(object limits) {
        if (limits is TLimit tLimit) return LimitsPassed(tLimit);
        return null;
    }
    public abstract bool LimitsPassed(TLimit limits);
}

public class SpecificResult : Result<SpecificLimits> {
    public double MeasureA { get; set; }
    public string MeasureB { get; set; }

    public override bool LimitsPassed(SpecificLimits limits) {
        return this.MeasureA >= limits.MeasureA_min
                && this.MeasureA <= limits.MeasureA_max
                && this.MeasureB == limits.MeasureB_master;
    }
}

Для нескольких типов лимитов у нас есть немного больше работы:

public class SpecificResult2 : Result {

    Type[] _types = new Type[] { typeof(SpecificLimits), typeof(SpecificLimits2) };
    public override Type[] AllowedLimitTypes => _types;

    public override bool? LimitsPassed(object limits) {
        return limits switch {
            SpecificLimits specLimits => LimitsPassed(specLimits),
            SpecificLimits2 specLimits2 => LimitsPassed(specLimits2),
            _ => null
        };
    }

    public bool LimitsPassed(SpecificLimits limits) {
        // implementation
        return true;
    }

    public bool LimitsPassed(SpecificLimits2 limits) {
        // implementation
        return true;
    }
}

У нас также могут быть общие удобные классы для более распространенных случаев — два или три TLimits:

public abstract class Result<TLimit1,TLimit2> 
public abstract class Result<TLimit1,TLimit2,TLimit3>