数据类型

C# 是一种 强类型语言。这意味着我们必须声明一个变量的类型，该类型指示它将存储的值的类型，例如整数、浮点数、小数点、文本等

下面声明并初始化了不同数据类型的变量

int num = 100;
float rate = 10.2f; // 浮点型要加 f
double a = 10.01d; // 双精度浮点型 加d
decimal amount = 100.50M; //decimal 固定要加m
char code = 'C';
bool isValid = true;
string name = "Steve";
DateTime dateTime = DateTime.Now;

C#主要将数据类型分为两种类型：值类型 和 引用类型。值类型包括简单类型（如 int、float、bool 和 char）、枚举类型、结构类型和 Nullable 值类型。引用类型包括类类型、接口类型、委托类型和数组类型

数据类型概述

值类型

类型	.net 对应的类型	范围	默认值
bool	布尔值	True 或 False	False
char	16 位 Unicode 字符	U +0000 到 U +ffff	'\0'
decimal	128 位精确的十进制值，28-29 有效位数	(-7.9 x 1028 到 7.9 x 1028) / 100 到 28	0.0M
float	32 位单精度浮点型	-3.4 x 1038 到 + 3.4 x 1038	0.0F
double	64 位双精度浮点型	(+/-)5.0 x 10-324 到 (+/-)1.7 x 10308	0.0D
int	2 位有符号整数类型	-2,147,483,648 到 2,147,483,647	0
sbyte	8 位有符号整数类型	-128 到 127	0
short	16 位有符号整数类型	-32,768 到 32,767	0
long	64 位有符号整数类型	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807	0L
byte	8 位无符号整数	0 到 255	0
ushort	16 位无符号整数类型	0 到 65,535	0
uint	32 位无符号整数类型	0 到 4,294,967,295	0
ulong	64 位无符号整数类型	0 到 18,446,744,073,709,551,615	0
DateTime	时间

总结内容如下：

描述	类型
Unicode 字符(16 位)	char
布尔值	bool
有符号整数	sbyte(8 位) < short(16 位) < int(32 位) < long(64 位)
正整数	byte(8 位) < ushort(16 位) < uint(32 位) < ulong(64 位)
浮点数	float(32 位) < double(64 位)
时间	DateTime

变量声明示例：（需要指定类型）

int age = 20;
bool isStudent = true;
float grade = 4.2;

另外，为了扩充变量的范围（加一个 null），可以在声明时加个 ?，我们称其为 可空类型

可空类型表示其基础值类型正常范围内的值，再加上一个 null 值

int age = null; ×（报错）
int? age = null; √（正常）
age = 20; // age 可以被赋值为 -2,147,483,648 到 2,147,483,647 之间的任意值，也可以被赋值为 null
bool? isStudent = null;
isStudent = true; // isStudent 可以被赋值为 true 或 false 或 null

引用类型

引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。

换句话说，它们指的是一个内存位置。使用多个变量时，引用类型可以指向一个内存位置。如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。内置的 引用类型有：object、dynamic 和 string

对象（Object）类型

对象（Object）类型是 C# 通用类型系统（Common Type System - CTS）中所有数据类型的终极基类。Object 是 System.Object 类的别名。所以对象（Object）类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是，在分配值之前，需要先进行类型转换。

当一个值类型转换为对象类型时，则被称为装箱；另一方面，当一个对象类型转换为值类型时，则被称为拆箱。

object obj;
obj = 100; // 这是装箱

动态（Dynamic）类型

您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。

声明动态类型，举例：

dynamic d = 20;

动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时发生的，而动态类型变量的类型检查是在运行时发生的。对象（Object）类型更常用一些。

字符串（String）类型

字符串（String）类型允许您给变量分配任何字符串值。字符串（String）类型是 System.String 类的别名。它是从对象（Object）类型派生的。字符串（String）类型的值可以通过两种形式进行分配："" 和 @""

例如：

string str = "runoob.com";
string text = "This is a \"string\" in C#.";
string lines = "hello\r\n my name is \r\n malema.net";

在一个文本有多行的情况下，我们还可以用 @ 号来定义：

string lines = @"hello 
my name is 
malema.net";

在使用@的时候如果我们还想在字符串里面放到双引号"的话我们会发现这个时候没有办法用转义字符。我们必须得用 ""两个双引号来表示一个双引号

string lines = @"hello
my name is\""
malema.net";

C# string 字符串的前面可以加 @ 则将转义字符（\）当作普通字符对待

存储值的方式

根据它们在内存中存储值的方式进行分类。 C# 数据类型有下面的三种分类：

值类型
引用类型
指针类型

栈和堆

当我们的代码执行时，内存中有两个地方用来存储这些代码。分别是栈和堆。栈和堆都用来帮助我们运行代码的，它们驻留在机器内存中，且包含所有代码执行所需要的信息。

栈是编译期间就 分配好 的内存空间，因此你的代码中必须就栈的大小有明确的定义；堆是程序运行期间动态分配的内存空间，你可以根据程序的运行情况确定要分配的堆内存的大小存放在栈中时要管存储顺序,保持着先进后出的原则，他是一片连续的内存域，有系统自动分配和维护。
而堆是 无序的，他是一片不连续的内存域，有用户自己来控制和释放，如果用户自己不释放的话，当内存达到一定的特定值时，通过 垃圾回收器(GC) 来回收。

值类型的值存储

值类型的数据是 放在栈当中 的。（因为它在定义的时候就可以知道它的具体大小了），（也叫放在自己声明的位置，要结合程序是如何运行的来理解）

引用类型的值存储

与值类型不同，引用类型不直接存储其值。相反，它存储 存储值的地址。换句话说，引用类型包含一个指向保存数据的另一个内存位置的指针（放在堆中）

参数传递的特点

值类型参数值传递的特点

当您将值类型变量从一种方法传递到另一种方法时，系统会在另一种方法中创建变量的副本。如果在一个方法中更改了值，则不会影响另一种方法中的变量。
同一个方法里面把一个变量赋给另一个变量，系统也是创建这个变量的副本

引用类型参数传递的特点

当您将引用类型变量从一种方法传递到另一种方法时，它不会创建新副本；相反，它 传递变量的地址。所以，如果我们在一个方法中改变了一个变量的值，它也会反映在调用方法中。（在同一个方法中也是一样的）。

class Program
{
    static void ChangeReferenceType(Student std2)
    {
        std2.Age = 200;
    }

    static void Main(string[] args)
    {
        Student std1 = new Student();
        std1.Age = 100;
        ChangeReferenceType(std1);
        Console.WriteLine(std1.Age); // 200
        var std2 = std1; // 改的是 std2 的值，但是 std1 的值也变了。
        std2.Age = 300;
        Console.WriteLine(std1.Age); // 300
    }
}

public class Student
{
    public int Age { get; set; }
}

类型判断

隐式类型 var

在c#3.0之后，新增关键字 var 来定义变量

var i = 100;

这个 i 还是强类型的变量。编译器会在 编译的时候 进行类型推断。 i 这个变量会被当作 int 类型

下面的这种定义类型也可以被推断出来

int i = 10;
var j = i + 1; // int 类型

使用 GetType 获取类型进而判断

var obj = "hello";
if (obj.GetType() == typeof(string))
{
    Console.WriteLine("obj is a string");
}

类型转换

C# 提供了下列内置的类型转换方法：

方法	描述
ToBoolean	如果可能的话，把类型转换为布尔型。
ToByte	把类型转换为字节类型。
ToChar	如果可能的话，把类型转换为单个 Unicode 字符类型。
ToDateTime	把类型（整数或字符串类型）转换为日期-时间结构。
ToDecimal	把浮点型或整数类型转换为十进制类型。
ToDouble	把类型转换为双精度浮点型。
ToInt16	把类型转换为 16 位整数类型。
ToInt32	把类型转换为 32 位整数类型。
ToInt64	把类型转换为 64 位整数类型。
ToSbyte	把类型转换为有符号字节类型。
ToSingle	把类型转换为小浮点数类型。
ToString	把类型转换为字符串类型。
ToType	把类型转换为指定类型。
ToUInt16	把类型转换为 16 位无符号整数类型。
ToUInt32	把类型转换为 32 位无符号整数类型。
ToUInt64	把类型转换为 64 位无符号整数类型。

每个类型里面基本上都有一个 Parse 或者 TryParse

举例，字符串转数字：

if (int.TryParse("65", out int age))
{
    // age 是 65
};

变量和常量

变量

定义：

int age = 24;

常量

变量声明前面多了个 const

定义：

const int age = 24;

代码实例：

using System;

public class ConstTest
{
    class SampleClass
    {
        public int x;
        public const int c = 5;
        public SampleClass(int p)
        {
            x = p;
        }
    }

    static void Main()
    {
        SampleClass mC = new SampleClass(11);
        mC.x += 1;
        // SampleClass.c += 1;
        // 报错：赋值号左边必须是变量、属性或索引器
    }
}

结构体 Struct

定义

我们使用 struct 语句定义一个结构体。struct 语句为程序定义了一个带有多个成员的新的数据类型。

例如，可以按照如下的方式声明 Book 结构：

struct Books
{
   public string title;
   public string author;
   public string subject;
   public int book_id;
};

下面的程序演示了结构的用法：

using System;  
using System.Text;  
       
struct Books  
{  
   public string title;  
   public string author;  
   public string subject;  
   public int book_id;  
};    
  
public class testStructure  
{  
   public static void Main(string[] args)  
   {  
  
      Books Book1;        /* 声明 Book1，类型为 Books */  
      Books Book2;        /* 声明 Book2，类型为 Books */  
  
      /* book 1 详述 */  
      Book1.title = "C Programming";  
      Book1.author = "Nuha Ali";  
      Book1.subject = "C Programming Tutorial";  
      Book1.book_id = 6495407;  
  
      /* book 2 详述 */  
      Book2.title = "Telecom Billing";  
      Book2.author = "Zara Ali";  
      Book2.subject =  "Telecom Billing Tutorial";  
      Book2.book_id = 6495700;  
  
      /* 打印 Book1 信息 */  
      Console.WriteLine("Book 1 title : {0}", Book1.title);  
      Console.WriteLine("Book 1 author : {0}", Book1.author);  
      Console.WriteLine("Book 1 subject : {0}", Book1.subject);  
      Console.WriteLine("Book 1 book_id :{0}", Book1.book_id);  
  
      /* 打印 Book2 信息 */  
      Console.WriteLine("Book 2 title : {0}", Book2.title);  
      Console.WriteLine("Book 2 author : {0}", Book2.author);  
      Console.WriteLine("Book 2 subject : {0}", Book2.subject);  
      Console.WriteLine("Book 2 book_id : {0}", Book2.book_id);        
  
      Console.ReadKey();  
  
   }  
}

当上面的代码被编译和执行时，它会产生下列结果：

Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700

特点

结构可带有 方法、字段、索引、属性、运算符方法和事件。
结构可定义构造函数，但不能定义析构函数。但是，您不能为结构定义无参构造函数。无参构造函数(默认)是自动定义的，且不能被改变。
与类不同，结构不能继承其他的结构或类。
结构不能作为其他结构或类的基础结构。
结构可实现一个或多个接口。
结构成员不能指定为 abstract、virtual 或 protected。
当使用 New 操作符创建一个结构对象时，会调用适当的构造函数来创建结构。与类不同，结构 可以不使用 New 操作符 即可被实例化。
如果不使用 New 操作符，只有在所有的字段都被初始化之后，字段才被赋值，对象才被使用。

类和结构体的区别

（类的相关介绍见下面内容）

类是引用类型，结构是值类型
结构 不支持继承
结构不能声明默认的 构造函数

以上实例重写

using System;
using System.Text;
     
struct Books
{
   private string title;
   private string author;
   private string subject;
   private int book_id;
   public void setValues(string t, string a, string s, int id)
   {
      title = t;
      author = a;
      subject = s;
      book_id =id; 
   }
   public void display()
   {
      Console.WriteLine("Title : {0}", title);
      Console.WriteLine("Author : {0}", author);
      Console.WriteLine("Subject : {0}", subject);
      Console.WriteLine("Book_id :{0}", book_id);
   }

};  

public class testStructure
{
   public static void Main(string[] args)
   {

      Books Book1 = new Books(); /* 声明 Book1，类型为 Books */
      Books Book2 = new Books(); /* 声明 Book2，类型为 Books */

      /* book 1 详述 */
      Book1.setValues("C Programming", "Nuha Ali", "C Programming Tutorial",6495407);
      /* book 2 详述 */
      Book2.setValues("Telecom Billing", "Zara Ali", "Telecom Billing Tutorial", 6495700);

      Book1.display();  /* 打印 Book1 信息 */
      Book2.display();  /* 打印 Book2 信息 */

      Console.ReadKey();

   }
}

结构和类的适用场合分析：

当堆栈的空间很有限，且 有大量的逻辑对象 时，创建类要比创建结构好一些；
对于点、矩形和颜色这样的轻量对象，假如要声明一个含有许多个颜色对象的数组，则CLR需要为 每个对象 分配内存，在这种情况下，使用结构的成本较低；
在表现抽象和 多级别 的对象层次时，类是最好的选择，因为结构不支持继承。
大多数情况下，目标类型只是含有一些数据，或者以数据为主。

枚举 Enum

枚举是一组命名整型常量。枚举类型是使用 enum 关键字声明的。

C# 枚举是值类型。换句话说，枚举包含自己的值，且不能继承或传递继承。

声明 enum 变量

声明枚举的一般语法：

enum <enum_name>
{ 
    enumeration list 
};

其中，

enum_name 指定枚举的类型名称。
enumeration list 是一个用逗号分隔的标识符列表。

枚举列表中的每个符号代表一个整数值，一个比它前面的符号大的整数值。默认情况下，第一个枚举符号的值是 0.例如：

enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };

下面的实例演示了枚举变量的用法：

using System;  
  
public class EnumTest  
{  
    enum Day { Sun, Mon, Tue, Wed, Thu, Fri, Sat };  
  
    static void Main()  
    {  
        int x = (int)Day.Sun;  
        int y = (int)Day.Fri;  
        Console.WriteLine("Sun = {0}", x);  
        Console.WriteLine("Fri = {0}", y);  
    }  
}

当上面的代码被编译和执行时，它会产生下列结果：

Sun = 0
Fri = 5

字符串 String

在 C# 中，您可以使用字符数组来表示字符串，但是，更常见的做法是使用 string 关键字来声明一个字符串变量。string 关键字是 System.String 类的别名。

创建 String 对象

您可以使用以下方法之一来创建 string 对象：

通过给 String 变量指定一个字符串
通过使用 String 类构造函数
通过使用字符串串联运算符（ + ）
通过检索属性或调用一个返回字符串的方法
通过格式化方法来转换一个值或对象为它的字符串表示形式

下面的实例演示了这点：

using System;  
  
namespace StringApplication  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
           //字符串，字符串连接  
            string fname, lname;  
            fname = "Rowan";  
            lname = "Atkinson";  
  
            string fullname = fname + lname;  
            Console.WriteLine("Full Name: {0}", fullname);  
  
            //通过使用 string 构造函数  
            char[] letters = { 'H', 'e', 'l', 'l','o' };  
            string greetings = new string(letters);  
            Console.WriteLine("Greetings: {0}", greetings);  
  
            //方法返回字符串  
            string[] sarray = { "Hello", "From", "Tutorials", "Point" };  
            string message = String.Join(" ", sarray);  
            Console.WriteLine("Message: {0}", message);  
  
            //用于转化值的格式化方法  
            DateTime waiting = new DateTime(2012, 10, 10, 17, 58, 1);  
            string chat = String.Format("Message sent at {0:t} on {0:D}",  
            waiting);  
            Console.WriteLine("Message: {0}", chat);  
            Console.ReadKey() ;  
        }  
    }  
}

当上面的代码被编译和执行时，它会产生下列结果：

Full Name: RowanAtkinson
Greetings: Hello
Message: Hello From Tutorials Point
Message: Message sent at 17:58 on Wednesday, 10 October 2012

String 类的属性

String 类有以下两个属性：

属性	描述
Chars	在当前 String 对象中获取 Char 对象的指定位置
Length	在当前的 String 对象中获取字符串长度

String 类的方法

String 类有许多方法用于 string 对象的操作。下面的表格提供了一些最常用的方法：

方法及入参	返回值类型	描述
Compare( string strA, string strB )	int	比较两个指定的 string 对象，并返回一个表示它们在排列顺序中相对位置的整数。该方法区分大小写。
Compare( string strA, string strB, bool ignoreCase )	int	比较两个指定的 string 对象，并返回一个表示它们在排列顺序中相对位置的整数。但是，如果布尔参数为真时，该方法不区分大小写
Concat( string str0, string str1, ... )	string	连接多个 string 对象
Contains( string value )	bool	判断是否包含指定 string
Copy( string str )	string	创建一个与指定字符串具有相同值的新的 String 对象
CopyTo( int sourceIndex, char[] destination, int destinationIndex, int count )	void	从 string 对象的指定位置开始复制指定数量的字符到 Unicode 字符数组中的指定位置
EndsWith( string value )	bool	判断 string 对象的结尾是否匹配指定的字符串
Equals( string value )	bool	判断当前的 string 对象是否与指定的 string 对象具有相同的值
Equals( string a, string b )	bool	判断两个指定的 string 对象是否具有相同的值
Format( string format, Object arg0 )	string	把指定字符串中一个或多个格式项替换为指定对象的字符串表示形式
IndexOf( char / string value, int startIndex )	int	返回【指定 Unicode 字符 / 指定字符串】从该字符串中从 startIndex（不填则为 0）开始搜索第一次出现的索引，索引从 0 开始
IndexOfAny( char[] anyOf, int startIndex )	int	返回某一个指定的 Unicode 字符数组中任意字符从该实例中从 startIndex（不填则为 0）开始搜索第一次出现的索引，索引从 0 开始
Insert( int startIndex, string value )	string	返回一个新的字符串，其中，指定的字符串被插入在当前 string 对象的指定索引位置
IsNullOrEmpty( string value )	bool	指示指定的字符串是否为 null 或者是否为一个空的字符串
Join( string separator, string[] value )	string	连接一个字符串数组中的所有元素，使用指定的分隔符分隔每个元素
Join( string separator, string[] value, int startIndex, int count )	string	连接一个字符串数组中的指定位置开始的指定元素，使用指定的分隔符分隔每个元素
LastIndexOf( char / string value )	int	返回【指定 Unicode 字符 / 指定字符串】在当前 string 对象中最后一次出现的索引位置，索引从 0 开始
Remove( int startIndex, int count )	string	从当前字符串的指定位置开始移除 count（不填则表示到最后一个位置为止）数量的字符，并返回字符串
Replace( char / string oldValue, char / string newValue )	string	把当前 string 对象中，所有指定的 Unicode 字符 / 字符串替换为另一个指定的 Unicode 字符 / 字符串，并返回新的字符串
Split( char[] separator, int count )	string[]	返回一个字符串数组，包含当前的 string 对象中的子字符串，子字符串是使用指定的 Unicode 字符数组中的元素进行分隔的。count 参数指定要返回的子字符串的最大数目（不填则为全部）
StartsWith( string value )	bool	判断字符串实例的开头是否匹配指定的字符串
ToCharArray()	char[]	返回一个带有当前 string 对象中所有字符的 Unicode 字符数组
ToCharArray( int startIndex, int length )	char[]	返回一个带有当前 string 对象中所有字符的 Unicode 字符数组，从指定的索引开始，直到指定的长度为止
ToLower()	string	把字符串转换为小写并返回
ToUpper()	string	把字符串转换为大写并返回
Trim()	string	移除当前 String 对象中的所有前导空白字符和后置空白字符

下面的实例演示了上面提到的一些方法：

比较字符串

using System;  

namespace StringApplication  
{  
   class StringProg  
   {  
      static void Main(string[] args)  
      {  
         string str1 = "This is test";  
         string str2 = "This is text";  
  
         if (String.Compare(str1, str2) == 0)  
         {  
            Console.WriteLine(str1 + " and " + str2 +  " are equal.");  
         }  
         else  
         {  
            Console.WriteLine(str1 + " and " + str2 + " are not equal.");  
         }  
         Console.ReadKey() ;  
      }  
   }  
}

输出：

This is test and This is text are not equal.

字符串包含字符串：

using System;  
  
namespace StringApplication  
{  
   class StringProg  
   {  
      static void Main(string[] args)  
      {  
         string str = "This is test";  
         if (str.Contains("test"))  
         {  
            Console.WriteLine("The sequence 'test' was found.");  
         }  
         Console.ReadKey() ;  
      }  
   }  
}

输出：

The sequence 'test' was found.

获取子字符串：

using System;  
namespace StringApplication  
{  
    class StringProg  
    {  
        static void Main(string[] args)  
            {  
                string str = "Last night I dreamt of San Pedro";  
                Console.WriteLine(str);  
                string substr = str.Substring(23);  
                Console.WriteLine(substr);  
                Console.ReadKey() ;  
            }  
    }  
}

输出：

Last night I dreamt of San Pedro
San Pedro

连接字符串：

using System;  
  
namespace StringApplication  
{  
   class StringProg  
   {  
      static void Main(string[] args)  
      {  
         string[] starray = new string[]{"Down the way nights are dark",  
         "And the sun shines daily on the mountain top",  
         "I took a trip on a sailing ship",  
         "And when I reached Jamaica",  
         "I made a stop"};  
  
         string str = String.Join("\n", starray);  
         Console.WriteLine(str);  
         Console.ReadKey() ;  
      }  
   }  
}

输出：

Down the way nights are dark
And the sun shines daily on the mountain top
I took a trip on a sailing ship
And when I reached Jamaica
I made a stop

数组 Array

C语言规定数组长度在编译时必须有明确的值，即必须在数组定义时 指定数组的长度，且一旦数组被创建，其长度就 不能再改变。（可以改变数组长度的参考 C# 进阶知识 -- ArrayList、List）

声明

在 C# 中声明一个数组，您可以使用下面的语法：

datatype[] arrayName;

其中，

datatype 用于指定被存储在数组中的元素的类型。
[ ] 指定数组的秩（维度）。秩指定数组的大小。
arrayName 指定数组的名称。

初始化、赋值

使用 new 关键字来创建数组的实例

例如：

int [] marks = new int[5]

没有给数组赋值，元素则为各类型对应的默认值

您可以在声明数组的同时给数组赋值，比如：

double[] balance = { 2340.0, 4523.69, 3421.0 };

您也可以创建并初始化一个数组，比如：

int [] marks = new int[5]  { 99, 98, 92, 97, 95 };

Array 类的属性

Array 类是 C# 中所有数组的基类，它是在 System 命名空间中定义。Array 类提供了各种用于数组的属性和方法。

下表列出了 Array 类中一些最常用的属性：

属性	描述
IsFixedSize	获取一个值，该值指示数组是否带有固定大小。
IsReadOnly	获取一个值，该值指示数组是否只读。
Length	获取一个 32 位整数，该值表示所有维度的数组中的元素总数。
LongLength	获取一个 64 位整数，该值表示所有维度的数组中的元素总数。
Rank	获取数组的秩（维度）。

Array 类的方法

下表列出了 Array 类中一些最常用的方法：

方法	描述
Clear	根据元素的类型，设置数组中某个范围的元素为默认值
GetLength	获取指定维度的数组中的元素总数
GetValue(Int)	获取一维数组中指定位置的值。
SetValue(Object, Int)	给一维数组中指定位置的元素设置值。索引由第 2 个参数指定。
GetLowerBound	获取数组中指定维度的下界
GetUpperBound	获取数组中指定维度的上界
Copy(Array1, Array2, Int)	从数组的第一个元素开始复制某个范围的元素到另一个数组的第一个元素位置。长度由第 3 个参数指定
CopyTo(Array, Int)	从当前的一维数组中复制所有的元素到一个指定的一维数组的指定索引位置。索引由第 3 个参数指定
IndexOf(Array, Object)	搜索指定的对象，返回整个一维数组中第一次出现的索引
Reverse(Array)	逆转整个一维数组中元素的顺序。
Sort(Array)	使用数组的每个元素的 IComparable 实现来排序整个一维数组中的元素。
GetType	获取当前实例的类型，从对象（Object）继承
ToString	返回一个表示当前对象的字符串。从对象（Object）继承。

如需了解 Array 类的完整的方法列表，请参阅微软的 C# 文档。

下面的程序演示了 Array 类的一些方法的用法：

using System;  
namespace ArrayApplication  
{  
    class MyArray  
    {  
         
        static void Main(string[] args)  
        {  
            int[] list = { 34, 72, 13, 44, 25, 30, 10 };  
  
            Console.Write("原始数组： ");  
            foreach (int i in list)  
            {  
                Console.Write(i + " ");  
            }  
            Console.WriteLine();  
             
            // 逆转数组  
            Array.Reverse(list);  
            Console.Write("逆转数组： ");  
            foreach (int i in list)  
            {  
                Console.Write(i + " ");  
            }  
            Console.WriteLine();  
             
            // 排序数组  
            Array.Sort(list);  
            Console.Write("排序数组： ");  
            foreach (int i in list)  
            {  
                Console.Write(i + " ");  
            }  
            Console.WriteLine();  
  
           Console.ReadKey();  
        }  
    }  
}

当上面的代码被编译和执行时，它会产生下列结果：

原始数组： 34 72 13 44 25 30 10

逆转数组： 10 30 25 44 13 72 34

排序数组： 10 13 25 30 34 44 72

C# 系列 -- 数据类型

数据类型

数据类型概述

值类型

引用类型

对象（Object）类型

动态（Dynamic）类型

字符串（String）类型

存储值的方式

栈和堆

值类型的值存储

引用类型的值存储

参数传递的特点

值类型 参数值传递的特点

引用类型 参数传递的特点

类型判断

隐式类型 var

使用 GetType 获取类型进而判断

类型转换

变量和常量

变量

常量

结构体 Struct

定义

特点

类和结构体的区别

枚举 Enum

声明 enum 变量

字符串 String

创建 String 对象

String 类的属性

String 类的方法

数组 Array

声明

初始化、赋值

Array 类的属性

Array 类的方法

值类型参数值传递的特点

引用类型参数传递的特点