c# 容器变换 原创

List<Tuple<int, double, bool>> 变为List<Tuple<int, bool>>集合

如果您有一个List<Tuple<int, double, bool>>并且您想要将其转换为一个List<Tuple<int, bool>>集合，忽略double值，您可以使用LINQ的Select方法来创建一个新的Tuple列表，其中只包含int和bool值。

下面是一个例子：

csharp

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Tuple;  
  
class Program  
{  
    static void Main()  
    {  
        // 假设这是您的原始List<Tuple<int, double, bool>>  
        List<Tuple<int, double, bool>> originalList = new List<Tuple<int, double, bool>>  
        {  
            Tuple.Create(1, 2.0, true),  
            Tuple.Create(3, 4.0, false),  
            Tuple.Create(1, 5.0, true),  
            Tuple.Create(6, 2.0, false)  
        };  
  
        // 使用Select创建一个新的List<Tuple<int, bool>>，只包含int和bool值  
        List<Tuple<int, bool>> newList = originalList.Select(t => Tuple.Create(t.Item1, t.Item3)).ToList();  
  
        // 输出新的List<Tuple<int, bool>>  
        foreach (var tuple in newList)  
        {  
            Console.WriteLine($"Int: {tuple.Item1}, Bool: {tuple.Item2}");  
        }  
    }  
}

在这个例子中，Select方法接收一个lambda表达式，该表达式指定如何从原始Tuple创建一个新的Tuple。在这个lambda表达式中，我们使用t.Item1来获取int值，并使用t.Item3来获取bool值。然后，我们使用ToList()方法将结果转换为一个新的List<Tuple<int, bool>>。

请注意，在输出时我使用了tuple.Item2来引用新的Tuple中的bool值，但实际上在C#的Tuple<T1, T2>中，Item2并不存在，因为我们只创建了一个包含两个元素的Tuple（即Tuple<int, bool>）。因此，在上面的代码中，我使用了tuple.Item2作为一个示例，但在实际的代码中，您应该使用tuple.Item2（在C# 7.0及更高版本中，您也可以使用命名元素和模式匹配来使代码更具可读性）。在这个特定的例子中，您应该使用tuple.Item2来引用bool值，因为Tuple.Create(t.Item1, t.Item3)创建了一个Tuple<int, bool>。

c# Tuble<int,double,int> 去除int,double,int三个同时相同的元素

在 C# 中，Tuple<T1, T2, T3> 是一个固定大小的、不可变的值集合，它并不直接支持像列表（List）或集合（Set）那样的去重操作，因为 Tuple 主要是用来将多个值打包成一个单一的对象，而不是用来存储和操作大量数据的集合。

然而，如果你有一个包含 Tuple<int, double, int> 的集合（比如 List<Tuple<int, double, int>>），并且你想要去除那些三个元素都相同的 Tuple，你可以通过一些LINQ查询来实现这个目的。

下面是一个示例，展示了如何从一个 List<Tuple<int, double, int>> 中去除那些三个元素都相同的 Tuple：

csharp

using System;  
using System.Collections.Generic;  
using System.Linq;  
  
class Program  
{  
    static void Main()  
    {  
        // 示例数据  
        List<Tuple<int, double, int>> tuples = new List<Tuple<int, double, int>>  
        {  
            Tuple.Create(1, 2.0, 3),  
            Tuple.Create(4, 5.0, 6),  
            Tuple.Create(1, 2.0, 3), // 这个应与第一个重复  
            Tuple.Create(7, 8.0, 9),  
            Tuple.Create(4, 5.0, 6)  // 这个应与第二个重复  
        };  
  
        // 使用LINQ去除重复的Tuple  
        var uniqueTuples = tuples  
            .GroupBy(t => new { t.Item1, t.Item2, t.Item3 })  
            .Select(group => group.First())  
            .ToList();  
  
        // 输出结果  
        foreach (var tuple in uniqueTuples)  
        {  
            Console.WriteLine($"({tuple.Item1}, {tuple.Item2}, {tuple.Item3})");  
        }  
    }  
}

这段代码首先使用 GroupBy 方法根据 Tuple 的三个元素进行分组。由于 GroupBy 会将具有相同键的元素组合在一起，因此所有三个元素都相同的 Tuple 会被分在同一组中。然后，使用 Select(group => group.First()) 从每个组中选择第一个元素（实际上，由于我们按所有三个元素分组，所以每个组的所有元素都是相同的）。最后，使用 ToList() 将结果转换回 List<Tuple<int, double, int>>。

注意，由于 Tuple 是不可变的，你无法通过改变 Tuple 自身的属性来去除重复项。相反，我们通过过滤和选择来创建一个新的不包含重复元素的集合。

List<Tuple<double, double, double,int>> uniqueTuples 遍历uniqueTuples 的过程中修改int 的值

在C#中，遍历并修改List<Tuple<double, double, double, int>>中元组的int值是可以实现的。以下是一个示例代码，展示了如何遍历列表并修改每个元组中int值的方法：

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // 创建一个示例的 uniqueTuples 列表
        var uniqueTuples = new List<Tuple<double, double, double, int>>
        {
            Tuple.Create(1.0, 2.0, 3.0, 10),
            Tuple.Create(4.0, 5.0, 6.0, 20),
            Tuple.Create(7.0, 8.0, 9.0, 30)
        };

        // 遍历列表并修改int值
        for (int i = 0; i < uniqueTuples.Count; i++)
        {
            var tuple = uniqueTuples[i];
            // 修改第四个元素（int值）
            uniqueTuples[i] = new Tuple<double, double, double, int>(tuple.Item1, tuple.Item2, tuple.Item3, tuple.Item4 + 5);
        }

        // 打印修改后的列表
        foreach (var tuple in uniqueTuples)
        {
            Console.WriteLine($"({tuple.Item1}, {tuple.Item2}, {tuple.Item3}, {tuple.Item4})");
        }
    }
}

在这个示例中，uniqueTuples 是一个包含四个元组的列表。在遍历过程中，使用索引访问每个元组，然后创建一个新的元组来替换原来的元组，同时修改第四个元素（int值）。

List<Tuple<double, double, double, double>> uniqueTuples 按照第四个doule 从大到小排序

在C#中，要对List<Tuple<double, double, double, double>>按照第四个double值从大到小进行排序，可以使用LINQ（Language Integrated Query）来实现。以下是一个示例代码，展示了如何进行排序：

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        // 创建一个示例的 uniqueTuples 列表
        var uniqueTuples = new List<Tuple<double, double, double, double>>
        {
            Tuple.Create(1.0, 2.0, 3.0, 10.0),
            Tuple.Create(4.0, 5.0, 6.0, 20.0),
            Tuple.Create(7.0, 8.0, 9.0, 5.0)
        };

        // 按照第四个 double 值从大到小排序
        var sortedTuples = uniqueTuples.OrderByDescending(tuple => tuple.Item4).ToList();

        // 打印排序后的列表
        foreach (var tuple in sortedTuples)
        {
            Console.WriteLine($"({tuple.Item1}, {tuple.Item2}, {tuple.Item3}, {tuple.Item4})");
        }
    }
}

在这个示例中，我们首先创建了一个uniqueTuples列表，其中包含三个元组。然后使用LINQ的OrderByDescending方法，按照元组的第四个double值（即tuple.Item4）从大到小排序。最后，将排序后的结果存储在sortedTuples列表中，并遍历打印每个元组的值。

运行上述代码，输出将会按照第四个double值从大到小的顺序显示元组：

(4, 5, 6, 20)
(1, 2, 3, 10)
(7, 8, 9, 5)

这样，你就能够根据元组中第四个double值的大小对列表进行排序了。

List<Tuple<double, double, Vector3>> edges;struct vector{double x;double y;double z;}edges计算x = 10，y=20，z=30的集合

在C#中，似乎您使用了Vector3和Tuple来表示边(edges)，同时提到了一个自定义的结构体Vector。如果您想从edges列表中找出满足条件的元素（即Vector3中的x=10，y=20，z=30），可以使用LINQ查询来实现。下面是一种可能的实现方法：

首先，假设您的Vector结构体定义如下：

public struct Vector
{
    public double x;
    public double y;
    public double z;
}

然后，您的Vector3可能类似于Unity中的Vector3：

using UnityEngine;

// 使用Unity中的Vector3表示
List<Tuple<double, double, Vector3>> edges;

接下来，您可以使用LINQ查询来筛选出符合条件的元素：

using System;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;

class Program
{
    static void Main()
    {
        // 假设有一个包含边信息的列表 edges
        var edges = new List<Tuple<double, double, Vector3>>
        {
            Tuple.Create(1.0, 2.0, new Vector3(10, 20, 30)),
            Tuple.Create(3.0, 4.0, new Vector3(15, 25, 35)),
            Tuple.Create(5.0, 6.0, new Vector3(10, 20, 30)),
            Tuple.Create(7.0, 8.0, new Vector3(5, 10, 15))
        };

        // 要查找的目标 Vector3
        Vector3 target = new Vector3(10, 20, 30);

        // 使用 LINQ 查询找到符合条件的元素
        var matchingEdges = edges.Where(tuple => tuple.Item3 == target).ToList();

        // 打印符合条件的边
        foreach (var edge in matchingEdges)
        {
            Console.WriteLine($"({edge.Item1}, {edge.Item2}, ({edge.Item3.x}, {edge.Item3.y}, {edge.Item3.z}))");
        }
    }
}

在这个示例中，我们假设edges是一个包含了Tuple<double, double, Vector3>的列表，其中Vector3表示边的起点和终点。我们使用LINQ的Where方法来筛选出符合条件的元素，条件是元组的第三个元素（Vector3）等于目标Vector3（10, 20, 30）。

运行上述代码，会输出所有满足条件的边：

(1, 2, (10, 20, 30))
(5, 6, (10, 20, 30))

这样，您就可以根据需要找出edges列表中所有满足条件的元素了。

其中tuple.Item3可以通过x，y，z比较吗

如果您希望在LINQ查询中直接比较Tuple中的Vector3的各个成员（即x，y，z），可以使用如下方式进行比较。在C#中，Vector3是一个Unity引擎中的结构体，它有x，y和z成员变量，因此您可以通过这些成员变量来进行比较。

下面是如何修改代码以实现这一点：

using System;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;

class Program
{
    static void Main()
    {
        // 假设有一个包含边信息的列表 edges
        var edges = new List<Tuple<double, double, Vector3>>
        {
            Tuple.Create(1.0, 2.0, new Vector3(10, 20, 30)),
            Tuple.Create(3.0, 4.0, new Vector3(15, 25, 35)),
            Tuple.Create(5.0, 6.0, new Vector3(10, 20, 30)),
            Tuple.Create(7.0, 8.0, new Vector3(5, 10, 15))
        };

        // 要查找的目标 Vector3
        Vector3 target = new Vector3(10, 20, 30);

        // 使用 LINQ 查询找到符合条件的元素
        var matchingEdges = edges.Where(tuple => 
                                        tuple.Item3.x == target.x &&
                                        tuple.Item3.y == target.y &&
                                        tuple.Item3.z == target.z)
                                 .ToList();

        // 打印符合条件的边
        foreach (var edge in matchingEdges)
        {
            Console.WriteLine($"({edge.Item1}, {edge.Item2}, ({edge.Item3.x}, {edge.Item3.y}, {edge.Item3.z}))");
        }
    }
}

在上述代码中，我们修改了LINQ查询的条件部分，使用了tuple.Item3.x，tuple.Item3.y和tuple.Item3.z来分别与目标Vector3的成员变量进行比较。这样就可以确保只有在所有成员变量都相同时才会将该元素包括在内。

运行上述代码，输出仍然是所有满足条件的边：

(1, 2, (10, 20, 30))
(5, 6, (10, 20, 30))

这种方法可以确保您根据Vector3的每个成员进行精确比较，从而找出符合特定条件的元素。

List<List> 合并为List

要将一个List<List>（即列表的列表，其中每个内部列表包含double类型的元素）合并为一个单一的List，你可以使用LINQ的SelectMany方法。SelectMany方法将序列中的每个元素投影到一个序列中，然后将所有这些序列合并成一个序列。

下面是一个示例代码，展示了如何将List<List>合并为一个List：

csharp
using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
static void Main()
{
// 示例数据：一个包含多个double列表的列表
List<List> listOfLists = new List<List>
{
new List { 1.1, 2.2, 3.3 },
new List { 4.4, 5.5 },
new List { 6.6, 7.7, 8.8, 9.9 }
};

    // 使用LINQ的SelectMany方法将多个列表合并为一个列表  
    List<double> mergedList = listOfLists.SelectMany(list => list).ToList();  

    // 输出结果  
    foreach (var item in mergedList)  
    {  
        Console.WriteLine(item);  
    }  
}  

}
在这个例子中，listOfLists是一个List<List>，它包含三个List。我们使用SelectMany方法将这三个内部列表“展平”成一个单一的List，并将其存储在mergedList中。然后，我们遍历mergedList并打印出其中的每个元素。

输出将是：

1.1
2.2
3.3
4.4
5.5
6.6
7.7
8.8
9.9
这显示了所有内部列表的double元素都被合并到了一个单一的列表中。

C# 对List转haset

在C#中，可以使用LINQ来将List转换为HashSet。这里是一个简单的例子：

using System;
using System.Collections.Generic;
using System.Linq;
 
class Program
{
    static void Main()
    {
        List<int> list = new List<int> { 1, 2, 2, 3, 4, 4, 5 };
        HashSet<int> hashSet = new HashSet<int>(list);
 
        foreach (var item in hashSet)
        {
            Console.WriteLine(item);
        }
    }
}

在这个例子中，我们创建了一个包含重复项的List。然后我们使用HashSet的构造函数，传入list来创建一个HashSet。这样就去除了所有的重复项。最后，我们遍历并打印HashSet中的每个元素。