public R Provide(C context)
{
object prvContext = context;
// lets try to convert context to IDictionary b/c this is preferred context in NIC.NET
if (prvContext != null)
{
var cnv = ConvertManager.FindConverter(prvContext.GetType(), typeof(IDictionary));
if (cnv != null)
{
prvContext = cnv.Convert(prvContext, typeof(IDictionary));
}
}
object res = UnderlyingProvider.GetObject(prvContext);
if (!(res is R) && res != null)
{
return(ConvertManager.ChangeType <R>(res));
}
else
{
return((R)((object)res));
}
}
static void Main(string[] args)
{
LogManager.Configure(new TraceLogger());
IComponentsConfig config = ConfigurationSettings.GetConfig("components") as IComponentsConfig;
INamedServiceProvider srvPrv = new NReco.Winter.ServiceProvider(config);
var zz = ConvertManager.ChangeType <IOperation <object> >(srvPrv.GetService("ZZ"));
IOperation <IDictionary <string, object> > a = srvPrv.GetService("A") as IOperation <IDictionary <string, object> >;
NameValueContext c = new NameValueContext();
Console.WriteLine("NReco 'hello world' sample. Try to type 'hello' or 'what is your name', 'die' for exit");
while (true)
{
Console.Write("you> ");
c["msg"] = Console.ReadLine();
Console.Write("nreco> ");
a.Execute(c);
if (c.ContainsKey("state") && Convert.ToString(c["state"]) == "exit")
{
return;
}
}
}
public static LambdaParameterWrapper operator %(LambdaParameterWrapper c1, LambdaParameterWrapper c2)
{
var c1decimal = ConvertManager.ChangeType <decimal>(c1.Value);
var c2decimal = ConvertManager.ChangeType <decimal>(c2.Value);
return(new LambdaParameterWrapper(c1decimal % c2decimal));
}
public static bool AreEqual(object o1, object o2)
{
if (o1 == null && o2 == null)
{
return(true);
}
if (o1 != null)
{
var o1EqRes = o1.Equals(o2);
// if Equals returns false try to convert o2 to o1 type
if (!o1EqRes && o2 != null)
{
var o2Conv = ConvertManager.FindConverter(o2.GetType(), o1.GetType());
if (o2Conv != null)
{
return(o1.Equals(o2Conv.Convert(o2, o1.GetType())));
}
}
return(o1EqRes);
}
if (o2 != null)
{
return(o2.Equals(o1));
}
return(false);
}
/// <summary>
/// 写入字节数据
/// </summary>
/// <param name="identity">数据标识</param>
/// <param name="buffer">字节数据</param>
/// <param name="remark">其他信息</param>
public void Write(string identity, byte[] buffer, string remark = "")
{
if (IsEnable || IsRomte)
{
ConvertManager.Push(GetPath(identity), buffer, remark);
}
}
public virtual void Execute(IDictionary <string, object> context)
{
var delegParams = TargetDelegate.Method.GetParameters();
if (delegParams.Length != Arguments.Count)
{
throw new TargetParameterCountException(
String.Format("Delegate {0} requires {1} parameter(s)", TargetDelegate.GetType(), delegParams.Length));
}
var argValues = new object[Arguments.Count];
var i = 0;
foreach (var argFunc in Arguments)
{
var argValue = argFunc(context);
argValues[i] = ConvertManager.ChangeType(argValue, delegParams[i].ParameterType);
i++;
}
var invokeResult = TargetDelegate.DynamicInvoke(argValues);
if (ResultKey != null)
{
context[ResultKey] = invokeResult;
}
}
protected bool CheckParamsCompatibility(ParameterInfo[] paramsInfo, Type[] types, object[] values)
{
for (int i = 0; i < paramsInfo.Length; i++)
{
Type paramType = paramsInfo[i].ParameterType;
if (paramType.IsInstanceOfType(values[i]))
{
continue;
}
// null and reference types
if (values[i] == null && !paramType.IsValueType)
{
continue;
}
// possible autocast between generic/non-generic common types
if (ConvertManager.CanChangeType(types[i], paramType))
{
continue;
}
// incompatible parameter
return(false);
}
return(true);
}
public object Evaluate(IDictionary context, string expression)
{
IDictionary <string, object> varContext = ConvertManager.ChangeType(context, typeof(IDictionary <string, object>)) as IDictionary <string, object>;
return(UnderlyingExprProvider.Provide(
new ExpressionContext <string>(expression, varContext)));
}
public object Provide(object context)
{
object o = GetCodeObject();
Type t = o.GetType();
MethodInfo mi = t.GetMethod(CodeMethodName);
NameValueContext varContext = new NameValueContext();
foreach (VariableDescriptor varDescr in Variables)
{
object varValue = varDescr.VarProvider.Provide(context);
if (varValue != null && !varDescr.VarType.IsInstanceOfType(varValue))
{
ITypeConverter cnv = ConvertManager.FindConverter(varValue.GetType(), varDescr.VarType);
if (cnv != null)
{
varValue = cnv.Convert(varValue, varDescr.VarType);
}
else
{
throw new InvalidCastException(
String.Format("Context variable {0} cannot be cast to expected type {1}",
varDescr.Name, varDescr.VarType));
}
}
varContext[varDescr.Name] = varValue;
}
object s = mi.Invoke(o, new object[] { varContext });
return(s);
}
public static LambdaParameterWrapper InvokeDelegate(object obj, object[] args)
{
if (obj is LambdaParameterWrapper)
{
obj = ((LambdaParameterWrapper)obj).Value;
}
if (obj == null)
{
throw new NullReferenceException("Delegate is null");
}
if (!(obj is Delegate))
{
throw new NullReferenceException(String.Format("{0} is not a delegate", obj.GetType()));
}
var deleg = (Delegate)obj;
var delegParams = deleg.Method.GetParameters();
if (delegParams.Length != args.Length)
{
throw new TargetParameterCountException(
String.Format("Target delegate expects {0} parameters", delegParams.Length));
}
var resolvedArgs = new object[args.Length];
for (int i = 0; i < resolvedArgs.Length; i++)
{
resolvedArgs[i] = ConvertManager.ChangeType(
args[i] is LambdaParameterWrapper ? ((LambdaParameterWrapper)args[i]).Value : args[i],
delegParams[i].ParameterType);
}
return(new LambdaParameterWrapper(deleg.DynamicInvoke(resolvedArgs)));
}
private string BuildValueString(IProvider provider, PropertyFieldMapping mapping, DbParameterCollection parameters, object value, int index, int batch)
{
var sb = new StringBuilder();
var converter = ConvertManager.GetConverter(mapping.PropertyType);
if (converter != null)
{
value = converter.ConvertTo(value, mapping.FieldType);
}
if (value is Enum)
{
sb.Append((int)value);
}
else if (NeedPutParameters(mapping.FieldType, value))
{
var prefix = provider.GetService <ISyntaxProvider>().ParameterPrefix;
var parameterName = AddOrReplayParameter(parameters, mapping.FieldType, ref value, index, batch,
() => provider.DbProviderFactory.CreateParameter());
sb.AppendFormat("{0}{1}", prefix, parameterName);
}
else if (value is string || value is Guid)
{
sb.AppendFormat("'{0}'", value);
}
else
{
sb.Append(value);
}
return(sb.ToString());
}
protected override object ConvertTo(object o, Type toType)
{
// optimization: do not use type conversion mechanizm for conversions between primitive types
//if (o!=null && o.GetType().IsPrimitive && toType.IsPrimitive) {
if (Converter != null && o != null && Converter.CanConvert(o.GetType(), toType))
{
return(Converter.Convert(o, toType));
}
if (o != null)
{
ITypeConverter cnv = ConvertManager.FindConverter(o.GetType(), toType);
if (cnv != null)
{
return(cnv.Convert(o, toType));
}
}
else
{
if (!toType.IsValueType)
{
return(null);
}
}
//}
return(base.ConvertTo(o, toType));
}
protected override object Invoke(params object[] args)
{
var targetParams = Target.Method.GetParameters();
var allArgs = new object[targetParams.Length];
int argIdx = 0;
for (int i = 0; i < allArgs.Length; i++)
{
var hasFixedParam = FixedArgs.Length > i && !KeepArg.Equals(FixedArgs[i]);
if (hasFixedParam)
{
allArgs[i] = ConvertManager.ChangeType(FixedArgs[i], targetParams[i].ParameterType);
}
else
{
if (args.Length > argIdx)
{
allArgs[i] = ConvertManager.ChangeType(args[argIdx++], targetParams[i].ParameterType);
}
else
{
throw new TargetParameterCountException("Insufficient number of arguments");
}
}
}
return(Target.DynamicInvoke(allArgs));
}
private Expression BuildExecuteBatch(BatchCommandExpression batch)
{
var operation = Parameterize(batch.Operation.Body);
var result = translator(operation);
var namedValues = NamedValueGatherer.Gather(operation);
var table = new DataTable();
foreach (var nv in namedValues)
{
var info = GetPropertyInfoFromExpression(nv.Value);
table.Columns.Add(nv.Name, info.DataType.Value.FromDbType());
}
var parameters = namedValues.ToDictionary(s => s.Name, s =>
{
var expression = s.Value;
if (ConvertManager.GetConverter(expression.Type) != null)
{
var info = GetPropertyInfoFromExpression(expression);
var convExp = Expression.Call(null, MthGetConverter, Expression.Constant(expression.Type));
expression = Expression.Call(convExp, MthConvertTo, expression, Expression.Constant((DbType)info.DataType));
}
var lambda = Expression.Lambda(expression, batch.Operation.Parameters[1]).Compile();
return(lambda);
});
var entities = (IEnumerable)((ConstantExpression)batch.Input).Value;
foreach (IEntity entity in entities)
{
var row = table.NewRow();
foreach (var nv in parameters)
{
row[nv.Key] = nv.Value.DynamicInvoke(entity) ?? DBNull.Value;
}
table.Rows.Add(row);
}
Expression plan = Expression.Call(executor, MthUpdate,
Expression.Constant(table),
Expression.Constant((SqlCommand)result.QueryText),
Expression.Constant(null, typeof(SqlCommand)),
Expression.Constant(null, typeof(SqlCommand))
);
if (operation.NodeType != (ExpressionType)DbExpressionType.Insert)
{
return(plan);
}
return(Expression.Call(typeof(ExecutionBuilder), nameof(ExecutionBuilder.UpdateEntities), null,
plan,
Expression.Constant(table, typeof(DataTable)),
Expression.Constant(entities, typeof(IEnumerable))));
}
/// <summary>
/// 开始监听
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public static async Task Start(AspNetWebSocketContext context)
{
string socketID = context.QueryString[SOCKETIDNAME].ToString();
WebSocket socket = context.WebSocket;
ContainsKeyInit(socket, socketID);
ArraySegment <byte> buffer = new ArraySegment <byte>(new byte[2048]);
#region 离线消息处理
if (MESSAGE_POOL.ContainsKey(socketID))
{
List <SendMessageModel> msgs = MESSAGE_POOL[socketID];
foreach (SendMessageModel item in msgs)
{
buffer = new ArraySegment <byte>(Encoding.UTF8.GetBytes(ConvertManager.ModelToJson(item)));
await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
MESSAGE_POOL.Remove(socketID);
}
#endregion
while (true)
{
if (socket.State == WebSocketState.Open)
{
WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None);
string receivedMessage = Encoding.UTF8.GetString(buffer.Array, 0, result.Count);
ReceivedMessageModel recM = ConvertManager.JsonToModel <ReceivedMessageModel>(receivedMessage);
if (CONNECT_POOL.ContainsKey(recM.TargetSocketID)) //判断客户端是否在线
{
WebSocket destSocket = CONNECT_POOL[recM.TargetSocketID]; //目的客户端
if (destSocket != null && destSocket.State == WebSocketState.Open)
{
buffer = new ArraySegment <byte>(Encoding.UTF8.GetBytes(ConvertManager.ModelToJson(new SendMessageModel(recM.Message))));
await destSocket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
}
else
{
await Task.Run(() =>
{
if (!MESSAGE_POOL.ContainsKey(recM.TargetSocketID))//将用户添加至离线消息池中
{
MESSAGE_POOL.Add(recM.TargetSocketID, new List <SendMessageModel>());
}
MESSAGE_POOL[recM.TargetSocketID].Add(new SendMessageModel(recM.Message));//添加离线消息
});
}
}
else
{
if (CONNECT_POOL.ContainsKey(socketID))
{
CONNECT_POOL.Remove(socketID);
}
break;
}
}
}
public WeChatManagerTests()
{
#region 测试代码--微信Token
string resStr = "{\"access_token\":\"zWtGZHO2EHfig-nBhIUb0XtQrh88kqDXV4RalOUvZi22tFELCKieW30O85aQafsH8DOKX1HS-J1Scb7Bdi7jShgrLg4Jc8_sBxcFuqYnGyf5QplcIZLXwOt7tHlcxDKEJPFaAIAXDT\",\"expires_in\":7200}";
WeChatTokenModel tempTokenM = ConvertManager.JsonToModel <WeChatTokenModel>(resStr);
WebCacheManager.Set("MATERALWECHATTOKENKEY", tempTokenM, DateTimeOffset.Now.AddSeconds(tempTokenM.expires_in - 60));
#endregion
}
/// <summary>
/// 将一个 <see cref="IDataReader"/> 转换为一个 <typeparamref name="T"/> 的对象。
/// </summary>
/// <param name="database">当前的 <see cref="IDatabase"/> 对象。</param>
/// <param name="reader">一个 <see cref="IDataReader"/> 对象。</param>
/// <returns>由当前 <see cref="IDataReader"/> 对象中的数据转换成的 <typeparamref name="T"/> 对象实例。</returns>
public virtual T Map(IDatabase database, IDataReader reader)
{
var value = RecordWrapper == null ? reader[0] :
RecordWrapper.GetValue(reader, 0);
var converter = ConvertManager.GetConverter(typeof(T));
return(converter != null ? (T)converter.ConvertFrom(value, reader.GetFieldType(0).GetDbType()) :
value.To <object, T>());
}
public override object Convert(object o, Type toType)
{
// check for special case
if (o != null && toType == typeof(IExpressionResolver) &&
TypeHelper.FindGenericInterface(o.GetType(), typeof(IProvider <,>)) != null)
{
var exprPrv = ConvertManager.ChangeType <IProvider <ExpressionContext <string>, object> >(o);
return(base.Convert(exprPrv, toType));
}
return(base.Convert(o, toType));
}
/// <summary>
/// 将一个 <see cref="DataRow"/> 转换为一个 <typeparamref name="T"/> 的对象。
/// </summary>
/// <param name="database">当前的 <see cref="IDatabase"/> 对象。</param>
/// <param name="row">一个 <see cref="DataRow"/> 对象。</param>
/// <returns>由 <see cref="DataRow"/> 中数据转换成的 <typeparamref name="T"/> 对象实例。</returns>
public virtual T Map(IDatabase database, DataRow row)
{
var converter = ConvertManager.GetConverter(typeof(T));
if (converter != null)
{
return((T)converter.ConvertFrom(row[0], row.Table.Columns[0].DataType.GetDbType()));
}
return(row[0].To <object, T>());
}
public async Task StartAsync <T>() where T : IWebSocketClientHandler
{
var handler = ConvertManager.GetDefaultObject <T>();
if (!(handler is WebSocketClientHandler clientHandler))
{
throw new MateralWebSocketClientException("Handler类型必须派生于WebSocketClientHandler");
}
_clientHandler = clientHandler;
await StartAsync();
}
internal static TC ToTypeEx <TS, TC>(this TS value)
{
var converter = ConvertManager.GetConverter(typeof(TC));
if (converter != null)
{
return((TC)converter.ConvertFrom(value, typeof(TC).GetDbType()));
}
return(value.To <TS, TC>());
}
protected override Expression VisitColumn(ColumnExpression column)
{
ParameterExpression recordWrapper;
ParameterExpression dataReader;
int ordinal;
if (scope != null && scope.TryGetValue(column, out recordWrapper, out dataReader, out ordinal))
{
if (!column.Type.IsDbTypeSupported())
{
throw new InvalidCastException(SR.GetString(SRKind.InvalidCastPropertyValue, column.Type.FullName));
}
//把 ColumnExpression 换成 RecordWrapper.GetInt32(IDataReader, int) 这样的表达式
var dbType = column.MapInfo != null && column.MapInfo.DataType != null ?
(DbType)column.MapInfo.DataType : column.Type.GetDbType();
var method = RecordWrapHelper.GetMethodByOrdinal(dbType);
Expression expression = Expression.Call(recordWrapper, method, dataReader, Expression.Constant(ordinal));
//先找转换器
var converter = ConvertManager.GetConverter(column.Type);
if (converter != null)
{
//调用ConvertManager.GetConverter
var mconverter = Expression.Call(null, MthGetConverter, Expression.Constant(column.Type));
//调用 IValueConverter.ConvertFrom
expression = (Expression)Expression.Convert(
Expression.Call(mconverter, MthConvert, expression, Expression.Constant(dbType)),
column.Type);
}
else
{
if (column.Type.IsNullableType())
{
//调用 RecordWrapper.IsDbNull 判断值是否为空
expression = (Expression)Expression.Condition(
Expression.Call(recordWrapper, MthIsDbNull, dataReader, Expression.Constant(ordinal)),
Expression.Convert(Expression.Constant(null), column.Type),
Expression.Convert(expression, column.Type));
}
else if (column.Type != method.ReturnType)
{
expression = (Expression)Expression.Convert(expression, column.Type);
}
}
return(expression);
}
return(column);
}
/// <summary>
/// 根据条件查询日志分页信息
/// </summary>
/// <param name="qModel">查询条件</param>
/// <param name="pageM">分页对象</param>
/// <returns>日志信息</returns>
public MPagingData <List <LogModel> > GetInfoByWhere(LogQueryModel qModel, MPagingModel pageM)
{
DataSet ds = SQLServerManager.Pagination(qModel.GetQuerySQL(false), qModel.GetGroupStr(), pageM.PagingIndex, pageM.PagingSize);
MPagingData <List <LogModel> > resM = new MPagingData <List <LogModel> >();
resM.Data = ConvertManager.DataTableToList <LogModel>(ds.Tables[0]);
pageM.PagingIndex = Convert.ToInt32(ds.Tables[1].Rows[0][0]);
pageM.DataCount = Convert.ToInt32(ds.Tables[1].Rows[0][1]);
pageM.PagingCount = Convert.ToInt32(ds.Tables[1].Rows[0][2]);
resM.PageInfo = pageM;
return(resM);
}
/// <summary>
/// 将一个 <see cref="DataRow"/> 转换为一个 <typeparamref name="T"/> 的对象。
/// </summary>
/// <param name="row">一个 <see cref="DataRow"/> 对象。</param>
/// <returns>由 <see cref="DataRow"/> 中数据转换成的 <typeparamref name="T"/> 对象实例。</returns>
public virtual T Map(DataRow row)
{
var index = row.Table.Columns.Count != 1 ? 1 : 0;
var converter = ConvertManager.GetConverter(typeof(T));
if (converter != null)
{
return((T)converter.ConvertFrom(row[index], row.Table.Columns[index].DataType.GetDbType()));
}
return(row[index].To <object, T>());
}
public TValue this[TKey key] {
get {
if (Map[key] != null && !(Map[key] is TValue))
{
return(ConvertManager.ChangeType <TValue>(Map[key]));
}
return((TValue)Map[key]);
}
set {
Map[key] = value;
}
}
public static LambdaParameterWrapper operator +(LambdaParameterWrapper c1, LambdaParameterWrapper c2)
{
if (c1.Value is string || c2.Value is string)
{
return(new LambdaParameterWrapper(Convert.ToString(c1.Value) + Convert.ToString(c2.Value)));
}
else
{
var c1decimal = ConvertManager.ChangeType <decimal>(c1.Value);
var c2decimal = ConvertManager.ChangeType <decimal>(c2.Value);
return(new LambdaParameterWrapper(c1decimal + c2decimal));
}
}
public void Execute(IDictionary context)
{
C c;
if (!(context is C) && context != null)
{
c = ConvertManager.ChangeType <C>(context);
}
else
{
c = (C)((object)context);
}
UnderlyingOperation.Execute(c);
}
/// <summary>
/// 获取是否支持数据类型。
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static bool IsDbTypeSupported(this Type type)
{
Guard.ArgumentNull(type, "type");
type = type.GetNonNullableType();
var typeCode = Type.GetTypeCode(type);
if (ConvertManager.CanConvert(type))
{
return(true);
}
return(typeCode != TypeCode.Object &&
typeCode != TypeCode.Empty &&
typeCode != TypeCode.DBNull);
}
/// <summary>
/// 将一个 <see cref="IDataReader"/> 转换为一个 <typeparamref name="T"/> 的对象。
/// </summary>
/// <param name="reader">一个 <see cref="IDataReader"/> 对象。</param>
/// <returns>由当前 <see cref="IDataReader"/> 对象中的数据转换成的 <typeparamref name="T"/> 对象实例。</returns>
public virtual T Map(IDataReader reader)
{
var index = reader.FieldCount != 1 ? 1 : 0;
var value = RecordWrapper == null ? reader[index] :
RecordWrapper.GetValue(reader, index);
var converter = ConvertManager.GetConverter(typeof(T));
if (converter != null)
{
return((T)converter.ConvertFrom(value, reader.GetFieldType(index).GetDbType()));
}
return(value.To <object, T>());
}
private async void Button_OnClicked(object sender, EventArgs e)
{
string currency = null;
var selectedIndex = CurrencyPicker.SelectedIndex;
if (selectedIndex != -1)
{
currency = CurrencyPicker.Items[selectedIndex];
}
var amountInput = AmountEntry.Text;
var amount = decimal.Parse(amountInput);
var result = await ConvertManager.ConvertCurrency(currency, amount);
await DisplayAlert("Success!", amount + " Bitcoins is: " + result.ToString(CultureInfo.InvariantCulture) + currency, "Close");
}
