Kann ein Dapper DynamicParameters-Objekt wie ein Parameterwörterbuch aufgezählt werden?

Question

Ich weiß, dass ich ein ParameterDirection mit Dapper.DynamicParameters verwenden:

var parameters = new DynamicParameters(); 
parameters.Add("iparam", 42); 
parameters.Add("oparam", null, DbType.Int32, ParameterDirection.Output); 
connection.Execute(sql, parameters); 

Aber kann ich so tun, wenn eine Dictionary<string, object> mit?

var parameters = new Dictionary<string, object>(); 
parameters.Add("iparam", 42); 
parameters.Add("oparam", /* ??? */); 
connection.Execute(sql, parameters); 

Alternativ, wie kann ich iterieren einem DynamicParameters, um die Parameternamen und Werte zu erhalten?

Originaltitel:

Kann ein Dapper Parameter mit Parameterdirection hinzugefügt werden, um einen Wörterbuch verwenden?

Answer 1

Es scheint ein Fehler in Dapper zu sein. Dies wird bestätigt, um im neuesten NuGet-Paket zu arbeiten:

foreach (var paramName in parameters.ParameterNames) 
{ 
    var value = ((SqlMapper.IParameterLookup)parameters)[paramName]; 
} 

Allerdings ist es ein bisschen ausführlich. unter Verwendung der lokal Dapper Quelle (kein NuGet Paket), konnte ich ohne Fehler diesen Code auszuführen (Wie des Schreibens, das commit b77e53):

foreach (var paramName in parameters.ParameterNames) 
{ 
    var value = parameters.Get<dynamic>(paramName); 
} 

Nach Charles Burns' comment, es immer noch eine Ausnahme auslöst, die mich führt zu glauben, dass der Patch es noch nicht in NuGet geschafft hat. Das Festschreiben, das Get<dynamic> repariert, ist here

Answer 2

Das Objekt DynamicParameters kann mehrere Abschnitte für jedes Mal enthalten, das es angefügt wurde. Es ist also nicht nötig, durch ParameterNames (es wird leer sein) wie in der obigen Antwort zu iterieren.

public static Dictionary<string, object> ToParametersDictionary(this DynamicParameters dynamicParams) 
{ 
    var argsDictionary = new Dictionary<String, Object>(); 
    var iLookup = (SqlMapper.IParameterLookup) dynamicParams; 
    //if (dynamicParams.ParameterNames.Any()) 
    //{ 
     // read the parameters added via dynamicParams.Add("NAME", value) 
     foreach (var paramName in dynamicParams.ParameterNames) 
     { 
      var value = iLookup[paramName]; 
      argsDictionary.Add(paramName, value); 
     } 
    //} 
    //else 
    //{ 
     // read the "templates" field containing dynamic parameters section added 
     // via dynamicParams.Add(new {PARAM_1 = value1, PARAM_2 = value2}); 
     var templates = dynamicParams.GetType().GetField("templates", BindingFlags.NonPublic | BindingFlags.Instance); 
     if (templates != null) 
     { 
      var list = templates.GetValue(dynamicParams) as List<Object>; 
      if (list != null) 
      { 
       // add properties of each dynamic parameters section 
       foreach (var objProps in list.Select(obj => obj.GetPropertyValuePairs().ToList())) 
       { 
        objProps.ForEach(p => argsDictionary.Add(p.Key, p.Value)); 
       } 
      } 
     } 
    } 
    return argsDictionary; 
} 

und GetPropertyValuePairs(..) ist

public static Dictionary<string, object> GetPropertyValuePairs(this object obj, String[] hidden = null) 
{ 
    var type = obj.GetType(); 
    var pairs = hidden == null 
     ? type.GetProperties() 
      .DistinctBy(propertyInfo => propertyInfo.Name) 
      .ToDictionary(
       propertyInfo => propertyInfo.Name, 
       propertyInfo => propertyInfo.GetValue(obj, null)) 
     : type.GetProperties() 
      .Where(it => !hidden.Contains(it.Name)) 
      .DistinctBy(propertyInfo => propertyInfo.Name) 
      .ToDictionary(
       propertyInfo => propertyInfo.Name, 
       propertyInfo => propertyInfo.GetValue(obj, null)); 
    return pairs; 
} 

public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) 
{ 
    var seenKeys = new HashSet<TKey>(); 
    return source.Where(element => seenKeys.Add(keySelector(element))); 
}