public T ExecuteSingleOrDefault <T>(IDynamicParameters parameters, Enum storedProcedureEnum)
{
using (var sqlConnection = _sqlConnectionFactory.Create())
{
var procedureName = storedProcedureEnum.GetSqlScriptInfo().Name;
return(sqlConnection.QuerySingleOrDefault <T>(procedureName, parameters, commandType: CommandType.StoredProcedure));
}
}
/// <summary>
/// Close the connection
/// </summary>
public void Dispose()
{
if (connection != null && connection.State != ConnectionState.Closed)
{
connection.Close();
}
parameters = null;
}
public static RuntimeDefinedParameterDictionary GetRuntimeParams(this IDynamicParameters cmdlet)
{
if (!_memMap.TryGetValue(cmdlet, out var dict))
{
dict = new RuntimeDefinedParameterDictionary();
_memMap.Add(cmdlet, dict);
}
return(dict);
}
/// <summary>
/// Open the connection
/// </summary>
/// <returns></returns>
internal bool OpenConnection()
{
if (connection.State != ConnectionState.Open)
{
connection.Open();
parameters = parameters ?? new DynamicParameters();
}
return(true);
}
public IEnumerable <TFirst> Execute <TFirst, TSecond>(IDynamicParameters parameters, Enum storedProcedureEnum, bool oneToMany = false, string splitOn = "Id")
{
Func <TFirst, TSecond, TFirst> map = null;
if (oneToMany)
{
var rootObjects = new Dictionary <int, TFirst>();
map = (first, second) =>
{
TFirst firstEntry;
if (!rootObjects.TryGetValue(first.GetHashCode(), out firstEntry))
{
firstEntry = first;
rootObjects.Add(firstEntry.GetHashCode(), firstEntry);
}
var collectionPropertyInfo = firstEntry.GetType().GetProperties()
.Single(x => x.PropertyType.IsAssignableFrom(typeof(ICollection <TSecond>)));
var collection = (ICollection <TSecond>)collectionPropertyInfo.GetValue(firstEntry);
collection.Add(second);
return(firstEntry);
};
}
else
{
map = (first, second) =>
{
var typeOfSecond = typeof(TSecond);
var propertyOfSecondType = first.GetType().GetProperties().Single(x => x.PropertyType == typeOfSecond);
propertyOfSecondType.SetValue(first, second);
return(first);
};
}
using (var sqlConnection = _sqlConnectionFactory.Create())
{
var procedureName = storedProcedureEnum.GetSqlScriptInfo().Name;
return(sqlConnection.Query(procedureName, map, parameters, commandType: CommandType.StoredProcedure, splitOn: splitOn).Distinct());
}
}
public static RuntimeDefinedParameter AddRuntimeParam(this IDynamicParameters cmdlet, Type valueType, string paramName, ParameterAttribute paramAttribute, params Attribute[] extraAddtributes)
{
var attrCollection = new Collection <Attribute>()
{
paramAttribute ?? new ParameterAttribute()
};
if (extraAddtributes != null)
{
foreach (var extraParam in extraAddtributes)
{
attrCollection.Add(extraParam);
}
}
var definedParam = new RuntimeDefinedParameter(paramName, valueType, attrCollection);
var runtimeParams = GetRuntimeParams(cmdlet);
runtimeParams.Add(paramName, definedParam);
return(definedParam);
}
public static RuntimeDefinedParameter AddRuntimeParam <TValue>(this IDynamicParameters cmdlet, string paramName, ParameterAttribute paramAttribute, params Attribute[] extraAddtributes)
{
return(AddRuntimeParam(cmdlet, typeof(TValue), paramName, paramAttribute, extraAddtributes));
}
public static RuntimeDefinedParameter AddRuntimeParamWithValidateSet <TValue>(this IDynamicParameters cmdlet, string paramName, string[] validSets, ParameterAttribute paramAttribute = null, Attribute[] extraAddtributes = null)
{
var attrs = new List <Attribute>()
{
new ValidateSetAttribute(validSets)
};
if (extraAddtributes != null)
{
attrs.AddRange(extraAddtributes);
}
return(AddRuntimeParam <TValue>(cmdlet, paramName, paramAttribute, attrs.ToArray()));
}
public Task <IEnumerable <TReturn> > QueryAsync <TFirst, TSecond, TThird, TReturn>(string query, IDynamicParameters param, Func <TFirst, TSecond, TThird, TReturn> map)
{
return(dbConnection.QueryAsync <TFirst, TSecond, TThird, TReturn>(query, map, param));
}
public Task <IEnumerable <T> > QueryAsync <T>(string query, IDynamicParameters param)
{
return(dbConnection.QueryAsync <T>(query, param));
}
public dynamic CallFunction(string command, IDynamicParameters param = null)
{
return(connection.Query(command, param).FirstOrDefault());
}
