/// <summary>
/// Reads an object of type <see cref="object"/> from the current stream
/// and advances the stream position.
/// </summary>
/// <returns>object read from the stream</returns>
public override object ReadObject()
{
// read type handle
short handle = reader.ReadInt16();
// Find an appropriate surrogate by handle
ISerializationSurrogate surrogate =
TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, context.CacheContext);
if (surrogate == null)
{
surrogate = TypeSurrogateSelector.GetSurrogateForSubTypeHandle(handle, reader.ReadInt16(), context.CacheContext);
}
//If surrogate not found defaultSurrogate is returned
//if (surrogate == null) throw new CompactSerializationException("Type handle " + handle + " is not registered with Compact Serialization Framework");
object obj = null;
try
{
obj = surrogate.Read(this);
}
catch (CompactSerializationException)
{
throw;
}
catch (Exception e)
{
throw new CompactSerializationException(e.Message, e);
}
return(obj);
}
/// <summary>
/// Deserializes an object from the specified compact binary writer.
/// </summary>
/// <param name="reader">Stream containing reader</param>
/// <param name="cacheContext">Name of the cache</param>
/// <param name="skip">True to skip the bytes returning null</param>
static internal object Deserialize(CompactBinaryReader reader, string cacheContext, bool skip)
{
// read type handle
short handle = reader.ReadInt16();
reader.Context.CacheContext = cacheContext;
// Find an appropriate surrogate by handle
ISerializationSurrogate surrogate =
TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, cacheContext);
if (surrogate == null)
{
surrogate = TypeSurrogateSelector.GetSurrogateForSubTypeHandle(handle, reader.ReadInt16(), cacheContext);
}
if (surrogate == null)
{
throw new CompactSerializationException("Type handle " + handle + "is not registered with Compact Serialization Framework");
}
if (!skip)
{
return(surrogate.Read(reader));
}
else
{
surrogate.Skip(reader);
return(null);
}
}
public override void Skip(CompactBinaryReader reader)
{
ISerializationSurrogate decimalSurrogate = TypeSurrogateSelector.GetSurrogateForType(typeof(decimal), null);
decimalSurrogate.Skip(reader);
decimalSurrogate.Skip(reader);
}
public override void WriteDirect(CompactBinaryWriter writer, object graph)
{
object[] array = (object[])graph;
writer.Write(array.Length);
if (!typeof(object[]).Equals(graph.GetType()))
{
object obj = null;
for (int i = 0; i < array.Length; i++)
{
if (array[i] != null)
{
obj = array[i];
break;
}
}
ISerializationSurrogate surrogate = TypeSurrogateSelector.GetSurrogateForObject(obj, writer.CacheContext);
writer.Write(surrogate.TypeHandle);
if (surrogate.SubTypeHandle > 0)
{
writer.Write(surrogate.SubTypeHandle);
}
}
else
{
ISerializationSurrogate surrogate = TypeSurrogateSelector.GetSurrogateForObject(new object(), writer.CacheContext);
writer.Write(surrogate.TypeHandle);
}
for (int i = 0; i < array.Length; i++)
{
writer.WriteObject(array[i]);
}
}
/// <summary>
/// Reads an object of type <see cref="object"/> from the current stream
/// and advances the stream position.
/// </summary>
/// <returns>object read from the stream</returns>
public override object ReadObject()
{
// read type handle
short handle = reader.ReadInt16();
// Find an appropriate surrogate by handle
ISerializationSurrogate surrogate =
TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, context.CacheContext);
object obj = null;
try
{
obj = surrogate.Read(this);
}
catch (CompactSerializationException)
{
throw;
}
catch (Exception e)
{
throw new CompactSerializationException(e.Message, e);
}
return(obj);
}
/// <summary>
/// Registra os tipos compactos.
/// </summary>
public static void RegisterCompactTypes()
{
TypeSurrogateSelector.RegisterTypeSurrogate(new ArraySerializationSurrogate(typeof(CacheEntry[])));
TypeSurrogateSelector.RegisterTypeSurrogate(new ArraySerializationSurrogate(typeof(WriteBehindAsyncProcessor.IWriteBehindTask[])));
TypeSurrogateSelector.RegisterTypeSurrogate(new CustomArraySerializationSurrogate(typeof(CustomArraySerializationSurrogate)));
CompactFormatterServices.RegisterCompactType(typeof(CacheEntry), 0x3d);
CompactFormatterServices.RegisterCompactType(typeof(CounterHint), 0x3e);
CompactFormatterServices.RegisterCompactType(typeof(TimestampHint), 0x3f);
CompactFormatterServices.RegisterCompactType(typeof(PriorityEvictionHint), 0x40);
CompactFormatterServices.RegisterCompactType(typeof(AggregateExpirationHint), 0x44);
CompactFormatterServices.RegisterCompactType(typeof(IdleExpiration), 0x45);
CompactFormatterServices.RegisterCompactType(typeof(LockExpiration), 0x87);
CompactFormatterServices.RegisterCompactType(typeof(FixedExpiration), 70);
CompactFormatterServices.RegisterCompactType(typeof(KeyDependency), 0x47);
CompactFormatterServices.RegisterCompactType(typeof(FixedIdleExpiration), 0x48);
CompactFormatterServices.RegisterCompactType(typeof(DependencyHint), 0x49);
CompactFormatterServices.RegisterCompactType(typeof(CompactCacheEntry), 0x69);
CompactFormatterServices.RegisterCompactType(typeof(CallbackEntry), 0x6b);
CompactFormatterServices.RegisterCompactType(typeof(CallbackInfo), 0x6f);
CompactFormatterServices.RegisterCompactType(typeof(AsyncCallbackInfo), 0x70);
CompactFormatterServices.RegisterCompactType(typeof(Colosoft.Caching.Synchronization.CacheSyncDependency), 0x71);
CompactFormatterServices.RegisterCompactType(typeof(CacheInsResultWithEntry), 0x76);
CompactFormatterServices.RegisterCompactType(typeof(ExtensibleDependency), 0x77);
CompactFormatterServices.RegisterCompactType(typeof(WriteThruProviderManager.WriteBehindTask), 120);
CompactFormatterServices.RegisterCompactType(typeof(WriteThruProviderManager.BulkWriteBehindTask), 0x79);
CompactFormatterServices.RegisterCompactType(typeof(UserBinaryObject), 0x7d);
}
/// <summary>
/// Skips an object of type <see cref="object"/> from the current stream
/// and advances the stream position.
/// </summary>
public override void SkipObject()
{
// read type handle
short handle = reader.ReadInt16();
// Find an appropriate surrogate by handle
ISerializationSurrogate surrogate =
TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, context.CacheContext);
if (surrogate == null)
{
surrogate = TypeSurrogateSelector.GetSurrogateForSubTypeHandle(handle, reader.ReadInt16(), context.CacheContext);
}
try
{
surrogate.Skip(this);
}
catch (CompactSerializationException)
{
throw;
}
catch (Exception e)
{
throw new CompactSerializationException(e.Message);
}
}
public STDFRecordFormatter()
{
// Add default provider
TypeSurrogateSelector.AddSurrogate(typeof(ATR), new ATRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(BPS), new BPSSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(DTR), new DTRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(EPS), new EPSSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(FAR), new FARSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(FTR), new FTRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(GDR), new GDRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(HBR), new HBRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(MIR), new MIRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(MPR), new MPRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(MRR), new MRRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(PCR), new PCRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(PGR), new PGRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(PIR), new PIRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(PLR), new PLRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(PMR), new PMRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(PRR), new PRRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(PTR), new PTRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(RDR), new RDRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(SBR), new SBRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(SDR), new SDRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(TSR), new TSRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(WCR), new WCRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(WIR), new WIRSurrogate());
TypeSurrogateSelector.AddSurrogate(typeof(WRR), new WRRSurrogate());
}
public override void Skip(CompactBinaryReader reader)
{
// read type handle
short handle = reader.ReadInt16();
// Find an appropriate surrogate by handle
ISerializationSurrogate typeSurr = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, null);
if (typeSurr == null)
{
typeSurr = TypeSurrogateSelector.GetSurrogateForSubTypeHandle(handle, reader.ReadInt16(), reader.Context.CacheContext);
}
int length = reader.ReadInt32();
T?[] array = new T?[length];
while (true)
{
int index = reader.ReadInt32();
if (index < 0)
{
break;
}
typeSurr.Skip(reader);
}
}
/// <summary>
/// Serializa a instancia no escritor.
/// </summary>
/// <param name="writer">Escritor onde os dados serão salvos.</param>
/// <param name="graph">Instancia que será serializada.</param>
/// <param name="cacheContext"></param>
internal static void Serialize(CompactBinaryWriter writer, object graph, string cacheContext)
{
var surrogateForObject = TypeSurrogateSelector.GetSurrogateForObject(graph, cacheContext);
writer.Context.CacheContext = cacheContext;
writer.Write(surrogateForObject.TypeHandle);
surrogateForObject.Write(writer, graph);
}
public override T ReadObjectAs <T>()
{
// Find an appropriate surrogate by type
ISerializationSurrogate surrogate =
TypeSurrogateSelector.GetSurrogateForType(typeof(T), context.CacheContext);
return((T)surrogate.Read(this));
}
public override void Write(CompactBinaryWriter writer, object graph)
{
Type enumType = Enum.GetUnderlyingType(ActualType);
ISerializationSurrogate typeSurr = TypeSurrogateSelector.GetSurrogateForType(enumType, writer.Context.CacheContext);
writer.Write(typeSurr.TypeHandle);
typeSurr.Write(writer, graph);
}
public override void Skip(CompactBinaryReader reader)
{
// Find an appropriate surrogate by handle
short handle = reader.ReadInt16();
ISerializationSurrogate typeSurr = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, reader.Context.CacheContext);
typeSurr.Skip(reader);
}
public override void SkipObjectAs <T>()
{
// Find an appropriate surrogate by type
ISerializationSurrogate surrogate =
TypeSurrogateSelector.GetSurrogateForType(typeof(T), context.CacheContext);
surrogate.Skip(this);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="graph"></param>
public override void WriteObjectAs <T>(T graph)
{
if (graph == null)
{
throw new ArgumentNullException("graph");
}
TypeSurrogateSelector.GetSurrogateForType(typeof(T), _context.CacheContext).Write(this, graph);
}
public override object Read(CompactBinaryReader reader)
{
// Find an appropriate surrogate by handle
short handle = reader.ReadInt16();
ISerializationSurrogate typeSurr = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, reader.Context.CacheContext);
return(Enum.ToObject(ActualType, typeSurr.Read(reader)));
}
/// <summary>
/// Escreve o objeto do tipo informado.
/// </summary>
/// <param name="type"></param>
/// <param name="graph"></param>
public override void WriteObjectAs(Type type, object graph)
{
type.Require("type").NotNull();
if (graph == null)
{
throw new ArgumentNullException("graph");
}
TypeSurrogateSelector.GetSurrogateForType(type, _context.CacheContext).Write(this, graph);
}
public override void Write(CompactBinaryWriter writer, object graph)
{
ISerializationSurrogate decimalSurrogate = TypeSurrogateSelector.GetSurrogateForType(typeof(decimal), null);
AverageResult result = (AverageResult)graph;
decimalSurrogate.Write(writer, result.Sum);
decimalSurrogate.Write(writer, result.Count);
}
/// <summary>
/// Reads data from an STDF data stream and deserializes it into the corresponding STDF record type.
/// </summary>
/// <param name="stream">Stream object to read the record data from.</param>
/// <returns></returns>
public override object Deserialize(Stream stream)
{
SerializeStream = stream;
EndOfStream = SerializeStream.Position >= SerializeStream.Length;
if (EndOfStream)
{
return(null);
}
ReadHeader(out ushort recordLength, out ushort recordTypeCode);
if (SerializeStream.Position + recordLength > SerializeStream.Length)
{
throw new EndOfStreamException("Unexpected end of record during serialization.");
}
Type recordType = STDFFormatterServices.ConvertTypeCode(recordTypeCode);
ISurrogate serializerSurrogate = TypeSurrogateSelector.GetSurrogate(recordType);
if (serializerSurrogate == null)
{
// no surrogate to deserialize this type. Skip to next record and return
SerializeStream.Seek(recordLength, SeekOrigin.Current);
//Console.WriteLine("Skipping record type " + recordType.Name);
return(null);
}
ISTDFRecord record = (ISTDFRecord)STDFFormatterServices.GetUninitializedObject(recordType);
record.RecordLength = recordLength;
SerializationInfo info = SerializationInfo.Create(recordType, Converter);
long startPosition = SerializeStream.Position;
foreach (SerializationInfoEntry field in info)
{
EndOfRecord = (SerializeStream.Position - startPosition) >= recordLength;
if (EndOfRecord)
{
// If end of record reached yet we still have more fields to serialize, then we can skip the rest of the record.
break;
}
if (field.ItemCountIndex >= 0)
{
// Field has an item count property, so we are deserializing an array.
// Get the number of items to deserialize from the value that was deserialized earlier.
int itemCount = info.GetValue <int>((int)field.ItemCountIndex);
if (itemCount > 0)
{
info.SetValue(field.Index, ReadArray(field.Type.GetElementType(), itemCount));
}
}
else
{
info.SetValue(field.Index, Read(field.Type));
}
}
EndOfStream = SerializeStream.Position >= SerializeStream.Length;
// Set the fields on the record
serializerSurrogate.SetObjectData(record, info);
return(record);
}
/// <summary>
/// Lê um objeto do tipo informado.
/// </summary>
/// <param name="type">Tipo que será deserializado.</param>
/// <returns></returns>
public override object ReadObjectAs(Type type)
{
if (typeof(ICompactSerializable).IsAssignableFrom(type))
{
ICompactSerializable graph = Activator.CreateInstance(type) as ICompactSerializable;
graph.Deserialize(this);
return(graph);
}
return(TypeSurrogateSelector.GetSurrogateForType(type, _context.CacheContext).Read(this));
}
public override object Read(CompactBinaryReader reader)
{
ISerializationSurrogate decimalSurrogate = TypeSurrogateSelector.GetSurrogateForType(typeof(decimal), null);
AverageResult result = new AverageResult();
result.Sum = (decimal)decimalSurrogate.Read(reader);
result.Count = (decimal)decimalSurrogate.Read(reader);
return(result);
}
public override void SkipDirect(CompactBinaryReader reader, object graph)
{
object[] array = (object[])graph;
short handle = reader.ReadInt16();
ISerializationSurrogate surrogate = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, reader.CacheContext);
for (int i = 0; i < array.Length; i++)
{
reader.SkipObject();
}
}
public override object Read(CompactBinaryReader reader)
{
short handle = reader.ReadInt16();
var surrogateForTypeHandle = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, reader.Context.CacheContext);
if (surrogateForTypeHandle == null)
{
surrogateForTypeHandle = TypeSurrogateSelector.GetSurrogateForSubTypeHandle(handle, reader.ReadInt16(), reader.Context.CacheContext);
}
return(Enum.ToObject(base.ActualType, surrogateForTypeHandle.Read(reader)));
}
public override void Skip(CompactBinaryReader reader)
{
short handle = reader.ReadInt16();
var surrogateForTypeHandle = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, reader.Context.CacheContext);
if (surrogateForTypeHandle == null)
{
surrogateForTypeHandle = TypeSurrogateSelector.GetSurrogateForSubTypeHandle(handle, reader.ReadInt16(), reader.Context.CacheContext);
}
surrogateForTypeHandle.Skip(reader);
}
/// <summary>
/// Serializes an object into the specified compact binary writer.
/// </summary>
/// <param name="writer">specified compact binary writer</param>
/// <param name="graph">object</param>
static internal void Serialize(CompactBinaryWriter writer, object graph, string cacheContext)
{
// Find an appropriate surrogate for the object
ISerializationSurrogate surrogate =
TypeSurrogateSelector.GetSurrogateForObject(graph, cacheContext);
// write type handle
writer.Context.CacheContext = cacheContext;
writer.Write(surrogate.TypeHandle);
surrogate.Write(writer, graph);
}
public override void WriteObjectAs <T>(T graph)
{
if (graph == null)
{
throw new ArgumentNullException("graph");
}
// Find an appropriate surrogate for the object
ISerializationSurrogate surrogate = TypeSurrogateSelector.GetSurrogateForType(typeof(T), context.CacheContext);
surrogate.Write(this, graph);
}
private static void EmitPortableWriteInstruction(FieldInfo field, ILGenerator il)
{
MethodInfo meth = null;
if (field != null)
{
Type fieldType = field.FieldType;
il.Emit(OpCodes.Ldfld, field);
if (fieldType.IsPrimitive)
{
ISerializationSurrogate surrogateForType = TypeSurrogateSelector.GetSurrogateForType(fieldType, null);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldc_I4, (int)surrogateForType.TypeHandle);
il.Emit(OpCodes.Conv_I2);
MethodInfo method = typeof(CompactBinaryWriter).GetMethod("Write", new Type[] {
typeof(short)
});
if (method != null)
{
il.Emit(OpCodes.Callvirt, method);
}
meth = typeof(CompactBinaryWriter).GetMethod("Write", new Type[] {
fieldType
});
if (meth != null)
{
il.Emit(OpCodes.Callvirt, meth);
}
}
if (meth == null)
{
if (fieldType.IsValueType)
{
il.Emit(OpCodes.Box, fieldType);
}
if (fieldType.IsInterface || !fieldType.IsPrimitive)
{
il.Emit(OpCodes.Callvirt, _compactBinaryWriterWriteObject);
}
else
{
il.Emit(OpCodes.Ldtoken, fieldType);
il.Emit(OpCodes.Call, _type_GetTypeFromHandle);
il.Emit(OpCodes.Callvirt, _compactBinaryWriterWriteObjectAs);
}
}
}
else
{
throw new NotSupportedException();
}
}
/// <summary>
/// Salta os dados do leitor.
/// </summary>
/// <param name="reader"></param>
/// <param name="graph"></param>
public override void SkipDirect(CompactBinaryReader reader, object graph)
{
object[] objArray = (object[])graph;
short handle = reader.ReadInt16();
if (TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, reader.CacheContext) == null)
{
TypeSurrogateSelector.GetSurrogateForSubTypeHandle(handle, reader.ReadInt16(), reader.Context.CacheContext);
}
for (int i = 0; i < objArray.Length; i++)
{
reader.SkipObject();
}
}
/// <summary>
/// Registers types with the Compact Serializatin Framework. Range of reserved
/// typeHandle is (61 - 1000).
/// </summary>
public static void RegisterCompactTypes()
{
TypeSurrogateSelector.RegisterTypeSurrogate(new ArraySerializationSurrogate(typeof(CacheEntry[])));
TypeSurrogateSelector.RegisterTypeSurrogate(new CustomArraySerializationSurrogate(typeof(CustomArraySerializationSurrogate)));
CompactFormatterServices.RegisterCompactType(typeof(CacheEntry), 61);
CompactFormatterServices.RegisterCompactType(typeof(PriorityEvictionHint), 64);
CompactFormatterServices.RegisterCompactType(typeof(CacheStatistics), 65);
CompactFormatterServices.RegisterCompactType(typeof(ClusterCacheStatistics), 66);
CompactFormatterServices.RegisterCompactType(typeof(NodeInfo), 67);
CompactFormatterServices.RegisterCompactType(typeof(IdleExpiration), 69);
CompactFormatterServices.RegisterCompactType(typeof(LockExpiration), 135);
CompactFormatterServices.RegisterCompactType(typeof(FixedExpiration), 70);
CompactFormatterServices.RegisterCompactType(typeof(CompactCacheEntry), 105);
CompactFormatterServices.RegisterCompactType(typeof(CallbackEntry), 107);
CompactFormatterServices.RegisterCompactType(typeof(CallbackInfo), 111);
CompactFormatterServices.RegisterCompactType(typeof(AsyncCallbackInfo), 112);
CompactFormatterServices.RegisterCompactType(typeof(BucketStatistics), 117);
CompactFormatterServices.RegisterCompactType(typeof(CacheInsResultWithEntry), 118);
CompactFormatterServices.RegisterCompactType(typeof(UserBinaryObject), 125);
CompactFormatterServices.RegisterCompactType(typeof(VirtualArray), 149);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Common.Locking.LockManager), 150);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Common.DataStructures.DistributionMaps), 160);
CompactFormatterServices.RegisterCompactType(typeof(EventCacheEntry), 262);
CompactFormatterServices.RegisterCompactType(typeof(EventContext), 263);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Caching.AutoExpiration.LockMetaInfo), 264);
CompactFormatterServices.RegisterCompactType(typeof(Function), 75);
CompactFormatterServices.RegisterCompactType(typeof(AggregateFunction), 76);
CompactFormatterServices.RegisterCompactType(typeof(PartitionedCacheBase.Identity), 77);
CompactFormatterServices.RegisterCompactType(typeof(ReplicatedCacheBase.Identity), 78);
CompactFormatterServices.RegisterCompactType(typeof(StateTxfrInfo), 116);
CompactFormatterServices.RegisterCompactType(typeof(CompressedValueEntry), 133);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Caching.Queries.QueryResultSet), 151);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Caching.OperationContext), 153);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Caching.OperationContext[]), 345);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Caching.EventContext[]), 346);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Caching.OperationID), 163);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Caching.NCacheSessionItem), 129);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Common.DataReader.ReaderResultSet), 333);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Common.DataReader.RecordSet), 334);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Common.DataReader.ColumnCollection), 335);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Common.DataReader.RowCollection), 336);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Common.DataReader.SubsetInfo), 337);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Common.DataReader.RecordRow), 338);
CompactFormatterServices.RegisterCompactType(typeof(Alachisoft.NCache.Common.DataReader.RecordColumn), 339);
}
public override object ReadDirect(CompactBinaryReader reader, object graph)
{
object[] array = (object[])graph;
short handle = reader.ReadInt16();
ISerializationSurrogate surrogate = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, reader.CacheContext);
Object obj = Array.CreateInstance(surrogate.ActualType, array.Length);
for (int i = 0; i < array.Length; i++)
{
((Array)obj).SetValue(reader.ReadObject(), i);
}
//array[i] = reader.ReadObject();
return(obj);
}