首页 / C# / c# – 与泛型的多态性 – 奇怪的行为

c# – 与泛型的多态性 – 奇怪的行为

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了c# – 与泛型的多态性 – 奇怪的行为，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含9373字，纯文字阅读大概需要14分钟。

内容图文

可插拔框架

想象一个简单的可插拔系统,使用继承多态非常简单：

>我们有一个图形渲染系统
>有不同类型的图形形状(单色,彩色等)需要渲染
>渲染由特定于数据的插件完成,例如, ColorRenderer将渲染ColorShape.
>每个插件都实现了IRenderer,因此它们都可以存储在IRenderer []中.
>启动时,IRenderer []会填充一系列特定的渲染器
>当接收到新形状的数据时,基于形状的类型从阵列中选择插件.
>然后通过调用其Render方法调用插件,将形状作为其基本类型传递.
>在每个后代类中重写Render方法;它将Shape转换回其后代类型,然后呈现它.

希望以上是清楚的 – 我认为这是一种非常常见的设置.使用继承多态和运行时强制转换非常容易.

没有铸造它

现在是棘手的部分.为了回应this question,我想提出一种方法来做到这一切,无需任何铸造.由于IRenderer []数组 – 从数组中获取插件,这通常需要将其转换为特定类型以使用其特定于类型的方法,这是很棘手的,我们不能这样做.现在,我们可以通过仅与其基类成员交互插件来解决这个问题,但部分要求是渲染器必须运行特定于类型的方法,该方法具有特定于类型的数据包作为参数,并且基础class无法做到这一点,因为没有办法将它传递给特定类型的数据包而不将其转移到基础然后再回到祖先.棘手.

起初我认为这是不可能的,但经过几次尝试,我发现我可以通过juking c#generic系统来实现它.我创建了一个与插件和形状类型相反的接口,然后使用它.渲染器的分辨率由特定类型的Shape决定. Xyzzy,逆变界面使得演员不必要.

这是我可以提出的代码的最短版本作为示例.这编译并运行和行为正确：

public enum ColorDepthEnum { Color = 1, Monochrome = 2 }

public interface IRenderBinding<in TRenderer, in TData> where TRenderer : Renderer 
                                                  where TData: Shape  
{ 
    void Render(TData data);
}
abstract public class Shape
{
    abstract public ColorDepthEnum ColorDepth { get; }
    abstract public void Apply(DisplayController controller);
}

public class ColorShape : Shape
{
    public string TypeSpecificString = "[ColorShape]";  //Non-virtual, just to prove a point
    override public ColorDepthEnum ColorDepth { get { return ColorDepthEnum.Color; } }

    public override void Apply(DisplayController controller)
    {
        IRenderBinding<ColorRenderer, ColorShape> renderer = controller.ResolveRenderer<ColorRenderer, ColorShape>(this.ColorDepth);
        renderer.Render(this);
    }
}
public class MonochromeShape : Shape
{
    public string TypeSpecificString = "[MonochromeShape]";  //Non-virtual, just to prove a point
    override public ColorDepthEnum ColorDepth { get { return ColorDepthEnum.Monochrome; } }

    public override void Apply(DisplayController controller)
    {
        IRenderBinding<MonochromeRenderer, MonochromeShape> component = controller.ResolveRenderer<MonochromeRenderer, MonochromeShape>(this.ColorDepth);
        component.Render(this);
    }
}


abstract public class Renderer : IRenderBinding<Renderer, Shape>
{
    public void Render(Shape data) 
    {
        Console.WriteLine("Renderer::Render(Shape) called.");
    }
}


public class ColorRenderer : Renderer, IRenderBinding<ColorRenderer, ColorShape>
{

    public void Render(ColorShape data) 
    {
        Console.WriteLine("ColorRenderer is now rendering a " + data.TypeSpecificString);
    }
}

public class MonochromeRenderer : Renderer, IRenderBinding<MonochromeRenderer, MonochromeShape>
{
    public void Render(MonochromeShape data)
    {
        Console.WriteLine("MonochromeRenderer is now rendering a " + data.TypeSpecificString);
    }
}


public class DisplayController
{
    private Renderer[] _renderers = new Renderer[10];

    public DisplayController()
    {
        _renderers[(int)ColorDepthEnum.Color] = new ColorRenderer();
        _renderers[(int)ColorDepthEnum.Monochrome] = new MonochromeRenderer();
        //Add more renderer plugins here as needed
    }

    public IRenderBinding<T1,T2> ResolveRenderer<T1,T2>(ColorDepthEnum colorDepth) where T1 : Renderer where T2: Shape
    {
        IRenderBinding<T1, T2> result = _renderers[(int)colorDepth];  
        return result;
    }
    public void OnDataReceived<T>(T data) where T : Shape
    {
        data.Apply(this);
    }

}

static public class Tests
{
    static public void Test1()
    {
       var _displayController = new DisplayController();

        var data1 = new ColorShape();
        _displayController.OnDataReceived<ColorShape>(data1);

        var data2 = new MonochromeShape();
        _displayController.OnDataReceived<MonochromeShape>(data2);
    }
}

如果运行Tests.Test1(),输出将为：

ColorRenderer is now rendering a [ColorShape]
MonochromeRenderer is now rendering a [MonochromeShape]

美丽,它的作品吧？然后我想知道……如果ResolveRenderer返回了错误的类型怎么办？

型号安全吗？

根据this MSDN article,

Contravariance, on the other hand, seems counterintuitive….This seems backward, but it is type-safe code that compiles and runs. The code is type-safe because T specifies a parameter type.

我在想,这实际上并不是安全的.

介绍一个返回错误类型的错误

所以我在控制器中引入了一个错误,因此错误地存储了MonochromeRenderer所属的ColorRenderer,如下所示：

public DisplayController()
{
    _renderers[(int)ColorDepthEnum.Color] = new ColorRenderer();
    _renderers[(int)ColorDepthEnum.Monochrome] = new ColorRenderer(); //Oops!!!
}

我确信我会遇到某种类型不匹配的异常.但不,程序完成,这个神秘的输出：

ColorRenderer is now rendering a [ColorShape]
Renderer::Render(Shape) called.

什么……？

我的问题：

第一,

为什么MonochromeShape :: Apply调用Renderer :: Render(Shape)？它试图调用Render(MonochromeShape),它显然具有不同的方法签名.

MonochromeShape :: Apply方法中的代码仅具有对接口的引用,特别是IRelated< MonochromeRenderer,MonochromeShape>,它只显示Render(MonochromeShape).

尽管Render(Shape)看起来很相似,但它是一个具有不同入口点的不同方法,并且在使用的界面中甚至都没有.

第二,

由于Render方法都不是虚拟的(每个后代类型引入了一个新的,非虚拟的,非重写的方法,具有不同的,特定于类型的参数),我原以为入口点在编译时被绑定.是否在运行时实际选择了method group中的方法原型？如果没有VMT的发货条款,这怎么可能有效呢？它是否使用某种反射？

第三,

c#contravariance绝对不是安全的吗？而不是无效的强制转换异常(至少告诉我有一个问题),我得到一个意外的行为.有没有办法在编译时检测这样的问题,或者至少让它们抛出异常而不是做出意想不到的事情？

解决方法:

好的,首先,不要写这样的泛型类型.正如你所发现的那样,它很快变得非常混乱.永远不要这样做：

class Animal {}
class Turtle : Animal {}
class BunchOfAnimals : IEnumerable<Animal> {}
class BunchOfTurtles : BunchOfAnimals, IEnumerable<Turtle> {}

哦痛苦.现在我们有两条路径来获取IEnumerable< Animal>来自BunchOfTurtles：要求基类实现它,要么派生类实现IEnumerable< Turtle>然后将其协变转换为IEnumerable< Animal>.结果是：你可以向一群海龟询问一系列动物,长颈鹿可以出来.这不是矛盾;基类的所有功能都存在于派生类中,包括在被问到时生成一系列长颈鹿.

让我再次强调这一点,以便它非常清楚.在某些情况下,这种模式可以创建实现定义的情况,在这种情况下,无法静态地确定实际调用哪种方法.在一些奇怪的极端情况下,您实际上可以使方法在源代码中出现的顺序成为运行时的决定因素.只是不要去那里.

有关这个引人入胜的主题的更多信息,我建议您阅读我2007年关于该主题的博客文章的所有评论：https://blogs.msdn.microsoft.com/ericlippert/2007/11/09/covariance-and-contravariance-in-c-part-ten-dealing-with-ambiguity/

现在,在你的具体情况下,一切都很好地定义,它只是没有你认为它应该定义.

首先：为什么这种类型安全？

IRenderBinding<MonochromeRenderer, MonochromeShape> component = new ColorRenderer();

因为你说它应该是.从编译器的角度来解决它.

> ColorRenderer是一个渲染器
> Renderer是一个IRenderBinding< Renderer,Shape>
> IRenderBinding在其两个参数中都是逆变的,因此可能总是使其具有更具体的类型参数.
>因此,渲染器是IRenderBinding< MonochromeRenderer,MonochromeShape>
>因此转换有效.

完成.

那么为什么Renderer :: Render(Shape)在这里调用？

    component.Render(this);

你问：

Since none of the Render methods are virtual (each descendant type introduces a new, non-virtual, non-overridden method with a different, type-specific argument), I would have thought that the entry point was bound at compile time. Are method prototypes within a method group actually chosen at run-time? How could this possibly work without a VMT entry for dispatch? Does it use some sort of reflection?

我们来看看吧.

component是编译时类型IRenderBinding< MonochromeRenderer,MonochromeShape>.

这是编译时类型MonochromeShape.

所以我们在ColorRenderer上调用任何方法实现IRenderBinding< MonochromeRenderer,MonochromeShape> .Render(MonochromeShape).

运行时必须确定实际意味着哪个接口. ColorRenderer实现了IRenderBinding< ColorRenderer,ColorShape>直接和IRenderBinding< Renderer,Shape>通过它的基类.前者与IRenderBinding< MonochromeRenderer,MonochromeShape>不兼容,但后者是.

因此,运行时推断出你的意思是后者,并执行调用,就像它是IRenderBinding< Renderer,Shape> .Render(Shape)一样.

那叫哪种方法呢？你的类在基类上实现了IRenderBinding< Renderer,Shape> .Render(Shape),这就是被调用的那个.

请记住,接口定义“槽”,每个方法一个.创建对象时,每个接口槽都填充一个方法. IRenderBinding< Renderer,Shape> .Render(Shape)的插槽用基类版本填充,IRenderBinding< ColorRenderer,ColorShape> .Render(ColorShape)的插槽用派生类版本填充.您选择了前者的插槽,因此您可以获得该插槽的内容.

Is c# contravariance definitely not type safe?

我向你保证它是安全的.正如您应该注意到的那样：您在没有强制转换的情况下进行的每次转换都是合法的,并且您调用的每个方法都是使用预期的类型调用的.例如,你从未调用过ColorShape的方法,引用了MonochromeShape.

Instead of an invalid cast exception (which at least tells me there is a problem), I get an unexpected behavior.

不,你得到完全预期的行为.您刚刚创建了一个非常令人困惑的类型网格,并且您对类型系统没有足够的理解来理解您编写的代码.不要那样做.

Is there any way to detect problems like this at compile time, or at least to get them to throw an exception instead of doing something unexpected?

首先不要写这样的代码.永远不要实现相同界面的两个版本,以便它们可以通过协变或逆变转换来统一.它只不过是痛苦和困惑.同样,永远不要使用在泛型替换下统一的方法来实现接口. (例如,接口IFoo< T> {void M(int); void M(T);} class Foo：IFoo< int> {uh oh})

我考虑过添加一个警告,但很难看到如何在极少数情况下关闭警告.只能通过编译指示关闭的警告是很糟糕的警告.

内容总结

以上是互联网集市为您收集整理的c# – 与泛型的多态性 – 奇怪的行为全部内容，希望文章能够帮你解决c# – 与泛型的多态性 – 奇怪的行为所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/756509.html

来源：【匿名】

【上一篇】c# – 在.NET Standard / Core中获取构造函数列表的等价物是什么？【下一篇】assemblyinfo.csC#Assembly类访问程序集信息

更多 ►

【c# – 与泛型的多态性 – 奇怪的行为】教程文章相关的互联网学习教程文章

C#中的多态【图】

一、首先理解一下什么叫多态：同一种操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。举一个形象的例子，在我们听音乐会的时候，当指挥发出开始的信号，不同的乐器收到相同的信号，但是他们产生不同的行为：钢琴发出的是钢琴的声音，小号发出的是小号的声响。或者，如果把每个动物当成一个对象，那么他们都有一个方法叫做吃，但是他们却产生不同的行为。如图：二、多...

学习C#多态性【代码】

C#多态性以下均为在菜鸟教程中学习的笔记多态是同一个行为具有多个不同表现形式或形态的能力。在C#中，每一个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自Object。在C#中，多态就是同一个接口，使用不同实例而执行不同的操作。静态多态性在编译时，函数和对象的连接机制称为早期绑定，也被称为静态绑定。C#提供了两种技术来实现静态多态性。分别为：1、函数重载2、运算符重载下期讨论运算符重载，这期只讨论函数重...

C# 面向对象的封装、继承、多态

一、封装：封装：把客观的事物封装成类，使用和修改方便；作用和结构体使用方法相似，程序执行流程不同；要点：成员变量，属性，成员方法，构造函数，成员方法的静态和非静态，命名空间，常用的访问修饰符public公共的、parvate私有的，只有类本身可以访问，internal默认的，同一个命名空间下可以访问、protected被保护的、同一个继承关系下可以访问；重名问题：同一个作用域下不允许出现重名问题，最简答解释作用域就是一个花括号...

C#封装、多态、抽象、接口、匿名方法等学习

1：封装将对象进行封装，并不等于将整个对象完全包裹起来，而是根据实际需要，设置一定的访问权限，用户根据不同的权限调用对象提供的功能，在C#语言中，可以使用修饰符public、internal、protected、private分别修饰类的字段、属性和方法。 2：继承，主要是注意继承的格式 [csharp] view plaincopypublic class ParentClass //父类 { public ParentClass(); } public class ChildClass : ParentClass ：子类 { ...

C# 多态性【代码】

C# 多态性多态性常被视为自封装和继承之后，面向对象的编程的第三个支柱。 Polymorphism（多态性）是一个希腊词，指“多种形态”，多态：一个接口多个功能。静态多态性：编译时发生函数响应（调用）；动态多态性：运行时发生函数响应。静态绑定（早期绑定）：编译时函数和对象的连接机制。两种技术实现静态多态性：函数重载/运算符重载。函数重载：在同一范围内对相同函数名有多个定义，可以是参数类型或参数个数的不同，但不许只...

C#中的接口实现多态【代码】【图】

我们都知道虚方法实现多态，抽象方法实现多态等，我们今天来看看如何使用接口实现多态1.首先我们先要来了解了解什么是接口，它存在的意识 01.接口就是为了约束方法的格式(参数和返回值类型)而存在的 02.接口可以实现多继承，弥补单继承的缺陷。　 03.接口可以看成是一个特殊的抽象类，通过反编译看源码可知 04.接口中方法不用访问修饰符，因为CLR会自动添加，并且不能有方法体 05.如果一个类实现了某个接口，就得实现...

C#中的继承与多态还有接口【图】

简单继承最简单的三个类public class Animal {public Animal(){Debug.Log("Construct Animal!");} }public class Mammal : Animal {public Mammal(){Debug.Log("Construct Mamal!");} }public class Sheep : Mammal {public Sheep(){Debug.Log("Construct Sheep!");} }在main里面Sheep sheep = new Sheep();子类的构造函数会依次执行基类的构造函数，没有异议。需要注意的是，没有特别声明，子类都会自动去找父类中没有参数的构造函...

Liam的C# 学习历程（三）：类与对象、继承与多态【图】

在这一次的课程中，我们主要学习了C#中一些关于类的的具体应用和面向对象（OOP）的三大特点：封装（Encapsulation）、多态（Polymorphism）和继承（Inheritance）。接下来就让我们来实验一下学到的知识。　　（一）This 关键字　　this关键字（又称this指针）是类中所有非静态方法的隐藏指针。　　调用this的方法有很多种，首先是在收到与成员变量同名的参数时，使用this可以避免混淆，就像下面过程所演示的：　　成员函数SomeMeth...

Csharp多态的实现(抽象类)【代码】

1.什么是抽象类抽象类是虚拟的类,不能创建对象,用abstract修饰,在子类中用override进行重写抽象类中可以存放抽象方法,属性,也可以存放非抽象方法,属性(这个在下面的代码可以看出来的)非抽象类中只能存放非抽象的方法(这个可以在下面的代码中可以看出类)如果子类也是抽象类,那么父类中所有的抽象方法,属性不必全部实现; 如果子类不是抽象类,那么父类中所有的抽象方法,属性必须全部实现(如果不实现会报错,这个也可以观察出来)2.下面来...

C# 面向对象的三大特性封装继承多态

C# 面向对象的三大特性 https://blog.csdn.net/yiyelanxin/article/details/94388986#封装目录一、封装二、继承三、多态 C# 面向对象的三大特性分别是封装、继承、多态，下面将帮助您更深一步了解并运用这三大特性。一、封装封装被定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"。在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。抽象和封装是面向对象程序设计的相关特性。抽象允许相关信息可视化...

C# 封装、继承、多态

C#是纯面向对象的编程语言，运用面向对象的思想对于编写一个大型工程就显得非常重要。C#主要是通过封装（encapsulating）、继承（inheritance）和多态（polymorphism）来实现。封装：封装的目的就是为了屏蔽细节，把细节封装在内部，只给外部公开需要公开的，数据安全,提高代码的重用性。访问修饰符： public：公共访问是允许的最高访问级别，对访问公共成员没有限制，任何类都可以被访问。 private：私有成员只有在声明它们的类...

C#与.net高级编程 C#的多态介绍

用virtual关键字标记的方法称为虚方法，如果子类希望改变虚方法的实现细节就必须使用 override关键字。抽象类 abstract关键字防止创建毫无意义的基本类，使用abstract关键字创建抽象基类，防止被实例化使用abstract关键字创建抽象方法，强制每一个子类重写特定的方法，abstract成员没有提供任何实现。（注：抽象方法只可以定义在抽象类中，如果不是这样的话，就会收到编译器错误）成员投影如果派生类定义的成员和定义在蕨类中...

C#多态【图】

多态性（C# 编程指南）转自MSDN 通过继承，一个类可以用作多种类型：可以用作它自己的类型、任何基类型，或者在实现接口时用作任何接口类型。这称为多态性。C# 中的每种类型都是多态的。类型可用作它们自己的类型或用作 Object 实例，因为任何类型都自动将 Object 当作基类型。多态性不仅对派生类很重要，对基类也很重要。任何情况下，使用基类实际上都可能是在使用已强制转换为基类类型的派生类对象。基类的设计者可以预测到其基...

C# 面向对象编程【多态详解】【代码】

C# 面向对象编程【多态详解】文章目录 C# 面向对象编程【多态详解】1. 里氏转换2. 多态2.1 虚方法3.2 抽象类3.3 接口1. 里氏转换 1)、子类可以赋值给父类 2)、如果父类中装的是子类对象，那么可以讲这个父类强转为子类对象声明 public class Person {public void PersonSayHello(){Console.WriteLine("我是父类");} } public class Student : Person {public void StudentSayHello(){Console.WriteLine("我是学生");} }里氏转换例...

C#基础入门第十三天（多态接口）【代码】

第十二天复习 namespace 复习 { class Program {static void Main(string[] args){/*Lisi<T>Dictionary<K,T>拆装箱装箱：值类型转为引用类型拆箱：引用类型转为值类型应该尽量避免在代码中发生文件流FileStream StreamReader和StreamWrite多态：虚方法、抽象类、接口虚方法抽象类*///List<int> list = new List<int>();//Dictionary<int, string> dic = new Dictionary<int, string>();//dic.Add(1, "张三");//dic[2] = "李四";//...

C# - 技术教程分类

C# 教程 C# 简介 C# 环境 C# 程序结构 C# 基本语法 C# 数据类型 C# 类型转换 C# 变量 C# 常量 C# 运算符 C# 判断 C# 循环 C# 封装 C# 方法 C# 可空类型 C# 数组（Array） C# 字符串（String） C# 结构体（Struct） C# 枚举（Enum） C# 类（Class） C# 继承 C# 多态性 C# 运算符重载 C# 接口（Interface） C# 命名空间（Namespace） C# 预处理器指令 C# 异常处理 C# 特性（Attribute） C# 反射（Reflection） C# 属性（Property） C# 索引器（Indexer） C# 委托（Delegate） C# 事件（Event） C# 集合（Collection） C# 泛型（Generic） C# 匿名方法 C# 不安全代码 C# 多线程 c# 全部

C# - 最热教程

c#编程连接oracle数据库无法加载DLL(oc...一个适合新手C#程序员编写练习的小项目...C# 异步UDP发送接收数据 C#程序执行时间长和慢查询解决：线程并...c# aspose操作word文档 C#继承讲解以及对象的创建 jquery+ajax+C#实现无刷新操作数据库数...C#精髓 GridView72大绝技学习gridview...c# static的全部用法收集整理 js模拟实现类似c#下的hashtable的简单功...

首页 / C# / c# – 与泛型的多态性 – 奇怪的行为

c# – 与泛型的多态性 – 奇怪的行为

内容导读

内容图文

内容总结

内容备注

内容手机端

【c# – 与泛型的多态性 – 奇怪的行为】教程文章相关的互联网学习教程文章

C# - 技术教程分类

C# - 最新教程

C# - 最热教程