Índice de la sección dedicada a .NET (en el Guille)

CrearClase

El código de la librería para generar clases para acceder a una tabla

Código para Visual Basic.NET (VB.NET)

Código para C Sharp (C#)

Actualizado: 14/Jul/2004
Autor: Guillermo 'guille' Som

Volver al índice de Generar clases para acceder a una tabla o al de la librería

El código de la librería: CrearClase, CrearClaseOleDb, CrearClaseSQL, ConvLang

 

Código para Visual Basic.NET (VB.NET) El código de Visual Basic .NET

'------------------------------------------------------------------------------
' Clase genérica para crear una clase                               (13/Jul/04)
' Esta clase se usará como base de las de SQL y OleDb
'
' ©Guillermo 'guille' Som, 2004
'------------------------------------------------------------------------------
Option Strict On
Option Explicit On 
'
Imports Microsoft.VisualBasic
Imports System
Imports System.Collections
'
Imports System.Data
Imports System.Data.SqlClient
Imports System.Data.OleDb

Namespace elGuille.Data.CodeGenerator
    Public Class CrearClase
        '
        Protected Shared mDataTable As New DataTable
        Protected Shared cadenaConexion As String
        Protected Shared nombreTabla As String = "Tabla1"
        '
        Public Shared Conectado As Boolean
        '
        ' Campos para usar desde las clases derivadas
        ' para usar con SQL
        Private Shared dataSource As String
        Private Shared initialCatalog As String
        Private Shared userId As String
        Private Shared usarSeguridadSQL As Boolean
        '
        ' para usar con OleDb (Access)
        Private Shared baseDeDatos As String
        Private Shared provider As String
        '
        ' para ambos tipos de bases de datos
        Private Shared usarCommandBuilder As Boolean = True
        Private Shared dbPrefix As String = "Sql"
        Private Shared password As String
        Private Shared esSQL As Boolean
        Private Shared lang As eLenguaje
        Private Shared nombreClase As String
        Private Shared cadenaSelect As String
        '
        ' estos métodos sólo se usarán desde las clases derivadas
        Protected Shared Function GenerarClaseOleDb(ByVal lang As eLenguaje, _
                                                    ByVal usarCommandBuilder As Boolean, _
                                                    ByVal nombreClase As String, _
                                                    ByVal baseDeDatos As String, _
                                                    ByVal cadenaSelect As String, _
                                                    ByVal password As String, _
                                                    ByVal provider As String) As String
            esSQL = False
            If provider = "" Then
                provider = "Microsoft.Jet.OLEDB.4.0"
            End If
            CrearClase.lang = lang
            CrearClase.usarCommandBuilder = usarCommandBuilder
            CrearClase.baseDeDatos = baseDeDatos
            CrearClase.nombreClase = nombreClase
            CrearClase.cadenaSelect = cadenaSelect
            CrearClase.password = password
            CrearClase.provider = provider
            dbPrefix = "OleDb"
            '
            Return generarClase()
        End Function
        '
        Protected Shared Function GenerarClaseSQL(ByVal lang As eLenguaje, _
                                                  ByVal usarCommandBuilder As Boolean, _
                                                  ByVal nombreClase As String, _
                                                  ByVal dataSource As String, _
                                                  ByVal initialCatalog As String, _
                                                  ByVal cadenaSelect As String, _
                                                  ByVal userId As String, _
                                                  ByVal password As String, _
                                                  ByVal usarSeguridadSQL As Boolean) As String
            esSQL = True
            CrearClase.lang = lang
            CrearClase.usarCommandBuilder = usarCommandBuilder
            CrearClase.nombreClase = nombreClase
            CrearClase.dataSource = dataSource
            CrearClase.initialCatalog = initialCatalog
            CrearClase.cadenaSelect = cadenaSelect
            CrearClase.userId = userId
            CrearClase.password = password
            CrearClase.usarSeguridadSQL = usarSeguridadSQL
            dbPrefix = "Sql"
            '
            Return generarClase()
        End Function
        '
        Private Shared Function generarClase() As String
            ' generar la clase a partir de la tabla seleccionada,
            ' las columnas son los campos a usar
            '
            '//////////////////////////////////////////////////////////////////
            ' TODO: Algunas cosas a mejorar                         (12/Jul/04)
            '   +No usar de forma predeterminada "ID" como campo índice
            '    intentar buscar el campo "AutoIncrement" o "Unique"
            '   +Dejar de forma predeterminada el CommandBuilder
            '    aunque el resto de comandos dejarlos comentados para revisar
            '   +Que esta función sirva tanto para SQL como para OleDb
            '    aunque haya que hacer dos funciones "intermedias"
            '    para que no haya que pasar parámetros no usados, como usarSeguridadSQL
            '   -Arreglar cuando sean datos "LongBinary -> Byte()"
            '   -Tener en cuenta que los nombres de los campos pueden tener
            '    caractes no válidos
            '//////////////////////////////////////////////////////////////////
            '
            Dim sb As New System.Text.StringBuilder
            Dim s As String
            Dim sb1 As System.Text.StringBuilder
            Dim sb2 As System.Text.StringBuilder
            Dim sb3 As System.Text.StringBuilder
            Dim campoIDnombre As String = "ID"
            Dim campoIDtipo As String = "System.Int32"
            Dim campos As New Hashtable
            Dim novalidos As String = " -ºª!|@#$%&/()=?¿*+^'¡-<>,.;:{}[]Çç€\" & Chr(34) & vbTab
            '
            ' buscar el campo autoincremental de la tabla           (12/Jul/04)
            ' también se buscará si es Unique
            For Each col As DataColumn In mDataTable.Columns
                ' comprobar si tiene caracteres no válidos          (14/Jul/04)
                ' en caso de que sea así, sustituirlos por un guión bajo
                Dim i As Integer
                s = col.ColumnName
                Do
                    i = s.IndexOfAny(novalidos.ToCharArray)
                    If i > -1 Then
                        If i = s.Length - 1 Then
                            s = s.Substring(0, i) & "_"
                        ElseIf i > 0 Then
                            s = s.Substring(0, i) & "_" & s.Substring(i + 1)
                        Else
                            s = "_" & s.Substring(i + 1)
                        End If
                    End If
                Loop While i > -1
                campos.Add(col.ColumnName, s)
                '
                ' No siempre el predeterminado es AutoIncrement
                If col.AutoIncrement OrElse col.Unique Then
                    campoIDnombre = s 'col.ColumnName
                    campoIDtipo = col.DataType.ToString
                    'Exit For
                End If
            Next
            '
            '
            ConvLang.Lang = lang
            sb.AppendFormat("{0}{1}", ConvLang.Comentario("------------------------------------------------------------------------------"), vbCrLf)
            If esSQL Then
                sb.AppendFormat("{0} Clase {1} generada automáticamente con CrearClaseSQL{2}", ConvLang.Comentario(), nombreClase, vbCrLf)
                sb.AppendFormat("{0} de la tabla '{1}' de la base '{2}'{3}", ConvLang.Comentario(), nombreTabla, initialCatalog, vbCrLf)
            Else
                sb.AppendFormat("{0} Clase {1} generada automáticamente con CrearClaseOleDb{2}", ConvLang.Comentario(), nombreClase, vbCrLf)
                sb.AppendFormat("{0} de la tabla '{1}' de la base '{2}'{3}", ConvLang.Comentario(), nombreTabla, baseDeDatos, vbCrLf)
            End If
            sb.AppendFormat("{0} Fecha: {1}{2}", ConvLang.Comentario(), DateTime.Now.ToString("dd/MMM/yyyy HH:mm:ss"), vbCrLf)
            sb.AppendFormat("{0}{1}", ConvLang.Comentario(), vbCrLf)
            If DateTime.Now.Year > 2004 Then
                sb.AppendFormat("{0}{1}", ConvLang.Comentario(String.Format(" ©Guillermo 'guille' Som, 2004-{0}", DateTime.Now.Year)), vbCrLf)
            Else
                sb.AppendFormat("{0}{1}", ConvLang.Comentario(" ©Guillermo 'guille' Som, 2004"), vbCrLf)
            End If
            sb.AppendFormat("{0}{1}", ConvLang.Comentario("------------------------------------------------------------------------------"), vbCrLf)
            '
            If lang = eLenguaje.eVBNET Then
                sb.AppendFormat("Option Strict On{0}", vbCrLf)
                sb.AppendFormat("Option Explicit On{0}", vbCrLf)
                sb.AppendFormat("{0}{1}", ConvLang.Comentario(), vbCrLf)
            End If
            ' las importaciones de espacios de nombres
            sb.AppendFormat("{0}{1}", ConvLang.Imports("System"), vbCrLf)
            sb.AppendFormat("{0}{1}", ConvLang.Imports("System.Data"), vbCrLf)
            If esSQL Then
                sb.AppendFormat("{0}{1}", ConvLang.Imports("System.Data.SqlClient"), vbCrLf)
            Else
                sb.AppendFormat("{0}{1}", ConvLang.Imports("System.Data.OleDb"), vbCrLf)
            End If
            sb.AppendFormat("{0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            ' declaración clase
            sb.AppendFormat("{0}{1}", ConvLang.Class("Public", nombreClase), vbCrLf)
            '
            '------------------------------------------------------------------
            ' los campos privados para usar con las propiedades
            '------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" Las variables privadas"), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" TODO: Revisar los tipos de los campos"), vbCrLf)
            For Each col As DataColumn In mDataTable.Columns
                'sb.AppendFormat("    {0}{1}", ConvLang.Variable("Private", "_" & col.ColumnName, col.DataType.ToString), vbCrLf)
                sb.AppendFormat("    {0}{1}", ConvLang.Variable("Private", "_" & campos(col.ColumnName).ToString, col.DataType.ToString), vbCrLf)
            Next
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(""), vbCrLf)
            '
            ' ajustarAncho: método privado para ajustar los caracteres de los campos de tipo String
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" Este método se usará para ajustar los anchos de las propiedades"), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Private", "ajustarAncho", "String", "cadena", "String", "ancho", "Integer"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.VariableNewParam("Dim", "sb", "System.Text.StringBuilder", "New String("" ""c, ancho)"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" devolver la cadena quitando los espacios en blanco"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" esto asegura que no se devolverá un tamaño mayor ni espacios ""extras"""), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Return("(cadena & sb.ToString()).Substring(0, ancho).Trim()"), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            ' Propiedades públicas de instancia
            '
            '------------------------------------------------------------------
            ' propiedades públicas mapeadas a cada columna de la tabla
            '------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" Las propiedades públicas"), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" TODO: Revisar los tipos de las propiedades"), vbCrLf)
            For Each col As DataColumn In mDataTable.Columns
                If col.DataType.ToString = "System.Byte[]" Then
                    sb.AppendFormat("    {0}{1}", ConvLang.Property("Public", "System.Byte()", campos(col.ColumnName).ToString), vbCrLf)
                Else
                    sb.AppendFormat("    {0}{1}", ConvLang.Property("Public", col.DataType.ToString, campos(col.ColumnName).ToString), vbCrLf)
                End If
                sb.AppendFormat("        {0}{1}", ConvLang.Get(), vbCrLf)
                If col.DataType.ToString <> "System.String" Then
                    sb.AppendFormat("            {0}{1}", ConvLang.Return(" _" & campos(col.ColumnName).ToString), vbCrLf)
                Else
                    If col.MaxLength > 255 Then
                        sb.AppendFormat("            {0}{1}", ConvLang.Comentario(" Seguramente sería mejor sin ajustar el ancho..."), vbCrLf)
                        sb.AppendFormat("            {0}{1}", ConvLang.Comentario(ConvLang.Return(String.Format("ajustarAncho(_{0},{1})", campos(col.ColumnName).ToString, col.MaxLength))), vbCrLf)
                        sb.AppendFormat("            {0}{1}", ConvLang.Return(" _" & campos(col.ColumnName).ToString), vbCrLf)
                    Else
                        sb.AppendFormat("            {0}{1}", ConvLang.Return(String.Format("ajustarAncho(_{0},{1})", campos(col.ColumnName).ToString, col.MaxLength)), vbCrLf)
                    End If
                End If
                sb.AppendFormat("        {0}{1}", ConvLang.EndGet(), vbCrLf)
                If col.DataType.ToString = "System.Byte[]" Then
                    sb.AppendFormat("        {0}{1}", ConvLang.Set("System.Byte()"), vbCrLf)
                Else
                    sb.AppendFormat("        {0}{1}", ConvLang.Set(col.DataType.ToString), vbCrLf)
                End If
                sb.AppendFormat("            {0}{1}", ConvLang.Asigna("_" & campos(col.ColumnName).ToString, "value"), vbCrLf)
                sb.AppendFormat("        {0}{1}", ConvLang.EndSet(), vbCrLf)
                sb.AppendFormat("    {0}{1}", ConvLang.EndProperty(), vbCrLf)
            Next
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            '------------------------------------------------------------------
            ' Item: propiedad predeterminada (indizador)
            '       permite acceder a los campos mediante un índice numérico
            '------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Property("Public", "String", "index", "Integer"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Devuelve el contenido del campo indicado en index"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" (el índice corresponde con la columna de la tabla)"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Get(), vbCrLf)
            For i As Integer = 0 To mDataTable.Columns.Count - 1
                Dim col As DataColumn = mDataTable.Columns(i)
                If i = 0 Then
                    sb.AppendFormat("            {0}{1}", ConvLang.If("index", "=", "0"), vbCrLf)
                Else
                    sb.AppendFormat("            {0}{1}", ConvLang.ElseIf("index", "=", i.ToString), vbCrLf)
                End If
                If col.DataType.ToString = "System.Byte[]" Then
                    ' TODO: convertir el array de bytes en una cadena...
                    sb.AppendFormat("                {0}{1}", ConvLang.Return("<Binario largo>"), vbCrLf)
                Else
                    sb.AppendFormat("                {0}{1}", ConvLang.Return("Me." & campos(col.ColumnName).ToString & ".ToString()"), vbCrLf)
                End If
            Next
            sb.AppendFormat("            {0}{1}", ConvLang.EndIf(), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Comentario(" Para que no de error el compilador de C#"), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Return(Chr(34) & Chr(34)), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.EndGet(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Set("String"), vbCrLf)
            For i As Integer = 0 To mDataTable.Columns.Count - 1
                Dim col As DataColumn = mDataTable.Columns(i)
                If i = 0 Then
                    sb.AppendFormat("            {0}{1}", ConvLang.If("index", "=", "0"), vbCrLf)
                Else
                    sb.AppendFormat("            {0}{1}", ConvLang.ElseIf("index", "=", i.ToString), vbCrLf)
                End If
                '
                Select Case col.DataType.ToString
                    Case "System.String"
                        sb.AppendFormat("                {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, "value"), vbCrLf)
                    Case "System.DateTime"
                        sb.AppendFormat("                {0}{1}", ConvLang.Try(), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, "System.DateTime.Parse(value)"), vbCrLf)
                        sb.AppendFormat("                {0}{1}", ConvLang.Catch(), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Comentario(" TODO: Usa el valor de fecha que quieras predeterminar"), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Comentario("       Una fecha ficticia:"), vbCrLf)
                        sb.AppendFormat("                    {0}{1}{2}", ConvLang.Comentario(), ConvLang.AsignaNew("Me." & campos(col.ColumnName).ToString, "System.DateTime", "1900, 1, 1"), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Comentario("       o la fecha de hoy:"), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, "System.DateTime.Now"), vbCrLf)
                        sb.AppendFormat("                {0}{1}", ConvLang.EndTry(), vbCrLf)
                    Case "System.Int16", "System.Int32", "System.Int64", _
                         "System.Single", "System.Decimal", "System.Double", _
                         "System.Byte", "System.SByte", "System.UInt16", "System.UInt32", "System.UInt64"
                        sb.AppendFormat("                {0}{1}", ConvLang.Try(), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, col.DataType.ToString & ".Parse(""0"" & value)"), vbCrLf)
                        sb.AppendFormat("                {0}{1}", ConvLang.Catch(), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, col.DataType.ToString & ".Parse(""0"")"), vbCrLf)
                        sb.AppendFormat("                {0}{1}", ConvLang.EndTry(), vbCrLf)
                    Case "System.Boolean"
                        sb.AppendFormat("                {0}{1}", ConvLang.Try(), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, col.DataType.ToString & ".Parse(value)"), vbCrLf)
                        sb.AppendFormat("                {0}{1}", ConvLang.Catch(), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, "False"), vbCrLf)
                        sb.AppendFormat("                {0}{1}", ConvLang.EndTry(), vbCrLf)
                    Case "System.Byte[]"
                        sb.AppendFormat("                {0} Es un Binario largo (array de Byte){1}", ConvLang.Comentario(), vbCrLf)
                        sb.AppendFormat("                {0} y por tanto no se le puede asignar el contenido de una cadena...{1}", ConvLang.Comentario(), vbCrLf)
                    Case Else
                        sb.AppendFormat("                {0}{1}", ConvLang.Comentario(" TODO: Comprobar la conversión a realizar"), vbCrLf)
                        sb.AppendFormat("                {0}{1}", ConvLang.Comentario(String.Format("       con el tipo {0}", col.DataType.ToString)), vbCrLf)
                        sb.AppendFormat("                {2}{0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, "value"), vbCrLf, ConvLang.Comentario())
                        sb.AppendFormat("                {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, col.DataType.ToString & ".Parse(value)"), vbCrLf)
                End Select
            Next
            sb.AppendFormat("            {0}{1}", ConvLang.EndIf(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.EndSet(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.EndProperty(), vbCrLf)
            '
            '------------------------------------------------------------------
            ' La propiedad Item usando el nombre de la columna      (11/Jul/04)
            '------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Property("Public", "String", "index", "String"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Devuelve el contenido del campo indicado en index"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" (el índice corresponde al nombre de la columna)"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Get(), vbCrLf)
            For i As Integer = 0 To mDataTable.Columns.Count - 1
                Dim col As DataColumn = mDataTable.Columns(i)
                If i = 0 Then
                    sb.AppendFormat("            {0}{1}", ConvLang.If("index", "=", Chr(34) & campos(col.ColumnName).ToString & Chr(34)), vbCrLf)
                Else
                    sb.AppendFormat("            {0}{1}", ConvLang.ElseIf("index", "=", Chr(34) & campos(col.ColumnName).ToString & Chr(34)), vbCrLf)
                End If
                If col.DataType.ToString = "System.Byte[]" Then
                    ' TODO: convertir el array de bytes en una cadena...
                    sb.AppendFormat("                {0}{1}", ConvLang.Return("<Binario largo>"), vbCrLf)
                Else
                    sb.AppendFormat("                {0}{1}", ConvLang.Return("Me." & campos(col.ColumnName).ToString & ".ToString()"), vbCrLf)
                End If
            Next
            sb.AppendFormat("            {0}{1}", ConvLang.EndIf(), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Comentario(" Para que no de error el compilador de C#"), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Return(Chr(34) & Chr(34)), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.EndGet(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Set("String"), vbCrLf)
            For i As Integer = 0 To mDataTable.Columns.Count - 1
                Dim col As DataColumn = mDataTable.Columns(i)
                If i = 0 Then
                    sb.AppendFormat("            {0}{1}", ConvLang.If("index", "=", Chr(34) & campos(col.ColumnName).ToString & Chr(34)), vbCrLf)
                Else
                    sb.AppendFormat("            {0}{1}", ConvLang.ElseIf("index", "=", Chr(34) & campos(col.ColumnName).ToString & Chr(34)), vbCrLf)
                End If
                '
                Select Case col.DataType.ToString
                    Case "System.String"
                        sb.AppendFormat("                {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, "value"), vbCrLf)
                    Case "System.DateTime"
                        sb.AppendFormat("                {0}{1}", ConvLang.Try(), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, "System.DateTime.Parse(value)"), vbCrLf)
                        sb.AppendFormat("                {0}{1}", ConvLang.Catch(), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Comentario(" TODO: Usa el valor de fecha que quieras predeterminar"), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Comentario("       Una fecha ficticia:"), vbCrLf)
                        sb.AppendFormat("                    {0}{1}{2}", ConvLang.Comentario(), ConvLang.AsignaNew("Me." & campos(col.ColumnName).ToString, "System.DateTime", "1900, 1, 1"), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Comentario("       o la fecha de hoy:"), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, "System.DateTime.Now"), vbCrLf)
                        sb.AppendFormat("                {0}{1}", ConvLang.EndTry(), vbCrLf)
                    Case "System.Int16", "System.Int32", "System.Int64", _
                         "System.Single", "System.Decimal", "System.Double", _
                         "System.Byte", "System.SByte", "System.UInt16", "System.UInt32", "System.UInt64"
                        sb.AppendFormat("                {0}{1}", ConvLang.Try(), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, col.DataType.ToString & ".Parse(""0"" & value)"), vbCrLf)
                        sb.AppendFormat("                {0}{1}", ConvLang.Catch(), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, col.DataType.ToString & ".Parse(""0"")"), vbCrLf)
                        sb.AppendFormat("                {0}{1}", ConvLang.EndTry(), vbCrLf)
                    Case "System.Boolean"
                        sb.AppendFormat("                {0}{1}", ConvLang.Try(), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, col.DataType.ToString & ".Parse(value)"), vbCrLf)
                        sb.AppendFormat("                {0}{1}", ConvLang.Catch(), vbCrLf)
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, "False"), vbCrLf)
                        sb.AppendFormat("                {0}{1}", ConvLang.EndTry(), vbCrLf)
                    Case "System.Byte[]"
                        '
                        sb.AppendFormat("                {0} Es un Binario largo (array de Byte){1}", ConvLang.Comentario(), vbCrLf)
                        sb.AppendFormat("                {0} y por tanto no se le puede asignar el contenido de una cadena...{1}", ConvLang.Comentario(), vbCrLf)
                    Case Else
                        sb.AppendFormat("                {0}{1}", ConvLang.Comentario(" TODO: Comprobar la conversión a realizar"), vbCrLf)
                        sb.AppendFormat("                {0}{1}", ConvLang.Comentario(String.Format("       con el tipo {0}", col.DataType.ToString)), vbCrLf)
                        sb.AppendFormat("                {2}{0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, "value"), vbCrLf, ConvLang.Comentario())
                        sb.AppendFormat("                {0}{1}", ConvLang.Asigna("Me." & campos(col.ColumnName).ToString, col.DataType.ToString & ".Parse(value)"), vbCrLf)
                End Select
            Next
            sb.AppendFormat("            {0}{1}", ConvLang.EndIf(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.EndSet(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.EndProperty(), vbCrLf)
            '
            '
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" Campos y métodos compartidos (estáticos) para gestionar la base de datos"), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            '------------------------------------------------------------------
            ' la cadena de conexión
            '------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" La cadena de conexión a la base de datos"), vbCrLf)
            sb1 = New System.Text.StringBuilder
            If lang = eLenguaje.eCS Then
                sb1.Append("@")
            End If
            If esSQL Then
                sb1.AppendFormat("""Data Source={0};", dataSource)
                sb1.AppendFormat(" Initial Catalog={0};", initialCatalog)
                If usarSeguridadSQL Then
                    sb1.AppendFormat(" user id={0}; password={1}", userId, password)
                Else
                    sb1.Append(" Integrated Security=yes;")
                End If
            Else
                If password <> "" Then
                    sb1.AppendFormat("{0}Provider={1}; Data Source={2}; Jet OLEDB:Database Password={3}", Chr(34), provider, baseDeDatos, password)
                Else
                    sb1.AppendFormat("{0}Provider={1}; Data Source={2}", Chr(34), provider, baseDeDatos)
                End If
            End If
            sb1.Append(Chr(34))
            sb.AppendFormat("    {0}{1}", ConvLang.DeclaraVariable("Private Shared", "cadenaConexion", "String", sb1.ToString), vbCrLf)
            '
            '------------------------------------------------------------------
            ' la cadena de selección (campo público)
            '------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" La cadena de selección"), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.DeclaraVariable("Public Shared", "CadenaSelect", "String", Chr(34) & cadenaSelect & Chr(34)), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            '------------------------------------------------------------------
            ' constructores
            ' Uno sin parámetros y otro que recibe la cadena de conexión
            '------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Constructor("Public", nombreClase), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.EndSub(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Constructor("Public", nombreClase, "conex", "String"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Asigna("cadenaConexion", "conex"), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.EndSub(), vbCrLf)
            '
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" Métodos compartidos (estáticos) privados"), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            '------------------------------------------------------------------
            ' row2<nombreClase>: asigna una fila de la tabla a un objeto del tipo de la clase
            '------------------------------------------------------------------
            sb.AppendFormat("    {0} asigna una fila de la tabla a un objeto {1}{2}", ConvLang.Comentario(), nombreClase, vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Private Shared", "row2" & nombreClase, nombreClase, "r", "DataRow"), vbCrLf)
            sb.AppendFormat("        {2} asigna a un objeto {0} los datos del dataRow indicado{1}", nombreClase, vbCrLf, ConvLang.Comentario())
            sb.AppendFormat("        {0}{1}", ConvLang.VariableNew("Dim", "o" & nombreClase, nombreClase), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            For Each col As DataColumn In mDataTable.Columns
                Select Case col.DataType.ToString
                    Case "System.String"
                        sb.AppendFormat("        {0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos(col.ColumnName).ToString), String.Format("r[""{0}""].ToString()", col.ColumnName)), vbCrLf)
                    Case "System.DateTime"
                        sb.AppendFormat("        {0}{1}", ConvLang.Try(), vbCrLf)
                        sb.AppendFormat("            {0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos(col.ColumnName).ToString), String.Format("DateTime.Parse(r[""{0}""].ToString())", col.ColumnName)), vbCrLf)
                        sb.AppendFormat("        {0}{1}", ConvLang.Catch(), vbCrLf)
                        sb.AppendFormat("            {0}{1}", ConvLang.Comentario(" TODO: Usa el valor de fecha que quieras predeterminar"), vbCrLf)
                        sb.AppendFormat("            {0}{1}", ConvLang.Comentario("       Una fecha ficticia:"), vbCrLf)
                        sb.AppendFormat("            {0}{1}{2}", ConvLang.Comentario(), ConvLang.AsignaNew(String.Format("o{0}.{1}", nombreClase, campos(col.ColumnName).ToString), "DateTime", "1900, 1, 1"), vbCrLf)
                        sb.AppendFormat("            {0}{1}", ConvLang.Comentario("       o la fecha de hoy:"), vbCrLf)
                        sb.AppendFormat("            {0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos(col.ColumnName).ToString), "DateTime.Now"), vbCrLf)
                        sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), vbCrLf)
                    Case "System.Int16", "System.Int32", "System.Int64", _
                         "System.Single", "System.Decimal", "System.Double", _
                         "System.Byte", "System.SByte", "System.UInt16", "System.UInt32", "System.UInt64"
                        sb.AppendFormat("        {0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos(col.ColumnName).ToString), String.Format("{1}.Parse(""0"" & r[""{0}""].ToString())", col.ColumnName, col.DataType.ToString)), vbCrLf)
                    Case "System.Boolean"
                        sb.AppendFormat("        {0}{1}", ConvLang.Try(), vbCrLf)
                        sb.AppendFormat("            {0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos(col.ColumnName).ToString), String.Format("System.Boolean.Parse(r[""{0}""].ToString())", col.ColumnName)), vbCrLf)
                        sb.AppendFormat("        {0}{1}", ConvLang.Catch(), vbCrLf)
                        sb.AppendFormat("            {0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos(col.ColumnName).ToString), "False"), vbCrLf)
                        sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), vbCrLf)
                    Case "System.Byte[]"
                        sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos(col.ColumnName).ToString), String.Format("r[""{0}""]", col.ColumnName)), vbCrLf, ConvLang.Comentario())
                    Case Else
                        ' Char, TimeSpan
                        sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" TODO: Comprobar la conversión a realizar"), vbCrLf)
                        sb.AppendFormat("        {0}{1}", ConvLang.Comentario(String.Format("       con el tipo {0}", col.DataType.ToString)), vbCrLf)
                        sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos(col.ColumnName).ToString), String.Format("r[""{0}""]", col.ColumnName)), vbCrLf, ConvLang.Comentario())
                        sb.AppendFormat("        {0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos(col.ColumnName).ToString), String.Format("{1}.Parse(r[""{0}""].ToString())", col.ColumnName, col.DataType.ToString)), vbCrLf)
                End Select
            Next
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Return("o" & nombreClase), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            '------------------------------------------------------------------
            ' <nombreClase>2Row: asigna un objeto de la clase a la fila indicada
            '------------------------------------------------------------------
            sb.AppendFormat("    {0} asigna un objeto {1} a la fila indicada{2}", ConvLang.Comentario(), nombreClase, vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Sub("Private Shared", String.Format("{0}2Row", nombreClase), "o" & nombreClase, nombreClase, "r", "DataRow"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(String.Format(" asigna un objeto {0} al dataRow indicado", nombreClase)), vbCrLf)
            For Each col As DataColumn In mDataTable.Columns
                ' Si es AutoIncrement no asignarle un valor         (10/Jul/04)
                ' si es Unique y no AutoIncrement se debe asignar   (13/Jul/04)
                If col.AutoIncrement Then 'OrElse col.Unique Then
                    sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" TODO: Comprueba si esta asignación debe hacerse"), vbCrLf)
                    sb.AppendFormat("        {0}{1}", ConvLang.Comentario("       pero mejor lo dejas comentado ya que es un campo autoincremental o único"), vbCrLf)
                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna(String.Format("r[""{0}""]", col.ColumnName), String.Format("o{0}.{1}", nombreClase, campos(col.ColumnName).ToString)), vbCrLf, ConvLang.Comentario())
                Else
                    sb.AppendFormat("        {0}{1}", ConvLang.Asigna(String.Format("r[""{0}""]", col.ColumnName), String.Format("o{0}.{1}", nombreClase, campos(col.ColumnName).ToString)), vbCrLf)
                End If
            Next
            sb.AppendFormat("    {0}{1}", ConvLang.EndSub(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            '------------------------------------------------------------------
            ' nuevo<nombreClase>: crea una nueva fila y la asigna a un objeto de la clase
            '------------------------------------------------------------------
            sb.AppendFormat("    {0} crea una nueva fila y la asigna a un objeto {1}{2}", ConvLang.Comentario(), nombreClase, vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Sub("Private Shared", "nuevo" & nombreClase, "dt", "DataTable", "o" & nombreClase, nombreClase), vbCrLf)
            sb.AppendFormat("        {2} Crear un nuevo {0}{1}", nombreClase, vbCrLf, ConvLang.Comentario())
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "dr", "DataRow", "dt.NewRow()"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "o" & nombreClase.Substring(0, 1), nombreClase, "row2" & nombreClase & "(dr)"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            For Each col As DataColumn In mDataTable.Columns
                sb.AppendFormat("        o{0}.{1} = o{2}.{1}{3}{4}", nombreClase.Substring(0, 1), campos(col.ColumnName).ToString, nombreClase, ConvLang.FinInstruccion(), vbCrLf)
            Next
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}2Row(o{1}, dr){2}{3}", nombreClase, nombreClase.Substring(0, 1), ConvLang.FinInstruccion(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Instruccion("dt.Rows.Add(dr)"), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.EndSub(), vbCrLf)
            '
            ' Métodos públicos compartidos (estáticos)
            '
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" Métodos públicos"), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            '------------------------------------------------------------------
            ' Tabla: devuelve una tabla con los datos indicados en la cadena de selección
            ' hay dos sobrecargas: una sin parámetros y
            ' otra en la que se indica la cadena de selección a usar
            '------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" devuelve una tabla con los datos indicados en la cadena de selección"), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public Shared", "Tabla", "DataTable"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Return("Tabla(CadenaSelect)"), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public Shared", "Tabla", "DataTable", "sel", "String"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(String.Format(" devuelve una tabla con los datos de la tabla {0}", nombreTabla)), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Variable("Dim", "da", dbPrefix & "DataAdapter"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.VariableNewParam("Dim", "dt", "DataTable", String.Format("{0}{1}{0}", Chr(34), nombreClase)), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Try(), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.AsignaNew("da", dbPrefix & "DataAdapter(sel, cadenaConexion)"), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("da.Fill(dt)"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Catch(), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Return("Nothing"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Return("dt"), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            '------------------------------------------------------------------
            ' Buscar                                                (10/Jul/04)
            '------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public Shared", "Buscar", nombreClase, "sWhere", "String"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Busca en la tabla los datos indicados en el parámetro"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" el parámetro contendrá lo que se usará después del WHERE"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "o" & nombreClase, nombreClase, "Nothing"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Variable("Dim", "da", dbPrefix & "DataAdapter"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.VariableNewParam("Dim", "dt", "DataTable", String.Format("{0}{1}{0}", Chr(34), nombreClase)), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Variable("Dim", "sel", "String", String.Format("{0}SELECT * FROM {1} WHERE {0} & sWhere", Chr(34), nombreTabla)), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.AsignaNew("da", dbPrefix & "DataAdapter(sel, cadenaConexion)"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Instruccion("da.Fill(dt)"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.If("dt.Rows.Count", ">", "0"), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Asigna("o" & nombreClase, "row2" & nombreClase & "(dt.Rows(0))"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.EndIf(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Return("o" & nombreClase), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            ' Métodos públicos de instancia
            '
            '------------------------------------------------------------------
            ' Actualizar: Actualiza los datos en la tabla usando la instancia actual
            '------------------------------------------------------------------
            sb.AppendFormat("    {0} Actualizar: Actualiza los datos en la tabla usando la instancia actual{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("    {0}             Si la instancia no hace referencia a un registro existente, se creará uno nuevo{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("    {0}             Para comprobar si el objeto en memoria coincide con uno existente,{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("    {0}             se comprueba si el {2} existe en la tabla.{1}", ConvLang.Comentario(), vbCrLf, campoIDnombre)
            sb.AppendFormat("    {0}             TODO: Si en lugar de {2} usas otro campo, indicalo en la cadena SELECT{1}", ConvLang.Comentario(), vbCrLf, campoIDnombre)
            sb.AppendFormat("    {0}                   También puedes usar la sobrecarga en la que se indica la cadena SELECT a usar{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public", "Actualizar", "String"), vbCrLf)
            sb.AppendFormat("        {0} TODO: Poner aquí la selección a realizar para acceder a este registro{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}       yo uso el {2} que es el identificador único de cada registro{1}", ConvLang.Comentario(), vbCrLf, campoIDnombre)
            If campoIDtipo.IndexOf("String") > -1 Then
                sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "sel", "String", String.Format("{0}SELECT * FROM {1} WHERE {2} = '{0} & Me.{2} & {0}'{0}", Chr(34), nombreTabla, campoIDnombre)), vbCrLf)
            Else
                sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "sel", "String", String.Format("{0}SELECT * FROM {1} WHERE {2} = {0} & Me.{2}.ToString()", Chr(34), nombreTabla, campoIDnombre)), vbCrLf)
            End If
            sb.AppendFormat("        {0}{1}", ConvLang.Return("Actualizar(sel)"), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), vbCrLf)
            '
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public", "Actualizar", "String", "sel", "String"), vbCrLf)
            sb.AppendFormat("        {1} Actualiza los datos indicados{0}", vbCrLf, ConvLang.Comentario())
            sb.AppendFormat("        {1} El parámetro, que es una cadena de selección, indicará el criterio de actualización{0}", vbCrLf, ConvLang.Comentario())
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {1} En caso de error, devolverá la cadena empezando por ERROR.{0}", vbCrLf, ConvLang.Comentario())
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "cnn", dbPrefix & "Connection"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "da", dbPrefix & "DataAdapter"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariableNewParam("Dim", "dt", "DataTable", String.Format("{0}{1}{0}", Chr(34), nombreClase)), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.AsignaNew("cnn", dbPrefix & "Connection", "cadenaConexion"), vbCrLf)
            sb.AppendFormat("        {0}{1}{2}", ConvLang.Comentario(), ConvLang.AsignaNew("da", dbPrefix & "DataAdapter", "CadenaSelect" & ", cnn"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.AsignaNew("da", dbPrefix & "DataAdapter", "sel, cnn"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Asigna("da.MissingSchemaAction", "MissingSchemaAction.AddWithKey"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("-------------------------------------------"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Esta no es la más óptima, pero funcionará"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("-------------------------------------------"), vbCrLf)
            sb.AppendFormat("        {2}{0}{1}", ConvLang.DeclaraVariableNewParam("Dim", "cb", dbPrefix & "CommandBuilder", "da"), vbCrLf, ConvLang.Comentario(Not usarCommandBuilder))
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna("da.UpdateCommand", "cb.GetUpdateCommand()"), vbCrLf, ConvLang.Comentario(Not usarCommandBuilder))
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("--------------------------------------------------------------------"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Esta está más optimizada pero debes comprobar que funciona bien..."), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("--------------------------------------------------------------------"), vbCrLf)
            sb.AppendFormat("        {2}{0}{1}", ConvLang.DeclaraVariable("Dim", "sCommand", "String"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Comentario(), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {2}{1} El comando UPDATE{0}", vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {2}{1} TODO: Comprobar cual es el campo de índice principal (sin duplicados){0}", vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {3}{1}       Yo compruebo que sea un campo llamado {2}, pero en tu caso puede ser otro{0}", vbCrLf, ConvLang.Comentario(), campoIDnombre, ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {3}{1}       Ese campo, (en mi caso {2}) será el que hay que poner al final junto al WHERE.{0}", vbCrLf, ConvLang.Comentario(), campoIDnombre, ConvLang.Comentario(usarCommandBuilder))
            '
            sb1 = New System.Text.StringBuilder
            sb2 = New System.Text.StringBuilder
            '
            sb1.AppendFormat("{0}UPDATE {1} SET ", Chr(34), nombreTabla)
            '
            s = ""
            For i As Integer = 0 To mDataTable.Columns.Count - 1
                Dim col As DataColumn = mDataTable.Columns(i)
                ' si el campo tiene caracteres no válidos           (14/Jul/04)
                ' ponerlo entre corchetes
                s = col.ColumnName
                If campos(col.ColumnName).ToString <> s Then
                    s = "[" & col.ColumnName & "]"
                End If
                If campos(col.ColumnName).ToString <> campoIDnombre Then
                    If esSQL Then
                        sb2.AppendFormat("{0} = @{0}, ", s)
                    Else
                        sb2.AppendFormat("{0} = ?, ", s)
                    End If
                End If
            Next
            s = sb2.ToString.TrimEnd
            If s.EndsWith(",") Then
                sb1.AppendFormat("{0} ", s.Substring(0, s.Length - 1))
            Else
                sb1.AppendFormat("{0} ", s)
            End If
            If esSQL Then
                sb1.AppendFormat(" WHERE ({1} = @{1}){0}", Chr(34), campoIDnombre)
            Else
                sb1.AppendFormat(" WHERE ({1} = ?){0}", Chr(34), campoIDnombre)
            End If
            '
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna("sCommand", sb1.ToString), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {2}{0}{1}", ConvLang.AsignaNew("da.UpdateCommand", dbPrefix & "Command", "sCommand, cnn"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            '
            If esSQL Then
                For Each col As DataColumn In mDataTable.Columns
                    Select Case col.DataType.ToString
                        Case "System.String"
                            If col.MaxLength > 255 Then
                                sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", col.MaxLength, vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                                s = String.Format("{2}@{0}{2}, SqlDbType.NText, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Chr(34))
                                sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                                s = String.Format("{2}@{0}{2}, SqlDbType.NText, {1}, {2}{0}{2}", col.ColumnName, 0, Chr(34))
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                            Else
                                s = String.Format("{2}@{0}{2}, SqlDbType.NVarChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Chr(34))
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                            End If
                        Case Else
                            sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                            s = String.Format("{1}@{0}{1}, {2}, 0, {1}{0}{1}", col.ColumnName, Chr(34), tipoSQL(col.DataType.ToString))
                            sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                    End Select
                Next
            Else
                Dim j As Integer = mDataTable.Columns.Count
                Dim k As Integer
                Dim sp(j) As String
                For k = 0 To j
                    sp(k) = "p" & (k + 1).ToString
                Next
                k = 0
                Dim sp1 As String
                Dim colID As DataColumn
                For Each col As DataColumn In mDataTable.Columns
                    If campos(col.ColumnName).ToString = campoIDnombre Then
                        colID = col
                    Else
                        sp1 = sp(k)
                        k += 1
                        Select Case col.DataType.ToString
                            Case "System.String"
                                If col.MaxLength > 255 Then
                                    sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", col.MaxLength, vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                                    s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Chr(34), sp1)
                                    sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                                    s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, 0, Chr(34), sp1)
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                                Else
                                    s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Chr(34), sp1)
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                                End If
                            Case Else
                                sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                                s = String.Format("{1}@{3}{1}, {2}, 0, {1}{0}{1}", col.ColumnName, Chr(34), tipoOleDb(col.DataType.ToString), sp1)
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                        End Select
                    End If
                Next
                sp1 = sp(j - 1)
                Select Case colID.DataType.ToString
                    Case "System.String"
                        If colID.MaxLength > 255 Then
                            sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", colID.MaxLength, vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                            s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", colID.ColumnName, colID.MaxLength, Chr(34), sp1)
                            sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                            s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", colID.ColumnName, 0, Chr(34), sp1)
                            sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                        Else
                            s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", colID.ColumnName, colID.MaxLength, Chr(34), sp1)
                            sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                        End If
                    Case Else
                        sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                        s = String.Format("{1}@{3}{1}, {2}, 0, {1}{0}{1}", colID.ColumnName, Chr(34), tipoOleDb(colID.DataType.ToString), sp1)
                        sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                End Select
                s = String.Format("{0}@{2}{0}, {1}, 0, {0}{0}", Chr(34), "OleDbType.Integer", sp(j))
                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            End If
            '
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Try(), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("da.Fill(dt)"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Catch("ex", "Exception"), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Return("""ERROR: "" & ex.Message"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            sb.AppendFormat("        {0}{1}", ConvLang.If("dt.Rows.Count", "=", "0"), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Comentario(" crear uno nuevo"), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Return("Crear()"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Else(), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion(nombreClase & "2Row(Me, dt.Rows(0))"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.EndIf(), vbCrLf)
            '
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Try(), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("da.Update(dt)"), vbCrLf)
            sb.AppendFormat("            dt.AcceptChanges(){0}{1}", ConvLang.FinInstruccion(), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Return("""Actualizado correctamente"""), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Catch("ex", "Exception"), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Return("""ERROR: "" & ex.Message"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            '------------------------------------------------------------------
            ' Crear: Crea un nuevo registro usando el contenido de la instancia
            '------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public", "Crear", "String"), vbCrLf)
            sb.AppendFormat("        {1} Crear un nuevo registro{0}", vbCrLf, ConvLang.Comentario())
            sb.AppendFormat("        {1} En caso de error, devolverá la cadena de error empezando por ERROR:.{0}", vbCrLf, ConvLang.Comentario())
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "cnn", dbPrefix & "Connection"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "da", dbPrefix & "DataAdapter"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariableNewParam("Dim", "dt", "DataTable", String.Format("{0}{1}{0}", Chr(34), nombreClase)), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.AsignaNew("cnn", dbPrefix & "Connection", "cadenaConexion"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.AsignaNew("da", dbPrefix & "DataAdapter", "CadenaSelect" & ", cnn"), vbCrLf)
            sb.AppendFormat("        {0}{1}{2}", ConvLang.Comentario(), ConvLang.AsignaNew("da", dbPrefix & "DataAdapter", "CadenaSelect" & ", cadenaConexion"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Asigna("da.MissingSchemaAction", "MissingSchemaAction.AddWithKey"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("-------------------------------------------"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Esta no es la más óptima, pero funcionará"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("-------------------------------------------"), vbCrLf)
            sb.AppendFormat("        {2}{0}{1}", ConvLang.DeclaraVariableNewParam("Dim", "cb", dbPrefix & "CommandBuilder", "da"), vbCrLf, ConvLang.Comentario(Not usarCommandBuilder))
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna("da.InsertCommand", "cb.GetInsertCommand()"), vbCrLf, ConvLang.Comentario(Not usarCommandBuilder))
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("--------------------------------------------------------------------"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Esta está más optimizada pero debes comprobar que funciona bien..."), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("--------------------------------------------------------------------"), vbCrLf)
            sb.AppendFormat("        {2}{0}{1}", ConvLang.DeclaraVariable("Dim", "sCommand", "String"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Comentario(), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {2}{0} El comando INSERT{1}", ConvLang.Comentario(), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {2}{0} TODO: No incluir el campo de clave primaria incremental{1}", ConvLang.Comentario(), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {3}{0}       Yo compruebo que sea un campo llamado {2}, pero en tu caso puede ser otro{1}", ConvLang.Comentario(), vbCrLf, campoIDnombre, ConvLang.Comentario(usarCommandBuilder))
            '
            sb1 = New System.Text.StringBuilder
            sb2 = New System.Text.StringBuilder
            sb3 = New System.Text.StringBuilder
            sb1.AppendFormat("{0}INSERT INTO {1} (", Chr(34), nombreTabla)
            '
            For i As Integer = 0 To mDataTable.Columns.Count - 1
                Dim col As DataColumn = mDataTable.Columns(i)
                s = col.ColumnName
                If campos(col.ColumnName).ToString <> s Then
                    s = "[" & col.ColumnName & "]"
                End If
                ' si no es AutoIncrement debe estar en los parámetros
                If col.AutoIncrement = False Then 'If col.ColumnName <> campoIDnombre Then
                    sb2.AppendFormat("{0}, ", s)
                    If esSQL Then
                        sb3.AppendFormat("@{0}, ", s)
                    Else
                        sb3.Append("?, ")
                    End If
                End If
            Next
            s = sb2.ToString.TrimEnd
            If s.EndsWith(",") Then
                sb1.AppendFormat("{0}", s.Substring(0, s.Length - 1))
            Else
                sb1.AppendFormat("{0}", s)
            End If
            sb1.Append(") ")
            '
            s = sb3.ToString.TrimEnd
            If s.EndsWith(",") Then
                sb1.AppendFormat(" VALUES({0})", s.Substring(0, s.Length - 1))
            Else
                sb1.AppendFormat(" VALUES({0})", s)
            End If
            '
            sb1.AppendFormat("{0}", Chr(34))
            '
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna("sCommand", sb1.ToString), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {2}{0}{1}", ConvLang.AsignaNew("da.InsertCommand", dbPrefix & "Command", "sCommand, cnn"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            '
            If esSQL Then
                For Each col As DataColumn In mDataTable.Columns
                    Select Case col.DataType.ToString
                        Case "System.String"
                            If col.MaxLength > 255 Then
                                sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", col.MaxLength, vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                                s = String.Format("{2}@{0}{2}, SqlDbType.NText, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Chr(34))
                                sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                                s = String.Format("{2}@{0}{2}, SqlDbType.NText, {1}, {2}{0}{2}", col.ColumnName, 0, Chr(34))
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                            Else
                                s = String.Format("{2}@{0}{2}, SqlDbType.NVarChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Chr(34))
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                            End If
                        Case Else
                            sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                            s = String.Format("{1}@{0}{1}, {2}, 0, {1}{0}{1}", col.ColumnName, Chr(34), tipoSQL(col.DataType.ToString))
                            sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                    End Select
                Next
            Else
                Dim j As Integer = mDataTable.Columns.Count
                Dim k As Integer
                Dim sp(j) As String
                For k = 0 To j
                    sp(k) = "p" & (k + 1).ToString
                Next
                k = 0
                Dim sp1 As String
                Dim colID As DataColumn
                For Each col As DataColumn In mDataTable.Columns
                    If campos(col.ColumnName).ToString = campoIDnombre Then
                        colID = col
                    Else
                        sp1 = sp(k)
                        k += 1
                        Select Case col.DataType.ToString
                            Case "System.String"
                                If col.MaxLength > 255 Then
                                    sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", col.MaxLength, vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                                    s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Chr(34), sp1)
                                    sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                                    s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, 0, Chr(34), sp1)
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                                Else
                                    s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Chr(34), sp1)
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                                End If
                            Case Else
                                sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                                s = String.Format("{1}@{3}{1}, {2}, 0, {1}{0}{1}", col.ColumnName, Chr(34), tipoOleDb(col.DataType.ToString), sp1)
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                        End Select
                    End If
                Next
                sp1 = sp(j - 1)
                Select Case colID.DataType.ToString
                    Case "System.String"
                        If colID.MaxLength > 255 Then
                            sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", colID.MaxLength, vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                            s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", colID.ColumnName, colID.MaxLength, Chr(34), sp1)
                            sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                            s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", colID.ColumnName, 0, Chr(34), sp1)
                            sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                        Else
                            s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", colID.ColumnName, colID.MaxLength, Chr(34), sp1)
                            sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                        End If
                    Case Else
                        sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                        s = String.Format("{1}@{3}{1}, {2}, 0, {1}{0}{1}", colID.ColumnName, Chr(34), tipoOleDb(colID.DataType.ToString), sp1)
                        sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                End Select
                s = String.Format("{0}@{2}{0}, {1}, 0, {0}{0}", Chr(34), "OleDbType.Integer", sp(j))
                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            End If
            '
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Try(), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("da.Fill(dt)"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Catch("ex", "Exception"), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Return("""ERROR: "" & ex.Message"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Instruccion("nuevo" & nombreClase & "(dt, Me)"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Try(), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("da.Update(dt)"), vbCrLf)
            sb.AppendFormat("            dt.AcceptChanges(){0}{1}", ConvLang.FinInstruccion(), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Return("""Se ha creado un nuevo " & nombreClase & Chr(34)), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Catch("ex", "Exception"), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Return("""ERROR: "" & ex.Message"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            '------------------------------------------------------------------
            ' Borrar: Borra el registro con el mismo ID que tenga la clase
            '         En caso de que quieras usar otro criterio para comprobar cual es el registro actual
            '         cambia la comparación
            '------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public", "Borrar", "String"), vbCrLf)
            sb.AppendFormat("        {0} TODO: Poner aquí la selección a realizar para acceder a este registro{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}       yo uso el {2} que es el identificador único de cada registro{1}", ConvLang.Comentario(), vbCrLf, campoIDnombre)
            If campoIDtipo.IndexOf("String") > -1 Then
                sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "sel", "String", String.Format("{0}SELECT * FROM {1} WHERE {2} = '{0} & Me.{2} & {0}'{0}", Chr(34), nombreTabla, campoIDnombre)), vbCrLf)
            Else
                sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "sel", "String", String.Format("{0}SELECT * FROM {1} WHERE {2} = {0} & Me.{2}.ToString()", Chr(34), nombreTabla, campoIDnombre)), vbCrLf)
            End If
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Return("Borrar(sel)"), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), vbCrLf)
            '
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public", "Borrar", "String", "sel", "String"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Borrar el registro al que apunta esta clase"), vbCrLf)
            sb.AppendFormat("        {1} En caso de error, devolverá la cadena de error empezando por ERROR:.{0}", vbCrLf, ConvLang.Comentario())
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "cnn", dbPrefix & "Connection"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "da", dbPrefix & "DataAdapter"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariableNewParam("Dim", "dt", "DataTable", String.Format("{0}{1}{0}", Chr(34), nombreClase)), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.AsignaNew("cnn", dbPrefix & "Connection", "cadenaConexion"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.AsignaNew("da", dbPrefix & "DataAdapter", "sel, cnn"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Asigna("da.MissingSchemaAction", "MissingSchemaAction.AddWithKey"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("-------------------------------------------"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Esta no es la más óptima, pero funcionará"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("-------------------------------------------"), vbCrLf)
            sb.AppendFormat("        {2}{0}{1}", ConvLang.DeclaraVariableNewParam("Dim", "cb", dbPrefix & "CommandBuilder", "da"), vbCrLf, ConvLang.Comentario(Not usarCommandBuilder))
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna("da.DeleteCommand", "cb.GetDeleteCommand()"), vbCrLf, ConvLang.Comentario(Not usarCommandBuilder))
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("--------------------------------------------------------------------"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Esta está más optimizada pero debes comprobar que funciona bien..."), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("--------------------------------------------------------------------"), vbCrLf)
            sb.AppendFormat("        {2}{0}{1}", ConvLang.DeclaraVariable("Dim", "sCommand", "String"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Comentario(), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {2}{0} El comando DELETE{1}", ConvLang.Comentario(), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {2}{0} TODO: Sólo incluir el campo de clave primaria incremental{1}", ConvLang.Comentario(), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {3}{0}       Yo compruebo que sea un campo llamado {2}, pero en tu caso puede ser otro{1}", ConvLang.Comentario(), vbCrLf, campoIDnombre, ConvLang.Comentario(usarCommandBuilder))
            '
            sb1 = New System.Text.StringBuilder
            If esSQL Then
                sb1.AppendFormat("{0}DELETE FROM {1} WHERE ({2} = @p1){0}", Chr(34), nombreTabla, campoIDnombre)
            Else
                sb1.AppendFormat("{0}DELETE FROM {1} WHERE ({2} = ?){0}", Chr(34), nombreTabla, campoIDnombre)
            End If
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna("sCommand", sb1.ToString), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            sb.AppendFormat("        {2}{0}{1}", ConvLang.AsignaNew("da.DeleteCommand", dbPrefix & "Command", "sCommand, cnn"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            '
            If esSQL Then
                For Each col As DataColumn In mDataTable.Columns
                    If campos(col.ColumnName).ToString = campoIDnombre Then
                        Select Case col.DataType.ToString
                            Case "System.String"
                                If col.MaxLength > 255 Then
                                    sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", col.MaxLength, vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                                    s = String.Format("{2}@p1{2}, SqlDbType.NText, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Chr(34))
                                    sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                                    s = String.Format("{2}@p1{2}, SqlDbType.NText, {1}, {2}{0}{2}", col.ColumnName, 0, Chr(34))
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                                Else
                                    s = String.Format("{2}@p1{2}, SqlDbType.NVarChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Chr(34))
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                                End If
                            Case Else
                                sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                                s = String.Format("{1}@p1{1}, {2}, 0, {1}{0}{1}", col.ColumnName, Chr(34), tipoSQL(col.DataType.ToString))
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                        End Select
                        Exit For
                    End If
                Next
                s = String.Format("{0}@p2{0}, {1}, 0, {0}{0}", Chr(34), "SqlDbType.Int")
                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            Else
                For Each col As DataColumn In mDataTable.Columns
                    If campos(col.ColumnName).ToString = campoIDnombre Then
                        Select Case col.DataType.ToString
                            Case "System.String"
                                If col.MaxLength > 255 Then
                                    sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", col.MaxLength, vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                                    s = String.Format("{2}@p1{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Chr(34))
                                    sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                                    s = String.Format("{2}@p1{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, 0, Chr(34))
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                                Else
                                    s = String.Format("{2}@p1{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Chr(34))
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                                End If
                            Case Else
                                sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", vbCrLf, ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder))
                                s = String.Format("{1}@p1{1}, {2}, 0, {1}{0}{1}", col.ColumnName, Chr(34), tipoOleDb(col.DataType.ToString))
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
                        End Select
                        Exit For
                    End If
                Next
                s = String.Format("{0}@p2{0}, {1}, 0, {0}{0}", Chr(34), "OleDbType.Integer")
                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" & s & ")"), vbCrLf, ConvLang.Comentario(usarCommandBuilder))
            End If
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Instruccion("da.Fill(dt)"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.If("dt.Rows.Count", "=", "0"), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Return("""ERROR: No hay datos"""), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Else(), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("dt.Rows(0).Delete()"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.EndIf(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Try(), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("da.Update(dt)"), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("dt.AcceptChanges()"), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Return("""Borrado satisfactoriamente"""), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.Catch("ex", "Exception"), vbCrLf)
            sb.AppendFormat("            {0}{1}", ConvLang.Return("""ERROR: "" & ex.Message"), vbCrLf)
            sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), vbCrLf)
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), vbCrLf)
            '
            sb.AppendFormat("{0}{1}", ConvLang.EndClass(), vbCrLf)
            '
            Return sb.ToString
        End Function
        '
        Private Shared Function tipoSQL(ByVal elTipo As String) As String
            Dim aCTS() As String = {"System.Boolean", "System.Int16", "System.Int32", "System.Int64", _
                                    "System.Decimal", "System.Single", "System.Double", "System.Byte", _
                                    "System.DateTime", "System.Guid", "System.Object"}
            Dim aSQL() As String = {"Bit", "SmallInt", "Int", "BigInt", _
                                    "Decimal", "Real", "Float", "TinyInt", _
                                    "DateTime", "UniqueIdentifier", "Variant"}
            Dim i As Integer = Array.IndexOf(aCTS, elTipo)
            If i > -1 Then
                Return "SqlDbType." & aSQL(i)
            End If
            Return "SqlDbType.Int"
        End Function
        '
        Private Shared Function tipoOleDb(ByVal elTipo As String) As String
            Dim aCTS() As String = {"System.Byte[]", "System.Boolean", "System.Int16", "System.Int32", "System.Int64", _
                                    "System.Decimal", "System.Single", "System.Double", "System.Byte", _
                                    "System.DateTime", "System.Guid", "System.Object", "System.String"}
            Dim aOle() As String = {"LongVarBinary", "Boolean", "SmallInt", "Integer", "BigInt", _
                                    "Decimal", "Single", "Double", "UnsignedTinyInt", _
                                    "Date", "Guid", "Variant", "VarWChar"}
            Dim i As Integer = Array.IndexOf(aCTS, elTipo)
            If i > -1 Then
                Return "OleDbType." & aOle(i)
            End If
            Return "OleDbType.Integer"
        End Function
    End Class
End Namespace

...

Código para C Sharp (C#) El código de C#

//------------------------------------------------------------------------------
// Clase genérica para crear una clase                               (13/Jul/04)
// Esta clase se usará como base de las de SQL y OleDb
//
// ©Guillermo 'guille' Som, 2004
//------------------------------------------------------------------------------
//
using System;
using System.Collections;
//
using System.Data;
using System.Data.SqlClient;
using System.Data.OleDb;
 
namespace elGuille.Data.CodeGenerator
{
    public class CrearClase
    {
        //
        protected static DataTable mDataTable = new DataTable();
        protected static string cadenaConexion;
        protected static string nombreTabla = "Tabla1";
        //
        public static bool Conectado;
        //
        // Campos para usar desde las clases derivadas
        // para usar con SQL
        private static string dataSource;
        private static string initialCatalog;
        private static string userId;
        private static bool usarSeguridadSQL;
        //
        // para usar con OleDb (Access)
        private static string baseDeDatos;
        private static string provider;
        //
        // para ambos tipos de bases de datos
        private static bool usarCommandBuilder = true;
        private static string dbPrefix = "Sql";
        private static string password;
        private static bool esSQL;
        private static eLenguaje lang;
        private static string nombreClase;
        private static string cadenaSelect;
        //
        // estos métodos sólo se usarán desde las clases derivadas
        protected static string GenerarClaseOleDb(eLenguaje lang, bool usarCommandBuilder, string nombreClase, string baseDeDatos, string cadenaSelect, string password, string provider) 
        {
            esSQL = false;
            if( provider == "" )
            {
                provider = "Microsoft.Jet.OLEDB.4.0";
            }
            CrearClase.lang = lang;
            CrearClase.usarCommandBuilder = usarCommandBuilder;
            CrearClase.baseDeDatos = baseDeDatos;
            CrearClase.nombreClase = nombreClase;
            CrearClase.cadenaSelect = cadenaSelect;
            CrearClase.password = password;
            CrearClase.provider = provider;
            dbPrefix = "OleDb";
            //
            return generarClase();
        }  
        //
        protected static string GenerarClaseSQL(eLenguaje lang, bool usarCommandBuilder, string nombreClase, string dataSource, string initialCatalog, string cadenaSelect, string userId, string password, bool usarSeguridadSQL) 
        {
            esSQL = true;
            CrearClase.lang = lang;
            CrearClase.usarCommandBuilder = usarCommandBuilder;
            CrearClase.nombreClase = nombreClase;
            CrearClase.dataSource = dataSource;
            CrearClase.initialCatalog = initialCatalog;
            CrearClase.cadenaSelect = cadenaSelect;
            CrearClase.userId = userId;
            CrearClase.password = password;
            CrearClase.usarSeguridadSQL = usarSeguridadSQL;
            dbPrefix = "Sql";
            //
            return generarClase();
        }  
        //
        private static string generarClase() 
        {
            // generar la clase a partir de la tabla seleccionada,
            // las columnas son los campos a usar
            //
            ////////////////////////////////////////////////////////////////////
            // TODO: Algunas cosas a mejorar                         (12/Jul/04)
            //   +No usar de forma predeterminada "ID" como campo índice
            //    intentar buscar el campo "AutoIncrement" o "Unique"
            //   +Dejar de forma predeterminada el CommandBuilder
            //    aunque el resto de comandos dejarlos comentados para revisar
            //   +Que esta función sirva tanto para SQL como para OleDb
            //    aunque haya que hacer dos funciones "intermedias"
            //    para que no haya que pasar parámetros no usados, como usarSeguridadSQL
            //   -Arreglar cuando sean datos "LongBinary -> Byte()"
            //   -Tener en cuenta que los nombres de los campos pueden tener
            //    caractes no válidos
            ////////////////////////////////////////////////////////////////////
            //
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            string s;
            System.Text.StringBuilder sb1;
            System.Text.StringBuilder sb2;
            System.Text.StringBuilder sb3;
            string campoIDnombre = "ID";
            string campoIDtipo = "System.Int32";
            Hashtable campos = new Hashtable();
            string novalidos = @" -ºª!|@#$%&/()=?¿*+^'¡-<>,.;:{}[]Çç€\" + Convert.ToString((char)34) + "\t";
            //
            // buscar el campo autoincremental de la tabla           (12/Jul/04)
            // también se buscará si es Unique
            foreach(DataColumn col in mDataTable.Columns)
            {
                // comprobar si tiene caracteres no válidos          (14/Jul/04)
                // en caso de que sea así, sustituirlos por un guión bajo
                int i;
                s = col.ColumnName;
                do
                {
                    i = s.IndexOfAny(novalidos.ToCharArray());
                    if( i > -1 )
                    {
                        if( i == s.Length - 1 )
                        {
                            s = s.Substring(0, i) + "_";
                        }
                        else if( i > 0 )
                        {
                            s = s.Substring(0, i) + "_" + s.Substring(i + 1);
                        }
                        else
                        {
                            s = "_" + s.Substring(i + 1);
                        }
                    }
                }while( i > -1);
                campos.Add(col.ColumnName, s);
                //
                // No siempre el predeterminado es AutoIncrement
                if( col.AutoIncrement || col.Unique )
                {
                    campoIDnombre = s; //col.ColumnName
                    campoIDtipo = col.DataType.ToString();
                    //Exit For
                }
            }
            //
            //
            ConvLang.Lang = lang;
            sb.AppendFormat("{0}{1}", ConvLang.Comentario("------------------------------------------------------------------------------"), "\r\n");
            if( esSQL )
            {
                sb.AppendFormat("{0} Clase {1} generada automáticamente con CrearClaseSQL{2}", ConvLang.Comentario(), nombreClase, "\r\n");
                sb.AppendFormat("{0} de la tabla '{1}' de la base '{2}'{3}", ConvLang.Comentario(), nombreTabla, initialCatalog, "\r\n");
            }
            else
            {
                sb.AppendFormat("{0} Clase {1} generada automáticamente con CrearClaseOleDb{2}", ConvLang.Comentario(), nombreClase, "\r\n");
                sb.AppendFormat("{0} de la tabla '{1}' de la base '{2}'{3}", ConvLang.Comentario(), nombreTabla, baseDeDatos, "\r\n");
            }
            sb.AppendFormat("{0} Fecha: {1}{2}", ConvLang.Comentario(), DateTime.Now.ToString("dd/MMM/yyyy HH:mm:ss"), "\r\n");
            sb.AppendFormat("{0}{1}", ConvLang.Comentario(), "\r\n");
            if( DateTime.Now.Year > 2004 )
            {
                sb.AppendFormat("{0}{1}", ConvLang.Comentario(String.Format(" ©Guillermo 'guille' Som, 2004-{0}", DateTime.Now.Year)), "\r\n");
            }
            else
            {
                sb.AppendFormat("{0}{1}", ConvLang.Comentario(" ©Guillermo 'guille' Som, 2004"), "\r\n");
            }
            sb.AppendFormat("{0}{1}", ConvLang.Comentario("------------------------------------------------------------------------------"), "\r\n");
            //
            if( lang == eLenguaje.eVBNET )
            {
                sb.AppendFormat("Option Strict On{0}", "\r\n");
                sb.AppendFormat("Option Explicit On{0}", "\r\n");
                sb.AppendFormat("{0}{1}", ConvLang.Comentario(), "\r\n");
            }
            // las importaciones de espacios de nombres
            sb.AppendFormat("{0}{1}", ConvLang.Imports("System"), "\r\n");
            sb.AppendFormat("{0}{1}", ConvLang.Imports("System.Data"), "\r\n");
            if( esSQL )
            {
                sb.AppendFormat("{0}{1}", ConvLang.Imports("System.Data.SqlClient"), "\r\n");
            }
            else
            {
                sb.AppendFormat("{0}{1}", ConvLang.Imports("System.Data.OleDb"), "\r\n");
            }
            sb.AppendFormat("{0}{1}", ConvLang.Comentario(), "\r\n");
            //
            // declaración clase
            sb.AppendFormat("{0}{1}", ConvLang.Class("Public", nombreClase), "\r\n");
            //
            //------------------------------------------------------------------
            // los campos privados para usar con las propiedades
            //------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" Las variables privadas"), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" TODO: Revisar los tipos de los campos"), "\r\n");
            foreach(DataColumn col in mDataTable.Columns)
            {
                //sb.AppendFormat("    {0}{1}", ConvLang.Variable("Private", "_" & col.ColumnName, col.DataType.ToString), vbCrLf)
                sb.AppendFormat("    {0}{1}", ConvLang.Variable("Private", "_" + campos[col.ColumnName].ToString(), col.DataType.ToString()), "\r\n");
            }
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(""), "\r\n");
            //
            // ajustarAncho: método privado para ajustar los caracteres de los campos de tipo String
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" Este método se usará para ajustar los anchos de las propiedades"), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Private", "ajustarAncho", "String", "cadena", "String", "ancho", "Integer"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.VariableNewParam("Dim", "sb", "System.Text.StringBuilder", "New String(\" \"c, ancho)"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" devolver la cadena quitando los espacios en blanco"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" esto asegura que no se devolverá un tamaño mayor ni espacios \"extras\""), "\r\n");
                                                                                                                                                        sb.AppendFormat("        {0}{1}", ConvLang.Return("(cadena & sb.ToString()).Substring(0, ancho).Trim()"), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            // Propiedades públicas de instancia
            //
            //------------------------------------------------------------------
            // propiedades públicas mapeadas a cada columna de la tabla
            //------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" Las propiedades públicas"), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" TODO: Revisar los tipos de las propiedades"), "\r\n");
            foreach(DataColumn col in mDataTable.Columns)
            {
                if( col.DataType.ToString() == "System.Byte[]" )
                {
                    sb.AppendFormat("    {0}{1}", ConvLang.Property("Public", "System.Byte()", campos[col.ColumnName].ToString()), "\r\n");
                }
                else
                {
                    sb.AppendFormat("    {0}{1}", ConvLang.Property("Public", col.DataType.ToString(), campos[col.ColumnName].ToString()), "\r\n");
                }
                sb.AppendFormat("        {0}{1}", ConvLang.Get(), "\r\n");
                if( col.DataType.ToString() != "System.String" )
                {
                    sb.AppendFormat("            {0}{1}", ConvLang.Return(" _" + campos[col.ColumnName].ToString()), "\r\n");
                }
                else
                {
                    if( col.MaxLength > 255 )
                    {
                        sb.AppendFormat("            {0}{1}", ConvLang.Comentario(" Seguramente sería mejor sin ajustar el ancho..."), "\r\n");
                        sb.AppendFormat("            {0}{1}", ConvLang.Comentario(ConvLang.Return(String.Format("ajustarAncho(_{0},{1})", campos[col.ColumnName].ToString(), col.MaxLength))), "\r\n");
                        sb.AppendFormat("            {0}{1}", ConvLang.Return(" _" + campos[col.ColumnName].ToString()), "\r\n");
                    }
                    else
                    {
                        sb.AppendFormat("            {0}{1}", ConvLang.Return(String.Format("ajustarAncho(_{0},{1})", campos[col.ColumnName].ToString(), col.MaxLength)), "\r\n");
                    }
                }
                sb.AppendFormat("        {0}{1}", ConvLang.EndGet(), "\r\n");
                if( col.DataType.ToString() == "System.Byte[]" )
                {
                    sb.AppendFormat("        {0}{1}", ConvLang.Set("System.Byte()"), "\r\n");
                }
                else
                {
                    sb.AppendFormat("        {0}{1}", ConvLang.Set(col.DataType.ToString()), "\r\n");
                }
                sb.AppendFormat("            {0}{1}", ConvLang.Asigna("_" + campos[col.ColumnName].ToString(), "value"), "\r\n");
                sb.AppendFormat("        {0}{1}", ConvLang.EndSet(), "\r\n");
                sb.AppendFormat("    {0}{1}", ConvLang.EndProperty(), "\r\n");
            }
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            //------------------------------------------------------------------
            // Item: propiedad predeterminada (indizador)
            //       permite acceder a los campos mediante un índice numérico
            //------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Property("Public", "String", "index", "Integer"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Devuelve el contenido del campo indicado en index"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" (el índice corresponde con la columna de la tabla)"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Get(), "\r\n");
            for(int i= 0; i<= mDataTable.Columns.Count - 1; i++)
            {
                DataColumn col = mDataTable.Columns[i];
                if( i == 0 )
                {
                    sb.AppendFormat("            {0}{1}", ConvLang.If("index", "=", "0"), "\r\n");
                }
                else
                {
                    sb.AppendFormat("            {0}{1}", ConvLang.ElseIf("index", "=", i.ToString()), "\r\n");
                }
                if( col.DataType.ToString() == "System.Byte[]" )
                {
                    // TODO: convertir el array de bytes en una cadena...
                    sb.AppendFormat("                {0}{1}", ConvLang.Return("<Binario largo>"), "\r\n");
                }
                else
                {
                    sb.AppendFormat("                {0}{1}", ConvLang.Return("Me." + campos[col.ColumnName].ToString() + ".ToString()"), "\r\n");
                }
            }
            sb.AppendFormat("            {0}{1}", ConvLang.EndIf(), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Comentario(" Para que no de error el compilador de C#"), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Return(Convert.ToString((char)34) + Convert.ToString((char)34)), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.EndGet(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Set("String"), "\r\n");
            for(int i= 0; i<= mDataTable.Columns.Count - 1; i++)
            {
                DataColumn col = mDataTable.Columns[i];
                if( i == 0 )
                {
                    sb.AppendFormat("            {0}{1}", ConvLang.If("index", "=", "0"), "\r\n");
                }
                else
                {
                    sb.AppendFormat("            {0}{1}", ConvLang.ElseIf("index", "=", i.ToString()), "\r\n");
                }
                //
                switch(col.DataType.ToString())
                {
                    case "System.String":
                        sb.AppendFormat("                {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), "value"), "\r\n");
                        break;
                    case "System.DateTime":
                        sb.AppendFormat("                {0}{1}", ConvLang.Try(), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), "System.DateTime.Parse(value)"), "\r\n");
                        sb.AppendFormat("                {0}{1}", ConvLang.Catch(), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Comentario(" TODO: Usa el valor de fecha que quieras predeterminar"), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Comentario("       Una fecha ficticia:"), "\r\n");
                        sb.AppendFormat("                    {0}{1}{2}", ConvLang.Comentario(), ConvLang.AsignaNew("Me." + campos[col.ColumnName].ToString(), "System.DateTime", "1900, 1, 1"), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Comentario("       o la fecha de hoy:"), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), "System.DateTime.Now"), "\r\n");
                        sb.AppendFormat("                {0}{1}", ConvLang.EndTry(), "\r\n");
                        break;
                    case "System.Int16":
                    case "System.Int32": case "System.Int64": case "System.Single": case "System.Decimal": case "System.Double": case "System.Byte": case "System.SByte": case "System.UInt16": case "System.UInt32": case "System.UInt64":
                        sb.AppendFormat("                {0}{1}", ConvLang.Try(), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), col.DataType.ToString() + ".Parse(\"0\" & value)"), "\r\n");
                        sb.AppendFormat("                {0}{1}", ConvLang.Catch(), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), col.DataType.ToString() + ".Parse(\"0\")"), "\r\n");
                        sb.AppendFormat("                {0}{1}", ConvLang.EndTry(), "\r\n");
                        break;
                    case "System.Boolean":
                        sb.AppendFormat("                {0}{1}", ConvLang.Try(), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), col.DataType.ToString() + ".Parse(value)"), "\r\n");
                        sb.AppendFormat("                {0}{1}", ConvLang.Catch(), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), "False"), "\r\n");
                        sb.AppendFormat("                {0}{1}", ConvLang.EndTry(), "\r\n");
                        break;
                    case "System.Byte[]":
                        sb.AppendFormat("                {0} Es un Binario largo (array de Byte){1}", ConvLang.Comentario(), "\r\n");
                        sb.AppendFormat("                {0} y por tanto no se le puede asignar el contenido de una cadena...{1}", ConvLang.Comentario(), "\r\n");
                        break;
                    default:
                        sb.AppendFormat("                {0}{1}", ConvLang.Comentario(" TODO: Comprobar la conversión a realizar"), "\r\n");
                        sb.AppendFormat("                {0}{1}", ConvLang.Comentario(String.Format("       con el tipo {0}", col.DataType.ToString())), "\r\n");
                        sb.AppendFormat("                {2}{0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), "value"), "\r\n", ConvLang.Comentario());
                        sb.AppendFormat("                {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), col.DataType.ToString() + ".Parse(value)"), "\r\n");
                        break; }
            }
            sb.AppendFormat("            {0}{1}", ConvLang.EndIf(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.EndSet(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.EndProperty(), "\r\n");
            //
            //------------------------------------------------------------------
            // La propiedad Item usando el nombre de la columna      (11/Jul/04)
            //------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Property("Public", "String", "index", "String"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Devuelve el contenido del campo indicado en index"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" (el índice corresponde al nombre de la columna)"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Get(), "\r\n");
            for(int i= 0; i<= mDataTable.Columns.Count - 1; i++)
            {
                DataColumn col = mDataTable.Columns[i];
                if( i == 0 )
                {
                    sb.AppendFormat("            {0}{1}", ConvLang.If("index", "=", Convert.ToString((char)34) + campos[col.ColumnName].ToString() + Convert.ToString((char)34)), "\r\n");
                }
                else
                {
                    sb.AppendFormat("            {0}{1}", ConvLang.ElseIf("index", "=", Convert.ToString((char)34) + campos[col.ColumnName].ToString() + Convert.ToString((char)34)), "\r\n");
                }
                if( col.DataType.ToString() == "System.Byte[]" )
                {
                    // TODO: convertir el array de bytes en una cadena...
                    sb.AppendFormat("                {0}{1}", ConvLang.Return("<Binario largo>"), "\r\n");
                }
                else
                {
                    sb.AppendFormat("                {0}{1}", ConvLang.Return("Me." + campos[col.ColumnName].ToString() + ".ToString()"), "\r\n");
                }
            }
            sb.AppendFormat("            {0}{1}", ConvLang.EndIf(), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Comentario(" Para que no de error el compilador de C#"), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Return(Convert.ToString((char)34) + Convert.ToString((char)34)), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.EndGet(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Set("String"), "\r\n");
            for(int i= 0; i<= mDataTable.Columns.Count - 1; i++)
            {
                DataColumn col = mDataTable.Columns[i];
                if( i == 0 )
                {
                    sb.AppendFormat("            {0}{1}", ConvLang.If("index", "=", Convert.ToString((char)34) + campos[col.ColumnName].ToString() + Convert.ToString((char)34)), "\r\n");
                }
                else
                {
                    sb.AppendFormat("            {0}{1}", ConvLang.ElseIf("index", "=", Convert.ToString((char)34) + campos[col.ColumnName].ToString() + Convert.ToString((char)34)), "\r\n");
                }
                //
                switch(col.DataType.ToString())
                {
                    case "System.String":
                        sb.AppendFormat("                {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), "value"), "\r\n");
                        break;
                    case "System.DateTime":
                        sb.AppendFormat("                {0}{1}", ConvLang.Try(), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), "System.DateTime.Parse(value)"), "\r\n");
                        sb.AppendFormat("                {0}{1}", ConvLang.Catch(), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Comentario(" TODO: Usa el valor de fecha que quieras predeterminar"), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Comentario("       Una fecha ficticia:"), "\r\n");
                        sb.AppendFormat("                    {0}{1}{2}", ConvLang.Comentario(), ConvLang.AsignaNew("Me." + campos[col.ColumnName].ToString(), "System.DateTime", "1900, 1, 1"), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Comentario("       o la fecha de hoy:"), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), "System.DateTime.Now"), "\r\n");
                        sb.AppendFormat("                {0}{1}", ConvLang.EndTry(), "\r\n");
                        break;
                    case "System.Int16":
                    case "System.Int32": case "System.Int64": case "System.Single": case "System.Decimal": case "System.Double": case "System.Byte": case "System.SByte": case "System.UInt16": case "System.UInt32": case "System.UInt64":
                        sb.AppendFormat("                {0}{1}", ConvLang.Try(), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), col.DataType.ToString() + ".Parse(\"0\" & value)"), "\r\n");
                        sb.AppendFormat("                {0}{1}", ConvLang.Catch(), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), col.DataType.ToString() + ".Parse(\"0\")"), "\r\n");
                        sb.AppendFormat("                {0}{1}", ConvLang.EndTry(), "\r\n");
                        break;
                    case "System.Boolean":
                        sb.AppendFormat("                {0}{1}", ConvLang.Try(), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), col.DataType.ToString() + ".Parse(value)"), "\r\n");
                        sb.AppendFormat("                {0}{1}", ConvLang.Catch(), "\r\n");
                        sb.AppendFormat("                    {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), "False"), "\r\n");
                        sb.AppendFormat("                {0}{1}", ConvLang.EndTry(), "\r\n");
                        break;
                    case "System.Byte[]":
                        //
                        sb.AppendFormat("                {0} Es un Binario largo (array de Byte){1}", ConvLang.Comentario(), "\r\n");
                        sb.AppendFormat("                {0} y por tanto no se le puede asignar el contenido de una cadena...{1}", ConvLang.Comentario(), "\r\n");
                        break;
                    default:
                        sb.AppendFormat("                {0}{1}", ConvLang.Comentario(" TODO: Comprobar la conversión a realizar"), "\r\n");
                        sb.AppendFormat("                {0}{1}", ConvLang.Comentario(String.Format("       con el tipo {0}", col.DataType.ToString())), "\r\n");
                        sb.AppendFormat("                {2}{0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), "value"), "\r\n", ConvLang.Comentario());
                        sb.AppendFormat("                {0}{1}", ConvLang.Asigna("Me." + campos[col.ColumnName].ToString(), col.DataType.ToString() + ".Parse(value)"), "\r\n");
                        break; }
            }
            sb.AppendFormat("            {0}{1}", ConvLang.EndIf(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.EndSet(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.EndProperty(), "\r\n");
            //
            //
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" Campos y métodos compartidos (estáticos) para gestionar la base de datos"), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            //------------------------------------------------------------------
            // la cadena de conexión
            //------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" La cadena de conexión a la base de datos"), "\r\n");
            sb1 = new System.Text.StringBuilder();
            if( lang == eLenguaje.eCS )
            {
                sb1.Append("@");
            }
            if( esSQL )
            {
                sb1.AppendFormat("\"Data Source={0};", dataSource);"
                sb1.AppendFormat(" Initial Catalog={0};", initialCatalog);
                if( usarSeguridadSQL )
                {
                    sb1.AppendFormat(" user id={0}; password={1}", userId, password);
                }
                else
                {
                    sb1.Append(" Integrated Security=yes;");
                }
            }
            else
            {
                if( password != "" )
                {
                    sb1.AppendFormat("{0}Provider={1}; Data Source={2}; Jet OLEDB:Database Password={3}", Convert.ToString((char)34), provider, baseDeDatos, password);
                }
                else
                {
                    sb1.AppendFormat("{0}Provider={1}; Data Source={2}", Convert.ToString((char)34), provider, baseDeDatos);
                }
            }
            sb1.Append(Convert.ToString((char)34));
            sb.AppendFormat("    {0}{1}", ConvLang.DeclaraVariable("Private Shared", "cadenaConexion", "String", sb1.ToString()), "\r\n");
            //
            //------------------------------------------------------------------
            // la cadena de selección (campo público)
            //------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" La cadena de selección"), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.DeclaraVariable("Public Shared", "CadenaSelect", "String", Convert.ToString((char)34) + cadenaSelect + Convert.ToString((char)34)), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            //------------------------------------------------------------------
            // constructores
            // Uno sin parámetros y otro que recibe la cadena de conexión
            //------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Constructor("Public", nombreClase), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.EndSub(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Constructor("Public", nombreClase, "conex", "String"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Asigna("cadenaConexion", "conex"), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.EndSub(), "\r\n");
            //
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" Métodos compartidos (estáticos) privados"), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            //------------------------------------------------------------------
            // row2<nombreClase>: asigna una fila de la tabla a un objeto del tipo de la clase
            //------------------------------------------------------------------
            sb.AppendFormat("    {0} asigna una fila de la tabla a un objeto {1}{2}", ConvLang.Comentario(), nombreClase, "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Private Shared", "row2" + nombreClase, nombreClase, "r", "DataRow"), "\r\n");
            sb.AppendFormat("        {2} asigna a un objeto {0} los datos del dataRow indicado{1}", nombreClase, "\r\n", ConvLang.Comentario());
            sb.AppendFormat("        {0}{1}", ConvLang.VariableNew("Dim", "o" + nombreClase, nombreClase), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            foreach(DataColumn col in mDataTable.Columns)
            {
                switch(col.DataType.ToString())
                {
                    case "System.String":
                        sb.AppendFormat("        {0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos[col.ColumnName].ToString()), String.Format("r[\"{0}\"].ToString()", col.ColumnName)), "\r\n");
                        break;
                    case "System.DateTime":
                        sb.AppendFormat("        {0}{1}", ConvLang.Try(), "\r\n");
                        sb.AppendFormat("            {0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos[col.ColumnName].ToString()), String.Format("DateTime.Parse(r[\"{0}\"].ToString())", col.ColumnName)), "\r\n");
                        sb.AppendFormat("        {0}{1}", ConvLang.Catch(), "\r\n");
                        sb.AppendFormat("            {0}{1}", ConvLang.Comentario(" TODO: Usa el valor de fecha que quieras predeterminar"), "\r\n");
                        sb.AppendFormat("            {0}{1}", ConvLang.Comentario("       Una fecha ficticia:"), "\r\n");
                        sb.AppendFormat("            {0}{1}{2}", ConvLang.Comentario(), ConvLang.AsignaNew(String.Format("o{0}.{1}", nombreClase, campos[col.ColumnName].ToString()), "DateTime", "1900, 1, 1"), "\r\n");
                        sb.AppendFormat("            {0}{1}", ConvLang.Comentario("       o la fecha de hoy:"), "\r\n");
                        sb.AppendFormat("            {0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos[col.ColumnName].ToString()), "DateTime.Now"), "\r\n");
                        sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), "\r\n");
                        break;
                    case "System.Int16":
                    case "System.Int32": case "System.Int64": case "System.Single": case "System.Decimal": case "System.Double": case "System.Byte": case "System.SByte": case "System.UInt16": case "System.UInt32": case "System.UInt64":
                        sb.AppendFormat("        {0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos[col.ColumnName].ToString()), String.Format("{1}.Parse(\"0\" & r[\"{0}\"].ToString())", col.ColumnName, col.DataType.ToString())), "\r\n");
                        break;
                    case "System.Boolean":
                        sb.AppendFormat("        {0}{1}", ConvLang.Try(), "\r\n");
                        sb.AppendFormat("            {0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos[col.ColumnName].ToString()), String.Format("System.Boolean.Parse(r[\"{0}\"].ToString())", col.ColumnName)), "\r\n");
                        sb.AppendFormat("        {0}{1}", ConvLang.Catch(), "\r\n");
                        sb.AppendFormat("            {0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos[col.ColumnName].ToString()), "False"), "\r\n");
                        sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), "\r\n");
                        break;
                    case "System.Byte[]":
                        sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos[col.ColumnName].ToString()), String.Format("r[\"{0}\"]", col.ColumnName)), "\r\n", ConvLang.Comentario());
                        break;
                    default:
                        // Char, TimeSpan
                        sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" TODO: Comprobar la conversión a realizar"), "\r\n");
                        sb.AppendFormat("        {0}{1}", ConvLang.Comentario(String.Format("       con el tipo {0}", col.DataType.ToString())), "\r\n");
                        sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos[col.ColumnName].ToString()), String.Format("r[\"{0}\"]", col.ColumnName)), "\r\n", ConvLang.Comentario());
                        sb.AppendFormat("        {0}{1}", ConvLang.Asigna(String.Format("o{0}.{1}", nombreClase, campos[col.ColumnName].ToString()), String.Format("{1}.Parse(r[\"{0}\"].ToString())", col.ColumnName, col.DataType.ToString())), "\r\n");
                        break; }
            }
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Return("o" + nombreClase), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            //------------------------------------------------------------------
            // <nombreClase>2Row: asigna un objeto de la clase a la fila indicada
            //------------------------------------------------------------------
            sb.AppendFormat("    {0} asigna un objeto {1} a la fila indicada{2}", ConvLang.Comentario(), nombreClase, "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Sub("Private Shared", String.Format("{0}2Row", nombreClase), "o" + nombreClase, nombreClase, "r", "DataRow"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(String.Format(" asigna un objeto {0} al dataRow indicado", nombreClase)), "\r\n");
            foreach(DataColumn col in mDataTable.Columns)
            {
                // Si es AutoIncrement no asignarle un valor         (10/Jul/04)
                // si es Unique y no AutoIncrement se debe asignar   (13/Jul/04)
                if( col.AutoIncrement )
                { //OrElse col.Unique Then
                    sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" TODO: Comprueba si esta asignación debe hacerse"), "\r\n");
                    sb.AppendFormat("        {0}{1}", ConvLang.Comentario("       pero mejor lo dejas comentado ya que es un campo autoincremental o único"), "\r\n");
                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna(String.Format("r[\"{0}\"]", col.ColumnName), String.Format("o{0}.{1}", nombreClase, campos[col.ColumnName].ToString())), "\r\n", ConvLang.Comentario());
                }
                else
                {
                    sb.AppendFormat("        {0}{1}", ConvLang.Asigna(String.Format("r[\"{0}\"]", col.ColumnName), String.Format("o{0}.{1}", nombreClase, campos[col.ColumnName].ToString())), "\r\n");
                }
            }
            sb.AppendFormat("    {0}{1}", ConvLang.EndSub(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            //------------------------------------------------------------------
            // nuevo<nombreClase>: crea una nueva fila y la asigna a un objeto de la clase
            //------------------------------------------------------------------
            sb.AppendFormat("    {0} crea una nueva fila y la asigna a un objeto {1}{2}", ConvLang.Comentario(), nombreClase, "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Sub("Private Shared", "nuevo" + nombreClase, "dt", "DataTable", "o" + nombreClase, nombreClase), "\r\n");
            sb.AppendFormat("        {2} Crear un nuevo {0}{1}", nombreClase, "\r\n", ConvLang.Comentario());
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "dr", "DataRow", "dt.NewRow()"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "o" + nombreClase.Substring(0, 1), nombreClase, "row2" + nombreClase + "(dr)"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            foreach(DataColumn col in mDataTable.Columns)
            {
                sb.AppendFormat("        o{0}.{1} = o{2}.{1}{3}{4}", nombreClase.Substring(0, 1), campos[col.ColumnName].ToString(), nombreClase, ConvLang.FinInstruccion(), "\r\n");
            }
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}2Row(o{1}, dr){2}{3}", nombreClase, nombreClase.Substring(0, 1), ConvLang.FinInstruccion(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Instruccion("dt.Rows.Add(dr)"), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.EndSub(), "\r\n");
            //
            // Métodos públicos compartidos (estáticos)
            //
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" Métodos públicos"), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            //------------------------------------------------------------------
            // Tabla: devuelve una tabla con los datos indicados en la cadena de selección
            // hay dos sobrecargas: una sin parámetros y
            // otra en la que se indica la cadena de selección a usar
            //------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(" devuelve una tabla con los datos indicados en la cadena de selección"), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public Shared", "Tabla", "DataTable"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Return("Tabla(CadenaSelect)"), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public Shared", "Tabla", "DataTable", "sel", "String"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(String.Format(" devuelve una tabla con los datos de la tabla {0}", nombreTabla)), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Variable("Dim", "da", dbPrefix + "DataAdapter"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.VariableNewParam("Dim", "dt", "DataTable", String.Format("{0}{1}{0}", Convert.ToString((char)34), nombreClase)), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Try(), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.AsignaNew("da", dbPrefix + "DataAdapter(sel, cadenaConexion)"), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("da.Fill(dt)"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Catch(), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Return("Nothing"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Return("dt"), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            //------------------------------------------------------------------
            // Buscar                                                (10/Jul/04)
            //------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public Shared", "Buscar", nombreClase, "sWhere", "String"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Busca en la tabla los datos indicados en el parámetro"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" el parámetro contendrá lo que se usará después del WHERE"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "o" + nombreClase, nombreClase, "Nothing"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Variable("Dim", "da", dbPrefix + "DataAdapter"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.VariableNewParam("Dim", "dt", "DataTable", String.Format("{0}{1}{0}", Convert.ToString((char)34), nombreClase)), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Variable("Dim", "sel", "String", String.Format("{0}SELECT * FROM {1} WHERE {0} & sWhere", Convert.ToString((char)34), nombreTabla)), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.AsignaNew("da", dbPrefix + "DataAdapter(sel, cadenaConexion)"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Instruccion("da.Fill(dt)"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.If("dt.Rows.Count", ">", "0"), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Asigna("o" + nombreClase, "row2" + nombreClase + "(dt.Rows(0))"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.EndIf(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Return("o" + nombreClase), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            // Métodos públicos de instancia
            //
            //------------------------------------------------------------------
            // Actualizar: Actualiza los datos en la tabla usando la instancia actual
            //------------------------------------------------------------------
            sb.AppendFormat("    {0} Actualizar: Actualiza los datos en la tabla usando la instancia actual{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("    {0}             Si la instancia no hace referencia a un registro existente, se creará uno nuevo{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("    {0}             Para comprobar si el objeto en memoria coincide con uno existente,{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("    {0}             se comprueba si el {2} existe en la tabla.{1}", ConvLang.Comentario(), "\r\n", campoIDnombre);
            sb.AppendFormat("    {0}             TODO: Si en lugar de {2} usas otro campo, indicalo en la cadena SELECT{1}", ConvLang.Comentario(), "\r\n", campoIDnombre);
            sb.AppendFormat("    {0}                   También puedes usar la sobrecarga en la que se indica la cadena SELECT a usar{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public", "Actualizar", "String"), "\r\n");
            sb.AppendFormat("        {0} TODO: Poner aquí la selección a realizar para acceder a este registro{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}       yo uso el {2} que es el identificador único de cada registro{1}", ConvLang.Comentario(), "\r\n", campoIDnombre);
            if( campoIDtipo.IndexOf("String") > -1 )
            {
                sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "sel", "String", String.Format("{0}SELECT * FROM {1} WHERE {2} = '{0} & Me.{2} & {0}'{0}", Convert.ToString((char)34), nombreTabla, campoIDnombre)), "\r\n");
            }
            else
            {
                sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "sel", "String", String.Format("{0}SELECT * FROM {1} WHERE {2} = {0} & Me.{2}.ToString()", Convert.ToString((char)34), nombreTabla, campoIDnombre)), "\r\n");
            }
            sb.AppendFormat("        {0}{1}", ConvLang.Return("Actualizar(sel)"), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), "\r\n");
            //
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public", "Actualizar", "String", "sel", "String"), "\r\n");
            sb.AppendFormat("        {1} Actualiza los datos indicados{0}", "\r\n", ConvLang.Comentario());
            sb.AppendFormat("        {1} El parámetro, que es una cadena de selección, indicará el criterio de actualización{0}", "\r\n", ConvLang.Comentario());
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {1} En caso de error, devolverá la cadena empezando por ERROR.{0}", "\r\n", ConvLang.Comentario());
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "cnn", dbPrefix + "Connection"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "da", dbPrefix + "DataAdapter"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariableNewParam("Dim", "dt", "DataTable", String.Format("{0}{1}{0}", Convert.ToString((char)34), nombreClase)), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.AsignaNew("cnn", dbPrefix + "Connection", "cadenaConexion"), "\r\n");
            sb.AppendFormat("        {0}{1}{2}", ConvLang.Comentario(), ConvLang.AsignaNew("da", dbPrefix + "DataAdapter", "CadenaSelect" + ", cnn"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.AsignaNew("da", dbPrefix + "DataAdapter", "sel, cnn"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Asigna("da.MissingSchemaAction", "MissingSchemaAction.AddWithKey"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("-------------------------------------------"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Esta no es la más óptima, pero funcionará"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("-------------------------------------------"), "\r\n");
            sb.AppendFormat("        {2}{0}{1}", ConvLang.DeclaraVariableNewParam("Dim", "cb", dbPrefix + "CommandBuilder", "da"), "\r\n", ConvLang.Comentario(! usarCommandBuilder));
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna("da.UpdateCommand", "cb.GetUpdateCommand()"), "\r\n", ConvLang.Comentario(! usarCommandBuilder));
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("--------------------------------------------------------------------"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Esta está más optimizada pero debes comprobar que funciona bien..."), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("--------------------------------------------------------------------"), "\r\n");
            sb.AppendFormat("        {2}{0}{1}", ConvLang.DeclaraVariable("Dim", "sCommand", "String"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Comentario(), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {2}{1} El comando UPDATE{0}", "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {2}{1} TODO: Comprobar cual es el campo de índice principal (sin duplicados){0}", "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {3}{1}       Yo compruebo que sea un campo llamado {2}, pero en tu caso puede ser otro{0}", "\r\n", ConvLang.Comentario(), campoIDnombre, ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {3}{1}       Ese campo, (en mi caso {2}) será el que hay que poner al final junto al WHERE.{0}", "\r\n", ConvLang.Comentario(), campoIDnombre, ConvLang.Comentario(usarCommandBuilder));
            //
            sb1 = new System.Text.StringBuilder();
            sb2 = new System.Text.StringBuilder();
            //
            sb1.AppendFormat("{0}UPDATE {1} SET ", Convert.ToString((char)34), nombreTabla);
            //
            s = "";
            for(int i= 0; i<= mDataTable.Columns.Count - 1; i++)
            {
                DataColumn col = mDataTable.Columns[i];
                // si el campo tiene caracteres no válidos           (14/Jul/04)
                // ponerlo entre corchetes
                s = col.ColumnName;
                if( campos[col.ColumnName].ToString() != s )
                {
                    s = "[" + col.ColumnName + "]";
                }
                if( campos[col.ColumnName].ToString() != campoIDnombre )
                {
                    if( esSQL )
                    {
                        sb2.AppendFormat("{0} = @{0}, ", s);
                    }
                    else
                    {
                        sb2.AppendFormat("{0} = ?, ", s);
                    }
                }
            }
            s = sb2.ToString().TrimEnd();
            if( s.EndsWith(",") )
            {
                sb1.AppendFormat("{0} ", s.Substring(0, s.Length - 1));
            }
            else
            {
                sb1.AppendFormat("{0} ", s);
            }
            if( esSQL )
            {
                sb1.AppendFormat(" WHERE ({1} = @{1}){0}", Convert.ToString((char)34), campoIDnombre);
            }
            else
            {
                sb1.AppendFormat(" WHERE ({1} = ?){0}", Convert.ToString((char)34), campoIDnombre);
            }
            //
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna("sCommand", sb1.ToString()), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {2}{0}{1}", ConvLang.AsignaNew("da.UpdateCommand", dbPrefix + "Command", "sCommand, cnn"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            //
            if( esSQL )
            {
                foreach(DataColumn col in mDataTable.Columns)
                {
                    switch(col.DataType.ToString())
                    {
                        case "System.String":
                            if( col.MaxLength > 255 )
                            {
                                sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", col.MaxLength, "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                                s = String.Format("{2}@{0}{2}, SqlDbType.NText, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Convert.ToString((char)34));
                                sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                s = String.Format("{2}@{0}{2}, SqlDbType.NText, {1}, {2}{0}{2}", col.ColumnName, 0, Convert.ToString((char)34));
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                            }
                            else
                            {
                                s = String.Format("{2}@{0}{2}, SqlDbType.NVarChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Convert.ToString((char)34));
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                            }
                            break;
                        default:
                            sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                            s = String.Format("{1}@{0}{1}, {2}, 0, {1}{0}{1}", col.ColumnName, Convert.ToString((char)34), tipoSQL(col.DataType.ToString()));
                            sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                            break; }
                }
            }
            else
            {
                int j = mDataTable.Columns.Count;
                int k;
                string[] sp = new string[(j + 1)];
                for(k = 0; k <= j; k++)
                {
                    sp[k] = "p" + (k + 1).ToString();
                }
                k = 0;
                string sp1;
                DataColumn colID = null;
                foreach(DataColumn col in mDataTable.Columns)
                {
                    if( campos[col.ColumnName].ToString() == campoIDnombre )
                    {
                        colID = col;
                    }
                    else
                    {
                        sp1 = sp[k];
                        k += 1;
                        switch(col.DataType.ToString())
                        {
                            case "System.String":
                                if( col.MaxLength > 255 )
                                {
                                    sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", col.MaxLength, "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                                    s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Convert.ToString((char)34), sp1);
                                    sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                    s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, 0, Convert.ToString((char)34), sp1);
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                }
                                else
                                {
                                    s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Convert.ToString((char)34), sp1);
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                }
                                break;
                            default:
                                sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                                s = String.Format("{1}@{3}{1}, {2}, 0, {1}{0}{1}", col.ColumnName, Convert.ToString((char)34), tipoOleDb(col.DataType.ToString()), sp1);
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                break; }
                    }
                }
                sp1 = sp[j - 1];
                switch(colID.DataType.ToString())
                {
                    case "System.String":
                        if( colID.MaxLength > 255 )
                        {
                            sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", colID.MaxLength, "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                            s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", colID.ColumnName, colID.MaxLength, Convert.ToString((char)34), sp1);
                            sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                            s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", colID.ColumnName, 0, Convert.ToString((char)34), sp1);
                            sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                        }
                        else
                        {
                            s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", colID.ColumnName, colID.MaxLength, Convert.ToString((char)34), sp1);
                            sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                        }
                        break;
                    default:
                        sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                        s = String.Format("{1}@{3}{1}, {2}, 0, {1}{0}{1}", colID.ColumnName, Convert.ToString((char)34), tipoOleDb(colID.DataType.ToString()), sp1);
                        sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                        break; }
                s = String.Format("{0}@{2}{0}, {1}, 0, {0}{0}", Convert.ToString((char)34), "OleDbType.Integer", sp[j]);
                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            }
            //
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Try(), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("da.Fill(dt)"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Catch("ex", "Exception"), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Return("\"ERROR: \" & ex.Message"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            sb.AppendFormat("        {0}{1}", ConvLang.If("dt.Rows.Count", "=", "0"), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Comentario(" crear uno nuevo"), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Return("Crear()"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Else(), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion(nombreClase + "2Row(Me, dt.Rows(0))"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.EndIf(), "\r\n");
            //
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Try(), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("da.Update(dt)"), "\r\n");
            sb.AppendFormat("            dt.AcceptChanges(){0}{1}", ConvLang.FinInstruccion(), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Return("\"Actualizado correctamente\""), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Catch("ex", "Exception"), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Return("\"ERROR: \" & ex.Message"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            //------------------------------------------------------------------
            // Crear: Crea un nuevo registro usando el contenido de la instancia
            //------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public", "Crear", "String"), "\r\n");
            sb.AppendFormat("        {1} Crear un nuevo registro{0}", "\r\n", ConvLang.Comentario());
            sb.AppendFormat("        {1} En caso de error, devolverá la cadena de error empezando por ERROR:.{0}", "\r\n", ConvLang.Comentario());
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "cnn", dbPrefix + "Connection"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "da", dbPrefix + "DataAdapter"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariableNewParam("Dim", "dt", "DataTable", String.Format("{0}{1}{0}", Convert.ToString((char)34), nombreClase)), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.AsignaNew("cnn", dbPrefix + "Connection", "cadenaConexion"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.AsignaNew("da", dbPrefix + "DataAdapter", "CadenaSelect" + ", cnn"), "\r\n");
            sb.AppendFormat("        {0}{1}{2}", ConvLang.Comentario(), ConvLang.AsignaNew("da", dbPrefix + "DataAdapter", "CadenaSelect" + ", cadenaConexion"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Asigna("da.MissingSchemaAction", "MissingSchemaAction.AddWithKey"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("-------------------------------------------"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Esta no es la más óptima, pero funcionará"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("-------------------------------------------"), "\r\n");
            sb.AppendFormat("        {2}{0}{1}", ConvLang.DeclaraVariableNewParam("Dim", "cb", dbPrefix + "CommandBuilder", "da"), "\r\n", ConvLang.Comentario(! usarCommandBuilder));
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna("da.InsertCommand", "cb.GetInsertCommand()"), "\r\n", ConvLang.Comentario(! usarCommandBuilder));
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("--------------------------------------------------------------------"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Esta está más optimizada pero debes comprobar que funciona bien..."), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("--------------------------------------------------------------------"), "\r\n");
            sb.AppendFormat("        {2}{0}{1}", ConvLang.DeclaraVariable("Dim", "sCommand", "String"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Comentario(), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {2}{0} El comando INSERT{1}", ConvLang.Comentario(), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {2}{0} TODO: No incluir el campo de clave primaria incremental{1}", ConvLang.Comentario(), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {3}{0}       Yo compruebo que sea un campo llamado {2}, pero en tu caso puede ser otro{1}", ConvLang.Comentario(), "\r\n", campoIDnombre, ConvLang.Comentario(usarCommandBuilder));
            //
            sb1 = new System.Text.StringBuilder();
            sb2 = new System.Text.StringBuilder();
            sb3 = new System.Text.StringBuilder();
            sb1.AppendFormat("{0}INSERT INTO {1} (", Convert.ToString((char)34), nombreTabla);
            //
            for(int i= 0; i<= mDataTable.Columns.Count - 1; i++)
            {
                DataColumn col = mDataTable.Columns[i];
                s = col.ColumnName;
                if( campos[col.ColumnName].ToString() != s )
                {
                    s = "[" + col.ColumnName + "]";
                }
                // si no es AutoIncrement debe estar en los parámetros
                if( col.AutoIncrement == false )
                { //If col.ColumnName <> campoIDnombre Then
                    sb2.AppendFormat("{0}, ", s);
                    if( esSQL )
                    {
                        sb3.AppendFormat("@{0}, ", s);
                    }
                    else
                    {
                        sb3.Append("?, ");
                    }
                }
            }
            s = sb2.ToString().TrimEnd();
            if( s.EndsWith(",") )
            {
                sb1.AppendFormat("{0}", s.Substring(0, s.Length - 1));
            }
            else
            {
                sb1.AppendFormat("{0}", s);
            }
            sb1.Append(") ");
            //
            s = sb3.ToString().TrimEnd();
            if( s.EndsWith(",") )
            {
                sb1.AppendFormat(" VALUES({0})", s.Substring(0, s.Length - 1));
            }
            else
            {
                sb1.AppendFormat(" VALUES({0})", s);
            }
            //
            sb1.AppendFormat("{0}", Convert.ToString((char)34));
            //
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna("sCommand", sb1.ToString()), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {2}{0}{1}", ConvLang.AsignaNew("da.InsertCommand", dbPrefix + "Command", "sCommand, cnn"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            //
            if( esSQL )
            {
                foreach(DataColumn col in mDataTable.Columns)
                {
                    switch(col.DataType.ToString())
                    {
                        case "System.String":
                            if( col.MaxLength > 255 )
                            {
                                sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", col.MaxLength, "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                                s = String.Format("{2}@{0}{2}, SqlDbType.NText, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Convert.ToString((char)34));
                                sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                s = String.Format("{2}@{0}{2}, SqlDbType.NText, {1}, {2}{0}{2}", col.ColumnName, 0, Convert.ToString((char)34));
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                            }
                            else
                            {
                                s = String.Format("{2}@{0}{2}, SqlDbType.NVarChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Convert.ToString((char)34));
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                            }
                            break;
                        default:
                            sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                            s = String.Format("{1}@{0}{1}, {2}, 0, {1}{0}{1}", col.ColumnName, Convert.ToString((char)34), tipoSQL(col.DataType.ToString()));
                            sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                            break; }
                }
            }
            else
            {
                int j = mDataTable.Columns.Count;
                int k;
                string[] sp = new string[(j + 1)];
                for(k = 0; k <= j; k++)
                {
                    sp[k] = "p" + (k + 1).ToString();
                }
                k = 0;
                string sp1;
                DataColumn colID = null;
                foreach(DataColumn col in mDataTable.Columns)
                {
                    if( campos[col.ColumnName].ToString() == campoIDnombre )
                    {
                        colID = col;
                    }
                    else
                    {
                        sp1 = sp[k];
                        k += 1;
                        switch(col.DataType.ToString())
                        {
                            case "System.String":
                                if( col.MaxLength > 255 )
                                {
                                    sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", col.MaxLength, "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                                    s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Convert.ToString((char)34), sp1);
                                    sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.UpdateCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                    s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, 0, Convert.ToString((char)34), sp1);
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                }
                                else
                                {
                                    s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Convert.ToString((char)34), sp1);
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                }
                                break;
                            default:
                                sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                                s = String.Format("{1}@{3}{1}, {2}, 0, {1}{0}{1}", col.ColumnName, Convert.ToString((char)34), tipoOleDb(col.DataType.ToString()), sp1);
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                break; }
                    }
                }
                sp1 = sp[j - 1];
                switch(colID.DataType.ToString())
                {
                    case "System.String":
                        if( colID.MaxLength > 255 )
                        {
                            sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", colID.MaxLength, "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                            s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", colID.ColumnName, colID.MaxLength, Convert.ToString((char)34), sp1);
                            sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                            s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", colID.ColumnName, 0, Convert.ToString((char)34), sp1);
                            sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                        }
                        else
                        {
                            s = String.Format("{2}@{3}{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", colID.ColumnName, colID.MaxLength, Convert.ToString((char)34), sp1);
                            sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                        }
                        break;
                    default:
                        sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                        s = String.Format("{1}@{3}{1}, {2}, 0, {1}{0}{1}", colID.ColumnName, Convert.ToString((char)34), tipoOleDb(colID.DataType.ToString()), sp1);
                        sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                        break; }
                s = String.Format("{0}@{2}{0}, {1}, 0, {0}{0}", Convert.ToString((char)34), "OleDbType.Integer", sp[j]);
                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            }
            //
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Try(), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("da.Fill(dt)"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Catch("ex", "Exception"), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Return("\"ERROR: \" & ex.Message"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Instruccion("nuevo" + nombreClase + "(dt, Me)"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Try(), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("da.Update(dt)"), "\r\n");
            sb.AppendFormat("            dt.AcceptChanges(){0}{1}", ConvLang.FinInstruccion(), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Return("\"Se ha creado un nuevo " + nombreClase + Convert.ToString((char)34)), "\r\n");"
            sb.AppendFormat("        {0}{1}", ConvLang.Catch("ex", "Exception"), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Return("\"ERROR: \" & ex.Message"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            //------------------------------------------------------------------
            // Borrar: Borra el registro con el mismo ID que tenga la clase
            //         En caso de que quieras usar otro criterio para comprobar cual es el registro actual
            //         cambia la comparación
            //------------------------------------------------------------------
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public", "Borrar", "String"), "\r\n");
            sb.AppendFormat("        {0} TODO: Poner aquí la selección a realizar para acceder a este registro{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}       yo uso el {2} que es el identificador único de cada registro{1}", ConvLang.Comentario(), "\r\n", campoIDnombre);
            if( campoIDtipo.IndexOf("String") > -1 )
            {
                sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "sel", "String", String.Format("{0}SELECT * FROM {1} WHERE {2} = '{0} & Me.{2} & {0}'{0}", Convert.ToString((char)34), nombreTabla, campoIDnombre)), "\r\n");
            }
            else
            {
                sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "sel", "String", String.Format("{0}SELECT * FROM {1} WHERE {2} = {0} & Me.{2}.ToString()", Convert.ToString((char)34), nombreTabla, campoIDnombre)), "\r\n");
            }
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Return("Borrar(sel)"), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), "\r\n");
            //
            sb.AppendFormat("    {0}{1}", ConvLang.Function("Public", "Borrar", "String", "sel", "String"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Borrar el registro al que apunta esta clase"), "\r\n");
            sb.AppendFormat("        {1} En caso de error, devolverá la cadena de error empezando por ERROR:.{0}", "\r\n", ConvLang.Comentario());
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "cnn", dbPrefix + "Connection"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariable("Dim", "da", dbPrefix + "DataAdapter"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.DeclaraVariableNewParam("Dim", "dt", "DataTable", String.Format("{0}{1}{0}", Convert.ToString((char)34), nombreClase)), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.AsignaNew("cnn", dbPrefix + "Connection", "cadenaConexion"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.AsignaNew("da", dbPrefix + "DataAdapter", "sel, cnn"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Asigna("da.MissingSchemaAction", "MissingSchemaAction.AddWithKey"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("-------------------------------------------"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Esta no es la más óptima, pero funcionará"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("-------------------------------------------"), "\r\n");
            sb.AppendFormat("        {2}{0}{1}", ConvLang.DeclaraVariableNewParam("Dim", "cb", dbPrefix + "CommandBuilder", "da"), "\r\n", ConvLang.Comentario(! usarCommandBuilder));
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna("da.DeleteCommand", "cb.GetDeleteCommand()"), "\r\n", ConvLang.Comentario(! usarCommandBuilder));
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("--------------------------------------------------------------------"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(" Esta está más optimizada pero debes comprobar que funciona bien..."), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario("--------------------------------------------------------------------"), "\r\n");
            sb.AppendFormat("        {2}{0}{1}", ConvLang.DeclaraVariable("Dim", "sCommand", "String"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Comentario(), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {2}{0} El comando DELETE{1}", ConvLang.Comentario(), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {2}{0} TODO: Sólo incluir el campo de clave primaria incremental{1}", ConvLang.Comentario(), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {3}{0}       Yo compruebo que sea un campo llamado {2}, pero en tu caso puede ser otro{1}", ConvLang.Comentario(), "\r\n", campoIDnombre, ConvLang.Comentario(usarCommandBuilder));
            //
            sb1 = new System.Text.StringBuilder();
            if( esSQL )
            {
                sb1.AppendFormat("{0}DELETE FROM {1} WHERE ({2} = @p1){0}", Convert.ToString((char)34), nombreTabla, campoIDnombre);
            }
            else
            {
                sb1.AppendFormat("{0}DELETE FROM {1} WHERE ({2} = ?){0}", Convert.ToString((char)34), nombreTabla, campoIDnombre);
            }
            sb.AppendFormat("        {2}{0}{1}", ConvLang.Asigna("sCommand", sb1.ToString()), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            sb.AppendFormat("        {2}{0}{1}", ConvLang.AsignaNew("da.DeleteCommand", dbPrefix + "Command", "sCommand, cnn"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            //
            if( esSQL )
            {
                foreach(DataColumn col in mDataTable.Columns)
                {
                    if( campos[col.ColumnName].ToString() == campoIDnombre )
                    {
                        switch(col.DataType.ToString())
                        {
                            case "System.String":
                                if( col.MaxLength > 255 )
                                {
                                    sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", col.MaxLength, "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                                    s = String.Format("{2}@p1{2}, SqlDbType.NText, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Convert.ToString((char)34));
                                    sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.InsertCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                    s = String.Format("{2}@p1{2}, SqlDbType.NText, {1}, {2}{0}{2}", col.ColumnName, 0, Convert.ToString((char)34));
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                }
                                else
                                {
                                    s = String.Format("{2}@p1{2}, SqlDbType.NVarChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Convert.ToString((char)34));
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                }
                                break;
                            default:
                                sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                                s = String.Format("{1}@p1{1}, {2}, 0, {1}{0}{1}", col.ColumnName, Convert.ToString((char)34), tipoSQL(col.DataType.ToString()));
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                break; }
                        break;
                    }
                }
                s = String.Format("{0}@p2{0}, {1}, 0, {0}{0}", Convert.ToString((char)34), "SqlDbType.Int");
                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            }
            else
            {
                foreach(DataColumn col in mDataTable.Columns)
                {
                    if( campos[col.ColumnName].ToString() == campoIDnombre )
                    {
                        switch(col.DataType.ToString())
                        {
                            case "System.String":
                                if( col.MaxLength > 255 )
                                {
                                    sb.AppendFormat("        {3}{2} TODO: Este campo seguramente es MEMO y el valor debería ser cero en lugar de {0}{1}", col.MaxLength, "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                                    s = String.Format("{2}@p1{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Convert.ToString((char)34));
                                    sb.AppendFormat("        {3}{0}{1}{2}", ConvLang.Comentario(), ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                    s = String.Format("{2}@p1{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, 0, Convert.ToString((char)34));
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                }
                                else
                                {
                                    s = String.Format("{2}@p1{2}, OleDbType.VarWChar, {1}, {2}{0}{2}", col.ColumnName, col.MaxLength, Convert.ToString((char)34));
                                    sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                }
                                break;
                            default:
                                sb.AppendFormat("        {2}{1} TODO: Comprobar el tipo de datos a usar...{0}", "\r\n", ConvLang.Comentario(), ConvLang.Comentario(usarCommandBuilder));
                                s = String.Format("{1}@p1{1}, {2}, 0, {1}{0}{1}", col.ColumnName, Convert.ToString((char)34), tipoOleDb(col.DataType.ToString()));
                                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
                                break; }
                        break;
                    }
                }
                s = String.Format("{0}@p2{0}, {1}, 0, {0}{0}", Convert.ToString((char)34), "OleDbType.Integer");
                sb.AppendFormat("        {2}{0}{1}", ConvLang.Instruccion("da.DeleteCommand.Parameters.Add(" + s + ")"), "\r\n", ConvLang.Comentario(usarCommandBuilder));
            }
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Instruccion("da.Fill(dt)"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.If("dt.Rows.Count", "=", "0"), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Return("\"ERROR: No hay datos\""), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Else(), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("dt.Rows(0).Delete()"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.EndIf(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Comentario(), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Try(), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("da.Update(dt)"), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Instruccion("dt.AcceptChanges()"), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Return("\"Borrado satisfactoriamente\""), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.Catch("ex", "Exception"), "\r\n");
            sb.AppendFormat("            {0}{1}", ConvLang.Return("\"ERROR: \" & ex.Message"), "\r\n");
            sb.AppendFormat("        {0}{1}", ConvLang.EndTry(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.EndFunction(), "\r\n");
            sb.AppendFormat("    {0}{1}", ConvLang.Comentario(), "\r\n");
            //
            sb.AppendFormat("{0}{1}", ConvLang.EndClass(), "\r\n");
            //
            return sb.ToString();
        }  
        //
        private static string tipoSQL(string elTipo) 
        {
            string[] aCTS = {"System.Boolean", "System.Int16", "System.Int32", "System.Int64", "System.Decimal", "System.Single", "System.Double", "System.Byte", "System.DateTime", "System.Guid", "System.Object"};
            string[] aSQL = {"Bit", "SmallInt", "Int", "BigInt", "Decimal", "Real", "Float", "TinyInt", "DateTime", "UniqueIdentifier", "Variant"};
            int i = Array.IndexOf(aCTS, elTipo);
            if( i > -1 )
            {
                return "SqlDbType." + aSQL[i];
            }
            return "SqlDbType.Int";
        }  
        //
        private static string tipoOleDb(string elTipo) 
        {
            string[] aCTS = {"System.Byte[]", "System.Boolean", "System.Int16", "System.Int32", "System.Int64", "System.Decimal", "System.Single", "System.Double", "System.Byte", "System.DateTime", "System.Guid", "System.Object", "System.String"};
            string[] aOle = {"LongVarBinary", "Boolean", "SmallInt", "Integer", "BigInt", "Decimal", "Single", "Double", "UnsignedTinyInt", "Date", "Guid", "Variant", "VarWChar"};
            int i = Array.IndexOf(aCTS, elTipo);
            if( i > -1 )
            {
                return "OleDbType." + aOle[i];
            }
            return "OleDbType.Integer";
        }  
    }
}

...

la Luna del Guille o... el Guille que está en la Luna... tanto monta...