传递带参数的函数，作为参数并返回泛型类型

Question

In the code below I am trying to pass a function func in to the GetData function. This would take the reader object and map it to a generic object.

I was hoping to pass GetData an object type along with a function to map data to that object type so I didn't have to repeatedly open / close / dispose the connection.

Is this possible or does anyone have any alternative suggestions?

public T GetData<T>(string cmdText,Func<T> func)
{
    using (SqlConnection conn = new SqlConnection(connectionStringBuilder.ConnectionString))
    {
        using (SqlCommand cmd = new SqlCommand(cmdText, conn))
        {
            SqlDataReader reader = cmd.ExecuteReader();
            //return func(reader);
            //  WITHIN THE FUNC FUNCTION:
            //  while (reader.Read())
            //  {
            //  Map function to T e.g
            //  T.property = reader["column"];
            //  Return T
            //  }
        }
    }
}

Answer 1

The signature that you're looking for is this:

T GetData<T>(string cmdText, Func<SqlDataReader, T> func)

Then you can go ahead and write your function as this:

public T GetData<T>(string cmdText, Func<SqlDataReader, T> func)
{
    using (var conn = new SqlConnection(connectionStringBuilder.ConnectionString))
    {
        using (var cmd = new SqlCommand(cmdText, conn))
        {
            var reader = cmd.ExecuteReader();
            return func(reader);
        }
    }
}

And you would use it like this:

var result = GetData("select * from Foo", dr =>
{
    while (dr.Read())
    {
        return new { property = dr["column"] };
    }
    throw new DataException();
});

Now that's based on how you said you'd like to use it in your question.

However , you've made the use of the function a bit hard on yourself as you've split the implementation - part is in GetData and part is in the calling code.

You're better off using this signature:

IEnumerable<T> GetData<T>(string cmdText, Func<SqlDataReader, T> func)

Now you can write the method like this:

public IEnumerable<T> GetData<T>(string cmdText, Func<SqlDataReader, T> func)
{
    using (var conn = new SqlConnection(connectionStringBuilder.ConnectionString))
    {
        using (var cmd = new SqlCommand(cmdText, conn))
        {
            var reader = cmd.ExecuteReader();
            while (reader.Read())
            {
                yield return func(reader);
            }
        }
    }
}

The advantage now is that the calling code is much simpler:

var results = GetData("select * from Foo", dr => new { property = dr["column"] });

This returns as many rows of data as your query returns.

If you know that your calling code only returns a single value, then you can drop a .Single() at the end of the method call to ensure you get one and only one result.