Error al guardar datos decimales: El valor del parámetro ‘xxx’ está fuera del intervalo

Pues eso… aunque ya te expliqué cómo definir los decimales en un campo de una tabla de SQL Server (El número de decimales del tipo decimal de SQL Server) aquí te amplio ese mismo tema (o casi), ya que estuve trasteando con esto de los decimales, y… bueno, no presté mucha atención a la explicación de los argumentos indicados al declarar un tipo decimal o numeric de Transact-SQL (si la hubiese prestado no estaría escribiendo esto Winking smile).
Te copio/pego (buen invento este del Copy&Paste) lo que dice la página de la documentación de Transact-SQL sobre decimal y numeric:

Argumentos

decimal[ (p[ ,s] )] y numeric[ (p[ ,s] )]
Números de precisión y escala fijas. Cuando se utiliza la precisión máxima, los valores válidos se sitúan entre – 10^38 +1 y 10^38 – 1. Los sinónimos ISO para decimal son dec y dec(p, s). numeric equivale desde el punto de vista funcional a decimal.

p (precisión)
El número total máximo de dígitos decimales que almacenará, tanto a la izquierda como a la derecha del separador decimal. La precisión debe ser un valor comprendido entre 1 y la precisión máxima de 38. La precisión predeterminada es 18.

s (escala)
El número de dígitos decimales que se almacenará a la derecha del separador decimal. Este número se extrae de p para determinar el número máximo de dígitos a la izquierda del separador decimal. La escala debe ser un valor comprendido entre 0 y p. Solo es posible especificar la escala si se ha especificado la precisión. La escala predeterminada es 0; por tanto, 0 <= s <= p. Los tamaños de almacenamiento máximo varían según la precisión.

Si lees eso y lo asimila pues… no hace falta que sigas leyendo… Eye rolling smile pero ya que estás aquí… anda… sigue leyendo… Be right back

Pues yo… no me lo leí bien… y como iba a trabajar con campos para guardar el porcentaje de IVA, actualmente en España son: 4% (0,5% de RE), 10% (1,40% de RE) y 21% (5,20% de RE); así que pensé que declarando el tipo como decimal (4,4) me iba bien… ya que pensé Angel que el primer 4 sería para las cifras a la izquierda del separador decimal y los otros 4 para lo que haya después del separador decimal), ¡craso error! (pero en este caso sería: ¡Guille error! Rolling on the floor laughing

Bueno, el error fue el que me dio el SQL Server al querer guardar el valor del IVA del 4%, es decir, guardar un simple valor “cuatro” (con 4 decimales) .
El error fue:
El valor de parámetro ‘4,0000’ está fuera del intervalo.

Nota:
El error “El valor de parámetro ‘4,0000’ está fuera del intervalo.” me lo dio usando la inserción de datos usando Update en un DataAdapter.
Al usar ExecuteNonQuery o ExecuteScalar el error que da es: “Error de desbordamiento aritmético al convertir numeric al tipo de datos numeric.
Estos dos casos de forma “programativa”.
Si se añade desde Mangement Studio de SQL Server, el error que da es: “El nombre de columna o los valores especificados no corresponden a la definición de la tabla.

Sí, estaba usando el objeto DataAdapter Smile para crear o actualizar los datos.

El error y la solución

El tema está en que si declaras un valor decimal de esta forma: decimal(4,4) esto lo que hace es definir el tipo decimal para 1ue acepte un máximo de 4 cifras (el primer argumento), incluidas las que van después del separador, y como está definido con 4 cifras decimales (el segundo valor) pues… ¡solo aceptará las 4 cifras decimales!
Por tanto… ¡error al canto! al menos si se asigna algún valor a la izquierda del separador decimal. Es decir, si le asignamos 4,0 dará error, pero si le asignas hasta un valor máximo de 0,9999 no lo dará. Otra cosa es que le asignes algo como: 0,9999876 en este caso si lo dará, ya que al redondear las cifras decimales a 4 se creará un valor mayor de cero, en este caso el valor que intentará guardar es: 1,0000.

Una solución sería definir el tipo para que acepte más cifras, por ejemplo:
decimal(6,4) permitirá 6 cifras en total, 4 de ellas para los decimales y 2 para la parte entera, de esta forma podremos guardar sin problemas valores hasta 99,9999.

Y esto sería todo, pero… te voy a mostrar código, que si no… no tienen gracia Winking smile

Código de ejemplo

Empezaré con un código Transact-SQL para crear dos tablas en una base de datos que previamente habrás creado con Management Studio de SQL Server llamada ErrorDecimal.

En la primera tabla (MiTabla1) definimos un tipo decimal(4,4):

use ErrorDecimal

CREATE TABLE dbo.MiTabla1 
(  
  Decimal_4_4 decimal(4,4)
 
);  

GO 

-- 21.5 dará error al asignar a decimal(4,4) ya que ese número tendría 6 cifras: el 21 y los 4 decimales
-- incluso 4.0 también daría error, pero no 0.9999

INSERT INTO dbo.MiTabla1 VALUES (21,5);  
GO 
SELECT Decimal_4_4 
FROM dbo.MiTabla1;

En la segunda tabla (MiTabla2) definimos dos columnas como decimal(6,4) y decimal(18,6):

use ErrorDecimal

CREATE TABLE dbo.MiTabla2 
(  
  Decimal_6_4 decimal(6,4)  
 ,Decimal_18_6 decimal(18,6)

);  

GO 

-- 99.9991912 no dará error al asignar a decimal(6,4) ya que solo aceptará los 4 primeros dígitos decimales
-- el valor que tendrá será: 99.9992
-- decimal(18,6) aceptará 18 cifras en total: 12 a la izquierda y 6 a la derecha
-- 999,999,999,999.9999199 mostrará 999999999999.999920
INSERT INTO dbo.MiTabla2 VALUES (99.9991912, 999999999999.9999199);  
GO 
SELECT Decimal_6_4, Decimal_18_6  
FROM dbo.MiTabla2;

Puedes ejecutar ese código y verás que te dará error al asignar el valor de MiTabla1.
En el código de MiTabla2 funcionará perfectamente (salvo que uses valores fuera de rango).

Una aplicación de ejemplo (Windows Forms)

Lo siguiente que te voy a mostrar es el código para usar una aplicación de Windows Forms (al final del artículo te he puesto los enlaces para el código de Visual Basic así como para C#).

Para poder usar este código debes definir en la base de datos un usuario llamado UsuarioErrDec con la clave 123456.

Nota:
Si no sabes cómo crear el usuario y la contraseña… ¡jum!
Bueno, tendrás que esperar a otro artículo que tengo preparado sobre este tema… o casi… Winking smile

Antes de poner el “tocho” de código (y las capturas del formulario en modo diseño) te diré las cosas que vas a encontrarte en el código, a ver si así te animas a seguir leyendo Smile

Base de datos:
1- Crear la cadena de conexión usando SqlConnectionStringBuilder.
2- Añadir nuevos datos a las tablas usando SqlConnection y ExecuteNonQuery.
2a- Los métodos de añadir utilizan una tupla (Tuple) para devolver dos valores: un valor Boolean para saber si hubo o no error y un valor String con el error o un mensaje de que se han añadido correctamente los datos.
3- Leer los datos de las tablas usando ExecuteReader y devolviendo una cadena con los nombres de las columnas y los valores.

Código general: Detectar las pulsaciones en los TextBox numéricos usando una función (AceptarTeclas)
4- En las cajas de texto numéricas permitir solo números y el signo menos y el separador decimal que definamos (en este ejemplo se permite la coma como separador y no se acepta el punto.
5- Permitir en las teclas numéricas la pulsación de la tecla INTRO y BORRAR.
indicar cual será el separador decimal y solo permitir números (y el signo menos)
6- Te explico el “fallillo” de que el punto siempre se acepta, salvo que se intercepte la pulsación.
7- Si se pulsa la tecla INTRO pasar al siguiente control.

Código general: Interceptar a nivel de formulario la pulsación de las teclas de edición (Ctrl+C, Ctrl+V, Ctrl+X y Ctrl+Z) en los controles de texto y trabajar con el portapapeles ¡sin necesidad de usar el objeto ClipBoard!
8- Las pulsaciones de las teclas se comprueban en el evento KeyDown del formulario.
9- Se utiliza ActiveControl y se comprueba si es una caja de texto.

El formulario en tiempo de diseño.

error_decimal_01

Comentarte que para que funcione lo de las “tuplas” en Visual Basic debes usar el .NET 4.7.2, por tanto yo he usado esa versión del compilador con el Visual Studio 2017 versión 15.9.3.
He usado la versión Professional, pero también funciona con la Community (gratuita). Por curiosidad, también lo he probado con el Visual Studio Enterprise 2019 (versión 16.0.0 Preview 1.0) y todo funciona perfectamente.

Y esto es todo amigos. Espero que te sea de utilidad Smile

Nos vemos.
Guillermo

P.S.
Este artículo está publicado originalmente en mi blog elguillemola.com pero también lo encontrarás en mi sitio elguille.info (realmente accede al post publicado en el blog).

El código de Visual Basic .NET y C#

Lo he puesto aparte para que sea más cómodo leerlo.

Estos son los enlaces en el blog, pero te recomiendo que lo veas en los publicados en elguille.info ya que el código se ve mejor Winking smile:

El código de Visual Basic .NET (blog)
El código de C# (blog)

El código de Visual Basic (elguille.info)
El código de C# (elguille.info)

Nota:
Convertido con mi utilidad gsConvertirCodigo y modificado manualmente ya que aún no “entiende” bien todo esto de la inferencia de tipos y las tuplas Smile

Por favor, cualquier comentario sobre el código por favor coméntalo en los posts correspondientes; aquí también puedes comentar, pero mejor en cada post para que el que vea ese post concreto sepa que se puede mejorar o lo que quieras que comentes, gracias.



Código de ejemplo (comprimido):

El zip con el código completo para Visual Basic y C#

El zip: SQL_Error_decimal.zip (en downloads.elguille.info)

Contiene una solución de Visual Studio 2017 con los proyectos para VB y C#

( MD5 Checksum: 2232781E047C1ED1A48DD00C7CA8E6F5 )

Error al guardar datos decimales – El código para C#

Aquí tienes el código para C# de la aplicación de ejemplo del artículo Error al guardar datos decimales: El valor del parámetro ‘xxx’ está fuera del intervalo.

Nota:
Si buscabas el código para Visual Basic está en este otro enlace:
Error al guardar datos decimales – El código para Visual Basic.

Cuando lo tenga publicado, te pondré el enlace para descargar la solución de Visual Studio 2017 tanto para VB como para C#.

El código de C#

//-----------------------------------------------------------------------------
//  Ejemplo para el error de asignar a decimal(4,4)                 (07/Dic/18)
//
// (c) Guillermo (elGuille) Som, 2018
//-----------------------------------------------------------------------------

using System;
using System.Data.SqlClient;
using System.Text;
using System.Windows.Forms;

namespace SQL_Error_decimal_cs
{
    public partial class Form1 : Form
    {


        //--------------------------------------------------------------------------
        // Los campos para acceder a la base de datos
        //--------------------------------------------------------------------------

        /// <summary>
        /// El usuario para acceder a la base de datos de SQL Server.<br />
        /// Si es una cadena vacía se usará la seguridad integrada de Windows.
        /// </summary>
        private string userDb = "UsuarioErrDec";

        /// <summary>
        /// El password del usuario que accede a la base de datos de SQL Server
        /// </summary>
        private string passwordDB = "123456";

        /// <summary>
        /// El servidor donde está la base de datos.<br />
        /// Normalmente será .\SQLEXPRESS o (local)
        /// </summary>
        private string serverName = @".\SQLEXPRESS";
        /// <summary>
        /// El nombre de la base de datos de SQL Server
        /// </summary>
        private string databaseName = "ErrorDecimal";

        /// <summary>
        /// Devuelve la cadena de conexión a la base de datos de SQL Server<br />
        /// Si el usuario es una cadena vacía, se usará la seguridad integrada de Windows
        /// </summary>
        private string ConnectionString {
            get {
                var sb = new SqlConnectionStringBuilder();
                sb.DataSource = serverName;
                sb.InitialCatalog = databaseName;
                if (String.IsNullOrWhiteSpace(userDb))
                {
                    sb.IntegratedSecurity = true;
                } else
                {
                    sb.UserID = userDb;
                    sb.Password = passwordDB;
                }
                return sb.ConnectionString;
            }
        }



        //--------------------------------------------------------------------------
        // Añadir un valor a las tablas
        //--------------------------------------------------------------------------
        private (bool hayError, string msg) AñadirMiTabla1(decimal valor)
        {
            var sel = "INSERT INTO MiTabla1 (Decimal_4_4) " +
                      "VALUES (@Decimal_4_4)";

            var retVal = (hayError: false, msg: "");

            var sCon = ConnectionString;

            using (SqlConnection con = new SqlConnection(sCon))
            {
                var cmd = new SqlCommand(sel, con);
                cmd.Parameters.AddWithValue("@Decimal_4_4", valor);

                con.Open();

                try
                {
                    var ret = Convert.ToInt32(cmd.ExecuteNonQuery());

                    retVal.hayError = (ret < 1);
                    retVal.msg = "Todo OK. cmd.ExecuteNonQuery() = " + ret.ToString();
                }
                catch (Exception ex)
                {
                    retVal.msg = ex.Message;
                    retVal.hayError = true;
                }
                con.Close();
            }
            return retVal;
        }

        private (bool hayError, string msg) AñadirMiTabla2(decimal[] valores)
        {
            var sel = "INSERT INTO MiTabla2 (Decimal_6_4, Decimal_18_6) " +
                      "VALUES (@Decimal_6_4, @Decimal_18_6)";

            var retVal = (hayError:false, msg:"");
            
            var sCon = ConnectionString;

            using (SqlConnection con = new SqlConnection(sCon))
            {
                SqlCommand cmd = new SqlCommand(sel, con);
                cmd.Parameters.AddWithValue("@Decimal_6_4", valores[0]);
                cmd.Parameters.AddWithValue("@Decimal_18_6", valores[1]);

                con.Open();

                try
                {
                    var ret = Convert.ToInt32(cmd.ExecuteNonQuery());

                    retVal.hayError = (ret < 1);
                    retVal.msg = "Todo OK. cmd.ExecuteNonQuery() = " + ret.ToString();
                }
                catch (Exception ex)
                {
                    retVal.msg = ex.Message;
                    retVal.hayError = true;
                }
                con.Close();
            }
            return retVal;
        }



        private string leerMiTabla(string tabla)
        {
            var sel = "SELECT * FROM " + tabla;

            var retVal = "";

            var sCon = ConnectionString;

            using (SqlConnection con = new SqlConnection(sCon))
            {
                var cmd = new SqlCommand(sel, con);

                con.Open();

                try
                {
                    var ret = cmd.ExecuteReader();

                    StringBuilder sb = new StringBuilder();

                    while (ret.Read())
                    {
                        sb.AppendLine(String.Format("{0} = {1}", ret.GetName(0), ret[0]));

                        if (ret.FieldCount > 1)
                            sb.AppendLine(String.Format("{0} = {1}", ret.GetName(1), ret[1]));
                    };
                    retVal = sb.ToString();
                }
                catch (Exception ex)
                {
                    retVal = "ERROR: " + ex.Message;
                }
                con.Close();
            };
            return retVal;
        }

        //--------------------------------------------------------------------------
        // Para aceptar la coma como decimal en las cajas numéricas
        //--------------------------------------------------------------------------
        /// <summary>
        /// El separador de decimales para los campos numéricos
        /// </summary>
        const string SeparadorDecimal = ",";

        /// <summary>
        /// Para indicar qué tecla "decimal" no se debe admitir
        /// </summary>
        const string NoSeparadorDecimal = ".";

        /// <summary>
        /// Comprobar si se aceptan las teclas en una caja de texto.
        /// En la pulsación de los controles numéricos
        /// aceptar solo los caracteres numéricos,
        /// el valor negativo, el separador de decimales
        /// y las teclas Intro, Delete, Back (borrar hacia atrás)
        ///
        /// Es raro, si teclasAceptadas es: ",-1234567890" también acepta el punto
        /// </summary>
        private char AceptarTeclas(KeyPressEventArgs e, string teclasAceptadas)
        {
            char c = e.KeyChar;

            if (c == Convert.ToChar(Keys.Return))
            {
                // con esto hacemos que se ignore la pulsación
                e.Handled = true;
                // se manda al siguiente control
                SendKeys.Send("{TAB}");
            }
            else if (c == Convert.ToChar(NoSeparadorDecimal))
            {
                e.KeyChar = Convert.ToChar(SeparadorDecimal);
            }
            else if (teclasAceptadas.Contains(c.ToString()))
            {
                // no hacer nada, se aceptan
            }
            else if (c == Convert.ToChar(Keys.Delete) || c == Convert.ToChar(Keys.Back))
            {
                // no hacer nada, se aceptan
            }
            else
            {
                e.Handled = true;
            }
            return c;
        }



        //--------------------------------------------------------------------------
        // Los métodos de evento del formulario
        //--------------------------------------------------------------------------

        private void btnCerrar_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        private void btnAsignarTabla1_Click(object sender, EventArgs e)
        {
            var d = 0M;
            Decimal.TryParse(txtTabla1_campo1.Text, out d);
            var ret = AñadirMiTabla1(d);

            txtMensaje1.Text = "";
            if (ret.hayError)
                txtMensaje1.Text = "ERROR\r\n";
            txtMensaje1.Text += ret.msg;
        }

        private void btnAsignarTabla2_Click(object sender, EventArgs e)
        {
            var valores = new decimal[12];
            var d = 0M;

            Decimal.TryParse(txtTabla2_campo1.Text, out d);
            valores[0] = d;

            d = 0M;
            Decimal.TryParse(txtTabla2_campo2.Text, out d);
            valores[1] = d;

            var ret = AñadirMiTabla2(valores);

            txtMensaje2.Text = "";
            if (ret.hayError)
                txtMensaje2.Text = "ERROR\r\n";
            txtMensaje2.Text += ret.msg;
        }

        private void btnMostrar1_Click(object sender, EventArgs e)
        {
            // mostrar los datos de MiTabla1
            txtMensaje1.Text = leerMiTabla("MiTabla1");
        }

        private void btnMostrar2_Click(object sender, EventArgs e)
        {
            // mostrar los datos de MiTabla2
            txtMensaje2.Text = leerMiTabla("MiTabla2");
        }

        private void txt_KeyPress(object sender, KeyPressEventArgs e)
        {
            AceptarTeclas(e, SeparadorDecimal + "-1234567890");
        }

        public Form1()
        {
            InitializeComponent();
        }

<

        private void Form1_KeyDown(object sender, KeyEventArgs e)
        {
            // detecta la pulsación de las teclas en el formulario
            // antes de mandarla a los controles
            // En el diseñador de formularios tienes que
            // asignar un valor True a la propiedad KeyPreview

            if (e.Modifiers == Keys.Control)
            {


                if (e.KeyCode == Keys.C)
                {
                    // copiar el texto
                    if (ActiveControl is TextBox)
                    {
                        //Dim texto = ActiveControl.Text
                        //Clipboard.SetText(texto)
                        var txt = ActiveControl as TextBox;
                        if (txt == null) return;
                        txt.Copy();

                        e.Handled = true;
                    }
                }
                else if (e.KeyCode == Keys.V)
                {
                    // pegar el texto
                    if (ActiveControl is TextBox)
                    {
                        var txt = ActiveControl as TextBox;
                        if (txt == null) return;
                        txt.Paste();

                        e.Handled = true;
                    }
                }
                else if (e.KeyCode == Keys.X)
                {
                    // cortar el texto
                    if (ActiveControl is TextBox)
                    {
                        var txt = ActiveControl as TextBox;
                        if (txt == null) return;
                        txt.Cut();

                        e.Handled = true;
                    }
                }
                else if (e.KeyCode == Keys.Z)
                {
                    //deshacer
                    if (ActiveControl is TextBox)
                    {
                        var txt = ActiveControl as TextBox;
                        if (txt == null) return;
                        if (txt.CanUndo)
                        {
                            txt.Undo();
                        }
                        e.Handled = true;
                    }
                }
            }
        }
    }
}

Espero que te sea de utilidad.

Nos vemos
Guillermo

Error al guardar datos decimales – El código para Visual Basic

Aquí tienes el código para Visual Basic de la aplicación de ejemplo del artículo Error al guardar datos decimales: El valor del parámetro ‘xxx’ está fuera del intervalo.

Nota:
Si buscabas el código para C# está en este otro enlace:
Error al guardar datos decimales – El código para C#.

Cuando lo tenga publicado, te pondré el enlace para descargar la solución de Visual Studio 2017 tanto para VB como para C#.

El código de Visual Basic .NET

'------------------------------------------------------------------------------
'  Ejemplo para el error de asignar a decimal(4,4)                  (07/Dic/18)
'
' (c) Guillermo (elGuille) Som, 2018
'------------------------------------------------------------------------------
Option Strict On
Option Infer On

Imports System
'Imports System.Data
Imports System.Data.SqlClient
Imports System.Text

Public Class Form1
    '--------------------------------------------------------------------------
    ' Los campos para acceder a la base de datos
    '--------------------------------------------------------------------------

    ''' <summary>
    ''' El usuario para acceder a la base de datos de SQL Server.<br />
    ''' Si es una cadena vacía se usará la seguridad integrada de Windows.
    ''' </summary>
    Private userDb As String = "UsuarioErrDec"

    ''' <summary>
    ''' El password del usuario que accede a la base de datos de SQL Server
    ''' </summary>
    Private passwordDB As String = "123456"

    ''' <summary>
    ''' El servidor donde está la base de datos.<br />
    ''' Normalmente será .\SQLEXPRESS o (local)
    ''' </summary>
    Private serverName As String = ".\SQLEXPRESS" ' "(local)"
    ''' <summary>
    ''' El nombre de la base de datos de SQL Server
    ''' </summary>
    Private databaseName As String = "ErrorDecimal"

    ''' <summary>
    ''' Devuelve la cadena de conexión a la base de datos de SQL Server<br />
    ''' Si el usuario es una cadena vacía, se usará la seguridad integrada de Windows
    ''' </summary>
    Private ReadOnly Property ConnectionString As String
        Get
            With New SqlConnectionStringBuilder
                .DataSource = serverName
                .InitialCatalog = databaseName
                If String.IsNullOrWhiteSpace(userDb) Then
                    .IntegratedSecurity = True
                Else
                    .UserID = userDb
                    .Password = passwordDB
                End If

                Return .ConnectionString
            End With
        End Get
    End Property

    '--------------------------------------------------------------------------
    ' Añadir un valor a las tablas
    '--------------------------------------------------------------------------
    Private Function AñadirMiTabla1(valor As Decimal) As (hayError As Boolean,
                                                         msg As String)
        Dim sel = "INSERT INTO MiTabla1 (Decimal_4_4) 
                   VALUES (@Decimal_4_4)"

        Dim retVal = (hayError:=False, msg:="")

        Dim sCon = ConnectionString

        Using con As New SqlConnection(sCon)
            Dim cmd As New SqlCommand(sel, con)

            cmd.Parameters.AddWithValue("@Decimal_4_4", valor)

            con.Open()

            Try
                Dim ret = CInt(cmd.ExecuteNonQuery())
                'Dim ret = CInt(cmd.ExecuteScalar())

                retVal.hayError = (ret < 1)
                retVal.msg = "Todo OK. cmd.ExecuteNonQuery() = " & ret.ToString

            Catch ex As Exception
                retVal.msg = ex.Message
                retVal.hayError = True
            End Try

            con.Close()
        End Using

        Return retVal
    End Function

    Private Function AñadirMiTabla2(valores() As Decimal) As (hayError As Boolean,
                                                         msg As String)
        Dim sel = "INSERT INTO MiTabla2 (Decimal_6_4, Decimal_18_6) 
                   VALUES (@Decimal_6_4, @Decimal_18_6)"

        Dim retVal = (hayError:=False, msg:="")

        Dim sCon = ConnectionString

        Using con As New SqlConnection(sCon)
            Dim cmd As New SqlCommand(sel, con)

            cmd.Parameters.AddWithValue("@Decimal_6_4", valores(0))
            cmd.Parameters.AddWithValue("@Decimal_18_6", valores(1))

            con.Open()

            Try
                Dim ret = CInt(cmd.ExecuteNonQuery())

                retVal.hayError = (ret < 1)
                retVal.msg = "Todo OK. cmd.ExecuteNonQuery() = " & ret.ToString

            Catch ex As Exception
                retVal.msg = ex.Message
                retVal.hayError = True
            End Try

            con.Close()
        End Using

        Return retVal
    End Function

    Private Function leerMiTabla(tabla As String) As String
        Dim sel = "SELECT * FROM " & tabla

        Dim retVal = ""

        Dim sCon = ConnectionString

        Using con As New SqlConnection(sCon)
            Dim cmd As New SqlCommand(sel, con)

            con.Open()

            Try
                Dim ret = cmd.ExecuteReader

                Dim sb As New StringBuilder

                While ret.Read()
                    sb.AppendLine(String.Format("{0} = {1}", ret.GetName(0), ret(0)))

                    If ret.FieldCount > 1 Then
                        sb.AppendLine(String.Format("{0} = {1}", ret.GetName(1), ret(1)))
                    End If
                End While

                retVal = sb.ToString

            Catch ex As Exception
                retVal = "ERROR: " & ex.Message
            End Try

            con.Close()
        End Using

        Return retVal
    End Function


    '--------------------------------------------------------------------------
    ' Para aceptar la coma como decimal en las cajas numéricas
    '--------------------------------------------------------------------------

    ''' <summary>
    ''' El separador de decimales para los campos numéricos
    ''' </summary>
    Private Const SeparadorDecimal As String = ","

    ''' <summary>
    ''' Para indicar qué tecla "decimal" no se debe admitir
    ''' </summary>
    Private Const NoSeparadorDecimal As String = "."

    ''' <summary>
    ''' Comprobar si se aceptan las teclas en una caja de texto.
    ''' En la pulsación de los controles numéricos
    ''' aceptar solo los caracteres numéricos, 
    ''' el valor negativo, el separador de decimales
    ''' y las teclas Intro, Delete, Back (borrar hacia atrás)
    ''' 
    ''' Es raro, si teclasAceptadas es: ",-1234567890" también acepta el punto
    ''' </summary>
    Private Function AceptarTeclas(e As KeyPressEventArgs, teclasAceptadas As String) As Char
        Dim c = e.KeyChar
        If c = Convert.ToChar(Keys.Return) Then
            ' con esto hacemos que se ignore la pulsación
            e.Handled = True
            ' se manda al siguiente control
            SendKeys.Send("{TAB}")
        ElseIf c = Convert.ToChar(NoSeparadorDecimal) Then
            e.KeyChar = Convert.ToChar(SeparadorDecimal)
        ElseIf teclasAceptadas.Contains(c) Then
            ' no hacer nada, se aceptan
        ElseIf c = Convert.ToChar(Keys.Delete) OrElse
               c = Convert.ToChar(Keys.Back) Then
            ' no hacer nada, se aceptan
        Else
            e.Handled = True
        End If

        Return c
    End Function

    '--------------------------------------------------------------------------
    ' Los métodos de evento del formulario
    '--------------------------------------------------------------------------

    Private Sub btnCerrar_Click(sender As Object, e As EventArgs) Handles btnCerrar.Click
        Me.Close()
    End Sub

    Private Sub btnAsignarTabla1_Click(sender As Object, e As EventArgs) Handles btnAsignarTabla1.Click
        Dim d = 0@
        Decimal.TryParse(txtTabla1_campo1.Text, d)
        Dim ret = AñadirMiTabla1(d)

        txtMensaje1.Text = ""
        If ret.hayError Then
            txtMensaje1.Text = "ERROR" & vbCrLf
        End If
        txtMensaje1.Text &= ret.msg
    End Sub

    Private Sub btnAsignarTabla2_Click(sender As Object, e As EventArgs) Handles btnAsignarTabla2.Click
        Dim valores(1) As Decimal
        Dim d = 0@
        Decimal.TryParse(txtTabla2_campo1.Text, d)
        valores(0) = d
        d = 0@
        Decimal.TryParse(txtTabla2_campo2.Text, d)
        valores(1) = d

        Dim ret = AñadirMiTabla2(valores)

        txtMensaje2.Text = ""
        If ret.hayError Then
            txtMensaje2.Text = "ERROR" & vbCrLf
        End If
        txtMensaje2.Text &= ret.msg
    End Sub

    Private Sub txt_KeyPress(sender As Object, e As KeyPressEventArgs) Handles _
                                        txtTabla2_campo1.KeyPress, txtTabla1_campo1.KeyPress,
txtTabla2_campo2.KeyPress AceptarTeclas(e, SeparadorDecimal &
"-1234567890") End Sub Private Sub btnMostrar1_Click(sender As Object, e As EventArgs) Handles btnMostrar1.Click ' mostrar los datos de MiTabla1 txtMensaje1.Text = leerMiTabla("MiTabla1") End Sub Private Sub btnMostrar2_Click(sender As Object, e As EventArgs) Handles btnMostrar2.Click ' mostrar los datos de MiTabla2 txtMensaje2.Text = leerMiTabla("MiTabla2") End Sub Private Sub Form1_KeyDown(sender As Object, e As KeyEventArgs) Handles MyBase.KeyDown ' detecta la pulsación de las teclas en el formulario ' antes de mandarla a los controles ' En el diseñador de formularios tienes que ' asignar un valor True a la propiedad KeyPreview If e.Modifiers = Keys.Control Then If e.KeyCode = Keys.C Then ' copiar el texto If TypeOf ActiveControl Is TextBox Then 'Dim texto = ActiveControl.Text 'Clipboard.SetText(texto) Dim txt = TryCast(ActiveControl, TextBox) If txt Is Nothing Then Return txt.Copy() e.Handled = True End If ElseIf e.KeyCode = Keys.V Then ' pegar el texto If TypeOf ActiveControl Is TextBox Then Dim txt = TryCast(ActiveControl, TextBox) If txt Is Nothing Then Return txt.Paste() e.Handled = True End If ElseIf e.KeyCode = Keys.X Then ' cortar el texto If TypeOf ActiveControl Is TextBox Then Dim txt = TryCast(ActiveControl, TextBox) If txt Is Nothing Then Return txt.Cut() e.Handled = True End If ElseIf e.KeyCode = Keys.Z Then 'deshacer If TypeOf ActiveControl Is TextBox Then Dim txt = TryCast(ActiveControl, TextBox) If txt Is Nothing Then Return If txt.CanUndo Then txt.Undo() End If e.Handled = True End If End If End If End Sub End Class

Espero que te sea de utilidad.

Nos vemos
Guillermo

Cómo usar las Tuplas en Visual Basic y C Sharp con .NET Core 2.1 (o Visual Studio 2017 con .NET 4.7.2)

Pues eso… aquí te voy a explicar (con ejemplo de código) cómo definir y usar las tuplas (Tuples) en Visual Basic .NET (y para los amantes de C#, también pondré algunos ejemplos en ese lenguaje puntoycomagudo Winking smile)

En esta primera “entrega” te voy a dar 3 ejemplos (+ 1 extra) de cómo usar las tuplas con .NET Core 2.1 (si prefieres hacerlo con .NET normal tendrás que usar la versión 4.7.2 o superior) en una aplicación de Consola.

El contenido es el siguiente:

Ejemplo 1: definir las tuplas sin nombres
Ejemplo 2: definir las tuplas con nombres y asignación después de definir
Ejemplo 3: definir las tuplas con nombres y asignando al definir
Ejemplo 4: definir las tuplas con nombres y asignando al definir (al estilo de C#)
Ejemplo 5: definir un método que recibe un array tuplas

Mmmmm… te dije 3 + un extra y resulta que son 4 + un extra Winking smile

Si no sabes qué son las tuplas, decirte que son como una estructura (Struct) pero definidas de forma “directa” sin necesidad de crear el tipo previamente.

Si quieres saber más sobre las tuplas, te recomiendo que leas la documentación de .NET:
Tipos de tupla en C#
Tuplas (Visual Basic)

Código de uso de Tuplas (Tuples) en Visual Basic

Ejemplo 1: Ejemplo básico de tuplas sin definir los nombres de los miembros:

' Al definirla de esta forma 
' tenemos una tupla con dos elementos del tipo cadena
Dim t1 = ("Hola", "mundo")

' para acceder a los miembros usaremos Item1, Item2
Console.WriteLine("{0} {1}", t1.Item1, t1.Item2)

Ejemplo 2: Definimos una tupla con miembros con nombres, asignando los nombres individualmente. Para acceder a los miembros de la tupla usamos los nombres.

' definimos una tupla con miembros con nombres
Dim t2 As (saludo As String, destino As String)
' para acceder a los miembros, usamos los nombres
t2.saludo = "Hola"
t2.destino = "Mundo"

Console.WriteLine("{0} {1}", t2.saludo, t2.destino)

Ejemplo 3: Definimos una tupla con miembros con nombres, asignando los valores al definirla. Para acceder a los miembros, usamos los nombres.

' definimos una tupla con miembros con nombres
Dim t2 As (saludo As String, destino As String) =
("Hola", "Mundo") ' para acceder a los miembros, usamos los nombres Console.WriteLine("{0} {1}", t2.saludo, t2.destino)

Ejemplo 4: Definimos una tupla con miembros con nombres, asignando los valores al definirla. Para acceder a los miembros, usamos los nombres.

' definimos una tupla con miembros con nombres
Dim t2 = (saludo:="Hola", destino:="Mundo")
' para acceder a los miembros, usamos los nombres
Console.WriteLine("{0} {1}", t2.saludo, t2.destino)

Ejemplo 5 (extra): Método que recibe un array de tipo “tupla”.

Este código es un método llamado colorear que recibe un array del tipo (ConsoleColor, String), se procesa cada uno de los elementos del array y se usa el valor del color para indicar el color del valor ForegroundColor (color del texto) de la clase Consola, el contenido del valor String lo usamos para mostrarlo en la consola por medio de WriteLine.

Con ese código se consiguen salidas en la ventana de la consola como la siguiente:

tuplasVB_04

El código del método colorear es el siguiente:

''' <summary>
''' Colorear la salida de los ejemplos, 
''' también usando tuplas 😉
''' Se pasa como argumento 
''' un array del tipo (color As ConsoleColor, texto As String)
''' </summary>
''' <param name=items">un array del tipo (color As ConsoleColor, texto As String)</param>"
Private Sub colorear(items As (color As ConsoleColor, texto As String)())
    For Each it In items
        Console.ForegroundColor = it.color
        Console.WriteLine(it.texto)
    Next

    Console.ForegroundColor = co.Gray
    Console.WriteLine()
End Sub

Para usarlo podemos hacer como en el código para el cuarto ejemplo:

Private Sub ejemplo4()
    colorear({(co.Green, "definimos una tupla con miembros con nombres"),
              (co.Green, "(asignando los valores al definirla)"),
              (co.Yellow, "Dim t2 = (saludo:=""Hola"", destino:=""Mundo"")"),
              (co.Green, "para acceder a los miembros, usamos los nombres"),
              (co.Yellow, "Console.WriteLine(""{0} {1}"", t2.saludo, t2.destino)")})

    ' definimos una tupla con miembros con nombres
    Dim t2 = (saludo:="Hola", destino:="Mundo")
    ' para acceder a los miembros, usamos los nombres
    Console.WriteLine("{0} {1}", t2.saludo, t2.destino)

    Console.ReadLine()
End Sub

Nota:
Es curioso, pero resulta que es más fácil definir los parámetros (de tipo array o matriz) directamente en la llamada del método colorear en Visual Basic que en C#.
En Visual Basic se indica el array del tipo tupla de la siguiente forma:

colorear({
    (co.Green, “definimos una tupla con miembros con nombres”),

     (co.Green, “(asignando los valores al definirla)”),     (co.Yellow, “Dim t2 = (saludo:=””Hola””, destino:=””Mundo””)”),

     (co.Green, “para acceder a los miembros, usamos los nombres”),

     (co.Yellow, “Console.WriteLine(“”{0} {1}””, t2.saludo, t2.destino)”)})

Mientras que en C# hay indicar que es un nuevo array:
colorear(new []{
       (co.Green, “definimos una tupla con miembros con nombres”),
       (co.Green, “(asignando los valores al definirla)”),
       (co.Yellow, “var t2 = (saludo:\”Hola\”, destino:\”Mundo\”);”),
       (co.Green, “para acceder a los miembros, usamos los nombres”),
       (co.Yellow, “Console.WriteLine(\”{0} {1}\”, t2.saludo, t2.destino);”)});

Y esto es todo por hoy.
Bueno, no, más abajo te muestro el código de estos dos últimos códigos para C#.

Nota:
En otra ocasión te mostraré más código de ejemplo del uso de tuplas en Visual Basic y C#, seguramente usando funciones que devuelvan tuplas y cómo usar la “inferencia” de los argumentos con nombre… ¿se podrá hacer eso con Visual Basic? sí se puede… pero necesita más explicación, ya que el Visual Studio 2017 no lo compilará y hay que hacer “un tuquillo” para que lo compile. Con C# tampoco lo compila, y también hay que hacer un truco similar al de Visual Basic.
En realidad no te lo explico aquí porque no lo había probado, entre otras cosas porque no me ha hecho falta; lo de la función que devuelve una tupla si que lo he usado en una aplicación que estoy haciendo actualmente.

Espero que te sea de utilidad Smile

Nos vemos.
Guillermo

P.S. 09/Dic/18:
No es un artículo dedicado a las tuplas, pero en el ejemplo que publiqué ayer sobre el Error al guardar datos decimales: El valor del parámetro ‘xxx’ está fuera del intervalo tienes un ejemplo de cómo usar una función que devuelve una tupla.

Private Function AñadirMiTabla1(valor As Decimal) As (hayError As Boolean, msg As String)

private (bool hayError, string msg) AñadirMiTabla1(decimal valor)

P.S.

Código de uso de Tuplas (Tuples) en C#

Ejemplo 1: Ejemplo básico de tuplas sin definir los nombres de los miembros:

// Al definirla de esta forma
// tenemos una tupla con dos elementos del tipo cadena
var t1 = ("Hola", "mundo");

// para acceder a los miembros usaremos Item1, Item2
Console.WriteLine("{0} {1}", t1.Item1, t1.Item2);

Ejemplo 4: Definimos una tupla con miembros con nombres, asignando los valores al definirla. Para acceder a los miembros, usamos los nombres.

// definimos una tupla con miembros con nombres
var t2 = (saludo: "Hola", destino: "Mundo");
// para acceder a los miembros, usamos los nombres
Console.WriteLine("{0} {1}", t2.saludo, t2.destino);

Ejemplo 5 (extra): Método que recibe un array de tipo “tupla”.

Este código es un método llamado colorear que recibe un array del tipo (ConsoleColor, string), se procesa cada uno de los elementos del array y se usa el valor del color para indicar el color del valor ForegroundColor (color del texto) de la clase Consola, el contenido del valor string lo usamos para mostrarlo en la consola por medio de WriteLine.

Con ese código se consiguen salidas en la ventana de la consola como la siguiente:

tuplasCS_04

El código del método colorear es el siguiente:

/// <summary>
/// Colorear la salida de los ejemplos,
/// también usando tuplas 😉
/// Se pasa como argumento
/// un array del tipo (ConsoleColor color, string texto)
/// </summary>
/// <param name=items">un array del tipo (ConsoleColor color, string texto)</param>"
static private void colorear((ConsoleColor color, string texto)[] items)
{
    foreach (var it in items)
    {
        Console.ForegroundColor = it.color;
        Console.WriteLine(it.texto);
    }

    Console.ForegroundColor = co.Gray;
    Console.WriteLine();
}

Para usarlo podemos hacer como en el código para el cuarto ejemplo:

/// <summary>
/// Definimos una tupla con miembros con nombres
/// (asignando los valores al definirla)
/// Para acceder a los miembros, usamos los nombres
/// </summary>
static private void ejemplo4()
{
    //new (co color,string texto)[]

    colorear(new []{
          (co.Green, "definimos una tupla con miembros con nombres"),
          (co.Green, "(asignando los valores al definirla)"),
          (co.Yellow, "var t2 = (saludo:\"Hola\", destino:\"Mundo\");"),
          (co.Green, "para acceder a los miembros, usamos los nombres"),
          (co.Yellow, "Console.WriteLine(\"{0} {1}\", t2.saludo, t2.destino);")});

    // definimos una tupla con miembros con nombres
    var t2 = (saludo: "Hola", destino: "Mundo");
    // para acceder a los miembros, usamos los nombres
    Console.WriteLine("{0} {1}", t2.saludo, t2.destino);

    Console.ReadLine();
}

¡Hasta el siguiente post! Smile

Tiene una licencia para Visual Studio Professional 2017

Pues eso… que hace unos días mientras usaba el Visual Studio Community 2017 me salió un mensaje que decía (ver figura 1):

Tiene una licencia para Visual Studio Professional 2017. Obténgala ahora.

vs2017_licencia_01
Figura 1. El IDE de Visual Studio dice que tengo una licencia gratis

Pulsé en el enlace y me mandó a la página de descargas de Visual Studio 2017 (ver figura 2), pero allí decía (tal como sigue diciendo) que la versión Professional es de evaluación.

Aún y así, la descargué e instalé.

Nota:
Por si no lo sabes, ya no tengo “licencia” para la versión de Visual Studio Professional como antes cuando era MVP.

vs2017_licencia_02
Figura 2. Página de descargas de Visual Studio 2017

Como no me fiaba de este “bondadoso regalo de Microsoft” busqué en la web a ver si alguien comentaba algo y… ¡no hallé nada!
Lo que pensé es que si era solo para los 30 días de prueba, pues… bien está, si “caduca” seguiré con la versión gratuita (Community) ya que prácticamente es lo mismo que la Professional, al menos para las cosas que yo uso.
En realidad lo que me gusta de la versión Professional es que te dice en qué parte del código estás usando un método o tipo (indicado justo encima de la definición con “n referencias” y al pulsar en ese “enlace” te muestra una ventana (tipo Intellisense) con los sitios en los que llaman al método o tipo y puedes verlos, etc. (ver la figura 3), pero por lo demás, con la versión “de gratis” me apaño bien Smile

vs2017_licencia_03
Figura 3. Referencias a las que hacen a un método o tipo de datos

Esta tarde, me sale un aviso de que me quedan pocos días para que expire los 30 días de prueba (también puedes seleccionar la opción Registrar producto, que está en el menú de ayuda de Visual Studio Professional 2017), pulso en ese aviso y me sale una pantalla parecida a la que te muestro en la figura 4, con la diferencia de que había más texto en el mensaje que hay a la derecha (indicando cuándo expiraba y esas cosas) y pulso en el “enlace” Buscar una licencia actualizada (con ese texto o algo parecido, ya no recuerdo jejeje) y me dijo que La licencia se ha actualizado correctamente.

vs2017_licencia_04
Figura 4. Buscar una licencia actualizada

Esperaré al 14 de diciembre a ver si es cierto que está registrada “de por vida” Winking smile

Espero que te sea de utilidad, sobre todo si no te fiabas de que ese mensaje fuese “verdadero” Winking smile

Nos vemos.
Guillermo

Números aleatorios con decimales en .NET

Pues eso… aquí te explicaré cómo generar números aleatorios con decimales y cómo indicar los valores entre los que quieres que estén esos números usando la clase Random de .NET y con ejemplos tanto para Visual Basic .NET como para C# (e incluso para BASIC, bueno… al menos para Visual Basic 6.0 y anteriores).

Pero primero te contaré la “batallita del Guille” para que sepas el porqué a estas alturas de la vida te explico algo tan “elemental” Winking smile

Si no te quieres leer la batallita, pues… pasa un poco más abajo que ahí te muestro el código de ejemplo tanto para Visual Basic .NET como para C# e incluso para VB6.

La batallita del Guille

Estaba yo el otro día escribiendo un código en el que necesitaba generar dos números aleatorios (en realidad varios).
Dos de ellos eran números enteros, en esos no tuve mayor problema, ya que tenía este artículo publicado en mi sitio: Random.Next ese incomprendido  y me lo leí, y todo a la perfección… Winking smile

El problema me surgió al crear los números aleatorios con decimales.
Yo sabía que usando NextDouble de la clase Random era como tenía que hacerlo (la certeza era porque yo lo decía al final del artículo ese que te he comentado en el párrafo anterior Winking smile).
Y curiosamente en ese mismo comentario decía que lo más parecido a la función Rnd() de Visual Basic 6.0 era precisamente NextDouble.
Pero… ¿quieres creerte que ya no me acordaba cómo se usaba la función RND de BASIC? jajajaja, en fin… seguramente serán cosas de la edad o de que en los últimos años no tengo la programación como una de mis tareas diarias… en fin…

La cuestión es que volvía a buscar en la web (indicando elGuille) cómo usar RND o casi… y me encontré como mi Curso Básico de Programación en Visual Basic, concretamente en las soluciones de la décima entrega, lo explicaba… ¡menos mal que el Guille aún mantiene su sitio después de los 22 años que cumplió hace pocos días! Winking smile

Generar un número aleatorio con decimales entre dos cifras

El método NextDouble genera un número que será igual o mayor que 0.0 y menor (pero no igual) que 1.0.
Por tanto si lo multiplicaras, por ejemplo por 6, generaría un valor que iría desde 0.0 a 5.99.

Nota:
En Visual Basic 6.0 (o incluso en VB.NET y si me apuras hasta en C#) se utilizará la función Rnd para hacer el mismo papel que NextDouble, pero con valores de tipo Single en lugar de Double.

Tal como explico en las respuestas del curso básico, si quieres un número entero entre 20 y 50 debes escribir un código como este (este ejemplo es de VB6, las variables están declaradas en otra parte… supongo)

T = Int(Rnd * 31) + 20 ‘Número de rascadas, T valdrá de 20 a 50

Es decir la función Rnd (o el método NextDouble) debes multiplicarlo por  31 (50-20+1) y después añadirle el mínimo (20). De esa forma se genera el rango de valores que queremos usar.
En ese ejemplo se usa la función Int para convertir el resultado en un número entero, pero recuerda que ¡es código de VB6!

Ahora veremos ese mismo ejemplo pero haciendo las cosas bien y con .NET.

El código de ejemplo

El siguiente código creará un número aleatorio (con decimales) entre 20 y 50 (ambos incluidos).

Inserta este código en el método Main de una aplicación de consola.

Código para Visual Basic .NET

Dim r As New Random()

Dim minimo As Integer = 20
Dim maximo As Integer = 50

Dim res = (r.NextDouble() * (maximo - minimo + 1)) + minimo
Console.WriteLine("Un número Double entre {0} y {1} (incluidos)", minimo, maximo)
Console.WriteLine("(r.NextDouble * ({0} - {1} + 1)) + {1} = {2}", maximo, minimo, res)
Console.WriteLine()

Console.ReadLine()

Código para C#

var r = new Random();

int minimo = 20;
int maximo = 50;

var res = (r.NextDouble() * (maximo - minimo + 1)) + minimo;
Console.WriteLine("Un número Double entre {0} y {1} (incluidos)", minimo, maximo);
Console.WriteLine("(r.NextDouble * ({0} - {1} + 1)) + {1} = {2}", maximo, minimo, res);
Console.WriteLine();

Console.ReadLine();

La salida mostrada será algo así:

numeros_aleatorios_vb_02
Figura 1. Salida del código de ejemplo

Casualmente el número generado aleatoriamente es 50 y pico… para que veas que el máximo también se incluye Smile

Resumiendo

Para generar un número entre dos valores (ambos incluidos) usa el cálculo siguiente:

(r.NextDouble() * (maximo – minimo + 1)) + minimo

o este otro que también hace lo mismo:

(r.NextDouble() * (minimo – maximo)) + maximo

Resaltar aquí, que si quieres la misma funcionalidad que el método Next de la clase Random, es decir que el valor generado sea igual o mayor que mínimo pero menor que máximo tendrías que hacerlo de esta forma:

(r.NextDouble() * (maximo – minimo)) + minimo

Para finalizar, recordarte que le eches un vistazo a las explicaciones que doy en el artículo que te indiqué al principio:
Random.Next ese incomprendido

Espero que te sirva Winking smile

Nos vemos.
Guillermo

Las novedades de Visual Basic 15.5 y C# 7.3

Pues eso… esto es lo último que dicen en el sitio de Microsoft sobre las novedades de Visual Basic .NET y C#

En la página de Novedades de Visual Basic indica que es la versión 15.5 disponible en Visual Studio 2017 versión 15.5 (supongo que o superior, aunque en el Visual Studio Professional 2017 versión 15.9.2 las versiones de VB y C# son diferentes, al menos eso es lo que se muestra en la ventana Acerca de tal como puedes comprobar en la figura 1 donde se indica que ambas son la versión 2.10.0-beta2).

Versiones_csharp_vb_vs_pro_2017_15_9_2
Figura 1. Las versiones de VB y C# mostradas en Visual Studio 2017 v15.9.2

En cuanto a las Novedades de C# la última versión indicada en la página de Microsoft es C# 7.3 disponible en la versión 15.7 de Visual Studio 2017 y como se ve en la captura de la figura 1 (del Visual Studio Professional 2017 versión 15.9.2) la versión allí mostrada es la 2.10.0-beta2.

Si usas los ejecutables de compilación desde la línea de comandos (abre el acceso directo que te habrá creado la instalación de Visual Studio 2017 ya sea la Professional o la Community) tanto vbc como csc te muestran que es la versión 2.10.0.0.
Pero eso no es lo importante, lo que importan son las características indicadas en las páginas de novedades tanto de C# como de Visual Basic.

Espero que antes de que acabe este mes publique un artículo sobre cómo usar las “tuplas” (Tuples) tanto en Visual Basic como en C#, al menos en las incluidas en las versiones 7.2 de .NET), pero eso será otro día Winking smile

Nos vemos.
Guillermo

Evitar el aviso Saving changes is not permitted al modificar una tabla con Microsoft SQL Server Management Studio

Pues eso… ya me ha ocurrido varias veces que al modificar una tabla de una base de datos de SQL Server me daba un aviso indicando que no podía guardar los datos al modificar la estructura de la tabla: cambiar alguna columna, añadir alguna nueva o eliminar una existente. El aviso en inglés es el siguiente:

Saving changes is not permitted. The changes that you have made require the following tables to be dropped and re-created. You have either made changes to a table that can’t be re-created or enabled the option Prevent saving changes that require the table to be re-created.

La última vez que me pasó (hace unos días) me puse a buscar en la web el porqué de este mensaje (que después de saber la solución me resulta más evidente que en el propio mensaje te dice –o casi- el porqué Smile).

La solución para evitarlo es cambiar la configuración en el propio Management Studio de SQL Server (en mi caso estoy usando el de la versión 17.9 instalada con SQL Server Express 2017), ahora te lo explico.

La solución ahora está “destacada” al buscar con Google o con Bing esa frase (la indicada en el título) y muestra la dada en “stackoverflow.com“, pero esa no fue la que usé… – en realidad ya no me acuerdo I don't know smile, pero creo que fue un artículo de Confluence Support del que te dejo también el enlace), en cualquier caso lo que debes hacer es lo siguiente:

En el Management Studio ve al menú Tools (Herramientas) selecciona Options… (Opciones) y en el cuadro de diálogo mostrado selecciona en el panel izquierdo Designers (Diseñadores) y quita la marca en la opción Prevent saving changes that require table re-creation (no sé qué texto pone en el Management Studio en español, pero como verás en la siguiente captura de ducho cuadro de diálogo es la última de las casillas seleccionables –checkboxes-).

SQLMS_Tools_Designers_ed
Figura 1 – Opción a quitar para evitar el aviso

Y eso es todo… espero que te sirva Winking smile

Nos vemos.
Guillermo

prueba de imagen

Probando con Open Live Writer y la configuración para cargar imágenes en el blog http://www.elguillemola.com

IMG_2848_edited

Nos vemos.
Guillermo

buenos días, martes 6-mar-18

Los buenos días de hoy es con una foto del amanecer en Nerja, concretamente desde el paseo de la plaza de los Cangrejos, en la playa de la Torrecilla

Nos vemos.

Guillermo