C#-动态编程

最新推荐文章于 2023-09-02 14:56:35 发布
最新推荐文章于 2023-09-02 14:56:35 发布
阅读量1.4k 收藏 10
点赞数 1
分类专栏： C#知识点整理 asp-net-mvc 文章标签： mvc c# 动态编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KingArthur_Tao/article/details/78581551
版权

1.前言：
博文首先区分清楚无类型化，弱类型化和强类型化；静态的类型化语言和动态的类型化语言等概念；
接着说说动态编程在C#中发展，这包括var关键字的出现，匿名类型，dynamic类型等；
最后说回到ASP.NET MVC的ViewBag。

2.明晰4个概念：
先看下面这张图：
4个概念

这就引入了2个问题：
为什么说C#是静态的类型化的语言，而Javascript是动态的类型化的语言？
为什么说C#是强类型化的语言，而Javascript是弱类型化的语言？

先暂且不谈无类型化的语言，要想解释清楚上面两个问题，首先得清楚这样的四个概念：弱类型、强类型和静态类型、动态类型。

2.1 静态类型和动态类型：
每一种程序设计语言都提供一定的类型检查机制，类型检查可以在编译时进行，也可以在运行时进行，分别称做静态类型检查和动态类型检查。
类型检查，可以说包含了语法检查；就是说在进行类型检查时不仅得满足这门语言的语法规则，还得满足一些的规则。

简单讲，静态类型和动态类型其实就是一种类型检查机制；

2.2 弱类型和强类型：
一门程序设计语言采取什么样的类型检查机制，对语言的实现效率有很大影响；
而在对这门语言书写的程序进行类型检查时，会根据这门语言的语法体系制定一系列的规则；
满足了这些规则，才能说书写的代码语法正确；

我们是根据这些规则来判断这门语言到底是强类型化的还是弱类型化的。
比如强类型化的语言需要满足下面几条规则：
a.每个变量都能在编译时确定唯一的类型
b.当变量允许存储1个以上类型的值时，可以对值进行检查（数组，List）
c.对于某种运算连接在一起的两个变量的所有实例都要进行静态类型检查，看它们的数据类型是否一致.（1+“1”，1-“1”）；
等等

只有在进行类型检查时全部满足了上述的规则才是强类型化的语言，反之就是弱类型化的语言。

总结一下：说到底静态类型和动态类型是一种类型检查机制，强类型和弱类型是对一系列类型检查规则的总称。

2.3 回答提出的两个问题：
这样有了基本的概念认知之后，就很好回答刚才引出来的两个问题了。

问题一：为什么说C#是静态的类型化的语言，而Javascript是动态的类型化的语言？
因为C#是在编译时进行类型检查的；要想运行C#书写的程序，得先将C#代码编译成为IL代码，这里就进行了类型检查；即静态类型检查。

而Javascript是一门解释运行的语言，在运行Js书写的程序前，无需进行编译，它是在程序启动运行时才进行类型检查的，类型检查通过了，就会解释执行当前行代码；即动态类型检查。

问题二：为什么说C#是强类型化的语言，而Javascript是弱类型化的语言？
因为C#在进行编译检查时，满足了强类型化语言所定义规则；而Js不满足这些规则，所以说C#是强类型化的语言，Js是弱类型化的语言。

附上语言分类图，以及知乎上的一个参考链接，那里说的比较学术性。
这里写图片描述

3.动态编程在C#里的发展：
在.NET Framework 的以前版本中，var关键字和匿名方法开辟出C#的“动态编程”路径。在版本4中，新增了dynamic类型，这才使得.NET Framework真正有了动态编程的能力。

3.1 var关键字和匿名方法：
Var关键字，用于隐式声明变量的类型，在编译时，编译器会进行类型推断，会确认变量的类型是什么。（智能感知在代码书写完成后，就能知道变量的类型）所以隐式类型的变量是强类型的。

Var在很多场合不是必须，但也有一些场合是必须，比如Linq查询中。
如下图所示：
var关键字
两个查询表达式。
在第一个表达式中，var 的使用是允许的，但不是必需的，因为查询结果的类型可以明确表述为 IEnumerable<string>。

但是，在第二个表达式中，必须使用 var，因为结果是匿名类型的集合，并且该类型的名称只有编译器本身才可访问。

需要注意的是，在示例 #2 中，foreach 迭代变量 item 必须也为隐式类型。即用var关键字声明变量，因为我们不知道该类型的名称，只有编译器知道。

接着是匿名方法：
在 2.0 之前的 C# 版本中，声明委托的唯一方法是使用命名方法。
C# 2.0 引入了匿名方法，
而在 C# 3.0 及更高版本中，Lambda 表达式取代了匿名方法，作为编写内联代码的首选方式。
匿名方法

3.2 dynamic关键字：
其实这前面说的仍是静态类型检查机制。对C#语言本身影响不大，直到dynamic类型的出现，才使得C#可以在运行时再确定变量类型，也就是部分代码进行动态类型检查，这才将弱类型化语言的一些特性赋予了C#。

dynamic 类型允许编写忽略编译期间的类型检查代码 。编译器假定，给dynamic类型的对象定义的任何操作都是有效的。如果该操作无效，则在代码运行之前不会检测该错误。

与var关键字不同，定义为dynamic的对象可以在运行期间改变其类型。

//下面的这些代码都是可以正常运行的
            dynamic dyn;
            dyn = 100;
            Console.WriteLine(dyn.GetType());
            Console.WriteLine(dyn);

            dyn = "This is a string";
            Console.WriteLine(dyn.GetType());
            Console.WriteLine(dyn);

            dyn = new SomeClass();

在使用var关键字时，对象类型的确定会延迟。类型一旦确定，就不能改变。动态对象（dynamic）的类型可以改变，而且可以改变多次，这不同于把对象的类型强制转换为另一种类型。在运行前，它始终只有一个类型，那就是dynamic。在运行时，它的类型可以进行改变。
这些动态功能是Dynamic Language Runtime（动态语言运行时）的一部分。

接着我们看看几个实例：
3.2.1 使用ExpandoObject类型来创建自己的动态类型：

using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExpandoObjectSample
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic expObj = new ExpandoObject();
            //字段、属性
            expObj.FirstName = "Liu1";
            expObj.LastName = "Liu2";
            Console.WriteLine(expObj.FirstName + " " + expObj.LastName);

            //方法
            Func<DateTime, string> GetTomorrow = today => today.AddDays(1).ToShortDateString();
            expObj.GetTomorrowDate = GetTomorrow;
            Console.WriteLine("Tomorrow is {0}", expObj.GetTomorrowDate(DateTime.Now));

            //集合
            expObj.Friends = new List<Person>();
            expObj.Friends.Add(new Person() { FirstName = "Bob", LastName = "Jones" });
            expObj.Friends.Add(new Person() { FirstName = "Liu", LastName = "Jones" });
            expObj.Friends.Add(new Person() { FirstName = "Tao", LastName = "Jones" });
            foreach (Person friend in expObj.Friends)
            {
                Console.WriteLine(friend.FirstName + " " + friend.LastName);
            }

            Console.ReadLine();
        }
    }

    class Person
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string GetFullName()
        {
            return string.Concat(FirstName, " ", LastName);
        }
    }

}

这上面在使用FirstName ，LastName，GetTomorrowDate ，Friends 时，就像它本来就已经定义在ExpandoObject类型中一样，但ExpandoObject是.NET Framework定义的一个类型。它没有包含这些字段，属性，方法的定义。点我查看ExpandoObject源码

这里面ExpandoObject类封装起来的其实是这样的三个方法，代码如下，可以拷贝到控制台中单步运行一下；

using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TaoDynamicObject
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic expObj = new TaoDynamicObject();
            //字段、属性
            expObj.FirstName = "Liu1";
            expObj.LastName = "Liu2";
            Console.WriteLine(expObj.FirstName + " " + expObj.LastName);

            //方法
            Func<DateTime, string> GetTomorrow = today => today.AddDays(1).ToShortDateString();
            expObj.GetTomorrowDate = GetTomorrow;
            Console.WriteLine("Tomorrow is {0}", expObj.GetTomorrowDate(DateTime.Now));

            //集合
            expObj.Friends = new List<Person>();
            expObj.Friends.Add(new Person() { FirstName = "Bob", LastName = "Jones" });
            expObj.Friends.Add(new Person() { FirstName = "Liu", LastName = "Jones" });
            expObj.Friends.Add(new Person() { FirstName = "Tao", LastName = "Jones" });
            foreach (Person friend in expObj.Friends)
            {
                Console.WriteLine(friend.FirstName + " " + friend.LastName);
            }

            Console.ReadLine();
        }
    }

    class TaoDynamicObject : DynamicObject
    {
        Dictionary<string, Object> _dynamicData = new Dictionary<string, object>() { };

        public override  bool TryGetMember(GetMemberBinder binder,out object result)
        {
            bool success = false;
            result = null;

            if (_dynamicData.ContainsKey(binder.Name))
            {
                result = _dynamicData[binder.Name];
                success = true;
            }
            else
            {
                result = "Property Not Found!";
                success = false;
            }
            return success;
        }
        //如何进行类型转换的？从object转换成为相应的类型
        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            _dynamicData[binder.Name] = value;
            return true;
        }

        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
        {
            dynamic method = _dynamicData[binder.Name];

            //这里如何处理多种类型的参数？
            //1.存储在托管堆上的对象，有自描述其类型的信息
            //2.会根据调用方法规定的参数类型进行强制转换
            result = method((DateTime)args[0]);
            return result != null;
        }
    }

    class Person
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string GetFullName()
        {
            return string.Concat(FirstName, " ", LastName);
        }
    }
}

在main函数中虽然没有明确的调用TryGetMember，TrySetMember，TryInvokeMember这三个函数，但在编译成IL时，编译器帮我们完成了这一步。

3.2.2 这个例子是为了说明少用dynamic类型：
当我们在使用dynamic类型时，虽然语法看起来很简洁，就像是在使用如int，string这样的关键字，并且还能够获得弱类型化的语言的一些功能，但在这儿背后是CLR做了大量的工作。

下面我们用一个实例来说明这点：
整体代码如下:

using System;

namespace DeCompile
{
    class Program
    {
        static void Main(string[] args)
        {
            StaticClass staticObject = new StaticClass();
            //DynamicClass dynamicObject = new DynamicClass();
            Console.WriteLine(staticObject.IntValue);
            //Console.WriteLine(dynamicObject.DynValue);
            Console.ReadLine();
        }
    }

    class StaticClass
    {
        public int IntValue = 100;
    }

    class DynamicClass
    {
        public dynamic DynValue = 100;
    }
}

我先注释了DynamicClass 这个类型的对象。在生成.exe程序之后用IL dasm.exe反编译成IL代码。

开始菜单中，找到并打开下图所示的 VS2015 开发人员命令提示
VS2015 开发人员命令提示
输入ildasm，并回车。
这里写图片描述

然后拖动exe程序到出现的ildasm程序中
这里写图片描述

这里生成的IL代码很少。
接着注释掉StaticClass ，并把DynamicClass 的注释去掉，在进行反编译。
就会得到如下所示的IL代码：

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // 代码大小       119 (0x77)
  .maxstack  9
  .locals init ([0] class DeCompile.DynamicClass dynamicObject)
  IL_0000:  newobj     instance void DeCompile.DynamicClass::.ctor()
  IL_0005:  stloc.0
  IL_0006:  ldsfld     class [System.Core]System.Runtime.CompilerServices.CallSite`1<class [mscorlib]System.Action`3<class [System.Core]System.Runtime.CompilerServices.CallSite,class [mscorlib]System.Type,object>> DeCompile.Program/'<>o__0'::'<>p__0'
  IL_000b:  brtrue.s   IL_004c
  IL_000d:  ldc.i4     0x100
  IL_0012:  ldstr      "WriteLine"
  IL_0017:  ldnull
  IL_0018:  ldtoken    DeCompile.Program
  IL_001d:  call       class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
  IL_0022:  ldc.i4.2
  IL_0023:  newarr     [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo
  IL_0028:  dup
  IL_0029:  ldc.i4.0
  IL_002a:  ldc.i4.s   33
  IL_002c:  ldnull
  IL_002d:  call       class [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo::Create(valuetype [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags,
                                                                                                                                                                             string)
  IL_0032:  stelem.ref
  IL_0033:  dup
  IL_0034:  ldc.i4.1
  IL_0035:  ldc.i4.0
  IL_0036:  ldnull
  IL_0037:  call       class [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo::Create(valuetype [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags,
                                                                                                                                                                             string)
  IL_003c:  stelem.ref
  IL_003d:  call       class [System.Core]System.Runtime.CompilerServices.CallSiteBinder [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.Binder::InvokeMember(valuetype [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpBinderFlags,
                                                                                                                                                               string,
                                                                                                                                                               class [mscorlib]System.Collections.Generic.IEnumerable`1<class [mscorlib]System.Type>,
                                                                                                                                                               class [mscorlib]System.Type,
                                                                                                                                                               class [mscorlib]System.Collections.Generic.IEnumerable`1<class [Microsoft.CSharp]Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo>)
  IL_0042:  call       class [System.Core]System.Runtime.CompilerServices.CallSite`1<!0> class [System.Core]System.Runtime.CompilerServices.CallSite`1<class [mscorlib]System.Action`3<class [System.Core]System.Runtime.CompilerServices.CallSite,class [mscorlib]System.Type,object>>::Create(class [System.Core]System.Runtime.CompilerServices.CallSiteBinder)
  IL_0047:  stsfld     class [System.Core]System.Runtime.CompilerServices.CallSite`1<class [mscorlib]System.Action`3<class [System.Core]System.Runtime.CompilerServices.CallSite,class [mscorlib]System.Type,object>> DeCompile.Program/'<>o__0'::'<>p__0'
  IL_004c:  ldsfld     class [System.Core]System.Runtime.CompilerServices.CallSite`1<class [mscorlib]System.Action`3<class [System.Core]System.Runtime.CompilerServices.CallSite,class [mscorlib]System.Type,object>> DeCompile.Program/'<>o__0'::'<>p__0'
  IL_0051:  ldfld      !0 class [System.Core]System.Runtime.CompilerServices.CallSite`1<class [mscorlib]System.Action`3<class [System.Core]System.Runtime.CompilerServices.CallSite,class [mscorlib]System.Type,object>>::Target
  IL_0056:  ldsfld     class [System.Core]System.Runtime.CompilerServices.CallSite`1<class [mscorlib]System.Action`3<class [System.Core]System.Runtime.CompilerServices.CallSite,class [mscorlib]System.Type,object>> DeCompile.Program/'<>o__0'::'<>p__0'
  IL_005b:  ldtoken    [mscorlib]System.Console
  IL_0060:  call       class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
  IL_0065:  ldloc.0
  IL_0066:  ldfld      object DeCompile.DynamicClass::DynValue
  IL_006b:  callvirt   instance void class [mscorlib]System.Action`3<class [System.Core]System.Runtime.CompilerServices.CallSite,class [mscorlib]System.Type,object>::Invoke(!0,
                                                                                                                                                                             !1,
                                                                                                                                                                             !2)
  IL_0070:  call       string [mscorlib]System.Console::ReadLine()
  IL_0075:  pop
  IL_0076:  ret
} // end of method Program::Main

看到上面生成的这么多看不太懂的代码，你就知道了，为什么不建议使用dynamic了吧。

4.ASP.NET MVC里的ViewBag：
说到ViewBag，就会说到ViewData和ViewDataDictionary

这里写图片描述

参考链接
ViewBag，ViewData

结合上面说到得dynamic类型，我们知道在页面中应该尽可能少的使用ViewBag，而更多的要使用强类型视图 即@model 语法。

5.结语：
博文中的概念性叙述比较多，有什么说的不对的地方，欢迎各位留言评论交流。

KingArthur_Tao
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
掌握元数据编程魔法：C# Reflection Emit实战，动态构建类型与方法的深度探索
java专栏
04-26 167
通过这个示例，您可以看到如何利用C#中的Reflection Emit API来动态生成包含属性和方法的类型，以及如何编写相应的IL指令来实现方法的逻辑。命名空间下的类来实现，这些类提供了低级别的IL（Intermediate Language，即微软中间语言）生成接口，用于构建新的类型和方法。下面，我们将通过一个详细的示例来展示如何使用Reflection Emit动态生成一个简单的类型，并附带丰富的代码和注释说明。定义一个动态程序集和其中的一个模块，作为动态类型存放的地方。的无参数方法，返回类型为。
C# 自带编译器实现程序运行过程中动态编译并运行字符串中的C#代码
04-23
C# 自带编译器实现程序运行过程中动态编译并运行字符串中的C#代码
C#简单的动态程序编译过程
qq_27474555的博客
03-24 725
C#简单的动态程序编译过程
在C#语言中动态加载和执行工作流活动
寒冰屋的专栏
12-03 900
在工作流的执行上下文中，需要执行来自不同业务部门的活动。此解决方案通过使用反射和面向对象编程来简化和统一它。
C#实现动态编程（即时编译JIT），执行本文代码，将文本转化为代码或者dll
magicchz的博客
05-20 1056
顾名思义，动态编程就是动态的把程序代码编辑好，即时生成软件，立即使用。我们平时的编程都是静态编程，即将代码写好，生成软件之后使用。动态编程是软件写好之后，将部分代码灵活地加入到程序里面。动态编程可以运用在PAAS风格的产品里面，可以用于实现模态软件。
【深入浅出C#】章节 9: C#高级主题：反射和动态编程
最新发布
喵叔
09-02 940
反射（Reflection）是计算机科学中的一个概念，通常用于描述在运行时动态地获取、检查和操作程序的类型、成员、方法、属性和其他代码元素的能力。反射使得程序能够在运行时了解自身的结构和元数据信息，而不需要在编译时知道这些信息。反射允许你在运行时获取对象的类型信息，包括类的名称、命名空间、基类、实现的接口等。这对于动态加载和操作程序集中的类型非常有用。通过反射，你可以获取类的字段、属性、方法、事件等成员的信息，包括它们的名称、数据类型、访问修饰符和特性。这使得你可以在运行时动态地操作这些成员。
C#动态编译
qq_35691561的博客
05-31 2138
C#动态编译 现在写的项目涉及了在.net standard下的动态编译，这篇文章就是来记录一下实现动态编译的过程。 CodeDom 一开始我使用的是System.CodeDom,在运行时会报错提示平台不支持的错误，在查询后发现.Net Standard不支持System.CodeDom，需要在上面一层建立和Roslyn依赖关系。Roslyn是一种.net 编译器。这一层也有人提供，叫Microsoft.CodeDom.Providers.DotNetCompilerPlatform。但我这次的实现并没有用
C# 动态编译代码实现
Tim专栏
11-20 7112
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.CodeDom.Compiler; using Microsoft.CSharp; using System.Web; using System.Reflection; namespac
C#-Windows编程
06-19
C#-Windows编程
C#.NET串口通信控件C#-.NET常用控件C#-串口编程SerialPort控件文档资料（10个）.zip
12-31
C#.NET串口通信控件C#_.NET常用控件C#_串口编程SerialPort控件文档资料（10个）： 001.C#_SerialPort控件通信详细介绍.pdf 002.C#_串口编程SerialPort控件.doc 003.C#串口通信：MSComm控件使用详解.doc 004.C#_.net...
C#中的动态类型(Dynamic)的项目工程
02-25
包含《C#中的动态类型(Dynamic)》文章涉及到的应用场景示例，比如： ①序列化对象; ②动态解析转换；
C#在运行时动态创建类型的实现方法
12-31
本文实例讲述了C#在运行时动态创建类型的实现方法。是C#项目开发中很实用的技巧。分享给大家供大家参考。具体分析如下： 具体来说，C# 在运行时动态的创建类型是通过动态生成C#源代码，然后通过编译器编译成程序集的方式实现动态创建类型的。 主要功能代码如下： public static Assembly NewAssembly() { //创建编译器实例。 provider = new CSharpCodeProvider(); //设置编译参数。 cp = new CompilerParameters(); cp.GenerateExecutable = false;
c#-ymodem-update
09-28
标题"C#-ymodem-update"指的是一个使用C#编程语言开发的YMODEM协议实现，主要功能是用于设备固件的升级，特别是针对bootloader的更新。YMODEM是一种流行的串行通信协议，用于在计算机之间传输文件，尤其是在低带宽和...
c#winform-C#编程篇
07-26
快速学会C#。好资源同分享.
C#经典编程-220例
09-03
《C#经典编程-220例》是一本深度挖掘C#编程精髓的教程，它包含了大量的实例，旨在帮助读者全面掌握C#编程语言的核心概念和技术。这220个例子覆盖了C#编程的各个层面，从基础语法到高级特性，从控制流到面向对象编程...
[小技巧]C# .net 动态编程 （1）
iml6yu的博客
08-22 481
文章目录动态编程第一个小目标知识点源代码显示结果待处理坑1总结 动态编程 最初想法：类似js那样动态的加载一段源代码可以直接对其操作。 js属于解释型语言，所以动态对于他来说属于先天具有，可以说是固有属性。 c# 属于编译型语言，所有对象理论都应该是提前编译好，才能运行的。 但是.net 已经考虑好了这一点，所以从根本上是支持动态编程的。 第一个小目标 根据源代码，动态编译并且能够设置和取到对应的属性值 知识点 反射 （基本使用到的两个类 Activator或者 Assembly。 有兴趣的网上搜资料）
C#:实现动态规划背包求解器算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
09-03 451
C#:实现动态规划背包求解器算法（附完整源码）
C# 动态类创建、动态创建属性和取动态类属性值
b07lxh的博客
05-22 9537
动态类创建、动态属性建立、赋值和取值
C# 学习笔记 16.动态类型
xiao_shentong的博客
04-05 346
一、动态类型介绍 c#是静态类型语言，因为它在定义变量的时候要明确给出变量的类型。 c#4.0中微软引入了dynamic关键字来动议动态类型。 二、为什么引入动态类型 1.减少强制类型转换的使用 2.调用python等动态语言 三、动态类的约束 ...
Microsoft Visual C#2008 step-by-step编程指南
《Microsoft Visual C#2008 Step by ...如果你是IT专业人员或对C#编程感兴趣，这本书将是深入理解和掌握Visual C#2008的理想资源。访问Microsoft Press的网站www.microsoft.com/mspress，可以获取更多相关信息和资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值