Sintaxis de propagación de JavaScript en C#

spread-syntax

Question

¿Hay alguna implementación en C # como la sintaxis de JavaScript ?

var arr = new []{
"1",
"2"//...
};
Console.WriteLine(...arr);

Answer 1

No hay una opción de propagación. Y hay razones.

1. Las propiedades no son una matriz en C # a menos que use la palabra clave params
2. Las propiedades que usan la palabra clave param tendrían que:
   1. Comparte el mismo tipo
   2. Tener un tipo compartido moldeable como doble para numéricos
   3. Ser de tipo objeto [] (como objeto es el tipo raíz de todo)

Sin embargo, dicho esto, puede obtener una funcionalidad similar con varias características de idioma.

Respondiendo a tu ejemplo:

DO#

var arr = new []{
"1",
"2"//...
};
Console.WriteLine(string.Join(", ", arr));

El enlace que proporciona tiene este ejemplo:

Extensión de 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));

Parámetros en C #, con el mismo tipo

public int Sum(params int[] values)
{
return values.Sum(); // Using linq here shows part of why this doesn''t make sense.
}
var numbers = new int[] {1,2,3};
Console.WriteLine(Sum(numbers));

En C #, con diferentes tipos numéricos, utilizando doble

public int Sum(params double[] values)
{
return values.Sum(); // Using linq here shows part of why this doesn''t make sense.
}
var numbers = new double[] {1.5, 2.0, 3.0}; // Double usually doesn''t have precision issues with small whole numbers
Console.WriteLine(Sum(numbers));

Reflexión En C #, con diferentes tipos numéricos, usando objeto y reflexión, este es probablemente el más cercano a lo que está pidiendo.

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;
}
}
}

Answer 2

no hay una biblioteca pre-construida directa en C # para manejar lo que está integrado en Spread

Para obtener esa funcionalidad en C #, debe reflejar el objeto y obtener los métodos, propiedades o campos mediante sus modificadores de acceso.

Harías algo como:

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

luego itere a través y arroje en su objeto dinámico:

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