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));
}
}
public StructuredParameterSchema(ISerializationTypeInfo typeInfo, ISerializationTypeMappingProvider typeMappingProvider)
{
SetupColumns(typeInfo.Type.Name, typeInfo.Type.Namespace);
DataColumn columnName = Columns[SchemaTableColumn.ColumnName];
DataColumn allowDbNull = Columns[SchemaTableColumn.AllowDBNull];
DataColumn dataType = Columns[SchemaTableColumn.DataType];
/* DataColumn numericScale = Columns[SchemaTableColumn.NumericScale];
DataColumn numericPrecision = Columns[SchemaTableColumn.NumericPrecision];
DataColumn columnSize = Columns[SchemaTableColumn.ColumnSize]; */
DataColumn baseColumnName = Columns[SchemaTableColumn.BaseColumnName];
DataColumn providerType = Columns[SchemaTableColumn.ProviderType];
DataColumn nonVersionedProviderType = Columns[SchemaTableColumn.NonVersionedProviderType];
DataColumn columnOrdinal = Columns[SchemaTableColumn.ColumnOrdinal];
List<SqlColumnInfo> sqlColumnInfos = new List<SqlColumnInfo>();
List<ColumnInfo> columns = new List<ColumnInfo>();
Dictionary<SqlColumnInfo, int> columnIndices = new Dictionary<SqlColumnInfo, int>();
if (typeInfo.Mapping.IsNativeType) {
DataRow row = NewRow();
row[columnName] = "value";
row[columnOrdinal] = 0;
row[dataType] = typeInfo.Type;
row[allowDbNull] = true;
row[baseColumnName] = "value";
row[providerType] = (int)typeInfo.Mapping.DbType;
Rows.Add(row);
columns.Add(new ColumnInfo(0, "value", Enum.GetName(typeof(SqlDbType), typeInfo.Mapping.DbType), typeInfo.Type));
IMemberConverter memberConverter = MemberConverter.Get(typeInfo.Type, false, "value", 0, DateTimeKind.Unspecified);
sqlColumnInfos.Add(new SqlColumnInfo(typeMappingProvider.GetMapping(typeInfo.Type), "value", memberConverter));
} else {
foreach (MemberInfo memberInfo in typeInfo.Type.GetAllFieldsAndProperties()) {
SqlColumnAttribute sqlColumn = SqlColumnAttributeBase.Get<SqlColumnAttribute>(memberInfo, false);
if (sqlColumn != null) {
Type memberType = memberInfo.GetMemberType();
SqlColumnInfo sqlColumnInfo = typeInfo.Mapping.Columns[sqlColumn.Name];
StructuredParameterAttribute parameterAttribute = StructuredParameterAttribute.GetStructuredParameterAttribute(memberInfo);
Debug.Assert(parameterAttribute != null);
ColumnInfo ci = new ColumnInfo(sqlColumnInfos.Count, sqlColumnInfo.Name, GetDataTypeName(sqlColumnInfo, memberType), memberType);
DataRow row = NewRow();
row[columnName] = ci.ColumnName;
row[columnOrdinal] = parameterAttribute.Position;
row[dataType] = Nullable.GetUnderlyingType(ci.DataType) ?? ci.DataType;
row[allowDbNull] = ci.DataType.IsNullableType();
row[baseColumnName] = ci.ColumnName;
row[providerType] = (int)sqlColumnInfo.DbType;
row[nonVersionedProviderType] = (int)sqlColumnInfo.DbType;
Rows.Add(row);
columnIndices.Add(sqlColumnInfo, parameterAttribute.Position);
sqlColumnInfos.Add(sqlColumnInfo);
columns.Add(ci);
}
}
sqlColumnInfos = sqlColumnInfos.OrderBy(ci => columnIndices[ci]).ToList();
}
MappedColumns = sqlColumnInfos.AsReadOnly();
ColumnsInfos = columns.ToArray();
if ((MappedColumns.Count != 1) ||(MappedColumns[0].MemberInfo != null)) {
ExtractMembers = MembersMethods.Get(MappedColumns.Select(c => c.MemberInfo).ToArray()).ExtractMembers;
}
AcceptChanges();
}
public IEnumerable<SqlCommand> CreateCommands(IMethodCallMessage mcm, SqlConnection connection, string schemaName, out SqlParameter returnValue, out SqlParameter[] outParameters, out ISerializationTypeInfo returnTypeInfo, out ICallDeserializationInfo procInfo, out XmlNameTable xmlNameTable,
IList<IDisposable> disposeList)
{
List<SqlCommand> sqlCommands = new List<SqlCommand>();
SqlCommand sqlCommand = methods[mcm.MethodBase].GetCommand(mcm, connection, out returnValue, out outParameters, out returnTypeInfo, out procInfo, out xmlNameTable, disposeList);
sqlCommands.Add(sqlCommand);
return sqlCommands;
}
public SqlCommand GetCommand(IMethodCallMessage mcm, SqlConnection connection, out SqlParameter returnParameter, out SqlParameter[] outArgs, out ISerializationTypeInfo procedureReturnTypeInfo, out ICallDeserializationInfo procedureInfo, out XmlNameTable xmlNameTable, IList<IDisposable> disposeList)
{
SqlCommand result = connection.CreateCommand();
result.CommandText = ProcedureName;
result.CommandType = CommandType.StoredProcedure;
if (timeout > 0) {
result.CommandTimeout = timeout;
}
outArgs = new SqlParameter[outArgCount];
xmlNameTable = xmlNameTableParameter != null ? (XmlNameTable)mcm.GetArg(xmlNameTableParameter.Position) : null;
foreach (SqlCallParameterInfo factory in parameters) {
result.Parameters.Add(factory.GetSqlParameter(result, mcm, outArgs, disposeList));
}
if (useReturnValue) {
returnParameter = result.CreateParameter();
returnParameter.SqlDbType = SqlDbType.Int;
returnParameter.Direction = ParameterDirection.ReturnValue;
result.Parameters.Add(returnParameter);
} else {
returnParameter = null;
}
procedureReturnTypeInfo = returnTypeInfo;
procedureInfo = this;
return result;
}
