C＃泛型转换问题

Question

I have a generic Filter class, and I want to make a conditional version of this class:

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);
        }
    }
}

Is there any way to avoid boxing in the GetResult return expression?

Answer 1

This seems to compile..

What I've added is a where S: R If that's what You were looking for

 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);
            }
        }
    }

Basically what this means - is that it's required that 'S' will be inherited from 'R'

Answer 2

The question for me - is why are You introducing an additional type S ? I believe that in both cases having only 'T' and 'R' defined should be enough.. and the it would look like this

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);
        }
    }
}

What this is saying - is that the result R will be a derived type from T, so it could be passed back into the 'GetResult' function as if it was of type T