4

((IEnumerable)source).OfType<T>()和有什么区别source as IEnumerable<T>

对我来说，它们看起来很相似，但事实并非如此！

source是 type IEnumerable<T>，但它被装箱为object.

编辑

这是一些代码：

public class PagedList<T> : List<T>, IPagedList
{
    public PagedList(object source, int index, int pageSize, int totalCount)
    {
        if (source == null)
            throw new ArgumentNullException("The source is null!");


        // as IEnumerable<T> gives me only null

        IEnumerable<T> list = ((IEnumerable)source).OfType<T>();

        if (list == null)
            throw new ArgumentException(String.Format("The source is not of type {0}, the type is {1}", typeof(T).Name, source.GetType().Name));

        PagerInfo = new PagerInfo
                        {
                            TotalCount = totalCount,
                            PageSize = pageSize,
                            PageIndex = index,
                            TotalPages = totalCount / pageSize
                        };

        if (PagerInfo.TotalCount % pageSize > 0)
            PagerInfo.TotalPages++;

        AddRange(list);
    }

    public PagerInfo PagerInfo { get; set; }
}

在另一个地方，我创建了一个 PagedList 的实例

public static object MapToPagedList<TSource, TDestination>(TSource model, int page, int pageSize, int totalCount) where TSource : IEnumerable
{
    var viewModelDestinationType = typeof(TDestination);
    var viewModelDestinationGenericType = viewModelDestinationType.GetGenericArguments().FirstOrDefault();

    var mappedList = MapAndCreateSubList(model, viewModelDestinationGenericType);

    Type listT = typeof(PagedList<>).MakeGenericType(new[] { viewModelDestinationGenericType });
    object list = Activator.CreateInstance(listT, new[] { (object) mappedList,  page, pageSize, totalCount });

    return list;
}

如果有人能告诉我为什么我必须将 mappedList 转换为对象，我将非常感激:)

这里是 MapAndCreateSubList 方法和 Map 委托：

private static List<object> MapAndCreateSubList(IEnumerable model, Type destinationType)
{
    return (from object obj in model select Map(obj, obj.GetType(), destinationType)).ToList();
}

 public static Func<object, Type, Type, object> Map = (a, b, c) =>
{
    throw new InvalidOperationException(
        "The Mapping function must be set on the AutoMapperResult class");
};
4

2 回答 2

12

((IEnumerable)source).OfType<T>()和有什么区别source as IEnumerable<T>对我来说，它们看起来很相似，但它们不是！

你说的对。它们非常不同。

前者的意思是“获取源序列并生成一个全新的、不同的序列，该序列由前一个序列中给定类型的所有元素组成”。

后者的意思是“如果源序列的运行时类型是给定的类型，那么给我一个对该序列的引用，否则给我 null”。

让我用一个例子来说明。假设你有：

IEnumerable<Animal> animals = new Animal[] { giraffe, tiger };
IEnumerable<Tiger> tigers = animals.OfType<Tiger>();

这会给你一个新的、不同的序列，其中包含一只老虎。

IEnumerable<Mammal> mammals = animals as IEnumerable<Mammal>;

那会给你null。动物不是哺乳动物的序列，即使它是恰好是哺乳动物的动物序列。动物的实际运行时类型是“动物数组”，并且动物数组与哺乳动物序列的类型不兼容。为什么不？好吧，假设转换成功，然后你说：

animals[0] = snake;
Mammal mammal = mammals.First();

嘿，你只是把一条蛇放到一个只能包含哺乳动物的变量中！我们不允许这样做，因此转换不起作用。

在 C# 4 中，您可以采用另一种方式。你可以这样做：

IEnumerable<Object> objects = animals as IEnumerable<Object>;

因为可以将一组动物视为一系列对象。你把一条蛇放在那里，一条蛇仍然是一个物体。不过，这只适用于 C# 4。（只有当这两种类型都是引用类型时它才有效。您不能将 int 数组转换为对象序列。）

但要理解的关键是该OfType<T>方法返回一个全新的序列，并且“as”运算符进行运行时类型测试。这些是完全不同的事情。

这是另一种看待它的方式。

tigers = animals.OfType<Tiger>()基本上是一样的

tigers = animals.Where(x=>x is Tiger).Select(x=>(Tiger)x);

也就是说，通过对动物的每个成员进行测试以查看它是否是老虎，从而产生一个新序列。如果是，请投射它。如果不是，则丢弃它。

mammals = animals as IEnumerable<Mammal>另一方面，基本相同

if (animals is IEnumerable<Mammal>)
    mammals = (IEnumerable<Mammal>) animals;
else
    mammals = null;

有道理？

于 2010-09-17T22:35:44.160 回答
3

OfType<T>()只会返回枚举中类型为 T 的类型。所以如果你有这个

object[] myObjects = new object[] { 1, 2, "hi", "there" };

然后打电话

var myStrings = myObjects.OfType<string>();

然后 myStrings 将是一个可枚举的对象，它将跳过 1 和 2，只返回“hi”和“there”。您不能将 myObjects 强制转换为IEnumerable<string>，因为它不是这样。

与此处类似的另一个运算符是Cast<T>()，它将尝试将所有项目转换为类型 T。

   var myStrings = myObjects.Cast<string>();

在这种情况下，一旦开始迭代 myStrings ，您将得到 a InvalidCastException，因为它会尝试将 1 转换为字符串并失败。

于 2010-09-17T21:56:38.533 回答