public void HandleBlockingRequestArgsReturns()
{
const int num = 10;
const int expectedResult = 55;
var mock = new Mock <ITestService> (MockBehavior.Strict);
mock.Setup(x => x.BlockingProcedureReturns(It.IsAny <int> (), It.IsAny <int> ()))
.Returns((int n, int sum) => BlockingProcedureReturnsFn(n, sum));
TestService.Service = mock.Object;
var call = Call("TestService", "BlockingProcedureReturns", Arg(0, num));
BlockingProcedureReturnsFnCount = 0;
ProcedureResult result = null;
Continuation <ProcedureResult> continuation = new ProcedureCallContinuation(call);
while (result == null)
{
try {
result = continuation.Run();
} catch (YieldException e) {
continuation = (Continuation <ProcedureResult>)e.Continuation;
}
}
// Verify the KRPCProcedure is called once, but the handler function is called multiple times
mock.Verify(x => x.BlockingProcedureReturns(It.IsAny <int> (), It.IsAny <int> ()), Times.Once());
Assert.AreEqual(num + 1, BlockingProcedureReturnsFnCount);
CheckResultNotEmpty(result);
Assert.AreEqual(expectedResult, (int)result.Value);
}
void Update(ulong id, ProcedureResult result)
{
lock (updateLock) {
if (!streams.ContainsKey(id))
{
return;
}
var stream = streams [id];
object value;
if (result.Error == null)
{
value = Encoder.Decode(result.Value, stream.ReturnType, connection);
}
else
{
value = connection.GetException(result.Error);
}
var condition = stream.Condition;
lock (condition) {
stream.Value = value;
Monitor.PulseAll(condition);
}
foreach (var callback in stream.Callbacks)
{
callback(value);
}
}
}
public void SetUp()
{
// Create a response object and get the binary representation of it
var streamUpdate = new StreamUpdate();
var result1 = new ProcedureResult();
result1.Error = new Error("Foo", string.Empty);
var streamResult1 = new StreamResult();
streamResult1.Id = 1263;
streamResult1.Result = result1;
var result2 = new ProcedureResult();
result2.Error = new Error("Bar", string.Empty);
var streamResult2 = new StreamResult();
streamResult2.Id = 3443;
streamResult2.Result = result2;
streamUpdate.Results.Add(streamResult1);
streamUpdate.Results.Add(streamResult2);
expectedUpdate = streamUpdate;
using (var stream = new MemoryStream()) {
expectedUpdate.ToProtobufMessage().WriteDelimitedTo(stream);
updateBytes = stream.ToArray();
}
}
public ProcedureResult ExecuteCall(ProcedureSignature procedure, object[] arguments)
{
if ((CallContext.GameScene & procedure.GameScene) == 0)
{
throw new RPCException("Procedure not available in game scene '" + CallContext.GameScene + "'");
}
object returnValue;
try {
returnValue = procedure.Handler.Invoke(arguments);
} catch (TargetInvocationException e) {
if (e.InnerException is YieldException)
{
throw e.InnerException;
}
throw new RPCException(e.InnerException);
}
var result = new ProcedureResult();
if (procedure.HasReturnType)
{
CheckReturnValue(procedure, returnValue);
result.Value = returnValue;
}
return(result);
}
static void CheckError(string name, string description, ProcedureResult result)
{
Assert.IsFalse(result.HasValue);
Assert.IsTrue(result.HasError);
Assert.AreEqual(name, result.Error.Name);
Assert.AreEqual(description, result.Error.Description);
}
public override void UpdateInternal()
{
try {
Result = continuation.Run();
} catch (YieldException) {
return;
} catch (System.Exception e) {
Result = new ProcedureResult {
Error = Service.Services.Instance.HandleException(e)
};
}
}
public override void Update()
{
try {
Result = continuation.Run();
} catch (YieldException) {
return;
} catch (System.Exception e) {
Result = new ProcedureResult {
Error = Core.HandleException(e)
};
}
}
/// <summary>
/// 执行存储过程
/// 存储过程是以sql语句的形式执行
/// 一般要求存储过程最后一个参数为output ，且为varchar(N)形式，对应的是out msg
/// </summary>
/// <param name="strSql">存储过程对应的sql语句</param>
/// <param name="retPosition">最后一个output参数的位置</param>
/// <param name="msg">返回字符中，最后一个参数</param>
/// <param name="rslt"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public ProcedureResult ExecuteProcedure(string strSql, int retPosition, params object[] parameters)
{
var result = new ProcedureResult()
{
Msg = "",
Rslt = -1,
Ds = new DataSet(),
};
if (strSql.IsNullOrEmpty())
{
return(null);
}
var sw = Stopwatch.StartNew();
DbConnection conn = null;
try
{
var ds = SelectDataSet(strSql, parameters);
if (ds != null && ds.Tables.Count > 0)
{
var dr = ds.Tables[ds.Tables.Count - 1].Rows[0];
result.Rslt = (int)dr["r"];
var colName = "op" + retPosition.ToString();
result.Msg = dr[colName].ConvertTo <string>();
ds.Tables.RemoveAt(ds.Tables.Count - 1);
if (result.Ds != null)
{
result.Ds.Tables.Clear();
result.Ds.Tables.AddRange(ds.Tables.Cast <DataTable>().Select(a => a.Copy()).ToArray());
}
}
}
catch (Exception e)
{
Logger.Error("({0})：{1} {2}".Formats(strSql, e.Message, e.StackTrace));
return(null);
}
finally
{
Close(conn);
var useTime = sw.ElapsedMilliseconds;
var logStr = "({0}) 执行时间 {1} 毫秒".Formats(strSql, useTime.ToString("F0"));
if (useTime > WornigMilliseconds)
{
Logger.Warn(logStr);
}
Logger.Debug(logStr);
}
return(result);
}
public static Schema.KRPC.ProcedureResult ToProtobufMessage(this ProcedureResult procedureResult)
{
var result = new Schema.KRPC.ProcedureResult();
if (procedureResult.HasValue)
{
result.Value = Encoder.Encode(procedureResult.Value);
}
if (procedureResult.HasError)
{
result.Error = procedureResult.Error.ToProtobufMessage();
}
return(result);
}
public ProcedureResult ExecuteCall(ProcedureSignature procedure, IContinuation continuation)
{
object returnValue;
try {
returnValue = continuation.RunUntyped();
} catch (YieldException) {
throw;
} catch (System.Exception e) {
throw new RPCException(e);
}
var result = new ProcedureResult();
if (procedure.HasReturnType)
{
CheckReturnValue(procedure, returnValue);
result.Value = returnValue;
}
return(result);
}
/// <summary>
/// プロシージャー実行による DbCommand の実行結果を取得します。
/// </summary>
public static ProcedureResult GetProcedureResult(this DbCommand command)
{
var result = new ProcedureResult();
// INOUT、OUTPUT、戻り値を格納する
foreach (DbParameter parameter in command.Parameters)
{
if (parameter.Direction == ParameterDirection.ReturnValue)
{
result.ReturnValue = parameter.Value;
}
if (parameter.Direction == ParameterDirection.InputOutput ||
parameter.Direction == ParameterDirection.Output)
{
result.Output.Add(parameter.ParameterName, parameter.Value);
}
}
return(result);
}
/// <summary>
/// 微信授权登录
/// </summary>
/// <param name=""></param>
/// <returns></returns>
public override ProcedureResult Login(CCY_Client client)
{
DbParameters Parameters = new DbParameters();
Parameters.Add("@in_sNickName", client.sNickName, DbType.String);
Parameters.Add("@in_sUnionid", client.sUnionid, DbType.String);
Parameters.Add("@in_sOpenId", client.sOpenId, DbType.String);
Parameters.Add("@@in_sHeadImg", client.sHeadImg, DbType.String);
Parameters.Add("@in_code", 0, DbType.Int32, ParameterDirection.Output);
Parameters.Add("@in_msg", null, DbType.String, ParameterDirection.Output, 100);
var list = query.QueryProcedure <dynamic>("ProviderSystem_ProviderUser_Login", Parameters);
var result = new ProcedureResult();
result.iCode = Parameters.Get <int>("in_code");
result.sMsg = Parameters.Get <string>("in_msg");
if (result.iCode == 100)
{
result.sData = list[0];
}
return(result);
}
static void CheckResultEmpty(ProcedureResult result)
{
Assert.IsFalse(result.HasValue);
Assert.IsFalse(result.HasError);
}
public StreamResult()
{
Result = new ProcedureResult();
}
