(C#基础) byte[] 之初始化, 赋值，转换。

即在与硬件交互数据时，需要经过以下几步：

第一，获得原始数据data，一般为字符串表示形式。

第二，通过Encoding.ASCII.GetBytes(data)函数将原始数据转换为ASCII码表示形式data2。

第三，为提高存储效率，可以通过将data2进一步转换为16进制表示形式data3。所以16进制的需要存储容量较小。

第四，将data3存入硬件。

第五，如果需要将data3从硬件中读出。

第六，通过先转换为2进制的ASCII码，再进一步转换为字符串进行显示，运算等。

1、计算机存储信息的最小单位，称之为位（bit），音译比特，二进制的一个“0”或一个“1”叫一位。
2、计算机存储容量基本单位是字节（Byte），音译为拜特，8个二进制位组成1个字节，一个标准英文字母占一个字节位置，一个标准汉字占二个字节位置。
3、计算机存储容量大小以字节数来度量，1024进位制：
1024B=1K（千）B
1024KB=1M（兆）B
1024MB=1G（吉）B
1024GB=1T（太）B
以下还有PB、EB、ZB、YB 、NB、DB，一般人不常使用了。
4、字符是一种符号，同以上说的存储单位不是一回事。

byte[] 之初始化赋值

用for loop 赋值当然是最基本的方法，不过在C#里面还有其他的便捷方法。

1. 创建一个长度为10的byte数组，并且其中每个byte的值为0.

byte[] myByteArray = new byte[10];

C# 在创建数值型(int, byte)数组时，会自动的把数组中的每个元素赋值为0.  （注：如果是string[], 则每个元素为的值为null. 

 

2. 创建一个长度为10的byte数组，并且其中每个byte的值为0x08. 

byte[] myByteArray = Enumerable.Repeat((byte)0x08, 10).ToArray();

用linq来赋值，语句只要一条， 当然我们还可以赋值不同的，但是有一定规律的值。

byte[] res= Enumerable.Range(1, 1000).Select(c=>Convert.ToByte(c)).ToArray();

 

3. 直接赋值

byte[] myByteArray = new byte[] { 0x01, 0x02, 0x03 };

 

byte[] ---> ushort

            byte[] array = new byte[] { 0xFE, 0x00 };

            ushort register = BitConverter.ToUInt16(array, 0);

上述转换后register 的值为 0x00FE

            byte[] array = new byte[] { 0x02, 0x01 ,0x04, 0x03 };

            ushort register = BitConverter.ToUInt16(array, 0);

上述转化后，其实只是取了array[0], array[1].的值，最后register 的值是 0x00010002， 即258

byte[] -> string

public static string ByteArrayToString(byte[] ba)
{
  string hex = BitConverter.ToString(ba);
  return hex.Replace("-","");
}

 

ushort ---> byte[]

            ushort register = 0x00F0;

            byte[] arr = BitConverter.GetBytes(register); 

在PC系统里, arr[0] = 0xF0(地位), arr[1] = 0x00 . 

互换ushort中的两个字节

            ushort number = 0x00F0;

            byte[] temp = BitConverter.GetBytes(number);
            Array.Reverse(temp); 

            ushort a = BitConverter.ToUInt16(temp, 0);

            ushort b = (ushort)(number << 8 | ((number & 0xFF00) >> 8));

 byte[] => Struct

public StructType ConverBytesToStructure<StructType>(byte[] bytesBuffer)
        {
            // 检查长度。
            if (bytesBuffer.Length != Marshal.SizeOf(typeof(StructType)))
            {
                throw new ArgumentException("bytesBuffer参数和structObject参数字节长度不一致。");
            }

            IntPtr bufferHandler = Marshal.AllocHGlobal(bytesBuffer.Length);
            for (int index = 0; index < bytesBuffer.Length; index++)
            {
                Marshal.WriteByte(bufferHandler, index, bytesBuffer[index]);
            }
            StructType structObject = (StructType)Marshal.PtrToStructure(bufferHandler, typeof(StructType));
            Marshal.FreeHGlobal(bufferHandler);
            return structObject;
        }

代码

　　　　　/// <summary>
        /// 将byte[]还原为指定的struct,该函数的泛型仅用于自定义结构
        /// startIndex：数组中 Copy 开始位置的从零开始的索引。
        /// length：要复制的数组元素的数目。
        /// </summary>
        public static T BytesToStruct<T>(byte[] bytes, int startIndex, int length)
        {
            if (bytes == null) return default(T);
            if (bytes.Length <= 0) return default(T);
            IntPtr buffer = Marshal.AllocHGlobal(length);
            try//struct_bytes转换
            {
                Marshal.Copy(bytes, startIndex, buffer, length);
                return (T)Marshal.PtrToStructure(buffer, typeof(T));
            }
            catch(Exception ex)
            {
                throw new Exception("Error in BytesToStruct ! " + ex.Message);
            }
            finally
            {
                Marshal.FreeHGlobal(buffer);
            }
        }

Struct => byte[]

代码 

　　　　　/// <summary>
        /// 将struct类型转换为byte[]
        /// </summary>
        public static byte[] StructToBytes(object structObj, int size)
        {
            IntPtr buffer = Marshal.AllocHGlobal(size);
            try//struct_bytes转换
            {
                Marshal.StructureToPtr(structObj, buffer, false);
                byte[] bytes = new byte[size];
                Marshal.Copy(buffer, bytes, 0, size);
                return bytes;
            }
            catch (Exception ex)
            {
                throw new Exception("Error in StructToBytes ! " + ex.Message);
            }
            finally
            {
                Marshal.FreeHGlobal(buffer);
            }
        }

 

byte[] 数组比较

//You can use Enumerable.SequenceEqual method.

using System;
using System.Linq;
...
var a1 = new int[] { 1, 2, 3};
var a2 = new int[] { 1, 2, 3};
var a3 = new int[] { 1, 2, 4};
var x = a1.SequenceEqual(a2); // true
var y = a1.SequenceEqual(a3); // false

 

string类型转成byte[]：

byte[] byteArray = System.Text.Encoding.Default.GetBytes ( str );

 

byte[]转成string：

string str = System.Text.Encoding.Default.GetString ( byteArray );

 

string类型转成ASCII byte[]：

（"01" 转成 byte[] = new byte[]{ 0x30,0x31}）

byte[] byteArray = System.Text.Encoding.ASCII.GetBytes ( str );

 

ASCIIbyte[]转成string：

（byte[] = new byte[]{ 0x30, 0x31} 转成"01"）

string str = System.Text.Encoding.ASCII.GetString ( byteArray );

 

 

参考： http://www.dotnetperls.com/initialize-array

【C#】数据类型（sbyte，byte，short，ushort，int，uint，long，ulong和char。、、、）

　　C#的数据类型可以分为3类:数值类型，引用类型，指针类型。指针类型仅在不安全代码中使用。    

　　值类型包括简单类型(如字符型，浮点型和整数型等)，集合类型和结构型。引用类型包括类类型，接口类型，代表类型和数组类型。

　　值类型和引用类型的不同之处是值类型的变量值直接包含数据，而引用类型的变量把它们的引用存储在对象中。对于引用类型的变量，完全有可能让两个不同的变量引用同一个对象，这样一来，对其中一个变量的操作就会影响到被另一个变量引用的对象。对于值类型的变量而言，每一个变量有它们自己的数值，因此对其中一个变量的操作不可能影响到另外一个变量。

1 值类型

　　所有的值类型都隐含地声明了一个公共的无参数的构造函数，这个构造函数叫做默认构造函数。默认构造函数返回一个初始为零的值类型的实例，称之为默认值。

　　对于sbyte，byte，short，ushort，int，uint，long，ulong，默认值为0。

　　对于char，默认值是'\x0000' ,对于float，默认值是0。0F 对于double，默认值是0。0D 对于decimal，默认值是0。0M 对于bool，默认值是false 对于一个枚举类型，默认值是0 对于一个结构类型，默认值的设置就是把所有值类型的域都设置为它们各自的默认值，把所有的引用类型的域赋为空

　　1.1 简单类型   

　  C#提供一套预定义的结构类型叫做简单类型。简单类型用保留字定义，这些保留字仅仅是在System名字空间里预定义的结构类型的化名。比如int是保留字，System。Int32是在System名字空间中预定义类型。一个简单类型和它化名的结构类型是完全一样的，也就是说写int和写System。Int32是一样的。简单类型主要有整型，浮点类型，小数类型，布尔类型，字符型 　　

　　1.1.1 整型

　　C#中支持9种整型:sbyte，byte，short，ushort，int，uint，long，ulong和char。

　　Sbyte:代表有符号的8位整数，数值范围从-128 ～ 127

　　Byte:代表无符号的8位整数，数值范围从0～255

　　Short:代表有符号的16位整数，范围从-32768 ～ 32767

　　ushort:代表有符号的16位整数，范围从0 到 65,535

　　Int:代表有符号的32位整数，范围从-2147483648 ～ 2147483648

　　uint:代表无符号的32位整数，范围从0 ～ 4294967295

　　Long:代表有符号的64位整数，范围从-9223372036854775808 ～ 9223372036854775808

　　Ulong:代表无符号的64位整数，范围从0 ～ 18446744073709551615。

　　char:代表无符号的16位整数，数值范围从0～65535。 Char类型的可能值对应于统一字符编码标准(Unicode)的字符集。

　　Char类型与其他整数类型相比有以下两点不同之处: a，没有其他类型到char类型的隐式转换。即使是对于sbyte，byte和ushort这样能完全使用char类型代表其值的类型， sbyte，byte和ushort到char的隐式转换也不存在。 b，char类型的常量必须被写为字符形式，如果用整数形式，则必须带有类型转换前缀。

　　比如(char)10赋值形式有三种: char chsomechar="A"; char chsomechar="\x0065"; 十六进制 char chsomechar="\u0065 ;

　　unicode表示法 字符型中有下列转义符: 1，\'用来表示单引号 2，\"用来表示双引号 3，\\ 用来表示反斜杠 4， \0 表示空字符 5， \a 用来表示感叹号 6， \b 用来表示退格 7， \f 用来表示换页 8， \n 用来表示换行 9， \r 用来表示回车 10， \t 用来表示水平tab 11， \v 用来表示垂直tab

　　1.1.2 浮点类型

　　C#支持两种浮点类型:float和double。

　　Float型所能表示的值的范围大约可以从1.5*10 -45～3.4* 10 38，精确到小数点后面7位。

　　Double型所能表示的值的范围大约可以从5.0*10 -324～1.7* 10 308，精确到小数点后面15位或16位。 如果二元操作中的其中一个操作数为浮点类型，那么另外一个操作数是整型或浮点类型，运算规则如下: a，如果其中一个操作数是整型，则操作数被转换为另一个操作数的浮点数类型; b，如果操作数之一为double，则另一操作数也被转换成double类型，运算以double类型的精度和取值范围进行，并且所得结果也为double类型; c，否则，运算至少将以float类型的取值范围和精度进行，并且所得结果也为float型。

　　1.1.3 小数(decimal)类型

　　小数类型非常适用于金融和货币运算。数值范围从1.0*10 -28～7.9* 10 28，精确到小数点后面28位。如果二元操作中的其中一个操作数是小数类型，那么另外一个从操作数是整型或小数类型。整型在运算前被转化为小数类型数。如果一个小数类型的算术运算产生了一个对于小数类型的格式来说太小的值，操作的结果将会变成0。如果一个小数类型的算术运算产生了一个对于小数类型的格式来说太大的值，就会触发溢出错误。小数类型较浮点类型而言，具有更大的精确度，但是数值范围相对小了很多。将浮点类型的数向小数类型的数转化时会产生溢出错误，将小数类型的数向浮点类型的数转化时会造成精确度的损失。因此，两种类型不存在隐式或显式转换。布尔型:值为true或false。没有标准能实现布尔类型和其他类型的转换。 1.2 枚举类型 枚举类型的元素使用的类型只能是long，int，short，byte。默认类型是int。默认第一个元素的值是0，每一个连续的元素按1递增。可以给元素直接赋值。如:

enum monthnames   
{  
　　January=1，  
　　February，   
　　march=31  
};  
可以强制定义其他类型，如:  
enum monthnames : byte  
{
　　January ，  
　　February，  
　　March  
};  
enum monthnames 
{
　　January=1，
　　February， 
　　march=31
};
可以强制定义其他类型，如:
enum monthnames : byte
{　　
　　January ，
　　February，
　　March
};

　　1.3结构类型

　　结构类型也是一种值类型，使用它的目的是用于创建小型的对象，用以节省内存。下面的例子表示一个使用byte类型的4个字段的IP地址。

using System;  

Struct IP //声明结构  
{   
　　publicbyte b1，b2，b3，b4;  
}  
  
Class test  
{  
 publicstaticvoid Main()  
  {  
    IP myIP;  
    myIP.b1=192;  
    myIP.b2=168;  
    myIP.b3=1;  
    myIP.b4=101;  
    Console.Write("{0}.{1}。"， myIP.b1， myIP.b2);  
    Console.Write("{0}.{1}"， myIP.b3， myIP.b4);  
　}
}  

using System;
Struct IP //声明结构
{ 
　　public byte b1，b2，b3，b4;
}

Class test
{
  public static void Main()
  {
    IP myIP;
    myIP.b1=192;
    myIP.b2=168;
    myIP.b3=1;
    myIP.b4=101;
    Console.Write("{0}.{1}。"， myIP.b1， myIP.b2);
    Console.Write("{0}.{1}"， myIP.b3， myIP.b4);
}
}

 

2 引用类型

　　引用类型包括类类型，接口类型，代表类型和数组类型。

　　2.1 类类型类 类型定义了一种数据结构，这个数据结构中包含了数据成员(如常量，字段和事件等)，函数成员(如方法，属性，索引，操作，构造函数和析构函数等)和嵌套 类型。支持继承。2.2 对象类型对象类型是其他所有类型最终的基础类型。在C#中每一种类型都直接或者间接的源于object这个类类型。

　　2.3 字符串类型字符串类型是直接从object中继承而来的密封类。String类型的值可以写成字符串文字的形式。

　　2.4 接口类型一个接口声明一个只有抽象成员的引用类型，接口仅仅存在方法标志，但没有执行代码。当定义一个类时，如果类从接口派生，可以派生自多重接口;但是如果类从类派生，就只能从一个类派生。 声明方法如例:

interface iface  
{  
　void showmyface();  
}  
interface iface
{
    void showmyface();
}

　　2.5 代表类型

　　代表引用一种静态的方法或者对象实例，引用该对象的实例方法。与其接近的是c/c++中的指针，但指针只能访问静态的函数，代表既能访问静态的方法，也能访问实例的方法。

　　2.6 数组数组是包含一串变量的数据结构。数组变量也称做数组元素，它们具有相同的类型，这种类型也称做数组元素类型。数组的元素类型可以是任何类型，包括数组类型。数组用下标确定每一个数组元素的索引号。只有一个下标的数组称为一维数组，多于一个下标的数组称为 多维数组。

　　 例:int[] a={0，2，4，6，8}; 等价于int[] a=new int[] {0，2，4，6，8}; 也可以这样初始化:a[0]=0; a[1]=2; a[2]=4; a[3]=6; a[4]=8;

　　 int[] a; //int型的一维数组

　　 int[，] a;int型的二维数组

　　 int[，，] a; //int型的三维数组

　　 int[] []a; //int型的数组的数组

　　 int[][][]a; //int型的数组的数组的数组

　　 数组的每个维数的长度不是数组类型的一部分，维数的长度是在数组创建语句中指定的，而不是在数组类型中 指定的，

　　 例如: int[，，] a3=new int[10，20，30]; a3是是一个数组变量， int[，，] 没有指定数组的长度，数组创建语句new int[10，20，30]才指定。

　　 下面的例子创建一个数组的数组:

　　 int[][] J=new int[3][];

　　 J[0]=new int[] {1，2，3};

　　 J[1]=new int[] {1，2，3，4，5，6};

　　 J[2]=new int[] {1，2，3，4，5，6，7，8，9};