.NET y SQL Nivel 1 Oscar Espinel: 2015

viernes, 5 de junio de 2015

Rompecabezas con MVC

Hola a todos en esta entrada podeis observar como complementar el juego de rompecabezas con el patron MVC, lo que teneis que hacer es simplemente generar otra capa mas en la que vais a colocar la capa base o las clases padre de la aplicacion, en la segunda colocais las operaciones y en la tercera se encuentra la capa fisica.

luego, pegais todo el código que te adjunto en el final de esta entrada, ejecutas el programa y listo es el mismo programa que teniamos pero con patron MVC, espero te haya gustado y dejadme comentarios por fa.

Adiós.

Descarguelooo¡¡

miércoles, 15 de abril de 2015

PICAS Y FIJAS

Hola, a todos espero que estén bien, bueno en esta oportunidad voy a publicar el juego de picas y fijas, voy a explicar el juego: Es un juego con números que data de un siglo o más, el juego también se puede jugar con varios dígitos, en este caso esta echo para 4 es muy sencillo modificar la cantidad de valores, cada uno de los jugadores escribe un número secreto de n dígitos. Las cifras deben ser todas diferentes. Luego, a su vez, los jugadores tratan de adivinar el número de su oponente, que da el número de aciertos. Si las cifras son coincidentes en sus posiciones correctas, son "fijas"(o bulls), si en diferentes posiciones, son "picas"(o cows). Ejemplo:

El número secreto: 4271

Intento del oponente: 1234

Respuesta: una fija y dos picas. (La fija es "2", las picas son "4" y "1".)

Como siempre se debe crear un nuevo proyecto en visual studio 2013 que se llame Picas y Fijas, luego de ello pensamos en las funciones y cualidades que va a tener la aplicación de picas y fijas:

Yo personalmente quise hacer una interfaz donde el jugador realiza el juego solitario, pero también es adaptable al juego por parejas o mas, para el desarrollo de esta aplicación creamos los parametros iniciales y el método constructor:

El método que sigue realiza la operación de llenar el arregloEscondido o primer vector con los números aleatorios que el usuario debe adivinar:

Existe un método que realiza la operación de crear los arreglos mediante el comboBox que creamos para insertar la cantidad de dígitos que el usuario quiere adivinar:

/// <summary>
        /// Este metodo realiza la creacion de los dos arreglos para el numero aleatorio y el ingresado por el usuario,
        /// se ubican en cada panel respectivo y se asignan propiedades.
        /// </summary>
        /// <param name="sender"></param>
/// <param name="e"></param>
private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            int numero = Convert.ToInt32(comboBox1.SelectedItem);
            int a = 80;
            for (int i = 1; i <= numero; i++)
            {
                TextBox PNumeroAdivinar = new TextBox(); //instanciamos nuestros nuevos TextBox del arreglo escondido
                TextBox PNumeroAdivinar2 = new TextBox(); //instanciamos nuestros nuevos TextBox del arreglo a insertar
               
                
                PNumeroAdivinar.Location = new Point(50, 12);
                PNumeroAdivinar.Left = a;
                PNumeroAdivinar.Height = 80;
                PNumeroAdivinar.Width = 80;
                PNumeroAdivinar.Name = "PNumeroAdivinar" + i.ToString();

this.Controls.Add(PNumeroAdivinar); 
                panelbox.Controls.Add(PNumeroAdivinar);

PNumeroAdivinar2.Location = new Point(50, 12);
                PNumeroAdivinar2.Left = a;
                PNumeroAdivinar2.Height = 100;
                PNumeroAdivinar2.Width = 80;
                PNumeroAdivinar2.Name = "PNumeroAdivinar2" + i.ToString();

this.Controls.Add(PNumeroAdivinar2);
                panelbox2.Controls.Add(PNumeroAdivinar2);

a = a + 80;
            }

comboBox1.Enabled = false;

}

El siguiente método realiza la comparación con los dos vectores y escoge la cantidad de picas que tiene el arreglo ingresado por el usuario:

En el siguiente caso ocurre lo mismo pero en cambio ahora compara el numero de fijas obtenidas por el usuario:

El método ganar compara sencillamente si la cantidad de fijas es igual al valor que el usuario escogió como dígitos, existe otro método que ingresa los datos de cada caja de texto y los guarda en el arreglo:

/// <summary>
        /// Este metodo genera la insercion de los datos digitados en las cajas de texto del panel 2 al arreglo adivinador
        /// </summary>
        /// <param name="sender"></param>
/// <param name="e"></param>
private void Insertar_Click(object sender, EventArgs e)
        {            
            //if ( (NumeroAdivinar1.Text == "" || NumeroAdivinar2.Text == "" || NumeroAdivinar3.Text == "" || NumeroAdivinar4.Text == ""))
            //{
            //   MessageBox.Show("Por favor ingrese un valor numerico");
            //}else
            {
                arregloAdivinador = insertarVector();
                picas = Mirarpicas(arregloAdivinador, arregloEscondido);
                fijas = MirarFijas(arregloAdivinador, arregloEscondido);
                log.Text += " \n Numero Introducido: " + arregloAdivinador[0].ToString() + " " +
                    " existen  " + picas + " picas y existen " + fijas +
                    " fijas " ;
                Ganar(fijas);
                intentos++;
                TriesText.Text = intentos.ToString();
                
            }

}

Y por ultimo generamos un método que genera un nuevo juego, y lo que hace es que desbloquea el combobox, y borra las cajas de texto de los paneles que el usuario generado anteriormente:

Yo realice una ventana nueva que cuando el usuario gana el juego se abre automáticamente y muestra un archivo .gif, también se cierra 2 segundos después de haberse abierto.

Bueno eso es todo por hoy, les agradezco por su tiempo y espero que les haya gustado, enseguida dejo el enlace para descargar el proyecto .zip.

Gracias.

Descargar archivo

PUZZLE NUMERICO

EL PUZZLE NUMERICO es un juego tipo solitario, en una cuadrícula de 4x4 se colocan los números del 1 al 15, dejando una casilla vacía, que puede ser ocupada por las piezas adyacentes, se trata de desordenar las 15 piezas con número y volver a recomponer el orden, puede resultar entretenido el proceso mediante el que se consigue resolverlo, pero el problema que te planteo es decidir si cualquier permutación de los 15 números puede ser reordenada, es decir, si el juego tiene solución para cualquier distribución inicial de los 15 números.

Inicialmente creamos un nuevo proyecto en visual studio 2013 que tenga el nombre del juego, luego creamos los parámetros de la clase y el método constructor:

Se debe detectar primero la dinámica del juego y las posibles acciones que este va a generar, en puzzle numérico existen unas reglas básicas que no se deben obviar como lo son: las casillas solo deben tener 4 movimientos, hacia arriba, abajo, izquierda y derecha si se encuentra el espacio posible, el juego finaliza cuando todas las casillas se encuentren en el orden correcto de izquierda a derecha y arriba hacia abajo, en el juego es posible reiniciar la partida y también generar los movimientos realizados:

Luego debemos crear 12 métodos básicos para la dinámica del juego y 16 métodos estándar para realizar los movimientos que tiene cada ficha en el juego, el primer método sera el que genere los números aleatorios de todo el juego y los coloque aleatoriamente en cada casilla:

El método que inserta cada valor en cada casilla es el siguiente:

Un método importante es el de finalizar el juego:

Cada casilla instancia un método general que realiza el movimiento de las figuras y cada que se oprime el botón "reset" se realizara una distribución aleatoria de números:

/// <summary>
        /// <summary>
        /// Método que evalua si es posible generar un movimiento en los botones centrales del
        /// juego (invocando al método cambiarPropiedades()).
        /// </summary>
        /// <param name="botonCentral"></param>
/// <param name="botonContiguo1"></param>
/// <param name="botonContiguo2"></param>
/// <param name="botonContiguo3"></param>
/// <param name="botonContiguo4"></param>
public void realizarMovimiento(Button botonCentral, Button botonContiguo1, Button botonContiguo2, Button botonContiguo3, Button botonContiguo4)
        {
            if (botonContiguo1.BackColor == Color.Black)
                cambiarPropiedades(botonCentral, botonContiguo1);
            else if (botonContiguo2.BackColor == Color.Black)
                cambiarPropiedades(botonCentral, botonContiguo2);
            else if (botonContiguo3.BackColor == Color.Black)
                cambiarPropiedades(botonCentral, botonContiguo3);
            else if (botonContiguo4.BackColor == Color.Black)
                cambiarPropiedades(botonCentral, botonContiguo4);
        }
        /// Este metodo reordena los valores del juego e inicializa el contador.
        /// </summary>
        /// <param name="sender"></param>
/// <param name="e"></param>
private void button1_Click_1(object sender, EventArgs e)
        {
            inicializarVectorAleatoriamente();
            fijarValorEnBotones();
        }

Eso es todo, el juego es muy interesante y ayuda a controlar y organizar la mente, si tienen dudas con gusto me escriben o le escriben al blog de mi compañero Jeison: http://jeisonayudaspuntonet.blogspot.com/2015/03/puzzle-numerico.html quien tambien participo en el desarrollo de esta maravillosa aplicacion.

Muchas gracias.

Descargar codigo.

martes, 7 de abril de 2015

Clases Abstractas

CLASES ABSTRACTAS

Hola, en esta ocasión quiero hablar sobre las clases abstractas y su implementación en el diagrama de clases poligonos regulares, como bien se sabe una clase abstracta no necesariamente debe tener métodos abstractos, en algunos casos la clase abstracta simplemente sirve para efectuar operaciones comunes a subclases sin necesidad de métodos abstractos. en otros casos si se usaran los métodos abstractos para referenciar operaciones en la clase abstracta del contenido de la sobreescritura en las subclases.

Las clases TRIANGULO, CUADRADO y PENTÁGONO pueden ser no abstractas ya que es una de las razones de ser de las clases abstractas, una clase abstracta no puede ser instanciada, pero pueden crearse subclases concretas sobre la base de una clase abstracta, y crear instancias de esas subclases, para esto hay que heredar de la clase abstracta y anular los métodos abstractos implementandolos.

En el diagrama podemos observar cómo hemos definido una clase abstracta denominada PoligonoRegular, se identifica señalando <<abstract>> en la parte superior del icono de la clase. Sin embargo, hereda de la clase Punto que no es abstracta, lo cual significa que puede haber instancias de Punto pero no de PoligonoRegular.

Triangulo, cuadrado y pentágono son subclases de la clase abstracta PoligonoRegular, que a su vez obtiene el metodo Punto en la clase Punto que es no abstracta y con ella varios metodos mas como lo son Punto con dos parámetros Double y Eje que a su vez es una clase <<enumeration>> que es una clase “especial” que limitan la creación de objetos a los especificados explícitamente en la implementación de la clase. La única limitación que tienen los enumerados respecto a una clase normal es que si tiene constructor, este debe de ser privado para que no se puedan crear nuevos objetos.

Muchas gracias, nos veremos en otra ocasión.

viernes, 6 de marzo de 2015

Calculadora de enteros

CALCULADORA EN .NET

Saludos: Ahora voy a explicar como realizar una calculadora en visual studio 2013 con c sharp, creamos un nuevo proyecto y debemos crear dos clases para probar la aplicación y para realizar las operaciones respectivas:

El código obtenido en este modulo esta echo en conjunto con Jeison en su blog http://jeisonayudaspuntonet.blogspot.com/ donde se ecplica claramente cada clase implementada para realizar esta prueba.

Al finalizar la implementan del código que al final de la entrada se adjuntara debera salir una pantalla de comando con las respectivas respuestas colocadas en la clase PruebasCalculadoraEnteros.

En este proyecto se crearon dos clases, una es para la realización de las operaciones que se van a utilizar en la calculadora llamada "PruebaCalculadoraEnteros" donde se realiza la quema de datos que serán operados por la clase "CalculadoraEnteros" donde se encuentran las distintas operaciones a realizar.

Si se tiene dudas acerca de esta implementación pueden visitar el blog de mis compañero, de nuevo muchas gracias y nos veremos en otra ocasión con mas de .net en visual studio 2013 y C Sharp.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Calculadora
{
/// <summary>
/// Clase para crear las operaciones que se pueden realizar con la calculadora
/// </summary>
class PruebasCalculadoraEnteros
{
/// <summary>
/// Se crea una instancia de la clase CalculadoraEnteros para utilizar los metodos
/// </summary>
CalculadoraEnteros calculadora = new CalculadoraEnteros();
/// <summary>
/// El metodo pruebaSumeDosEnteros toma como elementos, 2 enteros para su posterior suma donde el resultado
/// se imprime en consola
/// </summary>
public void pruebaSumeDosEnteros()
{
int result = calculadora.sumeDosEnteros(102, 70);
Console.WriteLine("sumeDosEnteros: " + result);
}
/// <summary>
/// El metodo pruebaRestaosEnteros toma como elementos, 2 enteros para su posterior resta donde el resultado
/// se imprime en consola
/// </summary>
public void pruebaResteDosEnteros()
{
int result = calculadora.resteDosEnteros(210, 67);
Console.WriteLine("resteDosEnteros: " + result);
}
/// <summary>
///El metodo pruebaSumeDosEnteros toma como elementos, 2 enteros para su posterior multiplicacion donde el resultado
/// se imprime en consola
/// </summary>
public void pruebaMultipliqueDosEnteros()
{
int result = calculadora.multipliqueDosEnteros(17, 51);
Console.WriteLine("multipliqueDosEnteros: " + result);
}
/// <summary>
/// El método pruebaCalculeCociente llama al método calculeCociente a través de una instancia de la clase CalculadoraEnteros,
/// se ingresan dos enteros como parámetro y se captura el valor retornado en una variable que se imprime por consola.
/// </summary>
public void pruebaCalculeCociente()
{
int cociente = calculadora.calculeCociente(167, 10);
Console.WriteLine("calculeCociente: " + cociente);
}
/// <summary>
/// El método pruebaCalculeResiduo llama al método calculeResiduo a través de una instancia de la clase CalculadoraEnteros,
/// se ingresan dos enteros como parámetro y se captura el valor retornado en una variable que se imprime por consola.
/// </summary>
public void pruebaCalculeResiduo()
{
int residuo = calculadora.calculeResiduo(167, 10);
Console.WriteLine("calculeResiduo: " + residuo);
}
/// <summary>
/// El método pruebaSumeEnteros llama al método sumeEnteros a través de una instancia de la clase CalculadoraEnteros,
/// se ingresa un arreglo de enteros como parámetro y se captura el valor que retorna de la suma en una variable que
/// se imprime por consola.
/// </summary>
public void pruebaSumeEnteros()
{
int[] enteros = { 1, 2, 3, 4, 5, 6 };
int suma = calculadora.sumeEnteros(enteros);
Console.WriteLine("sumeEnteros: " + suma);
}
/// <summary>
/// El método pruebaMultipliqueEnteros llama al método multipliqueEnteros a través de una instancia de la clase
/// CalculadoraEnteros, se ingresa un arreglo de enteros como parámetro y se captura el valor que retorna de la
/// multiplicación en una variable que se imprime por consola.
/// </summary>
public void pruebaMultipliqueEnteros()
{
int[] enteros = { 1, 2, 3, 4, 5, 6 };
int producto = calculadora.multipliqueEnteros(enteros);
Console.WriteLine("multipliqueEnteros: " + producto);
}
/// <summary>
/// El método Main contiene una instancia de la clase PruebasCalculadoraEnteros y a través de ésta invoca a los métodos
/// que ejecutan las pruebas correspondientes a cada operación; finalmente espera una tecla para finalizar la ejecución.
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
PruebasCalculadoraEnteros pruebas = new PruebasCalculadoraEnteros();
pruebas.pruebaSumeDosEnteros();
pruebas.pruebaResteDosEnteros();
pruebas.pruebaMultipliqueDosEnteros();
pruebas.pruebaCalculeCociente();
pruebas.pruebaCalculeResiduo();
pruebas.pruebaSumeEnteros();
pruebas.pruebaMultipliqueEnteros();
Console.ReadKey();
}
}
}

La otra clase:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Calculadora
{
/// <summary>
/// La clase CalculadoraEnteros contiene todos los métodos asociados únicamente a las operaciones.
/// </summary>
class CalculadoraEnteros
{
/// <summary>
/// El método sumeDosEnteros toma como parámetro dos números enteros y retorna la suma de ellos.
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <returns></returns>
public int sumeDosEnteros(int num1, int num2)
{
int result = num1 + num2;
return result;
}
/// <summary>
/// El método resteDosEnteros toma como parámetro dos números enteros y retorna la resta de ellos.
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <returns></returns>
public int resteDosEnteros(int num1, int num2)
{
int result = num1 - num2;
return result;
}
/// <summary>
/// El método multipliqueDosEnteros toma como parámetro dos números enteros y retorna la multiplicación entre ellos.
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <returns></returns>
public int multipliqueDosEnteros(int num1, int num2)
{
int result = num1 * num2;
return result;
}
/// <summary>
/// El método calculeCociente toma como parámetro dos números enteros y retorna el cociente de la división entre ellos.
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <returns></returns>
public int calculeCociente(int num1, int num2)
{
int cociente = num1 / num2;
return cociente;
}
/// <summary>
/// El método calculeResiduo toma como parámetro dos números enteros y retorna el residuo de la división entre ellos.
/// </summary>
/// <param name="num1"></param>
/// <param name="num2"></param>
/// <returns></returns>
public int calculeResiduo(int num1, int num2)
{
int residuo = num1 % num2;
return residuo;
}
/// <summary>
/// El método sumeEnteros recibe como parámetro un arreglo de enteros, los cuales va sumando mediante un ciclo for que recorre
/// dicho arreglo, y en una variable acumuladora almacena el resultado que finalmente es retornado.
/// </summary>
/// <param name="numeros"></param>
/// <returns></returns>
public int sumeEnteros(int[] numeros)
{
int suma = 0;
for (int i = 0; i < numeros.Length; i++)
{
suma = suma + numeros[i];
}
return suma;
}
/// <summary>
/// El método multipliqueEnteros recibe como parámetro un arreglo de enteros, los cuales va multiplicando mediante un ciclo
/// for que recorre dicho arreglo, y en una variable acumuladora almacena el resultado que finalmente es retornado.
/// </summary>
/// <param name="numeros"></param>
/// <returns></returns>
public int multipliqueEnteros(int[] numeros)
{
int producto = 1;
for (int i = 0; i < numeros.Length; i++)
{
producto = producto * numeros[i];
}
return producto;
}
}
}

CREAR REPOSITORIO EN LA NUBE DE VISUAL STUDIO 2013

CREAR REPOSITORIO EN LA NUBE DE VISUAL STUDIO 2013

hola a todos, hoy voy a mostrar como hacer un repositorio en visual studio 2013, primero debemos abrir el ambiente visual studio 2013, luego nos dirigimos a la parte derecha superior del ambiente donde aparecerá nuestra cuenta microsoft y elegimos la opción "Conectarse a Team Foundation Server":

Luego nos aparecerá un menú al lado derecho de la pantalla donde seleccionaremos la opcion "seleccionar proyectos de equipo":

Recuerda que el objetivo de utilizar un repositorio en la nube con visual studio 2013 es compartir toda tu información acerca de aplicaciones en cuanto a código con los demás y de esa misma manera recibir información de otros, comparte y ayuda a otros a mejorar sus códigos con el lenguaje de mejor sepas usar.

Para obtener mayor información por favor visita el siguiente link: http://s.ch9.ms/Series/Visual-Studio-2012-Premium-and-Ultimate-Overview-ESN/Visual-Studio-Ultimate-2012-How-to-multi-task-with-My-Work-ESN o también puedes visitar el Blog de Jeison: http://jeisonayudaspuntonet.blogspot.com/ es muy interesante y se pueden ver varios temas relacionados con .net

Gracias.

lunes, 9 de febrero de 2015

Creación de hola mundo¡

Buenos días, el día de hoy les voy a explicar cómo realizar la instalación de visual estudio en Windows 7 Professional, para comenzar debemos tener a la mano el ejecutable que nos permite instalar la aplicación en nuestro equipo de desarrollo:

Luego de descargar este archivo lo vamos a ejecutar dando doble clic sobre él, así se comenzara a descargar los paquetes de archivos de la aplicación y así se abrirá el ambiente .NET.

Luego abrimos el ambiente de desarrollo visual studio 2013 y crear un nuevo proyecto en archivo – nuevo – proyecto; saldrá la siguiente ventana para elegir la opción instalado – plantillas – visual C# - Escritorio de Windows - aplicación por consola y el nombre que queremos colocar en este caso se llamara “helloWorld”:

Damos clic al botón aceptar y automáticamente aparecerá el proyecto creado, con un código por defecto para la correcta depuración de la aplicación:

Luego digitamos el siguiente código:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace HelloWord

{

class Program

{

static void Main(string[] args)

{

Console.WriteLine("Hola Mundo!");

}

Con esto la aplicación nos dará el resultado esperado depurando la aplicación en el icono de iniciar o presionando la tecla f5, en una ventana de comandos nos aparecerá la palabra escrita en comillas Hola Mundo¡:

Muchas gracias por estar atentos a las indicaciones, cualquier duda o inquietud me pueden escribir comentarios a mi blog, muchas gracias.