正文

轻松学习C#的方法

︶ㄣ米米素材网 メ
米米素材网V管理员 / 阅读
0708

轻松学习C#的方法，对C#的方法感兴趣的朋友可以参考本篇文章，帮助大家更灵活的运用C#的方法。

       在类中自定义的“函数”称为“方法”，由于C#是完全面向对象的语言，同时为了便于解释后面要学的C#类，这里的“方法”来称呼“函数”。
       方法是一种用于实现可以有对象或类执行的计算机或操作的成员，是一个已命名的语句集。每个方法都有一个名称和主体。方法名应该是一个有意义的标识符，应描述出方法的用途。方法主体包含了调用方法时实际执行的语句。用户可以为大多数方法提供一些数据来进行处理，并让其返回一些信息(通常是处理结果)。方法是一种基本的，功能强大的编程机制。
       方法的声明格式为：
       修饰符  返回值类型  方法名称(参数列表)
        {
                 方法体
        }
       其中的修饰符和参数列表都是可选的，修饰符如下：new，public，protected，internal，private，static，virtual，sealed，override，abstract，extern，partial
       如果以下所有条件都为真，则所述的声明就具有一个有效的修饰符组合：
       (1)该声明包含一个由访问修饰符组成的有效组合
       (2)该声明中所含的修饰符没有彼此相同的
       (3)该声明最多包含下列修饰符中的一个：static，virtual和override
       (4)该声明最多包含下列修饰符中的一个：new和override
       (5)如果声明中包含abstract修饰符，则该声明不包含下列任何修饰符：static，virtual，sealed或extern
       (6)如果声明中包含private修饰符，则该声明不包含下列任何修饰符：virtual，override或abstract
       (7)如果声明包含sealed修饰符，则该声明还包含override修饰符
       (8)如果声明中包含partial修饰符，则该声明不包含下列任一修饰符：new，public，protected，internal，private，static，virtual，sealed，override，abstract，extern
        返回值类型是一个类型名，它指定了返回的信息是什么类型。这可以是任何类型，如果要返回值，则在方法体运行后必须由return语句返回一个和“返回值类型”相同类型的值，如果要写一个不返回值的方法，那么必须用关键字void来取代返回类型。如果声明包含partial修饰符，则返回类型必须为void。
        一个方法的名称必须不同于在一个类中声明的所有其他非方法的名称。此外，必须不同于在同一类中声明的所有其他方法的签名。在写参数列表时，所有形参和类型形参都不能同名。
        下面编写一个简单的返回两个整型数的和的方法：      

?
1
2
3
4
public int add(int a, int b)
    {
        return a+b;
    }

下面就具体介绍C#语言中的一些重要的基础的方法：
一、静态方法和实例方法
      静态方法是一个特殊的成员方法，不属于类的某一个具体的实例或对象，而属于类本身。静态方法不对特定实例进行操作，只能访问类中的静态成员。访问静态方法只能使用类名，而不需要创建对象，也不能使用对象名类引用，声明静态方法修饰符中必须有static关键字。
       实例方法可以使用类的任何成员。调用实例方法时，必须使用类的实例或对象来引用。实例方法对类的某个给定的实例进行操作，在实例方法类中可以使用this来访问实例。调用实例方法时，必须先创建一个对象。
       简单的说，静态方法只能访问静态成员，实例方法可以访问静态和实例成员。之所以不允许静态方法访问实例成员变量，是因为实例成员变量是属于某个对象的，而静态方法在执行时，并不一定存在对象。同样，因为实例方法可以访问实例成员变量，如果允许静态方法调用实例方法，将间接地允许静态方法使用实例成员变量，这是错误的。基于同样的道理，静态方法中不能使用关键字this。
例一、编程使用静态方法和实例方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<span style="font-size:18px;">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Text
{
  class A
  {
    int exaVar;//创建的一个为实例成员变量
    static int stVar;//创建的一个静态成员变量
    void tM()//实例方法
    {
      exaVar = 1;//等价于this.exVar=1
      stVar = 1;//等价于A.stVar=1
    }
     static void sM()//静态方法
    {
      //exaVar = 1;//错误，静态方法不可以调用实例成员变量
      stVar = 1;//等价于A.stVar=1
    }
    static void Main(string[] args)
    {
      A text = new A();//创建类A的对象为text
      text.exaVar = 1;//对象text访问实例成员变量
      A.stVar = 1;//只能使用类访问静态成员变量
      //text.stVar = 1;//不能使用对象text访问静态成员变量
      text.tM();//使用对象text访问实例成员方法
      //text.sM();//不能使用对象text访问静态成员方法
      A.sM();//使用类访问静态成员方法
      Console.WriteLine(text.exaVar + A.stVar);
      Console.ReadLine();
    }
  }
}</span>

输出的结果为：2
二、虚方法和非虚方法
       若一个实例方法的声明中含有virtual修饰符，则称该方法为虚方法。若其中没有virtual修饰符，则称该方法为非虚方法。
       非虚方法的实现是一成不变的，无论该方法是在声明它的类的实例上调用还是在派生类的实例上调用，实现均相同。与此相反，虚方法的实现可以由派生类取代。取代所继承的虚方法的实现的过程称为重写该方法。在虚方法调用中，该调用所涉及的那个实例运行时类型确定了要被调用的究竟是该方法的哪一种实现。在非虚方法调用中，相关的实例的编译时类型是决定性因素。
例二、使用虚方法和非虚方法在派生类中调用

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
<span style="font-size:18px;">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Text
{
  public class A
  {
    public virtual void ab()//定义的类A的虚方法    </span>
[csharp] view plaincopyprint?
<span style="font-size:18px;">    {
      Console.WriteLine("这是虚方法");
    }
    public void ac()//定义的类A的非虚方法
    {
      Console.WriteLine("这是非虚方法");
    }
  }
  public class B:A//类B私有继承类A
  {
    public override void ab()//重写继承的ab方法
</span>    <span style="font-size:18px;"> {
      Console.WriteLine("这是新的方法");
    }
    public new void ac()//创建一个新的方法覆盖原来的ac方法
    {
      Console.WriteLine("这是另一个新的方法");
    }
  }
  class Program
  {
    static void Main(string[] args)
    {
      B b = new B();//创建类B的对象b
      A a = b;//将对象b赋值给类A的对象a
      a.ab();//调用原ab虚方法
      b.ab();//调用ab方法
      a.ac();//调用原ac非虚方法
      b.ac();//调用ac方法
      Console.ReadLine();
    }
  }
}</span>

输出的结果为：

 轻松学习C#的方法

       从输出的结果中可以看出虚方法的实现是由派生类取代并且由它的方法实现，而非虚方法的实现是定义的类和派生类的各自由它们的方法实现。
三、虚方法和重写方法
       重写方法用相同的签名重写所继承的虚方法。虚方法声明用于引入新方法，而重写方法声明则用于使现有的继承虚方法专用化。用override声明所重写的那个方法称为已重写了的基方法。
        重写声明和已重写了的基方法具有相同的声明可访问性。换句话说，重写声明不能更改所对应的 虚方法的可访问性。但是，如果已重写的基方法是protected，并且声明它的程序集不是包含重写方法的程序集，则重写方法声明的可访问性必须是protected。
        重写override一般用于接口的实现和继承类的方法改写时应注意：
        (1)覆盖的方法的标志要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果
        (2)覆盖的方法的返回值必须和被覆盖的方法的返回值一致
        (3)覆盖的方法所抛出的异常必须和被覆盖的方法所抛出的异常一致，或者是其子类
        (4)被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖
例三、创建一个虚方法并重写这个虚方法，通过调用两个方法比较结果

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<span style="font-size:18px;">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Text
{
  class A
  {
    public virtual void a()//创建的虚方法
    {
      Console.WriteLine("这是虚方法");
    }
  }
  class B : A
  {
    public override void a()
    {
      Console.WriteLine("这是重写后的方法");
</span>    }
  }
  <span style="font-size:18px;">class Program
  {
    static void Main(string[] args)
    {
      B b1 = new B();//创建类B的对象b1
      b1.a();//调用重写后的a方法
      A a1 = new A();//创建类A的对象a1
      a1.a();//调用虚方法a
      A a2 = b1;//将类B的对象b1赋值给类A的对象a2
      a2.a();//调用虚方法a
      Console.ReadLine();
    }
  }
}
</span>

输出的结果为：这是重写后的方法
                       这是虚方法
                       这是重写后的方法
四、外部方法(这个方法很新奇，联想到很多)
        当方法声明包含extern修饰符时，称该方法为外部方法。外部方法是在外部实现的，编程语言通常是使用C#以外的语言。外部方法不可以是泛型。
        extern修饰符通常与DllImport属性一起使用，从而使外部方法可以由DLL(动态链接库)实现。执行环境可以支持其他用来提供外部方法实现的机制。当外部方法包含DllImport属性时，该方法声明必须同时包含一个static修饰符。
        在使用DLLImport属性时，一定要引入System.Runtime.InteropServices命名空间，此命名空间是提供各种各样支持COM interop及平台调用服务的成员。
例四、通过外部方法和Dlllmport属性调用“User32.dll”实例自定义信息提示框的功能

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<span style="font-size:18px;">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.InteropServices;//必须引入的命名空间
namespace Text
{
  class Program
  {
    [DllImport("User32.dll")]//调用User32.dll
    public static extern int MessageBox(int H, string m, string c, int type);//定义的外部方法
    static int Main(string[] args)
    {
      Console.Write("请输入信息：");
      string str = Console.ReadLine();//接受输入的信息
      return MessageBox(0,str,"我的信息提示框",0);//以信息提示框输出
    }
  }
}</span>

输出的结果为：

 轻松学习C#的方法

五、分部方法
        若一个方法声明中含有partial修饰符，则称该方法为分部方法。只能讲分部方法声明为分部类型的成员，而且要遵守约束数目。分部方法有着严格的限制。分部方法必须在分部类或分部机构内声明。它们必须是私有的，不能返回值，不能有输出参数。因为任何针对没有被实现的分部方法的调用都会简单地被忽略，所以说这些限制是非常有必要的。
        分部方法不能作为一个明确分配的变量，仅被代码生成器在处理轻量级事件的时候使用。假设用户解析一个数据库或者一个XML文件，然后生成了数据类，结果会发现有数十个类，几百个属性以及一大堆泛型和模板文件等。分部方法另外一个经常被用到的地方是验证，或者让属性的setter去更新另一个属性。所以如果用户要使用产生的代码，或者在运行时有几百个事件和千个方法调用的话(其实大多数情况下只用到了其中的一点点)，就可以选择分部方法。分部方法在声明和使用时要比事件容易得多，如果没有用到它们，它们就会消失。从分部方法必须是私有的限制中，
Alexander发现了该方法的不足之处，即如果用户喜欢原数据驱动的应用，并且已经被ASP.NET的数据绑定所困扰时(因为没有其他的方法可以附上原数据)，那么，将来会出现丢失信息的可能。
例五、创建一个类的分部方法并且在另一个部分中引用

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
<span style="font-size:18px;">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Text
{
  public partial class Program//定义的分部类
  {
    private int _setup;//定义的字段
    public int setup//定义的方法
    {
      set
      {
        _setup=value;
      }
      get
      {
        return _setup;
      }
    }
    partial void text(int t);//声明分部方法
    partial void text(int t)//实现声明
    {
      t += _setup;
      Console.Write(t);
    }
 
  }
  partial class Program
  {
    static void Main(string[] args)
    {
      Program pg = new Program();//创建类对象
      pg._setup = 100;//设置属性
      pg.text(50);//调用方法
      Console.ReadLine();
    }
  }
}</span>

输出的结果为：150

以上就是关于C#的方法五个例题分析，希望对大家的学习有所帮助。