c#学习笔记

最新推荐文章于 2023-04-24 10:30:42 发布
最新推荐文章于 2023-04-24 10:30:42 发布
阅读量241 收藏 2
点赞数
CC 4.0 BY-SA版权
文章标签： c# javascript 操作系统 ViewUI
原文链接：http://www.cnblogs.com/paradise-of-sunshine/p/10302067.html

1、程序结构

using System;
namespace HelloWorldApplication
{
   class HelloWorld
   {
      static void Main(string[] args)
      {
         /* 我的第一个 C# 程序*/
         Console.WriteLine("Hello World");
         Console.ReadKey();
      }
   }
}
  • 　　程序的第一行 using System; - using 关键字用于在程序中包含 System 命名空间。 一个程序一般有多个 using 语句。
  • 下一行是 namespace 声明。一个 namespace 里包含了一系列的类。HelloWorldApplication 命名空间包含了类 HelloWorld。
  • 下一行是 class 声明。类 HelloWorld 包含了程序使用的数据和方法声明。类一般包含多个方法。方法定义了类的行为。在这里，HelloWorld类只有一个 Main 方法。
  • 下一行定义了 Main 方法，是所有 C# 程序的 入口点。Main 方法说明当执行时 类将做什么动作。
  • 下一行 /*...*/ 将会被编译器忽略，且它会在程序中添加额外的 注释。
  • Main 方法通过语句 Console.WriteLine("Hello World"); 指定了它的行为。

    WriteLine 是一个定义在 System 命名空间中的 Console 类的一个方法。该语句会在屏幕上显示消息 "Hello, World!"。

  • 最后一行 Console.ReadKey(); 是针对 VS.NET 用户的。这使得程序会等待一个按键的动作，防止程序从 Visual Studio .NET 启动时屏幕会快速运行并关闭。

2、标识符

标识符是用来识别类、变量、函数或任何其它用户定义的项目。在 C# 中，类的命名必须遵循如下基本规则：

  • 标识符必须以字母、下划线或 @ 开头，后面可以跟一系列的字母、数字（ 0 - 9 ）、下划线（ _ ）、@。
  • 标识符中的第一个字符不能是数字。
  • 标识符必须不包含任何嵌入的空格或符号，比如 ? - +! # % ^ & * ( ) [ ] { } . ; : " ' / \。
  • 标识符不能是 C# 关键字。除非它们有一个 @ 前缀。 例如，@if 是有效的标识符，但 if 不是，因为 if 是关键字。
  • 标识符必须区分大小写。大写字母和小写字母被认为是不同的字母。
  • 不能与C#的类库名称相同。

3、数据类型

a、值类型（Value types）

值类型直接包含数据。比如 int、char、float，它们分别存储数字、字符、浮点数。

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

类型描述范围默认值
bool布尔值True 或 FalseFalse
byte8 位无符号整数0 到 2550
char16 位 Unicode 字符U +0000 到 U +ffff'\0'
decimal128 位精确的十进制值，28-29 有效位数(-7.9 x 1028 到 7.9 x 1028) / 100 到 280.0M
double64 位双精度浮点型(+/-)5.0 x 10-324 到 (+/-)1.7 x 103080.0D
float32 位单精度浮点型-3.4 x 1038 到 + 3.4 x 10380.0F
int32 位有符号整数类型-2,147,483,648 到 2,147,483,6470
long64 位有符号整数类型-923,372,036,854,775,808 到 9,223,372,036,854,775,8070L
sbyte8 位有符号整数类型-128 到 1270
short16 位有符号整数类型-32,768 到 32,7670
uint32 位无符号整数类型0 到 4,294,967,2950
ulong64 位无符号整数类型0 到 18,446,744,073,709,551,6150
ushort16 位无符号整数类型0 到 65,5350

如需得到一个类型或一个变量在特定平台上的准确尺寸，可以使用 sizeof 方法。表达式 sizeof(type) 产生以字节为单位存储对象或类型的存储尺寸。

b、引用类型（Reference types）

引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。它们指的是一个内存位置。使用多个变量时，引用类型可以指向一个内存位置。如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。内置的 引用类型有：object、dynamic 和 string。

对象类型：对象（Object）类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是，在分配值之前，需要先进行类型转换。

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

object obj;
obj = 100; // 这是装箱
c、动态（Dynamic）类型

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

dynamic d = 20;

　　动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时发生的，而动态类型变量的类型检查是在运行时发生的。

 d、字符串（String）类型

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

String str = "runoob.com";
或：
@"runoob.com";
C# string 字符串的前面可以加 @（称作"逐字字符串"）将转义字符（\）当作普通字符对待，比如：
string str = @"C:\Windows";
等价于：
string str = "C:\\Windows";
@ 字符串中可以任意换行，换行符及缩进空格都计算在字符串长度之内。
string str = @"<script type=""text/javascript"">
    <!--
    -->
</script>";
e、指针类型（Pointer types）
type* identifier;

4、类型转换

c#中，类型转换（或者叫做类型铸造）有两种形式：

  • 隐式类型转换 - 这些转换是 C# 默认的以安全方式进行的转换, 不会导致数据丢失。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。
  • 显式类型转换 - 显式类型转换，即强制类型转换。显式转换需要强制转换运算符，而且强制转换会造成数据丢失。
namespace TypeConversionApplication
{
    class ExplicitConversion
    {
        static void Main(string[] args)
        {
            double d = 5673.74;
            int i;

            // 强制转换 double 为 int
            i = (int)d;
            Console.WriteLine(i);
            Console.ReadKey();
            
        }
    }
}

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

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

下面的实例把不同值的类型转换为字符串类型：

namespace TypeConversionApplication
{
    class StringConversion
    {
        static void Main(string[] args)
        {
            int i = 75;
            float f = 53.005f;
            double d = 2345.7652;
            bool b = true;

            Console.WriteLine(i.ToString());
            Console.WriteLine(f.ToString());
            Console.WriteLine(d.ToString());
            Console.WriteLine(b.ToString());
            Console.ReadKey();
        }
    }
}

5、变量

 C# 中变量定义的语法：

<data_type> <variable_list>;

data_type 必须是一个有效的 C# 数据类型，可以是 char、int、float、double 或其他用户自定义的数据类型。variable_list 可以由一个或多个用逗号分隔的标识符名称组成。

 System 命名空间中的 Console 类提供了一个函数 ReadLine()，用于接收来自用户的输入，并把它存储到一个变量中。

int num;
num = Convert.ToInt32(Console.ReadLine());

函数 Convert.ToInt32() 把用户输入的数据转换为 int 数据类型，因为 Console.ReadLine() 只接受字符串格式的数据。

6、常量

常量是使用 const 关键字来定义的 。

public const int c1 = 5;

a、整数常量：

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，没有前缀则表示十进制。整数常量也可以有后缀，可以是 U 和 L 的组合，其中，U 和 L 分别表示 unsigned 和 long。后缀可以是大写或者小写，多个后缀以任意顺序进行组合。

212         /* 合法 */
215u        /* 合法 */
0xFeeL      /* 合法 */
078         /* 非法：8 不是一个八进制数字 */
032UU       /* 非法：不能重复后缀 */

　　以下是各种类型的整数常量的实例：

85         /* 十进制 */
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* int */
30u        /* 无符号 int */
30l        /* long */
30ul       /* 无符号 long */

b、浮点常量：

个浮点常量是由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。使用小数形式表示时，必须包含小数点、指数或同时包含两者。使用指数形式表示时，必须包含整数部分、小数部分或同时包含两者。有符号的指数是用 e 或 E 表示的。

3.14159       /* 合法 */
314159E-5L    /* 合法 */
510E          /* 非法：不完全指数 */
210f          /* 非法：没有小数或指数 */
.e55          /* 非法：缺少整数或小数 */

c、字符常量

字符常量是括在单引号里，例如，'x'，且可存储在一个简单的字符类型变量中。一个字符常量可以是一个普通字符（例如 'x'）、一个转义序列（例如 '\t'）或者一个通用字符（例如 '\u02C0'）。

在 C# 中有一些特定的字符，当它们的前面带有反斜杠时有特殊的意义，可用于表示换行符（\n）或制表符 tab（\t）。

转义序列含义
\\\ 字符
\'' 字符
\"" 字符
\?? 字符
\aAlert 或 bell
\b退格键（Backspace）
\f换页符（Form feed）
\n换行符（Newline）
\r回车
\t水平制表符 tab
\v垂直制表符 tab
\ooo一到三位的八进制数
\xhh . . .一个或多个数字的十六进制数

d、字符串常量

string c = "hello \t world";               // hello     world
string d = @"hello \t world";               // hello \t world
string e = "Joe said \"Hello\" to me";      // Joe said "Hello" to me
string f = @"Joe said ""Hello"" to me";   // Joe said "Hello" to me
string g = "\\\\server\\share\\file.txt";   // \\server\share\file.txt
string h = @"\\server\share\file.txt";      // \\server\share\file.txt

7、封装

 封装 被定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"。在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。

C# 封装根据具体的需要，设置使用者的访问权限，并通过 访问修饰符 来实现。一个 访问修饰符 定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：

  • public：所有对象都可以访问；
  • private：对象本身在对象内部可以访问；
  • protected：只有该类对象及其子类对象可以访问
  • internal：同一个程序集的对象可以访问；
  • protected internal：访问限于当前程序集或派生自包含类的类型。

 如果没有指定访问修饰符，则使用类成员的默认访问修饰符，即为 private。

 8、方法

<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
   Method Body
}
  • Access Specifier：访问修饰符，这个决定了变量或方法对于另一个类的可见性。
  • Return type：返回类型，一个方法可以返回一个值。返回类型是方法返回的值的数据类型。如果方法不返回任何值，则返回类型为 void。
  • Method name：方法名称，是一个唯一的标识符，且是大小写敏感的。它不能与类中声明的其他标识符相同。
  • Parameter list：参数列表，使用圆括号括起来，该参数是用来传递和接收方法的数据。参数列表是指方法的参数类型、顺序和数量。参数是可选的，也就是说，一个方法可能不包含参数。
  • Method body：方法主体，包含了完成任务所需的指令集。

 方法调用的时候有三种传递参数的方法：值参数、引用参数、输出参数；

a、值参数

普通的方法调用即是用的这种参数，实际参数的值会复制给形参，实参和形参使用的是两个不同内存中的值。所以，当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全。

b、引用参数

引用参数表示与提供给方法的实际参数具有相同的内存位置。所以当方法内的形参发生改变时，调用方法时传递的实参也会发生变化；

......
public void swap(ref int x, ref int y)
......
/* 调用函数来交换值 */
n.swap(ref a, ref b);
......

在c#中，这种参数使用的时候在形参和实参前加上ref关键字

c、按输出传递参数

输出参数会把方法输出的数据赋给自己，其他方面与引用参数相似。

namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void getValues(out int x, out int y )
      {
          Console.WriteLine("请输入第一个值： ");
          x = Convert.ToInt32(Console.ReadLine());
          Console.WriteLine("请输入第二个值： ");
          y = Convert.ToInt32(Console.ReadLine());
      }
   
      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* 局部变量定义 */
         int a , b;
         
         /* 调用函数来获取值 */
         n.getValues(out a, out b);

         Console.WriteLine("在方法调用之后，a 的值： {0}", a);
         Console.WriteLine("在方法调用之后，b 的值： {0}", b);
         Console.ReadLine();
      }
   }
}

当需要从一个参数没有指定初始值的方法中返回值时，输出参数特别有用。上例中如果改为引用参数由于没有给参数制定初始值，会出现报错。

9、可空类型

C# 提供了一个特殊的数据类型，nullable 类型（可空类型），用于对 int,double,bool 等无法直接赋值为 null 的数据类型进行 null 的赋值，可空类型可以表示其基础值类型正常范围内的值，再加上一个 null 值。

例如，Nullable< Int32 >，读作"可空的 Int32"，可以被赋值为 -2,147,483,648 到 2,147,483,647 之间的任意值，也可以被赋值为 null 值。类似的，Nullable< bool > 变量可以被赋值为 true 或 false 或 null。

         int? num1 = null;
         int? num2 = 45;
         double? num3 = new double?();
         double? num4 = 3.14157;
         bool? boolval = new bool?();

Null 合并运算符

Null 合并运算符把操作数类型隐式转换为另一个可空（或不可空）的值类型的操作数的类型。如果第一个操作数的值为 null，则运算符返回第二个操作数的值，否则返回第一个操作数的值。

double? num1 = null;
double? num2 = 3.14157;
double num3;
num3 = num1 ?? 5.34;      // num1 如果为空值则返回 5.34
Console.WriteLine("num3 的值： {0}", num3);
num3 = num2 ?? 5.34;
Console.WriteLine("num3 的值： {0}", num3);

10、数组

double[] balance = new double[10];

赋值：可以通过使用索引号赋值给一个单独的数组元素：

double[] balance = new double[10];
balance[0] = 4500.0;

可以在声明数组的同时给数组赋值：

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

也可以创建并初始化一个数组：

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

可以省略数组的大小：

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

创建一个数组时，C# 编译器会根据数组类型隐式初始化每个数组元素为一个默认值。例如，int 数组的所有元素都会被初始化为 0。

创建一个二维数组：

int [,] a = new int [3,4] {
 {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
};

创建的时候用逗号隔开，同理可以创建多维数组。

 交错数组

 交错数组是数组的数组。

/* 一个由 5 个整型数组组成的交错数组 */
int[][] a = new int[][]{new int[]{0,0},new int[]{1,2}, 
new int[]{2,4},new int[]{ 3, 6 }, new int[]{ 4, 8 } };

 参数数组

 有时，当声明一个方法时，您不能确定要传递给函数作为参数的参数数目。C# 参数数组解决了这个问题，参数数组通常用于传递未知数量的参数给函数（类似于js中的argument）。

......
public int AddElements(params int[] arr)
{
    int sum = 0;
    foreach (int i in arr)
    {
        sum += i;
     }
     return sum;
}
......
int sum = app.AddElements(512, 720, 250, 567, 889);
......

Array 类

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

 

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

 Array的一些常用方法：

 

序号方法 & 描述
1Clear
根据元素的类型，设置数组中某个范围的元素为零、为 false 或者为 null。
2Copy(Array, Array, Int32)
从数组的第一个元素开始复制某个范围的元素到另一个数组的第一个元素位置。长度由一个 32 位整数指定。
3CopyTo(Array, Int32)
从当前的一维数组中复制所有的元素到一个指定的一维数组的指定索引位置。索引由一个 32 位整数指定。
4GetLength 
获取一个 32 位整数，该值表示指定维度的数组中的元素总数。
5GetLongLength
获取一个 64 位整数，该值表示指定维度的数组中的元素总数。
6GetLowerBound
获取数组中指定维度的下界。
7GetType
获取当前实例的类型。从对象（Object）继承。
8GetUpperBound
获取数组中指定维度的上界。
9GetValue(Int32)
获取一维数组中指定位置的值。索引由一个 32 位整数指定。
10IndexOf(Array, Object)
搜索指定的对象，返回整个一维数组中第一次出现的索引。
11Reverse(Array)
逆转整个一维数组中元素的顺序。
12SetValue(Object, Int32)
给一维数组中指定位置的元素设置值。索引由一个 32 位整数指定。
13Sort(Array)
使用数组的每个元素的 IComparable 实现来排序整个一维数组中的元素。
14ToString
返回一个表示当前对象的字符串。从对象（Object）继承。

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

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

11、字符串

//字符串，字符串连接
            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() ;

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

序号方法名称 & 描述
1public static int Compare( string strA, string strB ) 
比较两个指定的 string 对象，并返回一个表示它们在排列顺序中相对位置的整数。该方法区分大小写。
2public static int Compare( string strA, string strB, bool ignoreCase ) 
比较两个指定的 string 对象，并返回一个表示它们在排列顺序中相对位置的整数。但是，如果布尔参数为真时，该方法不区分大小写。
3public static string Concat( string str0, string str1 ) 
连接两个 string 对象。
4public static string Concat( string str0, string str1, string str2 ) 
连接三个 string 对象。
5public static string Concat( string str0, string str1, string str2, string str3 ) 
连接四个 string 对象。
6public bool Contains( string value ) 
返回一个表示指定 string 对象是否出现在字符串中的值。
7public static string Copy( string str ) 
创建一个与指定字符串具有相同值的新的 String 对象。
8public void CopyTo( int sourceIndex, char[] destination, int destinationIndex, int count ) 
从 string 对象的指定位置开始复制指定数量的字符到 Unicode 字符数组中的指定位置。
9public bool EndsWith( string value ) 
判断 string 对象的结尾是否匹配指定的字符串。
10public bool Equals( string value ) 
判断当前的 string 对象是否与指定的 string 对象具有相同的值。
11public static bool Equals( string a, string b ) 
判断两个指定的 string 对象是否具有相同的值。
12public static string Format( string format, Object arg0 ) 
把指定字符串中一个或多个格式项替换为指定对象的字符串表示形式。
13public int IndexOf( char value ) 
返回指定 Unicode 字符在当前字符串中第一次出现的索引，索引从 0 开始。
14public int IndexOf( string value ) 
返回指定字符串在该实例中第一次出现的索引，索引从 0 开始。
15public int IndexOf( char value, int startIndex ) 
返回指定 Unicode 字符从该字符串中指定字符位置开始搜索第一次出现的索引，索引从 0 开始。
16public int IndexOf( string value, int startIndex ) 
返回指定字符串从该实例中指定字符位置开始搜索第一次出现的索引，索引从 0 开始。
17public int IndexOfAny( char[] anyOf ) 
返回某一个指定的 Unicode 字符数组中任意字符在该实例中第一次出现的索引，索引从 0 开始。
18public int IndexOfAny( char[] anyOf, int startIndex ) 
返回某一个指定的 Unicode 字符数组中任意字符从该实例中指定字符位置开始搜索第一次出现的索引，索引从 0 开始。
19public string Insert( int startIndex, string value ) 
返回一个新的字符串，其中，指定的字符串被插入在当前 string 对象的指定索引位置。
20public static bool IsNullOrEmpty( string value ) 
指示指定的字符串是否为 null 或者是否为一个空的字符串。
21public static string Join( string separator, string[] value ) 
连接一个字符串数组中的所有元素，使用指定的分隔符分隔每个元素。
22public static string Join( string separator, string[] value, int startIndex, int count ) 
连接接一个字符串数组中的指定位置开始的指定元素，使用指定的分隔符分隔每个元素。
23public int LastIndexOf( char value ) 
返回指定 Unicode 字符在当前 string 对象中最后一次出现的索引位置，索引从 0 开始。
24public int LastIndexOf( string value ) 
返回指定字符串在当前 string 对象中最后一次出现的索引位置，索引从 0 开始。
25public string Remove( int startIndex ) 
移除当前实例中的所有字符，从指定位置开始，一直到最后一个位置为止，并返回字符串。
26public string Remove( int startIndex, int count ) 
从当前字符串的指定位置开始移除指定数量的字符，并返回字符串。
27public string Replace( char oldChar, char newChar ) 
把当前 string 对象中，所有指定的 Unicode 字符替换为另一个指定的 Unicode 字符，并返回新的字符串。
28public string Replace( string oldValue, string newValue ) 
把当前 string 对象中，所有指定的字符串替换为另一个指定的字符串，并返回新的字符串。
29public string[] Split( params char[] separator ) 
返回一个字符串数组，包含当前的 string 对象中的子字符串，子字符串是使用指定的 Unicode 字符数组中的元素进行分隔的。
30public string[] Split( char[] separator, int count ) 
返回一个字符串数组，包含当前的 string 对象中的子字符串，子字符串是使用指定的 Unicode 字符数组中的元素进行分隔的。int 参数指定要返回的子字符串的最大数目。
31public bool StartsWith( string value ) 
判断字符串实例的开头是否匹配指定的字符串。
32public char[] ToCharArray()
返回一个带有当前 string 对象中所有字符的 Unicode 字符数组。
33public char[] ToCharArray( int startIndex, int length ) 
返回一个带有当前 string 对象中所有字符的 Unicode 字符数组，从指定的索引开始，直到指定的长度为止。
34public string ToLower()
把字符串转换为小写并返回。
35public string ToUpper()
把字符串转换为大写并返回。
36public string Trim()
移除当前 String 对象中的所有前导空白字符和后置空白字符。
......
if (String.Compare(str1, str2) == 0)
......

12、结构体

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

using System;
using System.Text;
     
struct Books
{
   private string title;
   private string author;
   private string subject;
   private int book_id;
   public void getValues(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，类型为 Book */
      Books Book2 = new Books(); /* 声明 Book2，类型为 Book */

      /* book 1 详述 */
      Book1.getValues("C Programming",
      "Nuha Ali", "C Programming Tutorial",6495407);

      /* book 2 详述 */
      Book2.getValues("Telecom Billing",
      "Zara Ali", "Telecom Billing Tutorial", 6495700);

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

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

      Console.ReadKey();

   }
}

 结构体和类的不同：

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

 13、类

 构造函数

类的 构造函数 是类的一个特殊的成员函数，当创建类的新对象时执行。构造函数的名称与类的名称完全相同，它没有任何返回类型。

默认的构造函数没有任何参数。但是如果你需要一个带有参数的构造函数可以有参数，这种构造函数叫做参数化构造函数。

class Line
   {
      private double length;   // 线条的长度
      public Line(double len)  // 参数化构造函数
      {
         Console.WriteLine("对象已创建，length = {0}", len);
         length = len;
      }

      public void setLength( double len )
      {
         length = len;
      }
      public double getLength()
      {
         return length;
      }

      static void Main(string[] args)
      {
         Line line = new Line(10.0);
         Console.WriteLine("线条的长度： {0}", line.getLength()); 
         // 设置线条长度
         line.setLength(6.0);
         Console.WriteLine("线条的长度： {0}", line.getLength()); 
         Console.ReadKey();
      }
   }

折构函数

类的 析构函数 是类的一个特殊的成员函数，当类的对象超出范围时执行。

析构函数的名称是在类的名称前加上一个波浪形（~）作为前缀，它不返回值，也不带任何参数。

析构函数用于在结束程序（比如关闭文件、释放内存等）之前释放资源。析构函数不能继承或重载。

class Line
   {
      private double length;   // 线条的长度
      public Line()  // 构造函数
      {
         Console.WriteLine("对象已创建");
      }
      ~Line() //析构函数
      {
         Console.WriteLine("对象已删除");
      }

      public void setLength( double len )
      {
         length = len;
      }
      public double getLength()
      {
         return length;
      }

      static void Main(string[] args)
      {
         Line line = new Line();
         // 设置线条长度
         line.setLength(6.0);
         Console.WriteLine("线条的长度： {0}", line.getLength());           
      }
   }

静态成员

我们可以使用 static 关键字把类成员定义为静态的。当我们声明一个类成员为静态时，意味着无论有多少个类的对象被创建，只会有一个该静态成员的副本。

关键字 static 意味着类中只有一个该成员的实例。静态变量用于定义常量，因为它们的值可以通过直接调用类而不需要创建类的实例来获取。静态变量可在成员函数或类的定义外部进行初始化。你也可以在类的定义内部初始化静态变量。

class StaticVar
    {
       public static int num;
        public void count()
        {
            num++;
        }
        public int getNum()
        {
            return num;
        }
    }
    class StaticTester
    {
        static void Main(string[] args)
        {
            StaticVar s1 = new StaticVar();
            StaticVar s2 = new StaticVar();
            s1.count();
            s1.count();
            s1.count();
            s2.count();
            s2.count();
            s2.count();         
            Console.WriteLine("s1 的变量 num： {0}", s1.getNum());
            Console.WriteLine("s2 的变量 num： {0}", s2.getNum());
            Console.ReadKey();
        }
    }

　　在上面这个例子中，num被定义成一个静态成员，所以不管后续该类被调用几次，该成员只使用这一个副本。num初始值为0，在Main中被s1和s2一共累加6次，所以最后结果s1和s2的输出都是6。

14、继承

当创建一个类时，不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类，这个新的类被称为派生类。

using System;
namespace RectangleApplication
{
   class Rectangle
   {
      // 成员变量
      protected double length;
      protected double width;
      public Rectangle(double l, double w)
      {
         length = l;
         width = w;
      }
      public double GetArea()
      {
         return length * width;
      }
      public void Display()
      {
         Console.WriteLine("长度： {0}", length);
         Console.WriteLine("宽度： {0}", width);
         Console.WriteLine("面积： {0}", GetArea());
      }
   }//end class Rectangle  
   class Tabletop : Rectangle
   {
      private double cost;
      public Tabletop(double l, double w) : base(l, w)
      { }
      public double GetCost()
      {
         double cost;
         cost = GetArea() * 70;
         return cost;
      }
      public void Display()
      {
         base.Display();
         Console.WriteLine("成本： {0}", GetCost());
      }
   }
   class ExecuteRectangle
   {
      static void Main(string[] args)
      {
         Tabletop t = new Tabletop(4.5, 7.5);
         t.Display();
         Console.ReadLine();
      }
   }
}

如果派生类和基类中存在相同命名的成员，那么在派生类中要通过base来调用基类中的成员

C# 不支持多重继承。但是，可以使用接口来实现多重继承。

15、重载

重载是可以在同一个范围内对相同的函数名有多个定义。函数的定义必须彼此不同，可以是参数列表中的参数类型不同，也可以是参数个数不同。不能重载只有返回类型不同的函数声明。

void print(int i)
      {
         Console.WriteLine("Printing int: {0}", i );
      }

      void print(double f)
      {
         Console.WriteLine("Printing float: {0}" , f);
      }

      void print(string s)
      {
         Console.WriteLine("Printing string: {0}", s);
      }
      static void Main(string[] args)
      {
         Printdata p = new Printdata();
         // 调用 print 来打印整数
         p.print(5);
         // 调用 print 来打印浮点数
         p.print(500.263);
         // 调用 print 来打印字符串
         p.print("Hello C++");
         Console.ReadKey();
      }

16、命名空间

 命名空间的设计目的是提供一种让一组名称与其他名称分隔开的方式。在一个命名空间中声明的类的名称与另一个命名空间中声明的相同的类的名称不冲突。

namespace_name.item_name;

前面的是名空间的名称， 点后面的是支持命名空间版本的函数或变量（类名）。

 using 关键字

 using 关键字表明程序使用的是给定命名空间中的名称。也可以使用 using 命名空间指令，这样在使用的时候就不用在前面加上命名空间名称。该指令告诉编译器随后的代码使用了指定命名空间中的名称。

using System;
using first_space;
using second_space;

namespace first_space
{
   class abc
   {
      public void func()
      {
         Console.WriteLine("Inside first_space");
      }
   }
}
namespace second_space
{
   class efg
   {
      public void func()
      {
         Console.WriteLine("Inside second_space");
      }
   }
}   
class TestClass
{
   static void Main(string[] args)
   {
      abc fc = new abc();
      efg sc = new efg();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}

可以使用点（.）运算符访问嵌套的命名空间的成员

using SomeNameSpace.Nested;

17、预处理指令

预处理器指令指导编译器在实际编译开始之前对信息进行预处理。

预处理器指令描述
#define它用于定义一系列成为符号的字符。
#undef它用于取消定义符号。
#if它用于测试符号是否为真。
#else它用于创建复合条件指令，与 #if 一起使用。
#elif它用于创建复合条件指令。
#endif指定一个条件指令的结束。
#line它可以让您修改编译器的行数以及（可选地）输出错误和警告的文件名。
#error它允许从代码的指定位置生成一个错误。
#warning它允许从代码的指定位置生成一级警告。
#region它可以让您在使用 Visual Studio Code Editor 的大纲特性时，指定一个可展开或折叠的代码块。
#endregion它标识着 #region 块的结束。

#define 允许您定义一个符号，这样，通过使用符号作为传递给 #if 指令的表达式，表达式将返回 true。

#define PI 
using System;
namespace PreprocessorDAppl
{
   class Program
   {
      static void Main(string[] args)
      {
         #if (PI)
            Console.WriteLine("PI is defined");
         #else
            Console.WriteLine("PI is not defined");
         #endif
         Console.ReadKey();
      }
   }
}

一个以 #if 指令开始的条件指令，必须显示地以一个 #endif 指令终止。

预处理器指令的用途理解：

在程序调试和运行上有重要的作用。比如预处理器指令可以禁止编译器编译代码的某一部分，如果计划发布两个版本的代码，即基本版本和有更多功能的企业版本，就可以使用这些预处理器指令来控制。在编译软件的基本版本时，使用预处理器指令还可以禁止编译器编译于额外功能相关的代码。另外，在编写提供调试信息的代码时，也可以使用预处理器指令进行控制。总的来说和普通的控制语句（if等）功能类似，方便在于预处理器指令包含的未执行部分是不需要编译的。

18、异常处理

异常提供了一种把程序控制权从某个部分转移到另一个部分的方式。

  • try：一个 try 块标识了一个将被激活的特定的异常的代码块。后跟一个或多个 catch 块。
  • catch：程序通过异常处理程序捕获异常。catch 关键字表示异常的捕获。
  • finally：finally 块用于执行给定的语句，不管异常是否被抛出都会执行。例如，如果您打开一个文件，不管是否出现异常文件都要被关闭。
  • throw：当问题出现时，程序抛出一个异常。使用 throw 关键字来完成。

 异常类

 

C# 异常是使用类来表示的。C# 中的异常类主要是直接或间接地派生于 System.Exception 类。System.ApplicationException 和 System.SystemException 类是派生于 System.Exception 类的异常类。

System.ApplicationException 类支持由应用程序生成的异常。所以程序员定义的异常都应派生自该类。

System.SystemException 类是所有预定义的系统异常的基类。

 

异常类描述
System.IO.IOException处理 I/O 错误。
System.IndexOutOfRangeException处理当方法指向超出范围的数组索引时生成的错误。
System.ArrayTypeMismatchException处理当数组类型不匹配时生成的错误。
System.NullReferenceException处理当依从一个空对象时生成的错误。
System.DivideByZeroException处理当除以零时生成的错误。
System.InvalidCastException处理在类型转换期间生成的错误。
System.OutOfMemoryException处理空闲内存不足生成的错误。
System.StackOverflowException处理栈溢出生成的错误。

异常处理

C# 以 try 和 catch 块的形式提供了一种结构化的异常处理方案。使用这些块，把核心程序语句与错误处理语句分离开。

这些错误处理块是使用 try、catch 和 finally 关键字实现的。

 19、文件的输入和输出

一个 文件 是一个存储在磁盘中带有指定名称和目录路径的数据集合。当打开文件进行读写时，它变成一个 流。

从根本上说，流是通过通信路径传递的字节序列。有两个主要的流：输入流 和 输出流。输入流用于从文件读取数据（读操作），输出流用于向文件写入数据（写操作）。

System.IO类

System.IO 命名空间有各种不同的类，用于执行各种文件操作，如创建和删除文件、读取或写入文件，关闭文件等。

I/O 类描述
BinaryReader从二进制流读取原始数据。
BinaryWriter以二进制格式写入原始数据。
BufferedStream字节流的临时存储。
Directory有助于操作目录结构。
DirectoryInfo用于对目录执行操作。
DriveInfo提供驱动器的信息。
File有助于处理文件。
FileInfo用于对文件执行操作。
FileStream用于文件中任何位置的读写。
MemoryStream用于随机访问存储在内存中的数据流。
Path对路径信息执行操作。
StreamReader用于从字节流中读取字符。
StreamWriter用于向一个流中写入字符。
StringReader用于读取字符串缓冲区。
StringWriter用于写入字符串缓冲区。

FileStream 类

System.IO 命名空间中的 FileStream 类有助于文件的读写与关闭。该类派生自抽象类 Stream。

您需要创建一个 FileStream 对象来创建一个新的文件，或打开一个已有的文件。例如，创建一个 FileStream 对象 F 来读取名为 sample.txt 的文件：

FileStream F = new FileStream("sample.txt", FileMode.Open, FileAccess.Read, FileShare.Read);

　　

参数描述
FileMode

FileMode 枚举定义了各种打开文件的方法。FileMode 枚举的成员有：

  • Append：打开一个已有的文件，并将光标放置在文件的末尾。如果文件不存在，则创建文件。
  • Create：创建一个新的文件。如果文件已存在，则删除旧文件，然后创建新文件。
  • CreateNew：指定操作系统应创建一个新的文件。如果文件已存在，则抛出异常。
  • Open：打开一个已有的文件。如果文件不存在，则抛出异常。
  • OpenOrCreate：指定操作系统应打开一个已有的文件。如果文件不存在，则用指定的名称创建一个新的文件打开。
  • Truncate：打开一个已有的文件，文件一旦打开，就将被截断为零字节大小。然后我们可以向文件写入全新的数据，但是保留文件的初始创建日期。如果文件不存在，则抛出异常。
FileAccess

FileAccess 枚举的成员有：Read、ReadWrite 和 Write。

FileShare

FileShare 枚举的成员有：

  • Inheritable：允许文件句柄可由子进程继承。Win32 不直接支持此功能。
  • None：谢绝共享当前文件。文件关闭前，打开该文件的任何请求（由此进程或另一进程发出的请求）都将失败。
  • Read：允许随后打开文件读取。如果未指定此标志，则文件关闭前，任何打开该文件以进行读取的请求（由此进程或另一进程发出的请求）都将失败。但是，即使指定了此标志，仍可能需要附加权限才能够访问该文件。
  • ReadWrite：允许随后打开文件读取或写入。如果未指定此标志，则文件关闭前，任何打开该文件以进行读取或写入的请求（由此进程或另一进程发出）都将失败。但是，即使指定了此标志，仍可能需要附加权限才能够访问该文件。
  • Write：允许随后打开文件写入。如果未指定此标志，则文件关闭前，任何打开该文件以进行写入的请求（由此进程或另一进过程发出的请求）都将失败。但是，即使指定了此标志，仍可能需要附加权限才能够访问该文件。
  • Delete：允许随后删除文件。
class Program
    {
        static void Main(string[] args)
        {
            FileStream F = new FileStream("test.dat", 
            FileMode.OpenOrCreate, FileAccess.ReadWrite);

            for (int i = 1; i <= 20; i++)
            {
                F.WriteByte((byte)i);
            }

            F.Position = 0;

            for (int i = 0; i <= 20; i++)
            {
                Console.Write(F.ReadByte() + " ");
            }
            F.Close();
            Console.ReadKey();
        }
    }

20、文本文件的读写

StreamReader 类（表示阅读器读取一系列字符）

序号方法 & 描述
1public override void Close()
关闭 StreamReader 对象和基础流，并释放任何与读者相关的系统资源。
2public override int Peek()
返回下一个可用的字符，但不使用它。
3public override int Read()
从输入流中读取下一个字符，并把字符位置往前移一个字符。

下面的实例演示了读取名为 Jamaica.txt 的文件。文件如下：

Down the way where the nights are gay
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

　　编译和执行上面的程序时，它会显示文件的内容。

static void Main(string[] args)
        {
            try
            {
                // 创建一个 StreamReader 的实例来读取文件 
                // using 语句也能关闭 StreamReader
                using (StreamReader sr = new StreamReader("c:/jamaica.txt"))
                {
                    string line;
                   
                    // 从文件读取并显示行，直到文件的末尾 
                    while ((line = sr.ReadLine()) != null)
                    {
                        Console.WriteLine(line);
                    }
                }
            }
            catch (Exception e)
            {
                // 向用户显示出错消息
                Console.WriteLine("The file could not be read:");
                Console.WriteLine(e.Message);
            }
            Console.ReadKey();
        }

StreamWriter 类（表示编写器写入一系列字符）

序号方法 & 描述
1public override void Close()
关闭当前的 StreamWriter 对象和基础流。
2public override void Flush()
清理当前编写器的所有缓冲区，使得所有缓冲数据写入基础流。
3public virtual void Write(bool value)
把一个布尔值的文本表示形式写入到文本字符串或流。（继承自 TextWriter。）
4public override void Write( char value ) 
把一个字符写入到流。
5public virtual void Write( decimal value ) 
把一个十进制值的文本表示形式写入到文本字符串或流。
6public virtual void Write( double value ) 
把一个 8 字节浮点值的文本表示形式写入到文本字符串或流。
7public virtual void Write( int value ) 
把一个 4 字节有符号整数的文本表示形式写入到文本字符串或流。
8public override void Write( string value ) 
把一个字符串写入到流。
9public virtual void WriteLine()
把行结束符写入到文本字符串或流。

使用 StreamWriter 类向文件写入文本数据：

string[] names = new string[] {"Zara Ali", "Nuha Ali"};
            using (StreamWriter sw = new StreamWriter("names.txt"))
            {
                foreach (string s in names)
                {
                    sw.WriteLine(s);

                }
            }

            // 从文件中读取并显示每行
            string line = "";
            using (StreamReader sr = new StreamReader("names.txt"))
            {
                while ((line = sr.ReadLine()) != null)
                {
                    Console.WriteLine(line);
                }
            }
            Console.ReadKey();

　　

 

 

 

 

 

 

 

 

 

---恢复内容结束---

转载于:https://www.cnblogs.com/paradise-of-sunshine/p/10302067.html

VB.NET 教程_02_常见对象
pre_eminent的JAVA学习园地
08-08 2182
VB.Net - 字符串   在VB.Net中，可以使用字符串作为字符数组，但是更常见的做法是使用String关键字声明一个字符串变量。 string关键字是System.String类的别名。 创建一个字符串对象 您可以使用以下方法之一创建字符串对象： By assigning a string literal to a String variable 通过指定一个字符串给一个...
《Visual C# 2012 从入门到精通》学习笔记
符江涛的博客
09-19 3700
第1部分 Visual C#和Visual Studio2012概述 第1章     欢迎进入C#编程世界 1.1        开始在Visual Studio 2012环境中编程 1.2        编写第一个程序 1.3        使用命名空间 作为好习惯，所有类都应该在命名空间中定义。例如，Console类在System命名空间中，它的全名为System.Console
Visual c#学习笔记
04-08
c#，asp.net学习笔记 是专业的资料对于想学习c#，asp.net的朋友又非常大的帮助，本书中每一章都配有丰富的源码及说明，对有有无开发经验的朋友都是值得以阅的资料
【C#】学习笔记2-Visual C#
weixin_41106066的博客
07-07 303
以下是通过按钮操作Label文字的例子，除了按钮事件均为自动生成 结构与Qt开发C++图形界面类似 Form1.cs，为组件设置函数 using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading.Tasks; usi
Visual C＃学习笔记光盘
05-24
Visual C＃学习笔记光盘 简介：本书由浅入深地讲解Visual C＃ 2005编程知识，全书内容分为6篇，共27章，第一篇介绍Visual Studio 2005开发环境和C＃基础，其中包括Visual C＃ 2005简介，C＃语言基础，面向对象编程基础，数组类和集合类，继承，线程和文件操作，以及处理错误和调试；第二篇介绍.NET与C＃核心技术，主要内容包括.NET框架，C＃.NET命名空间和程序集，字符处理，组件和部署；第三篇主要介绍Windows窗体程序，主要包括Windows窗体，WinForms高级控件，菜单和对话框，GDI+的应用和网络编程；第四篇主要介绍数据处理技术，主要包
C# 学习笔记（一）
khq溪风的博客
03-03 833
第一章 初识.NET框架 1.1 .NET框架的主要特点 （1）面向对象的开发环境 CLR、BCL以及C#是面向对象的，可以为桌面应用、移动应用以及web开发提供软件开发接口。 （2）自动垃圾回收机制 程序对象不再被使用时会被自动回收处理，程序员不用额外编写代码处理。 （3）互操作性 在一定的规则下允许不同.NET语言编写的程序模块进行交互。 （4）类型安全检查 CLR即公共语言运行库会检查确保参...
教程C#例子学习
weixin_42237615的博客
04-24 225
简单学习了C#的string，内部还有很多参数，可以看一看
Learning hard C# 学习笔记
04-01
总而言之，《Learning Hard C# 学习笔记》是一份全面的C#学习资源，它不仅覆盖了C#的基本语法和高级特性，还包含了实际开发中的应用场景，对于初学者来说是一份不可多得的参考资料。配合源码实践，相信你可以从零...
C#学习笔记
11-07
### C#学习笔记知识点解析 #### 面向对象编程的理解 标题中提到的“面向对象是本本主义、洁癖的体现”这句话反映了一种对面向对象编程（Object-Oriented Programming, OOP）的看法。面向对象编程是一种程序设计范式...
LearningHard C#学习笔记
03-04
LearningHard C#学习笔记，学习C#的经典入门教材。 非常适合初学者，希望大家一起努力。
C#梳理【字符串String】
09-11 875
在 C# 中，您可以使用字符数组来表示字符串，但是，更常见的做法是使用 string 关键字来声明一个字符串变量。string 关键字是 System.String 类的别名。 创建 String 对象 您可以使用以下方法之一来创建 string 对象： 通过给 String 变量指定一个字符串通过使用 String 类构造函数通过使用字符串串联运算符（ + ）通过检索属性或
[No0000EC]C# 字符串（String）
weixin_30339969的博客
04-20 434
在 C# 中，可以使用字符数组来表示字符串，但是，更常见的做法是使用string关键字来声明一个字符串变量。string 关键字是System.String类的别名。 创建 String 对象 可以使用以下方法之一来创建 string 对象： 通过给 String 变量指定一个字符串 通过使用 String 类构造函数 通过使用字符串串联运算符（ + ） 通过检索属性或调用...
c#中的Rank属性和GetUpperBound，GetLowerBound(0)方法
jiangxindu1的专栏
10-22 2846
今天使用数组的时候，用到了
汉诺塔的C语言简易实现（递归）
huhuhu1998的博客
10-17 586
汉诺塔问题 规则简述：有三个塔座，在第一个塔座上有n个直径大小不同的，从小到大依次标号为1，2，3……，n的圆盘。要求将所有圆盘移动至第三个塔座且仍按同样顺序叠排。（每次只能移动一个圆盘且任何时候不能将一个较大圆盘压在较小圆盘之上。） 那我们该如分析这个问题呢？ 无从下手之时，不妨我们先试着玩一下这个游戏。 我们将塔座分别编号为X （起始塔座），Y（辅助塔座），Z（目标塔座...
C#——把转义字符（\）当做普通字符处理
热门推荐
lmm0513的博客
03-20 1万+
C#中转义字符分两种，一种是\,一种是@。 string str2 = @"C:\Windows"; 等价于： string str3 = "C:\\Windows"; 但是如果我们字符串中的\都需要作为普通字符来处理时，单个使用转义字符将\转义为普通字符比较麻烦我们就可以只用@来实现 string str4 =...
c# string类型基本用法
IT技术猿猴的博客
09-12 3132
1)、Length：获得当前字符串中字符的个数 int ilength = namestr.Length; 2)、ToUpper():将字符转换成大写形式 str= str.ToUpper();////将字符串转换成大写形式 3)、ToLower():将字符串转换成小写形式 str= str.ToLower(); ////将字符串转换成小写形式 4)、Equals(strTwo,Strin...
C#字符串的几种常用方法
x91997301的博客
09-03 372
一、string关键字与StringBuilder类 C#字符串是使用string关键字声明的一个字符数组。字符串是使用引号声明的，如下例所示： strings="Hello,World!"; 字符串对象是“不可变的”，即它们一旦创建就无法更改。对字符串进行操作的方法实际上返回的是新的字符串对象。因此，出于性能方面的原因，大量的连接或其他涉及字符串的操作应当用StringBuilder类...
开发中遇到的问题
tingzhenge的博客
09-15 1099
开发中遇到的问题 枚举类型的处理方案 方案一：利用key取值的方法同步set值 1、定义一个新的字段用来存放枚举值所对应的字段描述 此处quarter是对应数据库字段的枚举值 @ApiModelProperty(value = "季度，枚举值：1，2，3，4四个值代表一年的Q1、Q2、Q3、Q4四个季度，代码里面可以定义成枚举") private Integer quarter; quarterName是自定的属性用来显示枚举值所对应的描述信息（数据库中无此字段） @ApiModelProperty(va
c#部分总结
yi_2333的博客
02-01 509
if...else   if(boolean_expression) {    /* 如果布尔表达式为真将执行的语句 */ } else {   /* 如果布尔表达式为假将执行的语句 */ } switch 语句     switch(expression) {     case constant-expression  :        stat
16天速成C#学习笔记
C#学习笔记（by sunyfun）作为一份个人网上整理制作的电子图书，显然是针对学习C#这门编程语言的入门与进阶指南。考虑到C#作为.NET框架的核心编程语言，广泛用于开发Windows应用程序、游戏开发（Unity引擎）、服务器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值