Prop-o-matic: generate your properties in C#, VB6/.Net, Asp, Html...

Prop-o-matic

Generates properties from a list of names (one per line; use the button to fix up comma separated properties).

Code (properties for C#, VB.Net and VB6; use Templates for a very basic data access class).
SQL (select/insert/update/delete statements - put an asterisk anywhere on the line for a primary key)
You can also generate web markup (HTML as divs or tables, asp.net and even asp3).

Paste in table columns
Use templates

Templates for C# and VB

IsDirty Membername

The full templates. The tokens are %LOCALS% (private member variables defined)
%TABLE% (table / class name)
%PROPS% (getter/setter properties)
%INIT% (initialize all private members to default values))
%VALID% (validation rules - null, string length)
%ADOALLPARAMETERS% (create ado parameters for all columns)
%ADOPKPARAMETERS% (create ado parameters just for primary keys)
%ADOFILL% (read the ado datareader/recordset into private member variables)
%SELECTSQL% (sql select statement)
%INSERTSQL% (sql insert statement)
%UPDATESQL% (sql update statement)
%DELETESQL% (sql delete statement)

These are self-contained "ActiveRecord" classes. Basic pattern is to pass in connection string or an active connection, set the primary key properties and call load (or delete), and set or change properties and call Save (insert or update based on whether loaded). In reality the .net ones should be based on abstract classes for most of the boilerplate, and anyway you'll probably just cut'n'copy snippets from this.

VB6 Template

Option Explicit

'these are exposed via public properties
Private m_ActiveConnection As ADODB.Connection
Private m_ConnectionString As String
Private m_IsNew As Boolean 'new or existing object
%LOCALS%

'Property ActiveConnection --------------------------------
Public Property Set ActiveConnection(ByVal vData As ADODB.Connection)
    Set m_ActiveConnection = vData
    Me.IsDirty = True
End Property
Public Property Get ActiveConnection() As ADODB.Connection
    Set ActiveConnection = m_ActiveConnection
End Property
'End Property ActiveConnection---------

'Property ConnectionString --------------------------------
Public Property Let ConnectionString(ByVal vData As String)
    m_ConnectionString = vData
    Me.IsDirty = True
End Property
Public Property Get ConnectionString() As String
    ConnectionString = m_ConnectionString
End Property
'End Property ConnectionString---------

'Property IsNew --------------------------------
Public Property Let IsNew(ByVal vData As Boolean)
    m_IsNew = vData
    Me.IsDirty = False
End Property
Public Property Get IsNew() As Boolean
    IsNew = m_IsNew
End Property
'End Property IsNew---------

'Property IsValid --------------------------------
Public Property Get IsValid() As Boolean
    'extend this method with business logic
    Dim l_IsValid As Boolean
%VALID%
	'business rules go here
    l_IsValid = True
    IsValid = l_IsValid
End Property
'End Property IsValid---------

%PROPS%

Private Sub Class_Initialize()
    Call Init
End Sub

Public Sub Init()
%INIT%
    Me.IsNew = True 'also sets IsDirty false
End Sub

Private Function OpenConnection() As ADODB.Connection
    'if not using Active Connection open a new connection
    Dim cn As New ADODB.Connection
    If m_ActiveConnection Is Nothing Then
        Call cn.Open(m_ConnectionString)
    Else
        Set cn = m_ActiveConnection
    End If
    Set OpenConnection = cn
End Function
Private Sub CloseConnection(ByVal cn As ADODB.Connection)
    'only close if not using Active Connection
    If m_ActiveConnection Is Nothing Then
        cn.Close
    End If
End Sub

'Set PKs via the properties- but you could put arguments here
Public Function Load() As Boolean
    Dim sql As String
    Dim cn As New ADODB.Connection
    Dim rs As New ADODB.Recordset
    Dim cmd As New ADODB.Command
    Dim par As ADODB.Parameter
    Dim lngRecordsAffected As Long
    
    On Error GoTo Load_Error
    Call Init
    sql = "%SELECTSQL%"
    Set cn = OpenConnection
    With cmd
        .ActiveConnection = cn
        .CommandText = sql
        .CommandType = adCmdText
%ADOPKPARAMETERS%
    End With
    Set par = Nothing
    
    Set rs = cmd.Execute()
    
    If Not rs.EOF Then
        'populate Me
%ADOFILL%
        Load = True
        Me.IsNew = False
    Else
        Load = False 'none found
    End If
CleanUp:
    Call CloseConnection(cn)
    Set rs = Nothing
    Set cmd = Nothing
    Set cn = Nothing
    Exit Function
Load_Error:
    Load = False
    GoTo CleanUp
End Function

Private Function Insert() As Boolean
    Dim sql As String
    Dim cn As New ADODB.Connection
    Dim cmd As New ADODB.Command
    Dim lngRecordsAffected As Long
    
    On Error GoTo Insert_Error
    sql = "%INSERTSQL%"
    Set cn = OpenConnection
    With cmd
        .ActiveConnection = cn
        .CommandText = sql
        .CommandType = adCmdText
%ADOALLPARAMETERS%
    End With
    
    Call cmd.Execute(lngRecordsAffected)
    
    Insert = IIf(lngRecordsAffected > 0, True, False)
    Me.IsNew = False
CleanUp:
    Call CloseConnection(cn)
    Set cmd = Nothing
    Set cn = Nothing
    Exit Function
Insert_Error:
    Insert = False
    GoTo CleanUp
End Function

Private Function Update() As Boolean
    Dim sql As String
    Dim cn As New ADODB.Connection
    Dim cmd As New ADODB.Command
    Dim lngRecordsAffected As Long
    
    On Error GoTo Update_Error
    sql = "%UPDATESQL%"
    Set cn = OpenConnection
    With cmd
        .ActiveConnection = cn
        .CommandText = sql
        .CommandType = adCmdText
%ADOALLPARAMETERS%
    End With
    
    Call cmd.Execute(lngRecordsAffected)
    
    Update = IIf(lngRecordsAffected > 0, True, False)
    Me.IsDirty = False
CleanUp:
    Call CloseConnection(cn)
    Set cmd = Nothing
    Set cn = Nothing
    Exit Function
Update_Error:
    Update = False
    GoTo CleanUp
End Function

Public Function Delete() As Boolean
'Primary keys must be set first. No checks for this.
'NB you can delete without loading an existing record
    Dim sql As String
    Dim cn As New ADODB.Connection
    Dim cmd As New ADODB.Command
    Dim lngRecordsAffected As Long
    
    On Error GoTo Delete_Error
    sql = "%DELETESQL%"
    Set cn = OpenConnection
    With cmd
        .ActiveConnection = cn
        .CommandText = sql
        .CommandType = adCmdText
%ADOPKPARAMETERS%
    End With
    
    Call cmd.Execute(lngRecordsAffected)
    
    Delete = IIf(lngRecordsAffected > 0, True, False)
    Me.IsDirty = False
CleanUp:
    Call CloseConnection(cn)
    Set cmd = Nothing
    Set cn = Nothing
    Exit Function
Delete_Error:
    Delete = False
    GoTo CleanUp
End Function

Public Function Save() As Boolean
    If Me.IsValid = False Then
        Save = False
    ElseIf m_IsNew Then
        Save = Insert()
    Else
        Save = Update()
    End If
End Function

C# Template

using System;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient; //can use DbFactories or OracleClient

namespace %TABLE%Namespace
{
	/// <summary>
	/// An activeRecord (crud) wrapper of a Sql table record
	/// </summary>
	public class %TABLE% : INotifyPropertyChanged
	{
        #region INotifyPropertyChanged Members
        public event PropertyChangedEventHandler PropertyChanged;
        #endregion
		#region Common Properties
		private SqlConnection  _activeConnection;
		private SqlConnection  _privateConnection;
		private string _connectionString;
		private bool _isNew;
        #endregion
		
		#region Constructor
		/// <summary>
		/// Default constructor
		/// </summary>
		public %TABLE%()
		{
			Init();
		}
		#endregion
		
		#region CRUD operations
		/// <summary>
		/// Initialize stuff
		/// </summary>
		private void Init() {
			_isNew = true;
%INIT%
		}
		
		/// <summary>
		/// Load from database into this object. If not in database (returns false), you have an empty new record.
		/// </summary>
		/// <returns>true if loaded, false if failed</returns>
		public bool Load(%PKTYPE% primaryKey) {
			const string sql = @"%SELECTSQL%";
			//initialize an empty record
			Init();
		    %PKNAME% = primaryKey;
			//grab the data
			SqlCommand cmd = new SqlCommand(sql, OpenConnection());
			try {
%ADOPKPARAMETERS%
				
				//singlerow hint - not used for sqlserver
				using (SqlDataReader dr = cmd.ExecuteReader(CommandBehavior.SingleRow)) {
					
					if (dr.HasRows) { //.net 1.1
						dr.Read();//Advance to the one and only row
%ADOFILL%
						_isNew= false;
					} else {
						//in a using block, so everything should close
						return false;
					}
				}
			} finally {
				cmd.Dispose();
				CloseConnection();
			}
			return true;
		}
		
		/// <summary>
		/// Saves the record to database. 
		/// </summary>
		/// <returns>True if saved, false if didn't</returns>
		public bool Save() {
			if(!IsValid)
				return false;
			if(_isNew)
				return Insert();
			else
				return Update();
		}
		
		private bool Insert() {
			string sql = @"%INSERTSQL%";
			bool ret = false;
			SqlCommand cmd = new SqlCommand(sql, OpenConnection());
			try {
%ADOALLPARAMETERS%
%ADOPKORIDENTITYPARAMETER%
				if (cmd.ExecuteNonQuery() > 0) {
					_isDirty = false; //not dirty anymore
					%READIDENTITY%
					ret = true;
				}
			} finally {
				cmd.Dispose();
				CloseConnection();
			}
			return ret;
		}
		
		/// <summary>
		/// Update an existing record in database
		/// </summary>
		private bool Update() {
			string sql = @"%UPDATESQL%";
			bool ret = false;
			SqlCommand cmd = new SqlCommand(sql, OpenConnection());
			try {
%ADOALLPARAMETERS%
				//primary key
%ADOPKPARAMETERS%
				if (cmd.ExecuteNonQuery() > 0) {
					_isDirty = false; //not dirty anymore
					ret = true;
				}
			} finally {
				cmd.Dispose();
				CloseConnection();
			}
			return ret;
		}
		
		/// <summary>
		/// Delete this record from database. You don't need to Load the record first- just set the primary key(s)
		/// </summary>
		/// <returns>Returns true if deleted, or false if no records updated</returns>
		public bool Delete() {
			string sql = @"%DELETESQL%";
			bool ret = false;
			SqlCommand cmd = new SqlCommand(sql, OpenConnection());
			try {
%ADOPKPARAMETERS%
			
			if (cmd.ExecuteNonQuery() > 0) {
				_isDirty = false; //not dirty anymore
				ret= true;
			}
			} finally {
				cmd.Dispose();
				CloseConnection();
			}
			return ret;
		}
		#endregion
		
		#region Private Connection Methods
		/// <summary>
		/// Use either the ActiveConnection or create one from ConnectionString
		/// </summary>
		private SqlConnection OpenConnection() {
			//if closed, open it (there are also states of broken, connecting etc)
			if (_activeConnection != null && _activeConnection.State == ConnectionState.Closed) {
				_activeConnection.Open();
			} else if (String.IsNullOrEmpty(_connectionString)) {
				//for 1.1 = if(_connectionString == null || _connectionString == "")
				throw new InvalidOperationException("No connection string");
			} else {
				//create a local connection which will we will close when done
				_privateConnection = new SqlConnection(_connectionString);
				_privateConnection.Open();
				return _privateConnection;
			}
			return _activeConnection;
		}
		
		/// <summary>
		/// Close the connection (local only- do not close a public connection)
		/// </summary>
		private void CloseConnection() {
			if (_privateConnection != null) {
				_privateConnection.Close();
			} else {
				//this connection may be used for something else, so don't close it
			}
		}
		#endregion

#region Common Properties

///<summary>
		///ActiveConnection
		///</summary>
		public SqlConnection ActiveConnection
		{
			get { return _activeConnection; }
			set { _activeConnection = value; }
		}

///<summary>
		///ConnectionString
		///</summary>
		public string ConnectionString
		{
			get { return _connectionString; }
			set
			{
				if(String.IsNullOrEmpty(value)) {
					throw new ArgumentNullException("value","Must not be null");
				}
				_connectionString = value;
			}
		}

///<summary>
		///Is this new or an existing (via Load)instance
		///</summary>
		public bool IsNew
		{
			get { return _isNew; }
			set { _isNew = value; }
		}

///<summary>
		///Is this valid to save?
		///</summary>
		public bool IsValid
		{
			get
			{
				bool _isValid = true;
%VALID%
				//business rules go here
				return _isValid;
			}
		}

#endregion

#region Record Properties
%LOCALS%

%PROPS%
		#endregion
	}

}

VB Template

Imports System
Imports System.Data
Imports System.Data.Common
Imports System.Data.SqlClient 'use DbFactories or OracleClient if rqd
Namespace %TABLE%Namespace
	''' <summary>
	''' An activeRecord (crud) wrapper of a Sql table record
	''' </summary>
	Public Class %TABLE%
		''' <summary>
		''' Default constructor
		''' </summary>
		Public Sub New()
			Init()
		End Sub

#Region "CRUD operations"
		''' <summary>
		''' Initialize stuff
		''' </summary>
		Private Sub Init()
			_IsNew = True
%INIT%
		End Sub

''' <summary>
		''' Load from database into this object. If not in database (returns false), you have an empty new record.
		''' </summary>
		''' <returns>true if loaded, false if failed</returns>
		Public Function Load(ByVal primaryKey As %PKTYPE%) As Boolean
			Dim sql As String = "%SELECTSQL%"
			'initialize an empty record
			Init()
		    %PKNAME% = primaryKey
			'grab the data
			Dim cmd As New SqlCommand(sql, OpenConnection())
			Try
%ADOPKPARAMETERS%

'singlerow hint - not used for sqlserver
				Using dr As SqlDataReader = cmd.ExecuteReader(CommandBehavior.SingleRow)

If dr.HasRows Then
						'.net 1.1
						dr.Read()
						'Advance to the one and only row
%ADOFILL%
						_IsNew = False
					Else
						'in a using block, so everything should close
						Return False
					End If
				End Using
			Catch ex As Exception
					'just rethrow so I can see it
				Throw
			Finally
				cmd.Dispose()
				CloseConnection()
			End Try
			Return True
		End Function

''' <summary>
		''' Saves the record to database. 
		''' </summary>
		''' <returns>True if saved, false if didn't</returns>
		Public Function Save() As Boolean
			If Not IsValid() Then
				Return False
			Else If _IsNew Then
				Return Insert()
			Else
				Return Update()
			End If
		End Function

Private Function Insert() As Boolean
			Dim sql As String = "%INSERTSQL%"
			Dim ret As Boolean = False
			Dim cmd As New SqlCommand(sql, OpenConnection())
			Try
%ADOALLPARAMETERS%
%ADOPKORIDENTITYPARAMETER%

If cmd.ExecuteNonQuery() > 0 Then
					_IsDirty = False
					'not dirty anymore
					ret = True
				End If
			Catch ex As Exception
					'rethrow
				Throw
			Finally
				cmd.Dispose()
				CloseConnection()
			End Try
			Return ret
		End Function

''' <summary>
		''' Update an existing record in database
		''' </summary>
		''' <returns></returns>
		Private Function Update() As Boolean
			Dim sql As String = "%UPDATESQL%"
			Dim ret As Boolean = False
			Dim cmd As New SqlCommand(sql, OpenConnection())
			Try
%ADOALLPARAMETERS%
            'primary key
%ADOPKPARAMETERS%
				If cmd.ExecuteNonQuery() > 0 Then
					_IsDirty = False
					'not dirty anymore
					ret = True
				End If
			Catch ex As Exception
					'rethrow
				Throw
			Finally
				cmd.Dispose()
				CloseConnection()
			End Try
			Return ret
		End Function

''' <summary>
		''' Delete this record from database. You don't need to Load the record first- just set the primary key(s)
		''' </summary>
		''' <returns>Returns true if deleted, or false if no records updated</returns>
		Public Function Delete() As Boolean
			Dim sql As String = "%DELETESQL%"
			Dim ret As Boolean = False
			Dim cmd As New SqlCommand(sql, OpenConnection())
			Try
%ADOPKPARAMETERS%

If cmd.ExecuteNonQuery() > 0 Then
					_IsDirty = False
					'not dirty anymore
					ret = True
				End If
			Catch ex As Exception
				Throw	'rethrow
			Finally
				cmd.Dispose()
				CloseConnection()
			End Try
			Return ret
		End Function
		#End Region

#Region "Private Connection Methods"
		''' <summary>
		''' Use either the ActiveConnection or create one from ConnectionString
		''' </summary>
		Private Function OpenConnection() As SqlConnection
			'if closed, open it (there are also states of broken, connecting etc)
			If _ActiveConnection IsNot Nothing AndAlso _ActiveConnection.State = ConnectionState.Closed Then
				_ActiveConnection.Open()
ElseIf [String].IsNullOrEmpty(_ConnectionString) Then
				'for 1.1 = if(_ConnectionString == null || _ConnectionString == "")
				Throw New ApplicationException("No connection string")
			Else
				'create a local connection which will we will close when done
				_PrivateConnection = New SqlConnection(_ConnectionString)
				_PrivateConnection.Open()
				Return _PrivateConnection
			End If
			Return _ActiveConnection
		End Function

''' <summary>
		''' Close the connection (local only- do not close a public connection)
		''' </summary>
		Private Sub CloseConnection()
			If _PrivateConnection IsNot Nothing Then
				_PrivateConnection.Close()
					'this connection may be used for something else, so don't close it
			Else
			End If
		End Sub
		#End Region

#Region "Common Properties"
		Private _ActiveConnection As SqlConnection
		Private _PrivateConnection As SqlConnection
		Private _ConnectionString As String
		Private _IsNew As Boolean

'''<summary>
		'''ActiveConnection
		'''</summary>
		Public Property ActiveConnection() As SqlConnection
			Get
				Return _ActiveConnection
			End Get
			Set
				_ActiveConnection = value
			End Set
		End Property

'''<summary>
		'''ConnectionString
		'''</summary>
		Public Property ConnectionString() As String
			Get
				Return _ConnectionString
			End Get
			Set
				If [String].IsNullOrEmpty(value) Then
					Throw New ArgumentNullException("value", "Must not be null")
				End If
				_ConnectionString = value
			End Set
		End Property

'''<summary>
		'''Is New instance (or via Load)
		'''</summary>
		Public Property IsNew() As Boolean
			Get
				Return _IsNew
			End Get
			Set
				_IsNew = value
			End Set
		End Property

'''<summary>
		'''Is this valid to save?
		'''</summary>
		Public Property IsValid() As Boolean
			Get
				Dim _IsValid As Boolean = False
%VALID%
				'business rules go here
				Return _IsValid
			End Get
		End Property

#End Region

#Region "Record Properties"
%LOCALS%

%PROPS%
		#End Region
	End Class

End Namespace

static void

Prop-o-matic