linq - Linq 中的临时表——有人看到这个问题吗？

Question

在试图解决:

Linq .Contains with large set causes TDS error

我想我偶然发现了一个解决方案，我想看看这是否是解决问题的犹太洁食方式。

(简短摘要)我想对 SQL 中没有(完全或至少很容易)生成的记录 ID 列表进行 linq-join。这是一个很大的列表，并且经常超过 TDS RPC 调用的 2100 项限制。所以我在 SQL 中所做的将它们扔到一个临时表中，然后在我需要它们时加入它。

所以我在 Linq 中做了同样的事情。

在我的 MyDB.dbml 文件中，我添加了:

<Table Name="#temptab" Member="TempTabs">
  <Type Name="TempTab">
    <Column Name="recno" Type="System.Int32" DbType="Int NOT NULL" 
          IsPrimaryKey="true" CanBeNull="false" />
  </Type>
</Table>

打开设计器并关闭它在那里添加了必要的条目，但为了完整起见，我将从 MyDB.desginer.cs 文件中引用:

   [Table(Name="#temptab")]
   public partial class TempTab : INotifyPropertyChanging, INotifyPropertyChanged
   {

           private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);

           private int _recno;

#region Extensibility Method Definitions
partial void OnLoaded();
partial void OnValidate(System.Data.Linq.ChangeAction action);
partial void OnCreated();
partial void OnrecnoChanging(int value);
partial void OnrecnoChanged();
#endregion

           public TempTab()
           {
                   OnCreated();
           }

           [Column(Storage="_recno", DbType="Int NOT NULL", IsPrimaryKey=true)]
           public int recno
           {
                   get
                   {
                           return this._recno;
                   }
                   set
                   {
                           if ((this._recno != value))
                           {
                                   this.OnrecnoChanging(value);
                                   this.SendPropertyChanging();
                                   this._recno = value;
                                   this.SendPropertyChanged("recno");
                                   this.OnrecnoChanged();
                           }
                   }
           }

           public event PropertyChangingEventHandler PropertyChanging;

           public event PropertyChangedEventHandler PropertyChanged;

           protected virtual void SendPropertyChanging()
           {
                   if ((this.PropertyChanging != null))
                   {
                           this.PropertyChanging(this, emptyChangingEventArgs);
                   }
           }

           protected virtual void SendPropertyChanged(String propertyName)
           {
                   if ((this.PropertyChanged != null))
                   {
                           this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
                   }
            }
    }

然后它就变成了在代码中处理一些东西的问题。我通常有的地方:

MyDBDataContext mydb = new MyDBDataContext();

我必须让它与普通的 SqlConnection 共享它的连接，以便我可以使用该连接来创建临时表。在那之后，它似乎非常有用。

string connstring = "Data Source.... etc..";
SqlConnection conn = new SqlConnection(connstring);
conn.Open();

SqlCommand cmd = new SqlCommand("create table #temptab " +
                                "(recno int primary key not null)", conn);
cmd.ExecuteNonQuery();

MyDBDataContext mydb = new MyDBDataContext(conn);
// Now insert some records (1 shown for example)
TempTab tt = new TempTab();
tt.recno = 1;
mydb.TempTabs.InsertOnSubmit(tt);
mydb.SubmitChanges();

并使用它:

// Through normal SqlCommands, etc...
cmd = new SqlCommand("select top 1 * from #temptab", conn);
Object o = cmd.ExecuteScalar();

// Or through Linq
var t = from tx in mydb.TempTabs
        from v in  mydb.v_BigTables
        where tx.recno == v.recno
        select tx;

有没有人认为这种方法有问题作为在 Linq 的连接中使用临时表的通用解决方案？

它很好地解决了我的问题，因为现在我可以在 Linq 中进行简单的连接，而不必使用 .Contains()。

后记 :
我确实遇到的一个问题是在表上混合 Linq 和常规 SqlCommands(一个是读/写，另一个是读/写)可能是危险的。始终使用 SqlCommands 在表上插入，然后使用 Linq 命令读取它效果很好。显然，Linq 缓存了结果——可能有办法绕过它，但它并不明显。

Answer 1

我认为使用临时表解决您的问题没有问题。就混合使用 SqlCommands 和 LINQ 而言，您对危险因素的看法是绝对正确的。使用 DataContext 执行 SQL 语句非常容易，我什至不用担心 SqlCommand:

private string _ConnectionString = "<your connection string>";

public void CreateTempTable()
{
    using (MyDBDataContext dc = new MyDBDataContext(_ConnectionString))
    {
        dc.ExecuteCommand("create table #temptab (recno int primary key not null)");
    }
}

public void DropTempTable()
{
    using (MyDBDataContext dc = new MyDBDataContext(_ConnectionString))
    {
        dc.ExecuteCommand("DROP TABLE #TEMPTAB");
    }
}

public void YourMethod()
{
    CreateTempTable();

    using (MyDBDataContext dc = new MyDBDataContext(_ConnectionString))
    {
        ...
        ... do whatever you want (within reason)
        ...
    }

    DropTempTable();
}