memorystream(net的序列化特性)

1. memorystream，net的序列化特性？

序列化通俗地讲就是将一个对象转换成一个字节流的过程，这样就可以轻松保存在磁盘文件或数据库中。反序列化是序列化的逆过程，就是将一个字节流转换回原来的对象的过程。

然而为什么需要序列化和反序列化这样的机制呢？这个问题也就涉及到序列化和反序列化的用途了，

对于序列化的主要用途有：

1）、将应用程序的状态保存在一个磁盘文件或数据库中，并在应用程序下次运行时恢复状态。例如, Asp.net 中利用序列化和反2）、序列化来保存和恢复会话状态。3）、一组对象可以轻松复制到Windows 窗体的剪贴板中，再粘贴回同一个或者另一个应用程序。将对象按值从一个应用程序域中发送到另一个程序域并且如果把对象序列化成内存中的字节流，就可以利用一些其他的技术来处理数据，例如，对数据进行加密和压缩等。

序列化和反序列化的简单使用：

using System;

using System.IO;

using System.Runtime.Serialization.Formatters.Binary;

namespace Serializable

{

[Serializable]

public class Person

{

public string personName;

[NonSerialized]

public string personHeight;

private int personAge;

public int PersonAge

{

get { return personAge; }

set { personAge = value; }

}

public void Write()

{

Console.WriteLine("Person Name: "+personName);

Console.WriteLine("Person Height: " +personHeight);

Console.WriteLine("Person Age: "+ personAge);

}

class Program

{

static void Main(string[] args)

{

Person person = new Person();

person.personName = "Jerry";

person.personHeight = "175CM";

person.PersonAge = 22;

Stream stream = Serialize(person);

//为了演示，都重置

stream.Position = 0;

person = null;

person = Deserialize(stream);

person.Write();

Console.Read();

}

private static MemoryStream Serialize(Person person)

{

MemoryStream stream = new MemoryStream();

// 构造二进制序列化格式器

BinaryFormatter binaryFormatter = new BinaryFormatter();

// 告诉序列化器将对象序列化到一个流中

binaryFormatter.Serialize(stream, person);

return stream;

}

private static Person Deserialize(Stream stream)

{

BinaryFormatter binaryFormatter = new BinaryFormatter();

return (Person)binaryFormatter.Deserialize(stream);

}

主要是调用System.Runtime.Serialization.Formatters.Binary命名空间下的BinnaryFormatter类来进行序列化和反序列化，

从中可以看出除了标记NonSerialized的其他成员都能序列化,注意这个属性只能应用于一个类型中的字段，而且会被派生类型继承。

SOAP 和XML 的序列化和反序列化和上面类似，只需要改下格式化器就可以了，这里我就不列出来了。

三、控制序列化和反序列化有两种方式来实现控制序列化和反序列化：

通过OnSerializing, OnSerialized,OnDeserializing, OnDeserialized,NonSerialized和OptionalField等属性实现System.Runtime.Serialization.ISerializable接口第一种方式实现控制序列化和反序列化代码：

using System;

using System.IO;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Formatters.Binary;

namespace ControlSerialization

{

[Serializable]

public class Circle

{

private double radius; //半径

[NonSerialized]

public double area; //面积

public Circle(double inputradiu)

{

radius = inputradiu;

area = Math.PI * radius * radius;

}

[OnDeserialized]

private void OnDeserialized(StreamingContext context)

{

area = Math.PI * radius * radius;

}

public void Write()

{

Console.WriteLine("Radius is: " + radius);

Console.WriteLine("Area is: " + area);

}

class Program

{

static void Main(string[] args)

{

Circle c = new Circle(10);

MemoryStream stream =new MemoryStream();

BinaryFormatter formatter = new BinaryFormatter();

// 将对象序列化到内存流中，这里可以使用System.IO.Stream抽象类中派生的任何类型的一个对象，这里我使用了 MemoryStream类型。

formatter.Serialize(stream,c);

stream.Position = 0;

c = null;

c = (Circle)formatter.Deserialize(stream);

c.Write();

Console.Read();

}

注意：如果注释掉 OnDeserialized属性的话，area字段的值就是0了，因为area字段没有被序列化到流中。

在上面需要序列化的对象中，格式化器只会序列化对象的radius字段的值。area字段中的值不会序列化，因为该字段已经应用了NonSerializedAttribute属性，然后我们用Circle c=new Circle(10)这样代码构建一个Circle对象时，在内部，area会设置一个约为314.159这样的值，这个对象序列化时，只有radius的字段的值（10）写入流中，但当反序列化成一个Circle对象时，它的area字段的值会初始化为0，而不是约314.159的一个值。为了解决这样的问题，所以自定义一个方法应用OnDeserializedAttribute属性。此时的执行过程为：每次反序列化类型的一个实例，格式化器都会检查类型中是否定义了一个应用了该attribute的方法，如果是，就调用该方法，调用该方法时，所有可序列化的字段都会被正确设置。除了OnDeserializedAttribute这个定制attribute,system.Runtime.Serialization命名空间还定义了OnSerializingAttribute,OnSerializedAttribute和OnDeserializingAttribute这些定制属性。

实现ISerializable接口方式控制序列化和反序列化代码：

using System;

using System.IO;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Formatters.Binary;

using System.Security.Permissions;

namespace ControlSerilization2

{

[Serializable]

public class MyObject : ISerializable

{

public int n1;

public intn2;

[NonSerialized]

public String str;

public MyObject()

{

}

protected MyObject(SerializationInfo info, StreamingContext context)

{

n1 = info.GetInt32("i");

n2 = info.GetInt32("j");

str = info.GetString("k");

}

[SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter = true)]

public virtual void GetObjectData(SerializationInfo info, StreamingContext context)

{

info.AddValue("i", n1);

info.AddValue("j", n2);

info.AddValue("k", str);

}

public void Write()

{

Console.WriteLine("n1 is: " + n1);

Console.WriteLine("n2 is: " + n2);

Console.WriteLine("str is: " + str);

}

class Program

{

static void Main(string[] args)

{

MyObject obj = new MyObject();

obj.n1 = 2;

obj.n2 = 3;

obj.str = "Jeffy";

MemoryStream stream = new MemoryStream();

BinaryFormatter formatter = new BinaryFormatter();

// 将对象序列化到内存流中，这里可以使用System.IO.Stream抽象类中派生的任何类型的一个对象，这里我使用了 MemoryStream类型。

formatter.Serialize(stream, obj);

stream.Position = 0;

obj = null;

obj = (MyObject)formatter.Deserialize(stream);

obj.Write();

Console.Read();

}

此时的执行过程为：当格式化器序列化对象时，会检查每个对象，如果发现一个对象的类型实现了ISerializable接口，格式化器会忽视所有定制属性，改为构造一个新的System.Runtime.Serialization.SerializationInfo对象，这个对象包含了要实际为对象序列化的值的集合。构造好并初始化好SerializationInfo对象后，格式化器调用类型的GetObjectData方法，并向它传递对SerializationInfo对象的引用，GetObjectData方法负责决定需要哪些信息来序列化对象，并将这些信息添加到SerializationInfo对象中，通过调用AddValue方法来添加需要的每个数据，添加好所有必要的序列化信息后，会返回至格式化器，然后格式化器获取已经添加到SerializationInfo对象中的所有值，并将它们都序列化到流中，当反序列化时，格式化器从流中提取一个对象时，会为新对象分配内存，最初，这个对象的所有字段都设为0或null,然后，格式化器检查类型是否实现了ISerializable接口，如果存在这个接口，格式化器就尝试调用一个特殊构造器，它的参数和GetObjectData方法的完全一致。

四、格式化器如何序列化和反序列化从上面的分析中可以看出，进行序列化和反序列化主要是格式化器在工作的，然而下面就是要讲讲格式化器是如何序列化一个应用了 SerializableAttribute 属性的对象。

1、格式化器调用FormatterServices的GetSerializableMembers方法：public static MemberInfo[] GetSerializableMembers(Type type,StreamingContext context);这个方法利用发射获取类型的public和private实现字段（标记了NonSerializedAttributee属性的字段除外）。方法返回由MemberInfo对象构成的一个数组，其中每个元素对应于一个可序列化的实例字段。2、对象被序列化，System.Reflection.MemberInfo对象数组传给FormatterServices的静态方法GetObjectData: public static object[] GetObjectData(Object obj,MemberInfo[] members); 这个方法返回一个Object数组，其中每个元素都标识了被序列化的那个对象中的一个字段的值。3、格式化器将程序集标识和类型的完整名称写入流中。4、格式化器然后遍历两个数组中的元素，将每个成员的名称和值写入流中。接下来是解释格式化器如何自动反序列化一个应用了 SerializableAttribute属性的对象。

1、格式化器从流中读取程序集标识和完整类型名称。2、格式化器调用FormatterServices的静态方法GetUninitializedObject: public static Object GetUninitializedObject(Type ttype);这个方法为一个新对象分配内存，但不为对象调用构造器。然而，对象的所有字段都被初始化为0或null.3格式化器现在构造并初始化一个MemberInfo数组，调用FormatterServices的GetSerializableMembers方法，这个方法返回序列化好、现在需要反序列化的一组字段。4、格式化器根据流中包含的数据创建并初始化一个Object数组。5、将对新分配的对象、MemberInfo数组以及并行Object数组的引用传给FormatterServices的静态方法PopulateObjectMembers: public static Object PopulateObjectMembers(Object obj,MemberInfo[] members,Object[] data);这个方法遍历数组，将每个字段初始化成对应的值。

memorystream(net的序列化特性)

2. linux下怎样进行摄像头编程？

在linux下所有设备都是文件。所以对摄像头的操作其实就是对文件的操作。USB摄像头的设备文件就是在/dev目录下的video0(假如只有一个摄像头)。在linux下操作摄像头就是使用v4l2对摄像头进行的操作，操作步骤如下

打开设备文件。

int fd=open(”/dev/video0″,O_RDWR);

2. 取得设备的capability，看看设备具有什么功能，比如是否具有输入,或者音频输入输出等。VIDIOC_QUERYCAP,struct v4l2_capability

v4l2_std_id std;

do {

ret= ioctl(fd, VIDIOC_QUERYSTD, std);

} while (ret == -1 errno == EAGAIN);

switch (std) {

case V4L2_STD_NTSC:

//……

case V4L2_STD_PAL:

//……

}

3. 选择输入，一个设备可以有多个输入。VIDIOC_S_INPUT,struct v4l2_input(可不要)

4. 设置的制式和帧格式，制式包括PAL，NTSC，帧的格式个包括宽度和高度等。

VIDIOC_S_STD,VIDIOC_S_FMT,struct v4l2_std_id,struct v4l2_format

struct v4l2_format fmt;

memset ( fmt, 0, sizeof(fmt) );

fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

fmt.fmt.pix.width = 320;

fmt.fmt.pix.height = 240;

fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG;

if (ioctl(fd, VIDIOC_S_FMT, fmt) < 0）

{

printf("set format failed\n");

//return 0;

}

5. 向驱动申请帧缓冲，一般不超过5个。struct v4l2_requestbuffers

struct v4l2_requestbuffers req;

memset(req, 0, sizeof (req));

req.count = 4;

req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

req.memory = V4L2_MEMORY_MMAP;

if (ioctl(fd,VIDIOC_REQBUFS,req) == -1)

{

perror("VIDIOC_REQBUFS error \n");

//return -1;

}

6.申请物理内存

将申请到的帧缓冲映射到用户空间，这样就可以直接操作采集到的帧了，而不必去复制。将申请到的帧缓冲全部入队列，以便存放采集到的数据.VIDIOC_QBUF,struct v4l2_buffer

VideoBuffer* buffers = calloc( req.count, sizeof(VideoBuffer) );

printf("sizeof(VideoBuffer) is %d\n",sizeof(VideoBuffer));

struct v4l2_buffer buf;

for (numBufs = 0; numBufs < req.count; numBufs++)

{

memset( buf, 0, sizeof(buf) );

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = numBufs;

if (ioctl(fd, VIDIOC_QUERYBUF, buf) < 0)

{

printf("VIDIOC_QUERYBUF error\n");

//return -1;

}

printf("buf len is %d\n",sizeof(buf));

//内存映射

buffers[numBufs].length = buf.length;

buffers[numBufs].offset = (size_t) buf.m.offset;

buffers[numBufs].start = mmap (NULL, buf.length,PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.offset);

printf("buffers.length = %d,buffers.offset = %d ,buffers.start[0] = %d\n",buffers[numBufs].length,buffers[numBufs].offset,buffers[numBufs].start[0]);

printf("buf2 len is %d\n",sizeof(buffers[numBufs].start));

if (buffers[numBufs].start == MAP_FAILED)

{

perror("buffers error\n");

//return -1;

}

if (ioctl (fd, VIDIOC_QBUF, buf) < 0)

{

printf("VIDIOC_QBUF error\n");

//return -1;

}

7. 开始的采集。

enum v4l2_buf_type type;

type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

if (ioctl (fd, VIDIOC_STREAMON, type) < 0)

{

printf("VIDIOC_STREAMON error\n");

// return -1;

}

8. 出队列以取得已采集数据的帧缓冲，取得原始采集数据。VIDIOC_DQBUF, 将缓冲重新入队列尾,这样可以循环采集。VIDIOC_QBUF

if (ioctl(fd, VIDIOC_DQBUF, buf) < 0)

{

perror("VIDIOC_DQBUF failed.\n");

//return -1;

}

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

unsigned char *ptcur = buffers[numBufs].start;

DEBUG("buf.bytesused = %d \n",buf.bytesused);

int i1;

for(i1=0; i1<buf.bytesused; i1++)

{

if((buffers[numBufs].start[i1] == 0xFF) (buffers[numBufs].start[i1+1] == 0xC4))

{

DEBUG("huffman table finded! \nbuf.bytesused = %d\nFFC4 = %d \n",buf.bytesused,i1);

break;

}

if(i1 == buf.bytesused)printf("huffman table don't exist! \n");

int i;

for(i=0; i<buf.bytesused; i++)

{

if((buffers[numBufs].start[i] == 0xFF) (buffers[numBufs].start[i+1] == 0xD8)) break;

ptcur++;

}

DEBUG("i=%d,FF=%02x,D8=%02x\n",i,buffers[numBufs].start[i],buffers[numBufs].start[i+1]);

int imagesize =buf.bytesused - i;

DEBUG("buf.bytesused = %d \n",buf.bytesused);

DEBUG ("imagesize = %d \n",imagesize);

9. 停止的采集。VIDIOC_STREAMOFF

10. 关闭设备。close(fd);

3. tea造句简单七年级？

1、I only drink socially.

2、You’re chewing your drink?

3、You spilled your drink.

4、His favorite drink is lemonade.

5、The second line of a couplet: sick, sick, drinkdrinkdrink every day. Streamer: drink die down.

6、Client: PepsiCo's Amp energy drink.

7、Water is a wholesome drink.

8、Let's drink to the bride and groom.

9、Or margarita. Whatever's your favorite drink.

10、Let's have a drink during the intermission!

11、a youth debauched by drugs and drink;

12、They smile and drink coffee together.

13、If we only drink sugary beverages and never drink water, how will our insides be cleansed?

14、Apparently, she gave them trouble because she refused to eat their food or drink their drink.

15、The host put a squeeze of lemon in my drink.

16、Impurity of the water made it unfit to drink.

17、He snuffed out his cigar, and began to drink whisky.

18、Dr. Young: And don't drink coffee, tea, or soda.

19、After work we all beetle off for a drink.

20、Stimulants as mild as caffeine can produce state-dependent learning boosts — so if you drink coffee or soda while studying, drink them before the test, too.

21、I work in a brewery but strangely enough I never drink beer.

22、Wild fruit juice, a famous and precious drink, has a good taste.

23、The first drink Thursday was on the house in the leading saloon.

24、The Kuna Indians who live there drink a kind of cocoa high in flavanols.

25、When Burns took a little bottle out of her cloak and had a drink, it ceased.

26、"Dear brother, do not drink," she began; but she was too late, for her brother had already knelt by the stream to drink, and as the first drop of water touched his lips he became a fawn.

27、After serving the lady her second drink, the bartender approaches the little drunk and states, it's your business if you want to buy the lady a drink, but why do you call her a ballerina?

28、Because caffeine is a psychostimulant, older women who drink 3 or more cups of coffee or tea a day have less memory loss and cognitive decline than their counterparts who drink less or none.

29、Stimulation may not be a good thing when you're drinking because you may drink longer, decide to stay at a party where you're drinking longer, and drink far more than you originally intended.

4. 内存读写方法？

代码如下

using System.Runtime.InteropServices;

using System.Text;

public class Function

{

//C#操作内存读写方法

public static byte PtrToByte( int Ptr )

{

byte b = Marshal.ReadByte( ( IntPtr ) Ptr );

return b;

}

public static char PtrToChar( int Ptr )

{

byte b = Marshal.ReadByte( ( IntPtr ) Ptr );

return ( char ) b;

}

public static short PtrToShort( int Ptr )

{

short b = Marshal.ReadInt16( ( IntPtr ) Ptr );

return b;

}

//C#操作内存读写方法

public static ushort PtrToUShort( int Ptr )

{

ushort b = ( ushort ) Marshal.ReadInt16( ( IntPtr ) Ptr );

return b;

}

public static int PtrToInt( int Ptr )

{

int b = Marshal.ReadInt32( ( IntPtr ) Ptr );

return b;

}

public static uint PtrToUInt( int Ptr )

{

uint b = ( uint ) Marshal.ReadInt32( ( IntPtr ) Ptr );

return b;

}

public static long PtrToLong( int Ptr )

{

long b = Marshal.ReadInt64( ( IntPtr ) Ptr );

return b;

} //C#操作内存读写方法

public static ulong PtrToULong( int Ptr )

{

ulong b = ( ulong ) Marshal.ReadInt64( ( IntPtr ) Ptr );

return b;

}

// Convert an ip address stored an address to equivalent string value

public static string GetPtrToIpAddr(int intPtr, intvarlen)

{

int i = 0;

StringBuilder sb = newStringBuilder(0,varlen*4);

byte[] byx = new byte[varlen];

// ip address cann't have zero value C#操作内存读写方法

// ip address cann't have zero length C#操作内存读写方法

if( ( intPtr == 0 ) || ( varlen == 0 ) ) return "";

Marshal.Copy( ( IntPtr ) intPtr , byx , 0 , varlen );

for( i = 0; i < varlen - 1; i ++ )

{

sb.Append(byx[i]);

sb.Append('.');

}

sb.Append(byx[varlen - 1]);

return sb.ToString();

}

5. 求一篇关于友谊的英语作文？

第一篇：

On friendship There is a place in my memory call friends.Friend are those people when all men doubt you,they can always believe you. Once there was a time,I felt so loneliness and sad.My freinds plan little gatherings for me ,and they write letters that make the tears stream down my face.And I feel that I'm not alone .So everytime when I can't stand the loneliness any more ,something will come to my mind ,something will come to my mind,someting that they love me and it will give me courage to go on . So freinds are just like my relatives .And friendship is home ,home that my feet may leave,but my heart can't.

关于友谊在我的记忆中有一个地方叫朋友。朋友就是那些当所有人都怀疑你的时候，却始终相信你的人。曾经有一段时间，我感到很孤独和悲伤。我的朋友们为我安排了小型聚会，他们给我写的信让我泪流满面。我觉得我不是一个人，所以每次当我再也不能忍受孤独的时候，一些事情会浮现在我的脑海里，一些事情会浮现在我的脑海里，一些他们爱我的事情会给我勇气继续走下去。所以朋友就像我的亲人，而友谊就是家，家我的脚可以离开，但我的心不能离开。

第二篇：

Everyone needs friends. with friends we will not feel lone. a good friend can teach us a lot. when we are in troubles,they will come and help us at the first time. when we make mistakes,they will tell us. when we are blue,they will comfort us.as an old saying goes, a friend in need is a friend indeed. so we must treasure the true friend.in my opinion,friendship is the most beautiful thing in our life.

每个人都需要朋友。有了朋友，我们就不会感到孤独。一个好朋友可以教我们很多。当我们遇到麻烦时，他们会第一时间来帮助我们。当我们犯错时，他们会告诉我们。当我们沮丧的时候，他们会安慰我们。俗话说得好，患难见真情。所以我们必须珍惜真正的朋友。在我看来，友谊是我们生活中最美好的东西。

6. 显卡的流处理单元是什么？

显卡的流处理单元又称流处理器（SP，Stream Processor），是统一架构GPU内通用标量着色器的称谓。流处理单元这个名词第一次出现在人们的视线中还要上溯到2006年12月4日， NVIDIA在当天正式对外发布新一代DX10显卡8800GTX，在技术参数表里面，看不到惯常使用的两个参数：Pixel Pipelines（像素渲染管线）和Vertex Pipelines（顶点着色单元），取而代之的是一个新名词：streaming processor，中文翻译过来就是流处理器（也叫流处理单元、SP单元），它的作用就是处理由CPU传输过来的数据，处理后转化为显示器可以辨识的数字信号。抗锯齿是3D特效中最重要的效果之一，我们在真实世界看到的物体，由无限的像素组成，不会看到有锯齿现象，而显示器没有足够多的点来表现图形，点与点之间的不连续就造成了锯齿。抗锯齿通过采样算法，在像素与像素之间进行平均值计算，增加像素的数目，达到像素之间平滑过渡的效果。去掉锯齿后，还可以模拟高分辨率游戏的精致画面。它是目前最热门的特效，主要用于1600 * 1200以下的低分辨率。理论上来说，在17寸显示器上，1600 * 1200分辨率已经很难看到锯齿，无须使用抗锯齿算法。如此类推，在19寸显示器上，必须使用1920 x 1080分辨率，总之，越大的显示器，分辨率越高，才越不会看到抗锯齿1920 x 1200。由于RAMDAC（Random Access Memory Digital to Analog Converter，随机存储器数/模转换器）频率和显示器制造技术的限制，我们不可能永无止境地提升显示器和显卡的分辨率，抗锯齿技术变得很有必要了。流处理器只是运算单元，不具备单独调度外部资源的能力，如果想让其在显卡中发挥作用，还是需要上层结构支持。让流处理器集群（ALU团簇）再组成GPU核心（GPC）才能真正形成计算能力，而显示器输出还需要Rops等后端才能形成完整的GPU。