C# 结合两种方法返回两个不同的值

嗨，我有两个方法返回两种不同的返回类型的值，比如int和string，我在方法内部执行查询，传递不同的变量，如下所示

方法1

private string SelectTransactionHistory(int transactionId, ContextObject contextObject)
{
    SqlConnection con;
    SqlCommand cmd;
    con = new SqlConnection(contextObject.ConnectionString);
    con.Open();

    string returnvalue = string.Empty;            
    string selecteQuery = "SELECT Comments 
                           From dbo.TransactionHistory 
                           WHERE TransactionID = '" + transactionId + "'";
    cmd = new SqlCommand(selecteQuery, con);
    returnvalue = (string)cmd.ExecuteScalar();
    con.Close();            
    return returnvalue;        
 }

方法2

private int SelectTransactionHistoryID(string comment, ContextObject contextObject)
{
    SqlConnection con;
    SqlCommand cmd;
    con = new SqlConnection(contextObject.ConnectionString);
    con.Open();

    string query = "SELECT TransactionID  
                    From dbo.TransactionHistory 
                    WHERE Comments = '" + comment + "'";
    cmd = new SqlCommand(query, con);
    int returnvalue = (int)cmd.ExecuteScalar();
    con.Close();
    return returnvalue;
} 

我在另一个类似这样的方法中调用这些方法

int transactionId = SelectTransactionHistoryID(comment, GetContext()); 
string commentsreturnValue = SelectTransactionHistory(transactionId, GetContext());

如何结合这两种方法来生成更通用的类型。。 有人对如何做这件事有什么建议吗。。

---

非常感谢

您可以使用ado.net创建一个方法来执行任何查询，例如：

private static T ExecuteQuery<T>(ContextObject contextObject, string query)
{
    T result;
    using (SqlConnection con = con = new SqlConnection(contextObject.ConnectionString))
    {
        try
        {
            con.Open();
            using (SqlCommand cmd = cmd = new SqlCommand(query, con))
            {
                result = (T)cmd.ExecuteScalar();
            }
        }
        catch
        {
            result = null;
        }
        finally
        {
            con.Close();
        }

    }   
    returnr result;  
}

---

您可以按如下方式创建单个函数-（未测试）

然后叫它如下-

string[] TransactionHistory = SelectTransactionHistory(transactionId, GetContext());
int transactionId = Convert.ToInt32(TransactionHistory[0]);
string commentsreturnValue = TransactionHistory[1];

---

以上代码未经测试。但是你可以想出一个主意。

我有我所有的基础设施类可以利用。但是，您可以用常规方法替换简洁的扩展方法

基本服务：

public interface IService
{
     T Execute<T>(Func<IDbConnection, T> query);
     void Execute(Action<IDbConnection> query);
}

public sealed class Service : IService
{
    private readonly string _connectionString;

    public Service(string connectionString)
    {
        _connectionString = connectionString;
    }

    private IDbConnection CreateConnection()
    {
        var connection = new SqlConnection(_connectionString);
        connection.Open();

        return connection;
    }

    public T Execute<T>(Func<IDbConnection, T> query)
    {
        using (var connection = CreateConnection())
        {
            return query(connection);
        }
    }

    public void Execute(Action<IDbConnection> query)
    {
        using (var connection = CreateConnection())
        {
            query(connection);
        }
    }
}

服务：

public interface ITransactionHistoryService
{
    IEnumerable<TransactionHistory> GetByTransactionId(int transactionId);
    IEnumerable<TransactionHistory> GetByComment(string comment);
}

public sealed class TransactionHistoryService : ITransactionHistoryService
{
    // Note SELECT * is frowned upon. Replace with actual column names.
    private const string GetByTransactionIdQuery =
        "SELECT * FROM dbo.TransactionHistory WHERE TransactionID = @TransactionId";
    private const string GetByCommentQuery =
        "SELECT * FROM dbo.TransactionHistory WHERE Comments = @Comment";
    private readonly IService _service;

    public TransactionHistoryService(IService service)
    {
        _service = service;
    }

    public IEnumerable<TransactionHistory> GetByTransactionId(int transactionId)
    {
        var result = _service.Execute(c =>
                                        c.Query<TransactionHistory>(GetByTransactionIdQuery,
                                                                    new { TransactionId = transactionId }));

        return result;
    }

    public IEnumerable<TransactionHistory> GetByComment(string comment)
    {
        var result = _service.Execute(c =>
                                        c.Query<TransactionHistory>(GetByCommentQuery,
                                                                    new { Comment = comment }));

        return result;
    }
}

公共接口ITransactionHistoryService
{
IEnumerable GetByTransactionId（int transactionId）；
IEnumerable GetByComment（字符串注释）；
}
公共密封类TransactionHistoryService:ITransactionHistoryService
{
//注意：SELECT*不受欢迎。请替换为实际的列名。
私有常量字符串GetByTransactionIdQuery=
“从dbo.TransactionHistory中选择*，其中TransactionID=@TransactionID”；
私有常量字符串GetByCommentQuery=
“从dbo.TransactionHistory中选择*，其中Comments=@Comment”；
私人只读设备服务；
公共事务历史服务（iSeries服务）
{
_服务=服务；
}
公共IEnumerable GetByTransactionId（int transactionId）
{
var result=\u service.Execute（c=>
c、 查询（GetByTransactionIdQuery，
新的{TransactionId=TransactionId}）；
返回结果；
}
公共IEnumerable GetByComment（字符串注释）
{
var result=\u service.Execute（c=>
c、 查询（GetByCommentQuery，
新的{Comment=Comment}）；
返回结果；
}
}

outparameters怎么样？你说的“combine”是什么意思？这些方法的顺序调用有什么意义吗？另外，请在查询中使用参数来防止SQL注入，并使用

来释放资源。您是否只会有两个或将来可以添加更多？嗯，是否可以创建单个方法并将变量传递给该方法感谢您的建议…非常感谢此解决方案，我正在寻找此解决方案。。。我在test方法中调用这些方法…所以可以在Execute query中编写select命令吗…您可以将任何查询传递给这个方法，它将为您执行，并给出一个
T
值结果。如果它能帮助你找到最终的解决方案，记得把它作为一个awnser来检查：）哦，这里的错误处理让我哭了。就让错误冒出来吧。
public interface IService
{
     T Execute<T>(Func<IDbConnection, T> query);
     void Execute(Action<IDbConnection> query);
}

public sealed class Service : IService
{
    private readonly string _connectionString;

    public Service(string connectionString)
    {
        _connectionString = connectionString;
    }

    private IDbConnection CreateConnection()
    {
        var connection = new SqlConnection(_connectionString);
        connection.Open();

        return connection;
    }

    public T Execute<T>(Func<IDbConnection, T> query)
    {
        using (var connection = CreateConnection())
        {
            return query(connection);
        }
    }

    public void Execute(Action<IDbConnection> query)
    {
        using (var connection = CreateConnection())
        {
            query(connection);
        }
    }
}

public class TransactionHistory
{
    public int TransactionID { get; set; }
    public string Comments { get; set; }
}

public interface ITransactionHistoryService
{
    IEnumerable<TransactionHistory> GetByTransactionId(int transactionId);
    IEnumerable<TransactionHistory> GetByComment(string comment);
}

public sealed class TransactionHistoryService : ITransactionHistoryService
{
    // Note SELECT * is frowned upon. Replace with actual column names.
    private const string GetByTransactionIdQuery =
        "SELECT * FROM dbo.TransactionHistory WHERE TransactionID = @TransactionId";
    private const string GetByCommentQuery =
        "SELECT * FROM dbo.TransactionHistory WHERE Comments = @Comment";
    private readonly IService _service;

    public TransactionHistoryService(IService service)
    {
        _service = service;
    }

    public IEnumerable<TransactionHistory> GetByTransactionId(int transactionId)
    {
        var result = _service.Execute(c =>
                                        c.Query<TransactionHistory>(GetByTransactionIdQuery,
                                                                    new { TransactionId = transactionId }));

        return result;
    }

    public IEnumerable<TransactionHistory> GetByComment(string comment)
    {
        var result = _service.Execute(c =>
                                        c.Query<TransactionHistory>(GetByCommentQuery,
                                                                    new { Comment = comment }));

        return result;
    }
}