troubleshooting Question

Unable to access a Namespace from a Class

Avatar of amoran
amoran asked on
.NET ProgrammingASP.NET
6 Comments1 Solution925 ViewsLast Modified:
Hi
I've created a new asp.net 2.0 website with Visual Web Developer 2005 Express Edition.

I have one .aspx page (default.aspx) and I've created two folders 'DAL' and 'BLL' (data access layer and business logic layer)

I created one class 'Course.vb' and placed it in the BLL layer.
I am using SQLHelper.cs in the DAL (i attach that file)

Now when I'm in the Course.vb file I notice that at this line

Dim ds As DataSet = SqlHelper.ExecuteDataset(System.Configuration.ConfigurationManager.AppSettings("ConnectionString"), "usp_Extranet_GetDirectory", _courseID)
     
It underlines SqlHelper and says 'Name SqlHelper is not declared'.
At the top of the Course.vb file I try to write
Imports DAL but it doesn't present that in the options
It shows
() BusinessLogicLayer
() Microsoft
() My
() System

But it doesn't allow me to do
Imports DataAccessLayer
 in order to get rid of the error 'Name SqlHelper is not declared'.
Anyone any ideas?

Thanks
AM
----------------SQLHelper.vb (this is in the DAL folder)---------------
 
Imports Microsoft.VisualBasic
Imports System.Data
Imports System.Data.SqlClient
Imports System.Collections
 
Namespace DataAccessLayer
 
    Public NotInheritable Class SQLHelper
 
        '*********************************************************************
        '
        ' Since this class provides only static methods, make the default constructor private to prevent 
        ' instances from being created with "new SqlHelper()".
        '
        '*********************************************************************
        Private Sub New()
        End Sub 'New
 
        '*********************************************************************
        '
        ' This method is used to attach array of SqlParameters to a SqlCommand.
        ' 
        ' This method will assign a value of DbNull to any parameter with a direction of
        ' InputOutput and a value of null.  
        ' 
        ' This behavior will prevent default values from being used, but
        ' this will be the less common case than an intended pure output parameter (derived as InputOutput)
        ' where the user provided no input value.
        ' 
        ' param name="command" The command to which the parameters will be added
        ' param name="commandParameters" an array of SqlParameters tho be added to command
        '
        '*********************************************************************
        Private Shared Sub AttachParameters(ByVal command As SqlCommand, ByVal commandParameters() As SqlParameter)
            Dim p As SqlParameter
            For Each p In commandParameters
                'check for derived output value with no value assigned
                If p.Direction = ParameterDirection.InputOutput And p.Value Is Nothing Then
                    p.Value = Nothing
                End If
                command.Parameters.Add(p)
            Next p
        End Sub 'AttachParameters
 
 
        '*********************************************************************
        '
        ' This method assigns an array of values to an array of SqlParameters.
        ' 
        ' param name="commandParameters" array of SqlParameters to be assigned values
        ' param name="parameterValues" array of objects holding the values to be assigned
        '
        '*********************************************************************
        Private Shared Sub AssignParameterValues(ByVal commandParameters() As SqlParameter, ByVal parameterValues() As Object)
 
            Dim i As Short
            Dim j As Short
 
            If (commandParameters Is Nothing) And (parameterValues Is Nothing) Then
                'do nothing if we get no data
                Return
            End If
 
            ' we must have the same number of values as we pave parameters to put them in
            If commandParameters.Length <> parameterValues.Length Then
                Throw New ArgumentException("Parameter count does not match Parameter Value count.")
            End If
 
            'value array
            j = commandParameters.Length - 1
            For i = 0 To j
                commandParameters(i).Value = parameterValues(i)
            Next
 
        End Sub 'AssignParameterValues
 
        '*********************************************************************
        '
        ' This method opens (if necessary) and assigns a connection, transaction, command type and parameters 
        ' to the provided command.
        ' 
        ' param name="command" the SqlCommand to be prepared
        ' param name="connection" a valid SqlConnection, on which to execute this command
        ' param name="transaction" a valid SqlTransaction, or 'null'
        ' param name="commandType" the CommandType (stored procedure, text, etc.)
        ' param name="commandText" the stored procedure name or T-SQL command
        ' param name="commandParameters" an array of SqlParameters to be associated with the command or 'null' if no parameters are required
        '
        '*********************************************************************
        Private Shared Sub PrepareCommand(ByVal command As SqlCommand, _
                                          ByVal connection As SqlConnection, _
                                          ByVal transaction As SqlTransaction, _
                                          ByVal commandType As CommandType, _
                                          ByVal commandText As String, _
                                          ByVal commandParameters() As SqlParameter)
 
            'if the provided connection is not open, we will open it
            If connection.State <> ConnectionState.Open Then
                connection.Open()
            End If
 
            'associate the connection with the command
            command.Connection = connection
 
            'set the command text (stored procedure name or SQL statement)
            command.CommandText = commandText
 
            'if we were provided a transaction, assign it.
            If Not (transaction Is Nothing) Then
                command.Transaction = transaction
            End If
 
            'set the command type
            command.CommandType = commandType
 
            'attach the command parameters if they are provided
            If Not (commandParameters Is Nothing) Then
                AttachParameters(command, commandParameters)
            End If
 
            Return
        End Sub 'PrepareCommand
 
 
        '*********************************************************************
        '
        ' Execute a SqlCommand (that returns no resultset) against the database specified in the connection string 
        ' using the provided parameters.
        '
        ' e.g.:  
        '  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        '
        ' param name="connectionString" a valid connection string for a SqlConnection
        ' param name="commandType" the CommandType (stored procedure, text, etc.)
        ' param name="commandText" the stored procedure name or T-SQL command
        ' param name="commandParameters" an array of SqlParamters used to execute the command
        ' returns an int representing the number of rows affected by the command
        '
        '*********************************************************************
        Public Overloads Shared Function ExecuteNonQuery(ByVal connectionString As String, _
                                                         ByVal commandType As CommandType, _
                                                         ByVal commandText As String, _
                                                         ByVal ParamArray commandParameters() As SqlParameter) As Integer
            'create & open a SqlConnection, and dispose of it after we are done.
            Dim cn As New SqlConnection(connectionString)
            Try
                cn.Open()
 
                'call the overload that takes a connection in place of the connection string
                Return ExecuteNonQuery(cn, commandType, commandText, commandParameters)
 
            Finally
                cn.Dispose()
            End Try
        End Function 'ExecuteNonQuery
 
 
        '*********************************************************************
        '
        ' Execute a stored procedure via a SqlCommand (that returns no resultset) against the database specified in 
        ' the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
        ' stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
        ' 
        ' This method provides no access to output parameters or the stored procedure's return value parameter.
        ' 
        ' e.g.:  
        '  int result = ExecuteNonQuery(connString, "PublishOrders", 24, 36);
        '
        ' param name="connectionString" a valid connection string for a SqlConnection
        ' param name="spName" the name of the stored prcedure
        ' param name="parameterValues" an array of objects to be assigned as the input values of the stored procedure
        ' returns an int representing the number of rows affected by the command
        '
        '*********************************************************************
        Public Overloads Shared Function ExecuteNonQuery(ByVal connectionString As String, _
                                                         ByVal spName As String, _
                                                         ByVal ParamArray parameterValues() As Object) As Integer
            Dim commandParameters As SqlParameter()
 
            'if we receive parameter values, we need to figure out where they go
            If Not (parameterValues Is Nothing) And parameterValues.Length > 0 Then
                'pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
 
                commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName)
 
                'assign the provided values to these parameters based on parameter order
                AssignParameterValues(commandParameters, parameterValues)
 
                'call the overload that takes an array of SqlParameters
                Return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters)
                'otherwise we can just call the SP without params
            Else
                Return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName)
            End If
        End Function 'ExecuteNonQuery
 
        '*********************************************************************
        '
        ' Execute a SqlCommand (that returns no resultset) against the specified SqlConnection 
        ' using the provided parameters.
        ' 
        ' e.g.:  
        '  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
        ' 
        ' param name="connection" a valid SqlConnection 
        ' param name="commandType" the CommandType (stored procedure, text, etc.) 
        ' param name="commandText" the stored procedure name or T-SQL command 
        ' param name="commandParameters" an array of SqlParamters used to execute the command 
        ' returns an int representing the number of rows affected by the command
        '
        '*********************************************************************
        Public Overloads Shared Function ExecuteNonQuery(ByVal connection As SqlConnection, _
                                                        ByVal commandType As CommandType, _
                                                        ByVal commandText As String, _
                                                        ByVal ParamArray commandParameters() As SqlParameter) As Integer
 
            'create a command and prepare it for execution
            Dim cmd As New SqlCommand
            Dim retval As Integer
 
            PrepareCommand(cmd, connection, CType(Nothing, SqlTransaction), commandType, commandText, commandParameters)
 
            'finally, execute the command.
            retval = cmd.ExecuteNonQuery()
 
            'detach the SqlParameters from the command object, so they can be used again
            cmd.Parameters.Clear()
 
            Return retval
 
        End Function 'ExecuteNonQuery
 
 
        '*********************************************************************
        '
        ' Execute a SqlCommand (that returns a resultset) against the database specified in the connection string 
        ' using the provided parameters.
        ' 
        ' e.g.:  
        '  DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
        ' 
        ' param name="connectionString" a valid connection string for a SqlConnection 
        ' param name="commandType" the CommandType (stored procedure, text, etc.) 
        ' param name="commandText" the stored procedure name or T-SQL command 
        ' param name="commandParameters" an array of SqlParamters used to execute the command 
        ' returns a dataset containing the resultset generated by the command
        '
        '*********************************************************************
        Public Overloads Shared Function ExecuteDataset(ByVal connectionString As String, _
                                                        ByVal commandType As CommandType, _
                                                        ByVal commandText As String, _
                                                        ByVal ParamArray commandParameters() As SqlParameter) As DataSet
            'create & open a SqlConnection, and dispose of it after we are done.
            Dim cn As New SqlConnection(connectionString)
            Try
                cn.Open()
 
                'call the overload that takes a connection in place of the connection string
                Return ExecuteDataset(cn, commandType, commandText, commandParameters)
            Finally
                cn.Dispose()
            End Try
        End Function 'ExecuteDataset
 
 
        '*********************************************************************
        '
        ' Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
        ' the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
        ' stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
        ' 
        ' This method provides no access to output parameters or the stored procedure's return value parameter.
        ' 
        ' e.g.:  
        '  DataSet ds = ExecuteDataset(connString, "GetOrders", 24, 36);
        ' 
        ' param name="connectionString" a valid connection string for a SqlConnection
        ' param name="spName" the name of the stored procedure
        ' param name="parameterValues" an array of objects to be assigned as the input values of the stored procedure
        ' returns a dataset containing the resultset generated by the command
        '
        '*********************************************************************
        Public Overloads Shared Function ExecuteDataset(ByVal connectionString As String, _
                                                        ByVal spName As String, _
                                                        ByVal ParamArray parameterValues() As Object) As DataSet
 
            Dim commandParameters As SqlParameter()
 
            'if we receive parameter values, we need to figure out where they go
            If Not (parameterValues Is Nothing) And parameterValues.Length > 0 Then
                'pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
                commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName)
 
                'assign the provided values to these parameters based on parameter order
                AssignParameterValues(commandParameters, parameterValues)
 
                'call the overload that takes an array of SqlParameters
                Return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters)
                'otherwise we can just call the SP without params
            Else
                Return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName)
            End If
        End Function 'ExecuteDataset
 
        '*********************************************************************
        '
        ' Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
        ' using the provided parameters.
        ' 
        ' e.g.:  
        '  DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
        '
        ' param name="connection" a valid SqlConnection
        ' param name="commandType" the CommandType (stored procedure, text, etc.)
        ' param name="commandText" the stored procedure name or T-SQL command
        ' param name="commandParameters" an array of SqlParamters used to execute the command
        ' returns a dataset containing the resultset generated by the command
        '
        '*********************************************************************
        Public Overloads Shared Function ExecuteDataset(ByVal connection As SqlConnection, _
                                                        ByVal commandType As CommandType, _
                                                        ByVal commandText As String, _
                                                        ByVal ParamArray commandParameters() As SqlParameter) As DataSet
 
            'create a command and prepare it for execution
            Dim cmd As New SqlCommand
            Dim ds As New DataSet
            Dim da As SqlDataAdapter
 
            PrepareCommand(cmd, connection, CType(Nothing, SqlTransaction), commandType, commandText, commandParameters)
 
            'create the DataAdapter & DataSet
            da = New SqlDataAdapter(cmd)
 
            'fill the DataSet using default values for DataTable names, etc.
            da.Fill(ds)
 
            'detach the SqlParameters from the command object, so they can be used again
            cmd.Parameters.Clear()
 
            'return the dataset
            Return ds
 
        End Function 'ExecuteDataset
 
 
        '*********************************************************************
        '
        ' Execute a SqlCommand (that returns a 1x1 resultset) against the database specified in the connection string 
        ' using the provided parameters.
        ' 
        ' e.g.:  
        '  int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
        ' 
        ' param name="connectionString" a valid connection string for a SqlConnection 
        ' param name="commandType" the CommandType (stored procedure, text, etc.) 
        ' param name="commandText" the stored procedure name or T-SQL command 
        ' param name="commandParameters" an array of SqlParamters used to execute the command 
        ' returns an object containing the value in the 1x1 resultset generated by the command
        '
        '*********************************************************************
        Public Overloads Shared Function ExecuteScalar(ByVal connectionString As String, _
                                                       ByVal commandType As CommandType, _
                                                       ByVal commandText As String, _
                                                       ByVal ParamArray commandParameters() As SqlParameter) As Object
            'create & open a SqlConnection, and dispose of it after we are done.
            Dim cn As New SqlConnection(connectionString)
            Try
                cn.Open()
 
                'call the overload that takes a connection in place of the connection string
                Return ExecuteScalar(cn, commandType, commandText, commandParameters)
            Finally
                cn.Dispose()
            End Try
        End Function 'ExecuteScalar
 
 
 
        '*********************************************************************
        '
        ' Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the database specified in 
        ' the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
        ' stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
        ' 
        ' This method provides no access to output parameters or the stored procedure's return value parameter.
        ' 
        ' e.g.:  
        '  int orderCount = (int)ExecuteScalar(connString, "GetOrderCount", 24, 36);
        ' 
        ' param name="connectionString" a valid connection string for a SqlConnection 
        ' param name="spName" the name of the stored procedure 
        ' param name="parameterValues" an array of objects to be assigned as the input values of the stored procedure 
        ' returns an object containing the value in the 1x1 resultset generated by the command
        '
        '*********************************************************************
        Public Overloads Shared Function ExecuteScalar(ByVal connectionString As String, _
                                                       ByVal spName As String, _
                                                       ByVal ParamArray parameterValues() As Object) As Object
            Dim commandParameters As SqlParameter()
 
            'if we receive parameter values, we need to figure out where they go
            If Not (parameterValues Is Nothing) And parameterValues.Length > 0 Then
                'pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
                commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName)
 
                'assign the provided values to these parameters based on parameter order
                AssignParameterValues(commandParameters, parameterValues)
 
                'call the overload that takes an array of SqlParameters
                Return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters)
                'otherwise we can just call the SP without params
            Else
                Return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName)
            End If
        End Function 'ExecuteScalar
 
 
        '*********************************************************************
        '
        ' Execute a SqlCommand (that returns a 1x1 resultset) against the specified SqlConnection 
        ' using the provided parameters.
        ' 
        ' e.g.:  
        '  int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
        ' 
        ' param name="connection" a valid SqlConnection 
        ' param name="commandType" the CommandType (stored procedure, text, etc.) 
        ' param name="commandText" the stored procedure name or T-SQL command 
        ' param name="commandParameters" an array of SqlParamters used to execute the command 
        ' returns an object containing the value in the 1x1 resultset generated by the command
        '
        '*********************************************************************
        Public Overloads Shared Function ExecuteScalar(ByVal connection As SqlConnection, _
                                                       ByVal commandType As CommandType, _
                                                       ByVal commandText As String, _
                                                       ByVal ParamArray commandParameters() As SqlParameter) As Object
            'create a command and prepare it for execution
            Dim cmd As New SqlCommand
            Dim retval As Object
 
            PrepareCommand(cmd, connection, CType(Nothing, SqlTransaction), commandType, commandText, commandParameters)
 
            'execute the command & return the results
            retval = cmd.ExecuteScalar()
 
            'detach the SqlParameters from the command object, so they can be used again
            cmd.Parameters.Clear()
 
            Return retval
 
        End Function 'ExecuteScalar
    End Class 'SqlHelper
    _
 
    '*********************************************************************
    '
    ' SqlHelperParameterCache provides functions to leverage a static cache of procedure parameters, and the
    ' ability to discover parameters for stored procedures at run-time.
    '
    '*********************************************************************
    Public NotInheritable Class SqlHelperParameterCache
 
        '*********************************************************************
        '
        ' Since this class provides only static methods, make the default constructor private to prevent 
        ' instances from being created with "new SqlHelperParameterCache()".
        '
        '*********************************************************************
        Private Sub New()
        End Sub 'New 
 
        Private Shared paramCache As Hashtable = Hashtable.Synchronized(New Hashtable)
 
        '*********************************************************************
        '
        ' resolve at run time the appropriate set of SqlParameters for a stored procedure
        ' 
        ' param name="connectionString" a valid connection string for a SqlConnection 
        ' param name="spName" the name of the stored procedure 
        ' param name="includeReturnValueParameter" whether or not to include their return value parameter 
        '
        '*********************************************************************
        Private Shared Function DiscoverSpParameterSet(ByVal connectionString As String, _
                                                       ByVal spName As String, _
                                                       ByVal includeReturnValueParameter As Boolean, _
                                                       ByVal ParamArray parameterValues() As Object) As SqlParameter()
 
            Dim cn As New SqlConnection(connectionString)
            Dim cmd As SqlCommand = New SqlCommand(spName, cn)
            Dim discoveredParameters() As SqlParameter
 
            Try
                cn.Open()
                cmd.CommandType = CommandType.StoredProcedure
                SqlCommandBuilder.DeriveParameters(cmd)
                If Not includeReturnValueParameter Then
                    cmd.Parameters.RemoveAt(0)
                End If
 
                discoveredParameters = New SqlParameter(cmd.Parameters.Count - 1) {}
                cmd.Parameters.CopyTo(discoveredParameters, 0)
            Finally
                cmd.Dispose()
                cn.Dispose()
 
            End Try
 
            Return discoveredParameters
 
        End Function 'DiscoverSpParameterSet
 
        'deep copy of cached SqlParameter array
        Private Shared Function CloneParameters(ByVal originalParameters() As SqlParameter) As SqlParameter()
 
            Dim i As Short
            Dim j As Short = originalParameters.Length - 1
            Dim clonedParameters(j) As SqlParameter
 
            For i = 0 To j
                clonedParameters(i) = CType(CType(originalParameters(i), ICloneable).Clone, SqlParameter)
            Next
 
            Return clonedParameters
        End Function 'CloneParameters
 
 
        '*********************************************************************
        '
        ' add parameter array to the cache
        '
        ' param name="connectionString" a valid connection string for a SqlConnection 
        ' param name="commandText" the stored procedure name or T-SQL command 
        ' param name="commandParameters" an array of SqlParamters to be cached 
        '
        '*********************************************************************
        Public Shared Sub CacheParameterSet(ByVal connectionString As String, _
                                            ByVal commandText As String, _
                                            ByVal ParamArray commandParameters() As SqlParameter)
            Dim hashKey As String = connectionString + ":" + commandText
 
            paramCache(hashKey) = commandParameters
        End Sub 'CacheParameterSet
 
 
        '*********************************************************************
        '
        ' Retrieve a parameter array from the cache
        ' 
        ' param name="connectionString" a valid connection string for a SqlConnection 
        ' param name="commandText" the stored procedure name or T-SQL command 
        ' returns an array of SqlParamters
        '
        '*********************************************************************
        Public Shared Function GetCachedParameterSet(ByVal connectionString As String, ByVal commandText As String) As SqlParameter()
            Dim hashKey As String = connectionString + ":" + commandText
            Dim cachedParameters As SqlParameter() = CType(paramCache(hashKey), SqlParameter())
 
            If cachedParameters Is Nothing Then
                Return Nothing
            Else
                Return CloneParameters(cachedParameters)
            End If
        End Function 'GetCachedParameterSet
 
        '*********************************************************************
        '
        ' Retrieves the set of SqlParameters appropriate for the stored procedure
        ' 
        ' This method will query the database for this information, and then store it in a cache for future requests.
        ' 
        ' param name="connectionString" a valid connection string for a SqlConnection 
        ' param name="spName" the name of the stored procedure 
        ' returns an array of SqlParameters
        '
        '*********************************************************************
        Public Overloads Shared Function GetSpParameterSet(ByVal connectionString As String, ByVal spName As String) As SqlParameter()
            Return GetSpParameterSet(connectionString, spName, False)
        End Function 'GetSpParameterSet 
 
 
        '*********************************************************************
        '
        ' Retrieves the set of SqlParameters appropriate for the stored procedure
        ' 
        ' This method will query the database for this information, and then store it in a cache for future requests.
        ' 
        ' param name="connectionString" a valid connection string for a SqlConnection 
        ' param name="spName" the name of the stored procedure 
        ' param name="includeReturnValueParameter" a bool value indicating whether the return value parameter should be included in the results 
        ' returns an array of SqlParameters
        '
        '*********************************************************************
        Public Overloads Shared Function GetSpParameterSet(ByVal connectionString As String, _
                                                           ByVal spName As String, _
                                                           ByVal includeReturnValueParameter As Boolean) As SqlParameter()
 
            Dim cachedParameters() As SqlParameter
            Dim hashKey As String
 
            hashKey = connectionString + ":" + spName + IIf(includeReturnValueParameter = True, ":include ReturnValue Parameter", "")
 
            cachedParameters = CType(paramCache(hashKey), SqlParameter())
 
            If (cachedParameters Is Nothing) Then
                paramCache(hashKey) = DiscoverSpParameterSet(connectionString, spName, includeReturnValueParameter)
                cachedParameters = CType(paramCache(hashKey), SqlParameter())
 
            End If
 
            Return CloneParameters(cachedParameters)
 
        End Function 'GetSpParameterSet
 
 
    End Class
 
End Namespace
 
----------------end ---------------------------------
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
--------------Course.vb (this is in the BLL folder)---------------
 
Imports Microsoft.VisualBasic
 
Imports System
Imports System.Web
Imports System.Configuration
Imports System.Data
Imports System.Web.Security
 
Namespace BusinessLogicLayer
 
    Public Class Course
 
#Region "Private Locals"
 
        Private _courseID As Integer
        Private _courseCode As String
        Private _courseType As String
        Private _courseName As String
        Private _duration As Decimal
        Private _displayOrder As Integer
        Private _isDisplayed As Boolean
 
#End Region
 
#Region "Constructors"
 
        Public Sub New()
        End Sub 'New
 
        Public Sub New(ByVal courseID As Integer)
            _courseID = courseID
        End Sub 'New
 
#End Region
 
#Region "Public Properties"
 
        Public Property CourseID() As Integer
            Get
                Return _courseID
            End Get
            Set(ByVal Value As Integer)
                _courseID = Value
            End Set
        End Property
 
        Public Property CourseCode() As String
            Get
                Return _courseCode
            End Get
            Set(ByVal Value As String)
                _courseCode = Value
            End Set
        End Property
 
        Public Property CourseType() As String
            Get
                Return _courseType
            End Get
            Set(ByVal Value As String)
                _courseType = Value
            End Set
        End Property
 
        Public Property CourseName() As String
            Get
                Return _courseName
            End Get
            Set(ByVal Value As String)
                _courseName = Value
            End Set
        End Property
 
        Public Property Duration() As Decimal
            Get
                Return _duration
            End Get
            Set(ByVal Value As Decimal)
                _duration = Value
            End Set
        End Property
 
        Public Property DisplayOrder() As Integer
            Get
                Return _displayOrder
            End Get
            Set(ByVal Value As Integer)
                _displayOrder = Value
            End Set
        End Property
 
        Public Property IsDisplayed() As Boolean
            Get
                Return _isDisplayed
            End Get
            Set(ByVal Value As Boolean)
                _isDisplayed = Value
            End Set
        End Property
 
#End Region
 
#Region "Functions"
 
        Public Function Load() As Boolean
 
            Dim ds As DataSet = SqlHelper.ExecuteDataset(System.Configuration.ConfigurationManager.AppSettings("ConnectionString"), "usp_Extranet_GetDirectory", _courseID)
            If ds.Tables(0).Rows.Count < 1 Then
                Return False
            End If
            _courseID = Convert.ToInt32(ds.Tables(0).Rows(0)("course_id"))
            _courseCode = Convert.ToString(ds.Tables(0).Rows(0)("course_code"))
            _courseType = Convert.ToInt32(ds.Tables(0).Rows(0)("course_type"))
            _courseName = Convert.ToBoolean(ds.Tables(0).Rows(0)("course_name"))
            _duration = Convert.ToBoolean(ds.Tables(0).Rows(0)("duration"))
            _displayOrder = Convert.ToBoolean(ds.Tables(0).Rows(0)("display_order"))
            _isDisplayed = Convert.ToBoolean(ds.Tables(0).Rows(0)("is_displayed"))
 
            Return True
 
        End Function 'Load
 
 
#End Region
 
    End Class
 
End Namespace
Join the community to see this answer!
Join our exclusive community to see this answer & millions of others.
Unlock 1 Answer and 6 Comments.
Join the Community
Learn from the best

Network and collaborate with thousands of CTOs, CISOs, and IT Pros rooting for you and your success.

Andrew Hancock - VMware vExpert
See if this solution works for you by signing up for a 7 day free trial.
Unlock 1 Answer and 6 Comments.
Try for 7 days

”The time we save is the biggest benefit of E-E to our team. What could take multiple guys 2 hours or more each to find is accessed in around 15 minutes on Experts Exchange.

-Mike Kapnisakis, Warner Bros