/// <summary> /// Transform dictionary to SqlDataRecord list /// 转化字典到TVP参数列表 /// </summary> /// <param name="dic">Dictionary</param> /// <param name="keyType">Key data type</param> /// <param name="itemType">Item data type</param> /// <param name="keyMaxLength">Char/byte key max length</param> /// <param name="valueMaxLength">Char/byte value max length</param> /// <returns>TVP list</returns> public static IEnumerable <SqlDataRecord> DictionaryToRecords(IDictionary dic, SqlDbType keyType, SqlDbType itemType, long?keyMaxLength = null, long?valueMaxLength = null) { // SqlDataRecord definition var keyMeta = IsLengthSpecifiedType(keyType) ? new SqlMetaData("key", keyType, keyMaxLength.GetValueOrDefault(40)) : new SqlMetaData("key", keyType); var itemMeta = IsLengthSpecifiedType(itemType) ? new SqlMetaData("item", itemType, valueMaxLength.GetValueOrDefault(128)) : new SqlMetaData("item", itemType); var sdr = new SqlDataRecord(keyMeta, itemMeta); // List enumerator var enumerator = dic.GetEnumerator(); while (enumerator.MoveNext()) { // Ignore null values if (enumerator.Key == null || enumerator.Value == null) { yield break; } // Set value sdr.SetValue(0, enumerator.Key); sdr.SetValue(1, enumerator.Value); // Yield return for the current item // Memory saving yield return(sdr); } }
public static void GetEnvironmentVars() { try { SortedList environment_list = new SortedList(); foreach (DictionaryEntry de in Environment.GetEnvironmentVariables()) { environment_list[de.Key] = de.Value; } SqlDataRecord record = new SqlDataRecord( new SqlMetaData("VarName", SqlDbType.NVarChar, 1024), new SqlMetaData("VarValue", SqlDbType.NVarChar, 4000) ); SqlContext.Pipe.SendResultsStart(record); foreach (DictionaryEntry de in environment_list) { record.SetValue(0, de.Key); record.SetValue(1, de.Value); SqlContext.Pipe.SendResultsRow(record); } SqlContext.Pipe.SendResultsEnd(); } catch (Exception ex) { SqlContext.Pipe.Send(ex.Message); } }
private List <SqlDataRecord> BuildSqlRecordList(CurrencyModel DataModel) { string CurrencyCode; decimal CurrencyRate; PropertyInfo[] PublicProps; Type ModelType; SqlDataRecord Record; SqlMetaData[] Columns; SqlMetaData C_Code, C_Rate; List <SqlDataRecord> CurrencyTable = new List <SqlDataRecord>(); C_Code = new SqlMetaData("Code", SqlDbType.NVarChar, 5); C_Rate = new SqlMetaData("Rate", SqlDbType.Decimal, 18, 2); Columns = new SqlMetaData[] { C_Code, C_Rate }; ModelType = typeof(CurrencyRateModel); PublicProps = ModelType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); foreach (PropertyInfo Property in PublicProps) { CurrencyCode = Property.Name.ToString(); CurrencyRate = Convert.ToDecimal(Property.GetValue(DataModel.quotes).ToString()); Record = new SqlDataRecord(Columns); Record.SetValue(Record.GetOrdinal("Code"), CurrencyCode.Substring(3)); Record.SetValue(Record.GetOrdinal("Rate"), Math.Round(CurrencyRate, 2)); CurrencyTable.Add(Record); } Record = new SqlDataRecord(Columns); Record.SetValue(Record.GetOrdinal("Code"), DataModel.source); Record.SetValue(Record.GetOrdinal("Rate"), 1.00M); CurrencyTable.Add(Record); return(CurrencyTable); }
private static void FillRecordFromElements(XmlReader inputReader, SqlDataRecord outputRecord, SqlMetaData[] outputColumns, string rowElementName) { bool continueReading = true; bool skipRead = false; int expectedColumnID = 0; while (continueReading && (skipRead || inputReader.Read())) { skipRead = false; if (inputReader.NodeType == XmlNodeType.Element) { //collect nulls for any missing columns - if "XSINIL" was not set when calling while (!inputReader.Name.Equals(outputColumns[expectedColumnID].Name)) { if (expectedColumnID == outputColumns.Length - 1) { //we ran out of columns - thrown an error throw new Exception("Unknown element found! (is it possible you did not specify a schema, did not specify " + "the \"XSINIL\" option, and had a null value in the first row? This would prevent successful column " + "auto-detection..."); } outputRecord.SetValue(expectedColumnID, null); expectedColumnID++; } bool valueIsNull = false; if (inputReader.HasAttributes && inputReader.MoveToAttribute("nil", "http://www.w3.org/2001/XMLSchema-instance") && inputReader.ReadContentAsString().Equals("true") ) { valueIsNull = true; } if (valueIsNull) { outputRecord.SetValue(expectedColumnID, null); } else { SetRecordValueFromString(outputRecord, outputColumns, expectedColumnID, inputReader.ReadElementContentAsString()); skipRead = true; } expectedColumnID++; } else if (inputReader.NodeType == XmlNodeType.EndElement && inputReader.Name.Equals(rowElementName)) { continueReading = false; } } //set any missing columns at the end to null while (expectedColumnID < outputColumns.Length) { outputRecord.SetValue(expectedColumnID, null); expectedColumnID++; } }
/// <summary> /// Rempli la liste de SQL record. /// </summary> /// <param name="isInsert">True si c'est pour une insertion.</param> private void PopulateParamList(bool isInsert) { _index = new Dictionary <int, T>(); SqlMetaData[] array = _metadataList.ToArray(); _dataRecordList = new List <SqlDataRecord>(); int insertKey = 0; foreach (T item in _collection) { if (isInsert && _beanDefinition.PrimaryKey.GetValue(item) != null) { throw new NotSupportedException("La clef primaire doit être nulle."); } SqlDataRecord record = new SqlDataRecord(array); int ordinal = 0; foreach (BeanPropertyDescriptor property in _beanDefinition.Properties) { object value = GetPropertyValue(item, property); if (property.MemberName == null || property.IsPrimaryKey || property == _insertKeyProp) { if (!isInsert && property.IsPrimaryKey && property.PrimitiveType == typeof(int)) { insertKey = (int)(value ?? insertKey); } if (property.MemberName == null || property.PrimitiveType == typeof(int)) { continue; } } record.SetValue(ordinal, value); ++ordinal; } record.SetValue(ordinal, insertKey); _dataRecordList.Add(record); _index.Add(insertKey, item); ++insertKey; } if (_dataRecordList.Count == 0) { SqlDataRecord record = new SqlDataRecord(array); for (int i = 0; i < array.Length; i++) { record.SetValue(i, null); } _dataRecordList.Add(record); } }
public void GetNullable_InvalidOrdinal_ShouldThrowException() { var dataRecord = new SqlDataRecord( new SqlMetaData("StringProp", SqlDbType.NVarChar, 20), new SqlMetaData("IntProp", SqlDbType.Int)); dataRecord.SetValue(0, "String value."); dataRecord.SetValue(1, 123); Assert.Throws <IndexOutOfRangeException>(() => dataRecord.GetNullable <string>(3)); }
public void GetNullableString_ValidStringValue_ShouldReturnStringValue() { const string StringValue = "String value."; var dataRecord = new SqlDataRecord( new SqlMetaData("StringProp", SqlDbType.NVarChar, 20), new SqlMetaData("IntProp", SqlDbType.Int)); dataRecord.SetValue(0, StringValue); dataRecord.SetValue(1, 123); Assert.Equal(StringValue, dataRecord.GetNullable <string>(0)); }
public void GetNullableInt_ValidIntValue_ShouldReturnIntValue() { const int IntValue = 123; var dataRecord = new SqlDataRecord( new SqlMetaData("StringProp", SqlDbType.NVarChar, 20), new SqlMetaData("IntProp", SqlDbType.Int)); dataRecord.SetValue(0, "String value."); dataRecord.SetValue(1, IntValue); Assert.Equal(IntValue, dataRecord.GetNullable <int>(1)); }
private void AddToWindow(object[] newTuple, string[] operators, ArrayList resultCollection, ArrayList resultstringCollection, SqlDataRecord record, SqlBoolean isFrameworkMode, int level, DataTable dtResult) { //Erste Spalte ist die ID long?[] recordInt = new long?[operators.GetUpperBound(0) + 1]; string[] recordstring = new string[operators.GetUpperBound(0) + 1]; DataRow row = dtResult.NewRow(); for (int iCol = 0; iCol <= newTuple.GetUpperBound(0); iCol++) { //Only the real columns (skyline columns are not output fields) if (iCol <= operators.GetUpperBound(0)) { //LOW und HIGH Spalte in record abfüllen if (operators[iCol].Equals("LOW")) { if (newTuple[iCol] == DBNull.Value) { recordInt[iCol] = null; } else { recordInt[iCol] = (long)newTuple[iCol]; } //Check if long value is incomparable if (iCol + 1 <= recordInt.GetUpperBound(0) && operators[iCol + 1].Equals("INCOMPARABLE")) { //Incomparable field is always the next one recordstring[iCol] = (string)newTuple[iCol + 1]; } } } else { row[iCol - (operators.GetUpperBound(0) + 1)] = newTuple[iCol]; record.SetValue(iCol - (operators.GetUpperBound(0) + 1), newTuple[iCol]); } } row[record.FieldCount - 1] = level; record.SetValue(record.FieldCount - 1, level); if (isFrameworkMode == true) { dtResult.Rows.Add(row); } else { SqlContext.Pipe.SendResultsRow(record); } resultCollection.Add(recordInt); resultstringCollection.Add(recordstring); }
private SqlDataRecord SetDbRecord(SqlDataRecord record, object value, int index) { if (value.IsPrimitive()) { var cValue = Convert.ChangeType(value, record.GetFieldType(index)); record.SetValue(index, cValue); } else { record.SetValue(index, value.ToString()); } return(record); }
public static IEnumerable<SqlDataRecord> GetSqlDataRecords() { var sqlRecord = new SqlDataRecord( new SqlMetaData("Id", SqlDbType.Int), new SqlMetaData("Name", SqlDbType.NVarChar, 10)); foreach (var record in TestData) { sqlRecord.SetValue(0, record.Id); sqlRecord.SetValue(1, record.Name); yield return sqlRecord; } }
public static void SendDataTable(DataTable dt) { bool[] coerceToString; // Do we need to coerce this column to string? SqlMetaData[] metaData = ExtractDataTableColumnMetaData(dt, out coerceToString); SqlDataRecord record = new SqlDataRecord(metaData); SqlPipe pipe = SqlContext.Pipe; pipe.SendResultsStart(record); try { foreach (DataRow row in dt.Rows) { for (int index = 0; index < record.FieldCount; index++) { object value = row[index]; if (null != value && coerceToString[index]) { value = value.ToString(); } record.SetValue(index, value); } pipe.SendResultsRow(record); } } finally { pipe.SendResultsEnd(); } }
public List <SqlDataRecord> ConvertListParameterValue(object value, SqlListParamPlaceHolder lph) { var list = value as IList; if (list == null || list.Count == 0) { return(null); //it should null, not DbNull.Value } bool isEnum = lph.ElementType.IsEnum; var records = new List <SqlDataRecord>(); var rowMetaData = new SqlMetaData("Value", SqlDbType.Variant); foreach (object elem in list) { var rec = new SqlDataRecord(rowMetaData); var v1 = isEnum ? ConvertHelper.EnumValueToInt(elem, lph.ElementType) : elem; rec.SetValue(0, v1); records.Add(rec); } if (records.Count == 0) { return(null); // with 0 rows throws error, advising to send NULL } return(records); }
IEnumerator <SqlDataRecord> IEnumerable <SqlDataRecord> .GetEnumerator() { List <SqlMetaData> records = new List <SqlMetaData>(); var properties = typeof(T).GetProperties(); foreach (var prop in properties) { SqlDbType sdbtyp = GetSqlType(prop.PropertyType); if (sdbtyp == SqlDbType.VarChar) { records.Add(new SqlMetaData(prop.Name, sdbtyp, 8000)); } else { records.Add(new SqlMetaData(prop.Name, sdbtyp)); } } SqlDataRecord ret = new SqlDataRecord(records.ToArray()); foreach (T data in this) { for (int i = 0; i < properties.Length; i++) { ret.SetValue(i, properties[i].GetValue(data, null)); } yield return(ret); } }
/// <summary> /// Create sql data record collection for bulk insert. /// It creates meta data from insert procedure mapping customattribute /// </summary> /// <typeparam name="T"> /// Any type which implements Framework.Common.Models.IModel interface. /// </typeparam> /// <param name="modelCollection"> /// A collection of model items to be bulk inserted. /// </param> /// <returns> /// A collection of SqlDataRecord object for bulk insert. /// </returns> public List <SqlDataRecord> CreateSqlDataRecordCollection <T>(List <T> modelCollection) where T : IModel { List <SqlDataRecord> recordCollection = null; ModelParameterMap[] modelInsertParameters = new ModelParameterMap[this.map.Parameters.Count]; SqlMetaData[] metaDataCollection = new SqlMetaData[this.map.Parameters.Count]; foreach (ArrayList parameterMap in this.map.Parameters.Values) { ModelParameterMap[] parameters = (ModelParameterMap[])parameterMap.ToArray(typeof(ModelParameterMap)); if (parameters != null && parameters.Length > 0) { for (int i = 0; i < parameters.Length; i++) { ModelParameterMap mp = parameters[i]; if (mp.ParameterAction == DBProcedureType.INSERT) { // create meta data for insert parameter. SqlMetaData metaData = this.CreateSQLMetaData(mp.ParameterName, mp.DatabaseType); metaDataCollection[mp.ParameterIndex - 1] = metaData; modelInsertParameters[mp.ParameterIndex - 1] = mp; } } } } List <SqlMetaData> metaDataList = new List <SqlMetaData>(); for (int counter = 0; counter < metaDataCollection.Length; counter++) { if (metaDataCollection[counter] != null) { metaDataList.Add(metaDataCollection[counter]); } } // create one sql data record object for each model in the collection // and add that object to list recordCollection = new List <SqlDataRecord>(); foreach (IModel model in modelCollection) { SqlDataRecord dataRecord = new SqlDataRecord(metaDataList.ToArray()); // assign value for each property in the data record. for (int index = 0; index < modelInsertParameters.Length; index++) { if (modelInsertParameters[index] != null) { ModelParameterMap mp = modelInsertParameters[index]; // this.SetDataRecordValue(dataRecord, mp.DatabaseType, mp.Property.GetValue(model, null), index); dataRecord.SetValue(index, mp.Property.GetValue(model, null)); } } recordCollection.Add(dataRecord); } return(recordCollection); }
/// <summary> /// Send the result back to the client /// </summary> /// <param name="dt"></param> public static void PipeDataTable(DataTable dt) { var md = ExtractDataTableColumnMetaData(dt); var r = new SqlDataRecord(md); var p = SqlContext.Pipe; //--------------------------------------------------------------------------------------- // First is invoked ‘SendResultsStart.’ // ‘SendResultStart’ marks the beginning of a result set to be sent back to the client, // and uses the r parameter to construct the metadata that describes the result set //--------------------------------------------------------------------------------------- p?.SendResultsStart(r); try { foreach (DataRow row in dt.Rows) { for (var i = 0; i < r.FieldCount; i++) { var v = row[i]; v = DBNull.Value != v ? (object) v.ToString() : DBNull.Value; r.SetValue(i, v); } p?.SendResultsRow(r); } } finally { // // 'SendResultEnd’ marks the end of a result set and returns the SqlPipe instance to the initial state. // p?.SendResultsEnd(); } }
// Used for sending lists in SqlParameter, to use in SQL clauses like 'WHERE x IN (@P0)" // @P0 should be declarate as VITA_ArrayAsTable data type. // We can use DataTable as a container, but DataTable is not supported by .NET core; // we use alternative: IEnumerable<SqlDataRecord>, it is supported. // TODO: review the method and optimize it. internal static object ConvertListToRecordList(object value) { var list = value as System.Collections.IEnumerable; var valueType = value.GetType(); Type elemType; Util.Check(valueType.IsListOfDbPrimitive(out elemType), "Value must be list of DB primitives. Value type: {0} ", valueType); if (elemType.IsNullableValueType()) { elemType = Nullable.GetUnderlyingType(elemType); } bool isEnum = elemType.IsEnum; var records = new List <SqlDataRecord>(); var colData = new SqlMetaData("Value", SqlDbType.Variant); foreach (object v in list) { var rec = new SqlDataRecord(colData); var v1 = isEnum ? (int)v : v; rec.SetValue(0, v1); records.Add(rec); } if (records.Count == 0) { return(null); // with 0 rows throws error, advising to send NULL } return(records); }
/// <summary> /// Guid items to records /// 转化Guid项目到TVP参数列表 /// </summary> /// <param name="items">Items</param> /// <returns>Result</returns> public static IEnumerable <SqlDataRecord> GuidItemToRecords(IEnumerable <GuidItem> items, long?maxLength = null) { // SqlDataRecord definition var sdr = new SqlDataRecord(new SqlMetaData("Id", SqlDbType.UniqueIdentifier), new SqlMetaData("Item", SqlDbType.VarChar, maxLength ?? 128)); foreach (var item in items) { // Set value sdr.SetValue(0, item.Id); sdr.SetValue(1, item.Label); // Yield return for the current item // Memory saving yield return(sdr); } }
public static void CreateGeometryDartboard(SqlGeometry centre, double radius, int numrings) { int srid = (int)centre.STSrid; List <SqlDataRecord> Grid = new List <SqlDataRecord>(); SqlMetaData[] Columns = { new SqlMetaData("CellId", SqlDbType.Int), new SqlMetaData("Cell", SqlDbType.Udt, typeof(SqlGeometry)) }; for (int x = 0; x < numrings; x++) { SqlGeometry Ring = centre.STBuffer(radius * (x + 1)); SqlGeometry Hole = centre.STBuffer(radius * x); Ring = Ring.STDifference(Hole); SqlDataRecord rec = new SqlDataRecord(Columns); rec.SetInt32(0, x); rec.SetValue(1, Ring); Grid.Add(rec); } SqlContext.Pipe.SendResultsStart(new SqlDataRecord(Columns)); foreach (SqlDataRecord d in Grid) { SqlContext.Pipe.SendResultsRow(d); } SqlContext.Pipe.SendResultsEnd(); }
public static void AddParameters(this SqlCommand command, IDictionary <string, object> parameterDictionary) { if (parameterDictionary != null) { foreach (var param in parameterDictionary) { if (param.Value is string[] stringArray) { SqlParameter sqlParam = command.CreateParameter(); sqlParam.ParameterName = param.Key; sqlParam.SqlDbType = SqlDbType.Structured; sqlParam.TypeName = "dbo.NvarcharTable"; if (stringArray.Length == 0) { sqlParam.Value = _emptyNvarcharTableParam; } else { sqlParam.Value = stringArray.Select(str => { SqlMetaData meta = new SqlMetaData("value", SqlDbType.NVarChar, 1000); SqlDataRecord record = new SqlDataRecord(meta); record.SetValue(0, str); return(record); }); } command.Parameters.Add(sqlParam); } else { command.Parameters.AddWithValue(param.Key, param.Value); } } } }
public static void GetSkyline(SqlString strQuery, SqlString strOperators, SqlInt32 numberOfRecords, SqlInt32 sortType, SqlInt32 count, SqlInt32 dimension, SqlString algorithm, SqlBoolean hasIncomparable) { try { Type strategyType = Type.GetType("prefSQL.SQLSkyline." + algorithm.ToString()); if (!typeof(SkylineStrategy).IsAssignableFrom(strategyType)) { throw new Exception("passed algorithm is not of type SkylineStrategy."); } var strategy = (SkylineStrategy)Activator.CreateInstance(strategyType); strategy.Provider = Helper.ProviderClr; strategy.ConnectionString = Helper.CnnStringSqlclr; strategy.RecordAmountLimit = numberOfRecords.Value; strategy.HasIncomparablePreferences = hasIncomparable.Value; strategy.SortType = sortType.Value; var skylineSample = new SkylineSampling { SubsetCount = count.Value, SubsetDimension = dimension.Value, SelectedStrategy = strategy }; DataTable dataTableReturn = skylineSample.GetSkylineTable(strQuery.ToString(), strOperators.ToString()); SqlDataRecord dataRecordTemplate = skylineSample.DataRecordTemplateForStoredProcedure; //throw new Exception(dataTableReturn.Rows[0].Table.Columns.Count.ToString()); if (SqlContext.Pipe != null) { SqlContext.Pipe.SendResultsStart(dataRecordTemplate); foreach (DataRow recSkyline in dataTableReturn.Rows) { for (var i = 0; i < recSkyline.Table.Columns.Count; i++) { dataRecordTemplate.SetValue(i, recSkyline[i]); } SqlContext.Pipe.SendResultsRow(dataRecordTemplate); } SqlContext.Pipe.SendResultsEnd(); } } catch (Exception ex) { //Pack Errormessage in a SQL and return the result var strError = "Error in prefSQL_SkylineSampling: "; strError += ex.Message; if (SqlContext.Pipe != null) { SqlContext.Pipe.Send(strError); } } }
internal void WriteTo(SqlDataRecord record, object row) { var ordinal = record.GetOrdinal(ColumnName); var value = _accessor[row, PropertyName]; var valueToWrite = ToDatabase(value); record.SetValue(ordinal, valueToWrite); }
public static IEnumerable <SqlDataRecord> ConvertToTvp <T>(this IEnumerable <T> data) where T : new() { SqlMetaData[] record; PropertyInfo[] properties; if (Tipler.ContainsKey(typeof(T))) { record = Tipler[typeof(T)]; if (Props.ContainsKey(typeof(T))) { properties = Props[typeof(T)]; } else { properties = typeof(T).GetTypeInfo().GetProperties(); Props.TryAdd(typeof(T), properties); } } else { var records = new List <SqlMetaData>(); if (Props.ContainsKey(typeof(T))) { properties = Props[typeof(T)]; } else { properties = typeof(T).GetTypeInfo().GetProperties(); Props.TryAdd(typeof(T), properties); } foreach (var prop in properties) { var pt = prop.PropertyType; var sdbtyp = prop.PropertyType.GetSqlDbType(); records.Add(pt.Name.Equals("String") ? new SqlMetaData(prop.Name, sdbtyp, 4000) : new SqlMetaData(prop.Name, sdbtyp)); } record = records.ToArray(); Tipler.TryAdd(typeof(T), record); } var ret = new SqlDataRecord(record); foreach (var d in data) { for (var i = 0; i < properties.Length; i++) { var im = properties[i]; ret.SetValue(i, properties[i].GetValue(d, null)); } yield return(ret); } }
private static void SetRecordValues(SqlDataRecord record, ITuple tuple, BindingParameterConverter[] converters) { for (int i = 0; i < record.FieldCount; i++) { object value = converters[i]?.Invoke(tuple[i].Value) ?? tuple[i].Value; record.SetValue(i, value); } }
public static SqlDataRecord Convert(T obj) { var tableRow = new SqlDataRecord(TableSchema); for (int i = 0; i < Properties.Length; i++) { tableRow.SetValue(i, Properties[i].GetGetMethod().Invoke(obj, new object[0])); } return(tableRow); }
public void GetNullableInt_DbNullDataRecordValue_ShouldReturnZero() { var dataRecord = new SqlDataRecord( new SqlMetaData("StringProp", SqlDbType.NVarChar, 20), new SqlMetaData("IntProp", SqlDbType.Int)); dataRecord.SetValue(0, "String value."); Assert.Equal(0, dataRecord.GetNullable <int>(1)); }
public void GetNullableString_DbNullDataRecordValue_ShouldReturnNull() { var dataRecord = new SqlDataRecord( new SqlMetaData("StringProp", SqlDbType.NVarChar, 20), new SqlMetaData("IntProp", SqlDbType.Int)); dataRecord.SetValue(1, 123); Assert.Equal(null, dataRecord.GetNullable <string>(0)); }
public IEnumerator <SqlDataRecord> GetEnumerator() { SqlDataRecord ret = new SqlDataRecord(new SqlMetaData("value", this.DbType)); foreach (var data in this) { ret.SetValue(0, data); yield return(ret); } }
public void GetXXX_ReturnValue(SqlDbType dbType, object value, Func <SqlDataRecord, object> getXXX) { SqlMetaData[] metaData = new SqlMetaData[] { new SqlMetaData("col1", dbType) }; SqlDataRecord record = new SqlDataRecord(metaData); record.SetValue(0, value); Assert.Equal(value, getXXX(record)); }
public void GetXXX_ThrowsIfBadType(Func <SqlDataRecord, object> getXXX) { SqlMetaData[] metaData = new SqlMetaData[] { new SqlMetaData("col1", SqlDbType.NVarChar, 1) }; SqlDataRecord record = new SqlDataRecord(metaData); record.SetValue(0, "a"); Assert.Throws <InvalidCastException>(() => getXXX(record)); }