2013/09/22

Como conectarse a una base de datos MS SQL Server desde C#

Una de las tareas más comunes para cualquier aplicación es hacer persistente y recuperar la información de una base de datos. En este caso daremos el primer paso para lograr este fin establecer una conexión con una instancia de base de datos por medio de código fuente.

1. Crear y configurar aplicación de consola.

Primeramente crearemos una aplicación de consola en C# y le agregaremos un archivo de configuración a nuestra nueva aplicación en donde deberemos definir la cadena de conexión para más información sobre el tema le invitamos a revisar la entrada de blog llamada: Cadenas de conexión para SQL Server en .Net. Siguiendo la recomendación de la entrada de blog nuestro archivo de configuración se vera de la siguiente forma:

Posteriormente debemos agregar una referencia al componente de .Net Framework llamado: "System.Configuration", si necesitamos saber cómo se incluir una referencia a nuestro proyecto podemos basarnos en su documentación oficial.

2. Establecer conexión con base de datos.

Ahora solamente nos queda establecer la conexión a la base de datos, como hemos definido nuestra cadena de conexión en nuestro archivo "app.config" debemos utilizar la clase ConfigurationManager para tener acceso a esta información y para lograr hacer la conexión a nuestra base de datos debemos utilizaremos un objeto de la clase SqlConnection.
En el siguiente ejemplo lo único que realizaremos una vez establecida la conexión será mostrar el nombre de la instancia de SQL Server, utilizando el objecto SqlConnection, por medio de la propiedad DataSourceEl código implementado se verá de la siguiente forma:


Debemos recordar incluir la siguiente declaración: using System.Configuration;, como se muestra en la línea número 6 del código fuente, en la sección correspondiente para poder tener acceso a la clase ConfigurationManger.
Espero que les sirva de mucha ayuda, para iniciar a trabajar con una instancia de bases de datos,
Saludos

2013/09/05

DevExpress - Controles para WinForms

El objetivo de este post es mostrarles algunas impresiones de los Controles del DevExpress para WinForms, tenemos en mente realizar tutoriales donde utilizaremos dichos controles.
Explora el conjunto de funciones completas DevExpress WinForms Controls.
Mas WinForms Controls


Mas información: DevExpress - Controls WinForms
Vamos a construir aplicaciones muy buenas, juntos!.

2013/09/02

Migrar Base de datos SQL Server a MySQL

www-ifxperu-com-Migracion-Base-Datos-SQL-Server-a-MySQL
Saludos estimados lectores, espero se encuentren bien, comenzamos por la siguiente frase un tanto persona: firme que esta situación de las migraciones de base de datos es un dolor de cabeza, debido a que se tiene que comprobar detenidamente que los datos hayan sido “movidos” en su totalidad, estuve buscando durante unas horas cómo hay que hacer en este tipo de casos, y del naufragio que tuve en la red aprendí que las herramientas trial no son buena idea por más que parezcan la cura a la desesperación que hay contra el tiempo, una recomendación: respirar, entrar en modo “yaoming” y seguir buscando con calma [aunque sabes que el tiempo te está ahorcando, evita el stress, las ideas claras aumentan la productividad]. Regresando al tema, veamos cómo es la nuez:

La idea es la siguiente: Primero MS SQL Server exportamos a un archivo MS Access, luego éste archivo lo importamos en MySQL
Y ya sin tanto rodeo, venga vamos! Iniciamos el SQL Server, en este caso tengo la versión 2008 R2, click derecho sobre la base de datos a migrar, Tareas –> Exportar datos ….
image
Aparecerá la siguiente ventana
image
Seleccionamos la configuración del origen de datos
image
En este paso, nos dirigimos hacia nuestro MS Access y creamos el archivo de “Base de Datos en blanco” es muy importante seleccionar el formato 2002-2003 y no 2007 como se ve en la imagen
image
Ahora regresamos al SQL Server y “examinamos” nuestro archivo y copiamos los datos.
image
image
Un pequeño detalle: es probable que salgan advertencias sobre los datos y los tipos por los que serán reemplazados.
Revisamos la base de datos creada en Access, siempre es bueno un SELECT COUNT(*) FROM nombretabla en el SQL Server y el Access para revisar la cantidad de filas empleadas.
Hasta aquí, ya tenemos la primera parte completa, continuemos! Para conectar el MySQL a MS Access, necesitamos el Connector/OBDC [descargar] Si están en windows de 64 bits, igual bajen el de 32bits porque encontré una manera medio alienígena de hacer la migración con pocos clicks y nos olvidamos de todas las configuraciones de los “nombres y archivos DSN”, dicho conector de arquitectura x86 es necesario para utilizar un programa llamado “Access To MySQL”[descargar] que a diferencia de otros programas que utilicé, éste en particular es freeware, simple, y muy efectivo:
image
Een la siguiente ventana solo buscaremos el access generado anteriormente y Next!
image
Aqui configuramos si queremos una transferencia directa o un archivo que contenga toda la estructura para luego ejecutarlo en el MySQL Query Browser.
image
Sea cual sea la opción elegida en el paso anterior, el programa solicitará que hagamos una selección de las tablas que emplearemos en la migración:
image
EL último paso viene a continuación, y bueno, solo queda presionar “Run Now” si es que ya reviste las opciones avanzadas
image
Los prefijos de las tablas están por una razón: algunos hosting solo admiten 1 base de datos y es por ello que toda instalación tiene su propio prefijo, por ejemplo el wordpres “wp_”
image
Y si le diste Run Now, comienza el proceso.
image
En caso hayas empleado File –> Open Script –> Seleccionas el archivo generado de extensión .sql y vas por execute
image
Finalmente hemos terminado, espero les haya sido de utilidad y les ahorre tiempo para evitar estar dando vueltas y vueltas por toda la red, nos vemos!

Fuente: http://ifxperu.com/
Si te ha parecido interesante podrías hacer click en +1, compartirlo en Facebook o Twitter, o dejar un comentario. ¡Gracias!.

Estructura de una aplicación ASP.NET MVC


Crear una aplicación ASP.NET MVC con Visual Studio

Ya hemos visto los fundamentos de una aplicación web y una introducción al patrón MVC. Llegados a esto punto ya podemos crear nuestra aplicación web con ASP.NET MVC. Para ello, abrimos Visual Studio, y a través del menú seleccionamos “New Project”. En el caso de que no tengamos instalado Visual Studio podemos descargar la versión Express (gratuita) desde el siguiente enlace: http://www.asp.net/mvc
image
Para crear una aplicación ASP.NET MVC basta con seleccionar la opción adecuada dentro de la pantalla de templates para Visual Studio. Seleccionamos ASP.NET MVC Web Applicattion. En el caso de que la opción no figure en al lista, es indicativo de que no hemos instalado ASP.NET MVC. Podemos realizar dicha descarga desde este enlace: http://www.asp.net/mvc
 image
En el siguiente paso debemos seleccionar la plantilla del proyecto. Disponemos de tres plantillas:
  • Empty – Plantilla vacia.
  • Internet Application – Plantilla de propósito general configurada con seguridad basada en formularios (la aplicación pedirá usuario y password al visitante para identificarse). Adecuada para aplicaciones de internet.
  • Intranet Application - Plantilla de propósito general configurada con seguridad basada en Windows, integrada con el directorio activo (la aplicación utiliza el usuario de Windows que esta conectado). Adecuada para entornos de intranet.
En nuestro caso seleccionamos “Internet Application”.
image
Es importante destacar que en la parte inferior de esta pantalla es en la que seleccionamos el motor de renderizado de las vistas «View Engine» - seleccionamos RAZOR. En ASP.NET MVC las vistas son procesadas por un motor de renderizado antes de ser devueltas al cliente. Este motor es RAZOR. En este mismo tutorial veremos en detalle la sintaxis de RAZOR.
Además disponemos de un segundo motor de renderizado – ASPX, que emplea la misma sintaxis utilizada por Web Forms (basado en las marcas <% %>)
También podemos instalar motores adicionales, como el caso de NHAML - http://code.google.com/p/nhaml/, una implementación de .NET del popular motor de renderizado de Ruby On Rails.
En esta pantalla – New ASP.NET MVC 4 Project -, seleccionamos además la casilla para crear un proyecto de «Testing» y el framework que deseamos utilizar para el mismo. Una de las ventajas que obtenemos al utilizar ASP.NET MVC es simplificar el proceso de test de nuestro código, algo importantísimo de cara a la calidad de nuestros desarrollos. Al final de este tutorial incluiremos un anexo sobre test unitario (mientras tanto os invito a la excelente introducción que realizo Ibon Landa en Geeks http://geeks.ms/blogs/ilanda/archive/2009/06/16/pruebas-unitarias-resumiendo.aspx)
Finalmente, pulsamos OK y Visual Studio creará el proyecto.
Al finalizar, debemos tener una solución de Visual Studio con una estructura como la siguiente:
image
Como podemos ver la imagen anterior Visual Studio ha creado una solución con dos proyectos:
  • MvcApplication1, se trata del proyecto web que contiene los archivos de nuestra aplicación web.
  • MvcApplication1.Test, es el proyecto de testing asociado.
A continuación vamos a explicar los diferente archivos y directorios que se han creado en el proyecto MvcApplication1, con el objetivo de entender la organización de ficheros y carpetas de ASP.NET MVC.
Profundizaremos en los diferentes conceptos según avancemos en el tutorial, se muestran aquí de manera introductoria para que nos vayamos familiarizando con la estructura de archivos y carpetas.

Estructura de directorios y archivos.

Cuando creamos una nueva aplicación con ASP.NET MVC se crea por defecto una estructura de directorios, apropiada para la gran mayoría de las aplicaciones. Por supuesto podemos añadir nuevos directorios a esta estructura, aunque por razones de coherencia recomendamos mantener la estructura que propone ASP.NET MVC.

Directorio App_Data.

Este directorio está pensado para ubicar archivos de datos, normalmente bases de datos MSSQL. También es el lugar adecuado para archivos XML o cualquier otra fuente de datos.
Inicialmente está vacio.

Directorio App_Start.

Este directorio, nuevo en ASP.NET MVC 4, contiene los archivos de código que se ejecutan al inicializar la aplicación. Como veremos mas adelante, todo aplicación ASP.NET MVC es una instancia derivada de la clase System.Web.HttpApplication, definida en el archivo global.asax. Esta clase es la encargada de iniciar la aplicación, el directorio App_Start está pensando para ubicar las clases de configuración para el inicio de la aplicación.
La siguiente imagen muestra el contenido del directorio.
image
Por defecto contiene los siguientes archivos(clases):
  • AuthConfig.cs
  • BundleConfig.cs
  • FilterConfig.cs
  • RouteConfig.cs
  • WebApiConfig.cs

Directorio Content.

El directorio Content está pensado para el contenido estático de la aplicación, especialmente útil para archivos css e imágenes asociadas.
image
ASP.NET MVC nos ofrece por defecto una organización en base a “temas”, que nos permita personalizar el aspecto visual de nuestra aplicación de forma fácil y rápida (eso en teoría… elaborar un tema visual puede requerir de mucho trabajo y la colaboración de un diseñador gráfico, algo que recomiendo siempre que sea posible).
También es el lugar apropiado para los archivos .less en el caso de que utilicemos esta tecnología en nuestra aplicación.

Directorio Controllers.

El directorio controllers en el lugar para los controladores, que como hemos visto en el capitulo anterior  los controladores son las clases encargadas de recibir y gestionar las peticiones http de la aplicación.
image
Veremos los controladores en profundidad mas adelante.

Directorio Filters

El directorio Filters es el lugar donde debemos ubicar los filtros. Los filtros son atributos (también llamados decoradores) para los controladores, que nos permiten aplicar un comportamiento previo y posterior a la ejecución de uno o varios métodos de los controladores. Son clases derivadas de System.Web.Mvc.ActionFilterAttribute. A través de este mecanismo podemos añadir fácilmente funcionalidad a nuestros controladores evitando repetir la misma lógica una y otra vez, sobrescribiendo el comportamiento de algunas acciones.
image 
La plantilla incluye un filtro de ejemplo, InitializeSimpleMembership, en el siguiente ejemplo vemos como se utiliza el fitlro para decorar la clase AccountController (también incluida en la plantilla de proyecto)
[Authorize]
[InitializeSimpleMembership]
public class AccountController : Controller
{
    //
    // GET: /Account/Login

}
Veremos los filtros en profundidad mas adelante.

Directorio Images

Este es evidente … El directorio images es lugar para la imágenes de nuestra aplicación.
image
Como observación diremos que en el caso de que las imágenes formen parte del aspecto visual del sitio web, y no del contenido, deberían estar en el directorio content, como parte de un tema.
Por ejemplo, el contenido de una galería fotográfica o de un catalogo de productos debería estas en la carpeta images, mientras que las imágenes de fondo, iconos de los botones, sprites, etc deberían estar en la carpeta content junto con los archivos css. Básicamente, si una imagen se utiliza en un archivo css el lugar adecuado es la carpeta content.

Directorio Models

El directorio models es la ubicación que nos propone ASP.NET MVC para las clases que representan el modelo de la aplicación, los datos que gestiona nuestra aplicación.
image
Nota. En aplicaciones complejas, divididas en capas las clases de modelo suelen incluirse en assemblie aparte.
La siguiente clase muestra un ejemplo muy básico para representar el modelo de nuestra aplicación.
public class FooModel
{
    public Guid Id { get; set; }

    public string Name { get; set; }
}
Una de las grandes ventajas de las que disponemos en ASP.NET es que podemos decorar la clase que representa la modelo con diferentes atributos, que nos van a permitir establecer reglar sobre los datos como por ejemplo las reglas de la validación, si el datos es requerido o no, la longitud máxima y mínima del dato … etc
public class FooModel
{
    [Required]   
    public Guid Id { get; set; }

    [Required]
    [StringLength(100, ErrorMessage = "The {0} must be at least {2} characters long.", MinimumLength = 3)]    
    [Display(Name = "Name for FooModel")]
    public string Name { get; set; }
}
Como veremos cuando veamos las vistas, estos atributos son interpretados por la vista para establecer automáticamente las validaciones necesarias en función del los decoradores utilizados en el modelo.

Directorio Scripts

El directorio scripts está pensado para ubicar los archivos de javascript (*.js). El código javascript es ejecutado en el contexto del navegador, es decir, en la parte cliente, y nos permite ejecutar acciones sin necesidad de enviar los datos al servidor.
image
ASP.NET MVC incluye varias librerias de javascript por defecto:
  • jquery.js. Esta popular y súper útil librería nos va a permitir gestionar fácilmente peticiones AJAX, manipular el DOM en cliente, etc … Esta librería se ha convertido en un framework muy popular, y es la base de para la creación de pluggins que nos van a permitir dotar a nuestro sitio web de efecto sorprendentes sin apenas esfuerzo. http://jquery.com/
  • jquery.spin.js. Este pluggin nos permite crear animaciones de indicación de carga de contenidos el circulito que da vueltas para indicarnos que la página esta realizando algún proceso . Es un pluggin de jQuery basado en spin.js. http://fgnass.github.io/spin.js/
  • jquery.validate.js. Este pluggin nos permite realizar validaciones en el lado cliente fácilmente. Esta vinculado al uso de decoradores en el modelo de nuestra aplicación.
  • knockout.js. Esta librería nos permite utilizar el patrón de diseño MVVM (Model View ViewModel), que introdujo Microsoft para el desarrollo con WPF y Silverlight en aplicaciones web con javascript. http://knockoutjs.com/
  • modernizr.js. Esta librería nos permite validar fácilmente si el navegador que esta ejecutando la página web es compatible con HTML5, en en caso de que no sea así proporcional un mecanismo alternativo (polyfill). http://modernizr.com/. Por ejemplo, si nuestro navegador es compatible con HTML5 interpretará sin problema la etiqueta VIDEO, pero en el caso de que estemos navegando con un navegador antiguo deberemos ofrecer al usuario un mecanismo alternativo para el video (un flash por ejemplo). En el siguiente enlace podemos encontrar polyfills para casi todas las características de HTML5: https://github.com/Modernizr/Modernizr/wiki/HTML5-Cross-Browser-Polyfills
Nota: El nombre de los archivos puede varias dependiendo de la versión instalada, por ejemplo el archivo jQuery.js se llama jquery-1.7.1.js, ya que corresponde con la versión 1.7.1 de la librería.

Directorio Views

El directorios Views contiene los archivos de vista. Como explicamos en la introducción al patrón MVC los controladores devuelven vistas sobre las que inyectamos el modelo de nuestra aplicación. Estas vistas son interpretadas por el motor de renderización – Razor en nuestro caso. Son archivos similares a aplicaciones de ASP clasico, donde tenemos código HTML estático y determinadas zonas de código que son ejecutadas en el servidor.
image
El siguiente ejemplo muestra el clásico “Hola Mundo”.
@{
    Layout = "~/Views/Shared/_Layout.cshtml";
    ViewBag.Title = "HelloWorld";
}
<h2>HelloWorld</h2>
@*El código se servidor se especifica con el caracter @*@
Podemos asignar un modelo a la vista a través de la siguiente directiva.
@model MvcApplication1.Models.FooModel
Veremos las vistas en profundidad mas adelante.

Directorio Shared

El directorio Shared contiene vistas que van a ser reutilizadas en otras vistas. Veremos como incluir vistas - denominadas parciales – en otra vista cuando veamos Razor, aunque de manera muy breve diremos que se realiza a través del Helper Html, de la siguiente forma:
@Html.Partial("Error") @*Incluye la vista parcial Error.cshtml, del directorio Shared*@
En este caso es muy importante respetar la ubicación de los archivos, ya que cuando desde una vista hagamos la llamada @Html.Partial(“Error”) para incluir la vista de la pantalla de error, el motor buscara en el directorio Shared para encontrar la vista Error.cshtml.
No debemos confundir una vista compartida con los controles .ascx de ASP.NET WebForms. Cuando incluimos vistas compartidas en otra vista, esta son interpretadas por RAZOR sin ejecutarse ningún controlador. Simplemente se renderiza su contenido – no como en los controles ascx donde se ejecuta todo el ciclo de vida del control completo y sus correspondientes eventos.
Es posible utilizar una vistas compartida de un modo muy similar al de un control ascx de ASP.NET WebForms, aunque para este debemos forzar la ejecución del controlador a través de los métodos Action y RenderAction del Helper Html:
@Html.Action("About") @*Ejecuta el método "About" del controlador correspondiente*@

Archivo _ViewStart.cshtml

Este archivo establece el layout por defecto de las páginas. El contenido del archivo es sencillo y únicamente especifica el archivo de layout.
@{
    Layout = "~/Views/Shared/_Layout.cshtml";
}
El layout es un archivo con extension .cshtml que contiene la estructura general de documento, que es reutilizada en el resto de vistas. De este modo evitamos tener que reescribir el código en todas las vistas, reutilizando el código y permitiendo que este sea mucho mas sencillo de mantener.
En cierto modo es similar a las MasterPages de ASP.NET WebForms.

Archivo _Layout.cshtml

El archivo _Layout.cshtml define el  layout de la aplicación, que contiene la estructura general de documento, que es reutilizada en el resto de vistas. El archivo _Layout.cshtml se encuentra dentro del directorio Views/Shared. El contenido del archivo layout por defecto se muestra a continuación:
<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="utf-8" />
        <title>@ViewBag.Title - My ASP.NET MVC Application</title>
        <link href="~/favicon.ico" rel="shortcut icon" type="image/x-icon" />
        <meta name="viewport" content="width=device-width" />
        @Styles.Render("~/Content/css")
        @Scripts.Render("~/bundles/modernizr")
        
    </head>
    <body>
        <header>
            <div class="content-wrapper">
                <div class="float-left">
                    <p class="site-title">@Html.ActionLink("your logo here", "Index", "Home")</p>
                </div>
                <div class="float-right">
                    <section id="login">
                        @Html.Partial("_LoginPartial")
                    </section>
                    <nav>
                        <ul id="menu">
                            <li>@Html.ActionLink("Home", "Index", "Home")</li>
                            <li>@Html.ActionLink("About", "About", "Home")</li>
                            <li>@Html.ActionLink("Contact", "Contact", "Home")</li>
                        </ul>
                    </nav>
                </div>
            </div>
        </header>
        <div id="body">
            @RenderSection("featured", required: false)
            <section class="content-wrapper main-content clear-fix">
                @RenderBody()
            </section>
        </div>
        <footer>
            <div class="content-wrapper">
                <div class="float-left">
                    <p>&copy; @DateTime.Now.Year - My ASP.NET MVC Application</p>
                </div>
            </div>
        </footer>

        @Scripts.Render("~/bundles/jquery")
        @RenderSection("scripts", required: false)
    </body>
</html>
Fijemonos en la llamada que hace Razor al método @RenderBody(), es ahí donde se procesará la vista que estemos mostrando.
Podemos tener múltiples archivos de layout dentro de nuestro proyecto.

El archivo web.config

El archivo web.config es el archivo principal de configuración de ASP.NET. Se trata de un archivo XML donde se define la configuración de la aplicación. Veremos poco a poco el contenido de este fichero, aunque vamos a ver aquí algunas características generales que es necesario conocer.
image
Para simplificar el despliegue de las aplicaciones, el archivo de configuración se presenta en diferentes versiones o “sabores”, de forma que podemos modificar el archivo de configuración dependiendo de nuestra configuración de despliegue. Si observamos estos archivos observaremos que contienen transformaciones XML que se aplican sobre el archivo web.config al desplegar la aplicación. De este modo cuando desplegamos la aplicación en modo Debug se aplicarán las transformaciones XML definidas en Web.Debug.config.
El archivo de configuración aplica un mecanismo de jerarquía a nivel de los archivos de configuración, en la que un archivo de mayor profundidad dentro de la jerarquía sobrescribe al de menor, en el contexto del recurso solicitado.
image
Por ejemplo, si dentro de nuestra aplicación tenemos un archivo web.config sobre la raíz del sitio (en gris sobre la imagen), y otro sobre la carpeta Views (en rojo), el archivo de configuración de la carpeta Views prevalece y sobrescribe el valor del archivo de configuración raiz (siempre que el recurso solicitado sea se encuentre el directorio, en este ejemplo Views).
De esta forma podemos por ejemplo establecer en nuestro sitio web “areas” públicas y privadas de manera muy sencilla, tan fácil separar los archivo es directorios e como incluir un archivo de configuración con la seguridad activada sobre el directorio privado, y otro accesible a todo el mundo en el directorio privado. Veremos como hacer esto con Areas de ASP.NET un poquito mas adelante.

El archivo global.asax

Toda aplicación ASP.NET MVC es una instancia de una clase derivada de System.Web.HttpApplication. Esta clase es el punto de entrada de nuestra aplicación – el Main de la aplicación web por decirlo de alguna manera. Como podemos observar, la clase base es la misma que para una aplicación ASP.NET clásica (WebForms) por lo que todos que podemos reutilizar todo lo que ya sabíamos de ASP.NET.
Desde este archivo podemos manejar eventos a nivel de aplicación, sesión, cache, autenticacion,  etc ...
Este archivo varia mucho desde la versión anterior de ASP.NET MVC, aunque el funcionamiento es el mismo. En ASP.NET MVC 4 se ha incluido el directorio App_Start que nos permite organizar como se inicializa la aplicación.
// Por defecto, el namespace corresponde con el nombre del proyecto 
namespace MvcApplication1 
{
    public class MvcApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            AuthConfig.RegisterAuth();
        }
    }
}
Como podemos ver, el código se encarga de registrar las áreas definidas en el proyecto, cargar la configuración, filtros, etc…, en definitiva, se encarga de configurar la aplicación para que esta pueda ejecutar de manera correcta. Las clases de configuración se encuentran en el directorio App_Start
En el siguiente enlace podemos encontrar la documentación oficial sobre el archivo global.asax http://msdn.microsoft.com/en-us/library/1xaas8a2(v=vs.71).aspx
La lista completa de eventos disponibles es la siguiente:
// Summary:
//     Occurs when ASP.NET acquires the current state (for example, session state)
//     that is associated with the current request.
public event EventHandler AcquireRequestState;
//
// Summary:
//     Occurs when a security module has established the identity of the user.
public event EventHandler AuthenticateRequest;
//
// Summary:
//     Occurs when a security module has verified user authorization.
public event EventHandler AuthorizeRequest;
//
// Summary:
//     Occurs as the first event in the HTTP pipeline chain of execution when ASP.NET
//     responds to a request.
public event EventHandler BeginRequest;
//
// Summary:
//     Occurs when the application is disposed.
public event EventHandler Disposed;
//
// Summary:
//     Occurs as the last event in the HTTP pipeline chain of execution when ASP.NET
//     responds to a request.
public event EventHandler EndRequest;
//
// Summary:
//     Occurs when an unhandled exception is thrown.
public event EventHandler Error;
//
// Summary:
//     Occurs just before ASP.NET performs any logging for the current request.
public event EventHandler LogRequest;
//
// Summary:
//     Occurs when the handler is selected to respond to the request.
public event EventHandler MapRequestHandler;
//
// Summary:
//     Occurs when the request state (for example, session state) that is associated
//     with the current request has been obtained.
public event EventHandler PostAcquireRequestState;
//
// Summary:
//     Occurs when a security module has established the identity of the user.
public event EventHandler PostAuthenticateRequest;
//
// Summary:
//     Occurs when the user for the current request has been authorized.
public event EventHandler PostAuthorizeRequest;
//
// Summary:
//     Occurs when ASP.NET has completed processing all the event handlers for the
//     System.Web.HttpApplication.LogRequest event.
public event EventHandler PostLogRequest;
//
// Summary:
//     Occurs when ASP.NET has mapped the current request to the appropriate event
//     handler.
public event EventHandler PostMapRequestHandler;
//
// Summary:
//     Occurs when ASP.NET has completed executing all request event handlers and
//     the request state data has been stored.
public event EventHandler PostReleaseRequestState;
//
// Summary:
//     Occurs when the ASP.NET event handler (for example, a page or an XML Web
//     service) finishes execution.
public event EventHandler PostRequestHandlerExecute;
//
// Summary:
//     Occurs when ASP.NET bypasses execution of the current event handler and allows
//     a caching module to serve a request from the cache.
public event EventHandler PostResolveRequestCache;
//
// Summary:
//     Occurs when ASP.NET finishes updating caching modules and storing responses
//     that are used to serve subsequent requests from the cache.
public event EventHandler PostUpdateRequestCache;
//
// Summary:
//     Occurs just before ASP.NET starts executing an event handler (for example,
//     a page or an XML Web service).
public event EventHandler PreRequestHandlerExecute;
//
// Summary:
//     Occurs just before ASP.NET sends content to the client.
public event EventHandler PreSendRequestContent;
//
// Summary:
//     Occurs just before ASP.NET sends HTTP headers to the client.
public event EventHandler PreSendRequestHeaders;
//
// Summary:
//     Occurs after ASP.NET finishes executing all request event handlers. This
//     event causes state modules to save the current state data.
public event EventHandler ReleaseRequestState;
//
// Summary:
//     Occurs when the managed objects that are associated with the request have
//     been released.
public event EventHandler RequestCompleted;
//
// Summary:
//     Occurs when ASP.NET finishes an authorization event to let the caching modules
//     serve requests from the cache, bypassing execution of the event handler (for
//     example, a page or an XML Web service).
public event EventHandler ResolveRequestCache;
//
// Summary:
//     Occurs when ASP.NET finishes executing an event handler in order to let caching
//     modules store responses that will be used to serve subsequent requests from
//     the cache.
public event EventHandler UpdateRequestCache;

Home Controller

La clase HomeController es el punto de entrada de la aplicación, la página por defecto.
Cuando creamos un nuevo proyecto ASP.NET MVC se crea también un controlador HomeController situado directamente el folder Controllers
image
El controlador de ejemplo que se incluye en el proyecto por defecto, incluye tres métodos: Index, About y Contact, que disponen de sus correspondiente vistas en el folder Home.
image
El código del HomeController es el siguiente:
namespace MvcApplication1.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            ViewBag.Message = "Modify this template to jump-start your ASP.NET MVC application.";

            return View();
        }

        public ActionResult About()
        {
            ViewBag.Message = "Your app description page.";

            return View();
        }

        public ActionResult Contact()
        {
            ViewBag.Message = "Your contact page.";

            return View();
        }
    }
}
Como podemos ver cada uno de los métodos del controlador devuelve la vista asociada por defecto:
  • Index() devuelve la vista index.cshtml
  • About() devuelve la vista about.cshtml
  • Contact() devuelve la vista contact.cshtml
Veremos los controladores en el siguiente capitulo.

Creación de Áreas.

Como hemos visto, ASP.NET MVC divide los elementos que componen su arquitectura en carpetas con el mismo nombre (Models, Views, Controllers). Esta división es fácil e intuitiva pero puede ser limitada en aplicaciones grandes, donde el número de entidades a manejar sea grande. Para estos casos ASP.NET MVC proporciona un mecanismo muy sencillo que nos permite agrupar contenidos (y sus configuraciones) denominadas Areas.
Un Area no es mas que una carpeta que replica en su interior la estructura anterior de MVC - Model, Views, Controllers y define sus propias rutas de acceso a través de la clase PublicContentAreaRegistration que se crea automáticamente al añadir una nueva área. Tiene la ventaja adicional de tener su propio archivo de configuración de modo que es ideal para diferenciar zonas públicas y privadas por ejemplo.
Podemos crear Areas del siguiente modo:
Sobre el explorador de soluciones de Visual Studio,
image
Visual Studio nos preguntara el nombre del área que queremos crear, en nuestro caso le damos el nombre PublicContent
image
Podemos ver que se ha creado en Visual Studio un directorio Areas, con un subdirectorio PublicContent en el que podemos encontrar la estructura de carpetas de Controllers, Models y Views que ya hemos visto anteriormente.
image
También tenemos un archivo de configuración (que nos permite sobrescribir la configuración raiz a través del mecanismo de jerarquia explicado anteriormente) y un archivo PublicContentAreaRegistration.cs en el que se registra la ruta del área sobre la tabla de rutas de ASP.NET MVC (veremos como funciona este mecanismo mas adelante), de momento diremos que la tabla de ruta establece un mapeo entre las URLs que envía el navegador y el controlador que debe gestionar estas peticiones.

Fuente: http://www.devjoker.com/
Si te ha parecido interesante podrías hacer click en +1, compartirlo en Facebook o Twitter, o dejar un comentario. ¡Gracias!.

Cómo iconizar una aplicación C# en el área de notificación de Windows

Explicaremos en este tutorial cómo ocultar una aplicación, desarrollada en C# (C Sharp) .Net, en el área de notificación de Windows, utilizando el componente no visual NotityIcon. Dicha aplicación quedará iniciada pero no se mostrará en la barra de tareas, en su lugar se mostrará un icono en el área de notificación de Windows:
Cómo iconizar una aplicación C# en el área de notificación de Windows
Para conseguir este efecto seguiremos los siguientes pasos. En primer lugar añadiremos a nuestra aplicación el componente NotifyIcon del Cuadro de herramientas (en el grupo "Controles comunes"):
Cómo iconizar una aplicación C# en el área de notificación de Windows
Antes de configurar el componente NotifyIcon añadiremos un segundo componente MenuStrip que nos permitirá mostrar un menú emergente al pulsar con el botón derecho del ratón sobre el icono del área de notificación para poder interacturar con la aplicación (volver a mostrarla, cerrarla y ejecutar cualquier tarea). Para ello accederemos al "Cuadro de herramientas" y pulsaremos sobre "MenuStrip" del grupo "Menús y barras de herramientas":
Cómo iconizar una aplicación C# en el área de notificación de Windows
Seleccionaremos el componente MenuStrip añadido y estableceremos su propiedad "Name" a "mnuContextual":
Cómo iconizar una aplicación C# en el área de notificación de Windows
Pulsaremos con el botón derecho del ratón sobre el MenuStrip llamado ahora mnuContextual y seleccionaremos "Editar elementos":
Cómo iconizar una aplicación C# en el área de notificación de Windows
Desde aquí añadiremos todos los elementos del menú que queramos para nuestra aplicación. Los típicos para el caso de la aplicación oculta en el área de notificación son, al menos, "Mostrar" y "Cerrar", de forma que al iconizar la aplicación siempre podamos volver a mostrarla. Para añadir estos elementos seleccionaremos el tipo "MenuItem" y pulsaremos "Agregar":
Cómo iconizar una aplicación C# en el área de notificación de Windows
En la propiedad "Name" de cada elemento de menú que añadamos estableceremos su valor adecuado para luego poder identificarlo. Por ejemplo para el menú "Mostrar aplicación" en la propiedad "Name" estableceremos "mnuMostrarAplicacion" y en la propiedad "Text" estableceremos el texto que se mostrará al usuario, por ejemplo "Abrir":
Cómo iconizar una aplicación C# en el área de notificación de Windows
De esta forma añadiremos todos los elementos del menú emergente que queramos que se muestren al pulsar con el botón derecho del ratón sobre el icono de nuestra aplicación:
Cómo iconizar una aplicación C# en el área de notificación de Windows
Ahora estableceremos el código C# para cada elemento de menú, para ello pulsaremos sobre el MenuStrip añadido mnuContextual, en la parte superior el asistente nos mostrará el menú contextual, haremos doble clic con el ratón sobre cada elemento del menú para añadir el código en su evento Click:
Cómo iconizar una aplicación C# en el área de notificación de Windows
Para el caso del elemento "Abrir" que será el que muestre la aplicación oculta en el área de notificación, añadiremos el siguiente código C#:
Cómo iconizar una aplicación C# en el área de notificación de Windows
        private void mnuMostrarAplicacion_Click(object sender, EventArgs e)
        {
            Show();
            WindowState = FormWindowState.Normal;
            Activate();
    iconizarApp.Visible = false;
        }

Básicamente el código C# anterior muestra la aplicación para que vuelva a aparecer en la barra de tareas, establece el valor WindowsState del formulario a "Normal", activa el formulario y oculta el icono del área de notificación.
De la misma forma añadiremos el código para el resto de elementos de menú, por ejemplo si hemos añadido la opción de cerrar la aplicación en el elemento de menú "Cerrar" el código podría ser:

        private void mnuCerrar_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }

Una vez creado el menú emergente continuaremos configurando el componente NotifyIcon, para ello pulsaremos sobre él (aparece en la parte inferior del diseñador) y estableceremos las siguientes propiedades:
  • Name: nombre identificativo del componente, por ejemplo iconizarApp.
  • ContextMenuStrip: seleccionaremos el menú contextual añadido anteriormente mnuContextual.
  • Icon: podremos añadir un icono que será el que se muestre en el área de notificación o bien podremos establecer por código C# en tiempo de ejecución el icono de nuestra aplicación (así lo haremos más adelante).
  • Visible: estableceremos esta propiedad a "False" pues no queremos que se muestre el icono una vez ejecutada la aplicación si no cuando el usuario pulse un botón "Minimizar" o bien cuando minimice la aplicación.
Todas las propiedades anteriores se pueden establecer por código y así lo haremos como ejemplo:
Cómo iconizar una aplicación C# en el área de notificación de Windows
Si queremos que al pulsar doble clic con el ratón sobre el icono de nuestra aplicación, en el área de notificación de Windows, se vuelva a mostrar (por ejemplo), deberemos acceder a los eventos del componente "NotifyIcon" seleccionándolo y pulsando en el icono "Eventos" de la ventana de "Propiedades":
Cómo iconizar una aplicación C# en el área de notificación de Windows
En el desplegable del evento DoubleClick seleccionaremos el evento Click del elemento del menú que queramos que se ejecute, en nuestro caso mnuMostrarAplicacion_Click:
Cómo iconizar una aplicación C# en el área de notificación de Windows
Nota: si queremos generar código C# independiente para el evento DoubleClick del NotifyIcon haremos doble clic sobre dicho evento y nos mostrará la ventana de código desde donde podremos generar el código fuente que queramos para este evento.
Una vez configurado el componente "NotifyIcon" añadiremos un botón "Minimizar" a nuestra aplicación (o cualquier otro componente como un menú o desde un evento). Cuando el usuario pulse sobre dicho botón la aplicación desaparecerá de la barra de tareas, también desaparecerá del escritorio y se mostrará un icono el el área de notificación. Para conseguir esto, en el evento "Click" del Button:
Cómo iconizar una aplicación C# en el área de notificación de Windows
Añadiremos el siguiente código:
Cómo iconizar una aplicación C# en el área de notificación de Windows
        private void btMinimizar_Click(object sender, EventArgs e)
        {
            iconizarApp.Icon = this.Icon;
            iconizarApp.ContextMenuStrip = this.mnuContextual;
            iconizarApp.Text = Application.ProductName;
            iconizarApp.Visible = true;
            this.Visible = false;
        }

El código C# anterior asigna el icono del formulario al NotifyIcon para que éste aparezca en el área de notificación, asigna en tiempo de ejecución el menú contextual "mnuContextual" al NotifyIcon (no hace falta hacer esto si lo hemos asignado en el componente gráfico en tiempo de diseño), asigna como texto del NotifyIcon el nombre de la aplicación (texto que se mostrará al pasar el ratón por encima del icono), muestra el icono en el área de notificación y oculta la aplicación del escritorio y de la barra de tareas.
Si además queremos que cuando el usuario minimice el formulario nuestra aplicación se oculte en el área de notificación, en el evento "Resize" del formulario:
Cómo iconizar una aplicación C# en el área de notificación de Windows
Añadiremos el siguiente código C#:
Cómo iconizar una aplicación C# en el área de notificación de Windows
        private void formTwitter_Resize(object sender, EventArgs e)
        {
            if (this.WindowState == FormWindowState.Minimized)
            {
                btMinimizar_Click(sender, e);
                iconizarApp.BalloonTipIcon = ToolTipIcon.Info;
                iconizarApp.BalloonTipTitle = Application.ProductName;
                iconizarApp.BalloonTipText = "La aplicación ha quedado ocultada " +
                    "en el área de notificación. Para mostrarla haga " +
                    "doble clic sobre el icono";
                iconizarApp.ShowBalloonTip(8);
            }   
        }
En el código anterior sería suficiente con "btMinimizar_Click(sender, e);" para llamar al procedimiento que oculta nuestra aplicación y muestra el icono en el área de notificación. Pero hemos aprovechado este ejemplo para indicar cómo mostrar un globo informativo en el área de notificación. Indicamos cada línea comentada:

                //Tipo de icono a mostrar el el globo informativo (Info, Error, None, Warning)
                iconizarApp.BalloonTipIcon = ToolTipIcon.Info;
                //Título del balón informativo (el nombre de la aplicación)
                iconizarApp.BalloonTipTitle = Application.ProductName;
                //Texto del balón informativo
                iconizarApp.BalloonTipText = "La aplicación ha quedado ocultada " +
                    "en el área de notificación. Para mostrarla haga " +
                    "doble clic sobre el icono";
                //Tiempo que aparecerá hasta ocultarse automáticamente
                iconizarApp.ShowBalloonTip(8);
Si además queremos realizar alguna acción cuando el usuario hace clic con el ratón sobre el globo informativo, añadiremos el código C# que queramos al evento BallonTipClicked del componente NotifyIcon (iconizarApp):
Cómo iconizar una aplicación C# en el área de notificación de Windows
Por ejemplo, si el usuario pulsa sobre el globo informativo la aplicación se mostrará, para ello añadiremos el siguiente código:
Cómo iconizar una aplicación C# en el área de notificación de Windows
        private void iconizarApp_BalloonTipClicked(object sender, EventArgs e)
        {
            mnuMostrarAplicacion_Click(sender, e);
        }
Ya podremos probar la aplicación, al pulsar el icono "Minimizar" aparecerá el icono de nuestra aplicación en el área de notificación y desaparecerá nuestra aplicación del escritorio y de la barra de tareas:
Cómo iconizar una aplicación C# en el área de notificación de Windows
Al pulsar con el botón derecho del ratón sobre el icono se mostrará el menú emergente:
Cómo iconizar una aplicación C# en el área de notificación de Windows
Y si minimizamos la aplicación:
Cómo iconizar una aplicación C# en el área de notificación de Windows
Nos mostrará el balón informativo y también se iconizará en el área de notificación:
Cómo iconizar una aplicación C# en el área de notificación de Windows

Fuente: http://www.ajpdsoft.com/
Si te ha parecido interesante podrías hacer click en +1, compartirlo en Facebook o Twitter, o dejar un comentario. ¡Gracias!.