C#相关知识_firstordefaultasync

一、SingleOrDefaultAsync与FirstOrDefaultAsync的区别

SingleOrDefaultAsync只取一条数据，如果无数据则返回null，若rownum大于1则报异常。

FirstOrDefaultAsync取一条数据，如果无数据则返回null，若rownum大于1则返回第一行数据。

二、.ToUpper()、.ToLower()

1、ToUpper() 函数用来将小写字母转换为大写字母。

只有当参数 c 是一个小写字母，并且存在对应的大写字母时，这种转换才会发生。

如果转换成功，那么返回与 c 对应的大写字母；如果转换失败，那么直接返回 c（值未变）。
注意，返回值为 int 类型，你可能需要隐式或者显式地将它转换为 char 类型。

2、.ToLower() 函数用来将大写字母转换为小写字母。

三、.ToString()格式化 常用数据转化

1、百分比

int i = 400;
int j = 200;
string p = ((double)i / j).ToString("P");//结果：200.00%

p = string.Format("{0:p}",0.126) //结果：12.60%

2、指定小数点位置（四舍五入）

//保留整数位
double a = 3.52312;
string b = a.ToString("F0");//结果：4

double c = 3.49999;
string d = c.ToString("F0");//结果：3

//保留2位小数
double a = 3.516;
string b = a.ToString("F2");//结果：3.52
//保留6位小数
double a = 3.5161256;
string b = a.ToString("F6");//结果：3.516126

3、double转int 会自动四舍五入

double a = 3.52312;
a = Convert.ToInt32(a);//结果：4

double c = 3.49999;
c = Convert.ToInt32(c);//结果：3

4、数字前面补足0

int a = 1;
b = a.ToString("d8");//结果：00000001
b = a.ToString("d4");//结果：0001
b = a.ToString("d2");//结果：01

5、千分符

string b = "";
//C#中用最简单的方法把数字（不含小数）转换为千分位格式
b = 1234567.ToString("###,###");//结果：1,234,567
b = 1234567.ToString("N0");//结果：1,234,567

//C#中把数字转换成带两位小数的千分位字符（其中N2是保留2位小数，N3则是保留三位小数，保留小数会四舍五入）
b = String.Format("{0:N}", 1234567.891); //结果：1,234,567.89
b = String.Format("{0:N}", 1234567);     //结果：1,234,567.00   默认为两位小数，如果没有小数位，则小数位补两个0
b = String.Format("{0:N2}", 1234567.896);//结果：1,234,567.90

6、C货币

2.5.ToString("C");//结果：¥2.50

7、十进制数

25.ToString("D5");//结果：00025

四、ToString()参数中格式解析大全

formatCode 是可选的格式化代码字符串。（详细内容请搜索“格式化字符串”查看）
必须用“{”和“}”将格式与其他字符分开。如果恰好在格式中也要使用大括号，可以用连续的两个大括号表示一个大括号，即： “{{”或者“}}”。
常用格式举例：
（1） int i=12345;
this.textBox1.Text=i.ToString();
//结果 12345（this指当前对象，或叫当前类的实例）
this.textBox2.Text=i.ToString("d8");
//结果 00012345
（2） int i=123;
double j=123.45;
string s1=string.Format("the value is {0,7:d}",i);
string s2=string.Format("the value is {0,7:f3}",j);
this.textBox1.Text=s1 ;
//结果 the value is 123
this.textBox2.Text=s2;
//结果 the value is 123.450
（3）double i=12345.6789;
this.textBox1.Text=i.ToString("f2"); //结果 12345.68
this.textBox2.Text=i.ToString("f6");
//结果 12345.678900
（4）double i=12345.6789;
this.textBox1.Text=i.ToString("n"); //结果 12,345.68
this.textBox2.Text=i.ToString(“n4”); //结果 12,345.6789
（5）double i=0.126;
string s=string.Format("the value is {0:p}",i);
this.textBox1.Text=i.ToString("p"); //结果 12.6%
this.textBox2.Text=s; //结果 the value is 12.6%
（6） DateTime dt =new DateTime(2003,5,25);
this.textBox1.Text=dt.ToString("yy.M.d");
//结果 03.5.25
this.textBox2.Text=dt.ToString(“yyyy年M月”);
//结果 2003年5月
Convert.ToDateTime("2005/12/22 22:22:22").ToString("yyyy/MM/dd HH:mm:ss")
"2005/12/22 22:22:22"
（7） int i=123;
double j=123.45;
string s=string.Format("i:{0,-7},j:{1,7}",i,j);
//-7表示左对齐，占7位
this.textBox1.Text=s ;
//结果i:123 ,j: 123.45
DateTime.ToString()用法详解
我们经常会遇到对时间进行转换,达到不同的显示效果，默认格式为:2006-6-6 14:33:34
如果要换成成200606,06-2006,2006-6-6或更多的格式该怎么办呢？
这里将要用到:DateTime.ToString的方法(String, IFormatProvider)
示例：
using System;
using System.Globalization;
String format="D";
DateTime date=DataTime.Now;
Response.Write(date.ToString(format, DateTimeFormatInfo.InvariantInfo));
结果输出
Thursday, June 16, 2006

在这里列出了参数format格式详细用法
=======================
格式字符 关联属性/说明
d ShortDatePattern
D LongDatePattern
f 完整日期和时间（长日期和短时间）
F FullDateTimePattern（长日期和长时间）
g 常规（短日期和短时间）
G 常规（短日期和长时间）
m、M MonthDayPattern
r、R RFC1123Pattern
s 使用当地时间的 SortableDateTimePattern（基于 ISO 8601）
t ShortTimePattern
T LongTimePattern
u UniversalSortableDateTimePattern 用于显示通用时间的格式
U 使用通用时间的完整日期和时间（长日期和长时间）
y、Y YearMonthPattern
下表列出了可被合并以构造自定义模式的模式
========================================
这些模式是区分大小写的；例如，识别“MM”，但不识别“mm”。如果自定义模式包含空白字符或用单引号括起来的字符，则输出字符串页也将包含这些字符。未定义为格式模式的一部分或未定义为格式字符的字符按其原义复制。
格式模式 说明 ：
d 月中的某一天。一位数的日期没有前导零。
dd 月中的某一天。一位数的日期有一个前导零。
ddd 周中某天的缩写名称，在 AbbreviatedDayNames 中定义。
dddd 周中某天的完整名称，在 DayNames 中定义。
M 月份数字。一位数的月份没有前导零。
MM 月份数字。一位数的月份有一个前导零。
MMM 月份的缩写名称，在 AbbreviatedMonthNames 中定义。
MMMM 月份的完整名称，在 MonthNames 中定义。
y 不包含纪元的年份。如果不包含纪元的年份小于 10，则显示不具有前导零的年份。
yy 不包含纪元的年份。如果不包含纪元的年份小于 10，则显示具有前导零的年份。
yyyy 包括纪元的四位数的年份。
gg 时期或纪元。如果要设置格式的日期不具有关联的时期或纪元字符串，则忽略该模式。
h 12 小时制的小时。一位数的小时数没有前导零。
hh 12 小时制的小时。一位数的小时数有前导零。
H 24 小时制的小时。一位数的小时数没有前导零。
HH 24 小时制的小时。一位数的小时数有前导零。
m 分钟。一位数的分钟数没有前导零。
mm 分钟。一位数的分钟数有一个前导零。
s 秒。一位数的秒数没有前导零。
ss 秒。一位数的秒数有一个前导零。
f 秒的小数精度为一位。其余数字被截断。
ff 秒的小数精度为两位。其余数字被截断。
fff 秒的小数精度为三位。其余数字被截断。
ffff 秒的小数精度为四位。其余数字被截断。
fffff 秒的小数精度为五位。其余数字被截断。
ffffff 秒的小数精度为六位。其余数字被截断。
fffffff 秒的小数精度为七位。其余数字被截断。
t 在 AMDesignator 或 PMDesignator 中定义的 AM/PM 指示项的第一个字符（如果存在）。
tt 在 AMDesignator 或 PMDesignator 中定义的 AM/PM 指示项（如果存在）。
z 时区偏移量（“+”或“-”后面仅跟小时）。一位数的小时数没有前导零。例如，太平洋标准时间是“-8”。
zz 时区偏移量（“+”或“-”后面仅跟小时）。一位数的小时数有前导零。例如，太平洋标准时间是“-08”。
zzz 完整时区偏移量（“+”或“-”后面跟有小时和分钟）。一位数的小时数和分钟数有前导零。例如，太平洋标准时间是“-08:00”。
: 在 TimeSeparator 中定义的默认时间分隔符。
/ 在 DateSeparator 中定义的默认日期分隔符。
% c 其中 c 是格式模式（如果单独使用）。如果格式模式与原义字符或其他格式模式合并，则可以省略“%”字符。
\ c 其中 c 是任意字符。照原义显示字符。若要显示反斜杠字符，请使用“\\”。
只有上面第二个表中列出的格式模式才能用于创建自定义模式；在第一个表中列出的标准格式字符不能用于创建自定义模式。自定义模式的长度至少为两个字符；例如，
DateTime.ToString( "d") 返回 DateTime 值；“d”是标准短日期模式。
DateTime.ToString( "%d") 返回月中的某天；“%d”是自定义模式。
DateTime.ToString( "d ") 返回后面跟有一个空白字符的月中的某天；“d”是自定义模式。
比较方便的是,上面的参数可以随意组合,并且不会出错,多试试,肯定会找到你要的时间格式
如要得到2005年06月 这样格式的时间
可以这样写:
date.ToString("yyyy年MM月", DateTimeFormatInfo.InvariantInfo)
如此类推.

下面列出一些Asp.net中具体的日期格式化用法：
============================================
1.绑定时格式化日期方法:

2.数据控件如DataGrid/DataList等的件格式化日期方法:
e.Item.Cell[0].Text = Convert.ToDateTime(e.Item.Cell[0].Text).ToShortDateString();
3.用String类转换日期显示格式:
String.Format( "yyyy-MM-dd ",yourDateTime);
4.用Convert方法转换日期显示格式:
Convert.ToDateTime("2005-8-23").ToString
("yyMMdd",System.Globalization.DateTimeFormatInfo.InvariantInfo); //支持繁体数据库
5.直接用ToString方法转换日期显示格式:
DateTime.Now.ToString("yyyyMMddhhmmss");
DateTime.Now.ToString("yyyy/MM/dd hh:mm:ss")
6.只显示年月
DataBinder.Eval(Container.DataItem,"starttime","{0:yyyy-M}")
7.显示时间所有部分，包括：年月日时分秒
DataFormatString='{0:yyyy-MM-dd HH24:mm:ss}'>
用DateTime.ToString(string format)输出不同格式的日期

DateTime.ToString()函数有四个重载。一般用得多的就是不带参数的那个了。殊不知，DateTime.ToString(string format)功能更强大，能输出不同格式的日期。以下把一些情况罗列出来，供大家参考。有些在MSDN上有的就没有列出来了。
1.         y代表年份，注意是小写的y，大写的Ｙ并不代表年份。
2.         M表示月份。
3.         d表示日期，注意D并不代表什么。
4.         h或H表示小时，h用的是12小时制，H用的是24小时制。
5.         m表示分钟。
6.         s表示秒。注意S并不代表什么。

五、"ToString"方法没有任何重载采用“1个参数”

解决：

 

六、 C#中(int)、int.Parse()、int.TryParse()和Convert.ToInt32()的区别

1、对于转换对象，Convert.ToInt32()可以为多种类型（例出数字类型外bool，DateTime等），int.TryParse()和int.Parse()只能是整型字符串类型（即各种整型ToString()之后的形式，不能为浮点型，否则int.Parse()就会出现输入的字符串格式不正确的错误，int.TryParse()也会返回false，输出参数为0），(int)只能是数字类型（例float,int,uint等）；

2、对于空值NULL，从运行报错的角度讲，(int)强制转换和int.Parse()都不能接受NULL；Convert.ToInt32()其实是在转换前先做了一个判断，参数如果为NULL，则直接返回0，否则就调用int.Parse()进行转换，int.TryParse()其实是对int.Parse()做了一个异常处理，如果出现异常则返回false，并且将输出参数返回0；

3、针对于浮点型的取舍问题，浮点型只有Convert.ToInt32()和(int)能进行转换，但是也是进行取舍了的，Convert.ToInt32()采取的取舍是进行四舍五入，而(int)则是截取浮点型的整数部分，忽略小数部分，例如Convert.ToInt32(1.499d)和(int)1.499d都返回1，Convert.ToInt32(1.5d)返回2，而(int)1.5d还是返回1；

4、关于溢出，将大的数据类型转换为小的数据类型时Convert.ToInt32()和int.Parse()都会报溢出错误，值对于Int32太大或太小，而(int)不报错，但是返回值为-1。

如此可见，我们在进行数据转换前选择转换方法要谨慎，如果是数字类型可以考虑直接用(int)强制转换，如果是整型字符串类型的，考虑用int.Parse()进行转换，如果不是这两种类型，再考虑用Convert.ToInt32()进行转换。

七、C#中Toint16 Toint32 Toint64 有什么区别

区别：转换成的数值范围不同。

Int16 表示 16 位有符号的整数，用2个字节来存储。数值范围：-32768 到 32767；
Int32 表示 32 位有符号的整数，是用4个字节来存储。数值范围：-2147483648 到 2147483647；
Int64 表示 64 位有符号的整数，是用8个字节来存储。数值范围：-9223372036854775808 到 9223372036854775808；

其他函数

1、Convert.ToChar()    转换为字符型(char)

2、Convert.ToString()    转换为字符串型(string)

3、Convert.ToDateTime()    转换为日期型(datetime)

4、Convert.ToDouble()    转换为双精度浮点型(double)

5、Conert.ToSingle()    转换为单精度浮点型(float)

八、compareTo()方法

1、返回参与比较的前后两个字符串的ASCII码的差值，如果两个字符串首字母不同，则该方法返回首字母的ASCII码的差值。

String a1 = "a";
String a2 = "c";        
System.out.println(a1.compareTo(a2));//结果为-2

2、参与比较的两个字符串如果首字符相同，则比较下一个字符，直到有不同的为止，返回该不同的字符的asc码差值。

String a1 = "aa";
String a2 = "ad";        
System.out.println(a1.compareTo(a2));//结果为-3

3、如果两个字符串不一样长，可以参与比较的字符又完全一样，则返回两个字符串的长度差值。

String a1 = "aa";
String a2 = "aa12345678";        
System.out.println(a1.compareTo(a2));//结果为-8

4、返回为正数表示a1>a2, 返回为负数表示a1<a2, 返回为0表示a1==a2。
5、int型可以直接比较，所以没有用到compareTo比较，如果声明的是Date、String、Integer、或者其他的，可以直接使用compareTo比较。

Integer n1 = 5;
Integer n2 = 6;
System.out.println(n1.compareTo(n2));//-1  

九、Task.FromResult的使用

Task.FromResult用来创建一个带返回值的、已完成的Task。

场景一：以同步的方式实现一个异步接口方法

比如有一个接口包含异步方法。

interface IMyInterface

{

	Task<int> DoSthAsync();

}

现在，需要以同步的方式实现该接口方法DoSthAsync，但要返回异步的结果。这正是Task.FromResult的用武之地。

public class MyClass : IMyInterface

{

	public Task<int> DoSthAsync()

	{

		int result = 1;

		return Task.FromResult(result);

	}

}

以上，在实现类MyClass的DoSthAsync方法中，都是以同步方式实现，但返回结果要是Task<int>,使用Task.FromResult刚好能返回一个带值的异步结果。

场景二：从缓存中获取值，以同步或者异步的方式实现

假设需要根据key从缓存中获取值，如果每个key对应的缓存不存在，就需要以异步的方式获取缓存，如果存在，就直接中缓存中获取值。

写一个异步获取缓存的方法。

private async Task<string> GetValueAsync(int key)

{

	string result = await SomeAsyncMethod();

	cache.TrySetValye(key, result);

	return result;

}

现在需要写一个方法用来获取缓存中的值，有可能是异步方式，也有可能是同步的方式(从本地缓存中获取)。

public Task<string> GetValueFromCache(int key)

{

	string result = string.Empty;

	if(cache.TryGetValue(key, out result))

	{

		return Task.FromResult(result);

	}

	return GetValueAsync(key);

}

以上，从本地缓存中获取值是同步的方式，但方法返回的类型是异步的Task，通过Task.FromResult(result)返回了异步结果。

另外，如果使用Task.FromResult不带返回值，就使用Task.FromResult(0) 或 Task.FromResult(null)。

十、IList<T>、List<T>、ArrayList、IList、ICollection、IEnumerable、IEnumerator、IQueryable、IEnumerable的区别

在C#中，数组、ArrayList都能够存储一组对象，那么三者到底有什么样的区别呢？

1、数组

数组在C#中最早出现的。在内存中是连续的，所以它的索引速度非常快，而且赋值与修改元素也很简单。

string[] s=new string[2];

//赋值
s[0]="a";
s[1]="b";
//修改
s[1]="a1";

        但是数组存在一些不足的地方。在数组的两个数据间插入数据是非常麻烦的，而且在声明数组的时候必须指定数组的长度，数组的长度过长会造成内存浪费，过短会造成数据溢出。如果在声明数组时我们不清楚数组的长度就会很麻烦。

2、ArrayList

        针对数组的这些缺点，C#中最先提供了ArrayList对象来解决这些问题。

        ArrayList是命名空间System.Collections下的一部分，在使用该类时必须进行引用，同时继承了IList接口，提供了数据存储和检索。ArrayList对象的大小是按照存储的数据来动态扩充与收缩的。所以在声明ArrayList对象时并不需要指定它的长度。

ArrayList list1 = new ArrayList();  
  
//新增数据  
list1.Add("cde");  
list1.Add(5678);  
  
//修改数据  
list[2] = 34;  
  
//移除数据  
list.RemoveAt(0);  
  
//插入数据  
list.Insert(0, "qwe");  

        从上面的例子看，ArrayList好像解决了数组中所有的缺点，为什么又会有List?

       我们从上面的例子看，在List中，我们不仅插入了字符串cde，而且插入了数字5678。这样在ArrayList中插入不同类型的数据是允许的。因为ArrayList会把插入其中的数据当object类型来处理，在我们使用ArrayList处理数据时，很可能会报类型不匹配的错误，也就是ArrayList不是类型安全的。在存储或检索值类型时通常发生装箱和取消装箱的操作，带来很大的性能损耗。

       装箱与拆箱的概念：

       简单的说：

       装箱：就是将值类型的数据打包到引用类型的实例中

       比如将string类型的值赋值abc赋给object对象obj。

String  i=”abc”;  
object obj=(object)i;  

        拆箱：就是从引用数据中提取值类型

       比如将object对象obj的值赋值给string类型的变量i

object obj=”abc”;  
string i=(string)obj;

         装箱与拆箱的操作是非常耗性能的。

3、泛型List

        因为ArrayList存在不安全类型与装箱拆箱的缺点，所以出现了泛型的概念。List类是ArrayList类的泛型等效类，它的大部分用法都与ArrayList相似，因为List类也继承了IList接口。最关键的区别在于，在声明List集合时，我们同时需要为其声明List集合内的对象类型。

List<string> list = new List<string>();  
  
//新增数据  
list.Add(“abc”);  
  
//修改数据  
list[0] = “def”;  
  
//移除数据  
list.RemoveAt(0);  

        上例中如果我们往List集合中插入int数组123，IDE就会报错，且不能通过编译。这样就避免了前面讲的类型安全问题与装箱拆箱的性能问题了。

总结：

        数组的容量是固定的，只能一次获取或设置一个元素的值，而ArrayList或List<T>的容量可根据需要自动扩充、修改、删除、或插入数据。

      数组可以具有多个维度，而ArrayhuoList<T>始终只有一个维度。但是，可以轻松的创建数组列表或列表的列表。特定类型（Object除外）的数组的性能优于ArrayList的性能。这事因为ArrayList的元素属于Object类型；所以在存储或检索值类型时通常发生装箱和拆箱的操作。不过，在不需要重新分配时（即最初容量十分接近列表的最大容量），List<T>的性能与同类型的数组十分相近。

      在决定使用List<T>还是使用ArrayList类（两者具有相似的功能）时，记住List<T>类在大多数情况下执行的更好并且是类型安全的。如果对List<T>类的类型T使用引用类型，则两个类的行为是完全相同的。但是，如果对类型T使用值类型，则需要考虑实现和装箱的问题。

十一、C#SerialPort详细用法

转自：serialport控件的详细用法 - 火腿骑士 - 博客园

1、简介
        随着USB的流行，串口通讯已经应用到日常生活的很多方面了，USB是一种高速的串口通讯协议，USB接口非常复杂，通常被用在需要传输大量数据数据的地方，如U盘、相机、打印机等。除了USB这种较为奢侈的串口外，在工控和嵌入式行业，大量被使用的是另一种古老的串口协议，RS-232串口。RS-232是一种非常简洁的低速串口通讯接口，它可以同时进行数据接收和发送的工作。
2、.NET 2.0对串口的支持
        .NET 2.0提供了对串口通信功能的支持，有关类可以在命名空间System.IO.Ports下找到，这其中最为重要的是SerialPort类。
通过创建一个新的SerialPort 对象，我们就可以在.NET程序中控制串口通讯的全过程。
3、使用 SerialPort 设置串口属性
        进行串口通讯时，需要设置一些相关参数，可以通过设置SerialPort 类的属性来进行。串口属性主要包括
.PortName 串口名称，COM1, COM2等。
.BaudRate 波特率，也就是串口通讯的速度，进行串口通讯的双方其波特率需要相同，如果用PC连接其他非PC系统，一般地，波特率由非PC系统决定。
.Parity 奇偶校验。可以选取枚举Parity中的值
.DataBits 数据位
.StopBits 停止位，可以选取枚举StopBits中的值
.Handshake 握手方式，也就是数据流控制方式，可以选取枚举Handshake中的值
4、打开与关闭串口
        在创建一个SerialPort 对象，设置串口属性后，可以通过 Open()方法打开串口。数据读写完成后，可以通过Close()方法关闭串口。
        根据经验，对于有些系统，在打开串口后，还需要将RtsEnable设置为True，这样才能读写数据，否则不能正常读写数据。
5、读写行数据
        双方通讯时，一般都需要定义通讯协议，即使最简单的通过串口发送文本聊天的程序。
        通常是在当一方按下回车时，将其所数据的文本连同换行符发给另一方。在这个通讯事例中，协议桢是通过换行符界定的，每一桢数据都被换行符隔开，这样就很容易识别出通讯双发发送的信息。
        在以上的例子中，可以用WriteLine()来发送数据，用ReadLine()来读取数据。WriteLine发送完数据后，会将换行符作为数据也发送给对方。ReadLine()读取数据时，直至遇到一个换行符，然后返回一个字符串代表一行信息。换行符可以通过SerialPort 的属性NewLine来设置。一般地，Windows将CrLn作为换行符，而在Linux下，换行符则只用一个Ln表示。
        ReadLine()方法是阻塞的，直至遇到一个换行符后返回。在读取数据时，如果一直没有遇到换行符，那么在等待ReadTimeout时间后，抛出一个TimeoutException。默认情况下，ReadTimeout为InfiniteTimeout。这样，ReadLine一直处于阻塞状态，直至有新一行数据到达。
        WriteLine()方法也是阻塞的，如果另一方不能及时接收数据，就会引起TimeoutException异常。
        由于ReadLine()和WriteLine()方法都是阻塞式的，在程序使用SerialPort 进行串口通讯时，一般应该把读写操作交由其他线程处理，避免因为阻塞而导致程序不响应。
6、读写字节或字符数据
        对于字节或字符数据，用Read()方法来读数据，该方法需要一个字节或字符数组作为参数来保存读取的数据，结果返回实际读取的字节或字符数。写数据使用Write()方法，该方法可以将字节数组、字符数据或字符串发送给另一方。
        如果通讯双方交换的数据位字节流数据，要构建一个使用的串口通讯程序，那么双方应该定义数据桢格式。通常数据桢由桢头和桢尾来界定。
        发送数据比较简单，只需要将构造好的数据用Write()方法发送出去即可。
        接收数据则比较复杂，通讯是以字节流的形式到达的，通过调用一次Read()方法并不能确保所读取的数据就是完整一桢。因此需要将每次读取的数据整合在一起，对整合后的数据进行分析，按照定义的桢格式，通过桢头和桢尾，将桢信息从字节流中抽取出来，这样才能获取有意义的信息。
        除了利用Read()方法来读数据，还可以使用ReadExisting()方法来读取数据。该方法读取当前所能读到的数据，以字符串的形式返回。
7、事件
        SerialPort 提供了DataReceived事件。当有数据进入时，该事件被触发。该事件的触发由操作系统决定，当有数据到达时，该事件在辅助线程中被触发。辅助线程的优先级比较低，因此并不能确保每个字节的数据到达时，该事件都被触发。
        在使用该事件接收数据时，最好对定义通讯协议格式，添加桢头和桢尾。在DataReceived事件中接收数据时，把数据放在数组中或字符串中缓冲起来，当接收的包含桢头和桢尾的完整数据时，在进行处理，另外，为了有效地接收数据，可以在每次读取数据后，加入System.Threading.Thread.Sleep方法进行演示。
8、其他
       用跳线使串口的第2、3针连接，可以在本地计算机上实现串口通信，所以，通过串口的第2、3针的连接可以对程序进行检测。
      .BytesToRead 该属性返回能够读到的字节数。

属性说明

十二、LINQ语法

1、简单的linq语法

//1
var ss = from r in db.Am_recProScheme
         select r;
//2
var ss1 = db.Am_recProScheme;
//3
string sssql = "select * from Am_recProScheme";

2、带where的查询

//1
var ss = from r in db.Am_recProScheme
         where r.rpId > 10
         select r;
//2
var ss1 = db.Am_recProScheme.Where(p => p.rpId > 10);
//3
string sssql = "select * from Am_recProScheme where rpid>10";

3、简单的函数计算（count，min，max，sum）

//1
获取最大的rpId
//var ss = (from r in db.Am_recProScheme
//          select r).Max(p => p.rpId);
获取最小的rpId
//var ss = (from r in db.Am_recProScheme
//          select r).Min(p => p.rpId);
//获取结果集的总数
//var ss = (from r in db.Am_recProScheme                  
//         select r).Count();
//获取rpId的和
var ss = (from r in db.Am_recProScheme
          select r).Sum(p => p.rpId);


//2
//var ss1 = db.Am_recProScheme.Max(p=>p.rpId);
//var ss1 = db.Am_recProScheme.Min(p => p.rpId);
//var ss1 = db.Am_recProScheme.Count() ;
var ss1 = db.Am_recProScheme.Sum(p => p.rpId);
Response.Write(ss);

//3
string sssql = "select max(rpId) from Am_recProScheme";
       sssql = "select min(rpId) from Am_recProScheme";
       sssql = "select count(1) from Am_recProScheme";
       sssql = "select sum(rpId) from Am_recProScheme";

4、排序order by desc/asc

var ss = from r in db.Am_recProScheme
         where r.rpId > 10
         orderby r.rpId descending  //倒序
         //  orderby r.rpId ascending   //正序
         select r;
//正序
var ss1 = db.Am_recProScheme.OrderBy(p => p.rpId).Where(p => p.rpId > 10).ToList();
//倒序
var ss2 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Where(p => p.rpId > 10).ToList();
string sssql = "select * from Am_recProScheme where rpid>10 order by rpId [desc|asc]";

5、top(1)

//如果取最后一个可以按倒叙排列再取值
var ss = (from r in db.Am_recProScheme
          select r).FirstOrDefault();
//（）linq to ef 好像不支持 Last() 
var ss1 = db.Am_recProScheme.FirstOrDefault();
//var ss1 = db.Am_recProScheme.First();          
string sssql = "select top(1) * from Am_recProScheme";

6、跳过前面多少条数据取余下的数据

//1
var ss = (from r in db.Am_recProScheme
          orderby r.rpId descending
          select r).Skip(10); //跳过前10条数据，取10条之后的所有数据   
//2  
var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Skip(10).ToList();
//3
string sssql = "select * from  (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum>10";

7、分页数据查询

//1
var ss = (from r in db.Am_recProScheme
          where r.rpId > 10
          orderby r.rpId descending
          select r).Skip(10).Take(10); //取第11条到第20条数据
//2 Take(10): 数据从开始获取，获取指定数量（10）的连续数据
var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Where(p => p.rpId > 10).Skip(10).Take(10).ToList();
//3
string sssql = "select * from  (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum>10 and rowNum<=20";

8、包含，类似like '%%'

//1
var ss = from r in db.Am_recProScheme
         where r.SortsText.Contains("张")
         select r;
//2
var ss1 = db.Am_recProScheme.Where(p => p.SortsText.Contains("张")).ToList();
//3
string sssql = "select * from Am_recProScheme where SortsText like '%张%'";

9、分组group by

//1
var ss = from r in db.Am_recProScheme
         orderby r.rpId descending
         group r by r.recType into n
         select new
         {
             n.Key,  //这个Key是recType
             rpId = n.Sum(r => r.rpId), //组内rpId之和
             MaxRpId = n.Max(r => r.rpId),//组内最大rpId
             MinRpId = n.Min(r => r.rpId), //组内最小rpId
         };
foreach (var t in ss)
{
    Response.Write(t.Key + "--" + t.rpId + "--" + t.MaxRpId + "--" + t.MinRpId);
}
//2
var ss1 = from r in db.Am_recProScheme
         orderby r.rpId descending
         group r by r.recType into n
         select n;
foreach (var t in ss1)
{
    Response.Write(t.Key + "--" + t.Min(p => p.rpId));
}
//3
var ss2 = db.Am_recProScheme.GroupBy(p => p.recType);
foreach (var t in ss2)
{
    Response.Write(t.Key + "--" + t.Min(p => p.rpId));
}
//4
string sssql = "select recType,min(rpId),max(rpId),sum(rpId) from Am_recProScheme group by recType";

10、sql中的In

//Linq
var ss = from p in db.Am_recProScheme
                  where (new int?[] { 24, 25,26 }).Contains(p.rpId)
                  select p;
foreach (var p in ss)
{
    Response.Write(p.Sorts);
}
//SQL
string st = "select * from Am_recProScheme where rpId in(24,25,26)";

11、内连接 INNER JOIN

//Linq
var ss = from r in db.Am_recProScheme
         join w in db.Am_Test_Result on r.rpId equals w.rsId
         orderby r.rpId descending
         select r;
//Lambda
var ss1 = db.Am_recProScheme.Join(db.Am_Test_Result, p => p.rpId, r => r.rsId, (p, r) => p).OrderByDescending(p => p.rpId).ToList();
//SQL
string sssql = "select r.* from  [Am_recProScheme] as r inner join [dbo].[Am_Test_Result] as t on r.[rpId] = t.[rsId] order by r.[rpId] desc";

12、左连接 LEFT JOIN

//两个DataTable关联，查找只在第一个表中的数据
static void Main(string[] args)
{
    DataTable dt1 = new DataTable("Ta");
    DataTable dt2 = new DataTable("Tb");
    dt1.Columns.Add("ID", typeof(int));
    dt1.Columns.Add("Name", typeof(string));
    dt1.Rows.Add(1, "小明");
    dt1.Rows.Add(2, "小红");
    dt1.Rows.Add(3, "小黑");
    dt2.Columns.Add("ID", typeof(int));
    dt2.Columns.Add("Name", typeof(string));
    dt2.Rows.Add(1, "小黄");
    dt2.Rows.Add(2, "小红");
    dt2.Rows.Add(3, "小强");
    //方法一：Linq
    //var query = from q1 in dt1.AsEnumerable()
    //            join q2 in dt2.AsEnumerable()
    //            on q1.Field<string>("Name") equals q2.Field<string>("Name") into tmp
    //            from q3 in tmp.DefaultIfEmpty()
    //            where q3 == null
    //            select new
    //            {
    //                ID = q1.Field<int>("ID"),
    //                Name = q1.Field<string>("Name")
    //            };
    //方法二：Lambda
    var query = dt1.AsEnumerable().GroupJoin(
        dt2.AsEnumerable(),
        x => x.Field<string>("Name"),
        y => y.Field<string>("Name"),
        (x, y) => y.DefaultIfEmpty(). Where(w => w == null).
        Select(z => new { ID = x.Field<int>("ID"), Name = x.Field<string>("Name") })
        ).SelectMany(x => x);
    foreach (var item in query)
    {
        Console.WriteLine($"ID={item.ID}    Name={item.Name}");
    }
    Console.Read();
}

13、实例用法

//数据库 + 自定义名称 =new 数据库
mydbDataContext con = new mydbDataContext();
//模糊查询表达式中用.Contains
con.car.Where(r=>r.name.Contains(TextBox1.Text.Trim())).ToList(）;
//开头查用.StartWith
con.car.Where(r => r.name.StartsWith(TextBox1.Text)).ToList();
//结尾查用.EndWith
con.car.Where(r => r.name.EndsWith(TextBox1.Text)).ToList();
//最大值
con.car.Max(r => r.price * r.oil).ToString();
//最小值
con.car.Min(r => r.price).ToString();
//求和
con.car.Sum(r => r.price).ToString();
//平均值
con.car.Average(r => r.price).ToString();
//升序：
con.car.OrderBy(r => r.price).ToList();
//降序：
con.car.OrderByDescending(r => r.price).ToList();

//上一页，下一页，组合查询：
int PageCount = 5;//每页显示条数
//上一页，PageCount_Label.Text为当前页码
int pageNum = Convert.ToInt32(PageCount_Label.Text) - 1;
Repeater1.DataSource = con.car.Skip((pageNum - 1) * PageCount).Take(PageCount);
Repeater1.DataBind(); 
PageCount_Label.Text = pageNum.ToString();
//下一页
int pageNum = Convert.ToInt32(PageCount_Label.Text) + 1;
Repeater1.DataSource = con.car.Skip((pageNum - 1) * PageCount).Take(PageCount);
Repeater1.DataBind();
PageCount_Label.Text = pageNum.ToString();
//组合查询的点击事件
List<car> list = con.car.ToList();
if (TextBox2.Text != "")
{
    List<car> list1 = con.car.Where(r => r.name.Contains(TextBox2.Text)).ToList();
    list = list.Intersect(list1).ToList();
}
if (TextBox3.Text != "")
{
    List<car> list1 = con.car.Where(r => r.oil == Convert.ToDecimal(TextBox3.Text)).ToList();
    list = list.Intersect(list1).ToList();
}
if (TextBox4.Text != "")
{
    List<car> list1 = con.car.Where(r => r.powers == Convert.ToInt32(TextBox4.Text)).ToList();
    list = list.Intersect(list1).ToList();
}
Repeater1.DataSource = list;
Repeater1.DataBind();

十三、LINQ中的Join

Linq中连接主要有组连接、内连接、左外连接、交叉连接四种。

1、 组连接

    组连接是与分组查询是一样的。即根据分组得到结果。 如下例,根据publisther分组得到结果。

    使用组连接的查询语句如下：

            //使用组连接
            var GroupQuery = from publisher in SampleData.Publishers
                             join book in SampleData.Books
                                  on publisher equals book.Publisher into publisherBooks
                             select new
                             {
                                 PublisherName = publisher.Name,
                                 Books = publisherBooks
                             };

    与上边等同的GroupBy语句如下：

            //使用Group
            var QueryByGroup = from book in SampleData.Books
                        group book by book.Publisher into grouping
                        select new
                        {
                            PublisherName = grouping.Key.Name,
                            Books = grouping
                        };

2、内连接

    内连接与SqL中inner join一样，即找出两个序列的交集。如下例找出book中的Publisher存在于SampleData.Publishers的资料。

    内连接查询语句如下：

            //join查询语句
            var joinQuery = from publisher in SampleData.Publishers
                            join book in SampleData.Books
                                on publisher equals book.Publisher
                            select new
                            {
                                PublisherName = publisher.Name,
                                BookName = book.Title
                            };

    与上边等同的查询操作符语句如下：

            //join操作符语句
            SampleData.Publishers.Join(
                SampleData.Books,               //join 对象
                publisher => publisher,         //外部的key
                book => book.Publisher,         //内部的key
                (publisher, book) => new        //结果
                {
                    PublisherName = publisher.Name,
                    BookName = book.Title
                });

3、左外连接

     左外连接与SqL中left join一样。如下例找出根据publisher中找出SampleData.Publishers中所有资料和book中存在于publisher的资料。

     左外连接查询语句如下：

            //left join, 为空时用default
            var leftJoinQuerybyDefault = from publisher in SampleData.Publishers
                                         join book in SampleData.Books
                                           on publisher equals book.Publisher into publisherBooks
                                         from book in publisherBooks.DefaultIfEmpty()
                                         select new
                                         {
                                             PublisherName = publisher.Name,
                                             BookName = (book == default(Book)) ? "no book" : book.Title
                                         };

     注：上例中使用了DefaultIfEmpty操作符，它能够为实序列提供一个默认的元素。DefaultIfEmpty使用了泛型中的default关键字。default关键字对于引用类型将返回null,而对于值类型则返回0。对于结构体类型，则会根据其成员类型将它们相应地初始化为null(引用类型)或0(值类型)。

    我们可以不使用default关键字，但在要DefaultIfEmpty中给定当空时的默认对象值。语句如下：

            //left join, 为空时使用默认对象
            var leftJoinQuery = from publisher in SampleData.Publishers
                                        join book in SampleData.Books
                                          on publisher equals book.Publisher into publisherBooks
                                        from book in publisherBooks.DefaultIfEmpty(
                                        new Book { Title = "" }                         //设置为空时的默认值
                                        )
                                        select new
                                        {
                                            PublisherName = publisher.Name,
                                            BookName = book.Title
                                        };

4、交叉连接

    交叉连接与SqL中Cross join一样。如下例中找出SampleData.Publishers与SampleData.Books的交叉连接。

    交叉连接查询语句：

            var crossJoinQuery = from publisher in SampleData.Publishers
                                 from book in SampleData.Books
                                 select new
                                 {
                                     PublisherName = publisher.Name,
                                     BookName = book.Title
                                 };

    查询操作符语句：

            //不使用查询表达式
            SampleData.Publishers.SelectMany(publisher => SampleData.Books.Select(
                book => new
                {
                    PublisherName = publisher.Name,
                    BookName = book.Title
                }
                ));

 本像用到的对象：

  static public class SampleData
  {
    static public Publisher[] Publishers =
    {
      new Publisher {Name="FunBooks"},
      new Publisher {Name="Joe Publishing"},
      new Publisher {Name="I Publisher"}
    };

    static public Author[] Authors =
    {
      new Author {FirstName="Johnny", LastName="Good"},
      new Author {FirstName="Graziella", LastName="Simplegame"},
      new Author {FirstName="Octavio", LastName="Prince"},
      new Author {FirstName="Jeremy", LastName="Legrand"}
    };

    static public Subject[] Subjects =
    {
      new Subject {Name="Software development"},
      new Subject {Name="Novel"},
      new Subject {Name="Science fiction"}
    };

    static public Book[] Books =
    {
      new Book {
        Title="Funny Stories",
        Publisher=Publishers[0],
        Authors=new[]{Authors[0], Authors[1]},
        PageCount=101,
        Price=25.55M,
        PublicationDate=new DateTime(2004, 11, 10),
        Isbn="0-000-77777-2",
        Subject=Subjects[0]
      },
      new Book {
        Title="LINQ rules",
        Publisher=Publishers[1],
        Authors=new[]{Authors[2]},
        PageCount=300,
        Price=12M,
        PublicationDate=new DateTime(2007, 9, 2),
        Isbn="0-111-77777-2",
        Subject=Subjects[0]
      },
      new Book {
        Title="C# on Rails",
        Publisher=Publishers[1],
        Authors=new[]{Authors[2]},
        PageCount=256,
        Price=35.5M,
        PublicationDate=new DateTime(2007, 4, 1),
        Isbn="0-222-77777-2",
        Subject=Subjects[0]
      },
      new Book {
        Title="All your base are belong to us",
        Publisher=Publishers[1],
        Authors=new[]{Authors[3]},
        PageCount=1205,
        Price=35.5M,
        PublicationDate=new DateTime(2006, 5, 5),
        Isbn="0-333-77777-2",
        Subject=Subjects[2]
      },
      new Book {
        Title="Bonjour mon Amour",
        Publisher=Publishers[0],
        Authors=new[]{Authors[1], Authors[0]},
        PageCount=50,
        Price=29M,
        PublicationDate=new DateTime(1973, 2, 18),
        Isbn="2-444-77777-2",
        Subject=Subjects[1]
      }
    };
  }

十四、Error mapping types

1、注意检查 MappingProfile类 是否有写 ，表与模型类映射以及模型类与表映射

2、检查 datamodel 里 int 类型数据，看这个字段在数据库中是否有空值，若有 则要在datamodel 的字段类型int 后加 ?