在Linq-to-SQL中，IMultipleResults是否多次访问数据库？

Question

I have a stored proc as follows :

CREATE PROCEDURE GetMultipleResults
   @SomeID int
AS
BEGIN
   SELECT * FROM SomeTable1 where SomeColumn1 = @SomeID
   SELECT * FROM SomeTable2 where SomeColumn2 = @SomeID
   SELECT * FROM SomeTable3 where SomeColumn3 = @SomeID
   SELECT * FROM SomeTable4 where SomeColumn4 = @SomeID
END

Then I use the following code to execute and retrieve the data:

[Function(Name = "dbo.SPROCName")]
[ResultType(typeof(ResultSet1))]
[ResultType(typeof(ResultSet2))]
[ResultType(typeof(ResultSet3))]
[ResultType(typeof(ResultSet4))]
public IMultipleResults SomeMethod([Parameter(DbType = "INT")] int? SomeID
{
    IExecuteResult result = this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod())), SomeID);
    return ((IMultipleResults)(result.ReturnValue));
}

Now finally, to get each result, I execute something like :

public void SomeOtherMethod(int SomeID)
{
    DataContext1 context = new DataContext1 (dbConnString);
    IMultipleResults results = context.SomeMethod(SomeID);

    ResultSet1 resultSet1= results.GetResult().FirstOrDefault();
    IEnumerable resultSet2 = results.GetResult().ToList();
    IEnumerable resultSet3 = results.GetResult().ToList();
    ResultSet4 resultSet4= results.GetResult().FirstOrDefault();
}

My question is, does Linq-to-SQL execute the entire stored procedure once, then the GetResult() is used to get it from memory, or does it execute n queries (round trip db calls) where n is the number of select statements in the stored proc (4 in this example)?

The reason I'm asking is because the following line almost takes the same amount of time to execute even for large data:

IMultipleResults results = context.SomeMethod(SomeID);

but the following part takes some noticeable time when run where resultSet3 is a large amount of data :

IEnumerable resultSet3 = results.GetResult().ToList();

Answer 1

There will certainly only be one round-trip to the database. LinqToSQL has no visibility of what's inside the stored procedure it has to rely on the ResultType attributes you have applied being correct.

Internally LinqToSQL will execute the stored procedure and then open a data reader to retrieve the results.

For the FirstOrDefault cases it will retrieve the first item (if there is one) and then skip to the next result set using IDataReader.NextResult . So even if resultSet1 is potentially large only the first row needs fetched over the network.

For the ToList cases the entire result set will be retrieved by the reader. So if there's lot of data it will necessarily take longer.