C# 如何从使用 LINQ to SQL 的方法返回查询结果
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/1075770/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
How to return query results from method that uses LINQ to SQL
提问by alchemical
Here is the code I'm working with, I'm still a bit new to LINQ, so this is a work in progress. Specifically, I'd like to get my results from this query (about 7 columns of strings, ints, and datetime), and return them to the method that called the method containing this LINQ to SQL query. A simple code example would be super helpful.
这是我正在使用的代码，我对 LINQ 还是有点陌生，所以这是一项正在进行的工作。具体来说，我想从这个查询中获取我的结果（大约 7 列字符串、整数和日期时间），并将它们返回给调用包含这个 LINQ to SQL 查询的方法的方法。一个简单的代码示例将非常有帮助。
using (ormDataContext context = new ormDataContext(connStr))
{
var electionInfo = from t1 in context.elections
join t2 in context.election_status
on t1.statusID equals t2.statusID
select new { t1, t2 };
}
(In this case, my query is returning all the contents of 2 tables, election and election_status.)
（在本例中，我的查询返回了 2 个表的所有内容，即选举和选举状态。）
回答by Daniel A. White
return electionInfo.ToList();
回答by John Fisher
You'll need to create classes that have the same structure as the anonymous types. Then, instead of "new { t1, t2 }", you use "new MyClass(t1, t2)".
您需要创建与匿名类型具有相同结构的类。然后，您使用“new MyClass(t1, t2)”而不是“new { t1, t2 }”。
Once you have a named class, you can pass it all over the place as you were hoping.
一旦你有了一个命名的类，你就可以像你希望的那样在整个地方传递它。
回答by Richard Anthony Hein
You cannot return an anonymous type from a method. It is only available within the scope in which it is created. You'll have to create a class instead.
您不能从方法返回匿名类型。它仅在创建它的范围内可用。你必须创建一个类。
回答by Doctor Jones
Specifically, I'd like to get my results from this query (about 7 columns of strings, ints, and datetime), and return them
具体来说，我想从这个查询中得到我的结果（大约 7 列字符串、整数和日期时间），并返回它们
Hi, the problem you've got with your query is that you're creating an anonymous type. You cannot return an anonymous type from a method, so this is where you're going to have trouble.
您好，您在查询中遇到的问题是您正在创建一个匿名类型。你不能从方法返回匿名类型，所以这就是你会遇到麻烦的地方。
What you will need to do is to create a "wrapper" type that can take an election and an election_status and then return those.
您需要做的是创建一个“包装器”类型，它可以进行选举和选举状态，然后返回它们。
Here's a little sample of what I'm talking about; as you can see I declare a Tuple class. The method that you will wrap your query in returns an IEnumerable.
这是我正在谈论的一个小样本；如您所见，我声明了一个 Tuple 类。您将在其中包装查询的方法返回一个 IEnumerable。
I hope this helps :-)
我希望这有帮助 ：-）
class Tuple
{
Election election;
Election_status election_status;
public Tuple(Election election, Election_status election_status)
{
this.election = election;
this.election_status = election_status;
}
}
public IEnumerable<Tuple> getElections()
{
IEnumerable<Tuple> result = null;
using (ormDataContext context = new ormDataContext(connStr))
{
result = from t1 in context.elections
join t2 in context.election_status
on t1.statusID equals t2.statusID
select new Tuple(t1, t2);
}
}
UPDATE
更新
Following from NagaMensch's comments, a better way to achieve the desired result would be to use the built in LINQ to SQL associations.
根据 NagaMensch 的评论，实现预期结果的更好方法是使用内置的 LINQ to SQL 关联。
If you go to your entity diagram and click on toolbox, you will see 3 options. Class, Association and Inheritance. We want to use Association.
如果您转到实体图并单击工具箱，您将看到 3 个选项。类、关联和继承。我们想使用Association。
Click on Association and click on the ElectionStatus entity, hold the mouse button down and it will allow you to draw a line to the Election entity.
Once you've drawn the line it will ask you which properties are involved in the association. You want to select the StatusId column from the Election entity, and the StatusId column from the ElectionStatus entity.
单击Association 并单击ElectionStatus 实体，按住鼠标按钮，它将允许您在Election 实体上画一条线。
画好线后，它会询问关联中涉及哪些属性。您希望从 Election 实体中选择 StatusId 列，并从 ElectionStatus 实体中选择 StatusId 列。
Now that you've completed your mapping you will be able to simplify your query greatly because the join will not be necessary. You can just access the election status via a brand new property that LINQ to SQL will have added to the Election entity.
现在您已经完成了映射，您将能够大大简化您的查询，因为连接不是必需的。您可以通过 LINQ to SQL 将添加到 Election 实体的全新属性访问选举状态。
Your code can now look like this:
您的代码现在可以如下所示：
//context has to be moved outside the function
static ExampleDataContext context = new ExampleDataContext();
//Here we can return an IEnumerable of Election now, instead of using the Tuple class
public static IEnumerable<Election> getElections()
{
return from election in context.Elections
select election;
}
static void Main(string[] args)
{
//get the elections
var elections = getElections();
//lets go through the elections
foreach (var election in elections)
{
//here we can access election status via the ElectionStatus property
Console.WriteLine("Election name: {0}; Election status: {1}", election.ElectionName, election.ElectionStatus.StatusDescription);
}
}
You can also find a "how to" on LINQ to SQL associations here.
您还可以在此处找到有关 LINQ to SQL 关联的“操作方法” 。
Note: It's worth mentioning that if you have an FK relationship set up between your tables in the database; LINQ to SQL will automatically pick the relationship up and map the association for you (therefore creating the properties).
注意：值得一提的是，如果您在数据库中的表之间设置了 FK 关系；LINQ to SQL 将自动选择关系并为您映射关联（因此创建属性）。
回答by Daniel Brückner
The problem is, that you are creating a anonymous type, hence there is no way to declare a method with this return type. You have to create a new type that will hold your query result and return this type.
问题是，您正在创建一个匿名类型，因此无法使用此返回类型声明方法。您必须创建一个新类型来保存您的查询结果并返回此类型。
But I suggest not to return the result in a new type but return just a colection of electionobjects and access the election_statusobjects through the relation properties assuming you included them in your model. The data load options cause the query to include the related election status objects in the query result.
但是我建议不要以新类型返回结果，而只返回election对象的集合并election_status通过关系属性访问对象，假设您将它们包含在模型中。数据加载选项导致查询在查询结果中包含相关的选举状态对象。
public IList<election> GetElections()
{
using (ormDataContext context = new ormDataContext(connStr))
{
DataLoadOptions dlo = new DataLoadOptions();
dlo.LoadWith<election>(e => e.election_status);
context.DeferredLoadingEnabled = false;
context.LoadOptions = dlo;
return context.elections.ToList();
}
}
Now you can do the following.
现在您可以执行以下操作。
IList<election> elections = GetElections();
// Access the election status.
Console.WriteLin(elections[0].election_status);
I general LINQ to SQL could just retrieve the related entities on demand - that is called deferred loading.
我一般 LINQ to SQL 可以按需检索相关实体 - 这称为延迟加载。
ormDataContext context = new ormDataContext(connStr));
IList<election> elections = context.elections.ToList();
// This will trigger a query that loads the election
// status of the first election object.
Console.WriteLine(elections[0].election_status);
But this requires you not to close the data context until you finished using the retrieved objects, hence cannot be used with a usingstatement encapsulated in a method.
但这要求您在使用完检索到的对象之前不要关闭数据上下文，因此不能与using封装在方法中的语句一起使用。
回答by Harshal
IEnumerable<object> getRecordsList()
{
using (var dbObj = new OrderEntryDbEntities())
{
return (from orderRec in dbObj.structSTIOrderUpdateTbls
select orderRec).ToList<object>();
}
}
回答by Firma Agnes
maybe it can help :)
也许它可以帮助:)
using (ormDataContext context = new ormDataContext(connStr))
{
var electionInfo = from t1 in context.elections
join t2 in context.election_status
on t1.statusID equals t2.statusID
select new {
t1.column1,
t1.column2,
t1.column3,
t1.column4,
t2.column5,
t2.column6,
t2.column7
};
}
foreach (var ei in electionInfo){
//write what do u want
}
