MakeSerializer_Monsajem_Array()
{
var Type = typeof(t);
var ItemsSerializer = GetSerialize(System.Array.CreateInstance(
((Collection.Array.Base.IArray)GetUninitializedObject(Type)).ElementType, 0).GetType());
var ObjSerializer = SerializeInfo <object> .GetSerialize();
Action <SerializeData, object> Serializer = (Data, obj) =>
{
var ar = (Collection.Array.Base.IArray)obj;
ObjSerializer.Serializer(Data, ar.Comparer);
ObjSerializer.Serializer(Data, ar.MyOptions);
ItemsSerializer.Serializer(Data, ar.ToArray());
};
Func <DeserializeData, object> Deserializer = (Data) =>
{
var ar = (Collection.Array.Base.IArray)GetUninitializedObject(Type);
ar.Comparer = ObjSerializer.Deserializer(Data);
ar.MyOptions = ObjSerializer.Deserializer(Data);
ar.Insert((Array)ItemsSerializer.Deserializer(Data));
return(ar);
};
return(Serializer, Deserializer);
}
private SerializeInfo WriteSerializer(SerializeData Data, Type Type)
{
var Sr = SerializeInfo.GetSerialize(Type);
VisitedInfoSerialize <object>(Data, Sr.Type, () => (Sr.NameAsByte, null));
return(Sr);
}
private SerializeInfo ReadSerializer(DeserializeData Data)
{
var Info = VisitedInfoDeserialize(Data, () =>
{
return(Read(Data));
});
return(SerializeInfo.GetSerialize(Info));
}
private void VisitedDeserialize(
DeserializeData Data,
Action <object> Set,
SerializeInfo deserializer)
{
if (deserializer.ConstantSize > -1)
{
Set(deserializer.Deserializer(Data));
return;
}
var LastFrom = Data.From;
var Fr = BitConverter.ToInt32(Data.Data, LastFrom);
Data.From += 4;
if (deserializer.CanStoreInVisit == false)
{
if (Fr == -2)
{
return;
}
Set(deserializer.Deserializer(Data));
return;
}
ObjectContainer VisitedObj;
switch (Fr)
{
case -1:
VisitedObj = new ObjectContainer()
{
HashCode = LastFrom,
IsUniqueHashCode = true
};
Data.Visitor.Add(VisitedObj);
VisitedObj.obj = deserializer.Deserializer(Data);
Set(VisitedObj.obj);
return;
case -2:
return;
}
VisitedObj = new ObjectContainer()
{
HashCode = Fr,
IsUniqueHashCode = true
};
Data.Visitor.TryGetValue(VisitedObj, out VisitedObj);
if (VisitedObj.obj == null)
{
Data.AtLast += () => Set(VisitedObj.obj);
}
else
{
Set(VisitedObj.obj);
}
}
private byte[] _Serialize <t>(t obj,
Action <Type> TrustToType,
Action <MethodInfo> TrustToMethod)
{
byte[] Result;
var SR = SerializeInfo <t> .GetSerialize();
SerializeData SR_Data = default;
try
{
#if DEBUG
if (Deletage_Target == null)
{
var Fields = DynamicAssembly.FieldControler.GetFields(typeof(Delegate));
var Fields_str = "";
for (int i = 0; i < Fields.Length; i++)
{
Fields_str += "\n" + Fields[i].Name;
}
throw new Exception("Cant Access to Deletage Target field at serializer, Fields >>" + Fields_str);
}
#endif
var ConstantSize = SR.ConstantSize;
if (ConstantSize == -1)
{
SR_Data = new SerializeData(true, TrustToType, TrustToMethod);
VisitedSerialize(SR_Data, obj, SR);
Result = SR_Data.Data.ToArray();
}
else
{
//return StructToBytes(obj, ConstantSize);
SR_Data = new SerializeData(false, TrustToType, TrustToMethod,
new MemoryStream(ConstantSize));
SR.Serializer(SR_Data, obj);
Result = SR_Data.Data.ToArray();
}
}
#if DEBUG
catch (Exception ex)
{
var Traced = SR_Data.Traced;
if (Traced != null)
{
Traced = "On " + Traced;
}
SR_Data.Traced = null;
throw new Exception($"Serialize Of Type >> {obj.GetType().FullName} Is Failed " + Traced, ex);
}
#endif
finally { }
return(Result);
}
private void VisitedSerialize(
SerializeData Data,
object obj,
SerializeInfo serializer)
{
if (serializer.ConstantSize > -1)
{
serializer.Serializer(Data, obj);
return;
}
var BytesData = Data.Data;
if (obj == null)
{
BytesData.Write(Byte_Int_N_2, 0, 4);
return;
}
if (serializer.CanStoreInVisit == false)
{
BytesData.Write(Byte_Int_N_1, 0, 4);
serializer.Serializer(Data, obj);
return;
}
var Key = new ObjectContainer()
{
HashCode = obj.GetHashCode(),
obj = obj
};
var Visitor = Data.Visitor;
if (Visitor.TryGetValue(Key, out var VisitedObj) == false)
{
Visitor.Add(Key);
#if DEBUG
Key.obj = obj;
#endif
Key.FromPos = (int)BytesData.Position;
BytesData.Write(Byte_Int_N_1, 0, 4);
serializer.Serializer(Data, obj);
}
else
{
#if DEBUG
if (VisitedObj.obj.GetType() != obj.GetType())
{
throw new Exception("Type of visited object is wrong" +
"\n\nMain: " + obj.GetType().ToString() +
"\n\nVisited: " + VisitedObj.obj.GetType().ToString());
}
#endif
BytesData.Write(BitConverter.GetBytes(VisitedObj.FromPos), 0, 4);
}
}
/// <summary>
/// 開始序列化
/// </summary>
/// <param name="Obj"></param>
/// <returns></returns>
public SerializeInfo Start(object Obj)
{
XmlDocument doc = null;
XmlSerializer ser = null;
StringBuilder sb = null;
SerializeInfo info = new SerializeInfo();
try
{
ser = new XmlSerializer(Obj.GetType());
sb = new StringBuilder();
using (StringWriter writer = new StringWriter(sb))
{
ser.Serialize(writer, Obj);
doc = new XmlDocument();
doc.LoadXml(sb.ToString());
info.XmlDoc = doc;
info.Body = doc.ChildNodes[1].ChildNodes[0].InnerText;
}
}
catch (System.Exception ex)
{
info.Message = "[Serialize.Start][" + ex.ToString() + "]";
}
finally
{
if (ser != null)
{
ser = null;
}
if (doc != null)
{
doc = null;
}
if (sb != null)
{
sb = null;
}
}
return(info);
}
public t Deserialize <t>(byte[] Data, ref int From,
Action <Type> TrustToType,
Action <MethodInfo> TrustToMethod)
{
t Result = default;
var SR = SerializeInfo <t> .GetSerialize();
DeserializeData DR_Data = default;
try
{
#if DEBUG
if (Deletage_Target == null)
{
var Fields = DynamicAssembly.FieldControler.GetFields(typeof(Delegate));
var Fields_str = "";
for (int i = 0; i < Fields.Length; i++)
{
Fields_str += "\n" + Fields[i].Name;
}
throw new Exception("Cant Access to Deletage Target field at serializer, Fields >>" + Fields_str);
}
#endif
if (SR.ConstantSize == -1)
{
DR_Data = new DeserializeData(true, TrustToType, TrustToMethod, Data);
VisitedDeserialize(DR_Data, (c) => Result = (t)c, SR);
DR_Data.AtLast?.Invoke();
}
else
{
//return BytesToStruct<t>(Data, 0);
DR_Data = new DeserializeData(false, TrustToType, TrustToMethod, Data);
Result = (t)SR.Deserializer(DR_Data);
}
}
#if DEBUG
catch (Exception ex)
{
var Traced = DR_Data.Traced;
if (Traced != null)
{
Traced = "On " + Traced;
}
DR_Data.Traced = null;
throw new Exception($"Deserialize From Point {DR_Data.From} Of Type >> {typeof(t).FullName} Is Failed {Traced}\nDatas As B64:\n" + System.Convert.ToBase64String(Data), ex);
}
#endif
finally { }
return(Result);
}
private void VisitedDeserialize(
Action <object> Set,
SerializeInfo deserializer)
{
var LastFrom = From;
var Fr = BitConverter.ToInt32(D_Data, From);
From += 4;
if (deserializer.CanStoreInVisit == false)
{
if (Fr == -2)
{
return;
}
Set(deserializer.Deserializer());
return;
}
ObjectContainer VisitedObj;
switch (Fr)
{
case -1:
VisitedObj = new ObjectContainer()
{
ObjHashCode = LastFrom
};
Visitor.BinaryInsert(VisitedObj);
VisitedObj.obj = deserializer.Deserializer();
Set(VisitedObj.obj);
return;
case -2:
return;
}
VisitedObj = new ObjectContainer()
{
ObjHashCode = Fr
};
VisitedObj = Visitor.BinarySearch(VisitedObj).Value;
if (VisitedObj.obj == null)
{
AtLast += () => Set(VisitedObj.obj);
}
else
{
Set(VisitedObj.obj);
}
}
private void VisitedSerialize(
object obj,
SerializeInfo serializer)
{
if (obj == null)
{
S_Data.Write(Byte_Int_N_2, 0, 4);
return;
}
if (serializer.CanStoreInVisit == false)
{
S_Data.Write(Byte_Int_N_1, 0, 4);
serializer.Serializer(obj);
return;
}
var VisitedObj = new ObjectContainer()
{
ObjHashCode = obj.GetHashCode(),
TypeHashCode = serializer.TypeHashCode
};
var VisitedPos = Visitor.BinaryInsert(ref VisitedObj);
if (VisitedPos > -1)
{
#if DEBUG
if (VisitedObj.obj.GetType() != obj.GetType())
{
throw new Exception("Type of visited object is wrong" +
"\nMain: " + obj.GetType().ToString() +
"\nVisited: " + VisitedObj.obj.GetType().ToString());
}
#endif
S_Data.Write(BitConverter.GetBytes(VisitedObj.FromPos), 0, 4);
return;
}
#if DEBUG
VisitedObj.obj = obj;
#endif
VisitedObj.FromPos = (int)S_Data.Position;
S_Data.Write(Byte_Int_N_1, 0, 4);
serializer.Serializer(obj);
}
private byte[] _Serialize <t>(t obj, Action <Type> TrustToType)
{
byte[] Result;
var SR = SerializeInfo <t> .GetSerialize();
var SR_Data = new SerializeData()
{
Trust = TrustToType
};
try
{
#if DEBUG
if (Deletage_Target == null)
{
var Fields = DynamicAssembly.FieldControler.GetFields(typeof(Delegate));
var Fields_str = "";
for (int i = 0; i < Fields.Length; i++)
{
Fields_str += "\n" + Fields[i].Name;
}
throw new Exception("Cant Access to Deletage Target field at serializer, Fields >>" + Fields_str);
}
#endif
VisitedSerialize(SR_Data, obj, SR);
Result = SR_Data.S_Data.ToArray();
}
#if DEBUG
catch (Exception ex)
{
var Traced = SR_Data.Traced;
if (Traced != null)
{
Traced = "On " + Traced;
}
SR_Data.Traced = null;
throw new Exception($"Serialize Of Type >> {obj.GetType().FullName} Is Failed " + Traced, ex);
}
#endif
finally { }
return(Result);
}
/// <summary>
/// Read <see cref="SerializeInfo"/> context to the current object include the body and properties using <see cref="SerializeInfo"/>.
/// </summary>
/// <param name="context"></param>
void ReadContext(SerializeInfo info)
{
MessageState = (MessageState)info.GetValue <byte>("MessageState");
MessageType = (MQTypes)info.GetValue <byte>("MessageType");
Command = (QueueCmd)info.GetValue <byte>("Command");
Priority = (Priority)info.GetValue <byte>("Priority");
Identifier = info.GetValue <string>("Identifier");
Retry = info.GetValue <byte>("Retry");
ArrivedTime = info.GetValue <DateTime>("ArrivedTime");
//SentTime = info.GetValue<DateTime>("SentTime");
Modified = info.GetValue <DateTime>("Modified");
Expiration = info.GetValue <int>("Expiration");
//MessageId = info.GetValue<int>("MessageId");
TransformType = (TransformTypes)info.GetValue <byte>("TransformType");
Destination = info.GetValue <string>("Destination");
//Label = info.GetValue<string>("Label");
//Sender = info.GetValue<string>("Sender");
////Topic = info.GetValue<string>("Topic");
//HeaderStream = (NetStream)info.GetValue("HeaderStream");
m_BodyStream = (NetStream)info.GetValue("BodyStream");
var ns = (NetStream)info.GetValue("ItemBinary");
ItemBinary = ns.ToArray();
//if (Command != QueueCmd.Ack)
//{
// Formatter = (Formatters)info.GetValue<int>("Formatter");
// m_BodyStream = (NetStream)info.GetValue("BodyStream");
// _TypeName = info.GetValue<string>("TypeName");
// Segments = info.GetValue<byte>("Segments");
// //HostType = info.GetValue<byte>("HostType");
// Notify = info.GetValue<string>("Notify");
// //Command = info.GetValue<string>("Command");
// //IsDuplex = info.GetValue<bool>("IsDuplex");
// //_Headers = (GenericNameValue)info.GetValue("Headers");
//}
}
/// <summary>
/// Write the current object include the body and properties to <see cref="ISerializerContext"/> using <see cref="SerializeInfo"/>.
/// </summary>
/// <param name="context"></param>
public void WriteContext(ISerializerContext context)
{
SerializeInfo info = new SerializeInfo();
info.Add("MessageState", (byte)MessageState);
info.Add("MessageType", (byte)MessageType);
info.Add("Command", (byte)Command);
info.Add("Priority", (byte)Priority);
info.Add("Identifier", Identifier);
info.Add("Retry", Retry);
info.Add("ArrivedTime", ArrivedTime);
//info.Add("SentTime", SentTime);
info.Add("Modified", Modified);
info.Add("Expiration", Expiration);
//info.Add("MessageId", MessageId);
info.Add("TransformType", (byte)TransformType);
info.Add("Destination", Destination);
//info.Add("Label", Label);
//info.Add("Sender", Sender);
////info.Add("Topic", Topic);
//info.Add("Headers", HeaderStream);
info.Add("BodyStream", BodyStream);
info.Add("ItemBinary", new NetStream(ItemBinary));
//if (Command != QueueCmd.Ack)
//{
// info.Add("Formatter", (int)Formatter);
// info.Add("BodyStream", BodyStream);
// info.Add("TypeName", TypeName);
// info.Add("Segments", Segments);
// //info.Add("HostType", HostType);
// info.Add("Notify", Notify);
// //info.Add("Command", Command);
// //info.Add("IsDuplex", IsDuplex);
// //info.Add("Headers", GetHeaders());
//}
context.WriteSerializeInfo(info);
}
public override void Write(Utf8JsonWriter writer,
Info value,
JsonSerializerOptions options) => SerializeInfo.Serialize(writer, value, "level1Name", "infoInherited");
public override void Make()
{
var Type = typeof(t);
var IsSerializable = Type.GetInterfaces().Where(
(c) =>
{
if (c.IsGenericType)
{
if (c.GetGenericTypeDefinition() == ISerializableType)
{
return(true);
}
}
return(false);
}).FirstOrDefault();
if (IsSerializable != null)
{
InsertSerializer(() =>
{
var sr = MakeSerializer_Serializable();
return(sr.Serializer, sr.Deserializer);
});
}
else if (Type == typeof(Delegate))
{
InsertSerializer(
(Data, obj) =>
{
var DType = obj.GetType();
var Serializer = GetSerialize(DType);
Serializere.VisitedInfoSerialize <object>(Data, DType, () => (Serializer.NameAsByte, null));
Serializer.Serializer(Data, obj);
},
(Data) =>
{
var Info = Serializere.VisitedInfoDeserialize(Data, () => Serializere.Read(Data));
return(GetSerialize(Info).Deserializer(Data));
});
}
else if (Type.GetInterfaces().Where((c) => c == typeof(Collection.Array.Base.IArray)).FirstOrDefault() != null)
{
InsertSerializer(() =>
{
var sr = MakeSerializer_Monsajem_Array();
return(sr.Serializer, sr.Deserializer);
});
}
else if (Type.IsInterface)
{
InsertSerializer(() =>
{
var Sr = SerializeInfo <object> .GetSerialize();
return(Sr.Serializer, Sr.Deserializer);
});
}
else if (Type.IsArray)
{
var size = SerializeInfo.GetSerialize(Type.GetElementType()).ConstantSize;
if (size != -1)
{
InsertSerializer(() =>
{
var sr = MakeSerializer_Array_Struct(size);
return(sr.Serializer, sr.Deserializer);
});
}
else
{
InsertSerializer(() =>
{
var sr = MakeSerializer_Array_Class();
return(sr.Serializer, sr.Deserializer);
});
}
}
else if (Type == typeof(System.Array))
{
InsertSerializer(() =>
{
var Sr = SerializeInfo <object> .GetSerialize();
return(Sr.Serializer, Sr.Deserializer);
});
}
else if (Type == typeof(System.Array))
{
InsertSerializer(() =>
{
var sr = MakeSerializer_Array_Class();
return((Data, obj) =>
{
var ar = (System.Array)obj;
}, (Data) =>
{
return null;
}
);
});
}
else if (Type.BaseType == typeof(MulticastDelegate))
{
InsertSerializer(() =>
{
var sr = MakeSerializer_Delegate();
return(sr.Serializer, sr.Deserializer);
});
}
else if (Nullable.GetUnderlyingType(Type) != null)
{
InsertSerializer(() =>
{
var sr = MakeSerializer_Nullable();
return(sr.Serializer, sr.Deserializer);
});
}
else if (Type.IsValueType)
{
if (ConstantSize == -1)
{
InsertSerializer(() =>
{
var sr = MakeSerializer_ValueType();
return(sr.Serializer, sr.Deserializer);
});
}
else
{
InsertSerializer(() => (Default_Serializer, Default_Deserializer));
}
}
else
{
InsertSerializer(() =>
{
var sr = MakeSerializer_Else();
return(sr.Serializer, sr.Deserializer);
});
}
}
/// <summary>
/// Read <see cref="ISerializerContext"/> context to the current object include the body and properties using <see cref="SerializeInfo"/>.
/// </summary>
/// <param name="context"></param>
public void ReadContext(ISerializerContext context)
{
SerializeInfo info = context.ReadSerializeInfo();
ReadContext(info);
}
public int SizeOf <t>() => SerializeInfo <t> .GetSerialize().ConstantSize;
/// <summary>
/// 序列化檔案
/// </summary>
/// <param name="FilePath"></param>
/// <returns></returns>
public SerializeFileInfo File(string FilePath)
{
SerializeFileInfo serializeFileInfo = new SerializeFileInfo();
SerializeInfo serializeInfo = new SerializeInfo();
FileStream fileStream = null;
FileInfo fileInfo = null;
try
{
fileStream = new FileStream(FilePath, FileMode.Open);
byte[] bytes = new byte[fileStream.Length];
for (int i = 0; i < bytes.Length; i++)
{
bytes[i] = (byte)fileStream.ReadByte();
}
serializeInfo = Start(bytes);
if (serializeInfo.Message.Length > 0)
{
serializeFileInfo.Message = serializeInfo.Message; return(serializeFileInfo);
}
serializeFileInfo.Body = serializeInfo.Body;
fileInfo = new FileInfo(FilePath);
serializeFileInfo.FileInfos = fileInfo;
}
catch (System.UnauthorizedAccessException ex)
{
serializeFileInfo.Message = "[Serialize.File][UnauthorizedAccessException][" + ex.ToString() + "]";
}
catch (System.Security.SecurityException ex)
{
serializeFileInfo.Message = "[Serialize.File][SecurityException][" + ex.ToString() + "]";
}
catch (System.IO.PathTooLongException ex)
{
serializeFileInfo.Message = "[Serialize.File][PathTooLongException][" + ex.ToString() + "]";
}
catch (System.IO.FileNotFoundException ex)
{
serializeFileInfo.Message = "[Serialize.File][FileNotFoundException][" + ex.ToString() + "]";
}
catch (System.Exception ex)
{
serializeFileInfo.Message = "[Serialize.File][" + ex.ToString() + "]";
}
finally
{
if (fileStream != null)
{
fileStream.Close(); fileStream = null;
}
}
return(serializeFileInfo);
}
public Serialization()
{
Serializere = this;
SerializeInfo <object> .InsertSerializer(
(Data, obj) => { },
(Data) => new object(), false);
SerializeInfo <DateTime> .InsertSerializer(
(Data, obj) =>
{
Data.Data.Write(BitConverter.GetBytes(((DateTime)obj).Ticks), 0, 8);
},
(Data) =>
{
int Position = Data.From; Data.From += 8;
return(DateTime.FromBinary(BitConverter.ToInt64(Data.Data, Position)));
}, true);
SerializeInfo <string> .InsertSerializer(
(Data, obj) =>
{
if (obj == null)
{
Data.Data.Write(BitConverter.GetBytes(-1), 0, 4);
return;
}
var Str = UTF8.GetBytes((string)obj);
var Len = BitConverter.GetBytes(Str.Length);
Data.Data.Write(Len, 0, 4);
Data.Data.Write(Str, 0, Str.Length);
},
(Data) =>
{
var StrSize = BitConverter.ToInt32(Data.Data, Data.From);
Data.From += 4;
if (StrSize == -1)
{
return(null);
}
var Position = Data.From;
Data.From += StrSize;
return(UTF8.GetString(Data.Data, Position, StrSize));
}, true);
SerializeInfo <Type> .InsertSerializer(
(Data, obj) =>
{
var Name = Write((obj as Type).MidName());
Data.Data.Write(Name, 0, Name.Length);
},
(Data) =>
{
return(Read(Data).GetTypeByName());
}, true);
{
var SR = SerializeInfo <object> .GetSerialize();
SerializeInfo <System.Runtime.InteropServices.GCHandle> .InsertSerializer(
(Data, obj) =>
{
var GC = (System.Runtime.InteropServices.GCHandle)obj;
SR.Serializer(Data, GC.Target);
},
(Data) =>
{
return(System.Runtime.InteropServices.GCHandle.Alloc(SR.Deserializer(Data)));
}, true);
}
SerializeInfo <IEqualityComparer <string> > .InsertSerializer(
(Data, obj) =>
{
if (obj == null)
{
Data.Data.WriteByte(0);
}
else
{
Data.Data.WriteByte(1);
}
},
(Data) =>
{
if (Data.Data[Data.From++] == 0)
{
return(null);
}
else
{
return(EqualityComparer <string> .Default);
}
}, true);
}
/// <summary>
/// Initialize a new instance of MessageStream from <see cref="SerializeInfo"/>.
/// </summary>
/// <param name="info"></param>
public Message(SerializeInfo info)
{
ReadContext(info);
}
public Serialization()
{
Serializere = this;
SerializeInfo <object> .InsertSerializer(
(Data, obj) => { },
(Data) => new object(), false);
SerializeInfo <bool> .InsertSerializer(
(Data, obj) =>
{
if ((bool)obj == true)
{
Data.S_Data.WriteByte(1);
}
else
{
Data.S_Data.WriteByte(0);
}
},
(Data) =>
{
int Position = Data.From; Data.From += 1;
var Result = (Data.D_Data)[Position];
return(Result > 0);
}, true);
SerializeInfo <char> .InsertSerializer(
(Data, Obj) =>
{
Data.S_Data.Write(BitConverter.GetBytes((char)Obj), 0, 2);
},
(Data) =>
{
int Position = Data.From; Data.From += 2;
return(BitConverter.ToChar(Data.D_Data, Position));
}, true);
SerializeInfo <byte> .InsertSerializer(
(Data, Obj) =>
{
Data.S_Data.WriteByte((byte)Obj);
},
(Data) =>
{
int Position = Data.From; Data.From += 1;
return(Data.D_Data[Position]);
}, true);
SerializeInfo <sbyte> .InsertSerializer(
(Data, Obj) =>
{
Data.S_Data.WriteByte((byte)((sbyte)Obj));
},
(Data) =>
{
int Position = Data.From; Data.From += 1;
return((sbyte)Data.D_Data[Position]);
}, true);
SerializeInfo <short> .InsertSerializer(
(Data, obj) =>
{
Data.S_Data.Write(BitConverter.GetBytes((short)obj), 0, 2);
},
(Data) =>
{
int Position = Data.From; Data.From += 2;
return(BitConverter.ToInt16(Data.D_Data, Position));
}, true);
SerializeInfo <ushort> .InsertSerializer(
(Data, Obj) =>
{
Data.S_Data.Write(BitConverter.GetBytes((ushort)Obj), 0, 2);
},
(Data) =>
{ /// as UInt16
int Position = Data.From; Data.From += 2;
return(BitConverter.ToUInt16(Data.D_Data, Position));
}, true);
SerializeInfo <int> .InsertSerializer(
(Data, obj) =>
{ /// as Int32
Data.S_Data.Write(BitConverter.GetBytes((int)obj), 0, 4);
},
(Data) =>
{ /// as Int32
int Position = Data.From; Data.From += 4;
return(BitConverter.ToInt32(Data.D_Data, Position));
}, true);
SerializeInfo <uint> .InsertSerializer(
(Data, obj) =>
{ /// as UInt32
Data.S_Data.Write(BitConverter.GetBytes((uint)obj), 0, 4);
},
(Data) =>
{ /// as UInt32
int Position = Data.From; Data.From += 4;
return(BitConverter.ToUInt32(Data.D_Data, Position));
}, true);
SerializeInfo <long> .InsertSerializer(
(Data, obj) =>
{ /// as Int64
Data.S_Data.Write(BitConverter.GetBytes((long)obj), 0, 8);
},
(Data) =>
{ /// as Int64
int Position = Data.From; Data.From += 8;
return(BitConverter.ToInt64(Data.D_Data, Position));
}, true);
SerializeInfo <ulong> .InsertSerializer(
(Data, obj) =>
{
Data.S_Data.Write(BitConverter.GetBytes((ulong)obj), 0, 8);
},
(Data) =>
{
int Position = Data.From; Data.From += 8;
return(BitConverter.ToUInt64(Data.D_Data, Position));
}, true);
SerializeInfo <float> .InsertSerializer(
(Data, obj) =>
{ /// as float
Data.S_Data.Write(BitConverter.GetBytes((float)obj), 0, 4);
},
(Data) =>
{ /// as float
int Position = Data.From; Data.From += 4;
return(BitConverter.ToSingle(Data.D_Data, Position));
}, true);
SerializeInfo <double> .InsertSerializer(
(Data, obj) =>
{ /// as double
Data.S_Data.Write(BitConverter.GetBytes((double)obj), 0, 8);
},
(Data) =>
{ /// as double
int Position = Data.From; Data.From += 8;
return(BitConverter.ToDouble(Data.D_Data, Position));
}, true);
SerializeInfo <DateTime> .InsertSerializer(
(Data, obj) =>
{
Data.S_Data.Write(BitConverter.GetBytes(((DateTime)obj).Ticks), 0, 8);
},
(Data) =>
{
int Position = Data.From; Data.From += 8;
return(DateTime.FromBinary(BitConverter.ToInt64(Data.D_Data, Position)));
}, true);
SerializeInfo <string> .InsertSerializer(
(Data, obj) =>
{
if (obj == null)
{
Data.S_Data.Write(BitConverter.GetBytes(-1), 0, 4);
return;
}
var Str = UTF8.GetBytes((string)obj);
var Len = BitConverter.GetBytes(Str.Length);
Data.S_Data.Write(Len, 0, 4);
Data.S_Data.Write(Str, 0, Str.Length);
},
(Data) =>
{
var StrSize = BitConverter.ToInt32(Data.D_Data, Data.From);
Data.From += 4;
if (StrSize == -1)
{
return(null);
}
var Position = Data.From;
Data.From += StrSize;
return(UTF8.GetString(Data.D_Data, Position, StrSize));
}, true);
SerializeInfo <IntPtr> .InsertSerializer(
(Data, obj) =>
{ /// as IntPtr
Data.S_Data.Write(BitConverter.GetBytes(((IntPtr)obj).ToInt64()), 0, 8);
},
(Data) =>
{ /// as IntPtr
int Position = Data.From; Data.From += 8;
return(new IntPtr(BitConverter.ToInt64(Data.D_Data, Position)));
}, true);
SerializeInfo <UIntPtr> .InsertSerializer(
(Data, obj) =>
{ /// as UIntPtr
Data.S_Data.Write(BitConverter.GetBytes(((UIntPtr)obj).ToUInt64()), 0, 8);
},
(Data) =>
{ /// as UIntPtr
int Position = Data.From; Data.From += 8;
return(new UIntPtr(BitConverter.ToUInt64(Data.D_Data, Position)));
}, true);
SerializeInfo <decimal> .InsertSerializer(
(Data, obj) =>
{ /// as Decimal
Data.S_Data.Write(BitConverter.GetBytes(Decimal.ToDouble((decimal)obj)), 0, 8);
},
(Data) =>
{ /// as Decimal
int Position = Data.From; Data.From += 8;
return(System.Convert.ToDecimal(BitConverter.ToDouble(Data.D_Data, Position)));
}, true);
SerializeInfo <Type> .InsertSerializer(
(Data, obj) =>
{
var Name = Write(((Type)obj).MidName());
Data.S_Data.Write(Name, 0, Name.Length);
},
(Data) =>
{
return(Read(Data).GetTypeByName());
}, true);
{
var SR = SerializeInfo <object> .GetSerialize();
SerializeInfo <System.Runtime.InteropServices.GCHandle> .InsertSerializer(
(Data, obj) =>
{
var GC = (System.Runtime.InteropServices.GCHandle)obj;
SR.Serializer(Data, GC.Target);
},
(Data) =>
{
return(System.Runtime.InteropServices.GCHandle.Alloc(SR.Deserializer(Data)));
}, true);
}
SerializeInfo <IEqualityComparer <string> > .InsertSerializer(
(Data, obj) =>
{
if (obj == null)
{
Data.S_Data.WriteByte(0);
}
else
{
Data.S_Data.WriteByte(1);
}
},
(Data) =>
{
if (Data.D_Data[Data.From++] == 0)
{
return(null);
}
else
{
return(EqualityComparer <string> .Default);
}
}, true);
}
/// <summary>
/// 把一个DataTable写入到数据库中(新建),返回插入行数，并添加新的标识列【ID20】因为ID列有可能和其它表关联，这个ID20是一个无关联的自动编号列，如果原先有ID20这一列，会删去这一列。
/// </summary>
public int CreateTable(DataTable dt, string tbName)
{
string sqlPM = "";
string sqlPM2 = "";
ArrayList arPMName = new ArrayList();
SerializeInfo ser = new SerializeInfo();
//先删除原来的表
try
{
int dd = this.Excute("drop table [" + tbName + "]");
}
catch
{ }
string sql1 = "Create Table [" + tbName + "](";
foreach (DataColumn dc in dt.Columns)
{
string colName = dc.ColumnName.Replace('.', '_');
if (colName.ToLower() == "id20")
{
continue;
}
string type = (ser.ChangeType(dc.DataType)).ToString();
string nullb = (dc.AllowDBNull) ? "NULL" : "not null";
//string identity = (dc.Unique) ? "identity(1,1)" : " ";
sql1 += "[" + colName + "] " + type + " " + nullb + ",";
sqlPM += "@" + colName + ",";
sqlPM2 += "[" + colName + "],";
arPMName.Add("@" + colName);
}
sql1 += " [ID20] autoincrement(1) ,constraint [ID20] primary key([ID20]) )";
int b = this.Excute(sql1);
int iOK = 0;
sqlPM = sqlPM.TrimEnd(new char[] { ',' });
sqlPM2 = sqlPM2.TrimEnd(new char[] { ',' });
string sql = "insert into [" + tbName + "](" + sqlPM2 + ") values (" + sqlPM + ")";
foreach (DataRow drRow in dt.Rows)
{
object[] objval = new object[dt.Columns.Count];
for (int i = 0; i < dt.Columns.Count; i++)
{
objval[i] = drRow[i];
}
int a = this.Excute(sql, ser.ArrayListToArr(arPMName), objval);
if (a == 1)
{
iOK++;
}
else
{
//str += "------Error";
}
}
return(iOK);
}
