C#（二） C#高级进阶

已于 2024-07-14 11:38:55 修改
阅读量8.9k 收藏 281
点赞数 26
分类专栏： 【编程语言】 # .Net 文章标签： c# 开发语言 .net
于 2022-08-14 21:05:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40772692/article/details/126336296
版权

1.C# 委托

​ C# 中的委托（Delegate）类似于 C 或 C++ 中的函数指针，是一种引用类型，表示对具有特定参数列表和返回值类型的方法的引用。简单来说，委托是一种方法的代理/中介，委托指向某个方法来实现具体的功能。委托是方法的抽象，它存储的就是一系列具有相同参数和返回值类型的方法的地址。 委托的使用包括定义声明委托、实例化委托以及调用委托三个阶段，在实例化委托时，必须将委托的实例与具有相同返回值类型以及参数列表的方法相关联，这样就可以通过委托来调用方法。另外，使用委托还可以将方法作为参数传递给其他方法。下面是一个委托的形象例子：

某人有三子，让他们各自带一样东西出门，并带回一头猎物。
上面一句话可以理解为父亲对儿子的委托：猎物 办法(工具 某工具)-->delegate 猎物(返回值) 带回猎物(委托名)(工具(参数类型) x)-->delegate int GetValue(int i)
三个人执行委托的方法各不相同
兔子 打猎(工具 弓)-public static int GetValue1(int i){ return i; }
野鸡 买(工具 钱)-public static int GetValue2(int i){ return i*2; }
狼 诱捕(工具 陷阱)-public static int GetValue3(int i){ return i*i; }

1.1 声明委托

delegate <return type> delegate-name(<parameter list>)
- return type 为返回值类型
- delegate-name 为委托的名称
- parameter list 为参数列表

注意： 委托可以引用与委托具有相同签名的方法，也就是说委托在声明时即确定了委托可以引用的方法。

public delegate int MyDelegate (string s);
//上面的委托可被用于引用任何一个带有一个单一的 string 参数的方法，并返回一个 int 类型变量。

1.2 实例化委托

​ 委托一旦声明，想要使用就必须使用 new 关键字来创建委托的对象，同时将其与特定的方法关联。当创建委托时，传递到 new 语句的参数为关联的方法名称，就像方法调用一样书写，但是不带有参数。

public delegate void printString(string s);                      // 声明一个委托
...
printString ps1 = new printString(WriteToScreen);       // 实例化委托对象并将其与 WriteToScreen 方法关联
printString ps2 = new printString(WriteToFile);            // 实例化委托对象并将其与 WriteToFile 方法关联

1.3 委托的使用

  • Action(arg): 调用委托Action并传入参数arg
  • Action.Invoke(arg): 调用委托Action并传入参数arg
  • 两种方式的关系：所有的委托类型，编译器都会自动生成一个 invoke 方法。用委托类型直接加参数是Invoke(参数)的一个捷径。其实等价调用 Invoke();
using System;

delegate int NumberChanger(int n);      // 定义委托
namespace c.biancheng.net
{
    class Demo
    {
        static int num = 10;
        public static int AddNum(int p){
            num += p;
            return num;
        }

        public static int MultNum(int q){
            num *= q;
            return num;
        }
        
        public static int getNum(){
            return num;
        }
        
        
        public static void Calculate(NumberChanger nc, int a)
        {
            nc(a);
        }
        
        static void Main(string[] args){
            // 创建委托实例
            NumberChanger nc1 = new NumberChanger(AddNum); 
            // 使用委托对象调用方法
            // 等价于 nc1.Invoke(25)
            nc1(25);
            Console.WriteLine("num 的值为: {0}", getNum());
            // 使用委托传递方法作为参数
            Calculate(MultNum,5)
            Console.WriteLine("num 的值为: {0}", getNum());
            Console.ReadKey();
        }
    }
}

1.4 多播委托（合并委托）

​ 在开发中，我们有时候会遇到要通过调用一个委托，同时可以执行多个方法的时候，就可以考虑用多播委托。委托对象有一个非常有用的属性，那就是可以通过使用+运算符将多个对象分配给一个委托实例，同时还可以使用-运算符从委托中移除已分配的对象，当委托被调用时会依次调用列表中的委托。委托的这个属性被称为委托的多播，也可称为组播，利用委托的这个属性，您可以创建一个调用委托时要调用的方法列表。注意：仅可合并类型相同的委托。

  • 多播委托的实质：一个委托实例不仅可以指向一个方法，还可以指向多个方法。

  • 总结：多播委托提供了一种类似于流水线的钩子机制，只要加载到这条流水线上的委托，都会被顺序执行。因为所有的都继承自MulticastDelegate,因此所有的委托都具有多播特性

using System;

delegate int NumberChanger(int n);      // 定义委托
namespace c.biancheng.net
{
    class Demo
    {
        static int num = 10;
        public static int AddNum(int p){
            num += p;
            return num;
        }

        public static int MultNum(int q){
            num *= q;
            return num;
        }
        public static int getNum(){
            return num;
        }
        static void Main(string[] args){
            // 创建委托实例
            NumberChanger nc;
            NumberChanger nc1 = new NumberChanger(AddNum);
            NumberChanger nc2 = new NumberChanger(MultNum);
            nc = nc1;
            nc += nc2;
            // 调用多播
            nc(5);
            Console.WriteLine("num 的值为: {0}", getNum());
            Console.ReadKey();
        }
    }
}

1.5 Func与Action

​ 在上述我们在使用委托的过程中，都是自定义一个委托类型，再使用这个自定义的委托定义一个委托字段或变量。而在.NetFramework3.0之后又新加入了一种特性，C#语言预先为我们定义了两个常用的委托，分别是Func和Action，还带来了Lambda，这使得委托的定义和使用变得简单起来， 在以后进行C#程序编写中引入委托更加灵活。

（1）Action 委托

​ C#中与预定义了一个委托类型Action，其基本特点就是可以执行/指向一个没有返回值（void）的方法。是一类没有输出参数的委托。

  • 原生Action: public delegate void Action(); 封装一个方法，该方法不具有参数且不返回值。
  • 泛型Action: public delegate void Action(T arg1,…); 封装一个方法，该方法具有参数并且不返回值(最多可有16个参数)
    static void printString()
    {
        Console.WriteLine("Hello World");
    }
    static void printNumber(int x)
    {
        Console.WriteLine(x);
    }
    static void Main(String[] args)
    {
        //Action基本使用
        Action a = printString;
        a(); // 输出结果  Hello World
        //Action指向有参数的方法
        Action<int> b = printNumber; // 定义一个指向 形参为int的函C#数
        b(5); // 输出结果  5
    }

（2）Func 委托

​ 委托类型Func同样也是C#中与预定义的委托，其基本特点就是可以执行/指向一个具有返回值的方法。与Action不同的是Func只有带泛型的一种形式。

  • 无参 Func：public delegate TResult Func();封装一个方法，该方法不具有参数，且返回由 TResult 参数指定的类型的值。
  • 有参 Func：public delegate TResult Func<in T,int T,…,out TResult>(T arg1,T arg2,…);封装一个方法，该方法具有参数，且返回由 TResult 参数指定的类型的值。(最多可有16个参数)
  • 注意：泛型列表中最后一个泛型参数代表返回类型，前面的都是参数类型；参数类型必须跟指向的方法的参数类型按照顺序一一对应。
namespace delegatesample_10._15_
{
    class Program
    {
        static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            //声明Func
            Func<int, int, int> func1 = new Func<int, int, int>(calculator.Add);
            Func<int, int, int> func2 = new Func<int, int, int>(calculator.Sub);
            int x = 100;
            int y = 200;
            int z1 = 0;
            int z2 = 0;
            z1 = func1.Invoke(x, y);
            Console.WriteLine(z1);
            z1 = func1(x, y);
            Console.WriteLine(z1);//都是Add方法的调用，输出两遍。
            z2 = func2.Invoke(x, y);
            Console.WriteLine(z2);
            z2 = func2(x, y);
            Console.WriteLine(z2);//都是Sub方法的调用，输出两遍。
        }
    }
    class Calculator
    {
        public int Add(int a,int b)
        {
            int result = a + b;
            return result;
        }
        public int Sub(int a,int b)
        {
            int result = a - b;
            return result;
        }
    }
}

2.C# 类型转换

2.1 类型检查 is

  • is： 检查对象是否与给定类型兼容。
object objTest = 11;
if( objTest is int )
{
    int nValue = (int)objTest;
}

2.2 自动转换 as

  • as： 用于在兼容的引用类型之间自动执行转换。如果是，as会返回对同一个对象的一个非null的目标引用；如果不兼容于目标类型，as运算符会返回null。
Employee myEmployee = myObject as Employee; 
if (myEmployee != null) { 
	...
}

注意： 用as来进行类型转换的时候，所要转换的对象类型必须是目标类型或者转换目标类型的派生类型，但不能应用在值类型数据。参考：C#中对象或普通类型进行类型转换

3.C# 匿名函数/方法

​ 在 C# 中，可以将匿名函数简单的理解为没有名称只有函数主体的函数。匿名函数提供了一种将代码块作为委托参数传递的技术，它是一个“内联”语句或表达式，可在任何需要委托类型的地方使用。匿名函数可以用来初始化命名委托或传递命名委托作为方法参数。需要注意的是：无需在匿名函数中指定返回类型，返回值类型是从方法体内的 return 语句推断出来的。匿名函数包括 Lambda 表达式和普通匿名函数两种声明方式。

  • 普通匿名函数：使用 delegate 关键字创建委托实例来声明。 = delegate (string str){ return str;};
  • Lambda表达式： = (参数列表 input-parameters) => { 函数体 expression; }; 括号内多个输入参数使用逗号加以分隔
class Test
{
    delegate void TestDelegate(string s);
    static void M(string s)
    {
        Console.WriteLine(s);
    }
 
    static void Main(string[] args)
    {
        //委托实例化形式1：普通的委托new方式
        TestDelegate testDelA = new TestDelegate(M);
　　　   //委托实例化形式2：普通匿名函数方式
        TestDelegate testDelB = delegate(string s) { Console.WriteLine(s); };
        //委托实例化形式3：Lambda表达式方式
        TestDelegate testDelC = (x) => { Console.WriteLine(x); };
 
        testDelA("Hello. My name is M and I write lines.");
        testDelB("That's nothing. I'm anonymous and ");
        testDelC("I'm a famous author.");
 
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}

4. C# 属性

属性语法是字段的自然延伸。 字段用来定义存储位置，而属性定义包含 get 和 set 访问器的声明（至少有一个），这两个访问器用于检索该属性（对应的字段）的值以及对其赋值。访问属性时，其行为类似于字段。 但与字段不同的是，属性通过访问器实现；访问器用于定义访问属性或为属性赋值时执行的语句。通过属性可以提供验证、不同的可访问性、迟缓计算或方案所需的任何要求。

（1）传统属性定义

//传统属性声明
//特点：存取时可做逻辑操作，但代码量多比较繁琐
class Student
{
	//字段
    private int _age; 
    private string _name;
    private Gender _gender;

	//属性访问器
    public int Age { get { return _age; } set { _age = value; } }
    public string Name { get { return _name; } set { _name = value; } }
    public Gender Gender { get { return _gender; } set { _gender = value; } }
}

（2）自动属性定义

自动属性有完全没有逻辑的get访问器和set访问器。在访问器后不写函数主体，而是直接以分号结尾。编译器会自动生成支持该属性的字段的存储位置，这个字段被称为匿名字段，仅供该属性访问。匿名字段没有名字，所以你不能在代码中亲自使用它。只能通过配套的自动属性间接使用。

//自动属性声明：编译器会自动把这段代码翻译成上面的完整版本
//特点：减少代码量简化开发，但属性定义时不能做其他逻辑判断只能简单存取
class Student
{
    public int Age { get; set; }
    public string Name { get; set; }
    public Gender Gender { get; set; }
}

（3） 可访问性控制

  • 访问权限

可以在访问器前使用访问修饰符，但在单个访问器上放置的任何访问修饰符都必须比属性定义上的访问修饰符提供更严格的限制。

public class Person
{
	//现在，可以从任意代码访问 FirstName 属性，但只能从 Person 类中的其他代码对其赋值。
    public string FirstName { get; private set; }

    // Omitted for brevity.
}
  • 只读/只写

还可以直接限制对属性的修改方式，即访问器的声明。

		//声明只读属性
		public ICommand CheckCommand
        {
            get
            {
                return new RelayCommand(_ =>
                {
                   //do something...
                });
            }
        }

（4）抽象属性

抽象类可拥有抽象属性，这些属性应在派生类中被实现。下面的程序说明了这点：

using System;
namespace runoob
{
   public abstract class Person
   {
      public abstract string Name
      {
         get;
         set;
      }
      public abstract int Age
      {
         get;
         set;
      }
   }
   class Student : Person
   {

      private string code = "N.A";
      private string name = "N.A";
      private int age = 0;

      // 声明类型为 string 的 Code 属性
      public string Code
      {
         get
         {
            return code;
         }
         set
         {
            code = value;
         }
      }
   
      // 声明类型为 string 的 Name 属性
      public override string Name
      {
         get
         {
            return name;
         }
         set
         {
            name = value;
         }
      }

      // 声明类型为 int 的 Age 属性
      public override int Age
      {
         get
         {
            return age;
         }
         set
         {
            age = value;
         }
      }
      public override string ToString()
      {
         return "Code = " + Code +", Name = " + Name + ", Age = " + Age;
      }
   }
   class ExampleDemo
   {
      public static void Main()
      {
         // 创建一个新的 Student 对象
         Student s = new Student();
           
         // 设置 student 的 code、name 和 age
         s.Code = "001";
         s.Name = "Zara";
         s.Age = 9;
         Console.WriteLine("Student Info:- {0}", s);
         // 增加年龄
         s.Age += 1;
         Console.WriteLine("Student Info:- {0}", s);
         Console.ReadKey();
       }
   }
}

5. C# 事件

事件建立在委托之上，与委托不同的是：委托是一个行为/动作，而事件是一个从动作发生->行为处理的过程，是个模型。事件（Event） 基本上说是一个用户操作，如按键、点击、鼠标移动等等，或者是一些出现，如系统生成的通知。应用程序需要在事件发生时响应事件。
举个例子：“发生→响应”中的五个部分：闹钟响铃了小明起床。其中4个部分很容易看出：闹钟（事件源），响铃（事件），小明（订阅者），起床（事件处理行为）。其中还有一个隐含的部分为：订阅。 也就是小明订阅了他手机的铃声，手机响铃时，小明才会发生反应。如果是别人的手机，小明没有订阅，就算响铃，小明也不会有反应。

5.1 事件模型

事件在类中声明且生成，且通过使用同一个类或其他类中的委托与事件处理程序关联。包含事件的类用于发布事件。这被称为 发布器（publisher） 类。其他接受该事件的类被称为 订阅器（subscriber） 类。事件使用 发布-订阅（publisher-subscriber） 模型。

  • 发布器（publisher） 是一个包含事件和委托定义的对象。事件和委托之间的联系也定义在这个对象中。发布器（publisher）类的对象调用这个事件，并通知其他的对象。

  • 订阅器（subscriber） 是一个接受事件并提供事件处理程序的对象。在发布器（publisher）类中的委托调用订阅器（subscriber）类中的方法（事件处理程序）。

5.2 事件声明

在类的内部声明事件，首先必须声明该事件的委托类型。例如：

public delegate void BoilerLogHandler(string status);

然后，声明事件本身，使用 event 关键字包装委托：

// 基于上面的委托定义事件
public event BoilerLogHandler BoilerEventLog;

5.3 事件的使用

        //事件发布者
        public class PublishEvent
        {	//拥有事件及其委托
            public delegate string Display(string str);
            public event Display DisplayEvent;

            //事件触发器
            public void Shows(string str)
            {
                if (DisplayEvent != null)
                {
                    DisplayEvent(str);
                }
            }

        }

        //事件订阅者
        public class Listen1
        {
        	//订阅事件的处理/响应方法
            public string MakeAlert(string str)
            {
                Console.WriteLine(str + "Listen1");
                return str + "Listen1";
            }
        }

		class Program
        {
            static void Main()
            {
            	//1.声明事件发布者
                PublishEvent pe = new PublishEvent();
                //2.声明订阅者
                Listen1 l1 =  new Listen1();
                Listen2 l2 = new Listen2();

                //变量l1和l2订阅了事件（当侦听到事件发生时会调用各自的方法响应事件）
                pe.DisplayEvent += l1.MakeAlert;
                pe.DisplayEvent += l2.ShowMsg;

                //触发事件->通知订阅->响应事件
                pe.Shows("事件");

                Console.ReadKey();

            }
        }

5.4 注意事项

  • 事件的本质：事件的本质是委托字段的一个包装器，是特殊的委托。这个包装是对委托起到限制作用，防止对象内部的委托实例被外部乱用，封装的一个重要的功能就是隐藏。事件对外界隐藏了委托实例的大部分功能。
    • 限制一：委托的调用没有限制，可以在任意的地方进行调用，而事件修饰过的委托只能在定义自己的类内部进行调用。
    • 限制二：委托可以使用“=”、“+=”、“-=”三种符号来表示赋值，添加和移除一个函数，而事件修饰过的委托在自己的类中也可以使用这三个符号（注意子类也属于外部的类），而在外部的类中时则只能使用“+=”和“-=”来添加移除函数，不能使用“=”进行直接赋值
  • 命名规范：用于声明事件的委托，一般命名为事件名+EventHandler。事件名+EventHandler的委托参数一般有两个（由win32API 演化而来，历史悠久）
    • 第一个参数：sender是Object类型，表示事件源\事件发送者 。
    • 第二个参数：e是EventArgs类型 。EventArgs类表示包含事件数据的类的基类，并提供用于不包含事件数据的事件的值。

6. 快捷方式

  • prop+tab : 自动创建 属性
  • propdp+tab : 自动创建 依赖属性及其包装器
  • propfull+tab : 自动创建 属性及其字段
  • propa+tab : 自动创建 附加属性
C# 的 Moq 库高级进阶：刨根问底的深度解析
java专栏
09-08 481
通过今天的探索，我们了解了 Moq 的一些高级功能，包括如何模拟复杂的接口、使用自动模拟以及如何验证方法调用。希望这篇深入浅出的文章能帮助你在实际项目中更好地运用 Moq！🎈好了，小伙伴们，今天的分享就到这里啦！如果你有任何疑问或者想要分享自己的经验，请在评论区留言。我们下次再见！👋上述示例代码仅供参考，实际使用时请根据项目需求进行适当调整。✨Moq 官方文档Moq 单元测试指南Moq 自动模拟如果你需要模拟复杂的逻辑流，考虑使用和SetupSet对于复杂的测试场景，考虑使用AutoMocker。
C#高级编程二十天----静态类
见证大牛成长之路的专栏
06-21 1181
如果类只包含静态的方法和属性,该类就是静态的.静态类在功能上与使用私有静态构造函数创建的类相同.不能创建静态类的实例.使用关键字static关键字,编译器可以检查用户是否不经意间给类添加了实例成员.如果是,就生成一个编译错误.这可以确保不创建静态类的实例. 语法: static class StatucTest { public static void SayHello() {} }
C#入门及进阶教程（二）：C#应用程序的一般结构
qq_46689623的博客
01-26 799
C#入门及进阶教程（二）：C#应用程序的一般结构
《C# 编程入门全攻略：从基础到进阶的学习秘籍》
最新发布
zhu1996zhu的博客
03-31 857
本文为想要学习 C# 编程的初学者精心打造。从搭建学习环境开始，详细阐述 C# 基础语法，如数据类型、控制结构等内容，逐步深入到面向对象编程的关键要点。还涵盖项目实战、进阶知识以及持续学习的方法与资源推荐。无论你是零基础小白，还是有一定基础想巩固提升的，都能从中获取实用的学习指导，开启 C# 编程之旅。
c#高级进阶资料
02-21
泛型,反射,linq.设计模式,多线程,百万级数据库优化
C#高级
哲哲
05-27 1853
异常是在程序执行期间出现的问题。C# 中的异常是对程序运行时出现的特殊情况的一种响应，比如尝试除以零。 C# 异常处理有四个关键词：try、catch、finally 和 throw。 try：一个 try 块标识了一个将被激活的特定的异常的代码块。后跟一个或多个 catch 块。 catch：程序通过异常处理程序捕获异常。catch 关键字表示异常的捕获。 finally：finally 块用于...
C# 委托和事件高级进阶
dengyanxi2992的博客
10-29 395
本篇文章主要采用理论和代码实例相结合方式来论述委托和事件，涉及到一些边界技术，如软件架构的OCP原则(开-闭原则)， 软件架构解耦，设计模式(Sender-Order)和事件驱动模型，有一定难度和深度，不适合初级者。 第一部份 委托 关于委托内容，主要围绕下图来论述。 一 委托是什么(what) （一）委托产生的背景之一 1.我们先来假设这样一个情景需求： ...
C#高级教程
学习之路，创业之光
05-06 2551
语法上没有任何错误，只不过在运行过程由于某些原因出现了问题。转义符\n：换行（苹果系统或者控制台）\t：制表\b：删除前面的字符（注意：放在字符串的两端没有效果\r\n：换行（win系统）\：表示一个\可以这样用@"F:\fjld\fd\a\q.txt"取消在字符串中的转义作用在声明变量的最前面加const属性的作用就是保护字段、对字段的赋值和取值进行限定。属性的本质就是两个方法，一个叫get()一个叫set()。1.抽象成员必须标记为abstract,并且不能有任何实现。
C#进阶
weixin_30629653的博客
11-29 639
基于C#高级编程第10版 第Ⅰ部分 C# 语 言第1章 .NET应用程序体系结构 2第2章 核心C# 29第3章 对象和类型 71第4章 继承 102第5章 托管和非托管的资源 122第6章 泛型 155第7章 数组和元组 179第8章 运算符和类型强制转换202第9章 委托、lambda表达式和第10章 字符串和正则表达式 264第11章 集合 284第12章 特殊的集合 317第13章 LI...
基于C#语言的C高级语法进阶设计与源码解析
09-29
本项目旨在深入探讨C#语言中的高级特性，并通过丰富的实例源码，为C#开发人员提供一个实践与理论相结合的学习资源。项目所包含的资源文件类型多样，从源代码到项目配置，再到资源文件，为学习者构建了一个全方位的...
《C#进阶》--01.泛型
qq_43372178的博客
06-19 627
需要说明，泛型语法是C#进阶语法学习中的最基础的语法，很多语法和技术点的学习，知识点的耦合非常严重，例如委托，Lambda等等的学习中，都穿插着泛型的使用，这也是C#进阶语法学习的起点1）ArrayList 先看一个常用集合ArrayList的基本使用 ArrayList再存数据时指定是Object，存储起来非常方便，可以存放任意类型的元素，但是它有以下几个缺点2）List List使用泛型解决了上述问题 什么是泛型 1)概念 可以在方法，类上添加一个未知的，动态的类型参数，由调用者来确定传入的类型，而非定
C#进阶教程
05-26
C#进阶教程，for people not very experienced.
C#高级（内容齐全）
10-17
C#高级（内容齐全），里面介绍了.net、罗列了c#语法进阶。很好的完善c#知识体系结构的pdf学习文件
C#高级应用
weixin_30408165的博客
04-20 224
　　学习编程也有大半年了，想起老师前天说的：“你们写的代码都是小儿科”，顿时有点心塞。。。想想也是，不可能就写一个For循环或者Foreach循环就可以拿到高薪了？我也觉得不太可能，下面我就来为大家简单介绍一下比较高级一点的应用。 　　一.索引器：当一个类中包含了数组和集合成员时，使用索引器将会大大简化对数组和集合成员的存取操作。 　　　　下面为语法： 1 [修饰符] 数据类型 th...
C#可扩展编程之MEF学习笔记(五)：MEF高级进阶
aa124413278的博客
09-24 484
好久没有写博客了，今天抽空继续写MEF系列的文章。有园友提出这种系列的文章要做个目录，看起来方便，所以就抽空做了一个，放到每篇文章的最后。 前面四篇讲了MEF的基础知识，学完了前四篇，MEF中比较常用的基本已经讲完了，相信大家已经能看出MEF所带来的便利了。今天就介绍一些MEF中一些较为不常用的东西，也就是大家口中的所谓的比较高级的用法。 前面讲的导出都是在每个类上面添加Export...
C#的进阶
KCDCY的博客
01-27 777
C#的进阶 文章目录C#的进阶1. 字符串1.1 常用函数（方法）1.2 字符串的特点2. 字符串3.4.5.6.7. 1. 字符串 1.1 常用函数（方法） （黄色为最重要） 1.ToUpper() 作用：将字符转换成大写形式，仅对字母有效。返回值是转换后的字符串。 使用：字符串变量或常量.ToUpper(); 例如："hh".ToUpper(); 2.ToLower() 作用：将字符转换成小写...
C# 进阶
weixin_43837133的博客
06-09 484
预定义特性 AttributeUsage Conditional Obsolete 自定义特性 声明 构建 应用概念 原理 用途 优缺点 使用get/set访问器 抽象属性this[int index] 用途 重载索引器概念 用途 声明 实例化 委托多播概念 用途 声明 使用 事件与委托的区别ArrayList Hashtable SortedList Stack Queue BitArray特性 泛型类 泛型方法 泛型委托 泛型接口 泛型约束概念 语法 委托与匿名方法 Lambda表达式unsafe 托管
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿阿阿安

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值