public SqlCallProcedureInfo(MethodInfo method, ISerializationTypeInfoProvider typeInfoProvider)
{
if (method == null) {
throw new ArgumentNullException("method");
}
if (typeInfoProvider == null) {
throw new ArgumentNullException("typeInfoProvider");
}
SqlProcAttribute procedure = GetSqlProcAttribute(method);
schemaName = procedure.SchemaName;
name = procedure.Name;
timeout = procedure.Timeout;
deserializeReturnNullOnEmptyReader = procedure.DeserializeReturnNullOnEmptyReader;
deserializeRowLimit = procedure.DeserializeRowLimit;
deserializeCallConstructor = procedure.DeserializeCallConstructor;
SortedDictionary<int, SqlCallParameterInfo> sortedParams = new SortedDictionary<int, SqlCallParameterInfo>();
outArgCount = 0;
foreach (ParameterInfo parameterInfo in method.GetParameters()) {
if ((parameterInfo.GetCustomAttributes(typeof(SqlNameTableAttribute), true).Length > 0) || (typeof(XmlNameTable).IsAssignableFrom(parameterInfo.ParameterType))) {
if (xmlNameTableParameter == null) {
xmlNameTableParameter = parameterInfo;
}
} else {
SqlCallParameterInfo sqlParameterInfo = new SqlCallParameterInfo(parameterInfo, typeInfoProvider, ref outArgCount);
sortedParams.Add(parameterInfo.Position, sqlParameterInfo);
}
}
parameters = sortedParams.Select(p => p.Value).ToArray();
returnTypeInfo = typeInfoProvider.GetSerializationTypeInfo(method.ReturnType);
if ((procedure.UseReturnValue != SqlReturnValue.Auto) || (method.ReturnType != typeof(void))) {
useReturnValue = (procedure.UseReturnValue == SqlReturnValue.ReturnValue) || ((procedure.UseReturnValue == SqlReturnValue.Auto) && (typeInfoProvider.TypeMappingProvider.GetMapping(method.ReturnType).DbType == SqlDbType.Int));
}
}
internal SqlCallInfo(AssemblyInventory inventory, ISerializationTypeInfoProvider serializationTypeInfoProvider, Type interfaceType, ISerializationTypeMappingProvider typeMappingProvider)
{
if (inventory == null) {
throw new ArgumentNullException("inventory");
}
if (serializationTypeInfoProvider == null) {
throw new ArgumentNullException("serializationTypeInfoProvider");
}
Debug.Assert(interfaceType != null);
if ((!interfaceType.IsInterface) || (interfaceType.IsGenericTypeDefinition) || (!typeof(IStoredProcedures).IsAssignableFrom(interfaceType))) {
throw new ArgumentException("The interface must inherit from IStoredProcedures", "interfaceType");
}
this.interfaceType = interfaceType;
foreach (Type innerInterface in interfaceType.GetInterfaces()) {
if (innerInterface != typeof(IStoredProcedures)) {
throw new ArgumentException("The interface cannot inherit from other interfaces then IStoredProcedures", "interfaceType");
}
}
foreach (MemberInfo memberInfo in interfaceType.GetMembers(BindingFlags.Instance|BindingFlags.Public|BindingFlags.DeclaredOnly)) {
MethodInfo methodInfo = memberInfo as MethodInfo;
if (methodInfo == null) {
throw new ArgumentException("Only methods are supported on the IStoredProcedures interfaces", "interfaceType");
}
methods.Add(methodInfo, new SqlCallProcedureInfo(inventory, serializationTypeInfoProvider, methodInfo, typeMappingProvider));
}
}
internal SqlDeserializationContext(IInstanceProvider provider, ISerializationTypeInfoProvider typeInfoProvider)
{
this.provider = provider;
this.typeInfoProvider = typeInfoProvider;
stateProvider = provider as IDeserializationStateProvider;
if (stateProvider != null) {
state = new SortedDictionary<string, object>(StringComparer.Ordinal);
stateProvider.BeginDeserialize(state);
}
}
internal static SqlCallInfo Get(Type interfaceType, ISerializationTypeInfoProvider typeInfoProvider)
{
if (interfaceType == null) {
throw new ArgumentNullException("interfaceType");
}
if (typeInfoProvider == null) {
throw new ArgumentNullException("typeInfoProvider");
}
SqlCallInfo result;
lock (knownTypes) {
if (!knownTypes.TryGetValue(interfaceType, out result)) {
result = new SqlCallInfo(interfaceType, typeInfoProvider);
knownTypes.Add(interfaceType, result);
}
}
return result;
}
public SqlCallParameterInfo(ParameterInfo parameter, ISerializationTypeInfoProvider typeInfoProvider, ref int outArgCount)
{
if (parameter == null) {
throw new ArgumentNullException("parameter");
}
if (typeInfoProvider == null) {
throw new ArgumentNullException("typeInfoProvider");
}
this.typeInfoProvider = typeInfoProvider;
SqlArgAttribute arg = GetSqlArgAttribute(parameter);
parameterName = arg.Name;
parameterType = parameter.ParameterType;
if (parameterType.IsByRef) {
parameterType = parameterType.GetElementType();
}
sqlType = (arg.Type != null) ? arg.Type.Value : typeInfoProvider.TypeMappingProvider.GetMapping(parameter.ParameterType).DbType;
size = arg.Size;
if ((size == 0) && ((sqlType == SqlDbType.NChar) || (sqlType == SqlDbType.Char))) {
size = 1;
}
nullable = arg.Nullable;
if (parameter.ParameterType.IsNullableType()) {
nullable = true;
} else if (parameter.ParameterType.IsValueType) {
nullable = false;
}
position = parameter.Position;
if (parameter.ParameterType.IsByRef) {
if (sqlType == SqlDbType.Structured) {
throw new NotSupportedException("Table valued parameters only support readonly inputs!");
}
direction = parameter.IsOut ? ParameterDirection.Output : ParameterDirection.InputOutput;
}
if (direction != ParameterDirection.Input) {
outArgPosition = outArgCount++;
}
if (sqlType == SqlDbType.Structured) {
structuredSchema = new StructuredParameterSchema(typeInfoProvider.GetSerializationTypeInfo(parameterType.GetGenericArguments()[0]), typeInfoProvider.TypeMappingProvider);
}
if ((sqlType == SqlDbType.Udt) && string.IsNullOrEmpty(arg.UserDefinedTypeName)) {
userDefinedTypeName = GetClrUserDefinedTypeName(parameter.ParameterType);
}
}
private SqlCallInfo(Type interfaceType, ISerializationTypeInfoProvider typeInfoProvider)
{
Debug.Assert(interfaceType != null);
if (interfaceType == null) {
throw new ArgumentNullException("interfaceType");
}
if (typeInfoProvider == null) {
throw new ArgumentNullException("typeInfoProvider");
}
if ((!interfaceType.IsInterface) || (interfaceType.IsGenericTypeDefinition) || (!typeof(IStoredProcedures).IsAssignableFrom(interfaceType))) {
throw new ArgumentException("interfaceType");
}
this.interfaceType = interfaceType;
foreach (MemberInfo memberInfo in interfaceType.GetMembers()) {
MethodInfo methodInfo = memberInfo as MethodInfo;
if (methodInfo == null) {
throw new InvalidOperationException("Only methods are supported");
}
if (methodInfo.Name != "Dispose") {
methods.Add(methodInfo, new SqlCallProcedureInfo(methodInfo, typeInfoProvider));
}
}
}
public SqlCallParameterInfo(ISerializationTypeInfoProvider serializationTypeInfoProvider, ParameterInfo param, ProcedureName procedureName, ProcedureParameter script, ISerializationTypeMappingProvider typeMappingProvider)
: base(procedureName, script, GetParameterDirection(param), GetParameterNullable(param), GetParameterEnumerable(param))
{
parameterInfo = param;
if (SqlType == SqlDbType.Structured) {
Type structuredType;
if (!param.ParameterType.TryGetIEnumerableElementType(out structuredType)) {
throw new ArgumentException("The given parameter must implement IEnumerable<> in order to be used as SQL structured parameter");
}
CreateTypeAsTableStatement createTableTypeScript;
if (!AssemblyInventory.Get(param.Member.DeclaringType.Assembly).TryFind(script.ParameterTypeName.Name.Value, out createTableTypeScript)) {
throw new ArgumentException(string.Format("The given structured parameter table type {0} cannot be found in the inventory", script.ParameterTypeName));
}
IDictionary<string, SqlColumnInfo> columnInfos;
ISerializationTypeInfo info = serializationTypeInfoProvider.GetSerializationTypeInfo(structuredType);
if (info.SimpleConverter != null) {
string columnName = createTableTypeScript.TableDefinitions.OfType<TableColumnDefinition>().First(d => d.ColumnDefinition is TypedColumnDefinition).ColumnName.Value;
columnInfos = new Dictionary<string, SqlColumnInfo>(1);
columnInfos.Add(columnName, new SqlColumnInfo(typeMappingProvider.GetMapping(structuredType), columnName, info.SimpleConverter));
} else {
columnInfos = typeMappingProvider.GetMapping(structuredType).Columns;
Attribute[] mappingAttributes = Attribute.GetCustomAttributes(param, typeof(SqlMappingAttribute), true);
if ((mappingAttributes != null) && (mappingAttributes.Length > 0)) {
IDictionary<string, SqlColumnInfo> mappedColumnInfos = new Dictionary<string, SqlColumnInfo>(columnInfos);
foreach (SqlMappingAttribute mappingAttribute in mappingAttributes) {
mappedColumnInfos[mappingAttribute.TableTypeColumn] = columnInfos[mappingAttribute.SqlColumn];
}
columnInfos = mappedColumnInfos;
}
}
structuredSchema = new StructuredParameterSchema(createTableTypeScript, columnInfos);
}
#warning Maybe implement more type compatibility checks for arguments here
// if ((sqlType == SqlDbType.Udt) && string.IsNullOrEmpty(arg.UserDefinedTypeName)) {
// userDefinedTypeName = SqlSerializationTypeMapping.GetClrUserDefinedTypeName(parameter.ParameterType, arg);
// }
}
