C# 调用具有不同类型的相同扩展函数作为参数（可能是委托？）答案

【问题标题】：C# call same extended function with different type as parameter (maybe delegates ?)C# 调用具有不同类型的相同扩展函数作为参数（可能是委托？）
【发布时间】：2021-11-13 00:17:24
【问题描述】：

我正在尝试为我的项目构建一个规则检查器，该检查器在规则列表中循环，如果其中任何一个的标志为真，则返回我。下面是我作为示例编写的代码（不是实际代码，请忽略最终未观察到的最佳实践或细节）。

using System.Collections;
using System.Collections.Generic;
using System.Linq;

public interface ICounterValued {
    int CounterValue {get;}
    int CounterLimit {get;}
}

public interface ITimeValued {
    float ElapsedTime {get;}
    float TimeLimit {get;}
}

public class MyMainClass : ICounterValued , ITimeValued {
    // Counter data
    private int     _counterValue   = 0;
    private int     _counterLimit   = 10;
    // Time data
    private float   _elapsedTime    = 0;
    private float   _timeLimit      = 10f;
    // ICounterValued
    public int      CounterValue    => _counterValue;
    public int      CounterLimit    => _counterLimit;
    // ITimeValued
    public float    ElapsedTime     => _elapsedTime;
    public float    TimeLimit       => _timeLimit;

    public RuleChecker  ruleChecker;

    public void InitializeMe(){
        ruleChecker = new RuleChecker();
        ruleChecker.rules.Add( new TimeRule() );
        ruleChecker.rules.Add( new CounterRule() );
    }

    public void UpdateRuleChecker(){
        ruleChecker.CheckRules<MyMainClass>( this );
    }

    public bool NeedToStop(){
        return ruleChecker.SomeRuleTriggered();
    }
}

public class RuleChecker {
    public List<Rule> rules = new List<Rule>();

    public void CheckRules<T>( T data ){
        rules.ForEach( x => x.UpdateMe<T>(data) );
    }

    public bool SomeRuleTriggered(){
        return rules.Any( x => x.IsTriggered() );
    }
}

public abstract class Rule {
    protected bool _triggered;

    public virtual bool IsTriggered() =>  _triggered;
    // check logic that will set the _triggered flag to true
    public abstract void UpdateMe<T>( T data );
}

public class TimeRule : Rule {
    public override void UpdateMe<ITimeValued>( ITimeValued data ){
        _triggered = (data.ElapsedTime >= data.TimeLimit);
    }
}

public class CounterRule : Rule {
    public override void UpdateMe<ICounterValued>( ICounterValued data ){
        _triggered = (data.CounterValue >= data.CounterLimit);
    }
}

这样做的目的是在未来对具有一个或多个接口的不同“MainClasses”使用相同的规则检查器，并且可以重用这些规则或添加新的规则，如具有自己的触发逻辑的“模块”。

上面的代码不起作用，因为当我调用通用 void（UpdateMe<ICounterValued> 和 UpdateMe<ITimeValued>）时，数据值无法访问我在接口内定义的属性（CounterValue，CounterLimit，ElapsedTime， TimeLimit)。

我假设这种 void 泛型方法存在一些转换或接口问题；我没有必要使用泛型，但我没有找到更聪明的解决方案；我已经在Rule 类中尝试了将代表作为UpdateMe 的参数的一些东西，但是没有任何东西可以用不同的类型参数进行扩展，并让规则检查器通过为每个参数传递MyMainClass 的实例来调用所有内容。

感谢 andavace 的任何建议。

【问题讨论】：

你得到的确切错误是什么，错误到底在哪里？
我想，但我不确定问题是你在Rule.UpdateMe<T> 中对T 没有限制，允许访问属性。我想我可以创建一个基本接口public interface IValued { int Value { get; } int Limit { get; } }，然后显式实现ICounterValued 和ITimeValued（暂时忽略int/float）。到目前为止我找不到魔法酱。我希望这个漫无边际的帮助
@Flydog57 错误为'ITimeValued' does not contain a definition for 'ElapsedTime' and no accessible extension method 'ElapsedTime' accepting a first argument of type 'ITimeValued' could be found (are you missing a using directive or an assembly reference?)，所有其他属性都相同。如果我总是知道界面内将包含什么类型的数据，则可以完成您的解决方案。我正在尝试实现的实际用途，例如，使用更复杂的接口，例如：``` public interface ITimer { AdvancedTimer Timer { get; } } ```
是的，我复制了你的代码并试图让它编译，得到了同样的错误。这是因为T 缺少约束。你不能在T 上调用某些东西，除非T 以允许调用发生的方式受到限制。我现在想已经太晚了，但你的问题让我很感兴趣。一旦我离开，我可能会想出一个解决方案。
@Flydog57 我认为你是对的，UpdateMe 的覆盖使 data 属性被视为通用 T 值，而不是被覆盖的接口类型。泛型解决方案看起来太有限，无法做如此不均匀的事情；也许与返回 bool 的代表的事情是可行的。

标签： c# generics interface delegates extends

【解决方案1】：

以这种方式构建（您的方法）对我来说更有意义：

public class RuledClass{
    public List<Rule> Rules = new List<Rule>();
    
    public bool AnyViolated(){
        return Rules.Any(r => r.IsViolated());
    }
}

public class MyMainClass : RuledClass, ICounterValued , ITimeValued {
    // Counter data
    public int     CounterValue {get;set;} 
    public int    CounterLimit  {get;set;} 
    // Time data
    public float  ElapsedTime   {get;set;} 
    public float  TimeLimit   {get;set;}   
    // ICounterValued
    

    public MyMainClass(){
        Rules.Add( new TimeRule(this) );
        Rules.Add( new CounterRule(this) );
    }
}

public abstract class Rule {
    public abstract bool IsViolated();
}

public class TimeRule : Rule {
    private ITimeValued _thing;
    public TimeRule(ITimeValued thing){
        _thing = thing;
    }
    public override bool IsViolated(){
        return (_thing.ElapsedTime >= _thing.TimeLimit);
    }
}
public class CounterRule : Rule {
    private ICounterValued _thing;
    public CounterRule(ICounterValued thing){
        _thing = thing;
    }
    public override bool IsViolated(){
        return (_thing.CounterValue >= _thing.CounterLimit);
    }
}

按照你的方法，我无法弄清楚为什么 X 类会有一个可以将 Y 类传递给的规则列表；它们适用的规则和类在我的脑海中是联系在一起的。因此我在构建时建立了这个链接

..但即使那样我也不知道我是否会这样做

我想我更有可能做这样的事情：

public class RuledClass{
    public List<Func<bool>> Rules = new List<Func<bool>>();
    
    public bool AnyViolated(){
        return Rules.Any(r => r());
    }
}

public class MyMainClass : RuledClass {
    // Counter data
    public int     CounterValue {get;set;} 
    public int    CounterLimit  {get;set;} 
    // Time data
    public float  ElapsedTime   {get;set;} 
    public float  TimeLimit   {get;set;}   
    // ICounterValued
    

    public MyMainClass(){
        Rules.Add(()=>ElapsedTime>TimeLimit);
        Rules.Add(()=>CounterValue>CounterLimit);
    }
}

【讨论】：

第一个代码是最接近的，我只是在我的代码中尝试了解决方案，通过一些调整，我可以让它在规则的构造函数中发送实例并将 MyMainClass 实例存储为像你一样的接口写道：private ICounterValued _thing;。扩展 RuledClass 不是一个好主意，因为 MyMainClass 通常需要扩展另一个不是 Ruled 的基类。第二种解决方案过于面向我的示例代码，例如，我必须在每个需要 TimeLimit 规则或 Counter Rule 的类中编写“违规逻辑”。
我只做了一个 RuledClass 因为我不想每次都提供一个 rules 属性定义；如果您乐于在 IRuleable 的任何地方重复规则定义，则可以将其设为接口。 第二种解决方案过于以我的示例代码为导向 - 这就是我害怕提供人为示例的结果.. 我必须编写“违规逻辑” - 但是通过使其成为接口，您必须“在每个需要 X 的类中编写更多属性”。第二个的逻辑非常简单，并且确实允许一个类设置自己疯狂的变化规则。
..没有无休止的接口，它们的实现以及支持它们的实例。.正如所呈现的那样，它使一个类负责检查它是否有效，但我认为没有理由外部类无法给出位于数组中的规则集Funcs

【解决方案2】：

我找到了一个似乎可行的解决方案，并且与我正在寻找的解决方案接近。 @Caius Jard 的第一个解决方案也有效，但我认为最好避免将检查实例指向规则的变量中。在我的问题中的相同示例代码下方，但更新代码旁边有 cmets：

using System.Collections;
using System.Collections.Generic;
using System.Linq;

public interface ICounterValued {
    int CounterValue {get;}
    int CounterLimit {get;}
}

public interface ITimeValued {
    float ElapsedTime {get;}
    float TimeLimit {get;}
}

public class MyMainClass : ICounterValued , ITimeValued {
    // Counter data
    private int     _counterValue   = 0;
    private int     _counterLimit   = 10;
    // Time data
    private float   _elapsedTime    = 0;
    private float   _timeLimit      = 10f;
    // ICounterValued
    public int      CounterValue    => _counterValue;
    public int      CounterLimit    => _counterLimit;
    // ITimeValued
    public float    ElapsedTime     => _elapsedTime;
    public float    TimeLimit       => _timeLimit;

    public RuleChecker  ruleChecker;

    public void InitializeMe(){
        ruleChecker = new RuleChecker();
        ruleChecker.rules.Add( new TimeRule() );
        ruleChecker.rules.Add( new CounterRule() );
    }

    // I don't need this anymore, the condition will be checked
    // inside SomeRuleTriggered
    // public void UpdateRuleChecker(){
    //     ruleChecker.CheckRules<MyMainClass>( this );
    // }

    public bool NeedToStop(){
        // The instance will be passed as argument
        // return ruleChecker.SomeRuleTriggered();
        return ruleChecker.SomeRuleTriggered( this );
    }
}

public class RuleChecker {
    public List<Rule> rules = new List<Rule>();

    // As commented above, I don't need to update a stored 
    // flag in Rule (and direved) anymore
    // public void CheckRules<T>( T data ){
    //     rules.ForEach( x => x.UpdateMe<T>(data) );
    // }

    // Now the instance will be passed as a generic object and parsed
    // inside IsTriggered method
    // public bool SomeRuleTriggered(){
    //     return rules.Any( x => x.IsTriggered() );
    // }
    public bool SomeRuleTriggered( object target ){
        return rules.Any( x => x.IsTriggered( target ) );
    }
}

public abstract class Rule {
    // No need to update a falg anymore
    // protected bool _triggered;

    // No need to update a falg anymore
    // public virtual bool IsTriggered() =>  _triggered;

    // No need to update a falg anymore
    // public abstract void UpdateMe<T>( T data );
    public abstract bool IsTriggered( object target );
}

public class TimeRule : Rule {
    // No need to update a falg anymore
    // public override void UpdateMe<ITimeValued>( ITimeValued data ){
    //     _triggered = (data.ElapsedTime >= data.TimeLimit);
    // }
    public override bool IsTriggered( object target ){
        ITimeValued target_timed = target as ITimeValued;
        if( null == target_timed)
            return false;

        return (target_timed.ElapsedTime >= target_timed.TimeLimit);
    }
}

public class CounterRule : Rule {
    // No need to update a falg anymore
    // public override void UpdateMe<ICounterValued>( ICounterValued data ){
    //     _triggered = (data.CounterValue >= data.CounterLimit);
    // }
    public override bool IsTriggered( object target ){
        ICounterValued target_counter = target as ICounterValued;
        if( null == target_counter)
            return false;

        return (target_counter.CounterValue >= target_counter.CounterLimit);
    }
}

如您所见，RuleChecker 可以调用任何Rule 派生类的方法，将检查实例作为通用object 传递。任何扩展 Rule 的类都可以实现他的规则逻辑覆盖 IsTriggered，并在内部进行显式转换，然后最终开始检查。

【讨论】：