C# C返回类型重协方差

我知道这一点以前已经讨论过了，但我还没有找到任何好的解决方案。在这个示例中，我使用了两个返回类型类ClassA和ClassB以及一个返回参数类。我有一个基类，我的ClassXml和ClassText就是从这个基类扩展而来的，我希望防止打印中的特定接口转换。这可能吗

调用ClassXml和ClassText执行方法，这些方法依次调用基类功能，基类功能调用适当的print

   using System;

    namespace ConsoleApplication1
    {
        internal class Program
        {
            public class ClassA
            {
                public string Xml
                {
                    get { return "xml"; }
                }
            }

            public class ClassB
            {
                public char Text
                {
                    get { return 't'; }
                }
            }

            public interface IReturnArgs<out T>
            {
                string Name { get; set; }
                T Source { get; }
            }

            public class ReturnArgs<T> : IReturnArgs<T>
                where T : class
            {
                public string Name { get; set; }

                private T _source;

                public T Source
                {
                    get { return _source ?? (_source = (T) Activator.CreateInstance(typeof (T), new object[] {})); }
                }
            }

            private static void Main(string[] args)
            {
                var classA = new ReturnArgs<ClassA>();
                var classB = new ReturnArgs<ClassB>();

                var xml = new ClassXml();
                xml.Execute(classA);

                var text = new ClassText();
                text.Execute(classB);

                Console.ReadKey();
            }

            public abstract class ClassBase
            {
                public void Execute(IReturnArgs<object> args)
                {
                    // Do something common to both classes e.g. run tasks etc (not shown)
                    // calls print when completed, each call specific to child class.

                    Print(args);
                }

                /// <summary>
                /// Abstract print method. Print invokes the child implementation.
                /// </summary>
                /// <param name="args"></param>
                public virtual void Print(IReturnArgs<object> args){}
            }

            public class ClassXml : ClassBase
            {
                public void Execute(IReturnArgs<ClassA> args)
                {
                    //invoked externally (Main) calling base common functionality. 

                    base.Execute(args);

                    Print(args);
                }

                //print invoked by child class call - Note if invoked in this class then IReturnArgs<ClassA> could be used 
                //and a cast would not be necessary - however, this would separate common calls accross child classes.
                public void Print(IReturnArgs<ClassA> args)
                {
                    Console.WriteLine("ClassA Source {0}", ((IReturnArgs<ClassA>)args).Source.Xml);//ugly cast
                }
            }

            public class ClassText : ClassBase
            {
                public void Execute(IReturnArgs<ClassB> args)
                {
                    //invoked externally (Main) calling base common functionality. 

                    base.Execute(args);
                }

                //print invoked by base class call which requires the cast IReturnArgs<ClassB> from IReturnArgs<object>
                public override void Print(IReturnArgs<object> args)
                {
                    Console.WriteLine("ClassB Source {0}", ((IReturnArgs<ClassB>)args).Source.Text);//ugly cast
                }
            }
        }
    }

---

你似乎做了两次同样的事情

ClassA和ClassB与ClassXML和ClassText的相关性太强

要解决这个问题，可以将ClassXML中的功能放在ClassA中，将ClassText中的功能放在ClassB中

或者，您可以使用GetContent方法实现ToString或其他接口ITextContent，以分别返回XML和文本。这样，您只需要一个ClassContent类，它只调用ITextContent.GetContent

完整的例子：

using System;

namespace ConsoleApplication1
{
    internal class Program
    {
        public Interface ITextContent
        {
           string GetContent();
        }

        public class ClassA : ITextContent
        {
            public string Xml
            {
                get { return "xml"; }
            }

            public string GetContent()
            {
                return this.Xml;
            }
        }

        public class ClassB : ITextContent
        {
            public char Text
            {
                get { return 't'; }
            }

            public string GetContent()
            {
                return this.Text;
            }
        }

        public interface IReturnArgs<out T>
        {
            string Name { get; set; }
            T Source { get; }
        }

        public class ReturnArgs<T> : IReturnArgs<T>
            where T : class
        {
            public string Name { get; set; }

            private T _source;

            public T Source
            {
                get { return _source ?? (_source = (T) Activator.CreateInstance(typeof (T), new object[] {})); }
            }
        }

        private static void Main(string[] args)
        {
            var classA = new ReturnArgs<ClassA>();
            var classB = new ReturnArgs<ClassB>();

            var xml = new ClassContent();
            xml.Execute(classA);

            var text = new ClassContent();
            text.Execute(classB);

            Console.ReadKey();
        }

        public class ClassContent
        {
            public void Execute(IReturnArgs<object> args)
            {
                Print(args);
            }

            public void Print(IReturnArgs<object> args)
            {
                Console.WriteLine(((IReturnArgs<ITextContent>)args).GetContent());
            }
        }
    }
}

---

您真的不应该面临在子类中强制转换的问题，因为基类不应该定义参数类型依赖于子类的方法。基类应该是两者的通用接口，这意味着无论我将什么分配给b和args，基类都应该始终有效：

---

为什么不使用公共接口/基类呢？在这个示例中，有一个基类叫做ClassBase。我试图理解或解决的是如何在子类/父类之间传递ReturnArgs，让它返回不同类型的源属性。谢谢你的帖子。ClassA和ClassB是用来说明T的不同类型的。我试图在子类ClassXml、ClassText中调用execute，而不在基类中使用IReturnArgs，也不在子级强制转换。我的答案仍然是一样的。通过为ClassA和ClassB引入一个通用接口，您可以获得所需的内容，您可以删除子级的强制转换。谢谢您的回答。我现在接受了这个答案。谢谢你的代码。是的，这会起作用，但不幸的是要求我的基类是泛型的。@user3021646它不能/不应该是泛型的原因是什么？

ClassBase b;
IReturnArgs<object> args;

...

b.Print(args);

public abstract class ClassBase<T> {
    public void Execute(IReturnArgs<T> args) { ... }
    public virtual void Print(IReturnArgs<T> args) { ... }
}

public class ClassXml : ClassBase<ClassA> {
   public override void Print(IReturnArgs<ClassA> args) {
       Console.WriteLine("ClassA Source {0}", args.Source.Text);
   }
}