C# Linq类型检查3次-是否有更好的形状？

我有一个Linq表达式，它对一个对象列表进行操作，在使用它之前，我需要为其中一个对象属性键入check

例如：

IEnumerable<Employee> activeAuditOwners = (

    from objectStateEntry in objectStateEntries
    where ( objectStateEntry.Entity is IAuditEntity ) == true
       && ( objectStateEntry.Entity as IAuditEntity ).Active == true
    select ( objectStateEntry.Entity as IAuditEntity ).Owner

);

IEnumerable activeAuditOwners=(
从objectStateEntries中的objectStateEntries
其中（objectStateEntry.Entity为IAudienty）=true
&&（objectStateEntry.Entity作为IAAuditenty）。Active==true
选择（objectStateEntry.Entity作为IAAuditenty）。所有者
);

我担心的是，我使用了3次类型检查（is，as，as），感觉不太干燥

是否有更好的查询形状可以避免这种情况（无需创建第二个查询）

---

更新：感谢您的精彩回答，我为未来的读者整理了一下示例。

关于类型的

扩展方法：

var data = from a in auditObjectStateEntries.OfType<IAuditEntity>()
           where a.Active
           select a.Owner;

var data=来自auditObjectStateEntries.OfType（）中的
其中a.活动
选择a.所有者；

编辑：

我忽略了.Entity部分，因此正确的查询是：

var data = from e in auditObjectStateEntries.Select(a => a.Entity).OfType<IAuditEntity>()
           where e.Active
           select e.Owner;

var data=来自auditObjectStateEntries中的e。选择（a=>a.Entity）。OfType（）
e.在哪里活动
选择e.所有者；
类型的
扩展方法如何：

var data = from a in auditObjectStateEntries.OfType<IAuditEntity>()
           where a.Active
           select a.Owner;

var data=来自auditObjectStateEntries.OfType（）中的
其中a.活动
选择a.所有者；

编辑：

我忽略了.Entity部分，因此正确的查询是：

var data = from e in auditObjectStateEntries.Select(a => a.Entity).OfType<IAuditEntity>()
           where e.Active
           select e.Owner;

var data=来自auditObjectStateEntries中的e。选择（a=>a.Entity）。OfType（）
e.在哪里活动
选择e.所有者；
是的，您可以使用let表达式：

from auditObjectStateEntry in auditObjectStateEntries
let auditEntity = auditObjectStateEntry.Entity as IAuditEntry
where auditEntity != null
          &&
      auditEntry.Active
select auditEntry

更新：
我忘记了其他回答者建议的类型的
。这绝对是一个更干净的解决方案，因此建议改用这种方法。
是的，您可以使用let表达式：

from auditObjectStateEntry in auditObjectStateEntries
let auditEntity = auditObjectStateEntry.Entity as IAuditEntry
where auditEntity != null
          &&
      auditEntry.Active
select auditEntry

更新：
我忘记了其他回答者建议的类型的
。这肯定是一个更干净的解决方案，因此建议改用这种方法。
一种方法是使用
let
子句：

from auditObjectStateEntry in auditObjectStateEntries
let entity = auditObjectStateEntries.Entity as IAuditEntity
where entity != null
   && entity.Active
select entity.Owner

一种方法是使用
let
子句：

from auditObjectStateEntry in auditObjectStateEntries
let entity = auditObjectStateEntries.Entity as IAuditEntity
where entity != null
   && entity.Active
select entity.Owner

首先，你可以忘记
是
，你不需要它。Per:

相当于：

expression is type ? (type)expression : (type)null

因此，您可以通过使用一次转换尝试来简化代码，例如：

IEnumerable<Employee> activeAuditOwners = (
    from auditObjectStateEntry in auditObjectStateEntries
    let entity = auditObjectStateEntry.Entity as IAuditEntry
    where entity != null && auditEntry.Active
    select auditEntry.Owner
);

IEnumerable activeAuditOwners=(
从auditObjectStateEntries中的auditObjectStateEntries
让entity=auditObjectStateEntry.entity作为IAAuditEntry
其中实体！=null&&auditEntry.Active
选择auditEntry.Owner
);
首先，你可以忘记
是
，你不需要它。Per:

相当于：

expression is type ? (type)expression : (type)null

因此，您可以通过使用一次转换尝试来简化代码，例如：

IEnumerable<Employee> activeAuditOwners = (
    from auditObjectStateEntry in auditObjectStateEntries
    let entity = auditObjectStateEntry.Entity as IAuditEntry
    where entity != null && auditEntry.Active
    select auditEntry.Owner
);

IEnumerable activeAuditOwners=(
从auditObjectStateEntries中的auditObjectStateEntries
让entity=auditObjectStateEntry.entity作为IAAuditEntry
其中实体！=null&&auditEntry.Active
选择auditEntry.Owner
);
这里有一些很好的解决方案，但我会使用类型如下的
：

IEnumerable<Employee> activeAuditOwners = objectStateEntries
  .Select(s => s.Entity)
  .OfType<IAuditEntry>()
  ,Where(e => e.Active)
  .Select(e => e.Owner);

IEnumerable activeAuditOwners=objectStateEntries
.选择（s=>s.Entity）
第（）类
，其中（e=>e.Active）
.选择（e=>e.Owner）；
这里有一些很好的解决方案，但我会使用类型如下的
：

IEnumerable<Employee> activeAuditOwners = objectStateEntries
  .Select(s => s.Entity)
  .OfType<IAuditEntry>()
  ,Where(e => e.Active)
  .Select(e => e.Owner);

IEnumerable activeAuditOwners=objectStateEntries
.选择（s=>s.Entity）
第（）类
，其中（e=>e.Active）
.选择（e=>e.Owner）；
对不起，Ladislav，我的示例有误导性-我已经更新了它。我不知道objectStateEntry.Entity的类型是什么-初始集合不是问题所在。他想在
Entity
属性上进行筛选，而不是集合本身。啊，是的，实际上类型更好。有一秒钟我忘了。绝对比我的建议更干净+1@svick：是的，我忽略了它，但这并不意味着不能使用类型为
的
。我在答案中添加了正确的查询。对不起，Ladislav，我的示例有误导性-我已经更新了它。我不知道objectStateEntry.Entity的类型是什么-初始集合不是问题所在。他想在
Entity
属性上进行筛选，而不是集合本身。啊，是的，实际上类型更好。有一秒钟我忘了。绝对比我的建议更干净+1@svick：是的，我忽略了它，但这并不意味着不能使用类型为
的
。我在答案中添加了正确的查询。我不明白，您不需要将
作为
，所以让我们使用它？哦，对不起。。。不需要使用is。我不明白，您不需要将
作为
，所以让我们使用它？哦，对不起。。。不需要使用的是。