C# 允许命名元组的语言

我想知道是否有允许命名元组的语言。Ie：具有不同类型和可配置名称的多个变量的对象

例如：

public-NamedTuple-CalculateStuff（int-arg1，int-arg2）
var结果=计算的重复次数（1,2）；
Console.WriteLine（“速度为：+result.Speed.ToString（））
Console.WriteLine（“距离为：+result.Distance.ToString（））

我可以想象动态如何支持这样一个特性。我通常使用的静态语言（如c#）可以编写字典，但这不是类型安全的，除非所有项都是相同的类型。或者您可以使用元组类型，但这意味着您有固定的成员名称（Var1、Var2等）

您也可以编写一个小型自定义类，但这是我希望避免的情况

我可以想象宏处理语言可以用静态语言为您编写类似的脚本，但我不知道有这样的语言

---

这来自于我的回答。

我不确定您需要它做什么-元组只是一个保存不同类型数据的结构。如果确实需要命名属性，则必须创建自定义类型或动态创建匿名类型

---

我也不知道有哪种静态类型语言会支持这一点，但C当然不支持。

你是说，类似Python的东西？Python（当前版本2.6和3.1）支持它们；-）。但说真的，我不知道有哪种静态类型的语言内置了它们。

在C#中使用结构或类有什么错

---

我不确定这是否正是您要查找的内容，但在Haskell中，您可以拥有具有指定名称和类型的记录：

data Movement = Movement { speed :: Double, distance :: Int } deriving (Show)

main = do
    print $ Movement 3.14 100
    print Movement {distance = 5, speed = 2.1}
    print Movement {speed = 9, distance = -4}

输出：

Movement {speed = 3.14, distance = 100} Movement {speed = 2.1, distance = 5} Movement {speed = 9.0, distance = -4} 运动{速度=3.14，距离=100} 移动{速度=2.1，距离=5} 运动{速度=9.0，距离=-4} 但从技术上讲，它不是一个元组。Haskell确实有元组，但据我所知，它们不能命名

在任何C派生语言中，这实际上也不是一个简单的结构。也许我在问题中遗漏了什么。

在C#中，你有匿名类型；这些类似，但有其自身的局限性：

var result = new { Speed = 12.4, Distance = 8, Caption = "car 1" };

但是，除非使用“示例强制转换”（脆性）、反射或

动态

，否则很难将其作为调用方使用。在这三种食物中，最后一种最能开胃

dynamic result = GetSomething();
Console.WriteLine(result.Speed);
Console.WriteLine(result.Distance);

---

在大多数情况下，只使用常规类是一个更好的主意，但这种方法确实有一些实际用途；例如，看看如何在ASP.NET MVC中使用它们来简单方便地传递配置信息（否则需要字典）。有点像jQuery如何允许将选项作为属性传递给对象。

Eiffel允许命名元组。

我知道

• Python（动态、强类型）
• 埃菲尔（静态，字符串输入）

两者都可以在.net中使用

---

可能是Lisp，你可以用Lisp做任何事情。

老问题，但我认为需要更好的解决方案

您可以通过利用元组类型获得命名参数，但将其包装在自定义命名类型中，该类型将.Item1、.Item2等包装为有意义的属性名称

我也讨厌元组有一些未命名的参数，这些参数使代码无法读取，但不能忽略这样一个事实：它节省了您自己实现IComparable、IStructuralEquatable等的时间，例如，您可以安全地将结构用作字典键

我认为这是一个非常令人愉快的妥协：

public class Velocity : Tuple<double, double, string>
{
    public Velocity(double Speed, double Direction, string Units) : base(Speed, Direction, Units) { }
    public double Speed { get { return this.Item1; } }
    public double Direction { get { return this.Item2; } }
    public string Units { get { return this.Item3; } }
}

您仍然可以从所有奇妙的元组特性中获益，这些特性使您可以将它用作字典中的复杂键，等等

---

唯一的缺点是，如果只计划在单个方法的范围内使用此元组，则必须在该方法的包含类的范围内声明类型。对于大多数应用程序，我不认为这是一个问题。

存在几种这样的语言。这种命名元组的单词是“record”。ML语言家族有这样的记录，以及相应的类型。具体语言包括：SML、OCaml，重要的是，还有F#。此链接介绍了F#中的记录：

谢谢。这是我如何使用你的小费

转盘的动态图像加载器

<div id="owl" class="owl-carousel owl-theme">
    @foreach (var image in Model.Sketches)
    {
        <div class="item" >
            <a href="@image.SketchHref" id="a_@image.SketchNumber" target="_blank" >
                <img id="sketch_@image.SketchNumber" class="lazyOwl" style="border:1px solid #d1c7c7;outline : 0;max-height:350px;max-width:400px;" 
                    title="click for full size" alt="@image.SketchName" data-src="@image.SketchHref" /></a>
                    <div style="text-align:left;height:auto;vertical-align:bottom;padding:2px;font-size:1em;color:#DF3A01;">Sketch @image.SketchNumber of @Model.Sketches.Count()</div>
        </div>
    }
    </div>

@foreach（模型草图中的var图像）
{
Sketch@image.SketchNumber of@Model.Sketch.Count（）
}

对于C#

公共列表草图
{
得到
{
List hrefs=新列表（）；

/* 图像名称与文件夹位置匹配 示例：1234101005_001.Gif将等于“c:\images\1234\10\1005_BLD” */

var sketchFolder=Regex.Replace（一些图片，@“（\d{4}）（\d{2}）（\d{4}）”，@“c:\sketch\$1\$2\$3\$BLD”）；
var sketchHref=Regex.Replace（一些图片，@“（\d{4}）（\d{2}）（\d{4}）”，@“/sketch/$1/$2/$3/\u BLD”）；
int16i=0；
if（System.IO.Directory.Exists（sketchFolder））
{
List gifs=GetGifs（sketchFolder）；
ForEach（委托（字符串gif）
{
字符串s=sketchHref+“/”+gif；
字符串f=sketchFolder+“/”+gif；
if（System.IO.File.Exists（f））
{
草图草图=新草图（++i）.ToString（），gif）；
添加（草图）；
}
else//gif不存在
{
草图草图=新草图（“占位符.png”，（++i.ToString（），gif）；
添加（草图）；
}
});
}
else//文件夹不存在
{
草图草图=新草图（“占位符.png”，（++i.ToString（），”）；
添加（草图）；
}
返回HREF；
}
}
公共课
public class Velocity : Tuple<double, double, string>
{
    public Velocity(double Speed, double Direction, string Units) : base(Speed, Direction, Units) { }
    public double Speed { get { return this.Item1; } }
    public double Direction { get { return this.Item2; } }
    public string Units { get { return this.Item3; } }
}

Tuple<double, double, string> myVelocity = new Tuple<double, double, string>(10, 2.34, "cm/s");
System.Diagnostics.Debug.Print("Speed: " + myVelocity.Item1);
System.Diagnostics.Debug.Print("Direction: " + myVelocity.Item2);
System.Diagnostics.Debug.Print("Units: " + myVelocity.Item3);

Velocity myVelocity2 = new Velocity(10, 2.34, "cm/s");
System.Diagnostics.Debug.Print("Speed: " + myVelocity2.Speed);
System.Diagnostics.Debug.Print("Direction: " + myVelocity2.Direction);
System.Diagnostics.Debug.Print("Units: " + myVelocity2.Units);

<div id="owl" class="owl-carousel owl-theme">
    @foreach (var image in Model.Sketches)
    {
        <div class="item" >
            <a href="@image.SketchHref" id="a_@image.SketchNumber" target="_blank" >
                <img id="sketch_@image.SketchNumber" class="lazyOwl" style="border:1px solid #d1c7c7;outline : 0;max-height:350px;max-width:400px;" 
                    title="click for full size" alt="@image.SketchName" data-src="@image.SketchHref" /></a>
                    <div style="text-align:left;height:auto;vertical-align:bottom;padding:2px;font-size:1em;color:#DF3A01;">Sketch @image.SketchNumber of @Model.Sketches.Count()</div>
        </div>
    }
    </div>

    public List<Sketches> Sketches 
    {
        get
        {
            List<Sketches> hrefs = new List<Sketches>();

            var sketchFolder = Regex.Replace(some_image, @"(\d{4})(\d{2})(\d{4})", @"c:\Sketches\$1\$2\$3\_BLD");
            var sketchHref = Regex.Replace(some_image, @"(\d{4})(\d{2})(\d{4})", @"/sketches/$1/$2/$3/_BLD");
            Int16 i = 0;

            if (System.IO.Directory.Exists(sketchFolder))
            {
                List<string> gifs = GetGifs(sketchFolder);

                gifs.ForEach(delegate(String gif)
                {
                    string s = sketchHref + "/" + gif;
                    string f = sketchFolder + "/" + gif;

                    if (System.IO.File.Exists(f))
                    {
                        Sketches sketch = new Sketches(s, (++i).ToString(), gif);
                        hrefs.Add(sketch);
                    }
                    else // gif does not exist
                    {
                        Sketches sketch = new Sketches("placeholder.png", (++i).ToString(), gif);
                        hrefs.Add(sketch);
                    }
                });
            }
            else // folder does not exist
            {
                Sketches sketch = new Sketches("placeholder.png", (++i).ToString(), "");
                hrefs.Add(sketch);
            }
            return hrefs;
        }
    }

public class Sketches : Tuple<string, string, string>
{
    public Sketches(string SketchHref, string SketchNumber, string SketchName) : base(SketchHref, SketchNumber, SketchName) { }
    public string SketchHref { get { return this.Item1; } }
    public string SketchNumber { get { return this.Item2; } }
    public string SketchName { get { return this.Item3; } }
}

let interval = (start: 0, end: 10)
let start = interval.start

(double speed, int distance) CalculateStuff(int arg1, int arg2)

var result = CalculateStuff(1,2);

Console.WriteLine("Speed is: " + result.speed.ToString())
Console.WriteLine("Distance is: " + result.distance.ToString())