C# LINQ变换函数

我问了一个奇怪的问题，linq中有转换函数吗。我的意思是，如果我有

List

或

List

，我想更改索引x处的元素或满足Where条件的任何元素。

如果您希望有条件地将一个Foo投影到另一个Foo（保持其他Foo不变），您可以执行以下操作：

IEnumerable<Foo> foos = ...

var transformed = foos.Select(foo => myCondition(foo) ? transform(foo) : foo);

请注意，这两个都返回新序列-LINQ通常不用于修改现有集合。当然，您可以将结果具体化为一个集合，必要时覆盖现有变量

// assuming the transform is from Foo -> Foo
foos = foos.Select(foo => transform(foo)).ToList();

因为您特别提到了列表，所以除了第一个查询之外，还有另一个非LINQ立即执行选项-方法：

listfoos=。。。
//隐式列表，假设转换来自Foo->Foo
var transformed=foos.ConvertAll
（foo=>myCondition（foo）？transform（foo）：foo；

---

编辑：听起来像是在寻找“ReplaceWhere”方法——据我所知，没有直接的框架方法可以替换基于谓词的列表元素。不过，自己写一本很容易：

/// <summary>
/// Replaces items in a list that match the specified predicate,
/// based on the specified selector. 
/// </summary>
public static void ReplaceWhere<T>(this IList<T> list,
                                   Func<T, bool> predicate,
                                   Func<T, T> selector)
{
    // null-checks here.

    for (int i = 0; i < list.Count; i++)
    {
        T item = list[i];

        if (predicate(item))
            list[i] = selector(item);
    }
}

//
///替换列表中与指定谓词匹配的项，
///基于指定的选择器。
/// 
public static void ReplaceWhere（此IList列表，
Func谓词，
Func选择器）
{
//此处为空检查。
for（int i=0；i

用法：

List<int> myList = ...
myList.ReplaceWhere(i => i > 0, i => i * i);

List myList=。。。
ReplaceWhere（i=>i>0，i=>i*i）；

您当然可以编写一个转换函数：

// allows you to transform every element
public static List<T> TransformAll<T>(this List<T> list,
                                      Func<T, T> converter)
{
    for (int i = 0; i < list.Count; i++)
    {
        list[i] = converter(list[i]);
    }
    return list;
}

// allows you to transform every element based on its index
public static List<T> TransformAll<T>(this List<T> list,
                                      Func<T, int, T> converter)
{
    for (int i = 0; i < list.Count; i++)
    {
        list[i] = converter(list[i], i);
    }
    return list;
}

// allows you to transform chosen elements
public static List<T> TransformWhere<T>(this List<T> list,
                                        Func<T, bool> predicate,
                                        Func<T, T> converter)
{
    for (int i = 0; i < list.Count; i++)
    {
        T item = list[i];
        if (predicate(item))
            list[i] = converter(item);
    }
    return list;
}

// allows you to transform chosen elements based on its index
public static List<T> TransformWhere<T>(this List<T> list,
                                        Func<T, int, bool> predicate,
                                        Func<T, int, T> converter)
{
    for (int i = 0; i < list.Count; i++)
    {
        T item = list[i];
        if (predicate(item, i))
            list[i] = converter(item, i);
    }
    return list;
}

//允许您转换每个元素
公共静态列表TransformAll（此列表，
Func转换器）
{
for（int i=0；i

---

请注意，我让所有函数返回传入的列表，以便您可以流畅地使用它们，如

list.TransformAll（x=>x+2）.Sum（）

您能更具体一点吗？使用LINQ，您可以将数据过滤、分组、排序、项目等，并将其转换为所有新类型的所有新序列。你具体想做什么？你的问题标题大致是投影运算符的定义。所有特殊字符都已在原始帖子中丢失：）。不管怎样，我在考虑转换，比如在整数列表的所有项中添加2。或者说，在foos列表中转换的foos实例@Jani，投影不是转换我想我知道投影，但这也是唯一会改变原始列表中元素的投影而不是转换。@Mubashir Khan:我的编辑是否符合您的要求？如果您不关心谓词，请传入

foo=>true

，或者使用一个

TransformAll

方法，如Gabe的答案中的方法。+1 a

replace其中

扩展始终能够找到我所从事的每个项目的方法。现在我正在考虑它，也许

Update

比

Transform

更好，因为数据的更改是明确的。

List<int> myList = ...
myList.ReplaceWhere(i => i > 0, i => i * i);

// allows you to transform every element
public static List<T> TransformAll<T>(this List<T> list,
                                      Func<T, T> converter)
{
    for (int i = 0; i < list.Count; i++)
    {
        list[i] = converter(list[i]);
    }
    return list;
}

// allows you to transform every element based on its index
public static List<T> TransformAll<T>(this List<T> list,
                                      Func<T, int, T> converter)
{
    for (int i = 0; i < list.Count; i++)
    {
        list[i] = converter(list[i], i);
    }
    return list;
}

// allows you to transform chosen elements
public static List<T> TransformWhere<T>(this List<T> list,
                                        Func<T, bool> predicate,
                                        Func<T, T> converter)
{
    for (int i = 0; i < list.Count; i++)
    {
        T item = list[i];
        if (predicate(item))
            list[i] = converter(item);
    }
    return list;
}

// allows you to transform chosen elements based on its index
public static List<T> TransformWhere<T>(this List<T> list,
                                        Func<T, int, bool> predicate,
                                        Func<T, int, T> converter)
{
    for (int i = 0; i < list.Count; i++)
    {
        T item = list[i];
        if (predicate(item, i))
            list[i] = converter(item, i);
    }
    return list;
}