/// <summary>
/// 本地模式测试验证
/// </summary>
/// <param name="table"></param>
/// <param name="isDelete"></param>
/// <returns></returns>
private static bool check(memoryDatabaseModelTable <identity> table, bool isDelete)
{
subArray <identity> array = cache.Values.getSubArray();
if (array.Count != 2)
{
return(false);
}
if (array[0].Int != 1)
{
return(false);
}
if (array[1].Int != 3)
{
return(false);
}
if (isDelete)
{
foreach (identity identity in array)
{
table.Delete(identity.Id);
}
}
table.Flush(false);
return(true);
}
/// <summary>
/// 本地模式测试验证
/// </summary>
/// <param name="table"></param>
/// <param name="isDelete"></param>
/// <returns></returns>
private static bool check(memoryDatabaseModelTable <primaryKey3, primaryKey> table, bool isDelete)
{
subArray <primaryKey3> subArray = cache.Values.getSubArray();
if (subArray.Count != 2)
{
return(false);
}
primaryKey3[] array = subArray.getSort(value => value.Key1);
if (array[0].Key1 != 1 || array[0].Key2 != "1" || array[0].Int != 1)
{
return(false);
}
if (array[1].Key1 != 2 || array[1].Key2 != "2" || array[1].Int != 3)
{
return(false);
}
if (isDelete)
{
foreach (primaryKey3 identity in array)
{
table.Delete(identity);
}
}
table.Flush(false);
return(true);
}
public void Get(subArray <byte> buffer)
{
if (buffer.length != 0 && fastCSharp.emit.dataDeSerializer.DeSerialize(ref buffer, ref Value))
{
IsValue = true;
}
}
/// <summary>
/// 获取预备服务
/// </summary>
/// <returns></returns>
internal subArray <keyValue <indexIdentity, service> > GetPerpServices()
{
subArray <keyValue <indexIdentity, service> > services = perpServices;
perpServices.Null();
return(services);
}
private void _M0(socket socket, ref subArray <byte> data)
{
fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
try
{
_i0 inputParameter = new _i0();
if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
{
_o0 outputParameter = new _o0();
Func <fastCSharp.net.returnValue <fastCSharp.code.cSharp.tcpBase.subByteArrayBuffer>, bool> callbackReturn = fastCSharp.net.tcp.commandServer.socket.callback <_o0, fastCSharp.code.cSharp.tcpBase.subByteArrayBuffer> .Get(socket, ref outputParameter, 0);
if (callbackReturn != null)
{
_value_.serverAsynchronous(inputParameter.data, callbackReturn);
}
return;
}
returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = fastCSharp.net.returnValue.type.ServerException;
fastCSharp.log.Error.Add(error, null, true);
}
socket.SendStream(socket.Identity, returnType);
}
/// <summary>
/// 节点队列(支持1读1写同时处理)测试
/// </summary>
/// <param name="nodes"></param>
public readWrite(node[] nodes)
{
queue = new queue <node>(new node());
values = new subArray <node>(nodes.Length);
using (task task = new task(thread = 2))
{
task.Add(push, nodes);
task.Add(pop);
}
if (values.Count != nodes.Length)
{
Console.WriteLine("ERROR");
}
else
{
int value = 0;
foreach (node node in values.UnsafeArray)
{
if (value != node.Value)
{
Console.WriteLine("ERROR");
break;
}
node.UnsafeClearQueueNextNode();
++value;
}
}
}
/// <summary>
/// 根据类型获取自定义属性函数信息集合
/// </summary>
/// <param name="type">对象类型</param>
/// <returns>自定义属性函数信息集合</returns>
public static attributeMethod[] GetStatic(Type type)
{
attributeMethod[] values;
if (staticMethods.TryGetValue(type, out values))
{
return(values);
}
Monitor.Enter(createStaticLock);
try
{
if (staticMethods.TryGetValue(type, out values))
{
return(values);
}
subArray <attributeMethod> array = default(subArray <attributeMethod>);
foreach (MethodInfo method in type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
{
object[] attributes = method.GetCustomAttributes(true);
if (attributes.Length != 0)
{
array.Add(new attributeMethod {
Method = method, attributes = attributes
});
}
}
staticMethods.Set(type, values = array.ToArray());
}
finally { Monitor.Exit(createStaticLock); }
return(values);
}
/// <summary>
/// 插入数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="value">待插入数据</param>
/// <param name="memberMap">目标成员位图</param>
/// <returns>是否成功</returns>
protected override bool insert <valueType, modelType>
(fastCSharp.emit.sqlTable.sqlTool <valueType, modelType> sqlTool, valueType value, fastCSharp.code.memberMap <modelType> memberMap)
{
DbConnection connection = GetConnection(false);
if (connection != null)
{
byte isExecute = 0;
try
{
subArray <valueType> values = subArray <valueType> .Unsafe(new valueType[] { value }, 0, 1);
import(connection, sqlTool.GetDataTable(ref values));
return(true);
}
catch (Exception error)
{
fastCSharp.log.Error.Add(error, null, false);
}
finally
{
if (isExecute == 0)
{
connection.Dispose();
}
else
{
pushConnection(ref connection, false);
}
}
}
return(false);
}
/// <summary>
/// 添加数据
/// </summary>
/// <param name="value"></param>
internal void Insert(valueType value)
{
subArray <valueType> array = subArray <valueType> .Unsafe(Array.UnsafeArray, 0, Array.StartIndex + Array.Count);
array.Add(value);
Array.UnsafeSet(array.UnsafeArray, array.Count, 0);
}
/// <summary>
/// 添加数据
/// </summary>
internal override void Insert()
{
DbConnection connection = client.GetConnection(false);
if (connection != null)
{
try
{
subArray <valueType> values = subArray <valueType> .Unsafe(new valueType[] { value }, 0, 1);
if (client.import(connection, sqlTool.GetDataTable(ref values)) != 0)
{
client.ConnectionPool.Push(ref connection);
}
else
{
value = null;
}
}
catch (Exception error)
{
value = null;
fastCSharp.log.Error.Add(error, sqlTool.TableName, false);
}
if (connection != null)
{
connection.Dispose();
}
}
else
{
value = null;
}
push();
}
/// <summary>
/// 安装入口
/// </summary>
/// <param name="parameter">安装参数</param>
/// <returns>是否安装成功</returns>
public bool Run(auto.parameter parameter)
{
if (parameter != null)
{
if (parameter.IsFastCSharp && parameter.ProjectName == pub.fastCSharp)
{
subArray <definition> definitions = ui.CurrentAssembly.GetTypes().getArray(type => new definition {
Type = type, Auto = type.customAttribute <auto>(), Parameter = parameter
})
.getFind(type => type.Auto != null && type.Auto.IsTemplate)// && type.Auto.DependType == typeof(cSharper)
.Sort((left, right) => string.CompareOrdinal(left.Type.FullName, right.Type.FullName));
subArray <string> codes = new subArray <string>(definitions.Count);
foreach (definition definition in definitions)
{
codes.Add(definition.ToString());
if (error.IsError)
{
return(false);
}
}
string fileName = new DirectoryInfo(parameter.ProjectPath).Parent.fullName() + @"ui\{" + pub.fastCSharp + "}.cSharper.cs";
if (WriteFile(fileName, WarningCode + string.Concat(codes) + FileEndCode))
{
error.Add(fileName + " 被修改");
throw new Exception();
}
}
return(true);
}
return(false);
}
/// <summary>
/// 嵌套类型处理
/// </summary>
/// <param name="type">类型</param>
/// <param name="reflectedType">上层类型</param>
private void reflectedType(Type type, Type reflectedType)
{
subArray <Type> reflectedTypeList = default(subArray <Type>);
do
{
reflectedTypeList.Add(reflectedType);
reflectedType = reflectedType.ReflectedType;
}while (reflectedType != null);
Type[] reflectedTypeArray = reflectedTypeList.array;
int reflectedTypeIndex = reflectedTypeList.length - 1;
reflectedType = reflectedTypeArray[reflectedTypeIndex];
NameStream.WriteNotNull(reflectedType.Namespace);
do
{
NameStream.Write('.');
NameStream.SimpleWriteNotNull(reflectedType.Name);
if (reflectedTypeIndex == 0)
{
reflectedType = type;
type = null;
}
else
{
reflectedType = reflectedTypeArray[--reflectedTypeIndex];
}
}while (reflectedType != null);
}
/// <summary>
/// TCP调用服务端验证
/// </summary>
/// <param name="socket">TCP调用套接字</param>
/// <param name="data">参数序列化数据</param>
private void verify(socket socket, ref subArray <byte> data)
{
fastCSharp.net.returnValue.type returnType;
try
{
fastCSharp.net.tcp.timeVerifyServer.input inputParameter = default(fastCSharp.net.tcp.timeVerifyServer.input);
if (fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter))
{
fastCSharp.net.returnValue <fastCSharp.net.tcp.timeVerifyServer.output> returnValue = new returnValue <timeVerifyServer.output> {
Value = new fastCSharp.net.tcp.timeVerifyServer.output {
Ret = timeVerify.Verify(socket, inputParameter.randomPrefix, inputParameter.md5Data, ref inputParameter.ticks)
}
};
returnValue.Value.ticks = inputParameter.ticks;
if (returnValue.Value.Ret)
{
socket.SetVerifyMethod();
}
returnValue.Type = net.returnValue.type.Success;
socket.SendStream(ref socket.identity, ref returnValue, default(tcp.commandServer.commandFlags));
return;
}
returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
}
catch (Exception error)
{
returnType = fastCSharp.net.returnValue.type.ServerException;
fastCSharp.log.Error.Add(error, null, true);
}
socket.SendStream(ref socket.identity, returnType);
}
///// <summary>
///// 模拟javascript编码函数escape
///// </summary>
///// <param name="value">原字符串</param>
///// <returns>escape编码后的字符串</returns>
//public static unsafe string JavascriptEscape(string value)
//{
// if (!string.IsNullOrEmpty(value))
// {
// fixed (char* valueFixed = value)
// {
// char* end = valueFixed + value.Length;
// int length = 0;
// for (char* start = valueFixed; start != end; ++start)
// {
// if ((*start & 0xff00) == 0)
// {
// if ((uint)(*start - '0') >= 10 && (uint)((*start | 0x20) - 'a') >= 26) length += 2;
// }
// else length += 5;
// }
// if (length != 0)
// {
// string newValue = fastCSharp.String.FastAllocateString(length += value.Length);
// fixed (char* newValueFixed = newValue)
// {
// byte* write = (byte*)newValueFixed;
// for (char* start = valueFixed; start != end; ++start)
// {
// uint charValue = *start;
// if ((charValue & 0xff00) == 0)
// {
// if ((uint)(charValue - '0') < 10 || (uint)((charValue | 0x20) - 'a') < 26)
// {
// *(char*)write = (char)charValue;
// write += sizeof(char);
// }
// else
// {
// uint code = charValue >> 4;
// *(char*)write = '%';
// code += code < 10 ? (uint)'0' : (uint)('0' + 'A' - '9' - 1);
// write += sizeof(char);
// code += (charValue << 16) & 0xf0000;
// *(uint*)write = code + (code < 0xa0000 ? (uint)'0' << 16 : ((uint)('0' + 'A' - '9' - 1) << 16));
// write += sizeof(uint);
// }
// }
// else
// {
// uint code = charValue >> 12;
// *(int*)write = '%' + ('u' << 16);
// code += code < 10 ? (uint)'0' : (uint)('0' + 'A' - '9' - 1);
// write += sizeof(int);
// code += (charValue & 0xf00) << 8;
// *(uint*)write = code + (code < 0xa0000 ? (uint)'0' << 16 : ((uint)('0' + 'A' - '9' - 1) << 16));
// code = (charValue >> 4) & 0xf;
// write += sizeof(uint);
// code += code < 10 ? (uint)'0' : (uint)('0' + 'A' - '9' - 1);
// code += (charValue << 16) & 0xf0000;
// *(uint*)write = code + (code < 0xa0000 ? (uint)'0' << 16 : ((uint)('0' + 'A' - '9' - 1) << 16));
// write += sizeof(uint);
// }
// }
// }
// return newValue;
// }
// }
// }
// return value;
//}
///// <summary>
///// 模拟javascript解码函数unescape
///// </summary>
///// <param name="value">原字符串</param>
///// <returns>unescape解码后的字符串</returns>
//internal static unsafe void JavascriptUnescape(ref subString value)
//{
// if (value.Length != 0)
// {
// fixed (char* valueFixed = value.value)
// {
// char* start = valueFixed + value.StartIndex, end = start + value.Length;
// while (start != end && *start != '%')
// {
// if (*start == 0) *start = ' ';
// ++start;
// }
// if (start != end)
// {
// char* write = start;
// NEXT:
// if (*++start == 'u')
// {
// uint code = (number.ParseHex(*(start + 1)) << 12) | (number.ParseHex(*(start + 2)) << 8) | (number.ParseHex(*(start + 3)) << 4) | number.ParseHex(*(start + 4));
// start += 5;
// *write++ = code != 0 ? (char)code : ' ';
// }
// else
// {
// uint code = (number.ParseHex(*start) << 4) | number.ParseHex(*(start + 1));
// start += 2;
// *write++ = code != 0 ? (char)code : ' ';
// }
// while (start < end)
// {
// if (*start == '%') goto NEXT;
// *write++ = *start == 0 ? ' ' : *start;
// ++start;
// }
// value.UnsafeSetLength((int)(write - valueFixed) - value.StartIndex);
// }
// }
// }
//}
/// <summary>
/// 模拟javascript解码函数unescape
/// </summary>
/// <param name="value">原字符串</param>
/// <returns>unescape解码后的字符串</returns>
internal static unsafe subString JavascriptUnescape(ref subArray <byte> value)
{
if (value.length != 0)
{
string newValue = fastCSharp.String.FastAllocateString(value.length);
fixed(char *newValueFixed = newValue)
fixed(byte *valueFixed = value.array)
{
byte *start = valueFixed + value.startIndex, end = start + value.length;
char *write = newValueFixed;
while (start != end && *start != '%')
{
*write++ = *start == 0 ? ' ' : (char)*start;
++start;
}
if (start == end)
{
return(subString.Unsafe(newValue, 0, value.length));
}
return(subString.Unsafe(newValue, 0, (int)(javascriptUnescape(start, end, write) - newValueFixed)));
}
}
return(default(subString));
}
private void removeRegister(clientId clientId)
{
if (clientId.Tick == logStream.Ticks && clientPool.Enter())
{
if (clientPool.Pool[clientId.Identity.Index].Free(clientId.Identity.Identity))
{
clientPool.FreeExit(clientId.Identity.Index);
subArray <string> removeNames = default(subArray <string>);
Monitor.Enter(serviceLock);
try
{
foreach (services service in serviceCache.Values.getArray())
{
hashString serviceName = service.Name;
if (removeRegister(clientId.Identity, service, ref serviceName))
{
removeNames.Add(service.Name);
}
}
}
finally { Monitor.Exit(serviceLock); }
if (removeNames.length != 0)
{
fastCSharp.log.Default.Add("TCP服务 " + removeNames.ToArray().joinString(',') + " 被注销", null, false);
}
}
else
{
clientPool.Exit();
}
}
}
static memoryDatabaseModel()
{
Type type = typeof(valueType);
Attribute = fastCSharp.code.typeAttribute.GetAttribute <memoryDatabaseModel>(type, true, true) ?? memoryDatabaseModel.Default;
code.fieldIndex[] fieldArray = fastCSharp.code.memberIndexGroup <valueType> .GetFields(Attribute.MemberFilter);
subArray <memoryDatabaseModel.fieldInfo> fields = new subArray <memoryDatabaseModel.fieldInfo>(), primaryKeys = new subArray <memoryDatabaseModel.fieldInfo>();
memoryDatabaseModel.fieldInfo identity = default(memoryDatabaseModel.fieldInfo);
int isCase = 0, isIdentity = 0;
foreach (code.fieldIndex field in fieldArray)
{
Type memberType = field.Member.FieldType;
if (!memberType.IsPointer && (!memberType.IsArray || memberType.GetArrayRank() == 1) && !field.IsIgnore)
{
dataMember memberAttribute = field.GetAttribute <dataMember>(true, true) ?? dataMember.DefaultDataMember;
if (memberAttribute.IsSetup)
{
fields.Add(new memoryDatabaseModel.fieldInfo(field, memberAttribute));
MemberMap.SetMember(field.MemberIndex);
if (isIdentity == 0)
{
if (memberAttribute != null && memberAttribute.IsIdentity)
{
identity = new memoryDatabaseModel.fieldInfo(field, memberAttribute);
isIdentity = 1;
}
else if (isCase == 0 && field.Member.Name == fastCSharp.config.memoryDatabase.Default.DefaultIdentityName)
{
identity = new memoryDatabaseModel.fieldInfo(field, memberAttribute);
isCase = 1;
}
else if (identity.Field == null && field.Member.Name.ToLower() == fastCSharp.config.memoryDatabase.Default.DefaultIdentityName)
{
identity = new memoryDatabaseModel.fieldInfo(field, memberAttribute);
}
}
if (memberAttribute.PrimaryKeyIndex != 0)
{
primaryKeys.Add(new memoryDatabaseModel.fieldInfo(field, memberAttribute));
}
}
}
}
IsAllMember = fields.length == fieldArray.Length ? 1 : 0;
if ((Identity = identity).Field != null)
{
#if NOJIT
new sqlModel <valueType> .identity32(identity.Field).Get(out GetIdentity, out SetIdentity);
#else
GetIdentity = getIdentityGetter32("GetMemoryDatabaseIdentity", identity.Field);
SetIdentity = getIdentitySetter32("SetMemoryDatabaseIdentity", identity.Field);
#endif
}
PrimaryKeys = primaryKeys.ToArray();
}
/// <summary>
/// 安装下一个类型
/// </summary>
protected override void nextCreate()
{
Identity = fastCSharp.code.cSharp.dataModel.GetIdentity <modelType>(type, Attribute);
PrimaryKeys = fastCSharp.code.cSharp.dataModel.GetPrimaryKeys <modelType>(type, Attribute);
if (IsCreate)
{
create(true);
}
}
/// <summary>
/// 根据域名获取IP地址
/// </summary>
/// <param name="domain">域名</param>
/// <returns>IP地址,失败返回null</returns>
internal unsafe static IPAddress[] GetIPAddress(ref subArray <byte> domain)
{
try
{
fixed(byte *domainFixed = domain.UnsafeArray)
{
byte *domainStart = domainFixed + domain.StartIndex;
unsafer.memory.ToLower(domainStart, domainStart + domain.Count);
hashBytes key = domain;
ipAddress value;
Monitor.Enter(domainIpLock);
try
{
value = domainIps.Get(key, default(ipAddress));
if (value.Ips != null && value.Timeout < date.NowSecond)
{
domainIps.Remove(key, out value);
value.Ips = null;
}
}
finally { Monitor.Exit(domainIpLock); }
if (value.Ips == null)
{
if (value.Domain == null)
{
value.Domain = String.UnsafeDeSerialize(domainStart, -domain.Count);
}
IPAddress ip;
if (IPAddress.TryParse(value.Domain, out ip))
{
value.Timeout = DateTime.MaxValue;
value.Domain = null;
setDomainIp(key.Copy(), ref value);
return(value.Ips = new IPAddress[] { ip });
}
value.Ips = Dns.GetHostEntry(value.Domain).AddressList;
if (value.Ips.Length != 0)
{
value.Timeout = date.NowSecond.AddTicks(domainIpTimeoutTicks);
setDomainIp(key.Copy(), ref value);
return(value.Ips);
}
}
else
{
return(value.Ips);
}
}
}
catch (Exception error)
{
log.Default.Add(error, null, false);
}
return(null);
}
protected internal bool serverSend(ref subArray <byte> data)
{
if (Socket.serverSend(data.array, data.startIndex, data.length, ref socketError))
{
return(true);
}
error();
return(false);
}
/// <summary>
/// HTTP响应Cookie
/// </summary>
/// <param name="name">名称</param>
/// <param name="value">值</param>
/// <param name="expires">超时时间,DateTime.MinValue表示忽略</param>
/// <param name="domain">有效域名</param>
/// <param name="path">有效路径</param>
/// <param name="isSecure">是否安全</param>
/// <param name="isHttpOnly">是否HTTP Only</param>
internal cookie(byte[] name, byte[] value, DateTime expires, subArray <byte> domain, byte[] path, bool isSecure, bool isHttpOnly)
{
Name = name;
Value = value;
Expires = expires;
Domain = domain;
Path = path;
IsSecure = isSecure;
IsHttpOnly = isHttpOnly;
}
/// <summary>
/// 获取数组
/// </summary>
/// <returns></returns>
public override subArray <valueType> GetSubArray()
{
subArray <valueType> subArray = new subArray <valueType>(Count);
foreach (cacheValue value in values.Values)
{
subArray.Add(value.Value);
}
return(subArray);
}
/// <summary>
/// WEB表单生成
/// </summary>
/// <param name="fields"></param>
public memberGetter(ref subArray <FieldInfo> fields)
{
this.fields = new field[fields.Count];
int index = 0;
foreach (FieldInfo field in fields)
{
this.fields[index++].Set(field);
}
}
/// <summary>
/// 导入数据
/// </summary>
/// <param name="client">SQL客户端操作</param>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="values">目标对象</param>
/// <param name="onInserted">删除数据回调</param>
/// <param name="isTransaction"></param>
public void Insert(client client, fastCSharp.emit.sqlTable.sqlTool <valueType, modelType> sqlTool, ref subArray <valueType> values, ref Action <subArray <valueType> > onInserted, bool isTransaction)
{
this.onInserted = onInserted;
this.client = client;
this.sqlTool = sqlTool;
this.values = values;
this.isTransaction = isTransaction;
onInserted = null;
fastCSharp.threading.task.Tiny.Add(this, threading.thread.callType.SqlClientInserter);
}
/// <summary>
/// 输出HTTP响应数据
/// </summary>
/// <param name="identity">HTTP操作标识</param>
/// <param name="response">HTTP响应数据</param>
public override unsafe bool Response(long identity, ref response response)
{
if (Interlocked.CompareExchange(ref this.identity, identity + 1, identity) == identity)
{
this.response = response;
response = null;
if (this.response.LastModified != null)
{
subArray <byte> ifModifiedSince = RequestHeader.IfModifiedSince;
if (ifModifiedSince.length == this.response.LastModified.Length)
{
fixed(byte *buffer = ifModifiedSince.array)
{
if (unsafer.memory.Equal(this.response.LastModified, buffer + ifModifiedSince.startIndex, ifModifiedSince.length))
{
response.Push(ref this.response);
this.response = response.NotChanged304;
}
}
}
}
if (boundaryReceiver != null)
{
bigBuffers.Push(ref boundaryReceiver.Buffer);
}
if (RequestHeader.Method == fastCSharp.web.http.methodType.POST && isLoadForm == 0)
{
switch (RequestHeader.PostType)
{
case requestHeader.postType.Json:
case requestHeader.postType.Form:
case requestHeader.postType.Xml:
case requestHeader.postType.Data:
if (formReceiver == null)
{
formReceiver = new formIdentityReceiver(this);
}
formReceiver.Receive(this);
return(true);
default:
if (boundaryReceiver == null)
{
boundaryReceiver = new boundaryIdentityReceiver(this);
}
boundaryReceiver.Receive(this);
return(true);
}
}
responseHeader();
return(true);
}
response.Push(ref response);
return(false);
}
/// <summary>
/// 图像缩略切剪
/// </summary>
/// <param name="data">图像文件数据</param>
/// <param name="width">缩略宽度,0表示与高度同比例</param>
/// <param name="height">缩略高度,0表示与宽度同比例</param>
/// <param name="type">目标图像文件格式</param>
/// <param name="memoryPool">输出数据缓冲区内存池</param>
/// <param name="seek">输出数据起始位置</param>
/// <returns>图像缩略文件数据</returns>
public static subArray <byte> Cut(byte[] data, int width, int height, ImageFormat type, memoryPool memoryPool = null, int seek = 0)
{
if (data == null)
{
return(default(subArray <byte>));
}
subArray <byte> dataArray = subArray <byte> .Unsafe(data, 0, data.Length);
Cut(ref dataArray, width, height, type, memoryPool, seek);
return(dataArray);
}
/// <summary>
/// 插入数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="values">待插入数据</param>
/// <param name="isIgnoreTransaction">是否忽略应用程序事务</param>
/// <param name="onInserted"></param>
public override void Insert <valueType, modelType>
(fastCSharp.emit.sqlTable.sqlTool <valueType, modelType> sqlTool, subArray <valueType> values, bool isIgnoreTransaction, Action <subArray <valueType> > onInserted)
{
if (onInserted == null)
{
log.Error.Throw(log.exceptionType.Null);
}
if (values.length == 0)
{
onInserted(values);
}
else
{
try
{
if (values.GetCount(value => sqlModel <modelType> .verify.Verify(value, fastCSharp.code.memberMap <modelType> .Default, sqlTool)) == values.length && sqlTool.CallOnInsert(ref values))
{
importer <valueType, modelType> inserter;
bool isTransaction = false;
if (!isIgnoreTransaction && sqlTool.IsDeleteTransaction)
{
if (fastCSharp.domainUnload.TransactionStart(false))
{
isTransaction = true;
inserter = importer <valueType, modelType> .Get();
}
else
{
inserter = null;
}
}
else
{
inserter = importer <valueType, modelType> .Get();
}
if (inserter != null)
{
inserter.Insert(this, sqlTool, ref values, ref onInserted, isTransaction);
}
else if (isTransaction)
{
fastCSharp.domainUnload.TransactionEnd();
}
}
}
finally
{
if (onInserted != null)
{
onInserted(default(subArray <valueType>));
}
}
}
}
/// <summary>
/// TCP数据包
/// </summary>
/// <param name="data">数据</param>
public tcp(ref subArray <byte> data)
{
if (data.Count >= DefaultHeaderSize && data.Count >= (uint)((data.UnsafeArray[data.StartIndex + 12] >> 4) << 2))
{
this.data = data;
}
else
{
this.data = default(subArray <byte>);
}
}
/// <summary>
/// 创建字典节点
/// </summary>
/// <param name="dictionary"></param>
/// <returns></returns>
public static jsonNode CreateDictionary(ref subArray <keyValue <subString, jsonNode> > dictionary)
{
jsonNode node = new jsonNode {
Type = type.Dictionary
};
subArray <keyValue <jsonNode, jsonNode> > array = dictionary.GetArray(value => new keyValue <jsonNode, jsonNode>(new jsonNode {
Type = type.String, String = value.Key
}, value.Value)).toSubArray();
node.SetDictionary(ref array);
return(node);
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="onSend">发送数据回调处理</param>
/// <param name="buffer">发送数据缓冲区</param>
/// <param name="memoryPool">发送数据缓冲区内存池</param>
public void Send(onSendType onSend, ref subArray <byte> buffer, memoryPool memoryPool)
{
this.onSend = onSend;
sendStartTime = date.nowTime.Now.AddTicks(date.SecondTicks);
this.memoryPool = memoryPool;
this.buffer = buffer.array;
sendIndex = buffer.startIndex;
sendLength = 0;
sendEndIndex = sendIndex + buffer.length;
send();
}
/// <summary>
/// HTTP响应头部输出
/// </summary>
/// <param name="buffer">输出数据</param>
/// <param name="memoryPool">内存池</param>
protected override void responseHeader(ref subArray <byte> buffer, memoryPool memoryPool)
{
if (responseSize == 0)
{
response.Push(ref response);
sender.Send(dataSender.onSendType.Next, ref buffer, memoryPool);
}
else
{
sender.Send(dataSender.onSendType.ResponseBody, ref buffer, memoryPool);
}
}
/// <summary>
/// 获取数据库物理层唯一标识
/// </summary>
/// <param name="data">数据</param>
/// <returns>数据库物理层唯一标识</returns>
private static unsafe timeIdentity getIdentity(ref subArray<byte> data)
{
timeIdentity identity;
fixed (byte* dataFixed = data.Array)
{
identity = *(timeIdentity*)(dataFixed + data.StartIndex);
if (identity.TimeTick == CoreLibrary.PubPlus.StartTime.Ticks)
{
data.UnsafeSet(data.StartIndex + sizeof(timeIdentity), data.Count - sizeof(timeIdentity));
}
else data.UnsafeSet(null, 0, 0);
}
return identity;
}
/// <summary>
/// 写入文件数据
/// </summary>
/// <param name="data">文件数据</param>
/// <returns>是否成功</returns>
public unsafe bool Write(subArray<byte> data)
{
try
{
if (fileWriter.UnsafeWriteCopy(data) >= 0) return true;
dispose(fileWriter.LastException);
}
catch (Exception error)
{
dispose(error);
}
return false;
}
/// <summary>
/// 获取域名服务信息
/// </summary>
/// <param name="domain">域名</param>
/// <returns>域名服务信息</returns>
public domainServer Get(subArray<byte> domain)
{
pointer data = this.data;
if (domain.Count != 0 && data.Data != null)
{
int index = new searcher(data).Search(domain);
if (index >= 0) return Servers[index];
}
return null;
}
/// <summary>
/// 写入日志
/// </summary>
/// <param name="identity">数据库物理层唯一标识</param>
/// <param name="data">日志数据</param>
/// <returns>是否成功写入缓冲区</returns>
internal int Append(identity identity, subArray<byte> data)
{
physicalInfo physical = physicals[identity.Index];
if (physical.Identity == identity.Identity)
{
int value = physical.Physical.Append(data);
if (value != 0) return value;
Close(identity, false);
}
return 0;
}
/// <summary>
/// 设置输出数据
/// </summary>
/// <param name="data">输出数据</param>
/// <param name="isBodyData">输出数据是否一次性(不可重用)</param>
public void SetBody(subArray<byte> data, bool isBodyOnlyOnce = true, bool canHeader = false)
{
CanHeader = canHeader;
if (data.Count == 0) Body.UnsafeSetLength(0);
else
{
if (!this.isBodyOnlyOnce) Buffer = Body.Array;
Body = data;
this.isBodyOnlyOnce = isBodyOnlyOnce;
}
}
/// <summary>
/// 创建数据库文件
/// </summary>
/// <param name="header">文件头数据</param>
/// <returns>是否成功</returns>
public bool Create(subArray<byte> header)
{
if (currentStep == (int) physicalOld.step.Waitting)
{
string fileName = path + this.fileName;
try
{
if (!File.Exists(fileName))
{
using (
FileStream file = new FileStream(fileName, FileMode.CreateNew, FileAccess.Write,
FileShare.None, 1, FileOptions.WriteThrough))
{
file.Write(header.Array, header.StartIndex, header.Count);
}
return true;
}
}
catch (Exception error)
{
log.Error.Add(error, null, false);
}
Dispose();
}
return false;
}
/// <summary>
/// 写入日志
/// </summary>
/// <param name="data">日志数据</param>
/// <returns>是否成功写入缓冲区</returns>
public unsafe bool AppendLogBuffer(subArray<byte> data)
{
if (currentStep == (int) physicalOld.step.Waitting)
{
fixed (byte* dataFixed = data.Array)
{
if (Interlocked.CompareExchange(ref logFileLock, 1, 0) != 0)
{
do
{
Thread.Sleep(0);
if (Interlocked.CompareExchange(ref logFileLock, 1, 0) == 0) break;
if (isRefreshErrorLog) Thread.Sleep(1);
else Thread.Sleep(0);
} while (Interlocked.CompareExchange(ref logFileLock, 1, 0) != 0);
}
try
{
if (logFileWriter.UnsafeWriteCopy(data) >= 0) return true;
lastException = logFileWriter.LastException;
//int length = logBufferIndex + data.Length;
//if (length <= Buffers.Size)
//{
// if (logBuffer == null) logBuffer = Buffers.Get();
// fixed (byte* bufferFixed = logBuffer)
// {
// unsafer.memory.Copy(dataFixed + data.StartIndex, bufferFixed + logBufferIndex, data.Length);
// }
// logBufferIndex = length;
// return true;
//}
//else
//{
// long fileIndex = 0;
// int startIndex = data.StartIndex, dataLenth = data.Length;
// if (logBufferIndex != 0)
// {
// fixed (byte* bufferFixed = logBuffer)
// {
// unsafer.memory.Copy(dataFixed + startIndex, bufferFixed + logBufferIndex, length = Buffers.Size - logBufferIndex);
// startIndex += length;
// dataLenth -= length;
// fileIndex = logFileWriter.UnsafeWrite(new memoryPool.pushSubArray { Value = subArray<byte>.Unsafe(logBuffer, 0, Buffers.Size), PushPool = Buffers.PushHandle });
// }
// }
// if (fileIndex >= 0)
// {
// for (logBuffer = Buffers.TryGet(); logBuffer != null; logBuffer = Buffers.TryGet())
// {
// if (dataLenth <= Buffers.Size)
// {
// unsafer.memory.Copy(dataFixed + startIndex, logBuffer, logBufferIndex = dataLenth);
// return true;
// }
// unsafer.memory.Copy(dataFixed + startIndex, logBuffer, Buffers.Size);
// startIndex += Buffers.Size;
// dataLenth -= Buffers.Size;
// fileIndex = logFileWriter.UnsafeWrite(new memoryPool.pushSubArray { Value = subArray<byte>.Unsafe(logBuffer, 0, Buffers.Size), PushPool = Buffers.PushHandle });
// if (fileIndex < 0) break;
// }
// if (logBuffer == null)
// {
// if (dataLenth <= Buffers.Size)
// {
// unsafer.memory.Copy(dataFixed + startIndex, logBuffer = Buffers.Get(), logBufferIndex = dataLenth);
// return true;
// }
// byte[] newData = new byte[dataLenth];
// unsafer.memory.Copy(dataFixed + startIndex, newData, dataLenth);
// if (logFileWriter.UnsafeWrite(new memoryPool.pushSubArray { Value = subArray<byte>.Unsafe(newData, 0, dataLenth) }) >= 0)
// {
// logBufferIndex = 0;
// return true;
// }
// }
// }
// lastException = logFileWriter.LastException;
//}
}
catch (Exception error)
{
lastException = error;
}
finally
{
logFileLock = 0;
}
}
Dispose();
}
return false;
}
/// <summary>
/// 读取数据
/// </summary>
/// <param name="data">读取的数据</param>
public void Read(ref subArray<byte> data)
{
if (isDisposed == 0)
{
readWaitHandle.WaitOne();
data = this.data;
fileWaitHandle.Set();
}
else data.Null();
}
/// <summary>
/// 获取域名服务信息
/// </summary>
/// <param name="domain">域名</param>
/// <returns>域名服务信息</returns>
internal virtual domainServer GetServer(subArray<byte> domain)
{
domainServer server = domains.Get(domain);
return server != null && server.IsStart ? server : null;
}
/// <summary>
/// 获取压缩数据
/// </summary>
/// <param name="data">数据</param>
/// <returns>压缩数据,失败返回null</returns>
internal static subArray<byte> GetCompress(subArray<byte> data, memoryPool memoryPool = null, int seek = 0)
{
if (data.Count > GZipSize)
{
subArray<byte> compressData = stream.GZip.GetCompress(data.Array, data.StartIndex, data.Count, seek, memoryPool);
if (compressData.Count != 0)
{
if (compressData.Count + GZipSize < data.Count) return compressData;
if (memoryPool != null) memoryPool.Push(ref compressData.array);
}
}
return default(subArray<byte>);
}
/// <summary>
/// 写入文件数据
/// </summary>
/// <param name="data">数据</param>
/// <returns>写入文件字节数</returns>
private int writeFile(subArray<byte> data)
{
int count = data.Count, length = currentIndex + count;
if (length < bufferLength)
{
Buffer.BlockCopy(data.Array, data.StartIndex, buffer, currentIndex, count);
currentIndex = length;
return 0;
}
byte[] dataArray = data.Array;
int index = data.StartIndex;
length = bufferLength - currentIndex;
if (currentIndex == startIndex)
{
fileStream.Write(dataArray, index, length += ((count - length) / bufferLength) * bufferLength);
index += length;
count -= length;
}
else
{
Buffer.BlockCopy(dataArray, index, buffer, currentIndex, length);
index += length;
count -= length;
fileStream.Write(buffer, startIndex, length = bufferLength - startIndex);
int size = count / bufferLength;
if (size != 0)
{
fileStream.Write(dataArray, index, size *= bufferLength);
index += size;
count -= size;
length += size;
}
}
Buffer.BlockCopy(dataArray, index, buffer, startIndex = 0, currentIndex = count);
return length;
}
/// <summary>
/// HTTP响应Cookie
/// </summary>
/// <param name="name">名称</param>
/// <param name="value">值</param>
/// <param name="expires">超时时间,DateTime.MinValue表示忽略</param>
/// <param name="domain">有效域名</param>
/// <param name="path">有效路径</param>
/// <param name="isSecure">是否安全</param>
/// <param name="isHttpOnly">是否HTTP Only</param>
internal CookiePlus(byte[] name, byte[] value, DateTime expires, subArray<byte> domain, byte[] path, bool isSecure, bool isHttpOnly)
{
Name = name;
Value = value;
Expires = expires;
Domain = domain;
Path = path;
IsSecure = isSecure;
IsHttpOnly = isHttpOnly;
}
/// <summary>
/// 创建数据库文件
/// </summary>
/// <param name="identity">数据库物理层唯一标识</param>
/// <param name="header">文件头数据</param>
/// <returns>是否创建成功</returns>
internal bool Create(identity identity, subArray<byte> header)
{
physicalInfo physical = physicals[identity.Index];
if (physical.Identity == identity.Identity)
{
if (physical.Physical.Create(header)) return true;
Close(identity, false);
}
return false;
}
public unsafe int Append(subArray<byte> data)
{
fixed (byte* dataFixed = data.array) return Append(dataFixed + data.StartIndex, data.Count);
}
public int Search(subArray<byte> data)
{
fixed (byte* dataFixed = data.array)
{
byte* start = dataFixed + data.StartIndex;
return search(start, start + data.Count);
}
}
public unsafe bool Create(subArray<byte> data)
{
fixed (byte* dataFixed = data.array) return Create(dataFixed + data.StartIndex, data.Count);
}
/// <summary>
/// 读取文件线程
/// </summary>
private unsafe void read()
{
int startIndex = 0, nextCount = sizeof(int) * 3;
try
{
byte[] headerBuffer = new byte[sizeof(int) * 3];
if (fileStream.Read(headerBuffer, 0, sizeof(int) * 3) != sizeof(int) * 3) return;
fixed (byte* bufferFixed = headerBuffer)
{
if (*(int*)bufferFixed != fastCSharp.emit.pub.PuzzleValue) return;
int headerSize = *(int*)(bufferFixed + sizeof(int));
if (headerSize > size || headerSize < sizeof(int) * 3 || (headerSize & 3) != 0) return;
int bufferSize = *(int*)(bufferFixed + sizeof(int) * 2);
if ((bufferSize & (bufferSize - 1)) != 0 || (bufferSize >> 12) == 0 || headerSize > bufferSize) return;
size -= headerSize;
physical.setLoadBuffer(bufferSize);
if (fileStream.Read(physical.loadBuffer, sizeof(int), headerSize -= sizeof(int) * 3) != headerSize) return;
fixed (byte* loaderBufferFixed = physical.loadBuffer) *(int*)loaderBufferFixed = bufferSize;
data.UnsafeSet(physical.loadBuffer, 0, headerSize + sizeof(int));
waitHandle.Set();
nextCount = 0;
}
byte[] buffer = physical.buffer, bigBuffer = nullValue<byte>.Array;
int isBigBuffer = 0;
fixed (byte* bufferFixed = buffer)
{
while (isDisposed == 0 && (size | (long)(uint)nextCount) != 0)
{
if (nextCount == 0)
{
if (fileStream.Read(buffer, startIndex = 0, nextCount = (int)Math.Min(buffer.Length, size)) != nextCount) return;
size -= nextCount;
}
byte* dataStart = bufferFixed + startIndex;
int dataSize = *(int*)dataStart, bufferSize;
if (dataSize < 0)
{
bufferSize = dataSize & 3;
bufferSize += (dataSize = -dataSize);
}
else
{
if ((dataSize & 3) != 0) return;
bufferSize = dataSize;
}
if (bufferSize > buffer.Length)
{
int count = bufferSize - nextCount;
if ((size -= count) < 0) return;
if (bufferSize > bigBuffer.Length)
{
uint bigSize = (uint)(bigBuffer.Length == 0 ? buffer.Length : bigBuffer.Length);
while (bigSize < bufferSize) bigSize <<= 1;
if (bigSize == 0x80000000U) return;
bigBuffer = new byte[bigSize];
isBigBuffer = 0;
}
if (isBigBuffer == 0)
{
Buffer.BlockCopy(buffer, startIndex, bigBuffer, 0, nextCount);
if (fileStream.Read(bigBuffer, nextCount, count) != count) return;
if (*(int*)dataStart < 0)
{
subArray<byte> newBuffer = fastCSharp.io.compression.stream.Deflate.GetDeCompressUnsafe(bigBuffer, sizeof(int), dataSize - sizeof(int), physical.memoryPool);
waitBuffer();
physical.setLoadBuffer(newBuffer.array);
data = newBuffer;
}
else
{
waitBuffer();
physical.setLoadBuffer();
data.UnsafeSet(bigBuffer, sizeof(int), dataSize - sizeof(int));
isBigBuffer = 1;
}
}
else
{
waitBuffer();
Buffer.BlockCopy(buffer, startIndex, bigBuffer, 0, nextCount);
if (fileStream.Read(bigBuffer, nextCount, count) != count) return;
if (*(int*)dataStart < 0)
{
subArray<byte> newBuffer = fastCSharp.io.compression.stream.Deflate.GetDeCompressUnsafe(bigBuffer, sizeof(int), dataSize - sizeof(int), physical.memoryPool);
physical.setLoadBuffer(newBuffer.array);
data = newBuffer;
isBigBuffer = 0;
}
else
{
physical.setLoadBuffer();
data.UnsafeSet(bigBuffer, sizeof(int), dataSize - sizeof(int));
}
}
waitHandle.Set();
nextCount = 0;
}
else
{
int count = bufferSize - nextCount;
if (count > 0)
{
if (size < count) return;
Buffer.BlockCopy(buffer, startIndex, buffer, 0, nextCount);
if (fileStream.Read(buffer, nextCount, count = (int)Math.Min(buffer.Length - nextCount, size)) != count) return;
dataStart = bufferFixed;
startIndex = 0;
size -= count;
nextCount += count;
}
if (*(int*)dataStart < 0)
{
subArray<byte> newBuffer = fastCSharp.io.compression.stream.Deflate.GetDeCompressUnsafe(buffer, startIndex + sizeof(int), bufferSize - sizeof(int), physical.memoryPool);
waitBuffer();
physical.setLoadBuffer(newBuffer.array);
data = newBuffer;
isBigBuffer = 0;
}
else
{
waitBuffer();
byte[] newBuffer;
if (isBigBuffer == 0)
{
if (bigBuffer.Length == 0) newBuffer = physical.getLoadBuffer();
else
{
newBuffer = bigBuffer;
isBigBuffer = 1;
}
}
else
{
newBuffer = physical.getLoadBuffer();
isBigBuffer = 0;
}
Buffer.BlockCopy(buffer, startIndex + sizeof(int), newBuffer, 0, bufferSize - sizeof(int));
data.UnsafeSet(newBuffer, 0, bufferSize - sizeof(int));
}
waitHandle.Set();
nextCount -= bufferSize;
startIndex += bufferSize;
}
}
}
if (isDisposed == 0)
{
waitBuffer();
data.UnsafeSet(physical.buffer, 0, 0);
}
}
finally
{
if (nextCount == 0) Dispose();
else
{
data.Null();
Dispose();
pub.Dispose(ref physical);
}
}
}
/// <summary>
/// 获取字段成员集合
/// </summary>
/// <param name="type"></param>
/// <param name="attribute"></param>
/// <returns>字段成员集合</returns>
public static subArray<memberInfo> GetFields(Type type, dataSerialize attribute, out int memberCountVerify, out int fixedSize, out int nullMapSize)
{
fieldIndex[] fieldIndexs = (fieldIndex[])typeof(fastCSharp.code.memberIndexGroup<>).MakeGenericType(type).GetMethod("GetFields", BindingFlags.Static | BindingFlags.Public).Invoke(null, new object[] { attribute.MemberFilter });
subArray<memberInfo> fields = new subArray<memberInfo>(fieldIndexs.Length);
int nullMapIndex = 0;
fixedSize = nullMapSize = 0;
foreach (fieldIndex field in fieldIndexs)
{
type = field.Member.FieldType;
if (!type.IsPointer && (!type.IsArray || type.GetArrayRank() == 1) && !field.IsIgnore)
{
fastCSharp.emit.dataSerialize.member memberAttribute = field.GetAttribute<fastCSharp.emit.dataSerialize.member>(true, true);
if (memberAttribute == null || memberAttribute.IsSetup)
{
memberInfo value = memberInfo.GetSerialize(field);
if (type != typeof(bool)) fixedSize += value.SerializeFixedSize;
nullMapSize += value.NullMapSize;
if (value.NullMapSize == 2)
{
value.SerializeNullMapIndex = nullMapIndex;
nullMapIndex += 2;
--fixedSize;
}
fields.Add(value);
}
}
}
memberCountVerify = fields.Count + 0x40000000;
fixedSize = (fixedSize + 3) & (int.MaxValue - 3);
nullMapSize = ((nullMapSize + 31) >> 5) << 2;
fields.Sort(memberInfo.SerializeFixedSizeSort);
foreach (memberInfo value in fields)
{
if (value.NullMapSize == 1) value.SerializeNullMapIndex = nullMapIndex++;
}
return fields;
}
/// <summary>
/// HTTP响应Cookie
/// </summary>
/// <param name="name">名称</param>
/// <param name="value">值</param>
/// <param name="domain">有效域名</param>
/// <param name="path">有效路径</param>
/// <param name="isSecure">是否安全</param>
/// <param name="isHttpOnly">是否HTTP Only</param>
public cookie(string name, string value, string domain, string path, bool isSecure, bool isHttpOnly)
{
if (name.length() != 0) Name = name.getBytes();
if (value.length() != 0) Value = value.getBytes();
if (domain.length() != 0)
{
byte[] data = domain.getBytes();
Domain = subArray<byte>.Unsafe(data, 0, data.Length);
}
if (path.length() != 0) Path = path.getBytes();
IsSecure = isSecure;
IsHttpOnly = isHttpOnly;
}
