Синтаксис JavaScript распространен в С#

Ответ 1

Нет возможности распространения. И тому есть причины.

1. Свойства не являются массивом в С#, если вы не используете ключевое слово params
2. Свойства, которые используют ключевое слово param, должны либо:
   1. Поделиться одним и тем же типом
   2. Иметь общий разделяемый тип, например double для чисел
   3. Быть объектом типа [] (так как объект является корневым типом всего)

Однако, сказав это, вы можете получить аналогичные функциональные возможности с различными языковыми функциями.

Отвечая на ваш пример:

С#

var arr = new []{
   "1",
   "2"//...
};

Console.WriteLine(string.Join(", ", arr));

Ссылка, которую вы предоставляете, имеет следующий пример:

Распространение JavaScript

function sum(x, y, z) {
  return x + y + z;
}

const numbers = [1, 2, 3];

console.log(sum(...numbers));
// expected output: 6

console.log(sum.apply(null, numbers));

Params В С# с тем же типом

public int Sum(params int[] values)
{
     return values.Sum(); // Using linq here shows part of why this does not make sense.
}

var numbers = new int[] {1,2,3};

Console.WriteLine(Sum(numbers));

В С# с разными числовыми типами, используя двойной

public int Sum(params double[] values)
{
     return values.Sum(); // Using linq here shows part of why this does not make sense.
}

var numbers = new double[] {1.5, 2.0, 3.0}; // Double usually does not have precision issues with small whole numbers

Console.WriteLine(Sum(numbers));

Отражение В С# с различными числовыми типами, использующими объект и отражение, это, вероятно, наиболее близко к тому, что вы просите.

using System;
using System.Reflection;

namespace ReflectionExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var paramSet = new object[] { 1, 2.0, 3L };
            var mi = typeof(Program).GetMethod("Sum", BindingFlags.Public | BindingFlags.Static);
            Console.WriteLine(mi.Invoke(null, paramSet));
        }

        public static int Sum(int x, double y, long z)
        {
            return x + (int)y + (int)z;
        }
    }
}

Ответ 2

в С# нет прямой встроенной библиотеки для обработки того, что встроено в Spread

Чтобы получить эту функциональность в С#, вам нужно отразить объект и получить методы, свойства или поля по их модификаторам доступа.

Вы бы сделали что-то вроде:

var tempMethods = typeof(Program).GetMethods();
var tempFields = typeof(Program).GetFields();
var tempProperties = typeof(Program).GetProperties();

затем выполните итерацию и добавьте их в свой динамический объект:

using System;
using System.Collections.Generic;
using System.Dynamic;

namespace myApp
{
    public class myClass
    {
        public string myProp { get; set; }
        public string myField;
        public string myFunction()
        {
            return "";
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var fields = typeof(myClass).GetFields();
            dynamic EO = new ExpandoObject();
            foreach (int i = 0; i < fields.Length; i++)
            {
                AddProperty(EO, "Language", "lang" + i);
                Console.Write(EO.Language);
            }
        }

        public static void AddProperty(ExpandoObject expando, string propertyName, object propertyValue)
        {
            // ExpandoObject supports IDictionary so we can extend it like this
            var expandoDict = expando as IDictionary<string, object>;
            if (expandoDict.ContainsKey(propertyName))
                expandoDict[propertyName] = propertyValue;
            else
                expandoDict.Add(propertyName, propertyValue);
        }
    }
} 

https://www.oreilly.com/learning/building-c-objects-dynamically

Ответ 3

Один прием, чтобы получить поведение, подобное этому (без отражения), состоит в том, чтобы принять params SomeObject[][] и также определить неявный оператор от SomeObject до SomeObject[]. Теперь вы можете передавать смесь массивов SomeObject и отдельных элементов SomeObject.

public class Item
{
    public string Text { get; }

    public Item (string text)
    {
        this.Text = text;
    }

    public static implicit operator Item[] (Item one) => new[] { one };
}

public class Print
{
    // Accept a params of arrays of items (but also single items because of implicit cast)

    public static void WriteLine(params Item[][] items)
    {
        Console.WriteLine(string.Join(", ", items.SelectMany(x => x)));
    }
}

public class Test
{
    public void Main()
    {
        var array = new[] { new Item("a1"), new Item("a2"), new Item("a3") };
        Print.WriteLine(new Item("one"), /* ... */ array, new Item("two")); 
    }
}