C#连串化链表

  第二版代码如下:

  第三版代码如下:

  第一版的代码如下:

  发现有些思路什么的不太好写出来,是祥和收拾的不够理解,不够到位?

  测试一切正常,搞定了。

  调式时发现SerializeHelper(SerializationInfo info, StreamingContext
context)这些函数中的info变量里,MemberCount值为1,
MemberNames[4]中只有MemberNames[0]C#,不会空,是”VALUES0″,这样就惨了,表明SerializeHelper里反体系化和体系化时是呼应的。由于体系化时是只写入了一个MeasuredValue,所以反系列化时,只可以拿到一个MeasuredValue,所以生成链表的操作无法在这些类里举办。对于SerializationInfo.AddValue(String
name, object value, Type,
type)时的name这一个参数的效益,我万分疑惑,看样子那个name不是大局范围的标识符,在地点的例证中,是仅在代表一个SerializeHelper的字节流中起标识符的机能?
  
 本来觉得挺麻烦的,依据自己一定直来直往的笔触,需要把List一部分片段的连串化,在此以前就搜过,没啥资料,而且自己也不领悟该怎么社团重要字去搜。后来自家想开,可以把必须接纳的id封装到一个类中,把链表拆分成单个的因素,体系化时每一回写入新增的要素,而反连串化时,把每个元素还原出来,然后依照元素的习性来组装到个别对应的链表中。

 
为了简洁起见,把那多少个处理,局部变量声明等的都去了。每一次只贴出修改过的类的代码,MeasuredValue是一个类,存储了征集到的多少。

 1 public static class FileSerializer
 2  {
 3         //stream是调用者负责关闭的
 4         public static void Serialize(FileStream stream, object objectToSerialize)
 5         {
 6                 BinaryFormatter bFormatter = new BinaryFormatter();
 7                 bFormatter.Serialize(stream, objectToSerialize);
 8         }
 9         public static T Deserialize<T>(FileStream stream)
10         {
11             T objectToDeSerialize = default(T);          
12             BinaryFormatter bFormatter = new BinaryFormatter();
13             objectToDeSerialize = (T)bFormatter.Deserialize(stream);          
14             return objectToDeSerialize;
15         }
16 }
17  class Serialize
18 {
19         public bool SerializeMeasuredData(List<MeasuredValue> values){
20             SerializeHelper data = new SerializeHelper(values);
21             FileSerializer.Serialize(stream, data);
22         }
23         public bool DeSerializeMeasuredData(List<MeasuredValue> values)
24         {
25                 SerializeHelper data = null;
26                 stream = File.Open(_fileName, FileMode.Open, FileAccess.Read);
27                 data = FileSerializer.Deserialize<SerializeHelper>(stream);
28                 values = data;
29         }
30         
31}
32     //33     //想在序列化时,序列化某些指定的List,并添加了别的信息所以加了这个SerializeHelper。
34 class SerializeHelper(){
35         List<MeasuredValue> _values;
36         public SerializeHelper(List<MeasuredValue> values){
37             _values = values;
38         }
39         public void GetObjectData(SerializationInfo info, StreamingContext ctxt)
40         {
41             info.AddValue("VALUES", _values, typeof(List<MeasuredValue>));
42         }
43         private SerializeHelper(SerializationInfo info, StreamingContext context)
44         {
45             _values = (List<MeasuredValue>)info.GetValue(_values, typeof(List<MeasuredValue>));                 
46         }
47         
48 }

  后来想实现每便只把扩张的采访数据体系化到文件里。我不确定思路对不对,所以采纳快猛糙的点子先实现了一晃。

  新增了一个类ToSeriaMV,把需要的ListName音讯和MeasuredValue封装起来,每趟系列化和反连串的对象都是它。

 1 class ToSeriaMV {
 2         MeasuredValue _value;
 3         string _listName;       
 4        public MeasuredValue Value {
 5             get { return _value; }
 6         }
 7         public String Name
 8         {
 9             get { return _listName; }
10         }
11        
12         public ToSeriaMV(MeasuredValue value, string listName){
13             _value = value;
14             _listName = listName;
15         }
16     }
17 class SerializeHelper(){
18         const string _name = "SerializedMV";
19         ToSeriaMV _toSerialMV;
20         List<MeasuredValue> _values;        
21         
22         public SerializeHelper(MeasuredValue value,String listName)        
23         {
24             _toSerialMV = new ToSeriaMV(value, listName);
25         }    
26         private SerializeHelper(SerializationInfo info, StreamingContext context)        
27         {
28             _deSerializedSuccessful = false;
29 
30             _toSerialMV = (ToSeriaMV)info.GetValue(_name, typeof(ToSeriaMV));
31              _deSerializedSuccessful = true;    
32         }
33          public void GetObjectData(SerializationInfo info, StreamingContext ctxt)
34         {
35             info.AddValue(_name, _toSerialMV, typeof(ToSeriaMV));
36         }
37 }
38  class Serialize
39     {    
40         public bool SerializeMeasuredData(MeasuredValue value, String listName)            
41             SerializeHelper data = new SerializeHelper(value, listName );            
42             FileSerializer.Serialize(stream, data);
43         }
44         public bool DeSerializeMeasuredData(List<MeasuredValue> values)
45         {
46                 SerializeHelper data = null;
47                 ToSeriaMV toSerialMv = null;
48                 stream = File.Open(_fileName, FileMode.Open, FileAccess.Read);                
49                 
50                 
51                 while(stream.Position<stream.Length){
52                     data = FileSerializer.Deserialize<SerializeHelper>(stream);
53                     ret = data.GetInfo(out toSerialMv);
54                         if(ret==false)
55                             break;
56                         AddToList(toSerialMv, values);     
57                 }                
58         }
59     }

 

情形简化:
  
 程序中的数据每隔1s实时获取的,存储到链表里,需要及时保存到文件里去。
   
在此之前的艺术是把链表对象序列化到文件里去,好处是不需要太多处理,不用管链表中是否有元素(相对于前边的第二种艺术而言)。不过这样有个问题,每一遍都得把所有链表连串化到文件里去,当数码多了随后开销挺大的。直觉上应当是历次只把新增的多寡追加到文件里就可以了。

  不过测试时出错了,不可能正常连串化出链表。各位可以猜到我的问题出在什么地方吗?

 1 class Serialize
 2     {
 3         uint _id;
 4         public bool SerializeMeasuredData(List<MeasuredValue> values){            
 5             SerializeHelper data = new SerializeHelper(values, _id);
 6             _id++;
 7             FileSerializer.Serialize(stream, data);
 8         }
 9         public bool DeSerializeMeasuredData(List<MeasuredValue> values)
10         {
11                 SerializeHelper data = null;
12                 stream = File.Open(_fileName, FileMode.Open, FileAccess.Read);
13                 data = FileSerializer.Deserialize<SerializeHelper>(stream);
14                 values = data;
15         }
16     }
17    18   
19 class SerializeHelper(){
20         List<MeasuredValue> _values;
21         _id;
22         public SerializeHelper(List<MeasuredValue> values, uint id){
23             _values = values;
24             _id = id;
25         }
26         
27         public void GetObjectData(SerializationInfo info, StreamingContext ctxt)
28         {
29             info.AddValue("VALUES"+_id.ToString(), _values[_values.Length-1], typeof(MeasuredValue));
30         }
31         //反序列化时id却由SerializeHelper来维护,因为不可能通过参数传递过来
32         private SerializeHelper(SerializationInfo info, StreamingContext context)
33         {
34             _id = 0;
35             MeasuredValue mv= null;
36             _values = new List<MeasuredValue>();
37             try{
38                 while(true){
39                     mv = (MeasuredValue)info.GetValue("VALUES"+id.ToString(), typeof(MeasuredValue));
40                     _values.Add(mv);
41                 }
42             }
43             catch(Exception ex){//出现异常说明到文件末尾
44             
45             }                  
46         }    
47 }

相关文章