如何将内存中的数组写入到硬盘
比如有一个double数组，如何将其存到硬盘？
[解决办法]
爱怎么写怎么写，这个没有什么标准
[解决办法]
正常写就行
[解决办法]
用系列化就可以了!!
[解决办法]
消息 队列服务
[解决办法]
为什么不用序列化呢？
[解决办法]
使用XmlSerializer
using System.Xml.Serialization;
然后假设你的对象类型是MyObject，实例是myObject1
XmlSerializer xs = new XmlSerializer(typeof(MyObject));
Stream stream = null;
xs.Serialize(stream, myObject1);
这样stream里存放的就是你的对象经过序列化以后的值
[解决办法]
使用文件流直接写硬盘就好了FileStream
[解决办法]
TO:现在是有一个很长很长的链表，不能直接序列化这个链表，但是要把这个链表的结果存在一个文件里
你可以将链表中的对象一个个依次序列化到文件中...
反序列化也一样，一个个再回来..
[解决办法]
TO:我狂晕，不是double数组吗，怎么又变成对象链表了
没见过这样问问题的！
用户需求突变，这是允许的..
呵呵..
[解决办法]
//将一个对象序列化成二进制数组
private byte[] SerializeToByte(ArrayList list)
{
//假如Arraylist为空，则返回null
if (list.Count == 0)
{
return null;
}
byte[] array = null;
try
{
//定义一个流
Stream stream = new MemoryStream();
//定义一个格式化器
BinaryFormatter bf = new BinaryFormatter();
//将Arraylist中的对象逐一进行序列化
foreach (object obj in list)
{
bf.Serialize(stream, obj);
}
array = new byte[stream.Length];
//将二进制流写入数组
stream.Position = 0;
stream.Read(array, 0, (int)stream.Length);
//关闭流
stream.Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return null;
}
return array;
}
//将一个二进制数组反序列化
private ArrayList DeseralizeToArraylist(byte[] b)
{
if (b == null || b.Length == 0)
{
return null;
}
//定义一个流
MemoryStream stream = new MemoryStream(b);
//定义一个格式化器
BinaryFormatter bf = new BinaryFormatter();
ArrayList list = new ArrayList();
while (stream.Position != stream.Length)
{
list.Add(bf.Deserialize(stream));
}
stream.Close();
return list;
}
[解决办法]
如果不能用序列化，试试这个：
using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.IO;
using System.Reflection;
using System.Runtime.Serialization;
using System.Collections;
namespace Convert
{
public static class XMLConvert
{
private static Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
public static string ToXML(object o)
{
return ToXML( "content ", o);
}
public static string ToXML(string name, object o)
{
StringBuilder stringBuilder = new StringBuilder();
XmlTextWriter xmlWriter = new XmlTextWriter(new StringWriter(stringBuilder));
xmlWriter.Formatting = Formatting.Indented;
xmlWriter.WriteStartDocument();
ToXML(name, o, xmlWriter, new Hashtable());
xmlWriter.WriteEndDocument();
return stringBuilder.ToString();
}
public static object ToObject(string strXML)
{
XmlDocument xml = new XmlDocument();
xml.LoadXml(strXML);
return ToObject(xml);
}
public static object ToObject(XmlDocument xml)
{
List <KeyValuePair <ObjectRef, int> > refList = new List <KeyValuePair <ObjectRef, int> > (xml.ChildNodes.Count * 4);
Hashtable refMap = new Hashtable(xml.ChildNodes.Count * 4);
object value = ToObject(xml.LastChild, refMap, refList);
foreach (KeyValuePair <ObjectRef, int> fieldRef in refList)
{
fieldRef.Key.SetValue(refMap[fieldRef.Value]);
}
return value;
}
private static void ToXML(string name, object value, XmlWriter xmlWriter, Hashtable refMap)
{
xmlWriter.WriteStartElement(name);
if (value != null)
{
if (refMap.ContainsKey(new Ref(value)))
{
xmlWriter.WriteAttributeString( "ref ", refMap[new Ref(value)].ToString());
}
else
{
Type type = value.GetType();
TypeToXML(type, xmlWriter);
if (!type.IsValueType)
{
xmlWriter.WriteAttributeString( "id ", refMap.Count.ToString());
refMap.Add(new Ref(value), refMap.Count);
}
if (type.IsPrimitive || type.Equals(typeof(string)))
{
xmlWriter.WriteString(Convert.ToString(value));
}
else if (type.IsArray)
{
foreach (object subvalue in (value as Array))
{
ToXML( "element ", subvalue, xmlWriter, refMap);
}
}
else
{
ToXML(type, value, xmlWriter, refMap);
}
}
}
xmlWriter.WriteEndElement();
}
private static void ToXML(Type type, object value, XmlWriter xmlWriter, Hashtable refMap)
{
if (type == null || type.Equals(typeof(object))) return;
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (FieldInfo field in fields)
{
ToXML(field.Name, field.GetValue(value), xmlWriter, refMap);
}
ToXML(type.BaseType, value, xmlWriter, refMap);
}
private static void TypeToXML(Type type, XmlWriter xmlWriter)
{
if (type.IsGenericType)
{
Type genericType = type.GetGenericTypeDefinition();
xmlWriter.WriteAttributeString( "type ", genericType.FullName);
Type[] genericArguments = type.GetGenericArguments();
xmlWriter.WriteAttributeString( "params ", ToParamsName(genericArguments));
}
else
{
xmlWriter.WriteAttributeString( "type ", type.FullName);
}
}
private static string ToParamsName(Type[] genericArguments)
{
string[] names = new string[genericArguments.Length];
for (int i = 0; i < genericArguments.Length; i++)
{
if (genericArguments[i].IsGenericType)
names[i] = genericArguments[i].GetGenericTypeDefinition().FullName + "( " + ToParamsName(genericArguments[i].GetGenericArguments()) + ") ";
else
names[i] = genericArguments[i].FullName;
}
return String.Join( ", ", names);
}
private static object ToObject(XmlNode node, Hashtable refMap, List <KeyValuePair <ObjectRef, int> > refList)
{
if (node == null || node.Attributes.Count == 0) return null;
Type type = GetType(node.Attributes[ "type "].Value);
if (type.IsGenericTypeDefinition)
{
string paramName = node.Attributes[ "params "].Value;
type = GetGenericType(type, paramName);
}
object value = null;
if (type.IsPrimitive || type.Equals(typeof(string)))
{
value = Convert.ChangeType(node.InnerText, type);
}
else if (type.IsArray)
{
value = Array.CreateInstance(type.GetElementType(), node.ChildNodes.Count);
for (int i = 0; i < node.ChildNodes.Count; i++)
{
if (node.ChildNodes[i].Attributes[ "ref "] != null)
refList.Add(new KeyValuePair <ObjectRef, int> (new ObjectRef(value, i), Int32.Parse(node.ChildNodes[i].Attributes[ "ref "].Value)));
else
(value as Array).SetValue(ToObject(node.ChildNodes[i], refMap, refList), i);
}
}
else
{
value = FormatterServices.GetUninitializedObject(type);
foreach (XmlNode xmlnode in node.ChildNodes)
{
FieldInfo field = GetField(type, xmlnode.Name);
if (xmlnode.Attributes[ "ref "] != null)
refList.Add(new KeyValuePair <ObjectRef, int> (new ObjectRef(value, field), Int32.Parse(xmlnode.Attributes[ "ref "].Value)));
else
field.SetValue(value, ToObject(xmlnode, refMap, refList));
}
}
if (node.Attributes[ "id "] != null) refMap[Int32.Parse(node.Attributes[ "id "].Value)] = value;
return value;
}
