646 lines
26 KiB
C#
646 lines
26 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="OleDbParameter.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
// <owner current="true" primary="true">[....]</owner>
|
|
// <owner current="true" primary="false">[....]</owner>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Data.OleDb {
|
|
|
|
using System;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Data.Common;
|
|
using System.Data.ProviderBase;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
|
|
[
|
|
System.ComponentModel.TypeConverterAttribute(typeof(System.Data.OleDb.OleDbParameter.OleDbParameterConverter))
|
|
]
|
|
public sealed partial class OleDbParameter : DbParameter, ICloneable, IDbDataParameter {
|
|
private NativeDBType _metaType;
|
|
private int _changeID;
|
|
|
|
private string _parameterName;
|
|
private byte _precision;
|
|
private byte _scale;
|
|
private bool _hasScale;
|
|
|
|
private NativeDBType _coerceMetaType;
|
|
|
|
public OleDbParameter() : base() { // V1.0 nothing
|
|
}
|
|
|
|
public OleDbParameter(string name, object value) : this() { // MDAC 59521
|
|
Debug.Assert(!(value is OleDbType), "use OleDbParameter(string, OleDbType)");
|
|
Debug.Assert(!(value is SqlDbType), "use OleDbParameter(string, OleDbType)");
|
|
|
|
ParameterName = name;
|
|
Value = value;
|
|
}
|
|
|
|
public OleDbParameter(string name, OleDbType dataType) : this() {
|
|
ParameterName = name;
|
|
OleDbType = dataType;
|
|
}
|
|
|
|
public OleDbParameter(string name, OleDbType dataType, int size) : this() {
|
|
ParameterName = name;
|
|
OleDbType = dataType;
|
|
Size = size;
|
|
}
|
|
|
|
public OleDbParameter(string name, OleDbType dataType, int size, string srcColumn) : this() {
|
|
ParameterName = name;
|
|
OleDbType = dataType;
|
|
Size = size;
|
|
SourceColumn = srcColumn;
|
|
}
|
|
|
|
[ EditorBrowsableAttribute(EditorBrowsableState.Advanced) ] // MDAC 69508
|
|
public OleDbParameter(string parameterName,
|
|
OleDbType dbType, int size,
|
|
ParameterDirection direction, Boolean isNullable,
|
|
Byte precision, Byte scale,
|
|
string srcColumn, DataRowVersion srcVersion,
|
|
object value) : this() { // V1.0 everything
|
|
ParameterName = parameterName;
|
|
OleDbType = dbType;
|
|
Size = size;
|
|
Direction = direction;
|
|
IsNullable = isNullable;
|
|
PrecisionInternal = precision;
|
|
ScaleInternal = scale;
|
|
SourceColumn = srcColumn;
|
|
SourceVersion = srcVersion;
|
|
Value = value;
|
|
}
|
|
|
|
[ EditorBrowsableAttribute(EditorBrowsableState.Advanced) ] // MDAC 69508
|
|
public OleDbParameter(string parameterName,
|
|
OleDbType dbType, int size,
|
|
ParameterDirection direction,
|
|
Byte precision, Byte scale,
|
|
string sourceColumn, DataRowVersion sourceVersion, bool sourceColumnNullMapping,
|
|
object value) : this() { // V2.0 everything - round trip all browsable properties + precision/scale
|
|
ParameterName = parameterName;
|
|
OleDbType = dbType;
|
|
Size = size;
|
|
Direction = direction;
|
|
PrecisionInternal = precision;
|
|
ScaleInternal = scale;
|
|
SourceColumn = sourceColumn;
|
|
SourceVersion = sourceVersion;
|
|
SourceColumnNullMapping = sourceColumnNullMapping;
|
|
Value = value;
|
|
}
|
|
|
|
internal int ChangeID {
|
|
get {
|
|
return _changeID;
|
|
}
|
|
}
|
|
|
|
override public DbType DbType {
|
|
get {
|
|
return GetBindType(Value).enumDbType;
|
|
}
|
|
set {
|
|
NativeDBType dbtype = _metaType;
|
|
if ((null == dbtype) || (dbtype.enumDbType != value)) { // MDAC 63571
|
|
PropertyTypeChanging();
|
|
_metaType = NativeDBType.FromDbType(value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void ResetDbType() {
|
|
ResetOleDbType();
|
|
}
|
|
|
|
[
|
|
RefreshProperties(RefreshProperties.All),
|
|
ResCategoryAttribute(Res.DataCategory_Data),
|
|
ResDescriptionAttribute(Res.OleDbParameter_OleDbType),
|
|
System.Data.Common.DbProviderSpecificTypePropertyAttribute(true),
|
|
]
|
|
public OleDbType OleDbType {
|
|
get {
|
|
return GetBindType(Value).enumOleDbType;
|
|
}
|
|
set {
|
|
NativeDBType dbtype = _metaType;
|
|
if ((null == dbtype) || (dbtype.enumOleDbType != value)) { // MDAC 63571
|
|
PropertyTypeChanging();
|
|
_metaType = NativeDBType.FromDataType(value);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool ShouldSerializeOleDbType() {
|
|
return (null != _metaType);
|
|
}
|
|
|
|
public void ResetOleDbType() {
|
|
if (null != _metaType) {
|
|
PropertyTypeChanging();
|
|
_metaType = null;
|
|
}
|
|
}
|
|
|
|
[
|
|
ResCategoryAttribute(Res.DataCategory_Data),
|
|
ResDescriptionAttribute(Res.DbParameter_ParameterName),
|
|
]
|
|
override public string ParameterName { // V1.2.3300, XXXParameter V1.0.3300
|
|
get {
|
|
string parameterName = _parameterName;
|
|
return ((null != parameterName) ? parameterName : ADP.StrEmpty);
|
|
}
|
|
set {
|
|
if (_parameterName != value) {
|
|
PropertyChanging();
|
|
_parameterName = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
[DefaultValue((Byte)0)] // MDAC 65862
|
|
[ResCategoryAttribute(Res.DataCategory_Data)]
|
|
[ResDescriptionAttribute(Res.DbDataParameter_Precision)]
|
|
public new Byte Precision {
|
|
get {
|
|
return PrecisionInternal;
|
|
}
|
|
set {
|
|
PrecisionInternal = value;
|
|
}
|
|
}
|
|
internal byte PrecisionInternal {
|
|
get {
|
|
byte precision = _precision;
|
|
if (0 == precision) {
|
|
precision = ValuePrecision(Value);
|
|
}
|
|
return precision;
|
|
}
|
|
set {
|
|
if (_precision != value) {
|
|
PropertyChanging();
|
|
_precision = value;
|
|
}
|
|
}
|
|
}
|
|
private bool ShouldSerializePrecision() {
|
|
return (0 != _precision);
|
|
}
|
|
|
|
[DefaultValue((Byte)0)] // MDAC 65862
|
|
[ResCategoryAttribute(Res.DataCategory_Data)]
|
|
[ResDescriptionAttribute(Res.DbDataParameter_Scale)]
|
|
public new Byte Scale {
|
|
get {
|
|
return ScaleInternal;
|
|
}
|
|
set {
|
|
ScaleInternal = value;
|
|
}
|
|
}
|
|
internal byte ScaleInternal {
|
|
get {
|
|
byte scale = _scale;
|
|
if (!ShouldSerializeScale(scale)) { // WebData 94688
|
|
scale = ValueScale(Value);
|
|
}
|
|
return scale;
|
|
}
|
|
set {
|
|
if (_scale != value || !_hasScale) {
|
|
PropertyChanging();
|
|
_scale = value;
|
|
_hasScale = true;
|
|
}
|
|
}
|
|
}
|
|
private bool ShouldSerializeScale() {
|
|
return ShouldSerializeScale(_scale);
|
|
}
|
|
|
|
private bool ShouldSerializeScale(byte scale) {
|
|
return _hasScale && ((0 != scale) || ShouldSerializePrecision());
|
|
}
|
|
|
|
object ICloneable.Clone() {
|
|
return new OleDbParameter(this);
|
|
}
|
|
|
|
private void CloneHelper(OleDbParameter destination) {
|
|
CloneHelperCore(destination);
|
|
destination._metaType = _metaType;
|
|
destination._parameterName = _parameterName;
|
|
destination._precision = _precision;
|
|
destination._scale = _scale;
|
|
destination._hasScale = _hasScale;
|
|
}
|
|
|
|
private void PropertyChanging() {
|
|
unchecked { _changeID++; }
|
|
}
|
|
|
|
private void PropertyTypeChanging() {
|
|
PropertyChanging();
|
|
_coerceMetaType = null;
|
|
CoercedValue = null;
|
|
}
|
|
|
|
// goal: call virtual property getters only once per parameter
|
|
internal bool BindParameter(int index, Bindings bindings) {
|
|
int changeID = _changeID;
|
|
object value = Value;
|
|
|
|
NativeDBType dbtype = GetBindType(value);
|
|
if (OleDbType.Empty == dbtype.enumOleDbType) {
|
|
throw ODB.UninitializedParameters(index, dbtype.enumOleDbType);
|
|
}
|
|
_coerceMetaType = dbtype;
|
|
value = CoerceValue(value, dbtype);
|
|
CoercedValue = value;
|
|
|
|
ParameterDirection direction = Direction;
|
|
|
|
byte precision;
|
|
if (ShouldSerializePrecision()) {
|
|
precision = PrecisionInternal;
|
|
}
|
|
else {
|
|
precision = ValuePrecision(value);
|
|
}
|
|
if (0 == precision) {
|
|
precision = dbtype.maxpre;
|
|
}
|
|
|
|
byte scale;
|
|
if (ShouldSerializeScale()) {
|
|
scale = ScaleInternal;
|
|
}
|
|
else {
|
|
scale = ValueScale(value);
|
|
}
|
|
|
|
int wtype = dbtype.wType;
|
|
int bytecount, size;
|
|
|
|
if (dbtype.islong) { // long data (image, text, ntext)
|
|
bytecount = ADP.PtrSize;
|
|
if (ShouldSerializeSize()) {
|
|
size = Size;
|
|
}
|
|
else {
|
|
if (NativeDBType.STR == dbtype.dbType) {
|
|
size = Int32.MaxValue; // WebData 98940
|
|
}
|
|
else if (NativeDBType.WSTR == dbtype.dbType) {
|
|
size = Int32.MaxValue/2;
|
|
}
|
|
else {
|
|
size = Int32.MaxValue;
|
|
}
|
|
}
|
|
wtype |= NativeDBType.BYREF;
|
|
}
|
|
else if (dbtype.IsVariableLength) { // variable length data (varbinary, varchar, nvarchar)
|
|
if (!ShouldSerializeSize() && ADP.IsDirection(this, ParameterDirection.Output)) {
|
|
throw ADP.UninitializedParameterSize(index, _coerceMetaType.dataType);
|
|
}
|
|
|
|
bool computedSize;
|
|
if (ShouldSerializeSize()) {
|
|
size = Size;
|
|
computedSize = false;
|
|
}
|
|
else {
|
|
size = ValueSize(value);
|
|
computedSize = true;
|
|
}
|
|
if (0 < size) {
|
|
if (NativeDBType.WSTR == dbtype.wType) {
|
|
// maximum 0x3FFFFFFE characters, computed this way to avoid overflow exception
|
|
bytecount = Math.Min(size, 0x3FFFFFFE) * 2 + 2;
|
|
}
|
|
else {
|
|
Debug.Assert(NativeDBType.STR != dbtype.wType, "should have ANSI binding, describing is okay");
|
|
bytecount = size;
|
|
}
|
|
|
|
if (computedSize) {
|
|
if (NativeDBType.STR == dbtype.dbType) { // WebData 98140
|
|
// maximum 0x7ffffffe characters, computed this way to avoid overflow exception
|
|
size = Math.Min(size, 0x3FFFFFFE) * 2;
|
|
}
|
|
}
|
|
|
|
if (ODB.LargeDataSize < bytecount) {
|
|
bytecount = ADP.PtrSize;
|
|
wtype |= NativeDBType.BYREF;
|
|
}
|
|
}
|
|
else if (0 == size) {
|
|
if (NativeDBType.WSTR == wtype) { // allow space for null termination character
|
|
bytecount = 2;
|
|
// 0 == size, okay for (STR == dbType)
|
|
}
|
|
else {
|
|
Debug.Assert(NativeDBType.STR != dbtype.wType, "should have ANSI binding, describing is okay");
|
|
bytecount = 0;
|
|
}
|
|
}
|
|
else if (-1 == size) {
|
|
bytecount = ADP.PtrSize;
|
|
wtype |= NativeDBType.BYREF;
|
|
}
|
|
else {
|
|
throw ADP.InvalidSizeValue(size);
|
|
}
|
|
}
|
|
else { // fixed length data
|
|
bytecount = dbtype.fixlen;
|
|
size = bytecount;
|
|
}
|
|
bindings.CurrentIndex = index;
|
|
|
|
// tagDBPARAMBINDINFO info for SetParameterInfo
|
|
bindings.DataSourceType = dbtype.dbString.DangerousGetHandle(); // NOTE: This is a constant and isn't exposed publicly, so there really isn't a potential for Handle Recycling.
|
|
bindings.Name = ADP.PtrZero;
|
|
bindings.ParamSize = new IntPtr(size);
|
|
bindings.Flags = GetBindFlags(direction);
|
|
//bindings.Precision = precision;
|
|
//bindings.Scale = scale;
|
|
|
|
// tagDBBINDING info for CreateAccessor
|
|
bindings.Ordinal = (IntPtr)(index+1);
|
|
bindings.Part = dbtype.dbPart;
|
|
bindings.ParamIO = GetBindDirection(direction);
|
|
bindings.Precision = precision;
|
|
bindings.Scale = scale;
|
|
bindings.DbType = wtype;
|
|
bindings.MaxLen = bytecount; // also increments databuffer size (uses DbType)
|
|
//bindings.ValueOffset = bindings.DataBufferSize; // set via MaxLen
|
|
//bindings.LengthOffset = i * sizeof_int64;
|
|
//bindings.StatusOffset = i * sizeof_int64 + sizeof_int32;
|
|
//bindings.TypeInfoPtr = 0;
|
|
//bindings.ObjectPtr = 0;
|
|
//bindings.BindExtPtr = 0;
|
|
//bindings.MemOwner = /*DBMEMOWNER_CLIENTOWNED*/0;
|
|
//bindings.Flags = 0;
|
|
|
|
//bindings.ParameterChangeID = changeID; // bind until something changes
|
|
Debug.Assert(_changeID == changeID, "parameter has unexpectedly changed");
|
|
|
|
if (Bid.AdvancedOn) {
|
|
Bid.Trace("<oledb.struct.tagDBPARAMBINDINFO|INFO|ADV> index=%d, parameterName='%ls'\n", index, ParameterName);//, bindings.BindInfo[index]);
|
|
Bid.Trace("<oledb.struct.tagDBBINDING|INFO|ADV>\n");//, bindings.DBBinding[index]);
|
|
}
|
|
return IsParameterComputed();
|
|
}
|
|
|
|
private static object CoerceValue(object value, NativeDBType destinationType) {
|
|
Debug.Assert(null != destinationType, "null destinationType");
|
|
if ((null != value) && (DBNull.Value != value) && (typeof(object) != destinationType.dataType)) {
|
|
Type currentType = value.GetType();
|
|
if (currentType != destinationType.dataType) {
|
|
try {
|
|
if ((typeof(string) == destinationType.dataType) && (typeof(char[]) == currentType)) {
|
|
}
|
|
else if ((NativeDBType.CY == destinationType.dbType) && (typeof(string) == currentType)) {
|
|
value = Decimal.Parse((string)value, NumberStyles.Currency, (IFormatProvider)null); // WebData 99376
|
|
}
|
|
else {
|
|
value = Convert.ChangeType(value, destinationType.dataType, (IFormatProvider)null);
|
|
}
|
|
}
|
|
catch (Exception e) {
|
|
//
|
|
if (!ADP.IsCatchableExceptionType(e)) {
|
|
throw;
|
|
}
|
|
|
|
throw ADP.ParameterConversionFailed(value, destinationType.dataType, e); // WebData 75433
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
private NativeDBType GetBindType(object value) {
|
|
NativeDBType dbtype = _metaType;
|
|
if (null == dbtype) {
|
|
if (ADP.IsNull(value)) {
|
|
dbtype = OleDb.NativeDBType.Default;
|
|
}
|
|
else {
|
|
dbtype = NativeDBType.FromSystemType(value);
|
|
}
|
|
}
|
|
return dbtype;
|
|
}
|
|
|
|
internal object GetCoercedValue() {
|
|
object value = CoercedValue; // will also be set during binding, will rebind everytime if _metaType not set
|
|
if (null == value) {
|
|
value = CoerceValue(Value, _coerceMetaType);
|
|
CoercedValue = value;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
internal bool IsParameterComputed() {
|
|
NativeDBType metaType = _metaType;
|
|
return ((null == metaType)
|
|
|| (!ShouldSerializeSize() && metaType.IsVariableLength)
|
|
|| ((NativeDBType.DECIMAL == metaType.dbType) || (NativeDBType.NUMERIC == metaType.dbType)
|
|
&& (!ShouldSerializeScale() || !ShouldSerializePrecision())
|
|
)
|
|
); // MDAC 69299
|
|
}
|
|
|
|
// @devnote: use IsParameterComputed which is called in the normal case
|
|
// only to call Prepare to throw the specialized error message
|
|
// reducing the overall number of methods to actually jit
|
|
internal void Prepare(OleDbCommand cmd) { // MDAC 70232
|
|
Debug.Assert(IsParameterComputed(), "Prepare computed parameter");
|
|
if (null == _metaType) {
|
|
throw ADP.PrepareParameterType(cmd);
|
|
}
|
|
else if (!ShouldSerializeSize() && _metaType.IsVariableLength) {
|
|
throw ADP.PrepareParameterSize(cmd);
|
|
}
|
|
else if (!ShouldSerializePrecision() && !ShouldSerializeScale() && ((NativeDBType.DECIMAL == _metaType.wType) || (NativeDBType.NUMERIC == _metaType.wType))) { // MDAC 71441
|
|
throw ADP.PrepareParameterScale(cmd, _metaType.wType.ToString("G", CultureInfo.InvariantCulture));
|
|
}
|
|
|
|
// Disabling the assert, see Dev11 775862 for details: http://vstfdevdiv.redmond.corp.microsoft.com:8080/WorkItemTracking/WorkItem.aspx?artifactMoniker=775862
|
|
// Debug.Assert(false, "OleDbParameter.Prepare didn't throw");
|
|
}
|
|
|
|
[
|
|
RefreshProperties(RefreshProperties.All),
|
|
ResCategoryAttribute(Res.DataCategory_Data),
|
|
ResDescriptionAttribute(Res.DbParameter_Value),
|
|
TypeConverterAttribute(typeof(StringConverter)),
|
|
]
|
|
override public object Value { // V1.2.3300, XXXParameter V1.0.3300
|
|
get {
|
|
return _value;
|
|
}
|
|
set {
|
|
_coercedValue = null;
|
|
_value = value;
|
|
}
|
|
}
|
|
|
|
private byte ValuePrecision(object value) {
|
|
return ValuePrecisionCore(value);
|
|
}
|
|
|
|
private byte ValueScale(object value) {
|
|
return ValueScaleCore(value);
|
|
}
|
|
|
|
private int ValueSize(object value) {
|
|
return ValueSizeCore(value);
|
|
}
|
|
|
|
static private int GetBindDirection(ParameterDirection direction) {
|
|
return (ODB.ParameterDirectionFlag & (int)direction);
|
|
/*switch(Direction) {
|
|
default:
|
|
case ParameterDirection.Input:
|
|
return ODB.DBPARAMIO_INPUT;
|
|
case ParameterDirection.Output:
|
|
case ParameterDirection.ReturnValue:
|
|
return ODB.DBPARAMIO_OUTPUT;
|
|
case ParameterDirection.InputOutput:
|
|
return (ODB.DBPARAMIO_INPUT | ODB.DBPARAMIO_OUTPUT);
|
|
}*/
|
|
}
|
|
|
|
static private int GetBindFlags(ParameterDirection direction) {
|
|
return (ODB.ParameterDirectionFlag & (int)direction);
|
|
/*switch(Direction) {
|
|
default:
|
|
case ParameterDirection.Input:
|
|
return ODB.DBPARAMFLAGS_ISINPUT;
|
|
case ParameterDirection.Output:
|
|
case ParameterDirection.ReturnValue:
|
|
return ODB.DBPARAMFLAGS_ISOUTPUT;
|
|
case ParameterDirection.InputOutput:
|
|
return (ODB.DBPARAMFLAGS_ISINPUT | ODB.DBPARAMFLAGS_ISOUTPUT);
|
|
}*/
|
|
}
|
|
|
|
// implemented as nested class to take advantage of the private/protected ShouldSerializeXXX methods
|
|
sealed internal class OleDbParameterConverter : System.ComponentModel.ExpandableObjectConverter {
|
|
|
|
// converter classes should have public ctor
|
|
public OleDbParameterConverter() {
|
|
}
|
|
|
|
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) {
|
|
if (typeof(System.ComponentModel.Design.Serialization.InstanceDescriptor) == destinationType) {
|
|
return true;
|
|
}
|
|
return base.CanConvertTo(context, destinationType);
|
|
}
|
|
|
|
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) {
|
|
if (null == destinationType) {
|
|
throw ADP.ArgumentNull("destinationType");
|
|
}
|
|
if ((typeof(System.ComponentModel.Design.Serialization.InstanceDescriptor) == destinationType) && (value is OleDbParameter)) {
|
|
return ConvertToInstanceDescriptor(value as OleDbParameter);
|
|
}
|
|
return base.ConvertTo(context, culture, value, destinationType);
|
|
}
|
|
|
|
private System.ComponentModel.Design.Serialization.InstanceDescriptor ConvertToInstanceDescriptor(OleDbParameter p) {
|
|
int flags = 0;
|
|
|
|
if (p.ShouldSerializeOleDbType()) {
|
|
flags |= 1;
|
|
}
|
|
if (p.ShouldSerializeSize()) {
|
|
flags |= 2;
|
|
}
|
|
if (!ADP.IsEmpty(p.SourceColumn)) {
|
|
flags |= 4;
|
|
}
|
|
if (null != p.Value) {
|
|
flags |= 8;
|
|
}
|
|
if ((ParameterDirection.Input != p.Direction) || p.IsNullable
|
|
|| p.ShouldSerializePrecision() || p.ShouldSerializeScale()
|
|
|| (DataRowVersion.Current != p.SourceVersion)) {
|
|
flags |= 16; // V1.0 everything
|
|
}
|
|
if (p.SourceColumnNullMapping) {
|
|
flags |= 32; // v2.0 everything
|
|
}
|
|
|
|
Type[] ctorParams;
|
|
object[] ctorValues;
|
|
switch(flags) {
|
|
case 0: // ParameterName
|
|
case 1: // OleDbType
|
|
ctorParams = new Type[] { typeof(string), typeof(OleDbType) };
|
|
ctorValues = new object[] { p.ParameterName, p.OleDbType };
|
|
break;
|
|
case 2: // Size
|
|
case 3: // Size, OleDbType
|
|
ctorParams = new Type[] { typeof(string), typeof(OleDbType), typeof(int) };
|
|
ctorValues = new object[] { p.ParameterName, p.OleDbType, p.Size };
|
|
break;
|
|
case 4: // SourceColumn
|
|
case 5: // SourceColumn, OleDbType
|
|
case 6: // SourceColumn, Size
|
|
case 7: // SourceColumn, Size, OleDbType
|
|
ctorParams = new Type[] { typeof(string), typeof(OleDbType), typeof(int), typeof(string) };
|
|
ctorValues = new object[] { p.ParameterName, p.OleDbType, p.Size, p.SourceColumn };
|
|
break;
|
|
case 8: // Value
|
|
ctorParams = new Type[] { typeof(string), typeof(object) };
|
|
ctorValues = new object[] { p.ParameterName, p.Value };
|
|
break;
|
|
default: // everything else
|
|
if (0 == (32 & flags)) { // V1.0 everything
|
|
ctorParams = new Type[] {
|
|
typeof(string), typeof(OleDbType), typeof(int), typeof(ParameterDirection),
|
|
typeof(bool), typeof(byte), typeof(byte), typeof(string),
|
|
typeof(DataRowVersion), typeof(object) };
|
|
ctorValues = new object[] {
|
|
p.ParameterName, p.OleDbType, p.Size, p.Direction,
|
|
p.IsNullable, p.PrecisionInternal, p.ScaleInternal, p.SourceColumn,
|
|
p.SourceVersion, p.Value };
|
|
}
|
|
else { // v2.0 everything - round trip all browsable properties + precision/scale
|
|
ctorParams = new Type[] {
|
|
typeof(string), typeof(OleDbType), typeof(int), typeof(ParameterDirection),
|
|
typeof(byte), typeof(byte),
|
|
typeof(string), typeof(DataRowVersion), typeof(bool),
|
|
typeof(object) };
|
|
ctorValues = new object[] {
|
|
p.ParameterName, p.OleDbType, p.Size, p.Direction,
|
|
p.PrecisionInternal, p.ScaleInternal,
|
|
p.SourceColumn, p.SourceVersion, p.SourceColumnNullMapping,
|
|
p.Value };
|
|
}
|
|
break;
|
|
}
|
|
System.Reflection.ConstructorInfo ctor = typeof(OleDbParameter).GetConstructor(ctorParams);
|
|
return new System.ComponentModel.Design.Serialization.InstanceDescriptor(ctor, ctorValues);
|
|
}
|
|
}
|
|
}
|
|
}
|