SELECT
	OBJECT_NAME(C.OBJECT_ID) AS 'Tabla'
	,C.name AS 'Columna'
	,SCHEMA_NAME(T.schema_id) AS 'Esquema'
	,T.name AS 'Tipo'	
	,C.max_length AS 'Tamaño Maximo en Bytes'
	,C.precision AS 'Precisión'
	,C.scale AS 'Escala'
FROM 
	sys.columns AS C
JOIN 
	sys.types AS T 
ON 
	C.user_type_id = T.user_type_id
WHERE 
	OBJECT_NAME(C.OBJECT_ID)='Card' 
ORDER BY 
	C.OBJECT_ID;

        /// <summary>
        /// Método para validar si una cadena cumple con la condición de ser correo electrónico.
        /// </summary>
        /// <param name="value">Valor a validar.</param>
        /// <returns>Resultado de la validación.</returns>
        public bool ValidateEmail(string value)
        {
            bool result = false;

            try
            {
                MailAddress mailAddress = new MailAddress(value);
                result = mailAddress.Address.Equals(value, StringComparison.OrdinalIgnoreCase);
            }
            catch (Exception)
            {
                result = false;
            }

            return result;
        }

       private bool SwitchWithDataType(Type dataType, object value)
        {
            bool result = false;

            Dictionary<Type, Action> @switch = new Dictionary<Type, Action>
            {
                {
                    typeof(short), () => { result = TryParseToShort(value); }
                },
                {
                    typeof(int), () =>{ result= TryParseToInt(value); }
                },
                {
                    typeof(long), () =>{ result= TryParseToLong(value); }
                },
                {
                    typeof(string), ()=>{ result=  TryParseToString(value); }
                }
            };

            @switch[dataType]();

            return result;
        }

SELECT * FROM [Catalogos].[CategoriasGasto];

SELECT 
	STUFF(
			CAST((SELECT
					CONCAT(',',MAX(Descripcion)) 
				FROM 
					[Catalogos].[CategoriasGasto]					
				GROUP BY 
					Descripcion
				FOR XML PATH('')) AS VARCHAR(8000))
			,1
			,1
			,''
		) AS 'Concatenacion';

namespace WebApiClient.App_Code
{
    #region [Bibliotecas de clases]
    using System;
    #endregion

    /// <summary>
    /// Clase que encapsula un conjunto de funciones para calculos de distancia entre coordenadas.
    /// </summary>
    public class Distancia
    {
        #region [Variables y constantes]
        /// <summary>
        /// Variable constante que encapsula el radio de la tierra.
        /// </summary>
        public const int _RADIO_TIERRA = 6371;
        #endregion

        #region [Constructor]
        /// <summary>
        /// Constructor de la clase.
        /// </summary>
        public Distancia() { }
        #endregion

        #region [Método para obtener la distancia en metros entre dos coordenadas]
        /// <summary>
        /// Método para obtener la distancia en metros entre dos coordenadas.
        /// </summary>
        /// <param name="latitud1">Latitud de la primera coordenada.</param>
        /// <param name="longitud1">Longitud de la primera coordenada.</param>
        /// <param name="latitud2">Latitud de la segunda coordenada.</param>
        /// <param name="longitud2">Longitud de la segunda coordenada.</param>
        /// <returns>Distancia en metros.</returns>
        public int ObtenDistanciaEnMetros(double latitud1, double longitud1, double latitud2, double longitud2)
        {
            double _distancia = 0;

            try
            {
                double _latitud = (latitud2 - latitud1) * (Math.PI / 180);
                double _longitud = (longitud2 - longitud1) * (Math.PI / 180);
                double _a = Math.Sin(_latitud / 2) * Math.Sin(_latitud / 2) + Math.Cos(latitud1 * (Math.PI / 180)) * Math.Cos(latitud2 * (Math.PI / 180)) * Math.Sin(_longitud / 2) * Math.Sin(_longitud / 2);
                double _c = 2 * Math.Atan2(Math.Sqrt(_a), Math.Sqrt(1 - _a));

                _distancia = (_RADIO_TIERRA * _c) * 1000;
            }
            catch (Exception)
            {
                _distancia = -1;
            }

            return (int)Math.Round(_distancia, MidpointRounding.AwayFromZero);
        }
        #endregion

        #region [Destructor de la clase]
        /// <summary>
        /// Destructor de la clase.
        /// Invoca al Garbage Collector para liberar el objeto de memoria.
        /// </summary>
        ~Distancia() { GC.Collect(); }
        #endregion
    }
}