Dapper Distinguishing Return Value and Result Set - dapper

Question

I am using Dapper's QueryMultipleAsync method to read multiple result set. My stored procedure checks some conditions (for example a user might be trying to get someone else's data by sending an Id to my API) to determine whether the data should return or not.
I, on C# side, first need to read the return value (not result set) to determine if data is returned or SP simply returned 3 (which means insufficient rights). To illustrate the case:
IF #UserRole < 10
BEGIN
RETURN 3; -- Insufficient rights.
END
IF #IsCurrentUserOwner = 0
BEGIN
RETURN 5; -- Not owner.
END
-- Get users.
SELECT
Id
, [Name]
, LastName
FROM
Users
-- WHERE ...
-- Get chat messages.
SELECT
*
FROM
ChatMessages
-- WHERE ...
I know that output and return values are written at the end of reader so I can only read return parameter when all the data (result set) is read. So, I always have to read the result set first then return/output parameters.
What if my SP looked like this:
-- ...some code above...
IF #IsCurrentUserOwner = 0
BEGIN
RETURN 5; -- Not owner.
END
DECLARE #RType TINYINT = NULL
-- some other code here to get #RType value here...
SELECT #RType -- To make this a result so QueryMultiple's reader can read this.
-- ...some other code to get users and chat messages...
To describe the problem:
#RType variable could be 5 as well as SP's return value. When I read the result first (because output/return parameters are at the end of reader), how do I know the value I just read (which is 5 in this case) is the #RType or return value? (they are convertible)
This is how my C# code roughly looks like:
var parameters = new DynamicParameters();
parameters.Add("#RetVal", dbType: DbType.Int32, direction: ParameterDirection.ReturnValue);
var dbResult = await Context.SqlConnection.QueryMultipleAsync(sql: "my_sp_name", param: parameters, commandType: CommandType.StoredProcedure)
// Some code here...
using (var reader = dbResult)
{
var rType = reader.Read<byte>(); // <----- How to know if I read #RType or just return value of SP since they are convertible to each other?
var users = reader.Read<User>();
var chatMessages = reader.Read<ChatMessage>();
// ...
}
var returnValue = parameters.Get<int>("#RetVal");
if (returnValue == 5)
{
return "You are not allowed to see this data";
}
How do you recommend me to handle the case?

Answer 1

Your C# code uses async - await (QueryMultipleAsync) and currently Dapper doesn't support for Async methods that no perform a SELECT statement.
There is an open issue about that in Github:
https://github.com/StackExchange/Dapper/issues/591
Option 1
You can split your stored procedure into 2 parts:
1. Check the Return value.
2. Getting the select statements.
Option 2
ALTER PROCEDURE dbo.sp
... your params..
#Output INT OUTPUT
AS
IF #UserRole < 10
BEGIN
SET #Output = 3; -- Insufficient rights.
END
IF #IsCurrentUserOwner = 0
BEGIN
SET #Output = 5; -- Not owner.
END
-- Get users.
SELECT
Id
, [Name]
, LastName
FROM
Users
-- WHERE ...
-- Get chat messages.
SELECT
*
FROM
ChatMessages
-- WHERE ...
Option 3
Use ADO.NET

Answer 2

I wasn't really clear on your question, but the snippet below should work. Since you are defining the #RetVal as ParameterDirection.ReturnValue you should be able to access it before accessing the actual readers. I was able to verify this works in SQL SERVER.
var returnValue = parameters.Get<int>("#RetVal");
if (returnValue == 5 || returnValue == 3)
{
return "You are not allowed to see this data";
}
using (var reader = dbResult)
{
var rType = reader.Read<byte>(); // <----- How to know if I read #RType or just return value of SP since they are convertible to each other?
var users = reader.Read<User>();
var chatMessages = reader.Read<ChatMessage>();
// ...
}
here is my stored procedure
ALTER PROCEDURE mysp_TestOne
#p1 int
AS
BEGIN
SET NOCOUNT ON;
if #p1 > 0
return 5;
SELECT 1 F1
union
Select 2 F1;
SELECT 1 F1
union
Select 2 F1;
END
GO
and more complete snippet of c#;
using (SqlConnection cn = new SqlConnection(connectionString))
{
var sql = #"mysp_TestOne";
var parameters = new DynamicParameters();
// #p1 triggers whether to return query results or just the returnvalue
parameters.Add("p1", 0, direction: ParameterDirection.Input);
parameters.Add("#RetVal", 0, direction: ParameterDirection.ReturnValue);
var dbResult = await cn.QueryMultipleAsync(sql, parameters, commandType: CommandType.StoredProcedure);
var returnValue = parameters.Get<int>("#RetVal");
if (returnValue == 5 || returnValue == 3)
{
return "You are not allowed to see this data";
}
using (var reader = dbResult)
{
var rType = reader.Read<byte>(); // <----- How to know if I read #RType or just return value of SP since they are convertible to each other?
var users = reader.Read<User>();
var chatMessages = reader.Read<ChatMessage>();
// ...
}
}
HTH