Collection List empties itself - vb.net

Question

I have a class for adding parameters to a database (PostgreSQL) connection object that inherits System.Collections.CollectionBase. This class is in a common library I use for multiple applications. Usually, it adds the objects without a problem, but I've started encountering a strange issue where the collection empties its objects for no apparent reason. This results in an error with the SQL statement not being built properly.
ENVIRONMENT
Windows 10 Pro x64 (19042.804)
Visual Studio 2017 CE (4.8.0484)
.NET Framework 4.7.2 (Library & Application)
PostgreSQL Server v12.1
Npgsql 5.0.3 (see below)
TROUBLESHOOTING
Here's the (obfuscated) code where the issue is occurring:
SQLCommand = "INSERT INTO table" & vbCrLf
SQLCommand += "(" & vbCrLf
SQLCommand += vbTab & "column1," & vbCrLf
SQLCommand += vbTab & "column2," & vbCrLf
SQLCommand += vbTab & "column3," & vbCrLf
SQLCommand += vbTab & "column4," & vbCrLf
SQLCommand += vbTab & "column5," & vbCrLf
SQLCommand += vbTab & "column6," & vbCrLf
SQLCommand += vbTab & "column7," & vbCrLf
SQLCommand += vbTab & "column8," & vbCrLf
SQLCommand += vbTab & "column9," & vbCrLf
SQLCommand += vbTab & "column10" & vbCrLf
SQLCommand += ")" & vbCrLf
SQLCommand += "VALUES" & vbCrLf
SQLCommand += "(" & vbCrLf
SQLCommand += vbTab & ":parameter1," & vbCrLf
SQLCommand += vbTab & ":parameter2," & vbCrLf
SQLCommand += vbTab & ":parameter3," & vbCrLf
SQLCommand += vbTab & ":parameter4," & vbCrLf
SQLCommand += vbTab & ":parameter5," & vbCrLf
SQLCommand += vbTab & ":parameter6," & vbCrLf
SQLCommand += vbTab & ":parameter7," & vbCrLf
SQLCommand += vbTab & ":parameter8," & vbCrLf
SQLCommand += vbTab & ":parameter9," & vbCrLf
SQLCommand += vbTab & ":parameter10" & vbCrLf
SQLCommand += ")" & vbCrLf
SQLCommand += "RETURNING pkid"
PGDB.Parameters.Add(":parameter1", value1) 'String
PGDB.Parameters.Add(":parameter2", value2) 'String
PGDB.Parameters.Add(":parameter3", value3) 'String
PGDB.Parameters.Add(":parameter4", value4) 'String
PGDB.Parameters.Add(":parameter5", value5) 'String
PGDB.Parameters.Add(":parameter6", value6) 'String
PGDB.Parameters.Add(":parameter7", value7) 'String - THIS IS WHERE THE LIST CLEARS
PGDB.Parameters.Add(":parameter8", value8) 'Boolean
PGDB.Parameters.Add(":parameter9", value9) 'String
PGDB.Parameters.Add(":parameter10", value10) 'String
MyID = Convert.ToInt32(PGDB.ExecuteStatementScalar(SQLCommand))
The PGDB object is my Npgsql database connection object and the Parameters object is the inherited collection. The first six parameters add to the collection without issue, but as soon as it goes to add the seventh, the entire list empties itself and starts over. The executing SQL statement should look like this:
-- EXPECTED SQL - WHAT IS STORED IN THE SQLCommand VARIABLE
INSERT INTO table
(
column1,
column2,
column3,
column4,
column5,
column6,
column7,
column8,
column9,
column10
)
VALUES
(
:parameter1,
:parameter2,
:parameter3,
:parameter4,
:parameter5,
:parameter6,
:parameter7,
:parameter8,
:parameter9,
:parameter10
)
RETURNING pkid
...but, what I get instead is this:
-- ACTUAL (WRONG) SQL EXECUTED BY THE DATABASE
INSERT INTO table
(
column1,
column2,
column3,
column4,
column5,
column6,
column7,
column8,
column9,
column10
)
VALUES
(
:parameter1,
:parameter2,
:parameter3,
:parameter4,
:parameter5,
:parameter6,
$1,
$2,
$3,
$4
)
RETURNING pkid
...which then generates an Npgsql.PostgresException complaining about the syntax when it actually tries to execute the SQL statement:
42601: syntax error at or near ":"
I've put in breakpoints to step through the process but it's always the same behavior. Here are some screenshots from my IDE:
Here's what the Parameters collection object looks like before the first parameter is added:
Here it is after the sixth parameter is added:
And here's what it looks like as soon as it enters execution of the Add() method on the seventh parameter:
To be sure, I also checked the state as it enters execution of the Add() method on the sixth parameter:
This method worked without error at one time, so I'm not sure why it "all of a sudden" stopped working. In my attempt to fix this and get all of the parameters to load correctly, I upgraded the Npgsql library from version 4.1.8 to 5.0.3. After I fought with it for a while - I had to resolve some version conflicts with the System.Buffers library - I was able to get it running again but, unfortunately, I got the exact same results.
Just in case it might be a memory issue, I went ahead and shut down everything and rebooted the computer. That also did not resolve the issue.
For reference, here's a trimmed-down version of the PGSQLParameters class, excluding various overloads for different value types.
Imports Npgsql
#Region "POSTGRESQL PARAMETER COLLECTION OBJECT"
Public Class PGSQLParameters
Inherits System.Collections.CollectionBase
Public Enum SQLDecimalType
SQLMoney = 1
SQLDecimal = 2
End Enum
#Region "COLLECTION ADD AND SUPPORT METHODS"
#Region "PUBLIC METHODS FOR ADDING ITEMS TO THE COLLECTION"
'-- Input Parameter
Public Overloads Sub Add(ByVal ParameterName As String, ByVal DataType As DbType, ByVal Size As Int32, ByVal Value As Object)
If ParameterName.Length = 0 Then
Return
End If
If TypeOf (Value) Is String AndAlso String.IsNullOrEmpty(Convert.ToString(Value)) Then
Value = DBNull.Value
End If
If Not ParameterName.StartsWith(":") Then
ParameterName = ParameterName.Insert(0, ":")
End If
List.Add(BuildParameter(ParameterName, DataType, Size, ParameterDirection.Input, Value))
End Sub
#Region "INPUT OVERLOADS"
'-- String
Public Overloads Sub Add(ByVal ParameterName As String, ByVal Value As String)
Dim StringLength As Integer = 0
If Not Value = Nothing AndAlso Not String.IsNullOrEmpty(Value) Then
StringLength = Value.Length
End If
Add(ParameterName, DbType.String, StringLength, Value)
End Sub
#End Region
#End Region
Private Function BuildParameter(ByVal ParameterName As String, ByVal DataType As DbType, ByVal Size As Int32, ByVal Direction As ParameterDirection, ByVal Value As Object) As NpgsqlParameter
Dim NewParameter As NpgsqlParameter
If Size > 0 Then
NewParameter = New NpgsqlParameter(ParameterName, DataType, Size)
Else
NewParameter = New NpgsqlParameter(ParameterName, DataType)
End If
NewParameter.Direction = Direction
If Not (Direction = ParameterDirection.Output AndAlso Value Is Nothing) Then
NewParameter.Value = DBNull.Value
If Not Value Is Nothing Then
NewParameter.Value = Value
ElseIf TypeOf (Value) Is Boolean Then
NewParameter.Value = Value
End If
End If
Return NewParameter
End Function
#End Region
End Class
#End Region
I don't see any reason for this spontaneous "clearing" of the Parameters collection, especially since all of the parameters leading up to and including the "problem" are String values, so they're all using the exact same method call (I've confirmed this in my walk-through). Additionally, based on the executing SQL, it looks like it's actually somehow preserving the first six parameters in the collection object and just not adding the new ones, which makes absolutely no sense.
Also, it doesn't look like it's completely reinstantiating the object because, as the screenshots show, the Capacity doesn't change from the sixth to the seventh parameter. If I had to say anything, it looks like it's cloning the collection after six parameters have been added, then discarding that clone and/or ignoring it completely. Again, it just makes no sense to me.
I wouldn't doubt that I'm simply overlooking something, but I have no idea what that "something" would be. Has anyone else encountered this type of behavior? Any help or ideas would be greatly appreciated. If I can or need to provide any additional details, let me know.

Answer 1

Might need to post more code - the posted code doesn't seem to exhibit any problem for me:
Drag this icon to your desktop, rename it as .zip and open it:
It has the exact solution files I used to check your issue (it doesn't show the issue on my computer)

Answer 2

I've managed to solve the issue, but the cause is something I wouldn't have expected and probably wouldn't be obvious without a complete listing of a good deal more code. I apologize for not providing enough detail in the original question, but I hadn't guessed where I'd eventually find the cause of the issue.
As I indicated above, the issue always occurred with the same parameter in the sequence. The value I was attempting to assign to that specific parameter was a Public Property (String) of a Lazy(Of T) object in another class.
The object in question looks something like this:
#Region "REAL ESTATE OBJECT"
''' <summary>
''' Standard object containing details about a specific piece of real estate
''' </summary>
Public Class RealEstate
#Region "PRIVATE FIELDS"
<EditorBrowsable(EditorBrowsableState.Never)> <DebuggerBrowsable(DebuggerBrowsableState.Never)>
Private _RealEstateTypeCode As String
<EditorBrowsable(EditorBrowsableState.Never)> <DebuggerBrowsable(DebuggerBrowsableState.Never)>
Private _PhysicalStreet1 As String
<EditorBrowsable(EditorBrowsableState.Never)> <DebuggerBrowsable(DebuggerBrowsableState.Never)>
Private _PhysicalStreet2 As String
<EditorBrowsable(EditorBrowsableState.Never)> <DebuggerBrowsable(DebuggerBrowsableState.Never)>
Private _PhysicalCity As String
<EditorBrowsable(EditorBrowsableState.Never)> <DebuggerBrowsable(DebuggerBrowsableState.Never)>
Private _PhysicalState As String
<EditorBrowsable(EditorBrowsableState.Never)> <DebuggerBrowsable(DebuggerBrowsableState.Never)>
Private _PhysicalZIPCode As String
#End Region
#Region "PRIVATE PROPERTIES"
<EditorBrowsable(EditorBrowsableState.Never)> <DebuggerBrowsable(DebuggerBrowsableState.Never)>
Private Property PGDB As PGSQLDB
#Region "LAZY PROPERTIES"
' >> THIS IS THE PROPERTY THAT APPEARS TO HAVE CAUSED THE ISSUE <<
<EditorBrowsable(EditorBrowsableState.Never)> <DebuggerBrowsable(DebuggerBrowsableState.Never)>
Private Property _RealEstateType As Lazy(Of PropertyType) =
New Lazy(Of PropertyType)(Function()
Return New PropertyType(_RealEstateTypeCode, Me.CIADB)
End Function)
#End Region
#End Region
#Region "PUBLIC PROPERTIES"
Public Property RealEstateID As Integer
Public Property PhysicalStreet1 As String
Get
Return _PhysicalStreet1
End Get
Set(value As String)
If Not value Is Nothing Then
If value.Trim.Length > 120 Then
_PhysicalStreet1 = value.Trim.Substring(0, 120).Trim.ToUpper
Else
_PhysicalStreet1 = value.Trim.ToUpper
End If
Else
_PhysicalStreet1 = String.Empty
End If
End Set
End Property
Public Property PhysicalStreet2 As String
Get
Return _PhysicalStreet2
End Get
Set(value As String)
If Not value Is Nothing Then
If value.Trim.Length > 120 Then
_PhysicalStreet2 = value.Trim.Substring(0, 120).Trim.ToUpper
Else
_PhysicalStreet2 = value.Trim.ToUpper
End If
Else
_PhysicalStreet2 = String.Empty
End If
End Set
End Property
Public Property PhysicalCity As String
Get
Return _PhysicalCity
End Get
Set(value As String)
If Not value Is Nothing Then
If value.Trim.Length > 60 Then
_PhysicalCity = value.Trim.Substring(0, 60).Trim.ToUpper
Else
_PhysicalCity = value.Trim.ToUpper
End If
Else
_PhysicalCity = String.Empty
End If
End Set
End Property
Public Property PhysicalState As String
Get
If _PhysicalState Is Nothing OrElse String.IsNullOrEmpty(_PhysicalState) OrElse _PhysicalState = "XX" Then
If Not _PhysicalZIPCode Is Nothing AndAlso Not String.IsNullOrEmpty(_PhysicalZIPCode) Then
_PhysicalState = Utility.GetStateCodeFromZIP(_PhysicalZIPCode)
End If
End If
Return _PhysicalState
End Get
Set(value As String)
If Not value Is Nothing Then
If value.Trim.Length > 2 Then
_PhysicalState = Utility.GetStateCodeFromName(value.Trim)
Else
If [Enum].IsDefined(GetType(USState), value.Trim.ToUpper) Then
Dim PState As USState
If [Enum].TryParse(value.Trim.ToUpper, PState) Then
_PhysicalState = Utility.GetStateCodeFromName(PState.GetEnumDescription)
End If
Else
_PhysicalState = value.Trim.ToUpper
End If
End If
Else
_PhysicalState = "OK"
End If
End Set
End Property
Public Property PhysicalZIPCode As String
Get
Return _PhysicalZIPCode
End Get
Set(value As String)
If Not value Is Nothing Then
If value.Trim.Length > 10 Then
_PhysicalZIPCode = value.Trim.Substring(0, 10).Trim.ToUpper
Else
_PhysicalZIPCode = value.Trim.ToUpper
End If
Else
_PhysicalZIPCode = String.Empty
End If
End Set
End Property
Public WriteOnly Property RealEstateTypeCode As String
Set(value As String)
_RealEstateTypeCode = value
End Set
End Property
Public ReadOnly Property RealEstateType As PropertyType
Get
Return _RealEstateType.Value
End Get
End Property
#End Region
In my original obfuscated code I simply injected a generic string as a placeholder, but it appears that the issue has everything to do with this specific assignment. The other values being added to the parameter list are "regular" properties of the object that are immediately accessible. But, something seems to "short circuit" when calling the Add() method using a Lazy(Of T) object for the Value parameter.
In order to "fix" the issue, I've declared an additional local String variable that retrieves the value of the needed property from this Lazy(Of T) object. I then use that local variable for assigning to the Add() method's Value parameter:
With REObject 'A RealEstate object
' > DECLARING THIS LOCAL VARIABLE TO RETRIEVE THE VALUE OF THE LAZY PROPERTY
Dim TypeCode As String = .RealEstateType.TypeCode
...
PGDB.Parameters.Add("street1", .PhysicalStreet1)
PGDB.Parameters.Add("street2", .PhysicalStreet2)
PGDB.Parameters.Add("city", .PhysicalCity)
PGDB.Parameters.Add("state", .PhysicalState)
PGDB.Parameters.Add("zip", .PhysicalZIPCode)
' > CHANGED THE FOLLOWING
' PGDB.Parameters.Add("type", .RealEstateType.TypeCode) 'String - THIS IS WHERE THE LIST CLEARS
' > TO USE THE LOCAL VARIABLE INSTEAD OF THE LAZY OBJECT'S PROPERTY VALUE
PGDB.Parameters.Add("type", TypeCode)
' > THE VALUE IS NOW SUCCESSFULLY ADDED
...
End With
Executing this code results in all of the parameters correctly populating with the correct values and the SQL statement executing in the database without error. So, it would seem that the fact that the Lazy(Of T) object hasn't been "filled" yet is causing some unexpected (for me, at least) behavior when entering the Add() method. To be honest, I'm still not sure why it was "resetting" the .List property of the Collection object when attempting to use the Lazy(Of T) object's property value, but at least this resolution achieves the desired goal. Again, I apologize for not providing enough detail initially, but hopefully this will help someone else.