/// <summary>
/// Execute the procedure synchronously and return the result.
/// This call will use the connection's DefaultCommandTimeout to control execution. Use overloaded methods to
/// specify a custom timeout value.
/// </summary>
/// <param name="parameter1">Value of parameter 1.</param>
/// <param name="parameter2">Value of parameter 2.</param>
/// <param name="parameter3">Value of parameter 3.</param>
/// <param name="parameter4">Value of parameter 4.</param>
/// <param name="parameter5">Value of parameter 5.</param>
/// <param name="parameter6">Value of parameter 6.</param>
/// <param name="parameter7">Value of parameter 7.</param>
/// <param name="parameter8">Value of parameter 8.</param>
/// <returns>Result of the procedure call</returns>
public Response <TResult> Execute(T1 parameter1, T2 parameter2, T3 parameter3, T4 parameter4, T5 parameter5, T6 parameter6, T7 parameter7, T8 parameter8)
{
return(this.Executor.Execute <TResult>(this.CommandTimeout, this.Name, this.NameUtf8Bytes, VoltType.CoalesceNull(parameter1), VoltType.CoalesceNull(parameter2), VoltType.CoalesceNull(parameter3), VoltType.CoalesceNull(parameter4), VoltType.CoalesceNull(parameter5), VoltType.CoalesceNull(parameter6), VoltType.CoalesceNull(parameter7), VoltType.CoalesceNull(parameter8)));
}
/// <summary>
/// Execute the procedure asynchronously and return an AsyncResponse that can be used to abort execution
/// before it completes (using the Cancel method on the object itself). This call will use the connection's
/// DefaultCommandTimeout to control execution. Use overloaded methods to specify a custom timeout value.
/// Upon completion of the call (Success, failure, timeout or cancellation), the wrapper's Callback method will
/// be called with the resulting Response object.
/// </summary>
/// <param name="parameter1">Value of parameter 1.</param>
/// <param name="parameter2">Value of parameter 2.</param>
/// <param name="parameter3">Value of parameter 3.</param>
/// <param name="parameter4">Value of parameter 4.</param>
/// <param name="parameter5">Value of parameter 5.</param>
/// <param name="parameter6">Value of parameter 6.</param>
/// <param name="parameter7">Value of parameter 7.</param>
/// <param name="parameter8">Value of parameter 8.</param>
/// <param name="callback">Execution callback (overrides any default provided when the wraper was
/// created).</param>
/// <param name="state">A user-defined state object to be passed to your callback through the Response's
/// .AsyncState property</param>
/// <returns>AsyncResponse with which the caller may later cancel the execution</returns>
public IAsyncResult BeginExecute(T1 parameter1, T2 parameter2, T3 parameter3, T4 parameter4, T5 parameter5, T6 parameter6, T7 parameter7, T8 parameter8, ExecuteAsyncCallback <TResult> callback, object state)
{
return(this.Executor.BeginExecute <TResult>(callback, state, this.CommandTimeout, this.Name, this.NameUtf8Bytes, VoltType.CoalesceNull(parameter1), VoltType.CoalesceNull(parameter2), VoltType.CoalesceNull(parameter3), VoltType.CoalesceNull(parameter4), VoltType.CoalesceNull(parameter5), VoltType.CoalesceNull(parameter6), VoltType.CoalesceNull(parameter7), VoltType.CoalesceNull(parameter8)));
}
/// <summary>
/// Execute the procedure synchronously and return the result.
/// This call will use the connection's DefaultCommandTimeout to control execution. Use overloaded methods to
/// specify a custom timeout value. Convenience TryMethod-style execution: the method wraps the underlying
/// call into a try/catch block so you don't have to and will return false in case of failure.
/// </summary>
/// <remarks>You will ONLY get an exception in case the connection dies on you. Actual execution errors (such
/// as a constraint violation while executing a procedure on the server) are packaged into the response object.
/// While you may prefer this method to writing your own try/catch block, you should keep in mind that a
/// failure prior to actually shipping out the request to the server usually means your application is in no
/// suitable shape to function; your catch or if(!proc.Exec(...)) block will have to adequately deal with the
/// situation.
/// </remarks>
/// <param name="parameter1">Value of parameter 1.</param>
/// <param name="parameter2">Value of parameter 2.</param>
/// <param name="parameter3">Value of parameter 3.</param>
/// <param name="parameter4">Value of parameter 4.</param>
/// <param name="parameter5">Value of parameter 5.</param>
/// <param name="parameter6">Value of parameter 6.</param>
/// <param name="parameter7">Value of parameter 7.</param>
/// <param name="parameter8">Value of parameter 8.</param>
/// <param name="response">Result of the procedure call</param>
/// <returns>True if the execution was successfully posted, false otherwise (will only happen if the connection died on you)</returns>
public bool TryExecute(T1 parameter1, T2 parameter2, T3 parameter3, T4 parameter4, T5 parameter5, T6 parameter6, T7 parameter7, T8 parameter8, out Response <TResult> response)
{
try
{
response = this.Executor.Execute <TResult>(this.CommandTimeout, this.Name, this.NameUtf8Bytes, VoltType.CoalesceNull(parameter1), VoltType.CoalesceNull(parameter2), VoltType.CoalesceNull(parameter3), VoltType.CoalesceNull(parameter4), VoltType.CoalesceNull(parameter5), VoltType.CoalesceNull(parameter6), VoltType.CoalesceNull(parameter7), VoltType.CoalesceNull(parameter8));
return(true);
}
catch { response = null; }
return(false);
}
/// <summary>
/// Execute the procedure asynchronously and return an AsyncResponse that can be used to abort execution
/// before it completes (using the Cancel method on the object itself). This call will use the connection's
/// DefaultCommandTimeout to control execution. Use overloaded methods to specify a custom timeout value.
/// Upon completion of the call (Success, failure, timeout or cancellation), the wrapper's Callback method will
/// be called with the resulting Response object.
/// </summary>
/// <param name="parameter1">Value of parameter 1.</param>
/// <param name="parameter2">Value of parameter 2.</param>
/// <param name="parameter3">Value of parameter 3.</param>
/// <param name="parameter4">Value of parameter 4.</param>
/// <param name="parameter5">Value of parameter 5.</param>
/// <param name="parameter6">Value of parameter 6.</param>
/// <param name="parameter7">Value of parameter 7.</param>
/// <returns>AsyncResponse with which the caller may later cancel the execution</returns>
public IAsyncResult BeginExecute(T1 parameter1, T2 parameter2, T3 parameter3, T4 parameter4, T5 parameter5, T6 parameter6, T7 parameter7)
{
return(this.Executor.BeginExecute <TResult>(this.Callback, null, this.CommandTimeout, this.Name, this.NameUtf8Bytes, VoltType.CoalesceNull(parameter1), VoltType.CoalesceNull(parameter2), VoltType.CoalesceNull(parameter3), VoltType.CoalesceNull(parameter4), VoltType.CoalesceNull(parameter5), VoltType.CoalesceNull(parameter6), VoltType.CoalesceNull(parameter7)));
}
/// <summary>
/// Instantiate a strongly-typed Table Wrapper around the given generic Table.
/// </summary>
/// <param name="table">The table to build the wrapper for.</param>
internal Table(Table table)
{
// Validate column count.
if (table.ColumnCount != 17)
{
throw new VoltInvalidDataException(Resources.InvalidColumnCount, table.ColumnCount);
}
// Validate column data types.
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(0)) == (typeof(T1))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(0)).ToString()
, typeof(T1).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(1)) == (typeof(T2))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(1)).ToString()
, typeof(T2).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(2)) == (typeof(T3))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(2)).ToString()
, typeof(T3).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(3)) == (typeof(T4))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(3)).ToString()
, typeof(T4).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(4)) == (typeof(T5))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(4)).ToString()
, typeof(T5).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(5)) == (typeof(T6))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(5)).ToString()
, typeof(T6).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(6)) == (typeof(T7))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(6)).ToString()
, typeof(T7).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(7)) == (typeof(T8))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(7)).ToString()
, typeof(T8).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(8)) == (typeof(T9))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(8)).ToString()
, typeof(T9).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(9)) == (typeof(T10))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(9)).ToString()
, typeof(T10).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(10)) == (typeof(T11))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(10)).ToString()
, typeof(T11).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(11)) == (typeof(T12))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(11)).ToString()
, typeof(T12).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(12)) == (typeof(T13))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(12)).ToString()
, typeof(T13).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(13)) == (typeof(T14))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(13)).ToString()
, typeof(T14).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(14)) == (typeof(T15))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(14)).ToString()
, typeof(T15).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(15)) == (typeof(T16))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(15)).ToString()
, typeof(T16).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(16)) == (typeof(T17))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(16)).ToString()
, typeof(T17).ToString()
);
}
// Validation complete, keep a reference to the raw table.
this.RawTable = table;
// Attach the enumerable row collection.
this._Rows = new RowCollection <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(this);
}
/// <summary>
/// Execute the procedure synchronously and return the result.
/// This call will use the connection's DefaultCommandTimeout to control execution. Use overloaded methods to
/// specify a custom timeout value. Convenience TryMethod-style execution: the method wraps the underlying
/// call into a try/catch block so you don't have to and will return false in case of failure.
/// </summary>
/// <remarks>You will ONLY get an exception in case the connection dies on you. Actual execution errors (such
/// as a constraint violation while executing a procedure on the server) are packaged into the response object.
/// While you may prefer this method to writing your own try/catch block, you should keep in mind that a
/// failure prior to actually shipping out the request to the server usually means your application is in no
/// suitable shape to function; your catch or if(!proc.Exec(...)) block will have to adequately deal with the
/// situation.
/// </remarks>
/// <param name="parameter1">Value of parameter 1.</param>
/// <param name="parameter2">Value of parameter 2.</param>
/// <param name="parameter3">Value of parameter 3.</param>
/// <param name="parameter4">Value of parameter 4.</param>
/// <param name="parameter5">Value of parameter 5.</param>
/// <param name="parameter6">Value of parameter 6.</param>
/// <param name="parameter7">Value of parameter 7.</param>
/// <param name="parameter8">Value of parameter 8.</param>
/// <param name="parameter9">Value of parameter 9.</param>
/// <param name="parameter10">Value of parameter 10.</param>
/// <param name="parameter11">Value of parameter 11.</param>
/// <param name="parameter12">Value of parameter 12.</param>
/// <param name="parameter13">Value of parameter 13.</param>
/// <param name="parameter14">Value of parameter 14.</param>
/// <param name="parameter15">Value of parameter 15.</param>
/// <param name="parameter16">Value of parameter 16.</param>
/// <param name="parameter17">Value of parameter 17.</param>
/// <param name="parameter18">Value of parameter 18.</param>
/// <param name="parameter19">Value of parameter 19.</param>
/// <param name="response">Result of the procedure call</param>
/// <returns>True if the execution was successfully posted, false otherwise (will only happen if the connection died on you)</returns>
public bool TryExecute(T1 parameter1, T2 parameter2, T3 parameter3, T4 parameter4, T5 parameter5, T6 parameter6, T7 parameter7, T8 parameter8, T9 parameter9, T10 parameter10, T11 parameter11, T12 parameter12, T13 parameter13, T14 parameter14, T15 parameter15, T16 parameter16, T17 parameter17, T18 parameter18, T19 parameter19, out Response <TResult> response)
{
try
{
response = this.Executor.Execute <TResult>(this.CommandTimeout, this.Name, this.NameUtf8Bytes, VoltType.CoalesceNull(parameter1), VoltType.CoalesceNull(parameter2), VoltType.CoalesceNull(parameter3), VoltType.CoalesceNull(parameter4), VoltType.CoalesceNull(parameter5), VoltType.CoalesceNull(parameter6), VoltType.CoalesceNull(parameter7), VoltType.CoalesceNull(parameter8), VoltType.CoalesceNull(parameter9), VoltType.CoalesceNull(parameter10), VoltType.CoalesceNull(parameter11), VoltType.CoalesceNull(parameter12), VoltType.CoalesceNull(parameter13), VoltType.CoalesceNull(parameter14), VoltType.CoalesceNull(parameter15), VoltType.CoalesceNull(parameter16), VoltType.CoalesceNull(parameter17), VoltType.CoalesceNull(parameter18), VoltType.CoalesceNull(parameter19));
return(true);
}
catch { response = null; }
return(false);
}
/// <summary>
/// Execute the procedure synchronously and return the result.
/// This call will use the connection's DefaultCommandTimeout to control execution. Use overloaded methods to
/// specify a custom timeout value.
/// </summary>
/// <param name="parameter1">Value of parameter 1.</param>
/// <param name="parameter2">Value of parameter 2.</param>
/// <param name="parameter3">Value of parameter 3.</param>
/// <param name="parameter4">Value of parameter 4.</param>
/// <param name="parameter5">Value of parameter 5.</param>
/// <param name="parameter6">Value of parameter 6.</param>
/// <param name="parameter7">Value of parameter 7.</param>
/// <param name="parameter8">Value of parameter 8.</param>
/// <param name="parameter9">Value of parameter 9.</param>
/// <param name="parameter10">Value of parameter 10.</param>
/// <param name="parameter11">Value of parameter 11.</param>
/// <param name="parameter12">Value of parameter 12.</param>
/// <param name="parameter13">Value of parameter 13.</param>
/// <param name="parameter14">Value of parameter 14.</param>
/// <param name="parameter15">Value of parameter 15.</param>
/// <param name="parameter16">Value of parameter 16.</param>
/// <param name="parameter17">Value of parameter 17.</param>
/// <param name="parameter18">Value of parameter 18.</param>
/// <param name="parameter19">Value of parameter 19.</param>
/// <returns>Result of the procedure call</returns>
public Response <TResult> Execute(T1 parameter1, T2 parameter2, T3 parameter3, T4 parameter4, T5 parameter5, T6 parameter6, T7 parameter7, T8 parameter8, T9 parameter9, T10 parameter10, T11 parameter11, T12 parameter12, T13 parameter13, T14 parameter14, T15 parameter15, T16 parameter16, T17 parameter17, T18 parameter18, T19 parameter19)
{
return(this.Executor.Execute <TResult>(this.CommandTimeout, this.Name, this.NameUtf8Bytes, VoltType.CoalesceNull(parameter1), VoltType.CoalesceNull(parameter2), VoltType.CoalesceNull(parameter3), VoltType.CoalesceNull(parameter4), VoltType.CoalesceNull(parameter5), VoltType.CoalesceNull(parameter6), VoltType.CoalesceNull(parameter7), VoltType.CoalesceNull(parameter8), VoltType.CoalesceNull(parameter9), VoltType.CoalesceNull(parameter10), VoltType.CoalesceNull(parameter11), VoltType.CoalesceNull(parameter12), VoltType.CoalesceNull(parameter13), VoltType.CoalesceNull(parameter14), VoltType.CoalesceNull(parameter15), VoltType.CoalesceNull(parameter16), VoltType.CoalesceNull(parameter17), VoltType.CoalesceNull(parameter18), VoltType.CoalesceNull(parameter19)));
}
/// <summary>
/// Instantiate a strongly-typed Table Wrapper around the given generic Table.
/// </summary>
/// <param name="table">The single-row table to build the wrapper for.</param>
internal SingleRowTable(SingleRowTable table)
{
// Validate column count.
if (table.ColumnCount != 9)
{
throw new VoltInvalidDataException(Resources.InvalidColumnCount, table.ColumnCount);
}
// Validate column data types.
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(0)) == (typeof(T1))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(0)).ToString()
, typeof(T1).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(1)) == (typeof(T2))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(1)).ToString()
, typeof(T2).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(2)) == (typeof(T3))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(2)).ToString()
, typeof(T3).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(3)) == (typeof(T4))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(3)).ToString()
, typeof(T4).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(4)) == (typeof(T5))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(4)).ToString()
, typeof(T5).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(5)) == (typeof(T6))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(5)).ToString()
, typeof(T6).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(6)) == (typeof(T7))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(6)).ToString()
, typeof(T7).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(7)) == (typeof(T8))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(7)).ToString()
, typeof(T8).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(8)) == (typeof(T9))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(8)).ToString()
, typeof(T9).ToString()
);
}
// Validation complete, keep a reference to the raw table.
this.RawTable = table;
}
/// <summary>
/// Execute the procedure asynchronously and return an AsyncResponse that can be used to abort execution
/// before it completes (using the Cancel method on the object itself). This call will use the connection's
/// DefaultCommandTimeout to control execution. Use overloaded methods to specify a custom timeout value.
/// Upon completion of the call (Success, failure, timeout or cancellation), the wrapper's Callback method will
/// be called with the resulting Response object.
/// </summary>
/// <param name="parameter1">Value of parameter 1.</param>
/// <param name="parameter2">Value of parameter 2.</param>
/// <param name="parameter3">Value of parameter 3.</param>
/// <param name="parameter4">Value of parameter 4.</param>
/// <param name="parameter5">Value of parameter 5.</param>
/// <param name="parameter6">Value of parameter 6.</param>
/// <param name="parameter7">Value of parameter 7.</param>
/// <param name="parameter8">Value of parameter 8.</param>
/// <param name="parameter9">Value of parameter 9.</param>
/// <param name="parameter10">Value of parameter 10.</param>
/// <param name="parameter11">Value of parameter 11.</param>
/// <param name="parameter12">Value of parameter 12.</param>
/// <param name="parameter13">Value of parameter 13.</param>
/// <param name="parameter14">Value of parameter 14.</param>
/// <param name="parameter15">Value of parameter 15.</param>
/// <param name="parameter16">Value of parameter 16.</param>
/// <param name="parameter17">Value of parameter 17.</param>
/// <param name="parameter18">Value of parameter 18.</param>
/// <param name="parameter19">Value of parameter 19.</param>
/// <param name="callback">Execution callback (overrides any default provided when the wraper was
/// created).</param>
/// <param name="state">A user-defined state object to be passed to your callback through the Response's
/// .AsyncState property</param>
/// <returns>AsyncResponse with which the caller may later cancel the execution</returns>
public IAsyncResult BeginExecute(T1 parameter1, T2 parameter2, T3 parameter3, T4 parameter4, T5 parameter5, T6 parameter6, T7 parameter7, T8 parameter8, T9 parameter9, T10 parameter10, T11 parameter11, T12 parameter12, T13 parameter13, T14 parameter14, T15 parameter15, T16 parameter16, T17 parameter17, T18 parameter18, T19 parameter19, ExecuteAsyncCallback <TResult> callback, object state)
{
return(this.Executor.BeginExecute <TResult>(callback, state, this.CommandTimeout, this.Name, this.NameUtf8Bytes, VoltType.CoalesceNull(parameter1), VoltType.CoalesceNull(parameter2), VoltType.CoalesceNull(parameter3), VoltType.CoalesceNull(parameter4), VoltType.CoalesceNull(parameter5), VoltType.CoalesceNull(parameter6), VoltType.CoalesceNull(parameter7), VoltType.CoalesceNull(parameter8), VoltType.CoalesceNull(parameter9), VoltType.CoalesceNull(parameter10), VoltType.CoalesceNull(parameter11), VoltType.CoalesceNull(parameter12), VoltType.CoalesceNull(parameter13), VoltType.CoalesceNull(parameter14), VoltType.CoalesceNull(parameter15), VoltType.CoalesceNull(parameter16), VoltType.CoalesceNull(parameter17), VoltType.CoalesceNull(parameter18), VoltType.CoalesceNull(parameter19)));
}
/// <summary>
/// Execute the procedure asynchronously and return an AsyncResponse that can be used to abort execution
/// before it completes (using the Cancel method on the object itself). This call will use the connection's
/// DefaultCommandTimeout to control execution. Use overloaded methods to specify a custom timeout value.
/// Upon completion of the call (Success, failure, timeout or cancellation), the wrapper's Callback method will
/// be called with the resulting Response object.
/// </summary>
/// <param name="parameter1">Value of parameter 1.</param>
/// <param name="parameter2">Value of parameter 2.</param>
/// <param name="parameter3">Value of parameter 3.</param>
/// <param name="parameter4">Value of parameter 4.</param>
/// <param name="parameter5">Value of parameter 5.</param>
/// <param name="parameter6">Value of parameter 6.</param>
/// <param name="parameter7">Value of parameter 7.</param>
/// <param name="parameter8">Value of parameter 8.</param>
/// <param name="parameter9">Value of parameter 9.</param>
/// <param name="parameter10">Value of parameter 10.</param>
/// <param name="parameter11">Value of parameter 11.</param>
/// <param name="parameter12">Value of parameter 12.</param>
/// <param name="parameter13">Value of parameter 13.</param>
/// <param name="parameter14">Value of parameter 14.</param>
/// <returns>AsyncResponse with which the caller may later cancel the execution</returns>
public IAsyncResult BeginExecute(T1 parameter1, T2 parameter2, T3 parameter3, T4 parameter4, T5 parameter5, T6 parameter6, T7 parameter7, T8 parameter8, T9 parameter9, T10 parameter10, T11 parameter11, T12 parameter12, T13 parameter13, T14 parameter14)
{
return(this.Executor.BeginExecute <TResult>(this.Callback, null, this.CommandTimeout, this.Name, this.NameUtf8Bytes, VoltType.CoalesceNull(parameter1), VoltType.CoalesceNull(parameter2), VoltType.CoalesceNull(parameter3), VoltType.CoalesceNull(parameter4), VoltType.CoalesceNull(parameter5), VoltType.CoalesceNull(parameter6), VoltType.CoalesceNull(parameter7), VoltType.CoalesceNull(parameter8), VoltType.CoalesceNull(parameter9), VoltType.CoalesceNull(parameter10), VoltType.CoalesceNull(parameter11), VoltType.CoalesceNull(parameter12), VoltType.CoalesceNull(parameter13), VoltType.CoalesceNull(parameter14)));
}
/// <summary>
/// Execute the procedure asynchronously and return an AsyncResponse that can be used to abort execution
/// before it completes (using the Cancel method on the object itself). This call will use the connection's
/// DefaultCommandTimeout to control execution. Use overloaded methods to specify a custom timeout value.
/// Upon completion of the call (Success, failure, timeout or cancellation), the wrapper's Callback method will
/// be called with the resulting Response object.
/// </summary>
/// <param name="parameter1">Value of parameter 1.</param>
/// <param name="parameter2">Value of parameter 2.</param>
/// <param name="parameter3">Value of parameter 3.</param>
/// <param name="parameter4">Value of parameter 4.</param>
/// <param name="parameter5">Value of parameter 5.</param>
/// <param name="parameter6">Value of parameter 6.</param>
/// <param name="parameter7">Value of parameter 7.</param>
/// <param name="parameter8">Value of parameter 8.</param>
/// <param name="parameter9">Value of parameter 9.</param>
/// <param name="parameter10">Value of parameter 10.</param>
/// <param name="parameter11">Value of parameter 11.</param>
/// <param name="parameter12">Value of parameter 12.</param>
/// <param name="parameter13">Value of parameter 13.</param>
/// <param name="parameter14">Value of parameter 14.</param>
/// <param name="parameter15">Value of parameter 15.</param>
/// <param name="parameter16">Value of parameter 16.</param>
/// <param name="parameter17">Value of parameter 17.</param>
/// <param name="parameter18">Value of parameter 18.</param>
/// <param name="parameter19">Value of parameter 19.</param>
/// <param name="parameter20">Value of parameter 20.</param>
/// <param name="parameter21">Value of parameter 21.</param>
/// <param name="parameter22">Value of parameter 22.</param>
/// <param name="parameter23">Value of parameter 23.</param>
/// <param name="parameter24">Value of parameter 24.</param>
/// <param name="parameter25">Value of parameter 25.</param>
/// <param name="parameter26">Value of parameter 26.</param>
/// <param name="parameter27">Value of parameter 27.</param>
/// <param name="parameter28">Value of parameter 28.</param>
/// <param name="parameter29">Value of parameter 29.</param>
/// <param name="parameter30">Value of parameter 30.</param>
/// <param name="state">A user-defined state object to be passed to your callback through the Response's
/// .AsyncState property</param>
/// <returns>AsyncResponse with which the caller may later cancel the execution</returns>
public IAsyncResult BeginExecute(T1 parameter1, T2 parameter2, T3 parameter3, T4 parameter4, T5 parameter5, T6 parameter6, T7 parameter7, T8 parameter8, T9 parameter9, T10 parameter10, T11 parameter11, T12 parameter12, T13 parameter13, T14 parameter14, T15 parameter15, T16 parameter16, T17 parameter17, T18 parameter18, T19 parameter19, T20 parameter20, T21 parameter21, T22 parameter22, T23 parameter23, T24 parameter24, T25 parameter25, T26 parameter26, T27 parameter27, T28 parameter28, T29 parameter29, T30 parameter30, object state)
{
return(this.Executor.BeginExecute <TResult>(this.Callback, state, this.CommandTimeout, this.Name, this.NameUtf8Bytes, VoltType.CoalesceNull(parameter1), VoltType.CoalesceNull(parameter2), VoltType.CoalesceNull(parameter3), VoltType.CoalesceNull(parameter4), VoltType.CoalesceNull(parameter5), VoltType.CoalesceNull(parameter6), VoltType.CoalesceNull(parameter7), VoltType.CoalesceNull(parameter8), VoltType.CoalesceNull(parameter9), VoltType.CoalesceNull(parameter10), VoltType.CoalesceNull(parameter11), VoltType.CoalesceNull(parameter12), VoltType.CoalesceNull(parameter13), VoltType.CoalesceNull(parameter14), VoltType.CoalesceNull(parameter15), VoltType.CoalesceNull(parameter16), VoltType.CoalesceNull(parameter17), VoltType.CoalesceNull(parameter18), VoltType.CoalesceNull(parameter19), VoltType.CoalesceNull(parameter20), VoltType.CoalesceNull(parameter21), VoltType.CoalesceNull(parameter22), VoltType.CoalesceNull(parameter23), VoltType.CoalesceNull(parameter24), VoltType.CoalesceNull(parameter25), VoltType.CoalesceNull(parameter26), VoltType.CoalesceNull(parameter27), VoltType.CoalesceNull(parameter28), VoltType.CoalesceNull(parameter29), VoltType.CoalesceNull(parameter30)));
}
/// <summary>
/// Execute the procedure asynchronously and return an AsyncResponse that can be used to abort execution
/// before it completes (using the Cancel method on the object itself). This call will use the connection's
/// DefaultCommandTimeout to control execution. Use overloaded methods to specify a custom timeout value.
/// Upon completion of the call (Success, failure, timeout or cancellation), the wrapper's Callback method will
/// be called with the resulting Response object.
/// </summary>
/// <param name="parameter1">Value of parameter 1.</param>
/// <param name="state">A user-defined state object to be passed to your callback through the Response's
/// .AsyncState property</param>
/// <returns>AsyncResponse with which the caller may later cancel the execution</returns>
public IAsyncResult BeginExecute(T1 parameter1, object state)
{
return(this.Executor.BeginExecute <TResult>(this.Callback, state, this.CommandTimeout, this.Name, this.NameUtf8Bytes, VoltType.CoalesceNull(parameter1)));
}
/// <summary>
/// Execute the procedure synchronously and return the result.
/// This call will use the connection's DefaultCommandTimeout to control execution. Use overloaded methods to
/// specify a custom timeout value.
/// </summary>
/// <param name="parameter1">Value of parameter 1.</param>
/// <returns>Result of the procedure call</returns>
public Response <TResult> Execute(T1 parameter1)
{
return(this.Executor.Execute <TResult>(this.CommandTimeout, this.Name, this.NameUtf8Bytes, VoltType.CoalesceNull(parameter1)));
}
/// <summary>
/// Execute the procedure synchronously and return the result.
/// This call will use the connection's DefaultCommandTimeout to control execution. Use overloaded methods to
/// specify a custom timeout value. Convenience TryMethod-style execution: the method wraps the underlying
/// call into a try/catch block so you don't have to and will return false in case of failure.
/// </summary>
/// <remarks>You will ONLY get an exception in case the connection dies on you. Actual execution errors (such
/// as a constraint violation while executing a procedure on the server) are packaged into the response object.
/// While you may prefer this method to writing your own try/catch block, you should keep in mind that a
/// failure prior to actually shipping out the request to the server usually means your application is in no
/// suitable shape to function; your catch or if(!proc.Exec(...)) block will have to adequately deal with the
/// situation.
/// </remarks>
/// <param name="parameter1">Value of parameter 1.</param>
/// <param name="response">Result of the procedure call</param>
/// <returns>True if the execution was successfully posted, false otherwise (will only happen if the connection died on you)</returns>
public bool TryExecute(T1 parameter1, out Response <TResult> response)
{
try
{
response = this.Executor.Execute <TResult>(this.CommandTimeout, this.Name, this.NameUtf8Bytes, VoltType.CoalesceNull(parameter1));
return(true);
}
catch { response = null; }
return(false);
}
/// <summary>
/// Instantiate a strongly-typed Table Wrapper around the given generic Table.
/// </summary>
/// <param name="table">The single-row table to build the wrapper for.</param>
internal SingleRowTable(SingleRowTable table)
{
// Validate column count.
if (table.ColumnCount != 31)
{
throw new VoltInvalidDataException(Resources.InvalidColumnCount, table.ColumnCount);
}
// Validate column data types.
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(0)) == (typeof(T1))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(0)).ToString()
, typeof(T1).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(1)) == (typeof(T2))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(1)).ToString()
, typeof(T2).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(2)) == (typeof(T3))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(2)).ToString()
, typeof(T3).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(3)) == (typeof(T4))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(3)).ToString()
, typeof(T4).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(4)) == (typeof(T5))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(4)).ToString()
, typeof(T5).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(5)) == (typeof(T6))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(5)).ToString()
, typeof(T6).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(6)) == (typeof(T7))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(6)).ToString()
, typeof(T7).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(7)) == (typeof(T8))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(7)).ToString()
, typeof(T8).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(8)) == (typeof(T9))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(8)).ToString()
, typeof(T9).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(9)) == (typeof(T10))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(9)).ToString()
, typeof(T10).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(10)) == (typeof(T11))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(10)).ToString()
, typeof(T11).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(11)) == (typeof(T12))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(11)).ToString()
, typeof(T12).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(12)) == (typeof(T13))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(12)).ToString()
, typeof(T13).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(13)) == (typeof(T14))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(13)).ToString()
, typeof(T14).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(14)) == (typeof(T15))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(14)).ToString()
, typeof(T15).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(15)) == (typeof(T16))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(15)).ToString()
, typeof(T16).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(16)) == (typeof(T17))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(16)).ToString()
, typeof(T17).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(17)) == (typeof(T18))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(17)).ToString()
, typeof(T18).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(18)) == (typeof(T19))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(18)).ToString()
, typeof(T19).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(19)) == (typeof(T20))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(19)).ToString()
, typeof(T20).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(20)) == (typeof(T21))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(20)).ToString()
, typeof(T21).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(21)) == (typeof(T22))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(21)).ToString()
, typeof(T22).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(22)) == (typeof(T23))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(22)).ToString()
, typeof(T23).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(23)) == (typeof(T24))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(23)).ToString()
, typeof(T24).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(24)) == (typeof(T25))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(24)).ToString()
, typeof(T25).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(25)) == (typeof(T26))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(25)).ToString()
, typeof(T26).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(26)) == (typeof(T27))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(26)).ToString()
, typeof(T27).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(27)) == (typeof(T28))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(27)).ToString()
, typeof(T28).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(28)) == (typeof(T29))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(28)).ToString()
, typeof(T29).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(29)) == (typeof(T30))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(29)).ToString()
, typeof(T30).ToString()
);
}
if (!(VoltType.ToDefaultNetType(table.GetColumnDBType(30)) == (typeof(T31))))
{
throw new VoltInvalidCastException(
Resources.InvalidCastException
, VoltType.ToDefaultNetType(table.GetColumnDBType(30)).ToString()
, typeof(T31).ToString()
);
}
// Validation complete, keep a reference to the raw table.
this.RawTable = table;
}
/// <summary>
/// Execute the procedure synchronously and return the result.
/// This call will use the connection's DefaultCommandTimeout to control execution. Use overloaded methods to
/// specify a custom timeout value. Convenience TryMethod-style execution: the method wraps the underlying
/// call into a try/catch block so you don't have to and will return false in case of failure.
/// </summary>
/// <remarks>You will ONLY get an exception in case the connection dies on you. Actual execution errors (such
/// as a constraint violation while executing a procedure on the server) are packaged into the response object.
/// While you may prefer this method to writing your own try/catch block, you should keep in mind that a
/// failure prior to actually shipping out the request to the server usually means your application is in no
/// suitable shape to function; your catch or if(!proc.Exec(...)) block will have to adequately deal with the
/// situation.
/// </remarks>
/// <param name="parameter1">Value of parameter 1.</param>
/// <param name="parameter2">Value of parameter 2.</param>
/// <param name="parameter3">Value of parameter 3.</param>
/// <param name="parameter4">Value of parameter 4.</param>
/// <param name="parameter5">Value of parameter 5.</param>
/// <param name="parameter6">Value of parameter 6.</param>
/// <param name="parameter7">Value of parameter 7.</param>
/// <param name="parameter8">Value of parameter 8.</param>
/// <param name="parameter9">Value of parameter 9.</param>
/// <param name="parameter10">Value of parameter 10.</param>
/// <param name="parameter11">Value of parameter 11.</param>
/// <param name="parameter12">Value of parameter 12.</param>
/// <param name="parameter13">Value of parameter 13.</param>
/// <param name="parameter14">Value of parameter 14.</param>
/// <param name="parameter15">Value of parameter 15.</param>
/// <param name="parameter16">Value of parameter 16.</param>
/// <param name="parameter17">Value of parameter 17.</param>
/// <param name="parameter18">Value of parameter 18.</param>
/// <param name="parameter19">Value of parameter 19.</param>
/// <param name="parameter20">Value of parameter 20.</param>
/// <param name="parameter21">Value of parameter 21.</param>
/// <param name="parameter22">Value of parameter 22.</param>
/// <param name="parameter23">Value of parameter 23.</param>
/// <param name="parameter24">Value of parameter 24.</param>
/// <param name="parameter25">Value of parameter 25.</param>
/// <param name="parameter26">Value of parameter 26.</param>
/// <param name="parameter27">Value of parameter 27.</param>
/// <param name="parameter28">Value of parameter 28.</param>
/// <param name="parameter29">Value of parameter 29.</param>
/// <param name="parameter30">Value of parameter 30.</param>
/// <param name="parameter31">Value of parameter 31.</param>
/// <param name="parameter32">Value of parameter 32.</param>
/// <param name="parameter33">Value of parameter 33.</param>
/// <param name="parameter34">Value of parameter 34.</param>
/// <param name="parameter35">Value of parameter 35.</param>
/// <param name="response">Result of the procedure call</param>
/// <returns>True if the execution was successfully posted, false otherwise (will only happen if the connection died on you)</returns>
public bool TryExecute(T1 parameter1, T2 parameter2, T3 parameter3, T4 parameter4, T5 parameter5, T6 parameter6, T7 parameter7, T8 parameter8, T9 parameter9, T10 parameter10, T11 parameter11, T12 parameter12, T13 parameter13, T14 parameter14, T15 parameter15, T16 parameter16, T17 parameter17, T18 parameter18, T19 parameter19, T20 parameter20, T21 parameter21, T22 parameter22, T23 parameter23, T24 parameter24, T25 parameter25, T26 parameter26, T27 parameter27, T28 parameter28, T29 parameter29, T30 parameter30, T31 parameter31, T32 parameter32, T33 parameter33, T34 parameter34, T35 parameter35, out Response <TResult> response)
{
try
{
response = this.Executor.Execute <TResult>(this.CommandTimeout, this.Name, this.NameUtf8Bytes, VoltType.CoalesceNull(parameter1), VoltType.CoalesceNull(parameter2), VoltType.CoalesceNull(parameter3), VoltType.CoalesceNull(parameter4), VoltType.CoalesceNull(parameter5), VoltType.CoalesceNull(parameter6), VoltType.CoalesceNull(parameter7), VoltType.CoalesceNull(parameter8), VoltType.CoalesceNull(parameter9), VoltType.CoalesceNull(parameter10), VoltType.CoalesceNull(parameter11), VoltType.CoalesceNull(parameter12), VoltType.CoalesceNull(parameter13), VoltType.CoalesceNull(parameter14), VoltType.CoalesceNull(parameter15), VoltType.CoalesceNull(parameter16), VoltType.CoalesceNull(parameter17), VoltType.CoalesceNull(parameter18), VoltType.CoalesceNull(parameter19), VoltType.CoalesceNull(parameter20), VoltType.CoalesceNull(parameter21), VoltType.CoalesceNull(parameter22), VoltType.CoalesceNull(parameter23), VoltType.CoalesceNull(parameter24), VoltType.CoalesceNull(parameter25), VoltType.CoalesceNull(parameter26), VoltType.CoalesceNull(parameter27), VoltType.CoalesceNull(parameter28), VoltType.CoalesceNull(parameter29), VoltType.CoalesceNull(parameter30), VoltType.CoalesceNull(parameter31), VoltType.CoalesceNull(parameter32), VoltType.CoalesceNull(parameter33), VoltType.CoalesceNull(parameter34), VoltType.CoalesceNull(parameter35));
return(true);
}
catch { response = null; }
return(false);
}
