Пары ключевых значений в парах C#

забавно, я только что создал (минут назад) метод, который позволяет это сделать, используя анонимные типы и отражение :

MyMethod(new { Key1 = "value1", Key2 = "value2" });


public void MyMethod(object keyValuePairs)
{
    var dic = DictionaryFromAnonymousObject(keyValuePairs);
    // Do something with the dictionary
}

public static IDictionary<string, string> DictionaryFromAnonymousObject(object o)
{
    IDictionary<string, string> dic = new Dictionary<string, string>();
    var properties = o.GetType().GetProperties();
    foreach (PropertyInfo prop in properties)
    {
        dic.Add(prop.Name, prop.GetValue(o, null) as string);
    }
    return dic;
}

немного хак, но вы могли бы иметь свой Message класс реализации IEnumerable интерфейс и дать ему Add метод. Затем вы сможете использовать синтаксис инициализатора коллекции:

Agent.SendMessage
(
    new Message(MessageTypes.SomethingHappened) {{ "foo", 42 }, { "bar", 123 }}
);

// ...

public class Message : IEnumerable
{
    private Dictionary<string, object> _map = new Dictionary<string, object>();

    public Message(MessageTypes mt)
    {
        // ...
    }

    public void Add(string key, object value)
    {
        _map.Add(key, value);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return ((IEnumerable)_map).GetEnumerator();
        // or throw a NotImplementedException if you prefer
    }
}

использовать словарь ...

void Main()
{
    var dic = new Dictionary<string, object>();
    dic.Add( "Key1", 1 );
    dic.Add( "Key2", 2 );   

    MyFunction( dic ).Dump();
}

public static object MyFunction( IDictionary dic )
{
   return dic["Key1"];
}

вот еще один:

static void Main(string[] args)
{
    // http://msdn.microsoft.com/en-us/library/bb531208.aspx
    MyMethod(new Dictionary<string,string>()
    {
        {"key1","value1"},
        {"key2","value2"}
    });
}

static void MyMethod(Dictionary<string, string> dictionary)
{
    foreach (string key in dictionary.Keys)
    {
        Console.WriteLine("{0} - {1}", key, dictionary[key]);
    }
}

некоторые сведения об инициализации словаря можно найти здесь.

С помощью словаря:

myFunction(new Dictionary<string, object>(){
  {"Key", value}, 
  {"Key2", value}});

которых прямо вперед, вам нужен только один new Dictionary<K, V>, а не для каждого аргумента. Тривиально получить ключи и значения.

или с анонимным типом:

myFunction(new {
  Key = value, 
  Key2 = value});

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

foreach (PropertyInfo property in arg.GetType().GetProperties())
{
  key = property.Name;
  value = property.GetValue(arg, null);
}

(прямо из моей головы, вероятно, некоторые ошибки...)

с динамическим типом В C# 4.0:

public class MyClass
{
    // Could use another generic type if preferred
    private readonly Dictionary<string, dynamic> _dictionary = new Dictionary<string, dynamic>();

    public void MyFunction(params dynamic[] kvps)
    {
        foreach (dynamic kvp in kvps)
            _dictionary.Add(kvp.Key, kvp.Value);
    }
}

вызов с помощью:

MyFunction(new {Key = "Key1", Value = "Value1"}, new {Key = "Key2", Value = "Value2"});

начиная с C# 7.0, вы можете использовать кортежи значений. C# 7.0 не только вводит новый тип, но и новый упрощенный синтаксис для кортежей.

public static void MyFunction(params (string Key, object Value)[] pairs)
{
    foreach (var pair in pairs) {
        Console.WriteLine($"{pair.Key} = {pair.Value}");
    }
}

также можно деконструировать кортеж, как это

        var (key, value) = pair;
        Console.WriteLine($"{key} = {value}");

это извлекает элементы кортежа в двух отдельных переменных key и value.

теперь вы можете называть MyFunction С различным количеством аргументов легко:

MyFunction(("a", 1), ("b", 2), ("c", 3));

посмотреть: новые функции в C# 7.0

Вы можете сделать это:

TestNamedMethod(DateField => DateTime.Now, IdField => 3);

здесь DateField и IdField должны быть идентификаторами "string".

на TestNameMethod:

public static string TestNameMethod(params Func<object, object>[] args)
{
    var name = (args[0].Method.GetParameters()[0]).Name;
    var val = args[0].Invoke(null);
    var name2 = (args[1].Method.GetParameters()[0]).Name;
    var val2 = args[1].Invoke(null);
    Console.WriteLine("{0} : {1}, {2} : {3}", name, val, name2, val2);
}

производительность на 5% быстрее, чем при использовании словаря. Недостаток: вы не можете использовать переменную в качестве ключа.

Вы можете использовать кортежи для достижения чего-то похожего на @Bryan Watts Pairing.Of без дополнительных класса:

public static void MyFunction(params Tuple<string, int>[] pairs)
{
}

MyFunction(Tuple.Create("foo", 1), Tuple.Create("bar", 2));

вы также можете ссылаться на пакетов NuGet "valuetuple", который позволяет делать следующее:

public static void MyFunction(params ValueTuple<string, object>[] pairs)
{
    var pair = pairs[1];
    var stringValue = pair.item1;
    var objectValue = pair.item2;
}

затем вы можете вызвать метод такой:

MyFunction(("string",object),("string", object));