Question

我有一个通用的Filter类，我想创建这个类的条件版本：

public abstract class Filter<T, R> 
{
    protected abstract R GetResult(T input);

    private class JoinedFilterIf<S> : Filter<T, S>
    {
        private readonly Filter<T, R> _left;
        private readonly Filter<R, S> _right;
        private readonly Func<R, bool> _condition;

        public JoinedFilterIf(Filter<T, R> left, Filter<R, S> right, Func<R, bool> condition)
        {
            _left = left;
            _right = right;
            _condition = condition;
        }

        protected override S GetResult(T input)
        {
            var result = _left.GetResult(input);
            return _condition(result) ? _right.GetResult(result) : (S)((object)result);
        }
    }
}

有没有办法避免在GetResult返回表达式中装箱？

Answer 1

这似乎是编译..

我添加的内容是where S: R 如果这就是你要找的东西

 public abstract class Filter<T, R>
    {
        protected abstract R GetResult(T input);

        private class JoinedFilterIf<S> : Filter<T, S> where S : R
        {
            private readonly Filter<T, R> _left;
            private readonly Filter<R, S> _right;
            private readonly Func<R, bool> _condition;

            public JoinedFilterIf(Filter<T, R> left, Filter<R, S> right, Func<R, bool> condition)
            {
                _left = left;
                _right = right;
                _condition = condition;
            }

            protected override S GetResult(T input)
            {
                var result = _left.GetResult(input);
                return _condition(result) ? _right.GetResult(result) : (S)(result);
            }
        }
    }

基本上这意味着什么 - 它需要＆＃39; S＆＃39; S＆＃39;将继承自＆＃39; R＆＃39;

Answer 2

对我来说问题 - 你为什么要引入另外一种S？我相信在这两种情况下只有“T＆＃39;和＆＃39; R＆＃39;定义应该足够..它看起来像这样

public abstract class Filter<T, R> where R : T
{
    protected abstract R GetResult(T input);

    private class JoinedFilterIf<S> : Filter<T, R> 
    {
        private readonly Filter<T, R> _left;
        private readonly Filter<T, R> _right;
        private readonly Func<R, bool> _condition;

        public JoinedFilterIf(Filter<T, R> left, Filter<T, R> right, Func<R, bool> condition)
        {
            _left = left;
            _right = right;
            _condition = condition;
        }

        protected override R GetResult(T input)
        {
            var result = _left.GetResult(input);
            return _condition(result) ? _right.GetResult(result) : (result);
        }
    }
}

这就是说 - 结果R将是来自T的派生类型，因此可以将其传递回＆＃39; GetResult＆＃39;功能就好像它是T型

C＃泛型投射问题

2 个答案: