756 lines
21 KiB
C#
756 lines
21 KiB
C#
/*
|
||
Copyright (c) Microsoft Corporation
|
||
|
||
All rights reserved.
|
||
|
||
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
|
||
compliance with the License. You may obtain a copy of the License
|
||
at http://www.apache.org/licenses/LICENSE-2.0
|
||
|
||
|
||
THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER
|
||
EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED WARRANTIES OR CONDITIONS OF
|
||
TITLE, FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT.
|
||
|
||
|
||
See the Apache Version 2.0 License for specific language governing permissions and
|
||
limitations under the License.
|
||
|
||
*/
|
||
|
||
//
|
||
// <20> Microsoft Corporation. All rights reserved.
|
||
//
|
||
using System;
|
||
using System.Collections;
|
||
using System.Collections.Generic;
|
||
using System.Collections.ObjectModel;
|
||
using System.Text;
|
||
using System.Reflection;
|
||
using System.Linq;
|
||
using System.Data.SqlTypes;
|
||
using System.Diagnostics;
|
||
using Microsoft.Research.DryadLinq.Internal;
|
||
using Microsoft.Research.DryadLinq;
|
||
|
||
namespace Microsoft.Research.DryadLinq
|
||
{
|
||
// If a class T implements HpcSerializer<T>, HpcLinq will use the
|
||
// read and write methods of the class to do serialization.
|
||
public interface IHpcSerializer<T>
|
||
{
|
||
T Read(HpcBinaryReader reader);
|
||
void Write(HpcBinaryWriter writer, T x);
|
||
}
|
||
}
|
||
|
||
namespace Microsoft.Research.DryadLinq.Internal
|
||
{
|
||
public abstract class HpcSerializer<T> : IHpcSerializer<T>
|
||
{
|
||
public HpcSerializer() { }
|
||
public abstract T Read(HpcBinaryReader reader);
|
||
public abstract void Write(HpcBinaryWriter writer, T x);
|
||
}
|
||
|
||
internal struct HpcLinqSequence<T> : IEnumerable<T>
|
||
{
|
||
private T[] elements;
|
||
|
||
internal HpcLinqSequence(T[] elems)
|
||
{
|
||
this.elements = elems;
|
||
}
|
||
|
||
internal int Count()
|
||
{
|
||
return this.elements.Length;
|
||
}
|
||
|
||
IEnumerator IEnumerable.GetEnumerator()
|
||
{
|
||
return this.GetEnumerator();
|
||
}
|
||
|
||
IEnumerator<T> IEnumerable<T>.GetEnumerator()
|
||
{
|
||
return this.GetEnumerator();
|
||
}
|
||
|
||
internal IEnumerator<T> GetEnumerator()
|
||
{
|
||
foreach (T x in this.elements)
|
||
{
|
||
yield return x;
|
||
}
|
||
}
|
||
}
|
||
|
||
// The only use is to handle Nullable<T>.
|
||
public static class StructHpcSerialization<T, S>
|
||
where T : struct
|
||
where S : HpcSerializer<T>, new()
|
||
{
|
||
private static S serializer = new S();
|
||
|
||
public static void Read(HpcBinaryReader reader, out Nullable<T> val)
|
||
{
|
||
bool hasValue = reader.ReadBool();
|
||
if (hasValue)
|
||
{
|
||
val = serializer.Read(reader);
|
||
}
|
||
else
|
||
{
|
||
val = null;
|
||
}
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, Nullable<T> val)
|
||
{
|
||
writer.Write(val.HasValue);
|
||
if (val.HasValue)
|
||
{
|
||
serializer.Write(writer, val.Value);
|
||
}
|
||
}
|
||
}
|
||
|
||
public static class StructHpcSerialization<T1, T2, S1, S2>
|
||
where T1 : struct
|
||
where T2 : struct
|
||
where S1 : HpcSerializer<T1>, new()
|
||
where S2 : HpcSerializer<T2>, new()
|
||
{
|
||
private static S1 serializer1 = new S1();
|
||
private static S2 serializer2 = new S2();
|
||
}
|
||
|
||
// A workaround to deal with some limitation of C# generics
|
||
public static class HpcSerialization<T, S>
|
||
where S : HpcSerializer<T>, new()
|
||
{
|
||
private static S serializer = new S();
|
||
|
||
public static void Read(HpcBinaryReader reader, out List<T> list)
|
||
{
|
||
int cnt = reader.ReadInt32();
|
||
list = new List<T>(cnt);
|
||
for (int i = 0; i < cnt; i++)
|
||
{
|
||
list.Add(serializer.Read(reader));
|
||
}
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, List<T> list)
|
||
{
|
||
writer.Write(list.Count);
|
||
foreach (T elem in list)
|
||
{
|
||
serializer.Write(writer, elem);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out LinkedList<T> list)
|
||
{
|
||
int cnt = reader.ReadInt32();
|
||
list = new LinkedList<T>();
|
||
for (int i = 0; i < cnt; i++)
|
||
{
|
||
list.AddLast(serializer.Read(reader));
|
||
}
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, LinkedList<T> list)
|
||
{
|
||
writer.Write(list.Count);
|
||
foreach (T elem in list)
|
||
{
|
||
serializer.Write(writer, elem);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out Queue<T> queue)
|
||
{
|
||
int cnt = reader.ReadInt32();
|
||
queue = new Queue<T>(cnt);
|
||
for (int i = 0; i < cnt; i++)
|
||
{
|
||
queue.Enqueue(serializer.Read(reader));
|
||
}
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, Queue<T> queue)
|
||
{
|
||
writer.Write(queue.Count);
|
||
foreach (T elem in queue)
|
||
{
|
||
serializer.Write(writer, elem);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out Stack<T> stack)
|
||
{
|
||
int cnt = reader.ReadInt32();
|
||
stack = new Stack<T>(cnt);
|
||
for (int i = 0; i < cnt; i++)
|
||
{
|
||
stack.Push(serializer.Read(reader));
|
||
}
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, Stack<T> stack)
|
||
{
|
||
writer.Write(stack.Count);
|
||
foreach (T elem in stack)
|
||
{
|
||
serializer.Write(writer, elem);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out HashSet<T> set)
|
||
{
|
||
int cnt = reader.ReadInt32();
|
||
set = new HashSet<T>();
|
||
for (int i = 0; i < cnt; i++)
|
||
{
|
||
set.Add(serializer.Read(reader));
|
||
}
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, HashSet<T> set)
|
||
{
|
||
writer.Write(set.Count);
|
||
foreach (T elem in set)
|
||
{
|
||
serializer.Write(writer, elem);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out Collection<T> set)
|
||
{
|
||
int cnt = reader.ReadInt32();
|
||
set = new Collection<T>();
|
||
for (int i = 0; i < cnt; i++)
|
||
{
|
||
set.Add(serializer.Read(reader));
|
||
}
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, Collection<T> set)
|
||
{
|
||
writer.Write(set.Count);
|
||
foreach (T elem in set)
|
||
{
|
||
serializer.Write(writer, elem);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out ReadOnlyCollection<T> set)
|
||
{
|
||
int cnt = reader.ReadInt32();
|
||
List<T> lst = new List<T>(cnt);
|
||
for (int i = 0; i < cnt; i++)
|
||
{
|
||
lst.Add(serializer.Read(reader));
|
||
}
|
||
set = new ReadOnlyCollection<T>(lst);
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, ReadOnlyCollection<T> set)
|
||
{
|
||
writer.Write(set.Count);
|
||
foreach (T elem in set)
|
||
{
|
||
serializer.Write(writer, elem);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out IEnumerable<T> seq)
|
||
{
|
||
int cnt = reader.ReadInt32();
|
||
T[] elems = new T[cnt];
|
||
for (int i = 0; i < cnt; i++)
|
||
{
|
||
elems[i] = serializer.Read(reader);
|
||
}
|
||
seq = new HpcLinqSequence<T>(elems);
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, IEnumerable<T> seq)
|
||
{
|
||
writer.Write(seq.Count());
|
||
foreach (T elem in seq)
|
||
{
|
||
serializer.Write(writer, elem);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out IList<T> seq)
|
||
{
|
||
int cnt = reader.ReadInt32();
|
||
seq = new List<T>(cnt);
|
||
for (int i = 0; i < cnt; i++)
|
||
{
|
||
seq.Add(serializer.Read(reader));
|
||
}
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, IList<T> seq)
|
||
{
|
||
writer.Write(seq.Count);
|
||
foreach (T elem in seq)
|
||
{
|
||
serializer.Write(writer, elem);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out ForkValue<T> val)
|
||
{
|
||
val = new ForkValue<T>();
|
||
if (reader.ReadBool())
|
||
{
|
||
val.Value = serializer.Read(reader);
|
||
}
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, ForkValue<T> val)
|
||
{
|
||
writer.Write(val.HasValue);
|
||
if (val.HasValue)
|
||
{
|
||
serializer.Write(writer, val.Value);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out AggregateValue<T> aggVal)
|
||
{
|
||
long cnt = reader.ReadInt64();
|
||
T val = default(T);
|
||
if (cnt > 0)
|
||
{
|
||
val = serializer.Read(reader);
|
||
}
|
||
aggVal = new AggregateValue<T>(val, cnt);
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, AggregateValue<T> aggVal)
|
||
{
|
||
writer.Write(aggVal.Count);
|
||
if (aggVal.Count > 0)
|
||
{
|
||
serializer.Write(writer, aggVal.Value);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out IndexedValue<T> indexedVal)
|
||
{
|
||
int index = reader.ReadInt32();
|
||
T val = serializer.Read(reader);
|
||
indexedVal = new IndexedValue<T>(index, val);
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, IndexedValue<T> indexedVal)
|
||
{
|
||
writer.Write(indexedVal.Index);
|
||
serializer.Write(writer, indexedVal.Value);
|
||
}
|
||
}
|
||
|
||
public static class HpcSerialization<T1, T2, S1, S2>
|
||
where S1 : HpcSerializer<T1>, new()
|
||
where S2 : HpcSerializer<T2>, new()
|
||
{
|
||
private static S1 serializer1 = new S1();
|
||
private static S2 serializer2 = new S2();
|
||
|
||
public static void Read(HpcBinaryReader reader, out Dictionary<T1, T2> dict)
|
||
{
|
||
int cnt = reader.ReadInt32();
|
||
dict = new Dictionary<T1, T2>(cnt);
|
||
for (int i = 0; i < cnt; i++)
|
||
{
|
||
T1 key = serializer1.Read(reader);
|
||
T2 val = serializer2.Read(reader);
|
||
dict.Add(key, val);
|
||
}
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, Dictionary<T1, T2> dict)
|
||
{
|
||
writer.Write(dict.Count);
|
||
foreach (KeyValuePair<T1, T2> elem in dict)
|
||
{
|
||
serializer1.Write(writer, elem.Key);
|
||
serializer2.Write(writer, elem.Value);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out SortedDictionary<T1, T2> dict)
|
||
{
|
||
int cnt = reader.ReadInt32();
|
||
dict = new SortedDictionary<T1, T2>();
|
||
for (int i = 0; i < cnt; i++)
|
||
{
|
||
T1 key = serializer1.Read(reader);
|
||
T2 val = serializer2.Read(reader);
|
||
dict.Add(key, val);
|
||
}
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, SortedDictionary<T1, T2> dict)
|
||
{
|
||
writer.Write(dict.Count);
|
||
foreach (KeyValuePair<T1, T2> elem in dict)
|
||
{
|
||
serializer1.Write(writer, elem.Key);
|
||
serializer2.Write(writer, elem.Value);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out SortedList<T1, T2> list)
|
||
{
|
||
int cnt = reader.ReadInt32();
|
||
list = new SortedList<T1, T2>(cnt);
|
||
for (int i = 0; i < cnt; i++)
|
||
{
|
||
T1 key = serializer1.Read(reader);
|
||
T2 value = serializer2.Read(reader);
|
||
list.Add(key, value);
|
||
}
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, SortedList<T1, T2> list)
|
||
{
|
||
writer.Write(list.Count);
|
||
foreach (KeyValuePair<T1, T2> elem in list)
|
||
{
|
||
serializer1.Write(writer, elem.Key);
|
||
serializer2.Write(writer, elem.Value);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out IGrouping<T1, T2> group)
|
||
{
|
||
T1 key = serializer1.Read(reader);
|
||
int len = reader.ReadInt32();
|
||
Grouping<T1, T2> realGroup = new Grouping<T1, T2>(key, len);
|
||
|
||
for (int i = 0; i < len; i++)
|
||
{
|
||
realGroup.AddItem(serializer2.Read(reader));
|
||
}
|
||
group = realGroup;
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, IGrouping<T1, T2> group)
|
||
{
|
||
serializer1.Write(writer, group.Key);
|
||
writer.Write(group.Count());
|
||
|
||
foreach (T2 elem in group)
|
||
{
|
||
serializer2.Write(writer, elem);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out KeyValuePair<T1, T2> kv)
|
||
{
|
||
T1 key = serializer1.Read(reader);
|
||
T2 val = serializer2.Read(reader);
|
||
kv = new KeyValuePair<T1, T2>(key, val);
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, KeyValuePair<T1, T2> kv)
|
||
{
|
||
serializer1.Write(writer, kv.Key);
|
||
serializer2.Write(writer, kv.Value);
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out Pair<T1, T2> pair)
|
||
{
|
||
T1 x = serializer1.Read(reader);
|
||
T2 y = serializer2.Read(reader);
|
||
pair = new Pair<T1, T2>(x, y);
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, Pair<T1, T2> pair)
|
||
{
|
||
serializer1.Write(writer, pair.Key);
|
||
serializer2.Write(writer, pair.Value);
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out ForkTuple<T1, T2> val)
|
||
{
|
||
val = new ForkTuple<T1, T2>();
|
||
if (reader.ReadBool())
|
||
{
|
||
val.First = serializer1.Read(reader);
|
||
}
|
||
if (reader.ReadBool())
|
||
{
|
||
val.Second = serializer2.Read(reader);
|
||
}
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, ForkTuple<T1, T2> val)
|
||
{
|
||
writer.Write(val.HasFirst);
|
||
if (val.HasFirst)
|
||
{
|
||
serializer1.Write(writer, val.First);
|
||
}
|
||
|
||
writer.Write(val.HasSecond);
|
||
if (val.HasSecond)
|
||
{
|
||
serializer2.Write(writer, val.Second);
|
||
}
|
||
}
|
||
|
||
public static void Read(HpcBinaryReader reader, out HpcLinqGrouping<T1, T2> group)
|
||
{
|
||
T1 key = serializer1.Read(reader);
|
||
int cnt = reader.ReadInt32();
|
||
T2[] elems = new T2[cnt];
|
||
for (int i = 0; i < cnt; i++)
|
||
{
|
||
elems[i] = serializer2.Read(reader);
|
||
}
|
||
group = new HpcLinqGrouping<T1, T2>(key, elems);
|
||
}
|
||
|
||
public static void Write(HpcBinaryWriter writer, HpcLinqGrouping<T1, T2> group)
|
||
{
|
||
serializer1.Write(writer, group.Key);
|
||
writer.Write(group.Count());
|
||
foreach (T2 elem in group)
|
||
{
|
||
serializer2.Write(writer, elem);
|
||
}
|
||
}
|
||
}
|
||
|
||
public sealed class ByteHpcSerializer : HpcSerializer<byte>
|
||
{
|
||
public override byte Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadUByte();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, byte x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
public sealed class SByteHpcSerializer : HpcSerializer<sbyte>
|
||
{
|
||
public override sbyte Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadSByte();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, sbyte x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
public sealed class BoolHpcSerializer : HpcSerializer<bool>
|
||
{
|
||
public override bool Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadBool();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, bool x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
public sealed class CharHpcSerializer : HpcSerializer<char>
|
||
{
|
||
public override char Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadChar();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, char x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
public sealed class Int16HpcSerializer : HpcSerializer<Int16>
|
||
{
|
||
public override Int16 Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadInt16();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, Int16 x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
public sealed class UInt16HpcSerializer : HpcSerializer<UInt16>
|
||
{
|
||
public override UInt16 Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadUInt16();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, UInt16 x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
public sealed class Int32HpcSerializer : HpcSerializer<Int32>
|
||
{
|
||
public override Int32 Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadInt32();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, Int32 x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
public sealed class UInt32HpcSerializer : HpcSerializer<UInt32>
|
||
{
|
||
public override UInt32 Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadUInt32();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, UInt32 x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
public sealed class Int64HpcSerializer : HpcSerializer<Int64>
|
||
{
|
||
public override Int64 Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadInt64();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, Int64 x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
public sealed class UInt64HpcSerializer : HpcSerializer<UInt64>
|
||
{
|
||
public override UInt64 Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadUInt64();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, UInt64 x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
public sealed class SingleHpcSerializer : HpcSerializer<float>
|
||
{
|
||
public override float Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadSingle();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, float x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
public sealed class DoubleHpcSerializer : HpcSerializer<double>
|
||
{
|
||
public override double Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadDouble();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, double x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
public sealed class DecimalHpcSerializer : HpcSerializer<decimal>
|
||
{
|
||
public override decimal Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadDecimal();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, decimal x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
public sealed class DateTimeHpcSerializer : HpcSerializer<DateTime>
|
||
{
|
||
public override DateTime Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadDateTime();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, DateTime x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
public sealed class StringHpcSerializer : HpcSerializer<string>
|
||
{
|
||
public override string Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadString();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, string x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
public sealed class GuidHpcSerializer : HpcSerializer<Guid>
|
||
{
|
||
public override Guid Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadGuid();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, Guid x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
|
||
|
||
public sealed class SqlDateTimeHpcSerializer : HpcSerializer<SqlDateTime>
|
||
{
|
||
public override SqlDateTime Read(HpcBinaryReader reader)
|
||
{
|
||
return reader.ReadSqlDateTime();
|
||
}
|
||
|
||
public override void Write(HpcBinaryWriter writer, SqlDateTime x)
|
||
{
|
||
writer.Write(x);
|
||
}
|
||
}
|
||
}
|