C#数据类型(详细)

原创 2024-03-27 10:08:32 5.2k 阅读 AI写同款

Seike_113

270粉丝24篇原创

关注

Sql Server 数据类型与 C# 数据类型对照 Sql Server 数据类型与 C# 数据类型对照已验证类型（Sql Server 2012 & Visual Studio 2013） Sql Server C# 简写 bigint System.Int64 long tinyint System.Byte byte binary(50) System.Byte[] byte[] image 阅读详情

AI摘要

本文详细介绍了C#的数据类型，包括值类型、引用类型和指针类型。阐述了各类数据类型的特点、存储方式、复制行为及方法参数传递的区别。还介绍了类、接口、委托等概念，如类和结构的不同点、接口的特点及委托的用途等，为C#开发提供了全面的知识参考。

数据类型分类：

值类型（Value types）
引用类型（Reference types）
指针类型（Pointer types）

值类型（Value types）

---变量可以直接分配值。

值类型直接包含数据。比如 int、char、float，它们分别存储数字、字符、浮点数。当您声明一个 int 类型时，系统分配内存来存储值。

下表列出了 C# 可用的值类型：

如需得到一个类型或一个变量在特定平台上的准确尺寸，可以使用 sizeof 方法。

表达式 sizeof(type) 产生以字节为单位存储对象或类型的存储尺寸。

using System;

namespace DataTypeApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         Console.WriteLine("Size of int: {0}", sizeof(int));
         Console.ReadLine();
      }
   }
}

引用类型（Reference types）

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

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

对象（Object）类型

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

⚠但是，在分配值之前，需要先进行类型转换。

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

int val = 8;
object obj = val;//整型数据转换为了对象类型（装箱）
int nval = （int）obj;//由值类型转换而来的对象类型再转回值类型（拆箱）

动态（Dynamic）类型

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

声明动态类型的语法：

dynamic <variable_name> = value;

dynamic d = 20;

⚠动态类型与对象类型相似：

对象类型变量的类型检查是在编译时发生的

动态类型变量的类型检查是在运行时发生的

字符串（String）类型

允许您给变量分配任何字符串值。它是从对象（Object）类型派生的。

字符串（String）类型的值可以通过两种形式进行分配：引号和 @引号0。

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

创建 String 对象

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

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

1 Chars
在当前 String 对象中获取 Char 对象的指定位置。
2 Length
在当前的 String 对象中获取字符数。

C# string.Format格式化日期

DateTime dt = new DateTime(2017,4,1,13,16,32,108);
string.Format("{0:y yy yyy yyyy}",dt); //17 17 2017 2017
string.Format("{0:M MM MMM MMMM}", dt);//4  04 四月 四月
string.Format("{0:d dd ddd dddd}", dt);//1  01 周六 星期六
string.Format("{0:t tt}", dt);//下 下午
string.Format("{0:H HH}", dt);//13 13
string.Format("{0:h hh}", dt);//1  01
string.Format("{0:m mm}", dt);//16 16
string.Format("{0:s ss}", dt);//32 32
string.Format("{0:F FF FFF FFFF FFFFF FFFFFF FFFFFFF}", dt);//1 1  108 108  108   108    108
string.Format("{0:f ff fff ffff fffff ffffff fffffff}", dt);//1 10 108 1080 10800 108000 1080000
string.Format("{0:z zz zzz}", dt);//+8 +08 +08:00

string.Format("{0:yyyy/MM/dd HH:mm:ss.fff}",dt);　　//2017/04/01 13:16:32.108
string.Format("{0:yyyy/MM/dd dddd}", dt);　　　　　　//2017/04/01 星期六
string.Format("{0:yyyy/MM/dd dddd tt hh:mm}", dt); //2017/04/01 星期六 下午 01:16
string.Format("{0:yyyyMMdd}", dt);　　　　　　　　　//20170401
string.Format("{0:yyyy-MM-dd HH:mm:ss.fff}", dt);　//2017-04-01 13:16:32.108

ps:除去string.Format()可以对日期进行格式化之外，*.ToString()也可以实现相同的效果：

DateTime dt = new DateTime(2017,4,1,13,16,32,108);
dt.ToString("y yy yyy yyyy");//17 17 2017 2017
dt.ToString("M MM MMM MMMM");//4  04 四月 四月
dt.ToString("d dd ddd dddd");//1  01 周六 星期六
dt.ToString("t tt");//下 下午
dt.ToString("H HH");//13 13
dt.ToString("h hh");//1  01
dt.ToString("m mm");//16 16
dt.ToString("s ss");//32 32
dt.ToString("F FF FFF FFFF FFFFF FFFFFF FFFFFFF");//1 1  108 108  108   108    108
dt.ToString("f ff fff ffff fffff ffffff fffffff");//1 10 108 1080 10800 108000 1080000
dt.ToString("z zz zzz");//+8 +08 +08:00

dt.ToString("yyyy/MM/dd HH:mm:ss.fff");　//2017/04/01 13:16:32.108
dt.ToString("yyyy/MM/dd dddd");　　　　　　//2017/04/01 星期六
dt.ToString("yyyy/MM/dd dddd tt hh:mm"); //2017/04/01 星期六 下午 01:16
dt.ToString("yyyyMMdd");　　　　　　　　　//20170401
dt.ToString("yyyy-MM-dd HH:mm:ss.fff");　//2017-04-01 13:16:32.108

用户自定义引用类型有：class、interface 或 delegate

类（Class）

当你定义一个类时，你定义了一个数据类型的蓝图。这实际上并没有定义任何的数据，但它定义了类的名称意味着什么，也就是说，类的对象由什么组成及在这个对象上可执行什么操作。对象是类的实例。构成类的方法和变量称为类的成员。

定义：类的定义是以关键字 class 开始，后跟类的名称。类的主体，包含在一对花括号内。

下面是类定义的一般形式：

<access specifier> class  class_name 
{
    // member variables
    <access specifier> <data type> variable1;
    <access specifier> <data type> variable2;
    ...
    <access specifier> <data type> variableN;
    // member methods
    <access specifier> <return type> method1(parameter_list) 
    {
        // method body 
    }
    <access specifier> <return type> method2(parameter_list) 
    {
        // method body 
    }
    ...
    <access specifier> <return type> methodN(parameter_list) 
    {
        // method body 
    }
}

注意：

访问标识符 <access specifier> 指定了对类及其成员的访问规则。如果没有指定，则使用默认的访问标识符。类的默认访问标识符是 internal，成员的默认访问标识符是 private。

数据类型 <data type> 指定了变量的类型，返回类型 <return type> 指定了返回的方法返回的数据类型。

如果要访问类的成员，你要使用点（.）运算符。

点运算符链接了对象的名称和成员的名称。

实例：

using System;
namespace BoxApplication
{
    class Box
    {
       public double length;   // 长度
       public double breadth;  // 宽度
       public double height;   // 高度
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();        // 声明 Box1，类型为 Box
            Box Box2 = new Box();        // 声明 Box2，类型为 Box
            double volume = 0.0;         // 体积

            // Box1 详述
            Box1.height = 5.0;
            Box1.length = 6.0;
            Box1.breadth = 7.0;

            // Box2 详述
            Box2.height = 10.0;
            Box2.length = 12.0;
            Box2.breadth = 13.0;
           
            // Box1 的体积
            volume = Box1.height * Box1.length * Box1.breadth;
            Console.WriteLine("Box1 的体积： {0}",  volume);

            // Box2 的体积
            volume = Box2.height * Box2.length * Box2.breadth;
            Console.WriteLine("Box2 的体积： {0}", volume);
            Console.ReadKey();
        }
    }
}

类和结构有以下几个基本的不同点：

类型：

结构是值类型（Value Type）： 结构是值类型，它们在栈上分配内存，而不是在堆上。当将结构实例传递给方法或赋值给另一个变量时，将复制整个结构的内容。
类是引用类型（Reference Type）： 类是引用类型，它们在堆上分配内存，栈中保存的只是引用。当将类实例传递给方法或赋值给另一个变量时，实际上是传递引用（内存地址）而不是整个对象的副本。
继承：

结构不能继承： 结构不能继承其他结构或类，也不能作为其他结构或类的基类。
类支持继承： 类支持单继承，一个类可以继承另一个类的成员，并且可以实现多个接口
默认构造函数：

结构不能有无参数的构造函数： 结构不能包含无参数的构造函数。每个结构都必须有至少一个有参数的构造函数。
类可以有无参数的构造函数： 类可以包含无参数的构造函数，如果没有提供构造函数，系统会提供默认的无参数构造函数。
可空性：

结构可以是可空的： 结构可以被声明为可空，即可以赋予 null 值。
类默认可为null： 类的实例默认可以为 null，因为它们是引用类型。
性能和内存分配：

结构通常更轻量： 由于结构是值类型且在栈上分配内存(存储在栈中)，栈空间小，访问速度相对更快。它们通常比类更轻量，故而，当我们描述一个轻量级对象的时候，结构可提高效率，成本更低。适用于简单的数据表示。
类可能有更多开销： 由于类是引用类型，可能涉及更多的内存开销和管理。类的对象是存储在堆空间中，堆空间大，但访问速度较慢，假如我们在传值的时候希望传递的是对象的引用地址而不是对象的拷贝，就应该使用类了。另外，当堆栈的空间很有限，且有大量的逻辑对象时，创建类要比创建结构好一些；

1、结构体中声明的字段无法赋予初值，类可以:

结构体定义：是值类型数据结构。它使得一个单一变量可以存储各种数据类型的相关数据。
struct 关键字用于创建结构体。结构体是用来代表一个记录

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();

   }
}

----------------错误案例--------------------------
struct test001
{
    private int aa = 1;
}

执行以上代码将出现“结构中不能实例属性或字段初始值设定”的报错，而类中无此限制，代码如下：

class test002
{
    private int aa = 1;
}

2、结构体的构造函数中，必须为结构体所有字段赋值，类的构造函数无此限制:

接口（Interface）

定义接口: MyInterface.cs

定义：指定一组函数成员而不实现成员的引用类型，其它类型和接口可以继承接口。

接口使用 interface 关键字声明，它与类的声明类似。接口声明默认是 public 的。下面是一个接口声明的实例：
interface IMyInterface
{
    void MethodToImplement();
}
以上代码定义了接口 IMyInterface。通常接口命令以 I 字母开头，这个接口只有一个方法 MethodToImplement()，没有参数和返回值，当然我们可以按照需求设置参数和返回值。

接口继承: InterfaceInheritance.cs

以下实例定义了两个接口 IMyInterface 和 IParentInterface。

如果一个接口继承其他接口，那么实现类或结构就需要实现所有接口的成员。

以下实例 IMyInterface 继承了 IParentInterface 接口，因此接口实现类必须实现 MethodToImplement() 和 ParentInterfaceMethod() 方法：

using System;

interface IParentInterface
{
    void ParentInterfaceMethod();
}

interface IMyInterface : IParentInterface
{
    void MethodToImplement();
}

class InterfaceImplementer : IMyInterface
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
        iImp.ParentInterfaceMethod();
    }

    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }

    public void ParentInterfaceMethod()
    {
        Console.WriteLine("ParentInterfaceMethod() called.");
    }
}

接口的特点

(1)通过接口可以实现多重继承，C# 接口的成员不能有 public、protected、internal、private 等修饰符。原因很简单，接口里面的方法都需要由外面接口实现去实现方法体，那么其修饰符必然是 public。C# 接口中的成员默认是 public 的，java 中是可以加 public 的。
(2)接口成员不能有 new、static、abstract、override、virtual 修饰符。有一点要注意，当一个接口实现一个接口，这2个接口中有相同的方法时，可用 new 关键字隐藏父接口中的方法。
(3)接口中只包含成员的签名，接口没有构造函数，所以不能直接使用 new 对接口进行实例化。接口中只能包含方法、属性、事件和索引的组合。接口一旦被实现，实现类必须实现接口中的所有成员，除非实现类本身是抽象类。
(4)C# 是单继承，接口是解决 C# 里面类可以同时继承多个基类的问题。
(5)接口内可以定义属性（有get和set的方法）。如string color { get ; set ; }这种。
(6)实现接口时，必须和接口的格式一致。
(7)必须实现接口的所有方法。

委托（Delegate）

C# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。

委托（Delegate） 是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。

委托（Delegate）特别用于实现事件和回调方法

声明委托

委托声明决定了可由该委托引用的方法。委托可指向一个与其具有相同标签的方法。

声明委托的语法如下：

delegate <return type> <delegate-name> <parameter list>

实例化委托（Delegate）

一旦声明了委托类型，委托对象必须使用 new 关键字来创建，且与一个特定的方法有关。当创建委托时，传递到 new 语句的参数就像方法调用一样书写，但是不带有参数。例如：

public delegate void printString(string s);
...
printString ps1 = new printString(WriteToScreen);
printString ps2 = new printString(WriteToFile);

委托的多播（Multicasting of a Delegate）

委托对象可使用 "+" 运算符进行合并。一个合并委托调用它所合并的两个委托。只有相同类型的委托可被合并。"-" 运算符可用于从合并的委托中移除组件委托。

使用委托的这个有用的特点，您可以创建一个委托被调用时要调用的方法的调用列表。这被称为委托的多播，也叫组播。

委托的用途

委托可用于引用带有一个字符串作为输入的方法，并不返回任何东西。

值类型，引用类型的区别：

存储方式:

值类型:值类型的变量直接存储数据的实际值。它们通常存储在栈(Stack)中，且内存分配和释放是自动完成的。每个值类型的变量都具有自己的内存空间，互相独立。
引用类型:引用类型的变量存储的是对象的引用(内存地址)。对象本身存储在堆(Heap)中，而变量只是引用它们的地址。多个引用类型的变量可以指向同一个对象，它们共享同一块内存空问。
复制行为:

值类型:当一个值类型的变量被赋值给另一个变量，实际上是将该值的副本复制给了新变量。因此，修改一个变量不会影响到其他变量，它们互相独立。(纸张的复印，修改复印件不会影响本件)
引用类型:当一个引用类型的变量被赋值给另一个变量，实际上是将对象的引用复制给了新变量。因此，两个变量引用同一个对象，修改其中一个变量会影响到另一个变量，它们共享同一块内存空间。(同一个云盘资源，使用不同链接分享给不同的人时，大家看到的资源是同一个资源，如果这个资源被修改了，大家看到的都变化了)
方法参数传递:

值类型:当将值类型的变量作为方法的参数进行传递时，实际上是将值的副本传递给了方法。在方法内部对参数的修改不会影响到原始变量。
引用类型:当将引用类型的变量作为方法的参数进行传递时，实际上是将对象的引用传递给了方法。在方法内部对参数引用的对象进行的修改会影响到原始变量。
在实际应用中，选择值类型还是引用类型取决于数据的特性和需求。

值类型适用于较小的简单数据，具有快速的访问和复制特性。

引用类型适用于复杂的对象、大型数据集合和需要共享数据的场景，但需要更多的内存开销和额外的访问层级。

指针类型（Pointer types）

指针是一种特殊的类型，既非值类型又非引用类型。

C#为了类型安全，默认并不支持指针。

但是也并不是说C#不支持指针，我们可以使用unsafe关键词，开启不安全代码(unsafe code)开发模式。在不安全模式下，我们可以直接操作内存，这样就可以使用指针了。

在不安全模式下，CLR并不检测unsafe代码的安全，而是直接执行代码。unsafe代码的安全需要开发人员自行检测。

一般在和硬件交互的时候，C#做图像处理的时候，针对大量的数据处理，这时候我们如果使用指针直接访问内存的话会在效率上提高很多

---变量存储另一种类型的内存地址

声明指针类型的语法：

type* identifier;

char* cptr;
int* iptr;

指针的赋值：

指针保存的就是地址，所以我们给指针赋值就是获取数据的地址，

但是这里要注意一点，如果我们要获取的数据在引用类型内，比如说是数组，由于数组是引用类型，且在内存中可移动（堆上可被垃圾回收），为了能获取可移动数据的地址，我们需要用fixed把它固定下来。
byte[] bytes = new byte[24];
                fixed (byte* pData=&bytes [0])
                {

                }

C#中使用指针的总结

1.引用类型不能定义为指针
2.msdn上说enum可以定义为指针，可是我真不知道它的用处是什么。所以在指针的类型中并没有出现enum类型。
3.c#中的指针操作远远不如c/c++，如果想学习指针的话，还是用c/c++
4.微软并不推荐使用unsafe code模式，也不推荐使用指针。在msdn官方文档中，唯一一句赞美C#指针的话就是“合理的使用指针，可以提高程序的执行速度”。但是什么是“合理的使用”？我下载了msdn上的几个关于C#指针的实例代码，发现用的最多的是调用api函数，在api函数中，有大量的指针参数。
5.fixed的使用可能产生存储碎片，因为它们不能移动。如果确实需要固定对象，固定对象的时间应该越短越好。
6.可以使我们了解非托管类型的内存分配。

标签