public static keyValue <string, string> Convert(LambdaExpression expression, charStream stream)
{
converter converter = new converter();
converter.create(expression, stream);
return(new keyValue <string, string>(converter.FirstMemberName, converter.FirstMemberSqlName));
}
/// <summary>
/// 数字转换成字符串
/// </summary>
/// <param name="value">数字值</param>
/// <param name="jsonStream">JSON输出流</param>
public unsafe static void ToString(sbyte value, charStream jsonStream)
{
if (value == 0)
{
jsonStream.Write('0');
}
else
{
if (value < 0)
{
char *chars = jsonStream.GetPrepLengthCurrent(5);
uint value32 = (uint)-(int)value;
*(int *)chars = '-' + ('0' << 16);
*(chars + 2) = 'x';
*(chars + 3) = (char)((value32 >> 4) + '0');
*(chars + 4) = (char)number.ToHex(value32 & 15);
jsonStream.UnsafeAddLength(5);
}
else
{
char *chars = jsonStream.GetPrepLengthCurrent(4);
uint value32 = (uint)(int)value;
*(int *)chars = '0' + ('x' << 16);
*(chars + 2) = (char)((value32 >> 4) + '0');
*(chars + 3) = (char)number.ToHex(value32 & 15);
jsonStream.UnsafeAddLength(4);
}
}
}
/// <summary>
/// 时间转字符串
/// </summary>
/// <param name="time">时间</param>
/// <param name="jsonStream">JSON输出流</param>
public static unsafe void ToStringNotNull(DateTime time, charStream jsonStream)
{
jsonStream.PrepLength(DateStart.Length + (19 + 1));
jsonStream.UnsafeSimpleWrite(DateStart);
toString((long)(((time.Kind == DateTimeKind.Utc ? time.Ticks + pub.LocalTimeTicks : time.Ticks) - JavascriptLocalMinTimeTicks) / date.MillisecondTicks), jsonStream);
jsonStream.UnsafeWrite(DateEnd);
}
/// <summary>
/// 格式化ajax字符串
/// </summary>
/// <param name="jsStream">JS字符流</param>
/// <param name="formatStream">格式化JSON字符流</param>
internal unsafe static void FormatJavascript(charStream jsStream, unmanagedStream formatStream)
{
if (jsStream.Length != 0)
{
char *start = jsStream.Char;
int length = formatLength(jsStream);
if (length == 0)
{
char *end = start + (length = jsStream.Length);
formatStream.PrepLength(length <<= 1);
for (char *write = (char *)(formatStream.CurrentData); start != end; ++start)
{
*write++ = *start == Quote ? '"' : *start;
}
formatStream.UnsafeAddLength(length);
}
else
{
length += jsStream.Length;
formatStream.PrepLength(length <<= 1);
formatJavascript(start, start + jsStream.Length, (char *)(formatStream.CurrentData));
formatStream.UnsafeAddLength(length);
}
}
}
/// <summary>
/// 数字转换成字符串
/// </summary>
/// <param name="value"></param>
/// <param name="jsonStream"></param>
private unsafe static void toString(ulong value, charStream jsonStream)
{
if (value <= uint.MaxValue)
{
ToString((uint)value, jsonStream);
}
else
{
char *chars = jsonStream.GetPrepLengthCurrent(18), next;
uint value32 = (uint)(value >> 32);
*(int *)chars = '0' + ('x' << 16);
if (value32 >= 0x10000)
{
next = getToHex(value32 >> 16, chars + 2);
toHex16(value32 & 0xffff, next);
next += 4;
}
else
{
next = getToHex(value32, chars + 2);
}
toHex16((value32 = (uint)value) >> 16, next);
toHex16(value32 & 0xffff, next + 4);
jsonStream.UnsafeAddLength((int)(next - chars) + 8);
}
}
/// <summary>
/// 获取Excel客户端
/// </summary>
/// <returns>Excel客户端</returns>
public unsafe client GetClient()
{
provider provider = Enum <providerType, provider> .Array((byte)Provider);
pointer buffer = fastCSharp.sql.client.SqlBuffers.Get();
try
{
using (charStream connectionStream = new charStream(buffer.Char, fastCSharp.sql.client.SqlBufferSize))
{
connectionStream.SimpleWriteNotNull("Provider=");
connectionStream.Write(provider.Name);
connectionStream.SimpleWriteNotNull(";Data Source=");
connectionStream.Write(DataSource);
if (Password != null)
{
connectionStream.WriteNotNull(";Database Password="******";Extended Properties='");
connectionStream.Write(provider.Excel);
connectionStream.WriteNotNull(IsTitleColumn ? ";HDR=YES;IMEX=" : ";HDR=NO;IMEX=");
number.ToString((byte)Intermixed, connectionStream);
connectionStream.Write('\'');
return((client) new sql.connection {
Type = type.Excel, Connection = connectionStream.ToString()
}.Client);
}
}
finally { fastCSharp.sql.client.SqlBuffers.Push(ref buffer); }
}
/// <summary>
/// 格式化ajax字符串
/// </summary>
/// <param name="jsStream">js字符流</param>
/// <returns>格式化后ajax字符串</returns>
public unsafe static string FormatJavascript(charStream jsStream)
{
if (jsStream.Length == 0)
{
return(string.Empty);
}
int length = formatLength(jsStream);
string value = fastCSharp.String.FastAllocateString(length + jsStream.Length);
fixed(char *valueFixed = value)
{
char *start = jsStream.Char;
if (length == 0)
{
char *write = valueFixed, end = start + jsStream.Length;
do
{
*write++ = *start == Quote ? '"' : *start;
}while (++start != end);
}
else
{
formatJavascript(start, start + jsStream.Length, valueFixed);
}
}
return(value);
}
private static unsafe void toJson(fastCSharp.emit.jsonSerializer toJsoner, cardMessage value)
{
if (value.card_ext.signature == null)
{
log.Default.Add("卡券扩展 签名为空", new System.Diagnostics.StackFrame(), true);
fastCSharp.web.ajax.WriteObject(toJsoner.UnsafeCharStream);
}
else
{
toJsoner.UnsafeWriteFirstName("card_id");
toJsoner.UnsafeToJson(value.card_id);
toJsoner.UnsafeWriteNextName("card_ext");
fastCSharp.emit.jsonSerializer cardToJsoner = typePool <fastCSharp.emit.jsonSerializer> .Pop() ?? new fastCSharp.emit.jsonSerializer();
pointer buffer = fastCSharp.unmanagedPool.StreamBuffers.Get();
try
{
using (charStream cardJsonStream = cardToJsoner.UnsafeCharStream)
{
cardJsonStream.UnsafeReset((byte *)buffer.Char, fastCSharp.unmanagedPool.StreamBuffers.Size);
cardToJsoner.UnsafeToJsonNotNull(value.card_ext, toJsoner.UnsafeConfig);
fastCSharp.web.ajax.UnsafeFormatJavascript(cardJsonStream, toJsoner.UnsafeCharStream);
}
}
finally
{
fastCSharp.unmanagedPool.StreamBuffers.Push(ref buffer);
toJsoner.UnsafeFree();
}
toJsoner.UnsafeCharStream.Write('}');
}
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertInSet(sql.expression.converter converter, Expression expression)
{
charStream stream = converter.Stream;
BinaryExpression binaryExpression = (BinaryExpression)expression;
Expression left = binaryExpression.Left;
converters[(int)left.NodeType](converter, left);
stream.Write(" In(");
func <object, string> toString = null;
int index = -1;
foreach (object value in (IEnumerable)((ConstantExpression)binaryExpression.Right).Value)
{
if (++index == 0)
{
toString = constantConverter.Default[value.GetType()];
}
else
{
stream.Write(',');
}
stream.Write(toString != null ? toString(value) : constantConverter.convertConstantStringMssql(value.ToString()));
}
stream.Write(')');
}
/// <summary>
/// 数字转换成字符串
/// </summary>
/// <param name="charStream"></param>
/// <param name="values"></param>
/// <param name="startIndex"></param>
/// <param name="endIndex"></param>
/// <param name="joinChar"></param>
/// <param name="isWriteNull"></param>
public void Join(charStream charStream, valueType[] values, int startIndex, int endIndex, char joinChar, bool isWriteNull)
{
if (startIndex != endIndex)
{
object[] parameters = null;
do
{
object value = values[startIndex];
if ((bool)hasValueMethod.Invoke(value, null))
{
if (parameters == null)
{
parameters = new object[] { null, charStream }
}
;
parameters[0] = valueMethod.Invoke(value, null);
method.Invoke(null, parameters);
}
else if (isWriteNull)
{
fastCSharp.web.ajax.WriteNull(charStream);
}
if (++startIndex == endIndex)
{
return;
}
charStream.Write(joinChar);
}while (true);
}
}
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="binaryExpression">表达式</param>
/// <param name="type">操作字符串</param>
private void convertBinaryExpression(converter converter, BinaryExpression binaryExpression, string type)
{
charStream stream = converter.Stream;
Expression left = binaryExpression.Left, right = binaryExpression.Right;
stream.Write('(');
if (left.IsSimple)
{
converters[(int)left.NodeType](converter, left);
stream.Write('=');
stream.Write('1');
}
else
{
converters[(int)left.NodeType](converter, left);
}
stream.Write(')');
stream.SimpleWriteNotNull(type);
stream.Write('(');
if (right.IsSimple)
{
converters[(int)right.NodeType](converter, right);
stream.Write('=');
stream.Write('1');
}
else
{
converters[(int)right.NodeType](converter, right);
}
stream.Write(')');
}
/// <summary>
/// 获取类型名称
/// </summary>
/// <param name="type">类型</param>
/// <returns>类型名称</returns>
public unsafe string GetName(Type type)
{
if (type.IsArray)
{
pointer buffer = fastCSharp.unmanagedPool.TinyBuffers.Get();
try
{
using (NameStream = new charStream(buffer.Char, fastCSharp.unmanagedPool.TinyBuffers.Size >> 1))
{
array(type, false);
return(NameStream.ToString());
}
}
finally { fastCSharp.unmanagedPool.TinyBuffers.Push(ref buffer); }
}
if (type.IsGenericType)
{
pointer buffer = fastCSharp.unmanagedPool.TinyBuffers.Get();
try
{
using (NameStream = new charStream(buffer.Char, fastCSharp.unmanagedPool.TinyBuffers.Size >> 1))
{
genericName(type);
return(NameStream.ToString());
}
}
finally { fastCSharp.unmanagedPool.TinyBuffers.Push(ref buffer); }
}
return(type.Name);
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="expression">表达式</param>
private void convertInSet(sql.expression.converter converter, Expression expression)
{
charStream stream = converter.Stream;
BinaryExpression binaryExpression = (BinaryExpression)expression;
Expression left = binaryExpression.Left;
converters[(int)left.NodeType](converter, left);
stream.SimpleWriteNotNull(" In(");
Action <charStream, object> toString = null;
int index = -1;
foreach (object value in (IEnumerable)((ConstantExpression)binaryExpression.Right).Value)
{
if (++index == 0)
{
toString = constantConverter[value.GetType()];
}
else
{
stream.Write(',');
}
if (toString == null)
{
stringConverter(stream, value.ToString());
}
else
{
toString(stream, value);
}
}
stream.Write(')');
}
/// <summary>
/// 创建表格
/// </summary>
/// <param name="connection">SQL连接</param>
/// <param name="table">表格信息</param>
internal unsafe override bool createTable(DbConnection connection, table table)
{
string name = table.Columns.Name;
if (connection != null && name != null && name.Length != 0 && table.Columns != null && table.Columns.Columns.Length != 0)
{
pointer buffer = fastCSharp.sql.client.SqlBuffers.Get();
try
{
using (charStream sqlStream = new charStream(buffer.Char, fastCSharp.sql.client.SqlBufferSize))
{
sqlStream.SimpleWriteNotNull("create table ");
sqlStream.SimpleWriteNotNull(name);
sqlStream.SimpleWriteNotNull(" (");
bool isNext = false;
foreach (column column in table.Columns.Columns)
{
if (isNext)
{
sqlStream.Write(',');
}
sqlStream.SimpleWriteNotNull(column.SqlName);
sqlStream.Write(' ');
sqlStream.Write(column.DbType.getSqlTypeName());
isNext = true;
}
sqlStream.Write(')');
return(executeNonQuery(connection, sqlStream.ToString()) >= 0);
}
}
finally { fastCSharp.sql.client.SqlBuffers.Push(ref buffer); }
}
return(false);
}
/// <summary>
/// 常量转换字符串
/// </summary>
/// <param name="sqlStream">SQL字符流</param>
/// <param name="value">常量</param>
private void convertConstant(charStream sqlStream, DateTime value)
{
sqlStream.PrepLength(fastCSharp.date.SqlMillisecondSize + 2);
sqlStream.UnsafeWrite('\'');
fastCSharp.date.ToSqlMillisecond((DateTime)value, sqlStream);
sqlStream.UnsafeWrite('\'');
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="converter">表达式转换器</param>
/// <param name="binaryExpression">表达式</param>
/// <param name="char1">操作字符1</param>
/// <param name="char2">操作字符2</param>
protected void convertBinaryExpression(converter converter, BinaryExpression binaryExpression,
char char1, char char2 = ' ')
{
charStream stream = converter.Stream;
Expression left = binaryExpression.Left, right = binaryExpression.Right;
if (left.IsSimple)
{
converters[(int)left.NodeType](converter, left);
}
else
{
stream.Write('(');
converters[(int)left.NodeType](converter, left);
stream.Write(')');
}
stream.Write(char1);
stream.Write(char2);
if (right.IsSimple)
{
converters[(int)right.NodeType](converter, right);
}
else
{
stream.Write('(');
converters[(int)right.NodeType](converter, right);
stream.Write(')');
}
}
/// <summary>
/// 字符串
/// </summary>
/// <param name="value">字符串</param>
/// <param name="jsonStream">JSON输出流</param>
public static void ToString(string value, charStream jsonStream)
{
jsonStream.PrepLength(value.Length + 2);
jsonStream.UnsafeWrite(Quote);
jsonStream.UnsafeWrite(value);
jsonStream.UnsafeWrite(Quote);
}
/// <summary>
/// 时间转字符串 第三方格式 /Date(xxx)/
/// </summary>
/// <param name="time">时间</param>
/// <param name="jsonStream">JSON输出流</param>
public static unsafe void ToStringOther(DateTime time, charStream jsonStream)
{
jsonStream.PrepLength(OtherDateStart.Length + (19 + 1 + 4));
jsonStream.UnsafeWrite(fastCSharp.web.ajax.Quote);
jsonStream.UnsafeSimpleWrite(OtherDateStart);
toString((long)(((time.Kind == DateTimeKind.Utc ? time.Ticks + pub.LocalTimeTicks : time.Ticks) - JavascriptLocalMinTimeTicks) / date.MillisecondTicks), jsonStream);
*(long *)jsonStream.CurrentChar = DateEnd + ('/' << 16) + ((long)fastCSharp.web.ajax.Quote << 32);
jsonStream.UnsafeAddLength(3);
}
/// <summary>
/// AJAX响应输出处理
/// </summary>
/// <param name="js">JS输出流</param>
protected unsafe override void ajax(charStream js)
{
js.WriteNotNull(@"{At:");
{
string _value1_ = At;
if (_value1_ == null)
{
fastCSharp.web.ajax.WriteNull(js);
}
else
{
fastCSharp.web.ajax.ToString(_value1_, js);
}
}
js.WriteNotNull(@",Environment:");
{
fastCSharp.document.environment _value1_ = Environment;
if (_value1_ == null)
{
fastCSharp.web.ajax.WriteNull(js);
}
else
{
js.WriteNotNull(@"{FastCSharpPath:");
{
string _value2_ = _value1_.FastCSharpPath;
if (_value2_ == null)
{
fastCSharp.web.ajax.WriteNull(js);
}
else
{
fastCSharp.web.ajax.ToString(_value2_, js);
}
}
js.WriteNotNull(@",VS2010:");
{
bool _value2_ = _value1_.VS2010;
fastCSharp.web.ajax.ToString((bool)_value2_, js);
}
js.Write('}');
}
}
js.WriteNotNull(@",WorkPath:");
{
string _value1_ = WorkPath;
if (_value1_ == null)
{
fastCSharp.web.ajax.WriteNull(js);
}
else
{
fastCSharp.web.ajax.ToString(_value1_, js);
}
}
js.Write('}');
}
/// <summary>
/// AJAX响应输出处理
/// </summary>
/// <param name="js">JS输出流</param>
protected unsafe override void ajax(charStream js)
{
js.WriteNotNull(@"{Return:");
{
int _value1_ = Return;
fastCSharp.web.ajax.ToString((int)_value1_, js);
}
js.Write('}');
}
/// <summary>
/// 字节流转换成JSON字符串
/// </summary>
/// <param name="jsonStream">JSON输出流,不能为null</param>
/// <param name="start">起始位置,不能为null</param>
/// <param name="end">结束位置,长度必须大于0</param>
public unsafe static void ToJson(charStream jsonStream, byte *start, byte *end)
{
jsonStream.Write('[');
for (web.ajax.ToString(*start, jsonStream); ++start != end; web.ajax.ToString(*start, jsonStream))
{
jsonStream.Write(',');
}
jsonStream.Write(']');
}
/// <summary>
/// 字符
/// </summary>
/// <param name="value">字符</param>
/// <param name="jsonStream">JSON输出流</param>
public unsafe static void ToString(char value, charStream jsonStream)
{
char *chars = jsonStream.GetPrepLengthCurrent(3);
*chars = Quote;
*(chars + 1) = value;
*(chars + 2) = Quote;
jsonStream.UnsafeAddLength(3);
}
internal unsafe charStream ResetJsonStream(void *data, int size)
{
if (jsonStream == null)
{
return(jsonStream = new charStream((char *)data, size >> 1));
}
jsonStream.UnsafeReset((byte *)data, size);
return(jsonStream);
}
/// <summary>
/// Guid转换成字符串
/// </summary>
/// <param name="value">Guid</param>
/// <param name="jsonStream">JSON输出流</param>
public unsafe static void ToString(ref Guid value, charStream jsonStream)
{
byte *data = (byte *)jsonStream.GetPrepLengthCurrent(38);
*(char *)data = fastCSharp.web.ajax.Quote;
new guid {
Value = value
}.ToString((char *)(data + sizeof(char)));
*(char *)(data + sizeof(char) * 37) = fastCSharp.web.ajax.Quote;
jsonStream.UnsafeAddLength(38);
}
private void convertConstant(charStream sqlStream, string value)
{
if (value == null)
{
fastCSharp.web.ajax.WriteNull(sqlStream);
}
else
{
convertString(sqlStream, value);
}
}
private void convertConstantToString <valueType>(charStream sqlStream, valueType value)
{
if (value == null)
{
fastCSharp.web.ajax.WriteNull(sqlStream);
}
else
{
convertString(sqlStream, value.ToString());
}
}
private void convertConstant(charStream sqlStream, DateTime?value)
{
if (value == null)
{
fastCSharp.web.ajax.WriteNull(sqlStream);
}
else
{
convertConstant(sqlStream, (DateTime)value);
}
}
private void convertConstant(charStream sqlStream, decimal?value)
{
if (value == null)
{
fastCSharp.web.ajax.WriteNull(sqlStream);
}
else
{
sqlStream.SimpleWriteNotNull(((decimal)value).ToString());
}
}
private void convertConstant(charStream sqlStream, ulong?value)
{
if (value == null)
{
fastCSharp.web.ajax.WriteNull(sqlStream);
}
else
{
fastCSharp.number.ToString((ulong)value, sqlStream);
}
}
private void convertConstant(charStream sqlStream, bool?value)
{
if (value == null)
{
fastCSharp.web.ajax.WriteNull(sqlStream);
}
else
{
sqlStream.Write((bool)value ? '1' : '0');
}
}
/// <summary>
/// 生成HTML
/// </summary>
/// <param name="isTag">是否包含当前标签</param>
/// <returns>HTML</returns>
public string Html(bool isTag)
{
if (TagName != null)
{
if (web.html.NonanalyticTagNames.Contains(TagName))
{
if (isTag && TagName.Length != 1)
{
using (charStream strings = new charStream())
{
tagHtml(strings);
strings.Write(nodeText.Html);
tagRound(strings);
return strings.ToString();
}
}
}
else
{
using (charStream strings = new charStream())
{
if (isTag) tagHtml(strings);
if (children.count() != 0)
{
htmlNode node;
list<nodeIndex> values = new list<nodeIndex>();
nodeIndex index = new nodeIndex { Values = children };
while (true)
{
if (index.Values == null)
{
if (values.Count == 0) break;
{
index = values.Pop();
index.Values[index.Index].tagRound(strings);
if (++index.Index == index.Values.Count)
{
index.Values = null;
continue;
}
}
}
node = index.Values[index.Index];
string nodeTagName = node.TagName;
bool isNonanalyticTagNames = nodeTagName != null && web.html.NonanalyticTagNames.Contains(nodeTagName);
if (node.children.count() == 0 || nodeTagName == null || isNonanalyticTagNames)
{
if (nodeTagName != null && nodeTagName.Length != 1) node.tagHtml(strings);
strings.Write(node.nodeText.Html);
if (nodeTagName != null && nodeTagName.Length != 1) node.tagRound(strings);
if (++index.Index == index.Values.Count) index.Values = null;
}
else
{
node.tagHtml(strings);
values.Add(index);
index.Values = node.children;
index.Index = 0;
}
}
}
if (isTag) tagRound(strings);
return strings.ToString();
}
}
}
return nodeText.Html;
}
/// <summary>
/// 时间转换成字符串(精确到毫秒)
/// </summary>
/// <param name="time">时间</param>
/// <param name="charStream">字符流</param>
internal static unsafe void ToSqlMillisecond(DateTime time, charStream charStream)
{
ToSqlMillisecond(time, charStream.Char + charStream.Length);
charStream.Unsafer.AddLength(SqlMillisecondSize);
}
/// <summary>
/// 生成标签html
/// </summary>
/// <param name="strings">html流</param>
private void tagHtml(charStream strings)
{
if (TagName.Length != 0)
{
strings.Write('<');
strings.Write(TagName);
if (attributes != null)
{
foreach (KeyValuePair<string, htmlText> attribute in attributes)
{
strings.Write(' ');
strings.Write(HttpUtility.HtmlEncode(attribute.Key));
strings.Write(@"=""");
strings.Write(attribute.Value.Html);
strings.Write(@"""");
}
}
if (web.html.CanNonRoundTagNames.Contains(TagName) && children == null && nodeText.Html == null) strings.Write(" /");
strings.Write('>');
}
}
/// <summary>
/// 生成标签结束
/// </summary>
/// <param name="strings">html流</param>
private void tagRound(charStream strings)
{
if (TagName.Length != 0
&& (!web.html.CanNonRoundTagNames.Contains(TagName) || children != null || nodeText.Html != null))
{
strings.Write("</");
strings.Write(TagName);
strings.Write(">");
}
}
internal unsafe charStream ResetJsonStream(void* data, int size)
{
if (jsonStream == null) return jsonStream = new charStream((char*)data, size >> 1);
jsonStream.Reset((byte*)data, size);
return jsonStream;
}
