# C# 变量和（原始）数据类型

> 原文： [https://www.programiz.com/csharp-programming/variables-primitive-data-types](https://www.programiz.com/csharp-programming/variables-primitive-data-types)

#### 在本教程中，我们将学习变量，如何在 C# 中创建变量以及 C# 编程语言支持的不同数据类型。

变量是赋予存储位置的符号名称。 变量用于将数据存储在计算机程序中。

* * *

## 如何在 C# 中声明变量？

这是在 C# 中声明变量的示例。

```cs
int age;
```

在此示例中，声明了类型为`int`（整数）的变量`age`，并且它只能存储整数值。

我们可以稍后在程序中为变量分配一个值，如下所示：

```cs
int age;
... ... ...
age = 24;
```

但是，在声明过程中也可以将变量初始化为某个值。 例如，

```cs
int age = 24;
```

在此，声明类型为`int`的变量`age`并将其初始化为`24`。

由于这是一个变量，因此我们也可以更改变量的值。 例如，

```cs
int age = 24;
age = 35;
```

这里，`age`的值从 24 更改为 35。

* * *

必须先声明 C# 中的变量，然后才能使用它们。 这意味着，必须先知道变量的名称和类型，然后才能为其分配值。 这就是为什么 C# 被称为[静态类型语言](https://stackoverflow.com/questions/1517582/what-is-the-difference-between-statically-typed-and-dynamically-typed-languages "Statically typed language")的原因。

声明后，就不能在范围内更改变量的数据类型。 范围可以看作是代码块，其中变量可见或可以使用。 如果您不理解前面的说明，请不要担心，我们将在后面的章节中了解范围。

现在请记住，我们无法在 C# 中执行以下操作：

```cs
int age;
age = 24;
... ... ...
float age;
```

* * *

### 隐式变量

另外，在 C# 中，我们可以使用`var`关键字声明变量而无需知道其类型。 此类变量称为**隐式类型局部变量**。

使用`var`关键字声明的变量必须在声明时进行初始化。

```cs
var value = 5;
```

编译器根据分配给变量的值来确定变量的类型。 在上面的示例中，`value`的类型为`int`。 这等效于：

```cs
int value;
value = 5;
```

您可以了解有关[隐式类型局部变量](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/implicitly-typed-local-variables)的更多信息。

* * *

## C# 中的变量命名规则

命名变量时，我们需要遵循某些规则。 在 C# 中命名变量的规则是：

1.  变量名称只能包含字母（大写和小写），下划线（_）和数字。
2.  The variable name must start with either letter, underscore or @ symbol. For example,

    Rules for naming variables in C#

    | 变量名 | 备注 |
    | --- | --- |
    | `name` | 有效 |
    | `subject101` | 有效 |
    | `_age` | 有效（命名私有成员变量的最佳实践） |
    | `@break` | 有效（如果名称是保留关键字，则使用） |
    | `101subject` | 无效（以数字开头） |
    | `your_name` | 有效 |
    | `your name` | 无效（包含空格） |

3.  C# 区分大小写。 这意味着`age`和`Age`涉及 2 个不同的变量。
4.  变量名称不能是 C# 关键字。 例如，`if`，`for`，`using`不能是变量名。 在下一个教程中，我们将讨论 [C# 关键字](/csharp-programming/keywords-identifiers "C# Keywords and Identifiers")的更多信息。

* * *

## 命名变量的最佳做法

1.  选择一个有意义的变量名。 例如，`name`，`age`，`subject`比`n`，`a`和`s`更有意义。
2.  使用 **camelCase** 表示法（以小写字母开头）来命名局部变量。 例如，`numOfStudents`，`age`等。
3.  使用 **PascalCase** 或 **CamelCase** （以大写字母开头）来命名公共成员变量。 例如，`Name`，`Price`等。
4.  使用前导下划线（`_`）后跟 **camelCase** 表示法来命名私有成员变量。 例如，`_bankBalance`，`_emailAddress`等。

您可以在处了解有关 C# 中[命名约定的更多信息](https://softwareengineering.stackexchange.com/questions/209532/naming-convention-of-variables-in-c-programming-language)。

不用担心公共和私有成员变量。 我们将在后面的章节中了解它们。

* * *

## C# 基本数据类型

C# 中的变量大致分为两种类型**：值类型**和**引用类型**。 在本教程中，我们将讨论作为值类型的子类的原始（简单）数据类型。

引用类型将在以后的教程中介绍。 但是，如果您想了解更多有关变量类型的信息，请访问 [C# 类型和变量](https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/types-and-variables)（官方 C# 文档）。

### `bool`（布尔）

*   布尔数据类型具有两个可能的值：`true`或`false`
*   **默认值**：`false`
*   布尔变量通常用于检查条件，例如，*循环*等*中的条件。*

例如：

```cs
using System;
namespace DataType
{
    class BooleanExample
    {
        public static void Main(string[] args)
        {
            bool isValid = true;
            Console.WriteLine(isValid);
        }
    }
}
```

当我们运行程序时，输出将是：

```cs
True
```

* * *

### 带符号整数

这些数据类型保存整数值（正数和负数）。 在所有可用位中，一位用于符号。

**1.`sbyte`**

*   **大小**：8 位
*   **范围**：-128 至 127。
*   **默认值**：0

例如：

```cs
using System;
namespace DataType
{
    class SByteExample
    {
        public static void Main(string[] args)
        {
            sbyte level = 23;
            Console.WriteLine(level);
        }
    }
}
```

当我们运行程序时，输出将是：

```cs
23
```

尝试分配超出范围的值，即小于 -128 或大于 127，然后看看会发生什么。

* * *

**2.`short`**

*   **大小**：16 位
*   **范围**：-32,768 至 32,767
*   **默认值**：0

例如：

```cs
using System;
namespace DataType
{
    class ShortExample
    {
        public static void Main(string[] args)
        {
            short value = -1109;
            Console.WriteLine(value);
        }
    }
}
```

当我们运行程序时，输出将是：

```cs
-1109
```

* * *

**3\. `int`**

*   **大小**：32 位
*   **范围**：-231 至 231-1
*   **默认值**：0

例如：

```cs
using System;
namespace DataType
{
    class IntExample
    {
        public static void Main(string[] args)
        {
            int score = 51092;
            Console.WriteLine(score);
        }
    }
}
```

当我们运行程序时，输出将是：

```cs
51092
```

* * *

**4.`long`**

*   **大小**：64 位
*   **范围**：-263 至 263-1
*   **默认值**：`0L`【末尾的`L`表示该值是`long`型】

例如：

```cs
using System;
namespace DataType
{
    class LongExample
    {
        public static void Main(string[] args)
        {
            long range = -7091821871L;
            Console.WriteLine(range);
        }
    }
}
```

当我们运行程序时，输出将是：

```cs
-7091821871
```

* * *

### 无符号整数

这些数据类型仅保留等于或大于 0 的值。当我们确定不会有负值时，通常使用这些数据类型来存储值。

**1.`byte`**

*   **大小**：8 位
*   **范围**：0 到 255。
*   **默认值**：0

例如：

```cs
using System;
namespace DataType
{
    class ByteExample
    {
        public static void Main(string[] args)
        {
            byte age = 62;
            Console.WriteLine(level);
        }
    }
}
```

当我们运行程序时，输出将是：

```cs
62
```

* * *

**2\. `ushort`**

*   **大小**：16 位
*   **范围**：0 到 65,535
*   **默认值**：0

例如：

```cs
using System;
namespace DataType
{
    class UShortExample
    {
        public static void Main(string[] args)
        {
            ushort value = 42019;
            Console.WriteLine(value);
        }
    }
}
```

当我们运行程序时，输出将是：

```cs
42019
```

* * *

**3\. `uint`**

*   **大小**：32 位
*   **范围**：0 到 232-1
*   **默认值**：0

例如：

```cs
using System;
namespace DataType
{
    class UIntExample
    {
        public static void Main(string[] args)
        {
            uint totalScore = 1151092;
            Console.WriteLine(totalScore);
        }
    }
}
```

当我们运行程序时，输出将是：

```cs
1151092
```

* * *

**4\. `ulong`**

*   **大小**：64 位
*   **范围**：0 到 264-1
*   **默认值**：0

例如：

```cs
using System;
namespace DataType
{
    class ULongExample
    {
        public static void Main(string[] args)
        {
            ulong range = 17091821871L;
            Console.WriteLine(range);
        }
    }
}
```

当我们运行程序时，输出将是：

```cs
17091821871
```

* * *

### 浮点

这些数据类型保存浮点值，即包含十进制值的数字。 例如 12.36，-92.17 等。

**1.`float`**

*   单精度浮点型
*   **大小**：32 位
*   **范围**：`1.5×10^−45`至`3.4×10^38`
*   **默认值**：`0.0F`【`F`表示值是浮点型】

例如：

```cs
using System;
namespace DataType
{
    class FloatExample
    {
        public static void Main(string[] args)
        {
            float number = 43.27F;
            Console.WriteLine(number);
        }
    }
}
```

当我们运行程序时，输出将是：

```cs
43.27
```

* * *

**2.`double`**

*   双精度浮点类型。 [单精度和双精度浮点有什么区别？](https://stackoverflow.com/questions/801117/whats-the-difference-between-a-single-precision-and-double-precision-floating-p)
*   **大小**：64 位
*   **范围**：`5.0×10^−324`至`1.7×10^308`
*   **默认值**：`0.0D`【`D`表示值是双精度型】

例如：

```cs
using System;
namespace DataType
{
    class DoubleExample
    {
        public static void Main(string[] args)
        {
            double value = -11092.53D;
            Console.WriteLine(value);
        }
    }
}
```

当我们运行程序时，输出将是：

```cs
-11092.53
```

* * *

### `char`（字符）

*   它代表一个 16 位 unicode 字符。
*   **大小**：16 位
*   **默认值**：`"\0"`
*   **范围**：U+0000（`'\u0000'`）至 U+FFFF（`'\uffff'`）

例如：

```cs
using System;
namespace DataType
{
    class CharExample
    {
        public static void Main(string[] args)
        {
            char ch1 ='\u0042';
            char ch2 = 'x';
            Console.WriteLine(ch1);
            Console.WriteLine(ch2);
        }
    }
} 
```

当我们运行程序时，输出将是：

```cs
B
x
```

`'B'`的 unicode 值为`'\u0042'`，因此打印`ch1`将打印`'B'`。

* * *

### `decimal`

*   与浮点类型（双精度和浮点型）相比，十进制类型具有更高的精度和更小的范围。 因此，它适合进行货币计算。
*   **大小**：128 位
*   **默认值**：`0.0M`【`M`表示十进制类型的值】
*   **范围**：（`-7.9x10^28`至`7.9x10^28`）/（100 至 28）

例如：

```cs
using System;
namespace DataType
{
    class DecimalExample
    {
        public static void Main(string[] args)
        {
         decimal bankBalance = 53005.25M;
            Console.WriteLine(bankBalance);
        }
    }
} 
```

当我们运行程序时，输出将是：

```cs
53005.25
```

必须在末尾添加后缀`M`或`m`，否则该值将被视为双精度值，并会产生错误。

* * *

## C# 字面值

让我们看下面的语句：

```cs
int number = 41;
```

这里，

*   `int`是一种数据类型
*   `number`是变量，
*   `41`是字面值

字面值是程序中显示的固定值。 他们不需要任何计算。 例如，`5`，`false`，`'w'`是直接出现在程序中的字面值，无需任何计算。

* * *

### 布尔字面值

*   `true`和`false`是可用的布尔字面值。
*   它们用于初始化布尔变量。

例如：

```cs
bool isValid = true;
bool isPresent = false;
```

* * *

### 整数字面值

*   整数字面值用于初始化整数数据类型的变量，即`sbyte`，`short`，`int`，`long`，`byte`，`ushort`，`uint`和`ulong`。
*   如果整数字面值以`L`或`l`结尾，则其类型为`long`。 为了获得最佳实践，请使用`L`（而非`l`）。

    ```cs
    long value1 = 4200910L;
    long value2 = -10928190L;
    ```

*   如果整数字面值以`0x`开头，则它表示十六进制值。 没有前缀的数字将被视为十进制值。 在 C# 中不允许使用八进制和二进制表示形式。

    ```cs
    int decimalValue = 25;
    int hexValue = 0x11c;// decimal value 284
    ```

* * *

### 浮点字面值

*   浮点字面值用于初始化`float`和`double`数据类型的变量。
*   如果浮点字面值以后缀`f`或`F`结尾，则其类型为`float`。 同样，如果以`d`或`D`结尾，则其类型为`double`。 如果两个后缀都不存在，则默认**类型**为`double`。
*   这些字面值以科学计数法表示时包含`e`或`E`。

    ```cs
    double number = 24.67;// double by default
    float value = -12.29F;
    double scientificNotation = 6.21e2;// equivalent to 6.21 x 102 i.e. 621
    ```

* * *

### 字符和字符串字面值

*   字符字面值用于初始化`char`数据类型的变量。
*   字符字面值用单引号引起来。 例如`'x'`，`'p'`等。
*   它们可以表示为字符，十六进制转义序列，unicode 表示或强制转换为`char`的整数值。

    ```cs
    char ch1 = 'R';// character
    char ch2 = '\x0072';// hexadecimal
    char ch3 = '\u0059';// unicode
    char ch4 = (char)107;// casted from integer
    ```

*   字符串字面值是字符字面值的集合。
*   它们用双引号引起来。 例如，`"Hello"`，`"Easy Programming"`等。

    ```cs
    string firstName = "Richard";
    string lastName = " Feynman";
    ```

*   C# also supports escape sequence characters such as:

    | 字符 | 含义 |
    | --- | --- |
    | `\'` | 单引号 |
    | `\"` | 双引号 |
    | `\\` | 反斜杠 |
    | `\n` | 新队 |
    | `\r` | 回车 |
    | `\t` | 水平制表符 |
    | `\a` | 警报 |
    | `\b` | 退格键 |