对于我开发的一些应用程序(后来渐渐忘记了)，我一直在编写纯SQL，主要用于MySQL。虽然我在python中使用过orm，比如SQLAlchemy，但我并没有坚持使用它们太久。通常是文档或复杂性(从我的角度来看)阻碍了我。

我是这样认为的:为了可移植性，使用ORM，如果只使用一种类型的数据库，则使用纯SQL。在开发需要数据库支持的应用程序时，我真的在寻找关于何时使用ORM或SQL的建议。

考虑到这一点，使用轻量级包装器来处理数据库不一致要比使用ORM好得多。

我刚刚开始使用EF代码，所以我在这个主题完全是一个初学者。

我想创建团队和比赛之间的关系:

1场比赛= 2支队伍(主队，客队)和结果。

我认为创建这样一个模型很容易，所以我开始编码:

public class Team
{
    [Key]
    public int TeamId { get; set;} 
    public string Name { get; set; }

    public virtual ICollection<Match> Matches { get; set; }
}


public class Match
{
    [Key]
    public int MatchId { get; set; }

    [ForeignKey("HomeTeam"), Column(Order = 0)]
    public int HomeTeamId { get; set; }
    [ForeignKey("GuestTeam"), Column(Order = 1)]
    public int GuestTeamId { get; set; }

    public float HomePoints { get; set; }
    public float GuestPoints { get; set; }
    public DateTime Date { get; set; }

    public virtual Team HomeTeam { get; set; }
    public virtual Team GuestTeam { get; set; }
}

我得到一个异常:

引用关系将导致不允许的循环引用。[约束名称= Match_GuestTeam]

我如何创建这样一个模型，有2个外键到同一个表?

我试着更新npm，看看它是否能解决我们遇到的一些依赖问题，现在我想降级到其他开发团队正在使用的版本。如何安装旧版本?

我根据关于npm CLI版本的说明更新了npm:

npm的最新版本 npm的最新版本是最新的稳定版本。当你安装Node.js时，npm会自动安装。然而，npm比Node.js更频繁地发布，所以要安装最新的稳定版本的npm，在命令行上运行: NPM安装npm@latest -g

我有两个表，User和Post。一个用户可以有多个帖子，一个帖子只能属于一个用户。

在我的用户模型中，我有一个hasMany关系…

public function post(){
    return $this->hasmany('post');
}

在我的post模型中，我有一个belongsTo关系…

public function user(){
    return $this->belongsTo('user');
}

现在我想使用Eloquent with()连接这两个表，但想要第二个表中的特定列。我知道我可以使用查询生成器，但我不想这样做。

在Post模型中，我写…

public function getAllPosts() {
    return Post::with('user')->get();
}

它运行以下查询…

select * from `posts`
select * from `users` where `users`.`id` in (<1>, <2>)

但我想要的是…

select * from `posts`
select id,username from `users` where `users`.`id` in (<1>, <2>)

当我用…

Post::with('user')->get(array('columns'....));

它只返回第一个表中的列。我想要第二个表中使用with()的特定列。我该怎么做呢?

我正在重写一个使用Node.js的项目。我想继续使用MySQL作为数据库(即使我不介意重写模式)。 我正在寻找一种易于使用、性能合理的ORM，它支持缓存、多对一和多对多关系。 从我能找到的MySQL orm来看，persistencejs和sequelize似乎是最成熟的。 你有这两方面的经验吗?在做决定时，我应该注意哪些相关的利弊?

我发现这些方法背后的概念和意义有点令人困惑，有人能在一个例子中(如果可能的话)向我解释一下has和with is之间的区别吗?

我有一个循环，开头为for I，范围为(0,100)。正常情况下，它可以正常运行，但有时由于网络条件而出现故障。目前，我已经设置它，以便在失败时，它将继续在except子句中(继续到I的下一个数字)。

我是否可以将相同的数字重新分配给i，并再次运行失败的循环迭代?

如何在原则2中设置默认值?

我使用过很多web应用程序，它们都是由后台复杂程度各异的数据库驱动的。通常，有一个ORM层独立于业务和表示逻辑。这使得单元测试业务逻辑相当简单;事情可以在离散的模块中实现，测试所需的任何数据都可以通过对象模拟来伪造。

但是测试ORM和数据库本身总是充满了问题和妥协。

这些年来，我尝试了一些策略，但没有一个能让我完全满意。

Load a test database with known data. Run tests against the ORM and confirm that the right data comes back. The disadvantage here is that your test DB has to keep up with any schema changes in the application database, and might get out of sync. It also relies on artificial data, and may not expose bugs that occur due to stupid user input. Finally, if the test database is small, it won't reveal inefficiencies like a missing index. (OK, that last one isn't really what unit testing should be used for, but it doesn't hurt.) Load a copy of the production database and test against that. The problem here is that you may have no idea what's in the production DB at any given time; your tests may need to be rewritten if data changes over time.

有些人指出，这两种策略都依赖于特定的数据，单元测试应该只测试功能。为此，我看到了一些建议:

使用模拟数据库服务器，只检查ORM是否在响应给定方法调用时发送了正确的查询。

您在测试数据库驱动的应用程序时使用了哪些策略?对你来说最有效的方法是什么?

I was having a discussion with a teammate about locking in .NET. He's a really bright guy with an extensive background in both lower-level and higher-level programming, but his experience with lower level programming far exceeds mine. Anyway, He argued that .NET locking should be avoided on critical systems expected to be under heavy-load if at all possible in order to avoid the admittedly small possibility of a "zombie thread" crashing a system. I routinely use locking and I didn't know what a "zombie thread" was, so I asked. The impression I got from his explanation is that a zombie thread is a thread that has terminated but somehow still holds onto some resources. An example he gave of how a zombie thread could break a system was a thread begins some procedure after locking on some object, and then is at some point terminated before the lock can be released. This situation has the potential to crash the system, because eventually, attempts to execute that method will result in the threads all waiting for access to an object that will never be returned, because the thread that is using the locked object is dead.

I think I got the gist of this, but if I'm off base, please let me know. The concept made sense to me. I wasn't completely convinced that this was a real scenario that could happen in .NET. I've never previously heard of "zombies", but I do recognize that programmers who have worked in depth at lower levels tend to have a deeper understanding of computing fundamentals (like threading). I definitely do see the value in locking, however, and I have seen many world class programmers leverage locking. I also have limited ability to evaluate this for myself because I know that the lock(obj) statement is really just syntactic sugar for:

bool lockWasTaken = false;
var temp = obj;
try { Monitor.Enter(temp, ref lockWasTaken); { body } }
finally { if (lockWasTaken) Monitor.Exit(temp); }

因为班长。进入并监控。出口被标记为extern。似乎可以想象，. net做了某种处理来保护线程不暴露给可能产生这种影响的系统组件，但这纯粹是推测，可能只是基于我以前从未听说过“僵尸线程”这一事实。所以，我希望我能在这里得到一些反馈:

有没有比我在这里解释的更明确的“僵尸线程”定义呢? 僵尸线程会在。net上出现吗?(为什么/为什么不?) 如果适用，我如何在。net中强制创建僵尸线程? 如果适用，我如何在。net中利用锁定而不冒僵尸线程场景的风险?

更新

我在两年多以前问过这个问题。今天发生了这样的事: