public DbValueConverter AddConverter(Type columnType, Type propertyType, ConvertFunc columnToProperty, ConvertFunc propertyToColumn)
{
var conv = new DbValueConverter(columnType, propertyType, columnToProperty, propertyToColumn);
AddConverter(conv);
return(conv);
}
// скорость тиков вверх
private void TickBuySpeed(string _timeTrade, double _time_mcs, double _price)
{
double speed = 0;
double TotalMillisec_trade = ConvertFunc.TotalMillisecondTradeCalc(_timeTrade, _time_mcs);
if (_price > previosPriceBuy)
{
double delta_millisec = TotalMillisec_trade - startTimeBuy;
startTimeBuy = TotalMillisec_trade;
if (delta_millisec <= 0)
{
return;
}
speed = sec / delta_millisec;
exchangeInformation.SpeedTickBuy = AverageSpeed(speed, speedListBuy);
previosPriceBuy = _price;
}
else
{
if (_price < previosPriceBuy)
{
previosPriceBuy = _price;
}
}
}
T[] Convert <T>(T[] arr1, ConvertFunc action, Clone <T> clone)
where T : class, IQueryElement
{
T[] arr2 = null;
for (var i = 0; i < arr1.Length; i++)
{
var elem1 = arr1[i];
var elem2 = (T)ConvertInternal(elem1, action);
if (elem2 != null && !ReferenceEquals(elem1, elem2))
{
if (arr2 == null)
{
arr2 = new T[arr1.Length];
for (var j = 0; j < i; j++)
{
arr2[j] = clone == null ? arr1[j] : clone(arr1[j]);
}
}
arr2[i] = elem2;
}
else if (arr2 != null)
{
arr2[i] = clone == null ? elem1 : clone(elem1);
}
}
return(arr2);
}
List <T> Convert <T>(List <T> list1, ConvertFunc action, Clone <T> clone)
where T : class, IQueryElement
{
List <T> list2 = null;
for (var i = 0; i < list1.Count; i++)
{
var elem1 = list1[i];
var elem2 = (T)ConvertInternal(elem1, action);
if (elem2 != null && !ReferenceEquals(elem1, elem2))
{
if (list2 == null)
{
list2 = new List <T>(list1.Count);
for (var j = 0; j < i; j++)
{
list2.Add(clone == null ? list1[j] : clone(list1[j]));
}
}
list2.Add(elem2);
}
else if (list2 != null)
{
list2.Add(clone == null ? elem1 : clone(elem1));
}
}
return(list2);
}
public override string ToString()
{
string resultToString = String.Format("{0},{1},{2:P2},{3:P2},{4:P2},{5},{6},{7},{8},{9},{10:P2},{11:P2},{12},{13},{14},{15},{16},,{17},{18}",
(itsBuy ? "buy" : "sell"),
request.Symbol,
endPriceIntervalPercentage,
startPriceIntervalPercentage,
fullIntervalPercentage,
endPrice,
startPrice,
maxOrMinPrice,
originalMaxOrMinPrice,
bestPrice,
updatePercentage,
extraPercent.Percent,
timeAllOrder.ToString(),
timeThisOrder.ToString(),
ConvertFunc.ConvertFromDateTime(startTimeThisOrder),
ConvertFunc.ConvertFromDateTime(endTimeOrder),
numUpdate,
request.Print(),
Result.Print()
);
return(resultToString);
}
/// <summary>
/// Pасчет скорости сделок в сд/сек
/// </summary>
/// <param name="_timeTrade">время сделки 00:00:00</param>
/// <param name="_time_mcs">время микросекунды</param>
public void TradesSpeed(string _timeTrade, double _time_mcs)
{
double speed = 0;
double TotalMillisec_trade = ConvertFunc.TotalMillisecondTradeCalc(_timeTrade, _time_mcs);
double delta_millisec = TotalMillisec_trade - TotalMillisec_trade_previos;
TotalMillisec_trade_previos = TotalMillisec_trade;
if (delta_millisec <= 0)
{
return;
}
speed = sec / delta_millisec;
speedList.Add(speed);
if (speedList.Count < countSpeedList)
{
return;
}
else
{
exchangeInformation.SpeedTrades = speedList.Average();
speedList.RemoveAt(0);
}
}
public DbValueConverter(Type columnType, Type propertyType, ConvertFunc columnToProperty, ConvertFunc propertyToColumn)
{
ColumnType = columnType;
PropertyType = propertyType;
ColumnToPropertyUnsafe = columnToProperty ?? NoConvertFunc;
PropertyToColumn = propertyToColumn ?? NoConvertFunc;
ColumnToProperty = ConvertSafeColumnToProp;
}
private DbValueConverter BuildEnumValueConverter(Type columnType, Type enumType)
{
var colToEnum = BuildIntToEnum(columnType, enumType);
var enumToCol = BuildEnumToInt(columnType, enumType);
ConvertFunc entToDbFunc = x => Convert.ChangeType(x, columnType);
var convObj = new DbValueConverter(columnType, enumType, (ConvertFunc)colToEnum, (ConvertFunc)enumToCol);
return(convObj);
}
public static void RegisterObjectConvert <T>(
IJsonConvert <T> convert)
{
ConvertFunc convert_wrapper =
delegate(IJsonWrapper input) {
return(convert.Convert(input));
};
custom_object_convert[typeof(T)] = convert_wrapper;
}
private bool Get <T>(string key, ref T value, ConvertFunc <T> convertFunc = null)
{
if (configMap.TryGetValue(key, out string strValue))
{
if ((convertFunc != null) && convertFunc(strValue, out T converted))
{
value = converted;
return(true);
}
}
return(false);
}
public static T[] ConvertToArray <T>(this byte[] bytes, int count, int stride, ConvertFunc <T> func)
{
T[] values = new T[count];
int offset = 0;
for (int i = 0; i < count; i++)
{
values[i] = func(bytes, offset);
offset += stride;
}
return(values);
}
public bool ReadSetting <T>(string settingName, ConvertFunc <T> convertingFunc, out T result)
{
var val = _settingsProvider.GetValueForKey(settingName);
if (val == null)
{
result = default(T);
return(false);
}
if (convertingFunc(val, out result) == false)
{
result = default(T);
return(false);
}
return(true);
}
/// <summary>
/// Скорость сделок с группировкой по тикам
/// </summary>
/// <param name="_timeTrade">время сделки 00:00:00</param>
/// <param name="_time_mcs">время сделки микросекунды</param>
/// <param name="_priceTrade">цена сделки</param>
public void SpeedTradesTickMeasure(string _timeTrade, double _time_mcs, double _priceTrade)
{
if (!ServiceFunc.CheckFunc.CheckTimeSession(_timeTrade, ref session_check))
{
return;
}
double speed = 0;
double TotalMillisec_trade = ConvertFunc.TotalMillisecondTradeCalc(_timeTrade, _time_mcs);
if (_priceTrade != priceTradesPrevios)
{
double delta = TotalMillisec_trade - TotalMillisecTradeStart;
TotalMillisecTradeStart = TotalMillisec_trade;
if (delta < 0)
{
exchangeInformation.SpeedTradesTick = 0;
MessageBox.Show("delta меньше НУЛЯ!");
}
else
{
if (delta == 0)
{
delta = 1;
} // если delta==0, будем считать, что сделки в тике прошли с минимальным разрывом.
speed = sec / delta;
double maxspeed_for_view = 100; // ограничение для отображения на графике
if (speed > maxspeed_for_view)
{
speed = maxspeed_for_view;
}
exchangeInformation.SpeedTradesTick = speed;
SpeedAvg(speed);
}
}
else
{
/*здесь вариант если буду считать скорость до смены тика*/
}
priceTradesPrevios = _priceTrade;
}
IQueryElement ConvertInternal(IQueryElement element, ConvertFunc action)
{
if (element == null)
{
return(null);
}
IQueryElement newElement;
if (_visitedElements.TryGetValue(element, out newElement))
{
return(newElement);
}
switch (element.ElementType)
{
case QueryElementType.SqlFunction:
{
var func = (SqlFunction)element;
var parms = Convert(func.Parameters, action);
if (parms != null && !ReferenceEquals(parms, func.Parameters))
{
newElement = new SqlFunction(func.SystemType, func.Name, func.Precedence, parms);
}
break;
}
case QueryElementType.SqlExpression:
{
var expr = (SqlExpression)element;
var parameter = Convert(expr.Parameters, action);
if (parameter != null && !ReferenceEquals(parameter, expr.Parameters))
{
newElement = new SqlExpression(expr.SystemType, expr.Expr, expr.Precedence, parameter);
}
break;
}
case QueryElementType.SqlBinaryExpression:
{
var bexpr = (SqlBinaryExpression)element;
var expr1 = (ISqlExpression)ConvertInternal(bexpr.Expr1, action);
var expr2 = (ISqlExpression)ConvertInternal(bexpr.Expr2, action);
if (expr1 != null && !ReferenceEquals(expr1, bexpr.Expr1) ||
expr2 != null && !ReferenceEquals(expr2, bexpr.Expr2))
{
newElement = new SqlBinaryExpression(bexpr.SystemType, expr1 ?? bexpr.Expr1, bexpr.Operation, expr2 ?? bexpr.Expr2, bexpr.Precedence);
}
break;
}
case QueryElementType.SqlTable:
{
var table = (SqlTable)element;
var fields1 = ToArray(table.Fields);
var fields2 = Convert(fields1, action, f => new SqlField(f));
var joins = Convert(table.Joins, action, j => j.Clone());
var targs = table.TableArguments == null ? null : Convert(table.TableArguments, action);
var fe = fields2 == null || ReferenceEquals(fields1, fields2);
var je = joins == null || ReferenceEquals(table.Joins, joins);
var ta = ReferenceEquals(table.TableArguments, targs);
if (!fe || !je || !ta)
{
if (fe)
{
fields2 = fields1;
for (var i = 0; i < fields2.Length; i++)
{
var field = fields2[i];
fields2[i] = new SqlField(field);
_visitedElements[field] = fields2[i];
}
}
newElement = new SqlTable(table, fields2, joins ?? table.Joins, targs ?? table.TableArguments);
_visitedElements[((SqlTable)newElement).All] = table.All;
}
break;
}
case QueryElementType.Join:
{
var join = (Join)element;
var ons = Convert(join.JoinOns, action);
if (ons != null && !ReferenceEquals(join.JoinOns, ons))
{
newElement = new Join(join.TableName, join.Alias, ons);
}
break;
}
case QueryElementType.Column:
{
var col = (SqlQuery.Column)element;
var expr = (ISqlExpression)ConvertInternal(col.Expression, action);
IQueryElement parent;
_visitedElements.TryGetValue(col.Parent, out parent);
if (parent != null || expr != null && !ReferenceEquals(expr, col.Expression))
{
newElement = new SqlQuery.Column(parent == null ? col.Parent : (SqlQuery)parent, expr ?? col.Expression, col._alias);
}
break;
}
case QueryElementType.TableSource:
{
var table = (SqlQuery.TableSource)element;
var source = (ISqlTableSource)ConvertInternal(table.Source, action);
var joins = Convert(table.Joins, action);
if (source != null && !ReferenceEquals(source, table.Source) ||
joins != null && !ReferenceEquals(table.Joins, joins))
{
newElement = new SqlQuery.TableSource(source ?? table.Source, table._alias, joins ?? table.Joins);
}
break;
}
case QueryElementType.JoinedTable:
{
var join = (SqlQuery.JoinedTable)element;
var table = (SqlQuery.TableSource)ConvertInternal(join.Table, action);
var cond = (SqlQuery.SearchCondition)ConvertInternal(join.Condition, action);
if (table != null && !ReferenceEquals(table, join.Table) ||
cond != null && !ReferenceEquals(cond, join.Condition))
{
newElement = new SqlQuery.JoinedTable(join.JoinType, table ?? join.Table, join.IsWeak, cond ?? join.Condition);
}
break;
}
case QueryElementType.SearchCondition:
{
var sc = (SqlQuery.SearchCondition)element;
var conds = Convert(sc.Conditions, action);
if (conds != null && !ReferenceEquals(sc.Conditions, conds))
{
newElement = new SqlQuery.SearchCondition(conds);
}
break;
}
case QueryElementType.Condition:
{
var c = (SqlQuery.Condition)element;
var p = (ISqlPredicate)ConvertInternal(c.Predicate, action);
if (p != null && !ReferenceEquals(c.Predicate, p))
{
newElement = new SqlQuery.Condition(c.IsNot, p, c.IsOr);
}
break;
}
case QueryElementType.ExprPredicate:
{
var p = (SqlQuery.Predicate.Expr)element;
var e = (ISqlExpression)ConvertInternal(p.Expr1, action);
if (e != null && !ReferenceEquals(p.Expr1, e))
{
newElement = new SqlQuery.Predicate.Expr(e, p.Precedence);
}
break;
}
case QueryElementType.NotExprPredicate:
{
var p = (SqlQuery.Predicate.NotExpr)element;
var e = (ISqlExpression)ConvertInternal(p.Expr1, action);
if (e != null && !ReferenceEquals(p.Expr1, e))
{
newElement = new SqlQuery.Predicate.NotExpr(e, p.IsNot, p.Precedence);
}
break;
}
case QueryElementType.ExprExprPredicate:
{
var p = (SqlQuery.Predicate.ExprExpr)element;
var e1 = (ISqlExpression)ConvertInternal(p.Expr1, action);
var e2 = (ISqlExpression)ConvertInternal(p.Expr2, action);
if (e1 != null && !ReferenceEquals(p.Expr1, e1) || e2 != null && !ReferenceEquals(p.Expr2, e2))
{
newElement = new SqlQuery.Predicate.ExprExpr(e1 ?? p.Expr1, p.Operator, e2 ?? p.Expr2);
}
break;
}
case QueryElementType.LikePredicate:
{
var p = (SqlQuery.Predicate.Like)element;
var e1 = (ISqlExpression)ConvertInternal(p.Expr1, action);
var e2 = (ISqlExpression)ConvertInternal(p.Expr2, action);
var es = (ISqlExpression)ConvertInternal(p.Escape, action);
if (e1 != null && !ReferenceEquals(p.Expr1, e1) ||
e2 != null && !ReferenceEquals(p.Expr2, e2) ||
es != null && !ReferenceEquals(p.Escape, es))
{
newElement = new SqlQuery.Predicate.Like(e1 ?? p.Expr1, p.IsNot, e2 ?? p.Expr2, es ?? p.Escape);
}
break;
}
case QueryElementType.BetweenPredicate:
{
var p = (SqlQuery.Predicate.Between)element;
var e1 = (ISqlExpression)ConvertInternal(p.Expr1, action);
var e2 = (ISqlExpression)ConvertInternal(p.Expr2, action);
var e3 = (ISqlExpression)ConvertInternal(p.Expr3, action);
if (e1 != null && !ReferenceEquals(p.Expr1, e1) ||
e2 != null && !ReferenceEquals(p.Expr2, e2) ||
e3 != null && !ReferenceEquals(p.Expr3, e3))
{
newElement = new SqlQuery.Predicate.Between(e1 ?? p.Expr1, p.IsNot, e2 ?? p.Expr2, e3 ?? p.Expr3);
}
break;
}
case QueryElementType.IsNullPredicate:
{
var p = (SqlQuery.Predicate.IsNull)element;
var e = (ISqlExpression)ConvertInternal(p.Expr1, action);
if (e != null && !ReferenceEquals(p.Expr1, e))
{
newElement = new SqlQuery.Predicate.IsNull(e, p.IsNot);
}
break;
}
case QueryElementType.InSubQueryPredicate:
{
var p = (SqlQuery.Predicate.InSubQuery)element;
var e = (ISqlExpression)ConvertInternal(p.Expr1, action);
var q = (SqlQuery)ConvertInternal(p.SubQuery, action);
if (e != null && !ReferenceEquals(p.Expr1, e) || q != null && !ReferenceEquals(p.SubQuery, q))
{
newElement = new SqlQuery.Predicate.InSubQuery(e ?? p.Expr1, p.IsNot, q ?? p.SubQuery);
}
break;
}
case QueryElementType.InListPredicate:
{
var p = (SqlQuery.Predicate.InList)element;
var e = (ISqlExpression)ConvertInternal(p.Expr1, action);
var v = Convert(p.Values, action);
if (e != null && !ReferenceEquals(p.Expr1, e) || v != null && !ReferenceEquals(p.Values, v))
{
newElement = new SqlQuery.Predicate.InList(e ?? p.Expr1, p.IsNot, v ?? p.Values);
}
break;
}
case QueryElementType.FuncLikePredicate:
{
var p = (SqlQuery.Predicate.FuncLike)element;
var f = (SqlFunction)ConvertInternal(p.Function, action);
if (f != null && !ReferenceEquals(p.Function, f))
{
newElement = new SqlQuery.Predicate.FuncLike(f);
}
break;
}
case QueryElementType.SetExpression:
{
var s = (SqlQuery.SetExpression)element;
var c = (ISqlExpression)ConvertInternal(s.Column, action);
var e = (ISqlExpression)ConvertInternal(s.Expression, action);
if (c != null && !ReferenceEquals(s.Column, c) || e != null && !ReferenceEquals(s.Expression, e))
{
newElement = new SqlQuery.SetExpression(c ?? s.Column, e ?? s.Expression);
}
break;
}
case QueryElementType.SetClause:
{
var s = (SqlQuery.SetClause)element;
var t = s.Into != null ? (SqlTable)ConvertInternal(s.Into, action) : null;
var i = Convert(s.Items, action);
if (t != null && !ReferenceEquals(s.Into, t) || i != null && !ReferenceEquals(s.Items, i))
{
var sc = new SqlQuery.SetClause();
sc.Into = t ?? sc.Into;
sc.Items.AddRange(i ?? s.Items);
sc.WithIdentity = s.WithIdentity;
newElement = sc;
}
break;
}
case QueryElementType.SelectClause:
{
var sc = (SqlQuery.SelectClause)element;
var cols = Convert(sc.Columns, action);
var take = (ISqlExpression)ConvertInternal(sc.TakeValue, action);
var skip = (ISqlExpression)ConvertInternal(sc.SkipValue, action);
IQueryElement parent;
_visitedElements.TryGetValue(sc.SqlQuery, out parent);
if (parent != null ||
cols != null && !ReferenceEquals(sc.Columns, cols) ||
take != null && !ReferenceEquals(sc.TakeValue, take) ||
skip != null && !ReferenceEquals(sc.SkipValue, skip))
{
newElement = new SqlQuery.SelectClause(sc.IsDistinct, take ?? sc.TakeValue, skip ?? sc.SkipValue, cols ?? sc.Columns);
((SqlQuery.SelectClause)newElement).SetSqlQuery((SqlQuery)parent);
}
break;
}
case QueryElementType.FromClause:
{
var fc = (SqlQuery.FromClause)element;
var ts = Convert(fc.Tables, action);
IQueryElement parent;
_visitedElements.TryGetValue(fc.SqlQuery, out parent);
if (parent != null || ts != null && !ReferenceEquals(fc.Tables, ts))
{
newElement = new SqlQuery.FromClause(ts ?? fc.Tables);
((SqlQuery.FromClause)newElement).SetSqlQuery((SqlQuery)parent);
}
break;
}
case QueryElementType.WhereClause:
{
var wc = (SqlQuery.WhereClause)element;
var cond = (SqlQuery.SearchCondition)ConvertInternal(wc.SearchCondition, action);
IQueryElement parent;
_visitedElements.TryGetValue(wc.SqlQuery, out parent);
if (parent != null || cond != null && !ReferenceEquals(wc.SearchCondition, cond))
{
newElement = new SqlQuery.WhereClause(cond ?? wc.SearchCondition);
((SqlQuery.WhereClause)newElement).SetSqlQuery((SqlQuery)parent);
}
break;
}
case QueryElementType.GroupByClause:
{
var gc = (SqlQuery.GroupByClause)element;
var es = Convert(gc.Items, action);
IQueryElement parent;
_visitedElements.TryGetValue(gc.SqlQuery, out parent);
if (parent != null || es != null && !ReferenceEquals(gc.Items, es))
{
newElement = new SqlQuery.GroupByClause(es ?? gc.Items);
((SqlQuery.GroupByClause)newElement).SetSqlQuery((SqlQuery)parent);
}
break;
}
case QueryElementType.OrderByClause:
{
var oc = (SqlQuery.OrderByClause)element;
var es = Convert(oc.Items, action);
IQueryElement parent;
_visitedElements.TryGetValue(oc.SqlQuery, out parent);
if (parent != null || es != null && !ReferenceEquals(oc.Items, es))
{
newElement = new SqlQuery.OrderByClause(es ?? oc.Items);
((SqlQuery.OrderByClause)newElement).SetSqlQuery((SqlQuery)parent);
}
break;
}
case QueryElementType.OrderByItem:
{
var i = (SqlQuery.OrderByItem)element;
var e = (ISqlExpression)ConvertInternal(i.Expression, action);
if (e != null && !ReferenceEquals(i.Expression, e))
{
newElement = new SqlQuery.OrderByItem(e, i.IsDescending);
}
break;
}
case QueryElementType.Union:
{
var u = (SqlQuery.Union)element;
var q = (SqlQuery)ConvertInternal(u.SqlQuery, action);
if (q != null && !ReferenceEquals(u.SqlQuery, q))
{
newElement = new SqlQuery.Union(q, u.IsAll);
}
break;
}
case QueryElementType.SqlQuery:
{
var q = (SqlQuery)element;
IQueryElement parent = null;
var doConvert = q.ParentSql != null && !_visitedElements.TryGetValue(q.ParentSql, out parent);
if (!doConvert)
{
doConvert = null != Find(q, e =>
{
var ret = action(e);
if (ret != null && !ReferenceEquals(e, ret))
{
_visitedElements.Add(e, ret);
return(true);
}
return(false);
});
}
if (!doConvert)
{
break;
}
var nq = new SqlQuery {
QueryType = q.QueryType
};
_visitedElements.Add(q, nq);
var fc = (SqlQuery.FromClause)ConvertInternal(q.From, action) ?? q.From;
var sc = (SqlQuery.SelectClause)ConvertInternal(q.Select, action) ?? q.Select;
var tc = q.QueryType == QueryType.Update || q.QueryType == QueryType.Insert ? ((SqlQuery.SetClause)ConvertInternal(q.Set, action) ?? q.Set) : null;
var wc = (SqlQuery.WhereClause)ConvertInternal(q.Where, action) ?? q.Where;
var gc = (SqlQuery.GroupByClause)ConvertInternal(q.GroupBy, action) ?? q.GroupBy;
var hc = (SqlQuery.WhereClause)ConvertInternal(q.Having, action) ?? q.Having;
var oc = (SqlQuery.OrderByClause)ConvertInternal(q.OrderBy, action) ?? q.OrderBy;
var us = q.HasUnion ? Convert(q.Unions, action) : q.Unions;
var ps = new List <SqlParameter>(q.Parameters.Count);
foreach (var p in q.Parameters)
{
IQueryElement e;
if (_visitedElements.TryGetValue(p, out e))
{
if (e == null)
{
ps.Add(p);
}
else if (e is SqlParameter)
{
ps.Add((SqlParameter)e);
}
}
}
nq.Init(tc, sc, fc, wc, gc, hc, oc, us, (SqlQuery)parent, q.ParameterDependent, ps);
_visitedElements[q] = action(nq) ?? nq;
return(nq);
}
}
newElement = newElement == null?action(element) : (action(newElement) ?? newElement);
_visitedElements.Add(element, newElement);
return(newElement);
}
public T Convert <T>(T element, ConvertFunc action)
where T : class, IQueryElement
{
_visitedElements.Clear();
return((T)ConvertInternal(element, action) ?? element);
}
List <T> Convert <T>(List <T> list, ConvertFunc action)
where T : class, IQueryElement
{
return(Convert(list, action, null));
}
T[] Convert <T>(T[] arr, ConvertFunc action)
where T : class, IQueryElement
{
return(Convert(arr, action, null));
}
private static object ReadValue(Type inst_type, JsonReader reader)
{
reader.Read();
if (reader.Token == JsonToken.ArrayEnd)
{
return(null);
}
Type underlying_type = Nullable.GetUnderlyingType(inst_type);
Type value_type = underlying_type ?? inst_type;
if (reader.Token == JsonToken.Null)
{
if (inst_type.IsClass || underlying_type != null)
{
return(null);
}
throw new JsonException(String.Format(
"Can't assign null to an instance of type {0}",
inst_type));
}
if (reader.Token == JsonToken.Double ||
reader.Token == JsonToken.Int ||
reader.Token == JsonToken.Long ||
reader.Token == JsonToken.String ||
reader.Token == JsonToken.Boolean)
{
Type json_type = reader.Value.GetType();
if (value_type.IsAssignableFrom(json_type))
{
return(reader.Value);
}
// If there's a custom importer that fits, use it
if (custom_importers_table.ContainsKey(json_type) &&
custom_importers_table[json_type].ContainsKey(
value_type))
{
ImporterFunc importer =
custom_importers_table[json_type][value_type];
return(importer(reader.Value));
}
// Maybe there's a base importer that works
if (base_importers_table.ContainsKey(json_type) &&
base_importers_table[json_type].ContainsKey(
value_type))
{
ImporterFunc importer =
base_importers_table[json_type][value_type];
return(importer(reader.Value));
}
// Maybe it's an enum
if (value_type.IsEnum)
{
return(Enum.ToObject(value_type, reader.Value));
}
// Try using an implicit conversion operator
MethodInfo conv_op = GetConvOp(value_type, json_type);
if (conv_op != null)
{
return(conv_op.Invoke(null,
new object[] { reader.Value }));
}
// No luck
throw new JsonException(String.Format(
"Can't assign value '{0}' (type {1}) to type {2}",
reader.Value, json_type, inst_type));
}
object instance = null;
if (reader.Token == JsonToken.ArrayStart)
{
AddArrayMetadata(inst_type);
ArrayMetadata t_data = array_metadata[inst_type];
if (!t_data.IsArray && !t_data.IsList)
{
throw new JsonException(String.Format(
"Type {0} can't act as an array",
inst_type));
}
IList list;
Type elem_type;
if (!t_data.IsArray)
{
list = (IList)Activator.CreateInstance(inst_type);
elem_type = t_data.ElementType;
}
else
{
list = new ArrayList();
elem_type = inst_type.GetElementType();
}
while (true)
{
object item = ReadValue(elem_type, reader);
if (item == null && reader.Token == JsonToken.ArrayEnd)
{
break;
}
list.Add(item);
}
if (t_data.IsArray)
{
int n = list.Count;
instance = Array.CreateInstance(elem_type, n);
for (int i = 0; i < n; i++)
{
((Array)instance).SetValue(list[i], i);
}
}
else
{
instance = list;
}
}
else if (reader.Token == JsonToken.ObjectStart)
{
if (custom_object_convert.ContainsKey(value_type))
{
WrapperFactory factory = delegate { return(new JsonData()); };
IJsonWrapper wrapper = factory();
wrapper.SetJsonType(JsonType.Object);
while (true)
{
reader.Read();
if (reader.Token == JsonToken.ObjectEnd)
{
break;
}
string property = (string)reader.Value;
((IDictionary)wrapper)[property] = ReadValue(
factory, reader);
}
ConvertFunc convert = custom_object_convert[value_type];
return(convert(wrapper));
}
else
{
AddObjectMetadata(value_type);
ObjectMetadata t_data = object_metadata[value_type];
instance = Activator.CreateInstance(value_type);
while (true)
{
reader.Read();
if (reader.Token == JsonToken.ObjectEnd)
{
break;
}
string property = (string)reader.Value;
if (t_data.Properties.ContainsKey(property))
{
PropertyMetadata prop_data =
t_data.Properties[property];
if (prop_data.IsField)
{
((FieldInfo)prop_data.Info).SetValue(
instance, ReadValue(prop_data.Type, reader));
}
else
{
PropertyInfo p_info =
(PropertyInfo)prop_data.Info;
if (p_info.CanWrite)
{
p_info.SetValue(
instance,
ReadValue(prop_data.Type, reader),
null);
}
else
{
ReadValue(prop_data.Type, reader);
}
}
}
else
{
if (!t_data.IsDictionary)
{
if (!reader.SkipNonMembers)
{
throw new JsonException(String.Format(
"The type {0} doesn't have the " +
"property '{1}'",
inst_type, property));
}
else
{
ReadSkip(reader);
continue;
}
}
((IDictionary)instance).Add(
property, ReadValue(
t_data.ElementType, reader));
}
}
}
}
return(instance);
}
public TypedValueConverterBase(ConvertFunc convertFunc, ConvertBackFunc convertBackFunc = null)
{
_convertFunc = convertFunc;
_convertBackFunc = convertBackFunc;
}
/// <summary>
/// 进行CSV资源文件解析，并加载到缓冲集合中。
/// </summary>
/// <typeparam name="T">Orm类。</typeparam>
/// <param name="aAssetName">资源文件名称。</param>
/// <param name="aTxtContent">资源文件内容。</param>
/// <param name="aConfigDic">要装载的缓冲集合。</param>
//public static void Parse<T>( string aAssetName, string aTxtContent, IDictionary<int, T> aConfigDic ) {
// //文件格式检查
// Debug.Log( "正在解析资源：" + aAssetName );
// IList<string> txtLines = aTxtContent.Split( new[]
// {
// "\r\n"
//}, StringSplitOptions.RemoveEmptyEntries ).ToList();
// if ( txtLines.Count < 2 ) {
// return;
// }
// //导入数据的列检查和筛选
// IDictionary<int, ColumnInfo> columnInfodDic = new Dictionary<int, ColumnInfo>();
// IDictionary<string, FieldInfo> fieldDic = typeof( T ).GetFields( BindingFlags.Instance | BindingFlags.Public ).ToDictionary( c => c.Name.ToUpper(), c => c );
// int iCounter = 0;
// IDictionary<int, string> columnDic = txtLines[1].Split( new[]
// {
// ","
//}, StringSplitOptions.None ).ToDictionary( c => iCounter++, c => c.ToUpper() );
// foreach ( KeyValuePair<string, FieldInfo> itr in fieldDic ) {
// if ( columnDic.Values.Contains( itr.Key ) ) {
// bool isArray = itr.Value.FieldType.IsArray;
// iCounter = 0;
// for ( int i = 0; i < columnDic.Count; i++ ) {
// if ( columnDic[i] == itr.Key ) {
// columnInfodDic.Add( i, new ColumnInfo { mColumnName = itr.Key, mFieldInfo = itr.Value, mArrayIndex = isArray ? iCounter : 0 } );
// if ( isArray ) {
// iCounter++;
// } else {
// break;
// }
// }
// }
// } else {
// return;
// }
// }
// //动态加载数据到缓冲集合中
// aConfigDic.Clear();
// //Func<T> funcExpress = GetExpressCreateFunc<T>();
// //Func<T> funcEmit = GetEmitCreateFunc<T>();
// for ( int i = 2; i < txtLines.Count; i++ ) {
// int sID = int.MinValue;
// //经过测试，以下3种性能差别不大；稳定起见，还是考虑第1种方式
// T ormObj = Activator.CreateInstance<T>(); //对象动态创建方式1
// //T ormObj = funcExpress(); //对象动态创建方式2
// //T ormObj = funcEmit(); //对象动态创建方式3
// string[] txtLine = txtLines[i].Split( new[]
// {
// ","
// }, StringSplitOptions.None );
// for ( int j = 0; j < txtLine.Length; j++ ) {
// if ( !columnInfodDic.ContainsKey( j ) || columnInfodDic[j].mArrayIndex > 0 ) {
// continue;
// }
// FieldInfo fInfo = columnInfodDic[j].mFieldInfo;
// Type fType = fInfo.FieldType;
// //不是数组，直接赋值
// if ( !fType.IsArray ) {
// fInfo.SetValue( ormObj, mTypeDic.ContainsKey( fType ) ? mTypeDic[fType]( txtLine[j] ) : txtLine[j] );
// if ( j == 0 ) {
// sID = int.Parse( txtLine[j] );
// }
// continue;
// }
// //是数组，需查找所有的相同字段名
// IList<int> arrayIndexs = (
// from itr in columnInfodDic
// where itr.Value.mColumnName == columnInfodDic[j].mColumnName
// select itr.Key
// ).ToList();
// fType = fType.GetElementType();
// Array objAry = Array.CreateInstance( fType, arrayIndexs.Count );
// for ( int k = 0; k < arrayIndexs.Count; k++ ) {
// objAry.SetValue( mTypeDic.ContainsKey( fType ) ? mTypeDic[fType]( txtLine[arrayIndexs[k]] ) : txtLine[arrayIndexs[k]], k );
// }
// fInfo.SetValue( ormObj, objAry );
// }
// if ( aConfigDic.ContainsKey( sID ) ) {
// aConfigDic[sID] = ormObj;
// Debug.LogWarning( string.Format( "资源文件 <{0}> 的Key <{1}> 重复，系统自动进行覆盖", aAssetName, sID ) );
// } else {
// aConfigDic.Add( sID, ormObj );
// }
// }
//}
//private static Func<T> GetExpressCreateFunc<T>()
//{
// return Expression.Lambda<Func<T>>(Expression.New(typeof(T)), null).Compile();
//}
//private static Func<T> GetEmitCreateFunc<T>()
//{
// DynamicMethod method = new DynamicMethod("", typeof(T), null);
// ILGenerator il = method.GetILGenerator();
// il.Emit(OpCodes.Newobj, typeof(T).GetConstructors()[0]);
// il.Emit(OpCodes.Ret);
// return method.CreateDelegate(typeof(Func<T>)) as Func<T>;
//}
#endregion
// #region public static T ParseXml<T>(string) 进行XML资源文件解析，并返回加载好的对象。
// /// <summary>
// /// 进行XML资源文件解析，并返回加载好的对象。
// /// </summary>
// /// <typeparam name="T">Orm类。</typeparam>
// /// <param name="aTxtContent">资源文件内容。</param>
// /// <returns>加载好的Orm对象。</returns>
// public static T ParseXml<T>(string aTxtContent) {
// IDictionary<string, FieldInfo> fieldDic = typeof(T).GetFields(BindingFlags.Instance | BindingFlags.Public).ToDictionary(c => c.Name.ToUpper(), c => c);
// T ormObj = Activator.CreateInstance<T>();
// XmlDocument xmlDoc = new XmlDocument();
// xmlDoc.LoadXml(aTxtContent);
// foreach(XmlNode node in xmlDoc.GetElementsByTagName("item")) {
// FieldInfo fInfo;
// if(fieldDic.TryGetValue(node.Attributes["key"].Value.ToUpper(), out fInfo)) {
// fInfo.SetValue(ormObj, mTypeDic.ContainsKey(fInfo.FieldType) ? mTypeDic[fInfo.FieldType](node.Attributes["value"].Value) : node.Attributes["value"].Value);
// }
// }
// return ormObj;
// }
// #endregion
#region private static void RegisterConvert() Orm映射字段的类型转换函数注册。
/// <summary>
/// Orm映射字段的类型转换函数注册。
/// </summary>
private static void RegisterConvert()
{
mTypeDic = new Dictionary <Type, ConvertFunc>();
//bool
ConvertFunc cFunc = delegate(string aReadValue) {
ushort rst;
if (ushort.TryParse(aReadValue, out rst))
{
return(rst != 0);
}
return(false);
};
mTypeDic.Add(typeof(bool), cFunc);
//byte
cFunc = delegate(string aReadValue) {
byte rst;
return(!byte.TryParse(aReadValue, out rst) ? (byte)0 : rst);
};
mTypeDic.Add(typeof(byte), cFunc);
//char
cFunc = delegate(string aReadValue) {
char rst;
return(!char.TryParse(aReadValue, out rst) ? '0' : rst);
};
mTypeDic.Add(typeof(char), cFunc);
//decimal
cFunc = delegate(string aReadValue) {
decimal rst;
return(!decimal.TryParse(aReadValue, out rst) ? 0 : rst);
};
mTypeDic.Add(typeof(decimal), cFunc);
//double
cFunc = delegate(string aReadValue) {
double rst;
return(!double.TryParse(aReadValue, out rst) ? 0 : rst);
};
mTypeDic.Add(typeof(double), cFunc);
//float
cFunc = delegate(string aReadValue) {
float rst;
return(!float.TryParse(aReadValue, out rst) ? 0f : rst);
};
mTypeDic.Add(typeof(float), cFunc);
//int
cFunc = delegate(string aReadValue) {
int rst;
return(!int.TryParse(aReadValue, out rst) ? 0 : rst);
};
mTypeDic.Add(typeof(int), cFunc);
//long
cFunc = delegate(string aReadValue) {
long rst;
return(!long.TryParse(aReadValue, out rst) ? 0 : rst);
};
mTypeDic.Add(typeof(long), cFunc);
//sbyte
cFunc = delegate(string aReadValue) {
sbyte rst;
return(!sbyte.TryParse(aReadValue, out rst) ? (sbyte)0 : rst);
};
mTypeDic.Add(typeof(sbyte), cFunc);
//short
cFunc = delegate(string aReadValue) {
short rst;
return(!short.TryParse(aReadValue, out rst) ? (short)0 : rst);
};
mTypeDic.Add(typeof(short), cFunc);
//string 不需要类型转换
//uint
cFunc = delegate(string aReadValue) {
uint rst;
return(!uint.TryParse(aReadValue, out rst) ? 0 : rst);
};
mTypeDic.Add(typeof(uint), cFunc);
//ushort
cFunc = delegate(string aReadValue) {
ushort rst;
return(!ushort.TryParse(aReadValue, out rst) ? (ushort)0 : rst);
};
mTypeDic.Add(typeof(ushort), cFunc);
}
public ProxyTableMetadataInternalEventToPublic(ConvertFunc procConvert,
ConvertToUndFunc procConvertToUnd)
{
ProcConvert = procConvert;
ProcConvertToUnd = procConvertToUnd;
}
public DbValueConverter AddConverter <TColumn, TProperty>(ConvertFunc columnToProperty, ConvertFunc propertyToColumn)
{
return(AddConverter(typeof(TColumn), typeof(TProperty), columnToProperty, propertyToColumn));
}
