/// <summary>
/// 创建 System.Data.SQLite.SQLiteConnectionStringBuilder
/// </summary>
/// <param name="connectionString">连接字符串</param>
/// <returns></returns>
public static System.Data.Common.DbConnectionStringBuilder CreateConnectionStringBuilder(string connectionString)
{
FastWrapper wrapper = GetType("System.Data.SQLite.SQLiteConnectionStringBuilder");
if (wrapper == null)
{
return(null);
}
System.Data.Common.DbConnectionStringBuilder builder;
if (string.IsNullOrEmpty(connectionString))
{
builder = FastWrapper.CreateInstance(wrapper.Type) as System.Data.Common.DbConnectionStringBuilder;
}
else
{
builder = FastWrapper.CreateInstance(wrapper.Type, connectionString) as System.Data.Common.DbConnectionStringBuilder;
string file = (string)FastWrapper.Get(builder, "DataSource");
if (!string.IsNullOrEmpty(file) && !file.Equals(":memory:", StringComparison.OrdinalIgnoreCase))
{
CreateFile(file);
}
}
FastWrapper.Set(builder, "Pooling", true);
FastWrapper.Set(builder, "FailIfMissing", false);
builder["journal mode"] = "Off";
return(builder);
}
/// <summary>
/// 绑定数据。
/// </summary>
/// <param name="dataContext">数据上下文对象。</param>
/// <param name="dataReader">数据读取对象。</param>
/// <param name="entity">当前实体对象。</param>
/// <param name="field">当前字段。</param>
/// <param name="type">实体中字段的类型。</param>
/// <param name="cache">缓存。</param>
/// <returns>返回绑定的数据。</returns>
public override object Bind(IDataContext dataContext, System.Data.IDataReader dataReader, object entity, string field, Type type, IDataBinderObjectCache cache)
{
var elementType = type.IsArray ? type.GetElementType() : type.GetGenericArguments()[0];
bool isSingleValue = (elementType == typeof(string) || elementType.IsValueType || TypeExtensions.IsNullableType(elementType));
if (isSingleValue && (string.IsNullOrEmpty(Field) || Field == "*"))
{
Field = "id";
}
using (var builder = dataContext.CreateSelect(SourceName)) {
PreSelectBuilder(dataContext, dataReader, entity, builder, cache);
if (isSingleValue)
{
builder.Select(Field);
}
builder.Query(Condition).Sort(Sorter);
return(CacheFunc(cache, builder, "list", type, () => {
var q = dataContext.CreateQuery(elementType, builder.CommandText, builder.Parameters);
q.DataBinderObjectCache = cache;
var list = (System.Collections.IList)FastWrapper.CreateInstance(type);
foreach (var item in q)
{
list.Add(item);
}
if (type.IsArray)
{
var array = Array.CreateInstance(elementType, list.Count);
list.CopyTo(array, 0);
return array;
}
return list;
}));
}
}
/// <summary>
/// 注册类型。
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public DatabaseSchemaHandler RegisterType(System.Type type)
{
if (type == null || !type.IsClass || type.IsAbstract ||
!TypeExtensions.IsInheritFrom(type, typeof(DatabaseSchemaHandler)))
{
return(null);
}
DatabaseSchemaHandler handler = null;
string key = type.FullName;
if (_caches.TryGetValue(key, out handler))
{
return(handler);
}
string fullName = TypeExtensions.FullName2(type);
try {
_log.Info("创建实例：{0}", fullName);
handler = (DatabaseSchemaHandler)FastWrapper.CreateInstance(type);
_caches.Add(key, handler);
_list.Add(handler);
ClassOrder(handler.Attribute.TableName, handler.Attribute.Order);
CacheRef(type.Assembly, handler);
return(handler);
} catch (System.Exception error) {
_log.Warning("创建实例失败：{0}\r\n{1}", fullName, LogBase.ExceptionToString(error));
return(null);
}
}
/// <summary>
/// 映射为实体对象：实体尝试。
/// </summary>
/// <param name="type">类型，为空则尝试失败。</param>
/// <param name="result">输出结果。</param>
/// <returns>返回是否尝试成功。</returns>
protected virtual bool ToObject_Try_Entity(System.Type type, out object result)
{
result = FastWrapper.CreateInstance(type);
//没有字段？
if (FieldCount == 0)
{
return(true);
}
for (int i = 0; i < FieldCount; i++)
{
string name = GetName(i);
var propertyInfo = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.IgnoreCase);
if (propertyInfo != null)
{
object value = GetValue(i, propertyInfo.PropertyType);
propertyInfo.SetValue(result, value, null);
continue;
}
var fieldInfo = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.IgnoreCase);
if (fieldInfo != null)
{
object value = GetValue(i, fieldInfo.FieldType);
fieldInfo.SetValue(result, value);
continue;
}
}
return(true);
}
/// <summary>
/// 创建数据库连接。
/// </summary>
/// <param name="connectionOptions">连接参数。</param>
/// <returns>返回数据库连接。</returns>
public override IConnection CreateConnection(object connectionOptions)
{
{
if (connectionOptions is string connectionString)
{
connectionString = connectionString.Trim();
if (connectionString.StartsWith("{"))
{
connectionOptions = JSON.Parse(connectionString);
goto lb_Object;
}
return(CreateConnection(connectionString));
}
if (connectionOptions is ConnectionOptions connectionOptions2)
{
connectionOptions = connectionOptions2.ToObject();
goto lb_Object;
}
}
lb_Object:
System.Data.Common.DbConnectionStringBuilder builder = FastWrapper.CreateInstance <System.Data.Common.DbConnectionStringBuilder>(GetType("MySql.Data.MySqlClient.MySqlConnectionStringBuilder", true));
builder["pooling"] = true;
//builder["MaxPoolSize"] = 1024;
//builder["Port"] = 5432;
builder["Charset"] = "utf8";
Collections.Generic.NameValueCollection <object> values = new Collections.Generic.NameValueCollection <object>(connectionOptions);
SetBuilderValue(builder, "SslMode", "None");
SetBuilderValue(builder, values, "port", "Port");
SetBuilderValue(builder, values, "host", "Data Source", p => {
string p10 = p as string;
if (string.IsNullOrEmpty(p10))
{
return(p);
}
if (p10.IndexOf(':') > -1)
{
string[] pair = p10.Split(':');
SetBuilderValue(builder, "Port", pair[1]);
return(pair[0]);
}
return(p);
});
SetBuilderValue(builder, values, "name", "Database");
SetBuilderValue(builder, values, "account", "User ID");
SetBuilderValue(builder, values, "password", "Password");
foreach (System.Collections.Generic.KeyValuePair <string, object> item in values)
{
//builder[item.Key] = item.Value;
SetBuilderValue(builder, item.Key, item.Value);
}
return(CreateConnection(builder.ConnectionString));
}
/// <summary>
/// 创建 System.Data.SQLite.SQLiteConnectionStringBuilder
/// </summary>
/// <returns></returns>
public static System.Data.Common.DbConnectionStringBuilder CreateConnectionStringBuilder()
{
FastWrapper wrapper = GetType("System.Data.SQLite.SQLiteConnectionStringBuilder");
if (wrapper == null)
{
return(null);
}
System.Data.Common.DbConnectionStringBuilder builder = FastWrapper.CreateInstance(wrapper.Type) as System.Data.Common.DbConnectionStringBuilder;
FastWrapper.Set(builder, "Pooling", true);
FastWrapper.Set(builder, "FailIfMissing", false);
builder["journal mode"] = "Off";
return(builder);
}
/// <summary>
/// 注册
/// </summary>
/// <param name="assembly">程序集实例。</param>
public static void Register(System.Reflection.Assembly assembly)
{
if (assembly == null)
{
return;
}
var attributes = AttributeExtensions.GetCustomAttributes <ProviderAttribute>(assembly, true);
foreach (var item in attributes)
{
if (string.IsNullOrEmpty(item.Name) || item.Type == null)
{
continue;
}
_list_cache.TryAdd(item.Name, FastWrapper.CreateInstance <IProvider>(item.Type, new object[0]));
}
}
/// <summary>
/// 绑定数据。
/// </summary>
/// <param name="dataContext">数据上下文对象。</param>
/// <param name="reader">数据查询读取器。</param>
/// <param name="entity">当前实体对象。</param>
/// <param name="field">当前字段。</param>
/// <param name="type">实体中字段的类型。</param>
/// <param name="cache">缓存。</param>
/// <returns>返回绑定的数据。</returns>
public override object Bind(IDataContext dataContext, IDataQueryReader reader, object entity, string field, Type type, IDataBinderObjectCache cache)
{
var elementType = type.IsArray ? type.GetElementType() : type.GetGenericArguments()[0];
bool isSingleValue = (elementType == typeof(string) || elementType.IsValueType || TypeExtensions.IsNullableType(elementType));
if (isSingleValue && (string.IsNullOrEmpty(Field) || Field == "*"))
{
Field = "id";
}
string fix = "__";
using (var builder = dataContext.CreateSelect(SourceName)) {
//PreSelectBuilder(dataContext, dataReader, entity, builder, cache);
if (isSingleValue)
{
builder.Select(builder.Dialect.PreName(new string[] { fix, Field }));
}
else
{
builder.Select(builder.Dialect.PreName(fix) + ".*");
}
builder.Refer(NoSQL.Refer.Begin().Refence(fix, TargetName, TargetField, SourceName, SourceField).Json());
var conditiion = MapObject(Condition, dataContext, entity, reader);
builder.Query(conditiion).Sort(Sorter);
return(CacheFunc(cache, builder, "list.ref", type, () => {
var list = (System.Collections.IList)FastWrapper.CreateInstance(type);
var q = dataContext.CreateQuery(elementType, builder.CommandText, builder.Parameters);
q.DataBinderObjectCache = cache;
foreach (var item in q)
{
list.Add(item);
}
if (type.IsArray)
{
var array = Array.CreateInstance(elementType, list.Count);
list.CopyTo(array, 0);
return array;
}
return list;
}));
}
}
/// <summary>
/// 创建 System.Data.SQLite.SQLiteConnection
/// </summary>
/// <param name="connectionString">文件或连接字符串</param>
/// <returns></returns>
public static IDbConnection CreateConnection(string connectionString)
{
FastWrapper wrapper = GetType("System.Data.SQLite.SQLiteConnection");
if (wrapper == null)
{
return(null);
}
if (!_inited[0])
{
lock (_inited) {
if (!_inited[0])
{
_inited[0] = true;
RegisterFunction();
}
}
}
if (string.IsNullOrEmpty(connectionString))
{
//connectionString = AppHelper.AppFile + ".db";
return(FastWrapper.CreateInstance(wrapper.Type) as IDbConnection);
}
bool byFile = (System.IO.File.Exists(connectionString) || connectionString.IndexOf('=') == -1);
System.Data.Common.DbConnectionStringBuilder builder;
if (byFile)
{
builder = CreateConnectionStringBuilder(connectionString, null);
}
else
{
builder = CreateConnectionStringBuilder(connectionString);
}
if (builder == null)
{
return(null);
}
return(FastWrapper.CreateInstance(wrapper.Type, builder.ConnectionString) as IDbConnection);
}
static System.Collections.IList CreateTArray(KeyEntry keyEntry, int length, bool list, bool isT, Type type)
{
if (type == null)
{
if (isT)
{
type = _valueTypes[keyEntry.ValueType];
}
else
{
type = typeof(object);
}
}
if (list)
{
return((System.Collections.IList)FastWrapper.CreateInstance(typeof(System.Collections.Generic.List <>).MakeGenericType(type), length));
}
else
{
return(Array.CreateInstance(type, length));
}
}
static void UnPackageValueDictionary(KeyEntry keyEntry, Entry entry, byte[] buffer)
{
TreePackage package = Load(buffer);
if (package == null || package.Count == 0)
{
entry.Value = new System.Collections.Hashtable();
return;
}
bool isGeneric = (bool)package.Attributes["IsGeneric"];
System.Collections.IDictionary result = null;
if (isGeneric)
{
Type t1 = FastWrapper.GetWarpperType((string)package.Attributes["T1"]);
Type t2 = FastWrapper.GetWarpperType((string)package.Attributes["T2"]);
object comparer = FastWrapper.Get(typeof(System.Collections.Generic.EqualityComparer <>).MakeGenericType(t1), "Default");
if (package.Attributes.ContainsKey("KeyIsString") && (bool)package.Attributes["KeyIsString"])
{
comparer = (bool)package.Attributes["ComparerIgnoreCase"] ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;
}
result = (System.Collections.IDictionary)FastWrapper.CreateInstance(typeof(System.Collections.Generic.Dictionary <,>).MakeGenericType(t1, t2), package.Count, comparer);
}
else
{
result = new System.Collections.Hashtable(package.Count);
}
Entry entry2 = null;
for (int index = 0; index < package.Count; index++)
{
entry2 = package.Entries[index.ToString()];
result.Add(entry2.Attributes["Key"], entry2.Value);
}
entry.Value = result;
}
/// <summary>
/// 创建数据库连接。
/// </summary>
/// <param name="connectionString">连接字符串。</param>
/// <returns>返回数据库连接。</returns>
public override IConnection CreateConnection(string connectionString)
{
CommonException.CheckArgumentNull(connectionString, "connectionString");
System.Type type = GetConnectionType(true);
return(new PostgreSQLConnection(this, FastWrapper.CreateInstance <IDbConnection>(type, connectionString), connectionString));
}
static System.Collections.IList CreateList(System.Type type)
{
return((System.Collections.IList)FastWrapper.CreateInstance(typeof(System.Collections.Generic.List <>).MakeGenericType(type)));
}
/// <summary>
/// 创建实例
/// </summary>
/// <returns>返回实例</returns>
public ICharRecognizer CreateInstance()
{
return((ICharRecognizer)FastWrapper.CreateInstance(Type));
}
public object Load(byte[] buffer)
{
TreePackage package = TreePackage.Load(buffer);
if (!package.Attributes.ContainsKey("Type"))
{
return(null);
}
Type type = FastWrapper.GetWarpperType((string)package.Attributes["Type"]);
if (type == null)
{
throw new TypeMismatchException("未能找到类型“" + (string)package.Attributes["Type"] + "”");
}
//bool isAnonymousType = type.IsAnonymousType();
//if (isAnonymousType) {
// ConstructorInfo ctorX = type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic)[0];
// ParameterInfo[] @paramsX = ctorX.GetParameters();
// object[] argsX = new object[@paramsX.Length];
// for (int i = 0; i < @paramsX.Length; i++) {
// argsX[i] = package[@paramsX[i].Name];
// }
// return FastWrapper.CreateInstance(type, argsX);
//}
ConstructorInfo[] ctors = type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance | BindingFlags.Instance);
object[] args = null;
if (ctors.Length > 0)
{
ConstructorInfo ctor = ctors[0];
ParameterInfo[] @params = ctor.GetParameters();
args = new object[@params.Length];
for (int i = 0; i < @params.Length; i++)
{
string key = null;
foreach (string k in package.Keys)
{
if (k.Equals(@params[i].Name, StringComparison.OrdinalIgnoreCase))
{
key = k;
}
}
args[i] = package[key];
package.Remove(key);
}
}
else
{
args = new object[0];
}
object result = FastWrapper.CreateInstance(type, args);
foreach (string key in package.Keys)
{
PropertyInfo property = type.GetProperty(key, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
if (property == null)
{
FieldInfo field = type.GetField(key, BindingFlags.Public | BindingFlags.Instance);
if (field != null)
{
field.SetValue(result, package[key]);
}
continue;
}
//try {
if (property.CanWrite)
{
property.SetValue(result, TypeExtensions.Convert(package[key], property.PropertyType), null);
}
//} catch(Exception e){
// throw new Exception(string.Format("key={0},name={1},type:{2},{3}", key, property.Name, type.FullName,e.Message));
//}
}
return(result);
}
/// <summary>
/// 创建数据库连接。
/// </summary>
/// <param name="connectionString">连接字符串。</param>
/// <returns>返回数据库连接。</returns>
public override IConnection CreateConnection(string connectionString)
{
CommonException.CheckArgumentNull(connectionString, "connectionString");
return(new SqlServerConnection(this, FastWrapper.CreateInstance <System.Data.SqlClient.SqlConnection>(connectionString), connectionString));
}
/// <summary>
/// 创建实例
/// </summary>
/// <returns>返回实例</returns>
public ITakeHandler CreateInstance()
{
return((ITakeHandler)FastWrapper.CreateInstance(Type));
}
public object Load(byte[] buffer)
{
TreePackage package = TreePackage.Load(buffer);
if (!package.Attributes.ContainsKey("Type"))
{
return(null);
}
Type type = FastWrapper.GetWarpperType((string)package.Attributes["Type"]);
if (type == null)
{
CommonException.ThrowTypeMismatch("未能找到类型“" + (string)package.Attributes["Type"] + "”");
}
//bool isAnonymousType = type.IsAnonymousType();
//if (isAnonymousType) {
// ConstructorInfo ctorX = type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic)[0];
// ParameterInfo[] @paramsX = ctorX.GetParameters();
// object[] argsX = new object[@paramsX.Length];
// for (int i = 0; i < @paramsX.Length; i++) {
// argsX[i] = package[@paramsX[i].Name];
// }
// return FastWrapper.CreateInstance(type, argsX);
//}
ConstructorInfo[] ctors = type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance | BindingFlags.Instance);
object[] args = null;
if (ctors.Length > 0)
{
ConstructorInfo ctor = ctors[0];
ParameterInfo[] @params = ctor.GetParameters();
args = new object[@params.Length];
for (int i = 0; i < @params.Length; i++)
{
string key = null;
foreach (string k in package.Keys)
{
if (k.Equals(@params[i].Name, StringComparison.OrdinalIgnoreCase) || k.EndsWith(@params[i].Name, StringComparison.OrdinalIgnoreCase))
{
key = k;
}
}
if (string.IsNullOrEmpty(key))
{
return(null);
}
args[i] = package[key];
package.Remove(key);
}
}
else
{
args = new object[0];
}
object result = FastWrapper.CreateInstance(type, args);
foreach (string key in package.Keys)
{
FieldInfo field = type.GetField(key, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (field != null)
{
field.SetValue(result, TypeExtensions.Convert(package[key], field.FieldType));
}
}
return(result);
}
/// <summary>
/// 映射DataReader当前数据记录。
/// </summary>
/// <param name="reader">数据读取对象。</param>
/// <param name="type">实体类型。</param>
/// <returns>返回映射结果。</returns>
public static object Current(
#if !net20
this
#endif
IDataReader reader, Type type)
{
CommonException.CheckArgumentNull(reader, "reader");
if (reader.IsClosed)
{
return(null);
}
if (type != null && (type.IsValueType || reader.GetFieldType(0) == type || (reader.FieldCount == 1 && type == typeof(string))))
{
//只拿第一列
object value = reader.GetValue(0);
if (value == DBNull.Value)
{
return(TypeExtensions.DefaultValue(type));
}
return(TypeExtensions.Convert(value, type));
}
if (type != null)
{
if ((reader.FieldCount == 1 && (type.IsEnum || (TypeExtensions.IsNullableType(type) && TypeExtensions.GetNullableType(type).IsEnum))) || //枚举
(type.IsValueType || reader.GetFieldType(0) == type)) //类型匹配
{
object value = reader.GetValue(0);
return(TypeExtensions.Convert((value == DBNull.Value ? TypeExtensions.DefaultValue(type) : value), type));
}
}
Symbol.Collections.Generic.NameValueCollection <object> values = null;
object result = null;
if (type == null)
{
values = new Symbol.Collections.Generic.NameValueCollection <object>();
result = values;
}
else
{
result = FastWrapper.CreateInstance(type);
//IExtensibleModel extensiableModel = result as IExtensibleModel;
//if (extensiableModel != null) {
// values = extensiableModel.Extendeds = new Symbol.Collections.Generic.NameValueCollection<object>();
if (result is Symbol.Collections.Generic.NameValueCollection <object> )
{
values = (Symbol.Collections.Generic.NameValueCollection <object>)result;
type = null;
}
}
for (int i = 0; i < reader.FieldCount; i++)
{
string name = reader.GetName(i);
//int extIndex = name.IndexOf("ext_");
//if (extIndex != -1)
// name = name.Substring(extIndex + 4);
bool isJson = false;
if (reader.GetFieldType(i) == typeof(string))
{
string dataTypeName = reader.GetDataTypeName(i);
isJson = string.Equals(dataTypeName, "jsonb", StringComparison.OrdinalIgnoreCase) ||
string.Equals(dataTypeName, "json", StringComparison.OrdinalIgnoreCase);
}
object value = reader[i];
if (value == DBNull.Value)
{
value = null;
}
//if (isJson) {
// string text = value as string;
// if (!string.IsNullOrEmpty(text)) {
// value = JSON.Parse(text);
// }
//} else
if (reader.GetFieldType(i) == typeof(byte[]) && string.Equals(reader.GetDataTypeName(i), "timestamp", StringComparison.OrdinalIgnoreCase))
{
byte[] buffer = (byte[])value;
Array.Reverse(buffer);
}
if (string.IsNullOrEmpty(name))
{
if (values != null)
{
values.Add("无列名" + i, value);
}
continue;
}
if (type != null)
{
PropertyInfo property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.IgnoreCase);
if (property != null)
{
if (!isJson)
{
isJson = TypeExtensions.Convert <bool>(ConstAttributeExtensions.Const(property, "SaveAsJson"), false);
}
if (!isJson && reader.GetFieldType(i) == typeof(string) &&
(!property.PropertyType.IsValueType && property.PropertyType != typeof(string)))
{
isJson = true;
}
if (isJson && !property.PropertyType.IsValueType &&
property.PropertyType != typeof(string))
{
//value = Symbol.Serialization.ObjectConverter.ConvertObjectToType(value, property.PropertyType, new Serialization.JavaScriptSerializer());
value = JSON.ToObject(value as string, property.PropertyType);
}
else
{
value = TypeExtensions.Convert(value, property.PropertyType);
}
property.SetValue(result, value, null);
continue;
}
FieldInfo fieldInfo = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.IgnoreCase);
if (fieldInfo != null)
{
if (isJson && !fieldInfo.FieldType.IsValueType && fieldInfo.FieldType != typeof(string))
{
//value = Symbol.Serialization.ObjectConverter.ConvertObjectToType(value, fieldInfo.FieldType, new Serialization.JavaScriptSerializer());
value = JSON.ToObject(value as string, fieldInfo.FieldType);
}
else
{
value = TypeExtensions.Convert(value, fieldInfo.FieldType);
}
fieldInfo.SetValue(result, value);
continue;
}
}
if (values == null)
{
continue;
}
if (value != null)
{
lb_Json_retry:
if (isJson)
{
value = JSON.Parse(value as string, true);
}
else if (string.Equals(reader.GetDataTypeName(i), "char(1)", StringComparison.OrdinalIgnoreCase) ||
string.Equals(reader.GetDataTypeName(i), "nchar(1)", StringComparison.OrdinalIgnoreCase))
{
value = reader.GetChar(i);
}
else if (value is string)
{
string text = ((string)value).Trim();
if (text != null && ((text.StartsWith("{") && text.EndsWith("}")) || (text.StartsWith("[") && text.EndsWith("]"))))
{
isJson = true;
goto lb_Json_retry;
}
}
}
values[name] = value;
if (isJson && reader.FieldCount == 1 && (type == null || type == typeof(object)))
{
return(value);
}
//values[name] = reader.GetValue(i);
//if (values[name] == DBNull.Value)
// values[name] = null;
//else if (values[name] != null) {
// if (string.Equals(reader.GetDataTypeName(i), "char(1)", StringComparison.OrdinalIgnoreCase)
// || string.Equals(reader.GetDataTypeName(i), "nchar(1)", StringComparison.OrdinalIgnoreCase)) {
// values[name] = reader.GetChar(i);
// }
//}
}
return(result);
}
/// <summary>
/// 创建 NameValueCollection 的实例。
/// </summary>
/// <param name="info">序列化信息。</param>
/// <param name="context">序列化上下文。</param>
protected NameValueCollection(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
{
_dictionary = FastWrapper.CreateInstance <Dictionary <string, T> >(info, context);
}
/// <summary>
/// 从byte[]中加载对象。
/// </summary>
/// <param name="buffer">对象的数据。</param>
/// <returns>返回解析后的对象。</returns>
public object Load(byte[] buffer)
{
return(((ICustomPackage)FastWrapper.CreateInstance(CustomPackageType)).Load(buffer));
}
/// <summary>
/// 将对象打包为byte[]
/// </summary>
/// <param name="instance">需要保存的实例，没有null的情况。</param>
/// <returns>返回打包后的数据。</returns>
public byte[] Save(object instance)
{
return(((ICustomPackage)FastWrapper.CreateInstance(CustomPackageType)).Save(instance));
}
/// <summary>
/// 映射为实体对象：字典尝试。
/// </summary>
/// <param name="type">类型，为空则尝试失败。</param>
/// <param name="result">输出结果。</param>
/// <returns>返回是否尝试成功。</returns>
protected virtual bool ToObject_Try_Dictionary(System.Type type, out object result)
{
result = null;
DictionaryAddAction dictionaryAdd;
if (type == null || type == typeof(object))
{
//默认类型
var values = new Symbol.Collections.Generic.NameValueCollection <object>();
result = values;
dictionaryAdd = values.Add;
}
else if (TypeExtensions.IsInheritFrom(type, typeof(Collections.Generic.NameValueCollection <object>)))
{
//继承关系
var values = FastWrapper.CreateInstance <Collections.Generic.NameValueCollection <object> >(type, new object[0]);
result = values;
dictionaryAdd = values.Add;
}
else if (TypeExtensions.IsInheritFrom(type, typeof(System.Collections.Generic.IDictionary <string, object>)))
{
//泛型
var values = FastWrapper.CreateInstance <System.Collections.Generic.IDictionary <string, object> >(type, new object[0]);
result = values;
dictionaryAdd = (key, value) => {
if (values.TryGetValue(key, out object p))
{
values[key] = value;
}
else
{
values.Add(key, value);
}
};
}
else if (TypeExtensions.IsInheritFrom(type, typeof(System.Collections.IDictionary)))
{
//非泛型
var values = FastWrapper.CreateInstance <System.Collections.IDictionary>(type, new object[0]);
result = values;
dictionaryAdd = (key, value) => {
if (values.Contains(key))
{
values[key] = value;
}
else
{
values.Add(key, value);
}
};
}
else
{
//剩下的没有可能性
return(false);
}
for (int i = 0; i < FieldCount; i++)
{
string name = GetName(i);
object value = GetValue(i);
if (TryParseJSON(value, out object jsonObject))
{
value = jsonObject;
}
dictionaryAdd(string.IsNullOrEmpty(name) ? ("无列名" + i) : name, value);
}
return(true);
}
unsafe static TreePackage()
{
#region typecode map ValueType
_typeCodes = new Dictionary <TypeCode, PackageValueTypes>();
_typeCodes.Add(TypeCode.Boolean, PackageValueTypes.Boolean);
_typeCodes.Add(TypeCode.Byte, PackageValueTypes.Byte);
_typeCodes.Add(TypeCode.Char, PackageValueTypes.Char);
_typeCodes.Add(TypeCode.Int16, PackageValueTypes.Int16);
_typeCodes.Add(TypeCode.Int32, PackageValueTypes.Int32);
_typeCodes.Add(TypeCode.Int64, PackageValueTypes.Int64);
_typeCodes.Add(TypeCode.Single, PackageValueTypes.Single);
_typeCodes.Add(TypeCode.Double, PackageValueTypes.Double);
_typeCodes.Add(TypeCode.SByte, PackageValueTypes.SByte);
_typeCodes.Add(TypeCode.Decimal, PackageValueTypes.Decimal);
_typeCodes.Add(TypeCode.UInt16, PackageValueTypes.UInt16);
_typeCodes.Add(TypeCode.UInt32, PackageValueTypes.UInt32);
_typeCodes.Add(TypeCode.UInt64, PackageValueTypes.UInt64);
_typeCodes.Add(TypeCode.DateTime, PackageValueTypes.DateTime);
_typeCodes.Add(TypeCode.String, PackageValueTypes.String);
_typeCodes.Add(TypeCode.Object, PackageValueTypes.Object);
_typeCodes.Add(TypeCode.DBNull, PackageValueTypes.Object);
_typeCodes.Add(TypeCode.Empty, PackageValueTypes.Object);
#endregion
#region type map ValueType
_typeValueTypes = new Dictionary <Type, PackageValueTypes>();
_typeValueTypes.Add(typeof(string), PackageValueTypes.String);
_typeValueTypes.Add(typeof(IntPtr), PackageValueTypes.IntPtr);
_typeValueTypes.Add(typeof(UIntPtr), PackageValueTypes.UIntPtr);
_typeValueTypes.Add(typeof(TimeSpan), PackageValueTypes.TimeSpan);
_typeValueTypes.Add(typeof(Guid), PackageValueTypes.Guid);
_typeValueTypes.Add(typeof(System.Drawing.Icon), PackageValueTypes.Icon);
_typeValueTypes.Add(typeof(System.Drawing.Color), PackageValueTypes.Color);
_typeValueTypes.Add(typeof(System.Drawing.Image), PackageValueTypes.Image);
_typeValueTypes.Add(typeof(TreePackage), PackageValueTypes.NestedPackage);
_typeValueTypes.Add(typeof(Stream), PackageValueTypes.Stream);
#endregion
#region valueType map Type
_valueTypes = new Dictionary <PackageValueTypes, Type>();
_valueTypes.Add(PackageValueTypes.Boolean, typeof(bool));
_valueTypes.Add(PackageValueTypes.Byte, typeof(byte));
_valueTypes.Add(PackageValueTypes.Char, typeof(char));
_valueTypes.Add(PackageValueTypes.Int16, typeof(short));
_valueTypes.Add(PackageValueTypes.Int32, typeof(int));
_valueTypes.Add(PackageValueTypes.Int64, typeof(long));
_valueTypes.Add(PackageValueTypes.Single, typeof(float));
_valueTypes.Add(PackageValueTypes.Double, typeof(double));
_valueTypes.Add(PackageValueTypes.SByte, typeof(sbyte));
_valueTypes.Add(PackageValueTypes.Decimal, typeof(decimal));
_valueTypes.Add(PackageValueTypes.UInt16, typeof(ushort));
_valueTypes.Add(PackageValueTypes.UInt32, typeof(uint));
_valueTypes.Add(PackageValueTypes.UInt64, typeof(ulong));
_valueTypes.Add(PackageValueTypes.IntPtr, typeof(IntPtr));
_valueTypes.Add(PackageValueTypes.UIntPtr, typeof(UIntPtr));
_valueTypes.Add(PackageValueTypes.DateTime, typeof(DateTime));
_valueTypes.Add(PackageValueTypes.TimeSpan, typeof(TimeSpan));
_valueTypes.Add(PackageValueTypes.String, typeof(string));
_valueTypes.Add(PackageValueTypes.Stream, typeof(Stream));
_valueTypes.Add(PackageValueTypes.Icon, typeof(System.Drawing.Icon));
_valueTypes.Add(PackageValueTypes.Image, typeof(System.Drawing.Image));
_valueTypes.Add(PackageValueTypes.Color, typeof(System.Drawing.Color));
_valueTypes.Add(PackageValueTypes.NestedPackage, typeof(TreePackage));
_valueTypes.Add(PackageValueTypes.Object, typeof(object));
#endregion
#region compressor map handlers
_compressors = new Dictionary <PackageCompressTypes, CompressorHandler>();
_compressors.Add(PackageCompressTypes.QuickLZ, Compressor_QuickLZ);
_compressors.Add(PackageCompressTypes.Gzip, Compressor_Gzip);
_compressors.Add(PackageCompressTypes.Lzma7z, Compressor_Lzma);
//_compressors.Add(PackageCompressTypes.Zlibwapi, (buffer, compress) => compress ? Symbol.IO.Compression.ZlibwapiHelper.Compress(buffer) : Symbol.IO.Compression.ZlibwapiHelper.Decompress(buffer));
_compressors.Add(PackageCompressTypes.NonEncrypt_NonCompress, Compressor_Empty);
#endregion
#region valueType map package SingleData Handler
_packageValueSingleDataHandlers = new Dictionary <PackageValueTypes, PackageValueSingleDataHandler>();
_packageValueSingleDataHandlers.Add(PackageValueTypes.Boolean, (keyEntry, entry) => {
byte[] result = new byte[1];
if ((bool)entry.Value)
{
result[0] = 1;
}
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Byte, (keyEntry, entry) => new byte[] { (byte)entry.Value });
_packageValueSingleDataHandlers.Add(PackageValueTypes.Char, (keyEntry, entry) => {
byte[] result = new byte[2];
char tChar = (char)entry.Value;
Marshal.Copy((IntPtr)(&tChar), result, 0, 2);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Int16, (keyEntry, entry) => {
short tShort = TypeExtensions.Convert <short>(entry.Value, 0);
byte[] result = new byte[2];
Marshal.Copy((IntPtr)(&tShort), result, 0, 2);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Int32, (keyEntry, entry) => {
int tInt32 = TypeExtensions.Convert <int>(entry.Value, 0);
byte[] result = new byte[4];
Marshal.Copy((IntPtr)(&tInt32), result, 0, 4);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Int64, (keyEntry, entry) => {
long tInt64 = TypeExtensions.Convert <long>(entry.Value, 0L);
byte[] result = new byte[8];
Marshal.Copy((IntPtr)(&tInt64), result, 0, 8);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Single, (keyEntry, entry) => {
float tSingle = TypeExtensions.Convert <float>(entry.Value, 0F);
byte[] result = new byte[4];
Marshal.Copy((IntPtr)(&tSingle), result, 0, 4);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Double, (keyEntry, entry) => {
double tDouble = TypeExtensions.Convert <double>(entry.Value, 0D);
byte[] result = new byte[8];
Marshal.Copy((IntPtr)(&tDouble), result, 0, 8);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.SByte, (keyEntry, entry) => {
sbyte tSByte = TypeExtensions.Convert <sbyte>(entry.Value, 0);
byte[] result = new byte[1];
Marshal.Copy((IntPtr)(&tSByte), result, 0, 1);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Decimal, (keyEntry, entry) => Encoding.ASCII.GetBytes(entry.Value.ToString()));
_packageValueSingleDataHandlers.Add(PackageValueTypes.UInt16, (keyEntry, entry) => {
ushort tUShort = TypeExtensions.Convert <ushort>(entry.Value, 0);
byte[] result = new byte[2];
Marshal.Copy((IntPtr)(&tUShort), result, 0, 2);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.UInt32, (keyEntry, entry) => {
uint tUInt32 = TypeExtensions.Convert <uint>(entry.Value, 0);
byte[] result = new byte[4];
Marshal.Copy((IntPtr)(&tUInt32), result, 0, 4);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.UInt64, (keyEntry, entry) => {
ulong tUInt64 = TypeExtensions.Convert <ulong>(entry.Value, 0L);
byte[] result = new byte[8];
Marshal.Copy((IntPtr)(&tUInt64), result, 0, 8);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.IntPtr, (keyEntry, entry) => {
IntPtr tIntPtr = (IntPtr)entry.Value;
byte[] result = new byte[IntPtr.Size];
if (IntPtr.Size == 4)
{
int tIntPtr2 = tIntPtr.ToInt32();
Marshal.Copy((IntPtr)(&tIntPtr2), result, 0, 4);
}
else
{
long tIntPtr3 = tIntPtr.ToInt64();
Marshal.Copy((IntPtr)(&tIntPtr3), result, 0, 8);
}
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.UIntPtr, (keyEntry, entry) => {
UIntPtr tUIntPtr = (UIntPtr)entry.Value;
byte[] result = new byte[UIntPtr.Size];
if (UIntPtr.Size == 4)
{
uint tUIntPtr2 = tUIntPtr.ToUInt32();
Marshal.Copy((IntPtr)(&tUIntPtr2), result, 0, 4);
}
else
{
ulong tUIntPtr3 = tUIntPtr.ToUInt64();
Marshal.Copy((IntPtr)(&tUIntPtr3), result, 0, 8);
}
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.DateTime, (keyEntry, entry) => {
return(Encoding.ASCII.GetBytes(((DateTime)entry.Value).ToString("yyyy-MM-dd HH:mm:ss")));
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.TimeSpan, (keyEntry, entry) => {
double tTimeSpan = ((TimeSpan)entry.Value).TotalMilliseconds;
byte[] result = new byte[8];
Marshal.Copy((IntPtr)(&tTimeSpan), result, 0, 8);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.String, (keyEntry, entry) => Encoding.UTF8.GetBytes((string)entry.Value));
_packageValueSingleDataHandlers.Add(PackageValueTypes.Stream, (keyEntry, entry) => {
MemoryStream memoryStream = entry.Value as MemoryStream;
if (memoryStream != null)
{
return(memoryStream.ToArray());
}
FileStream fileStream = entry.Value as FileStream;
if (fileStream != null)
{
fileStream.Position = 0;
byte[] result = new byte[fileStream.Length];
fileStream.Read(result, 0, result.Length);
return(result);
}
using (memoryStream = new MemoryStream()) {
StreamExtensions.CopyTo(((Stream)entry.Value), memoryStream, true);
return(memoryStream.ToArray());
}
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Icon, (keyEntry, entry) => {
using (MemoryStream memoryStream = new MemoryStream()) {
((System.Drawing.Icon)entry.Value).Save(memoryStream);
return(memoryStream.ToArray());
}
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Image, (keyEntry, entry) => {
using (MemoryStream memoryStream = new MemoryStream()) {
System.Drawing.Image p = (System.Drawing.Image)entry.Value;
p.Save(memoryStream, p.RawFormat);
return(memoryStream.ToArray());
}
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Color, (keyEntry, entry) => {
int tColor = ((System.Drawing.Color)entry.Value).ToArgb();
byte[] result = new byte[4];
Marshal.Copy((IntPtr)(&tColor), result, 0, 4);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Guid, (keyEntry, entry) => ((Guid)entry.Value).ToByteArray());
_packageValueSingleDataHandlers.Add(PackageValueTypes.NestedPackage, (keyEntry, entry) => ((TreePackage)entry.Value).Save());
_packageValueSingleDataHandlers.Add(PackageValueTypes.Object, (keyEntry, entry) => {
Type type = entry.Value.GetType();
if (AttributeExtensions.IsDefined <NonPackageAttribute>(type) || AttributeExtensions.IsDefined <Formatting.IgnoreAttribute>(type))
{
return(new byte[0]);
}
ICustomPackage customPackage = null;
byte flag;
if (AttributeExtensions.IsDefined <PropertyPackageAttribute>(type))
{
customPackage = PropertyPackage.Instance;
flag = 0;
}
else if (AttributeExtensions.IsDefined <FieldPackageAttribute>(type))
{
customPackage = FieldPackage.Instance;
flag = 1;
}
else if (AttributeExtensions.IsDefined <CustomPackageAttribute>(type))
{
var attribute = AttributeExtensions.GetCustomAttribute <CustomPackageAttribute>(type);
customPackage = FastWrapper.CreateInstance <ICustomPackage>(attribute.CustomPackageType);
//customPackage= CustomPackageAttribute.GetCustomPackageType(type);
flag = 255;
}
else
{
customPackage = PropertyPackage.Instance;
flag = 0;
}
using (MemoryStream stream = new MemoryStream(128)) {
stream.WriteByte(flag);
byte[] buffer = null;
if (flag == 255)
{
buffer = Encoding.UTF8.GetBytes(customPackage.GetType().AssemblyQualifiedName);
short iShort = (short)buffer.Length;
byte[] buffer2 = new byte[2];
Marshal.Copy((IntPtr)(&iShort), buffer2, 0, 2);
stream.Write(buffer2, 0, buffer2.Length);
stream.Write(buffer, 0, buffer.Length);
}
buffer = customPackage.Save(entry.Value);
stream.Write(buffer, 0, buffer.Length);
return(stream.ToArray());
}
});
#endregion
#region valueType map unpackage SingleData Handler
_unPakcageValueSingleDataHandlers = new Dictionary <PackageValueTypes, UnPackageValueSingleDataHandler>();
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Boolean, (keyEntry, entry, buffer) => entry.Value = buffer[0] == 1);
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Byte, (keyEntry, entry, buffer) => entry.Value = buffer[0]);
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Char, (keyEntry, entry, buffer) => {
char tChar;;
Marshal.Copy(buffer, 0, (IntPtr)(&tChar), 2);
entry.Value = tChar;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Int16, (keyEntry, entry, buffer) => {
short tShort;
Marshal.Copy(buffer, 0, (IntPtr)(&tShort), 2);
entry.Value = tShort;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Int32, (keyEntry, entry, buffer) => {
int tInt32;
Marshal.Copy(buffer, 0, (IntPtr)(&tInt32), 4);
entry.Value = tInt32;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Int64, (keyEntry, entry, buffer) => {
long tInt64;
Marshal.Copy(buffer, 0, (IntPtr)(&tInt64), 8);
entry.Value = tInt64;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Single, (keyEntry, entry, buffer) => {
float tSingle;
Marshal.Copy(buffer, 0, (IntPtr)(&tSingle), 4);
entry.Value = tSingle;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Double, (keyEntry, entry, buffer) => {
double tDouble;
Marshal.Copy(buffer, 0, (IntPtr)(&tDouble), 8);
entry.Value = tDouble;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.SByte, (keyEntry, entry, buffer) => {
sbyte tSByte;
Marshal.Copy(buffer, 0, (IntPtr)(&tSByte), 1);
entry.Value = tSByte;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Decimal, (keyEntry, entry, buffer) => entry.Value = decimal.Parse(Encoding.ASCII.GetString(buffer)));
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.UInt16, (keyEntry, entry, buffer) => {
ushort tUShort;
Marshal.Copy(buffer, 0, (IntPtr)(&tUShort), 2);
entry.Value = tUShort;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.UInt32, (keyEntry, entry, buffer) => {
uint tUInt32;
Marshal.Copy(buffer, 0, (IntPtr)(&tUInt32), 4);
entry.Value = tUInt32;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.UInt64, (keyEntry, entry, buffer) => {
ulong tUInt64;
Marshal.Copy(buffer, 0, (IntPtr)(&tUInt64), 8);
entry.Value = tUInt64;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.IntPtr, (keyEntry, entry, buffer) => {
IntPtr tIntPtr;
if (buffer.Length == 4)
{
int tIntPtr2;
Marshal.Copy(buffer, 0, (IntPtr)(&tIntPtr2), 4);
tIntPtr = new IntPtr(tIntPtr2);
}
else
{
long tIntPtr3;
Marshal.Copy(buffer, 0, (IntPtr)(&tIntPtr3), 8);
tIntPtr = new IntPtr(tIntPtr3);
}
entry.Value = tIntPtr;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.UIntPtr, (keyEntry, entry, buffer) => {
UIntPtr tUIntPtr;
if (buffer.Length == 4)
{
uint tUIntPtr2;
Marshal.Copy(buffer, 0, (IntPtr)(&tUIntPtr2), 4);
tUIntPtr = new UIntPtr(tUIntPtr2);
}
else
{
ulong tUIntPtr3;
Marshal.Copy(buffer, 0, (IntPtr)(&tUIntPtr3), 8);
tUIntPtr = new UIntPtr(tUIntPtr3);
}
entry.Value = tUIntPtr;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.DateTime, (keyEntry, entry, buffer) => entry.Value = DateTime.Parse(Encoding.ASCII.GetString(buffer)));
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.TimeSpan, (keyEntry, entry, buffer) => {
double tTimeSpan;
Marshal.Copy(buffer, 0, (IntPtr)(&tTimeSpan), 8);
entry.Value = TimeSpan.FromMilliseconds(tTimeSpan);
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.String, (keyEntry, entry, buffer) => entry.Value = Encoding.UTF8.GetString(buffer));
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Stream, (keyEntry, entry, buffer) => entry.Value = new MemoryStream(buffer));
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Icon, (keyEntry, entry, buffer) => {
using (MemoryStream memoryStream = new MemoryStream(buffer)) {
entry.Value = new System.Drawing.Icon(memoryStream);
}
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Image, (keyEntry, entry, buffer) => {
using (MemoryStream memoryStream = new MemoryStream(buffer)) {
entry.Value = System.Drawing.Image.FromStream(memoryStream);
}
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Color, (keyEntry, entry, buffer) => {
int tColor;
Marshal.Copy(buffer, 0, (IntPtr)(&tColor), 4);
entry.Value = System.Drawing.Color.FromArgb(tColor);
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Guid, (keyEntry, entry, buffer) => entry.Value = new Guid(buffer));
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.NestedPackage, (keyEntry, entry, buffer) => entry.Value = Load(buffer));
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Object, (keyEntry, entry, buffer) => {
if (buffer.Length == 0)//NonPackage
{
return;
}
using (MemoryStream stream = new MemoryStream(buffer)) {
byte flag = (byte)stream.ReadByte();
ICustomPackage customPackage = null;
byte[] buffer2;
if (flag == 0)
{
customPackage = PropertyPackage.Instance;
}
else if (flag == 1)
{
customPackage = FieldPackage.Instance;
}
else if (flag == 255)
{
short iShort;
buffer2 = new byte[2];
stream.Read(buffer2, 0, 2);
Marshal.Copy(buffer2, 0, (IntPtr)(&iShort), 2);
buffer2 = new byte [iShort];
stream.Read(buffer2, 0, iShort);
string typeFullName = Encoding.UTF8.GetString(buffer2);
Type customType = FastWrapper.GetWarpperType(typeFullName);
if (customType == null)
{
throw new TypeLoadException("未能找到类型“" + typeFullName + "”");
}
customPackage = (ICustomPackage)FastWrapper.CreateInstance(customType);
}
else
{
throw new NotSupportedException();
}
//read to end
buffer2 = new byte[stream.Length - stream.Position];
stream.Read(buffer2, 0, buffer2.Length);
entry.Value = customPackage.Load(buffer2);
}
});
#endregion
}
