TargetInvocation Exception

[vilagutv7]

Buenas tardes el codigo es el siguiente:

using System;
using System.Net;
using System.IO;
using System.Text;
using System.Globalization;
using System.Data;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Serialization.Formatters.Binary;
using System.Xml;
using System.Data.OleDb;
using FastSerializer;

namespace SerializaHash
{
[Serializable]public class campos : ISerializable
{
public String clave;
public List<int> posiciones = new List<int>();

//Default constructor
public campos()
{
clave = "";
posiciones = null;
}

//Deserialization constructor.
public campos(SerializationInfo info, StreamingContext ctxt)
{
SerializationReader sr = SerializationReader.GetReader(info);
clave = sr.ReadString();
posiciones = (List<int>)sr.ReadList<int>();
}

//Serialization function.
public void GetObjectData(SerializationInfo info, StreamingContext ctxt)
{
SerializationWriter sw = SerializationWriter.GetWriter();
sw.Write(clave);
sw.Write<int>(posiciones);
}

}

class Program
{
static void Main(string[] args)
{
FileStream fs = new FileStream("D:\\Ernesto\\Tesis\\Columnas\\id_Uno.P ersonas.txt", FileMode.Open, FileAccess.Read);
//FileStream prueba = new FileStream("D:\\Ernesto\\Tesis\\prueba.txt", FileMode.OpenOrCreate, FileAccess.Write);
Hashtable a = new Hashtable();
Hashtable b = new Hashtable();

try
{
System.Console.WriteLine("Leyendo Archivo en formato actual " + DateTime.Now);

BinaryFormatter bf = new BinaryFormatter();
a = (Hashtable)bf.Deserialize(fs);

System.Console.WriteLine("Fin Lectura Formato actual " + DateTime.Now);

IFormatter formatter = new BinaryFormatter();

int contador = 0;
int arch = 0;
List<campos> listaCamp = new List<campos>();

//Serializacion
System.Console.WriteLine("Inicio de Serializacion nueva " + DateTime.Now);

foreach (DictionaryEntry key in a)
{
campos camp = new campos();
camp.clave = key.Key.ToString();
camp.posiciones = (List<int>)key.Value;
contador++;
listaCamp.Add(camp);

if (contador == 12500)
{
arch++;
Stream stream = new FileStream("D:\\Ernesto\\Pruebas\\prueba" + arch + ".txt", FileMode.OpenOrCreate, FileAccess.Write);
formatter.Serialize(stream, listaCamp);
stream.Close();
contador = 0;
listaCamp.Clear();
}
}

System.Console.WriteLine("Fin Serializacion Nueva " + DateTime.Now);


BinaryFormatter bs = new BinaryFormatter();


//Deserializacion
System.Console.WriteLine("Inicio Deserializacion Nueva " + DateTime.Now);

for (int i = 1; i < 400; i++)
{
Stream stream1 = new FileStream("D:\\Ernesto\\Pruebas\\prueba" + i + ".txt", FileMode.Open, FileAccess.Read);
List<campos> lista = new List<campos>();
lista = (List<campos>)bs.Deserialize(stream1);
for (int j = 0; j < lista.Count; j++)
{
String clavecita = lista[j].clave;
List<int> pos = new List<int>();
pos = (List<int>)lista[j].posiciones;
b.Add(clavecita,pos);
}
System.Console.WriteLine("Archivo # " + i + " " + DateTime.Now);
}

System.Console.WriteLine("Fin Deserializacion Nueva " + DateTime.Now);

// stream.Close();


}

finally
{

fs.Close();

}
}
}
}

En seguida les adjunto el codigo de fast serializer que se encuentra en la pagina de Code Projects

[vilagutv7]

using System;
using System.IO;
using System.Reflection;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

namespace FastSerializer {


internal enum ObjType : byte {
nullType,
boolType,
byteType,
uint16Type,
uint32Type,
uint64Type,
sbyteType,
int16Type,
int32Type,
int64Type,
charType,
stringType,
singleType,
doubleType,
decimalType,
dateTimeType,
byteArrayType,
charArrayType,
otherType
}

public class SerializationWriter : BinaryWriter {

private SerializationWriter (Stream s) : base (s) {}


public static SerializationWriter GetWriter () {
MemoryStream ms = new MemoryStream (1024);
return new SerializationWriter (ms);
}

public override void Write (string str) {
if (str==null) {
Write ((byte)ObjType.nullType);
} else {
Write ((byte)ObjType.stringType);
base.Write (str);
}
}


public override void Write (byte[] b) {
if (b==null) {
Write (-1);
} else {
int len = b.Length;
Write (len);
if (len>0) base.Write (b);
}
}

/// <summary> Writes a char array to the buffer. Overrides the base implementation to
/// sends the length of the array which is needed when it is read. </summary>

public override void Write (char[] c) {
if (c==null) {
Write (-1);
} else {
int len = c.Length;
Write (len);
if (len>0) base.Write (c);
}
}

/// <summary> Writes a DateTime to the buffer. <summary>

public void Write (DateTime dt) { Write (dt.Ticks); }

/// <summary> Writes a generic ICollection (such as an IList<T>) to the buffer. </summary>

public void Write<T> (ICollection<T> c) {
if (c==null) {
Write (-1);
} else {
Write (c.Count);
foreach (T item in c) WriteObject (item);
}
}

/// <summary> Writes a generic IDictionary to the buffer. </summary>

public void Write<T,U> (IDictionary<T,U> d) {
if (d==null) {
Write (-1);
} else {
Write (d.Count);
foreach (KeyValuePair<T,U> kvp in d) {
WriteObject (kvp.Key);
WriteObject (kvp.Value);
}
}
}

/// <summary> Writes an arbitrary object to the buffer. Useful where we have something of type "object"
/// and don't know how to treat it. This works out the best method to use to write to the buffer. </summary>

public void WriteObject (object obj) {
if (obj==null) {
Write ((byte)ObjType.nullType);
} else {

switch (obj.GetType().Name) {

case "Boolean" : Write ((byte)ObjType.boolType);
Write ((bool)obj);
break;

case "Byte" : Write ((byte)ObjType.byteType);
Write ((byte)obj);
break;

case "UInt16" : Write ((byte)ObjType.uint16Type);
Write ((ushort)obj);
break;

case "UInt32" : Write ((byte)ObjType.uint32Type);
Write ((uint)obj);
break;

case "UInt64" : Write ((byte)ObjType.uint64Type);
Write ((ulong)obj);
break;

case "SByte" : Write ((byte)ObjType.sbyteType);
Write ((sbyte)obj);
break;

case "Int16" : Write ((byte)ObjType.int16Type);
Write ((short)obj);
break;

case "Int32" : Write ((byte)ObjType.int32Type);
Write ((int)obj);
break;

case "Int64" : Write ((byte)ObjType.int64Type);
Write ((long)obj);
break;

case "Char" : Write ((byte)ObjType.charType);
base.Write ((char)obj);
break;

case "String" : Write ((byte)ObjType.stringType);
base.Write ((string)obj);
break;

case "Single" : Write ((byte)ObjType.singleType);
Write ((float)obj);
break;

case "Double" : Write ((byte)ObjType.doubleType);
Write ((double)obj);
break;

case "Decimal" : Write ((byte)ObjType.decimalType);
Write ((decimal)obj);
break;

case "DateTime" : Write ((byte)ObjType.dateTimeType);
Write ((DateTime)obj);
break;

case "Byte[]" : Write ((byte)ObjType.byteArrayType);
base.Write ((byte[])obj);
break;

case "Char[]" : Write ((byte)ObjType.charArrayType);
base.Write ((char[])obj);
break;

default : Write ((byte)ObjType.otherType);
new BinaryFormatter().Serialize (BaseStream, obj);
break;

} // switch

} // if obj==null

} // WriteObject

/// <summary> Adds the SerializationWriter buffer to the SerializationInfo at the end of GetObjectData(). </summary>

public void AddToInfo (SerializationInfo info) {
byte[] b = ((MemoryStream)BaseStream).ToArray();
info.AddValue ("X", b, typeof(byte[]));
}

} // SerializationWriter


/// <summary> SerializationReader. Extends BinaryReader to add additional data types,
/// handle null strings and simplify use with ISerializable. </summary>

public class SerializationReader : BinaryReader {

private SerializationReader (Stream s) : base (s) {}

/// <summary> Static method to take a SerializationInfo object (an input to an ISerializable constructor)
/// and produce a SerializationReader from which serialized objects can be read </summary>.

public static SerializationReader GetReader (SerializationInfo info) {
byte[] byteArray = (byte[])info.GetValue ("X",typeof(byte[]));
MemoryStream ms = new MemoryStream (byteArray);
return new SerializationReader (ms);
}

/// <summary> Reads a string from the buffer. Overrides the base implementation so it can cope with nulls. </summary>

public override string ReadString () {
ObjType t = (ObjType)ReadByte();
if (t==ObjType.stringType) return base.ReadString ();
return null;
}

/// <summary> Reads a byte array from the buffer, handling nulls and the array length. </summary>

public byte[] ReadByteArray () {
int len = ReadInt32 ();
if (len>0) return ReadBytes (len);
if (len<0) return null;
return new byte[0];
}

/// <summary> Reads a char array from the buffer, handling nulls and the array length. </summary>

public char[] ReadCharArray () {
int len = ReadInt32 ();
if (len>0) return ReadChars (len);
if (len<0) return null;
return new char[0];
}

/// <summary> Reads a DateTime from the buffer. </summary>

public DateTime ReadDateTime () { return new DateTime (ReadInt64()); }

/// <summary> Reads a generic list from the buffer. </summary>

public IList<T> ReadList<T> () {
int count = ReadInt32();
if (count<0) return null;
IList<T> d = new List<T>();
for (int i=0; i<count; i++) d.Add ((T)ReadObject());
return d;
}

/// <summary> Reads a generic Dictionary from the buffer. </summary>

public IDictionary<T,U> ReadDictionary<T,U> () {
int count = ReadInt32();
if (count<0) return null;
IDictionary<T,U> d = new Dictionary<T,U>();
for (int i=0; i<count; i++) d[(T)ReadObject()] = (U)ReadObject();
return d;
}

/// <summary> Reads an object which was added to the buffer by WriteObject. </summary>

public object ReadObject () {
ObjType t = (ObjType)ReadByte();
switch (t) {
case ObjType.boolType : return ReadBoolean();
case ObjType.byteType : return ReadByte();
case ObjType.uint16Type : return ReadUInt16();
case ObjType.uint32Type : return ReadUInt32();
case ObjType.uint64Type : return ReadUInt64();
case ObjType.sbyteType : return ReadSByte();
case ObjType.int16Type : return ReadInt16();
case ObjType.int32Type : return ReadInt32();
case ObjType.int64Type : return ReadInt64();
case ObjType.charType : return ReadChar();
case ObjType.stringType : return base.ReadString();
case ObjType.singleType : return ReadSingle();
case ObjType.doubleType : return ReadDouble();
case ObjType.decimalType : return ReadDecimal();
case ObjType.dateTimeType : return ReadDateTime();
case ObjType.byteArrayType : return ReadByteArray();
case ObjType.charArrayType : return ReadCharArray();
case ObjType.otherType : return new BinaryFormatter().Deserialize (BaseStream);
default : return null;
}
}


} // SerializationReader

} // namespace

[vilagutv7]

Cuando Implemento estos metodos obtengo un TargetInvocationException dentro del metodo

//Deserialization constructor.
public campos(SerializationInfo info, StreamingContext ctxt)
{
SerializationReader sr = SerializationReader.GetReader(info);
clave = sr.ReadString();
posiciones = (List<int>)sr.ReadList<int>();
}

Si tienen idea de donde puede estar el error seria muy util...

[vilagutv7]

Incluso voy mas alla se cae en la linea

public static SerializationReader GetReader (SerializationInfo info) {
byte[] byteArray = (byte[])info.GetValue ("X",typeof(byte[]));
MemoryStream ms = new MemoryStream (byteArray);
return new SerializationReader (ms);
}

Del Fast Serialization