Un oggetto Dapper DynamicParameters può essere enumerato come un dizionario di parametri?

Question

So che posso utilizzare un ParameterDirection con Dapper.DynamicParameters:

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

Ma posso fare in modo che quando si utilizza un Dictionary<string, object>?

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

In alternativa, come posso iterare su una DynamicParameters al fine di ottenere i nomi ei valori dei parametri?

Titolo originale:

Può un parametro Dapper con ParameterDirection essere aggiunti usando un dizionario ?

Answer 1

Sembra un errore in Dapper. Questo è confermato per funzionare nell'ultimo pacchetto NuGet:

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

Tuttavia, è un po 'prolisso. Localmente utilizzando la Dapper sorgente (non un pacchetto NuGet), ero in grado di eseguire questo codice senza errori (come di scrittura che di commit b77e53):

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

Secondo Charles Burns' comment, si getta ancora un'eccezione, che mi porta credere che la patch non sia ancora arrivata a NuGet. Il commit che corregge Get<dynamic> è here

Answer 2

L'oggetto DynamicParameters può contenere diverse sezioni per ogni volta che è stato aggiunto. Quindi non è da enumerare attraverso ParameterNames (sarà vuoto) come nella risposta sopra.

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

e GetPropertyValuePairs(..) è

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