小编w12*_*128的帖子

当使用代码首先从数据库方法从现有数据库创建新的实体数据模型时,可以直接指定要包含在模型中的表.可以在Visual Studio向导中选择子集(或所有)表:

在这个例子中,Category和Product类都将与所创建的沿DbContext派生上下文类.如果我以后想要在同一个模型中添加其他表,是否有一种简单的方法来添加它们,即无需自己手动创建类？

例如,最初,我的DbContext课程将包含:

public virtual DbSet<Category> Categories { get; set; }
public virtual DbSet<Product> Products { get; set; }

现在假设我还想要包含Employee表,以便将DbContext类更新为:

public virtual DbSet<Category> Categories { get; set; }
public virtual DbSet<Product> Products { get; set; }
public virtual DbSet<Employee> Employees { get; set; }

VS上下文菜单似乎没有提供此选项,但也许我错过了一些东西.有没有办法恢复向导,以便我可以选择其他表？

一个解决方案是有一个单独的空项目,您只需创建一个新模型,然后复制/粘贴新类,但我很好奇是否有更快的方法.

我有一个包含文件记录的SQL Server 2012表。每条记录都有一varbinary(max)列BlobData，代表存储在文件中的数据–数据大小可以超过1 GB，并且不能放入RAM，因此我不希望它由字节数组支持。我想实现两个流操作：

• 将BlobData一行中的行顺序读取到缓冲区中；
• BlobData使用缓冲区按顺序逐块覆盖行。

使用纯ADO.NET，一种简单的方法是使用SqlDataReader和UPDATE .WRITE()：

// 1. Sequentially read varbinary(max) into a buffer
using (SqlDataReader reader = sqlCommand.ExecuteReader(System.Data.CommandBehavior.SequentialAccess))
{   
    while (reader.Read())
    {
        byte[] buffer = new byte[size];

        while ((count = reader.GetBytes(0, offset, buffer, 0, buffer.Length)) > 0)
        {
            DoStuffWithBuffer(buffer);
            offset += count;
        }
    }
}

// 2. Sequentially overwrite varbinary(max) from a buffer - iterate:
UPDATE [File] SET [BlobData].WRITE(@buffer, @offset, @count)
WHERE [FileID]=@id

据我所知，这些操作过去不在EF的范围内，我最好的选择就是简单地坚持使用ADO.NET。但是，我注意到EF6有一些新方法，例如用MSDNEntityDataReader.GetBytes() …

我知道实施配置模式的一般准则警告不要实现虚拟Dispose().但是,大多数情况下,我们只使用类中的托管资源,因此完整的部署模式似乎有点过分 - 即我们不需要终结器.在这种情况下,Dispose()在基类中使用虚拟是否可以？

考虑这个简单的例子:

abstract class Base : IDisposable
{
    private bool disposed = false;
    public SecureString Password { get; set; } // SecureString implements IDisposable.

    public virtual void Dispose()
    {
        if (disposed)
            return;

        if (Password != null)       
            Password.Dispose();     

        disposed = true;
    }
}

class Sub : Base
{
    private bool disposed = false;
    public NetworkStream NStream { get; set; } // NetworkStream implements IDisposable.

    public override void Dispose()
    {   
        if (disposed)
            return;

        if …

在处理任务时,经验法则似乎是线程池 - 通常由例如调用Task.Run()或Parallel.Invoke() - 使用 - 应该用于相对较短的操作.当处理长时间运行的操作时,我们应该使用该TaskCreationOptions.LongRunning标志 - 据我所知 - 避免堵塞线程池队列,即将工作推送到新创建的线程.

但究竟什么是长期运行？从时间上看,多长时间？在决定是否使用时,除了预期任务持续时间之外还有其他因素LongRunning,例如预期的CPU架构(频率,核心数量......)或将尝试运行的任务数量从程序员的角度来看？

例如,假设我有500个任务要在专用应用程序中处理,每个任务需要10-20秒才能完成.我应该只使用Task.Run启动所有500个任务(例如在循环中),然后等待它们全部,也许是LongRunning,同时保留默认的最大并发级别？然后,如果我设置LongRunning在这种情况下,这将不会创建500个新线程,并且实际上会导致大量开销和更高的内存使用(由于额外的线程被分配)与省略相比LongRunning？这假设在等待这500个任务时不会安排执行新任务.

我猜测设置的决定LongRunning取决于在给定时间间隔内对线程池发出的请求数量,而这LongRunning应该仅用于预期比大多数线程池放置的任务花费更长时间的任务 - 根据定义,最多只占所有任务的一小部分.换句话说,这似乎是一个排队和线程池利用率优化问题,应该通过测试逐个解决,如果有的话.我对么？

我正在尝试迭代通过 a 访问的 astd::vector<X>中包含的a 。与我的预期相反，如果我首先将其存储到副本中与直接迭代它，则行为会有所不同：struct Tstd::optional<T>std::optional<T>

#include <optional>
#include <string>
#include <vector>

// The rest is the same in both implementations    
struct Object
{
    std::string id;
    std::vector<SomeStructType> items;
};

Object readDataFile() { /*....*/ return {}; }
bool dataFileExists() { /*....*/ return true; }

std::optional<Object> getData()
{
    if (!dataFileExists()) {
        return std::nullopt;
    }

    Object obj = readDataFile();
    return obj;
}

int main()
{
    // Implementation 1 - works
    auto items = getData().value().items;
    for (auto const& item …

我正在执行UPDATE .WRITE()语句,并且发现它显然只有在你定义它时才有效:

string sql = "UPDATE [dbo].[Table] SET [Column].WRITE(@data, @offset, @count) WHERE ...";
...
sqlCommand.ExecuteNonQuery();

但是,如果我使用[dbo].[Table].[Column].WRITE(...)or [Table].[Column].WRITE(...),则抛出异常:

Incorrect syntax near 'WRITE'.

Stack trace:
   at System.Data.SqlClient.SqlConnection.OnError(SqlException exception, Boolean breakConnection)
   at System.Data.SqlClient.TdsParser.ThrowExceptionAndWarning(TdsParserStateObject stateObj)
   at System.Data.SqlClient.TdsParser.Run(RunBehavior runBehavior, SqlCommand cmdHandler, SqlDataReader dataStream, BulkCopySimpleResultSet bulkCopyHandler, TdsParserStateObject stateObj)
   at System.Data.SqlClient.SqlCommand.FinishExecuteReader(SqlDataReader ds, RunBehavior runBehavior, String resetOptionsString)
   at System.Data.SqlClient.SqlCommand.RunExecuteReaderTds(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, Boolean async)
   at System.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, String method, DbAsyncResult result)
   at System.Data.SqlClient.SqlCommand.InternalExecuteNonQuery(DbAsyncResult result, String methodName, Boolean sendToPipe)
   at …

当一个类拥有线程和互斥对象时,是否存在任何潜在的危险情况,其中复制/赋值将是危险的,这意味着应该删除复制构造函数和赋值？

考虑以下示例代码:

class A : B
{
    std::thread t;
    std::mutex m;

  public:
    A() : B() {}
    virtual ~A()
    {
        if (t.joinable())
            t.join();
    }

    // Should I delete cctor and assignment operator?

    virtual void Method()
    {
        t = std::thread([this] 
        {
            std::lock_guard<std::mutex> lck(m);
            ... // processing
        });
    }

    // Other methods that lock on mutex m
};

如果我理解正确,创建的线程Method()将不会在外部可见A,这意味着使用默认cctor进行复制不应该有问题,因为整个状态将被复制.我的推理是否正确？

在C#方法中,我执行以下返回多行的SQL查询:

SELECT [Data], [Version] 
FROM [dbo].[Table] 
WHERE [Id]=@uniqueId AND [ReferenceId] IS NULL 
ORDER BY [Version] Asc

然后我迭代结果并调用一个应该更新表的方法:

while (sqlDataReader.Read())
{
    SqlBytes data = sqlDataReader.GetSqlBytes(0);
    SqlInt64 version = sqlDataReader.GetSqlInt64(1);

    UpdateReference(data, version);
}


UpdateReference(data, version)
{
    // do database unrelated stuff with data

    UPDATE [dbo].[Table] 
    SET [dbo].[Table].[ReferenceId]=..., [dbo].[Table].[Data]=...
    WHERE [dbo].[Table].[Id]=@uniqueId AND [dbo].[Table].[Version]=@version
}

有一段时间这个工作正常,但突然(在SELECT ... INNER JOIN同一个表上执行一些查询后)停止了.我在第一个SELECT上创建了一个事务范围(在调用的方法中UpdateReference()):

 using (TransactionScope scope = new TransactionScope())
    SELECT ...
    while (sqlDataReader.Read()) ... UpdateReference();

我得到以下异常:

交易已中止.

如果我删除了事务范围,则在调用UPDATE一段时间后会发生超时异常:

超时已过期.操作完成之前经过的超时时间或服务器没有响应.

但这似乎不是SQL Server的问题.同样奇怪的是,对于某些记录,没有这样的问题 - 它们只发生在某些表记录上使用第一个SELECT时.

这是我到目前为止发现的: …

我想执行一个SELECT查询,后跟一系列UPDATE查询(全部在同一个表上); UPDATE在一个单独的方法中实现,该方法被重复调用.如果其中一个UPDATE查询失败,我希望它们全部失败/回滚 - 所以我想在事务中登记它们.但是,我不确定SqlConnection应该在哪里打开以避免任何问题.我目前的实现如下:

using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();

    // execute a single SELECT here

    using (TransactionScope scope = new TransactionScope())
    {
        for (int i=0; i<...; i++)
        {
            Update(); // UPDATE query
        }

        scope.Complete();
    }
}


Update()
{
    using (SqlConnection connection = new SqlConnection(connectionString))
    {
        connection.Open();

        // execute a single UPDATE here
    }
}

在所有情况下这应该如预期的那样工作吗

可以在SELECT之前打开连接,然后在Update()方法中打开一个新连接吗？由于连接池,相同的连接将同时用于SELECT和UPDATE查询(connectionString是一样的),但只更新查询将在交易入伍,对吧？但是如果使用不同的连接会发生什么Update()？是否所有UPDATE查询仍按预期在事务中登记并以原子方式执行？

如果我理解正确,在关闭第一个连接后(在using执行SELECT 的块之后)创建事务范围仍然有效,但会降低性能,因为连接将被关闭并需要重新打开,对吗？或者实际上是为事务范围创建的新连接,并且每次Update()调用时都会打开和关闭？

我收到一个文件作为byte []数据包流(总大小未提前知道),我需要在收到它之前立即处理它(我无法动态处理) ).收到的文件总大小可以从10 KB到4 GB不等.

• 用于存储所接收数据的一个选项是使用a MemoryStream,即一系列MemoryStream.Write(bufferReceived, 0, count)调用来存储所接收的分组.这很简单,但显然会导致大文件的内存不足异常.
• 另一种选择是使用a FileStream,即FileStream.Write(bufferReceived, 0, count).这样,不会出现内存不足异常,但我不确定的是由于磁盘写入导致的性能不佳(只要仍有大量内存可用,我不想发生) - 我想要尽可能避免磁盘访问,但我不知道如何控制它.

我做了一些测试,大部分时间,似乎在连续10次连续调用MemoryStream.Write()vs 之间几乎没有性能差异FileStream.Write(),但很多似乎取决于缓冲区大小和有问题的数据总量(即写入次数) .显然,MemoryStream尺寸重新分配也是一个因素.

1. 默认情况下使用MemoryStream和FileStream,即写入内存流的组合是否有意义,但是一旦收到的数据总量超过例如500 MB,请将其写入FileStream; 然后,从两个流中读取块以处理接收到的数据(首先处理500 MB MemoryStream,处理它,然后读取FileStream)？

2. 另一种解决方案是使用自定义内存流实现,该实现不需要连续的地址空间用于内部数组分配(即内存流的链接列表); 这样,至少在64位环境中,内存不足异常应该不再是问题.骗局:额外的工作,更多的错误空间.

那么FileStreamvs MemoryStream读/写如何在磁盘访问和内存缓存方面表现出来,即数据大小/性能平衡.我希望只要有足够的RAM可用,FileStream无论如何都会从内存(缓存)内部读/写,虚拟内存将负责其余的工作.但我不知道FileStream在写入磁盘时是否经常显式访问磁盘.

任何帮助,将不胜感激.