c#反射 订阅
C语言是一门面向过程的、抽象化的通用程序设计语言,广泛应用于底层开发。C语言能以简易的方式编译、处理低级存储器。C语言是仅产生少量的机器语言以及不需要任何运行环境支持便能运行的高效率程序设计语言。尽管C语言提供了许多低级处理的功能,但仍然保持着跨平台的特性,以一个标准规格写出的C语言程序可在包括类似嵌入式处理器以及超级计算机等作业平台的许多计算机平台上进行编译。 [1] 展开全文
C语言是一门面向过程的、抽象化的通用程序设计语言,广泛应用于底层开发。C语言能以简易的方式编译、处理低级存储器。C语言是仅产生少量的机器语言以及不需要任何运行环境支持便能运行的高效率程序设计语言。尽管C语言提供了许多低级处理的功能,但仍然保持着跨平台的特性,以一个标准规格写出的C语言程序可在包括类似嵌入式处理器以及超级计算机等作业平台的许多计算机平台上进行编译。 [1]
信息
类    别
程序设计语言
影响语言
C++、C#、D、Java、JavaScript、ObjectPHP等
创始时间
1972年
主要编译器
Visual C++、Clang、GCC、Turbo C等
中文名
C语言
创始人
Dennis MacAlistair Ritchie
发    源
BCPL语言
外文名
C Programming Language
c语言简介
C语言是一门面向过程的计算机编程语言,与C++、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。C语言描述问题比汇编语言迅速、工作量小、可读性好、易于调试、修改和移植,而代码质量与汇编语言相当。C语言一般只比汇编语言代码生成的目标程序效率低10%~20%。因此,C语言可以编写系统软件。 [2]  当前阶段,在编程领域中,C语言的运用非常之多,它兼顾了高级语言和汇编语言的优点,相较于其它编程语言具有较大优势。计算机系统设计以及应用程序编写是C语言应用的两大领域。同时,C语言的普适较强,在许多计算机操作系统中都能够得到适用,且效率显著。 [3]  冯.诺依曼在1945年提出了现代计算机的若干思想,被后人称为冯.诺依曼思想,这是计算机发展史上的里程碑。自1945 年至今大多采用其结构,因此冯.诺依曼被称为计算机之父。他的体系结构计算机由运算器、控制器、存储器、输入设备、输出设备五大部件构成。 C语言拥有一套完整的理论体系经过了漫长的发展历史,在编程语言中具有举足轻重的地位。 [4] 
收起全文
精华内容
下载资源
问答
  • C# 反射实例

    2018-09-29 14:24:48
    这是一个关于C#的发射使用的一个实例,获取属性,方法,赋值等操作。
  • 主要介绍了C#反射内存的处理,较为详细的分析了反射加载的内存释放问题,具有一定的参考借鉴价值,需要的朋友可以参考下
  • C#反射生成SQL实例

    2019-04-17 15:02:57
    C#反射生成SQL实例代码,无bug可完美运行,欢迎下载!
  • 实用结合C#反射实现动态定时器定时任务工具,可结合XML配置文档,实现独立动态的定时配置;用于定时任务执行、消息推送、WebService任务等;附件为程序源码。工具历经多项目验证,不足之处;欢迎交流指正!
  • C#反射

    万次阅读 2019-05-08 21:41:56
    1. 过多使用,会造成逻辑模糊,因为反射已经绕过的源码,看不到逻辑实现,会造成后期维护上的困扰 2. 性能的问题,使用反射处在解释的操作,主要应用在对灵活性和拓展性要求很高的系统框架上,普通程序不建议使用 ...

    优点:

    1.    提高程序的灵活性与可扩展性,耦合度;

    缺点:

    1.    过多使用,会造成逻辑模糊,因为反射已经绕过的源码,看不到逻辑实现,造成后期维护上的困扰

    2.       性能的问题,使用反射处在解释的操作,主要应用在对灵活性和拓展性要求很高的系统框架上,普通程序不建议使用

    小结:.Net应用程序由几个部分:‘程序集(Assembly)’、‘模块(Module)’、‘类型(class)’组成

     更简单的说反射是为了动态地运行时加载,而静态代码是在编译时就确定好了。也就是说当你的程序需要在运行时再做一些晚绑定,动态加载或检查对象等操作时,你就需要用到反射

    以下为实例TestDemo:

    新增类 Test.cs 里面有两个class 为 Test && Man  方便之后做测试;

    Class Test 定义有 字符串 MyType,类Man,Man中含有 定义的三个字符串分别是:Name,Age,sex ;还有一个返回String类型的方法Init();

     

    二:从调试模式看结果

    在类工厂中动态创建类的实例,使用System.Activator.CreateInstance,方法入参为两个string类型,分别入参 “类库名称” 和 “类名”这样就能将Test.cs实例出来啦!

    实例出来后,我们获取到了 Test.cs中的Mytpe &&man,但是他们都是null的;

    *SetValue()给实例出来的MyType赋值"I'm so cool"

    *GetValue()获取值

    *GetProperty() 搜索指定名称的公共属性;

     

    用objstr接收到值

     

    相对的用法:在类Man中看结果:
    一样的用法,可以看到效果也是大同小异的,最终取到Man的赋值;

    三:调用方法

    前面在Test.cs中定义了一个public 公开的Init()方法,该方法实现的是一个简单的字符串拼接,入参为两个string: str1 and str2

     

    现在我要在 static void Main 中 用反射去赋值并输出

    打开文本可视化工具:可以看到已经绕过类,直接入参调用Init()的方法返回了字符串拼接后的结果 “yi ya yi ya yook ok ok ”

    Invoke()传入,string[]数组,包含两个string类型的值;

    GetMehtod()搜索具有指定名称的公共方法;

    以上只是反射中的冰山一角,还有调用dll,各种各样的方式......

    作为.Net中较为重要的机制,有了反射我们就可以得到.net中每一个类型的相关信息,简单的来说就是通过反射获取成员变量。它的一些方法,属性,时间,构造函数以及参数等等。如果获得了构造函数的信息,即可直接创建对象,即使这个对象的类型在编译时还不知道。程序代码在编译后生成可执行的应用,我们首先要了解这种可执行应用程序的结构。

    也是突然心血来潮,前面写了那么多的JAVA基础的学习总结以后。想到假期写了两篇C#的技术点总结。

    对反射我也不是了解多少,都是结合自己在慕课学习和之前有了解的一些知识而言总结的,所以可以说都是些自己总结的表层的基础东西。

    展开全文
  • C#反射机制源码学习.rar C#反射机制源码学习.rar C#反射机制源码学习.rar
  • C#反射(Reflection)详解

    2018-10-30 17:27:27
    C#反射(Reflection)详解 什么是反射 命名空间和装配体的关系
  • c# 反射调用事件

    2021-03-17 13:40:18
    ,但是是对的,就是反射调用事件。 主要差别在反射的筛选条件 :typeof(MyClass).GetFields(BindingFlags.NonPublic | BindingFlags.Instance) 对于事件:public event EventHandler<MyEventArgs> Event1; 要...

    这里有个例子 。这个例子反射调用的是静态的Action。这里最后写了三点需要注意的,我觉得很对。“委托其实是个字段,要用GetField来获取”。
    这里的第一个答案。stackoverflow里的,这个就是反射调用事件。

    主要差别在反射的筛选条件
    typeof(MyClass).GetFields(BindingFlags.NonPublic | BindingFlags.Instance)

    对于事件:public event EventHandler<MyEventArgs> Event1;
    要用(BindingFlags.NonPublic | BindingFlags.Instance)筛选,
    而用(BindingFlags.Public | BindingFlags.Instance)找不到。
    (当然,用GetEvent()可以,但是对于EventInfo,我没找到怎么调用它。)

    我的代码:

    public class MyClass
        {
            public event EventHandler<MyEventArgs> Event1;
    
            List<FieldInfo> listOfEvent = new List<FieldInfo>();
    
            public void Test()
            {
                Event1 += F1;
    
                //下面这句能找到Event1,但是不好进一步调用
                //EventInfo[] eis = typeof(DelageteClass).GetEvents();
    
                //这样找出来的是私有字段,没想到Event1就在里面。listOfEvent 也在里面
                FieldInfo[] fis = typeof(MyClass).GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
    
                foreach (var fi in fis)//遍历过滤一下。如果你的类很多私有字段,这个循环的效率方面自己考虑
                {
                    var fiType = fi.FieldType;
                    var tempType = typeof(EventHandler<MyEventArgs>);
                    bool b = fiType == tempType;//根据类型过滤
                    if (b)
                    {
                        listOfEvent.Add(fi);
                    }
                }
    
                MyEventArgs myEventArgs = new MyEventArgs() { Name = "123" };
                
    			//遍历调用。考虑有多个事件。如果只有一个,上面直接根据名字找到,调用一个即可
                foreach (var fi in listOfEvent)
                {
                	//注意:如果事件 Event1 没有挂载事件处理(我这里在上面有: Event1 += F1;),tempV会为null,请自行处理
                    var tempV = fi.GetValue(this);//这个很重要,取字段的对象。用GetEvents得到的EventInfo找不到办法获取其对象
                    var invokeMethod = tempV.GetType().GetMethod("Invoke");
                    try
                    {
                        //调用,需要传对象下去。一开始我随便传了个this,抛异常“对象与目标类型不匹配”。至于那个null则无所谓
                        //invokeMethod.Invoke(this, new object[] { null, myEventArgs });
                        invokeMethod.Invoke(tempV, new object[] { null, myEventArgs });
                    }
                    catch (Exception ex)
                    {
                    }
                }
            }
    
            private void F1(object sender, MyEventArgs str)
            {
                Console.WriteLine(str.Name);
            }
        }
        
    public class MyEventArgs : EventArgs
        {
            public string Name { get; set; }
        }
    
    展开全文
  • C# 反射性能优化

    千次阅读 2020-11-03 20:27:10
    之前在做消息的自动注册机时,发现用反射获到的MethodInfo也是可以转成委托的,于是抽空整理了一下,写了一些用于优化反射的工具类和方法。

    之前在做消息的自动注册机时,发现用反射获到的MethodInfo也是可以转成委托的,于是抽空整理了一下,写了一些用于优化反射的工具类和方法。

    0.测试数据

      以下数据为访问10000000次得到的结果,单位为毫秒可以看到,优化的效果还是很明显的。

    直接访问使用反射访问优化反射访问
    属性Get491961143
    属性Set42238079
    空方法调用33138933

    1.PropertyInfo优化

      代码很简单,不做过多说明了,直接附在下面。属性的优化用了个类封装了一下,适用于Get,Set都是public的情况,如果有不是public的需要可以修改一下。

    public class PropertyWrapper<T>
    {
        private Action<T> setter;
        private Func<T> getter;
    
        public T Value
        {
            get
            {
                return getter();
            }
            set
            {
                setter(value);
            }
        }
    
        public PropertyWrapper(object target, PropertyInfo propertyInfo)
        {
            var methodInfo = propertyInfo.GetSetMethod();
            var @delegate = Delegate.CreateDelegate(typeof(Action<T>), target, methodInfo);
            setter = (Action<T>)@delegate;
    
            methodInfo = propertyInfo.GetGetMethod();
            @delegate = Delegate.CreateDelegate(typeof(Func<T>), target, methodInfo);
            getter = (Func<T>)@delegate;
        }
    }
    

    2.MethodInfo优化

      方法的优化直接用工具方法返回委托了。

    public static class Utility
    {
    	public static Action MethodWrapperAction(object target, MethodInfo methodInfo)
    	{
    	    return (Action)Delegate.CreateDelegate(typeof(Action), target, methodInfo);
    	}
    	
    	public static Action<T> MethodWrapperAction<T>(object target, MethodInfo methodInfo)
    	{
    	    return (Action<T>)Delegate.CreateDelegate(typeof(Action<T>), target, methodInfo);
    	}
    	
    	public static Action<T1, T2> MethodWrapperAction<T1, T2>(object target, MethodInfo methodInfo)
    	{
    	    return (Action<T1, T2>)Delegate.CreateDelegate(typeof(Action<T1, T2>), target, methodInfo);
    	}
    	
    	public static Action<T1,T2,T3> MethodWrapperAction<T1, T2, T3>(object target, MethodInfo methodInfo)
    	{
    	    return (Action<T1, T2, T3>)Delegate.CreateDelegate(typeof(Action<T1, T2, T3>), target, methodInfo);
    	}
    	
    	public static Func<TReslut> MethodWrapperFunc<TReslut>(object target, MethodInfo methodInfo)
    	{
    	    return (Func<TReslut>)Delegate.CreateDelegate(typeof(Func<TReslut>), target, methodInfo);
    	}
    	
    	public static Func<T1, TReslut> MethodWrapperFunc<T1, TReslut>(object target, MethodInfo methodInfo)
    	{
    	    return (Func<T1, TReslut>)Delegate.CreateDelegate(typeof(Func<T1, TReslut>), target, methodInfo);
    	}
    	
    	public static Func<T1, T2, TReslut> MethodWrapperFunc<T1, T2, TReslut>(object target, MethodInfo methodInfo)
    	{
    	    return (Func<T1, T2, TReslut>)Delegate.CreateDelegate(typeof(Func<T1, T2, TReslut>), target, methodInfo);
    	}
    	
    	public static Func<T1, T2, T3, Reslut> MethodWrapperFunc<T1, T2, T3, Reslut>(object target, MethodInfo methodInfo)
    	{
    	    return (Func<T1, T2, T3, Reslut>)Delegate.CreateDelegate(typeof(Func<T1, T2, T3, Reslut>), target, methodInfo);
    	}
    }
    

    4.总结

      之前一直纠结一个问题,在属性的get和set都为public时,有什么理由让我不用字段用属性呢。之前看某本书(忘记叫啥了)从编译级别阐述了一个理由。这次可以从反射的角度回答,当你需要使用反射访问变量时,属性比字段好优化。

    展开全文
  • 反射实例化类 public class Person { public string Name { get; set; } public Person(string name) { this.Name = name; } public string Say(string msg) { return $"{Name}: {msg}"; } } class ...

    反射实例化类

    public class Person
    {
      public string Name { get; set; }
     
      public Person(string name)
      {
        this.Name = name;
      }
     
      public string Say(string msg)
      {
        return $"{Name}: {msg}";
      }
    }
     
    class Program
    {
      // 测试次数
      const int count = 10000000;
     
      static void Main(string[] args)
      {
        CreateInstance0();
        CreateInstance1();
        CreateInstance2();
        CreateInstance3();
        CreateInstance4();
     
        Console.Read();
      }
     
      static void CreateInstance0()
      {
        Stopwatch watch = new Stopwatch();
        watch.Start();
     
        for (var i = 0; i < count; i++)
        {
          Person person = new Person("张三");
        }
     
        watch.Stop();
        Console.WriteLine($"{watch.Elapsed} - new");
      }
     
      static void CreateInstance1()
      {
        Stopwatch watch = new Stopwatch();
        watch.Start();
     
        for (var i = 0; i < count; i++)
        {
          object person = Activator.CreateInstance(typeof(Person), "张三");
        }
     
        watch.Stop();
        Console.WriteLine($"{watch.Elapsed} - Activator.CreateInstance");
      }
     
      static void CreateInstance2()
      {
        Assembly assembly = Assembly.GetExecutingAssembly();
     
        Stopwatch watch = new Stopwatch();
        watch.Start();
     
        for (var i = 0; i < count; i++)
        {
          Person obj = (Person)assembly.CreateInstance("ConsoleTest.Person", true, BindingFlags.Default, null, new object[] { "张三" }, null, null);
        }
     
        watch.Stop();
        Console.WriteLine($"{watch.Elapsed} - Assembly.CreateInstance");
      }
     
      static void CreateInstance3()
      {
        Assembly assembly = Assembly.GetExecutingAssembly();
     
        Stopwatch watch = new Stopwatch();
        watch.Start();
     
        for (var i = 0; i < count; i++)
        {
          Type type = assembly.GetType("ConsoleTest.Person");
          object person = Activator.CreateInstance(type, "张三");
        }
        watch.Stop();
        Console.WriteLine($"{watch.Elapsed} - Assembly.CreateInstance1");
      }
     
      static void CreateInstance4()
      {
        Assembly assembly = Assembly.GetExecutingAssembly();
     
        Stopwatch watch = new Stopwatch();
        watch.Start();
     
        Type type = assembly.GetType("ConsoleTest.Person");
        for (var i = 0; i < count; i++)
        {
          object person = Activator.CreateInstance(type, "张三");
        }
        watch.Stop();
        Console.WriteLine($"{watch.Elapsed} - Assembly.CreateInstance2");
      }
    }
    

    在这里插入图片描述

    通过反射实例化对象,要比直接 new 要慢 50 倍左右
    assembly.CreateInstance 要比 Activator.CreateInstance 慢,主要的性能损耗在 Assembly.GetType
    反射调用类的方法

    class Program
    {
      // 测试次数
      const int count = 10000000;
     
      static void Main(string[] args)
      {
        InvokeMethod0();
        InvokeMethod1();
        InvokeMethod2();
        InvokeMethod3();
        InvokeMethod4();
     
        Console.Read();
      }
     
      static void InvokeMethod0()
      {
        Person person = new Person("张三");
     
        Stopwatch watch = new Stopwatch();
        watch.Start();
     
        for (var i = 0; i < count; i++)
        {
          string name = person.Say("Hello World!");
        }
     
        watch.Stop();
        Console.WriteLine($"{watch.Elapsed} - 直接调用");
      }
     
      static void InvokeMethod1()
      {
        Person person = (Person)Activator.CreateInstance(typeof(Person), "张三");
     
        Stopwatch watch = new Stopwatch();
        watch.Start();
     
        for (var i = 0; i < count; i++)
        {
          string name = person.Say("Hello World!");
        }
     
        watch.Stop();
        Console.WriteLine($"{watch.Elapsed} - 反射缓存类调用");
      }
     
      static void InvokeMethod2()
      {
        Person person = (Person)Activator.CreateInstance(typeof(Person), "张三");
        MethodInfo method = typeof(Person).GetMethod(nameof(Person.Say), new Type[] { typeof(string) });
        Func<string, string> func = (Func<string, string>)method.CreateDelegate(typeof(Func<string, string>), person);
     
        Stopwatch watch = new Stopwatch();
        watch.Start();
     
        for (var i = 0; i < count; i++)
        {
          string result = func("Hello World!");
        }
     
        watch.Stop();
        Console.WriteLine($"{watch.Elapsed} - 使用反射创建出来的委托调用");
      }
     
      static void InvokeMethod3()
      {
        Person person = (Person)Activator.CreateInstance(typeof(Person), "张三");
     
        MethodInfo method = typeof(Person).GetMethod(nameof(Person.Say), new Type[] { typeof(string) });
     
        object[] parameters = new object[] { "Hello World!" };
     
        Stopwatch watch = new Stopwatch();
        watch.Start();
     
        for (var i = 0; i < count; i++)
        {
          string name = (string)method.Invoke(person, parameters);
        }
     
        watch.Stop();
        Console.WriteLine($"{watch.Elapsed} - 使用反射得到的方法缓存调用");
      }
     
      static void InvokeMethod4()
      {
        Person person = (Person)Activator.CreateInstance(typeof(Person), "张三");
     
        object[] parameters = new object[] { "Hello World!" };
     
        Stopwatch watch = new Stopwatch();
        watch.Start();
     
        for (var i = 0; i < count; i++)
        {
          string result = (string)(typeof(Person).GetMethod(nameof(Person.Say))?.Invoke(person, parameters));
        }
     
        watch.Stop();
        Console.WriteLine($"{watch.Elapsed} - 直接使用反射调用");
      }
    }
    

    在这里插入图片描述

    反射得到实例后c#教程调用方法和直接调用方法效率一样
    缓存反射方法调用和直接使用反射调用都非常耗效率
    以上就是c# 反射用法及效率对比的详细内容

    展开全文
  • C# 反射调用私有事件

    千次阅读 2019-08-30 08:53:43
    C# 反射调用私有事件经常会不知道如何写,本文告诉大家如何调用
  • C# 通过反射调用实例类或静态类的方法 一、创建类 //反射对象类 //ruleAssembly为dell文件、ruleNmspaceName :命名空间;ruleClsName:类名 Type ruleType = Assembly.Load(ruleAssembly).GetType(ruleNmspaceName ...
  • 下面小编就为大家带来一篇C# 使用反射来实现对象的深度复制方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • C# 反射GetValue方法

    2021-01-04 18:30:52
    众所周知,C#反射Type类可以获取到字段信息(FieldInfo)及属性信息(PropertyInfo),他们的基类是MemberInfo。 那么问题来了,再FieldInfo和Property Info中有一个方法为GetValue(Object obj),可以获取引用对象下的具备该...
  • 内容索引:C#源码,综合实战,反射实例 一个C#反射的实例源码,功能大家可以看截图,想研究的就下载吧。
  • 反射获取传入对象的属性拼接sql语句实现增、删、改
  • C#反射修改数组

    2020-12-30 11:35:05
    public static class DataHelper { //data 指的是类实例 replace指的是字段名 public static void SetCfgValue(object data, string replace, object value) { var configType = data.GetType();...
  • C# 反射小练习

    2021-11-04 10:44:53
    using System; using System.Collections.Generic; using System.Linq; using System.Reflection; using System.Threading.Tasks; using System.Transactions;...namespace Wrox.ProCSharp.Transactions ...
  • c# 反射的使用场景

    2021-06-27 14:50:29
    1.反射 可以通过具体的程序集加载对应的类型,或者遍历类的成员,获取成员的类的值,具体使用场景(配合接口使用) 接口,是一种约定,使实现接口的类和结构(没错,结构也可以)在形式上保持一致,接口中的方法必须...
  • 前提:使用反射的时候,遇到了结构体,不确定结构体与类的反射有什么区别,做了一个简单的实验,设置获取属性值。 结论:对属性值的设置和获取,结构体与类是相同的 2.代码 using System; using System....
  • 最近在项目过程中遇到了保存数据的需求,对实体类的部分数据进行保存,打算采用反射+自定义特性来实现数据保存,利于扩展 采用反射实现能够灵活获取要保存的数据,由于只需要保存实体类(Model)的部分数据,因此...
  • C#反射详解

    2021-03-26 11:12:09
    C#反射详解程序集元数据反射的概念反射的作用语法Type获取Type得到类的程序集信息得到类的程序集信息获取类中的所有公共成员获取类的公共构造函数并调用获取类的公共成员变量获取类的公共成员方法其他...
  • C#反射破坏单例

    千次阅读 2019-07-20 10:34:55
    上文我们讲到了反射的基本操作,实例化对象、属性、方法、特性等操作,可以参考C#反射 咱们切入正题,单例有两种,一种是程序加载时创建,一种是使用时创建,我们这里主要是创建一个加载时创建的单例。我们...
  • 主要介绍了C#通过反射创建自定义泛型的方法,需要的朋友可以参考下
  • 什么是反射在运行时环境,能否根据一个类的名字,来得到这个类的属性和方法?对于任何一个运行时的对象能否动态调用这个对象的方法?答案是可以的。这种动态的获取类的信息以及动态调用一个对象的方法的机制叫做反射...
  • ```csharp public static bool IsFundamental(this Type type) { return type.IsPrimitive || type.IsEnum || type.Equals(typeof(string)) || type.Equals(typeof(DateTime)); }
  • c#反射给属性赋值

    2021-08-06 21:29:59
    using System; using System.Reflection; namespace ConsoleApplication2 { public class ss { public string name; } ...internal class Program { public static void Main(string[] args) { ...
  • 主要介绍了C# 反射(Reflection)的的相关资料,文中示例代码非常详细,供大家参考和学习,感兴趣的朋友可以了解下
  • void Main() { var type = typeof(StockClass); type.Dump(); var fields=type.GetFields(BindingFlags.Instance|BindingFlags.NonPublic).Dump("字段"); var members = type.GetMethods().Dump("方法");...
  • C# 反射实例代码 接口方式动态加载dll方式

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 52,687
精华内容 21,074
关键字:

c#反射

c# 订阅