中dynamic的科学用法,动态指标

By admin in 4858.com on 2019年4月1日

中dynamic的科学用法,动态指标。dynamic是FrameWork4.0的新天性。dynamic的面世让C#装有了弱语言类型的风味。编写翻译器在编写翻译的时候不再对项目进行检讨,编写翻译期暗中认可dynamic对象支持您想要的别样特性。比如,尽管你对GetDynamicObject方法重回的目的一无所知,你也足以像如下那样进行代码的调用,编写翻译器不会报错:

dynamic是FrameWork4.0的新特色。
dynamic的出现让C#装有了弱语言类型的特色。编写翻译器在编译的时候不再对品种进行检查,编写翻译期暗中同意dynamic对象援助你想要的此外特性。比如,
尽管你对GetDynamicObject方法再次回到的靶子一窍不通,你也能够像如下那样进行代码的调用,编写翻译器不会报错:

C#编制程序总计(十四)dynamic

   
dynamic是FrameWork4.0的新性格。dynamic的产出让C#抱有了弱语言类型的特色。编写翻译器在编译的时候不再对项目举行自笔者批评,编写翻译期
暗中同意dynamic对象帮助您想要的其余个性。

dynamic dynamicObject = GetDynamicObject();
Console.WriteLine(dynamicObject.Name);
Console.WriteLine(dynamicObject.SampleMethod());

 

介绍

Visual
C# 二〇一〇 引入了1个新类型 dynamic。 该项目是一种静态类型,但项目为 dynamic 的靶子会跳过静态类型检查。 超越六分之三动静下,该目的就像拥有类型 object 一样。 在编写翻译时,将假定类型化为 dynamic 的成分协助任何操作。 因而,您不用考虑对象是从
COM API、从动态语言(例如 IronPython)、从 HTML 文档对象模型
(DOM)、从反射照旧从程序中的其余任务获取自身的值。 但是,假诺代码无效,则在运营时会捕获到错误。

 

    使用例子

dynamic与var关键字本质差异

var只好用作一些变量,不可能用来字段,参数;声明的同时必须开首化;开头化时类型就已经鲜明了,并且不能够再被赋值无法实行隐式类型转换的花色的多寡。

var实际上是编写翻译期抛给我们的“语法糖”,一旦被编写翻译,编写翻译期会自动匹配var
变量的骨子里类型,并用实际类型来替换该变量的表明,那看起来就接近大家在编码的时候是用实际类型举办表明的。

dynamic可用以项目标字段,方法参数,方法重回值,可用于泛型的门类参数等;能够赋值给或被赋值任何类型并且不须要显式的强制类型转换,因为这么些是运作时实施的,那要得益于dynamic类型的动态性格。

dynamic被编写翻译后,实际是四个object类型,只不过编写翻译器会对dynamic类型实行出格处理,让它在编写翻译时期不开始展览别的的门类检查,而是将项目检查放到了运转期。

从visual
studio的编辑器窗口就能看出来。以var表明的变量,帮助“智能感知”,因为visual
studion能预计出var类型的其实类型,而以dynamic表明的变量却不支持“智能感知”,因为编写翻译器对其运转期的门类一窍不通。对dynamic变量使用“智能感知”,会提示“此操作将在运转时解析”。

dynamic
dynamicObject = GetDynamicObject();
Console.WriteLine(dynamicObject.Name);
Console.WriteLine(dynamicObject.SampleMethod());

var与dynamic对比

壹 、var编写翻译时替换为实在类型,而dynamic实际是object类型。

如若被编写翻译,编写翻译期会自动匹配var
变量的实在类型,并用实际类型来替换该变量的发明,那看起来就类似大家在编码的时候是用实际类型实行表明的。而dynamic被编写翻译后,实际是一个object类型,只可是编写翻译器会对dynamic类型举办格外规处理,让它在编写翻译时期不进行别的的类型检查,而是将品种检查放到了运营期。

贰 、智能感知。

以var声明的变量,协理“智能感知”,因为visual
studion能推测出var类型的实际上类型,而以dynamic注脚的变量却不帮忙“智能感知”,因为编写翻译器对其运转期的项目一无所知。对dynamic变量使用“智能感知”,会提示“此操作将在运维时分析”。

 

    现有3个类Customer,我们用dynamicObject获得类中的内容。代码如下:

类型转换

Dynamic类型的实例和别的品种的实例间的更换是很简短的,开发人士能够很有益于地在dyanmic和非dynamic行为间切换。任何实例都能隐式转换为dynamic类型实例,见上边包车型客车事例:

dynamic d1 = 7;
dynamic d2 = "a string";
dynamic d3 = System.DateTime.Today;
dynamic d4 = System.Diagnostics.Process.GetProcesses();

Conversely, an implicit conversion can be dynamically applied to any
expression of type dynamic.
反之相同,类型为dynamic的此外表达式也能够隐式转换为别的连串。

int i = d1;
string str = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;

说到科学用法,那么首先应该提出八个荒唐用法:

简单案例

编写制定3个hello
world的测试程序,定义DynamicTest类型,并追加Welcome方法,其参数为name.

接下来制造dynamic对象,调用Welcome方法。参数为空。

using System;


namespace DynamicSample
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic obj = new DynamicTest();
            obj.Welcome();
        }
    }

    class DynamicTest
    {
        public void Welcome(string name)
        {
            Console.WriteLine("Hello {0},welcome to dynamic world.",name);
        }
    }
}

看望爆发什么业务啊,通过测试发现:

编写翻译通过,没有其他非凡。

运营时抛出特别,非凡音讯:

未处理Microsoft.CSharp.RuntimeBinder.RuntimeBinderException
  HResult=-2146233088
  Message=“Welcome”方法没有采用“0”个参数的重载
  Source=Anonymously Hosted DynamicMethods Assembly
  StackTrace:
       在 CallSite.Target(Closure , CallSite , Object )
       在 System.Dynamic.UpdateDelegates.UpdateAndExecuteVoid1[T0](CallSite site, T0 arg0)
       在 DynamicSample.Program.Main(String[] args) 位置 E:\Donet\C#\DynamicSample\DynamicSample\Program.cs:行号 13
       在 System.AppDomain._nExecuteAssembly(RuntimeAssembly assembly, String[] args)
       在 System.AppDomain.ExecuteAssembly(String assemblyFile, Evidence assemblySecurity, String[] args)
       在 Microsoft.VisualStudio.HostingProcess.HostProc.RunUsersAssembly()
       在 System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
       在 System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
       在 System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
       在 System.Threading.ThreadHelper.ThreadStart()
  InnerException: 

修正后:

    class Program
    {
        static void Main(string[] args)
        {
            dynamic obj = new DynamicTest();
            string name = "Tom";
            obj.Welcome(name);

            Console.WriteLine("Input any key to exit.");
            Console.ReadKey();
        }
    }

运作结果:

4858.com 1

 

假若改为var,定义该目的,并调用方法,代码如下,编写翻译器会报错:

            var v1 = new DynamicTest();
            v1.Welcome();

错误消息:

    错误    CS7036    未提供与“DynamicTest.Welcome(string)”的必需形参“name”对应的实参    DynamicSample    Program.cs    15
    错误    CS7036    There is no argument given that corresponds to the required formal parameter 'name' of 'DynamicTest.Welcome(string)'    DynamicSample    

 

    public class Customer
    {
        public string ReturnName()
        {
            return “学习Dynamic”;
        }
    }

措施中涵盖dynamic类型参数的重载难题

要是调用1个办法是传递了dynamic类型的目的,大概被调用的靶子是dynamic类型的,那么重载的论断是发生在运维时而不是编写翻译时。
动态语言运营时(dynamic language runtime DL奥迪Q3)动态语言运维时是.NET
Framework 4 Beta
第11中学的一组新的API,它提供了对c#中dynamic类型的支撑,也兑现了像IronPython和IronRuby之类的动态程序设计语言。

历来人会拿var那些根本字来和dynamic做相比。实际
上,var和dynamic完全是五个概念,根本不该置身一起做相比较。var实际上是编写翻译期抛给我们的“语法糖”,一旦被编写翻译,编写翻译期会自动匹配var
变量的其实类型,并用实际类型来替换该变量的阐发,那看起来就类似大家在编码的时候是用实际类型进行表达的。而dynamic被编写翻译后,实际是一个object类型,只可是编写翻译器会对dynamic类型实行超过常规规处理,让它在编写翻译时期不开始展览任何的类型检查,而是将项目检查放到了运转期。

dynamic应用范围

① 、在宣称中,作为质量、字段、索引器、参数、重返值或项目约束的品类,都足以使用dynamic。

贰 、在显式类型转换中,作为转换的对象项目。任何对象都能够隐式转为dynamic。

③ 、在以种类充当班值日(如 is 运算符或 as 运算符右边)可能作为 typeof 的参数成为构造类型的一局地的别的上下文中。

通过四个实例来具体表明:

    class DynamicUser
    {
        /// <summary>
        /// 字段
        /// </summary>
        public dynamic userid;

        /// <summary>
        /// 属性
        /// </summary>
        public dynamic UserName { get; set; }

        /// <summary>
        /// 玩游戏
        /// (dynamic可以作为参数、返回值等)
        /// </summary>
        /// <param name="game"></param>
        /// <returns></returns>
        public dynamic Play(dynamic game)
        {
            dynamic defaultGame = "Play Basketball.";

            dynamic secGame = "Play with mud.";

            if (game is int)
            {
                return defaultGame;
            }
            else
            {
                return secGame;
            }
        }
        /// <summary>
        /// 显式类型转换
        /// </summary>
        public void ConvertToDynamic(object obj)
        {
            dynamic d;
            d = (dynamic)obj;
            Console.WriteLine(d);
        }
        /// <summary>
        /// 类型判定
        /// (dynamic 可以使用is、as、typeof)
        /// </summary>
        public void TypeCheck()
        {
            int age = 20;
            Console.WriteLine("Age is Dynamic? {0}",age is dynamic);

            dynamic d = age as dynamic;
            Console.WriteLine("Age:{0}",d);         

            Console.WriteLine("List<dynamic>'s type is {0}",typeof(List<dynamic>));
        }

    }

4858.com,测试用例:

            DynamicUser user = new DynamicUser();
            user.userid = 123;
            user.UserName = "Lucy";
            user.ConvertToDynamic(user.userid);
            user.ConvertToDynamic(user.UserName);
            user.TypeCheck();

            Console.WriteLine("Input any key to exit.");
            Console.ReadKey();

测试结果:
4858.com 2

 

    //在决定中利用dynamic调用Customer中的内容
    class Program
    {
        static void Main(string[] args)
        {
            dynamic dynamicObject = new Customer();
            //此处没智能提示
            string sVal = dynamicObject.ReturnName();

dynamic 简化反射

起首作者们这么使用反射:

public class DynamicSample
{
public string Name { get; set; }

public int Add(int a, int b)
{
return a + b;
}
}
DynamicSample dynamicSample = new DynamicSample(); //create instance为了简化演示,我没有使用反射
var addMethod = typeof(DynamicSample).GetMethod("Add");
int re = (int)addMethod.Invoke(dynamicSample, new object[] { 1, 2 });

今后,大家有了简化的写法:

dynamic dynamicSample2 = new DynamicSample();
int re2 = dynamicSample2.Add(1, 2);

那从visual
studio的编辑器窗口就能看出来。以var注解的变量,帮助“智能感知”,因为visual
studion能估计出var类型的骨子里类型,而以dynamic注解的变量却不援救“智能感知”,因为编写翻译器对其运维期的类别一窍不通。对
dynamic变量使用“智能感知”,会提醒“此操作将在运作时分析”。

 dynamic的履行作用

关于dynamic的功效难点,那里暂不展开,后续专门来商量…

            Console.WriteLine(sVal);
            Console.ReadKey();
        }

var,dynamic,古板明确项目标频率比较

守旧类别的功用 >= var动态类型 > dynamic动态类型

编译器对dynamic举行了优化,比平素不经过缓存的反光成效高。

参考小说:

有关dynamic变量是二个object变量这或多或少,能够经过IL代码获得验证,那里不再贴出IL代码。当然,编写翻译器也对dynamic注脚进行了处理,以界别间接object变量。

应用

1、自动反射

二 、COM组件互操作

叁 、混合编制程序,例如IronRuby和IronPython

4、处理Html DOM对象

⑤ 、还有一种选择,数据传输中格式转换,如:对象转json等,很有利

 

 

dynamic是做为简化互操作性而被MSDN中山大学肆渲染,
小编感觉到正是依照那点,才被部分开发职员误解:因为众多开发职员不会接触COM+、OFFICE二回开发之类的编码,所以急需求贰个dynamic的行使
理由。那么,在日常费用中,作者觉着dynamic很有价值的少数是:

dynamic与Var比较:

类型转换

 

Dynamic类型的实例和别的连串的实例间的转换是相当粗略的,开发人士能够很有益于地在dyanmic和非dynamic行为间切换。任何实例都能隐式转换为dynamic类型实例,见下边包车型地铁例子:

   
常有人会拿var那一个主要字来和dynamic做相比较。实际上,var和dynamic完全是四个概念,根本不应有放在一块儿做
相比较。var实际上是编写翻译期抛给大家的“语法糖”,一旦被编译,编译期会自动匹配var
变量的实在类型,并用实际类型来替换该变量的阐发,那看起来就像是大家在编码的时候是用实际类型举办表明的。而dynamic被编写翻译后,实际是三个object类型,只可是编写翻译器会对dynamic类型实行非凡处理,让它在编写翻译时期不进行别的的体系检查,而是将品种检查放到了运营期。

dynamic d1 = 7;

 

dynamic d2 = “a string”;

    那从visual
studio的编辑器窗口就能看出来。以var评释的变量,援助“智能感知”,因为visual
studion能预计出var类型的实际上类型,而以dynamic评释的变量却不援救“智能感知”,因为编写翻译器对其运营期的档次一窍不通。对
dynamic变量使用“智能感知”,会唤醒“此操作将在运行时分析”。关于dynamic变量是二个object变量那或多或少,能够经过IL代码得到注脚,那里不再贴出IL代码。当然,编写翻译器也对dynamic申明进行了处理,以界别直接object变量。dynamic是做为简化互操作性而被MSDN中势不可挡渲染,小编觉得正是基于那或多或少,才被一些开发人士误解:因为许多开发人士不
会接触COM+、OFFICE二回开发之类的编码,所以急要求一个dynamic的施用理由。那么,在常常支付中,我以为dynamic很有价值的一点
是:dynamic能够简化反射在此之前作者们如此使用反射:

dynamic d3 = System.DateTime.Today;

    public class DynamicSample
    {
        public string Name { get; set; }

dynamic d4 = System.Diagnostics.Process.GetProcesses();

        public int Add(int a, int b)
        {
            return a + b;
        }
    }

Conversely, an implicit conversion can be dynamically applied to any
expression of type dynamic.

            Dynamic萨姆ple dynamicSample = new DynamicSample();   //create instance为了简化演示,笔者未曾应用反射
            var addMethod = typeof(DynamicSample).GetMethod(“Add”);
            int re = (int)addMethod.Invoke(dynamicSample, new object[] { 1, 2 });

反之相同,类型为dynamic的其余表明式也能够隐式转换为此外体系。

 

int i = d1;

 

string str = d2;

以往,大家有了简化的写法:

DateTime dt = d3;

 

System.Diagnostics.Process[] procs = d4;

dynamic dynamicSample2 = new DynamicSample();
int re2 = dynamicSample2.Add(1, 2);

情势中带有dynamic类型参数的重载难题

 

即便调用3个措施是传递了dynamic类型的目的,大概被调用的指标是dynamic类型的,那么重载的论断是发出在运作时而不是编写翻译时。

 

动态语言运行时(dynamic language runtime DL途乐)

 

动态语言运维时是.NET Framework 4 Beta
第11中学的一组新的API,它提供了对c#中dynamic类型的支持,也兑现了像IronPython和IronRuby之类的动态程序设计语言。

       
大家兴许会对那样的简化视如草芥,毕竟看起来代码并不曾滑坡多少,可是,假诺考虑到效用兼精彩两特性子,那么dynamic的优势就显现出来了。编写翻译器对
dynamic实行了优化,比尚未经过缓存的反射功能快了重重。假若非要相比较,能够将方面两者的代码(调用Add方法有些)运转一千000就能够得出
结论。

dynamic能够简化反射

 

先前小编们那样使用反射:

 

 

参考文章:

4858.com 3

 

public class
DynamicSample
{
public string Name {
get; set; }

 

public int Add(int a, int b)
{
return a

  • b;
    }
    }
    Dynamic萨姆ple dynamicSample = new DynamicSample(); //create
    instance为了简化演示,小编没有使用反射
    var addMethod = typeof(DynamicSample).GetMethod(“Add”);
    int re = (int)addMethod.Invoke(dynamicSample, new object[] { 1, 2
    });

4858.com 4

现行反革命,大家有了简化的写法:

dynamic
dynamicSample2 = new DynamicSample();

int re2

dynamicSample2.Add(1, 2);

咱俩或许会对这么的简化置之不理,究竟看起来代码并从未减掉多少,可是,要是考虑到成效兼精粹三个特点,那么dynamic的优势就显现出来了。编写翻译器对dynamic实行了优化,比平素不通过缓存的反射效能快了众多。若是非要比较,能够将上面两者的代码(调用Add方法有个别)运转1000000就能够得出结论。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有