Le flux d'entrée n'est pas valide d'un format binaire. Le contenu de départ

J'ai vu ce type de question posée, mais pas sûr de ce que la cause racine du problème a été ou comment résoudre le problème.

Je suis de la modification d'une classe existante pour être en mesure de charger des données dans les variables de membre à partir de flash. Maintenant, la charge de la catégorie de données à partir d'un fichier grâce à la fonction de charge. Cette fonction a été définie pour prendre en tableau d'octets.

Les données lues à partir de la mémoire flash est mis dans ce tableau d'octets.

L'erreur renvoyée est (qui se passe à la ligne ... = formatter.Deserialize(stream)):

Le flux d'entrée n'est pas valide d'un format binaire. Le départ de contenu (en octets): 93-E3-E6-3F-C3-F5-E4-41-00-C0-8D-C3-14-EE-4A-C3-00 ...

La chose intéressante ici est que le contenu est exactement le contenu du tableau d'octets qui est transmis dans le flux. En d'autres termes, ce sont les données de la mémoire flash et c'est exactement ce que je veux sérialisé. Je ne suis pas sûr de comprendre pourquoi l'erreur est levée.

Ou une meilleure question est: qu'est-ce que a est valide d'un format binaire pour un BinaryFormatter? Est-il besoin d'une certaine taille? Existe-il une valeur à la fin du nécessaire? Certaines valeurs invalide? La taille actuelle du tableau d'octets d'entrée est de 24 octets.

Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Windows.Media.Imaging;
using System.IO;
using Galileo.Data;
using System.Xml.Serialization;
using System.Reflection;
using System.Runtime.InteropServices;
using UComm;
using System.Runtime.Serialization.Formatters.Binary;
using ULog;
public void Load(byte[] spCalfromPrimary)
{
try
{
Type settingsType = this.GetType();
object tmp = Activator.CreateInstance(settingsType);
Stream stream = new MemoryStream();
stream.Write(spCalfromPrimary, 0, spCalfromPrimary.Length);
stream.Position = 0;
BinaryFormatter formatter = new BinaryFormatter();
//tmp = formatter.Deserialize(stream);
formatter.Deserialize(stream);            //**<--- throws error here**
//Use reflection to copy all public properties from the temporary object into this one.                
PropertyInfo[] properties = settingsType.GetProperties();
foreach (PropertyInfo property in properties)
{
object value = property.GetValue(tmp, null);
if (value == null)
{
throw new FileFormatException("Null value encountered in settings file");
}
else
{
property.SetValue(this, value, null);
}
}
}
catch (Exception ex)
{
_logger.DebugException("Failed to load spatial cal value from FW", ex);
Console.WriteLine(ex.Message);
}
}
//<summary>
///Loads the setting from file
///</summary>
public void Load()
{
Type settingsType = this.GetType();
XmlSerializer xser = new XmlSerializer(settingsType);
object tmp = Activator.CreateInstance(settingsType);
using (StreamReader reader = new StreamReader(_filename)) { tmp = xser.Deserialize(reader); }
//Use reflection to copy all public properties from the temporary object into this one.                
PropertyInfo[] properties = settingsType.GetProperties();
foreach (PropertyInfo property in properties)
{
object value = property.GetValue(tmp, null);
if (value == null)
{
throw new FileFormatException("Null value encountered in settings file");
}
else
{
property.SetValue(this, value, null);
}
}
}

Noter que j'ai aussi essayé de la Convertir un tableau d'octets en fonction de l'objet (que j'ai trouvé sur stackoverflow). Lorsque j'ai utilisé cette fonction, une exception a été encore jetés à .Deserialize(memStream).

//Convert a byte array to an Object
private Object ByteArrayToObject(byte[] arrBytes)
{
MemoryStream memStream = new MemoryStream();
BinaryFormatter binForm = new BinaryFormatter();
memStream.Write(arrBytes, 0, arrBytes.Length);
memStream.Seek(0, SeekOrigin.Begin);
Object obj = (Object) binForm.Deserialize(memStream);
return obj;
}

Apparemment, j'ai laissé de côté certaines informations importantes.

De sérialisation qui se passe dans une autre application à partir de la désérialisation. La sérialisation utilise un bitconverter de prendre les données, de les convertir en un tableau d'octets et de les télécharger en format flash. Laissez-moi vous expliquer. Les données sérialisées /désérialisé & stocké dans la mémoire flash est des données d'étalonnage. L'étalonnage est effectué à l'usine avec Application1 par la production. Il utilise un bitconverter de mettre chaque champ dans une rivière, puis sérialiser les flux.

CFlatInterface.FloatToStream(bData, ref i, rtsMappingData.ScaleTrackingDMD);
CFlatInterface.FloatToStream(bData, ref i, rtsMappingData.RotationAngle);
CFlatInterface.FloatToStream(bData, ref i, rtsMappingData.CenterOfRotation.dx);

où la fonction FloatToStream est défini comme:

public static void FloatToStream(byte[] buf, ref int index, float val)
{
Buffer.BlockCopy(BitConverter.GetBytes(val), 0, buf, index, sizeof(float));
index += sizeof(float);
}

De sorte que chaque domaine qui fait l'Étalonnage est placé dans le flux de cette façon. Les données sont placées dans un ruisseau et d'un tableau d'octets est construit et envoyé à flash.

De l'autre côté, une fois que le produit est sorti de l'usine et en cours d'utilisation, Application2 (application de l'utilisateur) a pour objet de Calibration qui a tout l'étalonnage des champs. Ce lit le flash, et obtient les données qui a été écrit par Application1. Application2 est d'essayer de désérialiser les données d'étalonnage à l'aide de BinaryFormatter et le code ci-dessus. Je suis venue à la conclusion que ce n'est pas possible (Grâce Rotem). Le déroulement correct de l'action est d'utiliser le même module de formatage pour les deux sérialisation /désérialisation - je vais la mettre en œuvre cette manière, et indiquer si cela fait une différence.

OriginalL'auteur AKT | 2014-02-15