/// <summary>
/// Register the screens in the application database
/// </summary>
/// <param name="assembly">Current Assembly</param>
/// <returns>Void</returns>
public static void RegisterScreens(Assembly assembly)
{
List <ScreenRoute> existingScreenRoute = userRepository.GetAvailableScreens();
List <ScreenRoute> controllerActions = assembly.GetTypes().Where(types => typeof(Controller).IsAssignableFrom(types))
.SelectMany(type => type.GetMethods())
.Where(method => method.IsPublic && !method.IsDefined(typeof(NonActionAttribute)) && method.IsDefined(typeof(LinkFilter)) && !method.DeclaringType.Name.Equals("Controller") && method.DeclaringType.Name.EndsWith("Controller")).Select(
screenRoutes => new ScreenRoute
{
ActionName = screenRoutes.GetType().IsDefined(typeof(ActionNameAttribute)) ? AttributeExtensions.GetCustomAttribute <ActionNameAttribute>(screenRoutes).Name : screenRoutes.Name,
ControllerName = screenRoutes.DeclaringType.Name,
AreaName = GetAreaName(screenRoutes.DeclaringType.FullName, screenRoutes.DeclaringType.Name),
LinkText = AttributeExtensions.GetCustomAttribute <LinkFilter>(screenRoutes).LinkText,
Read = AttributeExtensions.GetCustomAttribute <LinkFilter>(screenRoutes).Read,
Delete = AttributeExtensions.GetCustomAttribute <LinkFilter>(screenRoutes).Delete,
Write = AttributeExtensions.GetCustomAttribute <LinkFilter>(screenRoutes).Write,
GroupMenuTitle = AttributeExtensions.GetCustomAttribute <GroupMenuTitle>(screenRoutes.DeclaringType).Title,
}).ToList();
List <ScreenRoute> missingScreens = controllerActions.Except(existingScreenRoute).ToList();
foreach (ScreenRoute screens in missingScreens)
{
userRepository.AddApplicationScreens(screens);
}
}
static System.Collections.Generic.List <BindItem> TryGetBind(System.Type entityType)
{
string key = entityType.AssemblyQualifiedName;
var list = _list_key.GetOrAdd(key, (p) => {
if (entityType.IsValueType || entityType == typeof(string) || entityType == typeof(object) || TypeExtensions.IsNullableType(entityType))
{
return(null);
}
var cache = new System.Collections.Generic.List <BindItem>();
foreach (System.Reflection.PropertyInfo propertyInfo in entityType.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.GetProperty | System.Reflection.BindingFlags.SetProperty))
{
var binder = AttributeExtensions.GetCustomAttribute <DataBinderAttribute>(propertyInfo);
if (binder == null)
{
continue;
}
BindItem bindItem = new BindItem()
{
propertyInfo = propertyInfo,
binder = binder,
bindAction = binder.Bind,
};
cache.Add(bindItem);
}
return(cache);
});
return(list);
}
static System.Collections.Generic.List <BindItem> TryGetBind(System.Type entityType)
{
string key = entityType.AssemblyQualifiedName;
System.Collections.Generic.List <BindItem> list;
if (!_list_key.TryGetValue(key, out list))
{
ThreadHelper.Block(_list_key, () => {
if (!_list_key.TryGetValue(key, out list))
{
if (entityType.IsValueType || entityType == typeof(string) || entityType == typeof(object) || TypeExtensions.IsNullableType(entityType))
{
_list_key.TryAdd(key, null);
return;
}
list = new System.Collections.Generic.List <BindItem>();
foreach (System.Reflection.PropertyInfo propertyInfo in entityType.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.GetProperty | System.Reflection.BindingFlags.SetProperty))
{
var binder = AttributeExtensions.GetCustomAttribute <DataBinderAttribute>(propertyInfo);
if (binder == null)
{
continue;
}
BindItem bindItem = new BindItem()
{
propertyInfo = propertyInfo,
binder = binder,
bindAction = binder.Bind,
};
list.Add(bindItem);
}
_list_key.TryAdd(key, list.Count == 0 ? null : list);
}
});
}
return(list);
}
public static string Decrypt <T>(Expression <Func <T> > property)
{
var value = property.Compile()();
var cipherText = value.ToString();
try
{
var passPhrase = AttributeExtensions.GetCustomAttribute <T, EncryptAttribute>(property).Key;
var cipherTextBytes = Convert.FromBase64String(cipherText);
using (var password = new PasswordDeriveBytes(passPhrase, null))
{
var keyBytes = password.GetBytes(keysize / 8);
using (var symmetricKey = new RijndaelManaged())
{
symmetricKey.Mode = CipherMode.CBC;
using (var decryptor = symmetricKey.CreateDecryptor(keyBytes, initVectorBytes))
{
using (var memoryStream = new MemoryStream(cipherTextBytes))
{
using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
{
var plainTextBytes = new byte[cipherTextBytes.Length];
var decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
return(Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount));
}
}
}
}
}
}
catch (Exception)
{
return(cipherText);
}
}
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
}
static System.Type GenerateFunctionType(System.Type functionType)
{
SQLiteFunctionAttribute attribute = AttributeExtensions.GetCustomAttribute <SQLiteFunctionAttribute>(functionType);
if (attribute == null)
{
return(null);
}
bool ex = TypeExtensions.IsInheritFrom(functionType, typeof(SQLiteFunctionEx)) || attribute.Type == FunctionTypes.Collation;
FastWrapper baseType = GetType(ex ? "System.Data.SQLite.SQLiteFunctionEx" : "System.Data.SQLite.SQLiteFunction");
System.Reflection.AssemblyName assemblyName = new System.Reflection.AssemblyName(functionType.Namespace + ".DynamicClass_" + functionType.Name);
System.Reflection.Emit.AssemblyBuilderAccess accemblyBuilderAccess =
#if netcore
System.Reflection.Emit.AssemblyBuilderAccess.Run;
#else
IsDebug
? System.Reflection.Emit.AssemblyBuilderAccess.RunAndSave
: System.Reflection.Emit.AssemblyBuilderAccess.Run;
#endif
System.Reflection.Emit.AssemblyBuilder assembly =
#if netcore
System.Reflection.Emit.AssemblyBuilder.DefineDynamicAssembly(assemblyName, accemblyBuilderAccess);
#else
System.AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, accemblyBuilderAccess);
#endif
#if !netcore
bool canSave = (accemblyBuilderAccess == System.Reflection.Emit.AssemblyBuilderAccess.RunAndSave || accemblyBuilderAccess == System.Reflection.Emit.AssemblyBuilderAccess.Save);
#endif
System.Reflection.Emit.ModuleBuilder module =
#if netcore
assembly.DefineDynamicModule(assemblyName.Name);
#else
canSave
? assembly.DefineDynamicModule(assemblyName.Name, assemblyName.Name + ".dll")
: assembly.DefineDynamicModule(assemblyName.Name);//, n.Name + ".dll");
#endif
System.Reflection.Emit.TypeBuilder type = module.DefineType(
assemblyName.Name + ".DynamicClass",
System.Reflection.TypeAttributes.Public | System.Reflection.TypeAttributes.Sealed | System.Reflection.TypeAttributes.AutoClass,
baseType.Type,
System.Type.EmptyTypes);
{
FastWrapper wrapper = GetType("System.Data.SQLite.SQLiteFunctionAttribute");
System.Reflection.PropertyInfo[] properties = new System.Reflection.PropertyInfo[] {
wrapper.Type.GetProperty("Name"),
wrapper.Type.GetProperty("Arguments"),
wrapper.Type.GetProperty("FuncType"),
};
System.Reflection.Emit.CustomAttributeBuilder attributeBuilder = new System.Reflection.Emit.CustomAttributeBuilder(wrapper.Type.GetConstructor(System.Type.EmptyTypes), new object[0],
properties, new object[] {
attribute.Name,
attribute.Arguments,
TypeExtensions.Convert(attribute.Type, GetType("System.Data.SQLite.FunctionType").Type),
});
type.SetCustomAttribute(attributeBuilder);
}
System.Reflection.Emit.FieldBuilder _o = type.DefineField("_o", functionType, FieldAttributes.Private);
{
System.Reflection.Emit.ConstructorBuilder ctor = type.DefineConstructor(
System.Reflection.MethodAttributes.Public | System.Reflection.MethodAttributes.HideBySig | System.Reflection.MethodAttributes.SpecialName | System.Reflection.MethodAttributes.RTSpecialName,
System.Reflection.CallingConventions.HasThis,
System.Type.EmptyTypes);
System.Reflection.Emit.ILGenerator il = ctor.GetILGenerator();
il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
il.Emit(System.Reflection.Emit.OpCodes.Call, baseType.Type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance | BindingFlags.Instance, null, System.Type.EmptyTypes, new System.Reflection.ParameterModifier[0]));
il.Emit(System.Reflection.Emit.OpCodes.Nop);
il.Emit(System.Reflection.Emit.OpCodes.Nop);
il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
il.Emit(System.Reflection.Emit.OpCodes.Newobj, functionType.GetConstructor(System.Type.EmptyTypes));
il.Emit(System.Reflection.Emit.OpCodes.Stfld, _o);
il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
il.Emit(System.Reflection.Emit.OpCodes.Ldfld, _o);
il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
if (attribute.Type == FunctionTypes.Collation)
{
il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_1);
}
else
{
il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0);
}
il.Emit(System.Reflection.Emit.OpCodes.Callvirt, functionType.GetMethod("Init", BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod, null, new System.Type[] {
typeof(object), typeof(bool)
}, null));
il.Emit(System.Reflection.Emit.OpCodes.Nop);
il.Emit(System.Reflection.Emit.OpCodes.Ret);
}
CreateMethodDelegate createMethod = (methodInfo, action) => {
System.Reflection.ParameterInfo[] parameters = methodInfo.GetParameters();
System.Type[] parameterTypes = new System.Type[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
parameterTypes[i] = parameters[i].ParameterType;
}
System.Reflection.Emit.MethodBuilder method = type.DefineMethod(methodInfo.Name, (methodInfo.Attributes | MethodAttributes.NewSlot) ^ MethodAttributes.NewSlot, methodInfo.CallingConvention, methodInfo.ReturnType, parameterTypes);
for (int i = 0; i < parameters.Length; i++)
{
System.Reflection.Emit.ParameterBuilder parameter = method.DefineParameter(i + 1, parameters[i].Attributes, parameters[i].Name);
if (parameters[i].IsOptional)
{
if (parameters[i].ParameterType.IsValueType && parameters[i].DefaultValue == null)
{
continue;
}
parameter.SetConstant(parameters[i].DefaultValue);
}
}
System.Reflection.Emit.ILGenerator il = method.GetILGenerator();
bool hasReturn = (methodInfo.ReturnType != typeof(void));
System.Reflection.Emit.LocalBuilder @return = null;
if (hasReturn)
{
@return = il.DeclareLocal(methodInfo.ReturnType);
}
il.Emit(System.Reflection.Emit.OpCodes.Nop);
il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
il.Emit(System.Reflection.Emit.OpCodes.Ldfld, _o);
action(functionType.GetMethod(methodInfo.Name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance), method, il);
il.Emit(System.Reflection.Emit.OpCodes.Ret);
};
if (attribute.Type == FunctionTypes.Scalar)
{
createMethod(baseType.Type.GetMethod("Invoke"), (methodInfo, method, il) => {
il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1);
il.Emit(System.Reflection.Emit.OpCodes.Callvirt, methodInfo);
il.Emit(System.Reflection.Emit.OpCodes.Stloc_0);
System.Reflection.Emit.Label label = il.DefineLabel();
il.Emit(System.Reflection.Emit.OpCodes.Br_S, label);
il.MarkLabel(label);
il.Emit(System.Reflection.Emit.OpCodes.Ldloc_0);
});
}
else if (attribute.Type == FunctionTypes.Collation)
{
createMethod(baseType.Type.GetMethod("Compare"), (methodInfo, method, il) => {
il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1);
il.Emit(System.Reflection.Emit.OpCodes.Ldarg_2);
il.Emit(System.Reflection.Emit.OpCodes.Callvirt, methodInfo);
il.Emit(System.Reflection.Emit.OpCodes.Stloc_0);
System.Reflection.Emit.Label label = il.DefineLabel();
il.Emit(System.Reflection.Emit.OpCodes.Br_S, label);
il.MarkLabel(label);
il.Emit(System.Reflection.Emit.OpCodes.Ldloc_0);
});
}
else
{
createMethod(baseType.Type.GetMethod("Final"), (methodInfo, method, il) => {
il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1);
il.Emit(System.Reflection.Emit.OpCodes.Callvirt, methodInfo);
il.Emit(System.Reflection.Emit.OpCodes.Stloc_0);
System.Reflection.Emit.Label label = il.DefineLabel();
il.Emit(System.Reflection.Emit.OpCodes.Br_S, label);
il.MarkLabel(label);
il.Emit(System.Reflection.Emit.OpCodes.Ldloc_0);
});
createMethod(baseType.Type.GetMethod("Step"), (methodInfo, method, il) => {
il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1);
il.Emit(System.Reflection.Emit.OpCodes.Ldarg_2);
il.Emit(System.Reflection.Emit.OpCodes.Ldarg_3);
il.Emit(System.Reflection.Emit.OpCodes.Callvirt, methodInfo);
il.Emit(System.Reflection.Emit.OpCodes.Nop);
});
}
{
System.Reflection.MethodInfo methodInfo_base = baseType.Type.GetMethod("Dispose", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.InvokeMethod, null, new System.Type[] { typeof(bool) }, null);
createMethod(methodInfo_base, (methodInfo, method, il) => {
il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1);
il.Emit(System.Reflection.Emit.OpCodes.Callvirt, methodInfo);
il.Emit(System.Reflection.Emit.OpCodes.Nop);
il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0);
il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1);
il.Emit(System.Reflection.Emit.OpCodes.Call, methodInfo_base);
il.Emit(System.Reflection.Emit.OpCodes.Nop);
});
}
#if netcore20
var result = type.CreateTypeInfo();
#else
var result = type.CreateType();
#endif
#if !netcore
if (canSave)
{
assembly.Save(assemblyName.Name + ".dll");
}
#endif
return(result);
}
