Mostrando las entradas con la etiqueta .Net Framework. Mostrar todas las entradas
Mostrando las entradas con la etiqueta .Net Framework. Mostrar todas las entradas

viernes, 10 de junio de 2016

Construye una aplicación web desde cero con ASP.Net MVC

En el siguiente articulo se especifica todos los pasos necesarios para iniciarse e ir conociendo acerca de ASP.Net MVC, antes de iniciar con las fases de la construcción de la aplicación, te recomiendo leer el articulo Iniciando ASP.Net MVC encontrarás la información necesaria y resumida, además debe considerar otros puntos muy importantes antes de iniciarse, como por ejemplo las plantillas, motor de vista, pruebas unitarias y los directorio App_start ASP.Net MVC 

Requisitos para la implementación:
- Microsoft SQL Server Management Studio 2012.
- Microsoft Visual Studio Ultimate 2015 (Puede usar otras ediciones incluyendo la express).
- Framework 4  o 4.5 (Puede ser cualquiera de las 2, solo que la recomendación es iniciar y terminas con la que iniciaste).
- Dapper.Net (ORM para la  manipulación de datos desde la app, puedes agregarlo a tu proyecto desde nuget).
- Framework Bootstrap (para mejorar el diseño de nuestra aplicación)
- Y algo de Transact-SQL (para manipulación de datos desde base de datos).

Aquí dejo todos los pasos a seguir:
Crear Proyecto ASP.NET MVC - Fase I
Agregar modelo ASP.NET MVC - Fase II
Agregar controlador ASP.NET MVC - Fase III
Agregar vistas ASP.NET MVC - Fase IV
Bootstrap y ASP.NET MVC - Fase V
Pantalla de lo que se logrará al finalizar


Pueden descargar la fuente desde:
 Project - GitHub
Sugerencias y opiniones son bienvenidos o escríbanos a hadson1@gmail.com

Conozca acerca de WCF y Construya una Aplicación

En siguiente articulo quiero compartirles los conceptos necesarios para implementar servicios WCF (Windows Communication Foundation). Además, conoceremos acerca de como crear y cuales con los proyectos de tipo WCF, publicación en el IIS (Internet Information Server) y como consumir dicho servicio ya publicado.

Requisitos para la implementación:
- Microsoft SQL Server Management Studio 2008.
- Microsoft Visual Studio Ultimate 2010 o 2012.
- Framework 4 y MCV 4.
- Enterprise Library 5.
- AngularJS v1.2.24.
- Y algo de sentencia SQL (para manipulación de datos desde base de datos).

Aquí dejo todos los pasos a seguir:
Introducción a WCF - Fase I
Conexión a datos WCF - Fase II
Publicar Servicios WCF - Fase III
Consumir servicio WCF - Fase IV

Pantalla de lo que se logrará al finalizar



Sugerencias y opiniones son bienvenidos o escríbanos a hadson1@gmail.com

jueves, 31 de diciembre de 2015

Agregar modelo ASP.NET MVC - Fase II

Bueno, inicio esta siguiente fase esperando que sea útil para todos ustedes y a esperar el año 2016 que sea de muchas bendiciones y éxitos en todo lo que nos espera. Para los que están interesado el como iniciar en crear un proyecto les dejo en siguiente link Crear Proyecto ASP.NET MVC - Fase I 

Ahora implementaremos el modelo, controlador y vistas (en diferentes fases), digamos estas 3 palabras son las que encapsula toda implementación cuando se realiza bajo este padrón denominado MVC. Esta claro que a lo largo iremos viendo algunos concepto esenciales en toda nuestra implementación.

Para esto vamos a conceptualizar y detallar algunos puntos sobre el Modelo.

Modelos: Es el conjunto de clases (entidades o tablas que estén asociados con el modelo de datos) que representan el dominio de la aplicación. Actualmente se puede realizar diferentes tipos de implementación, incluso usando ORM de terceros con el Dapper.Net, entre otros. Algunas implemntaciones más usadas hasta ahora son:
  1. Entity Framework Database First: Consiste en crear un modelo de clases a partir de una base de datos existente usando el diseñador del Visual Studio.
  2. Entity Framework Model First: Consiste en crear un modelo de clases usando el diseñador que es provisto por el Visual Studio y a partir de este se crea la base de datos.
  3. Entity FrameworkCode First: Consiste en hacer uso de solamente código para crear el modelo de clases, sin depender de una herramienta de diseño, y a partir de este se crea la base de datos.
  4. Y también esta el Data Access Application Block del Enterprise Library que toma mucha fuerza en estos últimos tiempos, espero profundizar más adelante.
Hay mucha teoría por plasmar, si hay tiempo espero plasmar muchísima más teórica - en lo personal es lo primordial para todo aprendizaje. Con este poquísima teoría quiero iniciar la parte practica.

Ah, el modulo que decidí implementar será acerca del control de acceso a usuarios, es decir usare como modelo la base de datos que en su momento hice publico en el siguiente articulo Modulo de Control de Acceso - Primera Fase, todo sera basado en este modelo, sería genial que le den una leída. Otro de los detalles a considerar es que utilizare como acceso a datos el ORM Dapper (de paso voy aprendiendo a usar este orm que es light, más adelante haremos algo con Entity FrameworkData Access Application Block del Enterprise Library) y algo de T-SQL (implementare algunos procedimientos almacenados)

1.  Iniciamos el modelo de la base de datos que se hará uso por ahora sólo serán las 3 primera entidades (tablas) para el acceso del login.

2.  Creamos 2 procedimientos almacenados:
     2.1. Para la captura del id del usuario a logearse


USE [BD_SISTEMA]
GO
/****** Object:  StoredProcedure [dbo].[SP_GET_IDUSUARIO]    Script Date: 12/31/2015 18:07:46 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
ALTER PROCEDURE [dbo].[SP_GET_IDUSUARIO]
@PV_USUARIO VARCHAR(20)   
AS   
BEGIN
 SELECT ID_USUARIO
 FROM BD_SISTEMA.dbo.SEG_USUARIO
 WHERE USUARIO = @PV_USUARIO
END

     2.2. Para la captura de la descripción del rol a donde pertenece el id usuario.


USE [BD_SISTEMA]
GO
/****** Object:  StoredProcedure [dbo].[SP_GET_DES_ROL_IDUSUARIO]    Script Date: 12/31/2015 18:07:50 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
ALTER PROCEDURE [dbo].[SP_GET_DES_ROL_IDUSUARIO] 
@PN_ID_USUARIO NUMERIC(8)
AS 
BEGIN
 SELECT R.DES_ROL FROM BD_SISTEMA.dbo.SEG_USUARIO_ROL UR
    INNER JOIN BD_SISTEMA.dbo.SEG_ROL R
 ON R.ID_ROL = UR.ID_ROL
 WHERE UR.ID_USUARIO = @PN_ID_USUARIO
END

Con estos 2 pasos iniciales pasaremos a implementar nuestra app mvc:

3.  Creamos nuestro modelo de nombre login, clic en el directorio model, agregar clase,


Definamos el nombre, por ahora solo estoy haciendo referencia a la entidad SEG_USUARIO y los campos usuario y password (por ahora).

Consideración: Para el uso de las anotaciones deben importar los el espacio de nombre using System.ComponentModel.DataAnnotations, casi en su mayoría de las implementaciones son frecuentes las anotaciones.

4.  Antes de continuar con la implementaciones de las calses, vamos a configurar el archivo de configuración, es decir en archivo Web.config de la raíz principal de nuestro proyecto (no confundir con el archivo que se genera internamente en el directorio Views) agregamos nuestra cadena de configuración.
<connectionstrings>
    <add connectionstring="Data Source=.;Database=BD_SISTEMA;UID=sa;Password=xxx" name="ConnectionBD" providername="System.Data.SqlClient">
    </add>
</connectionstrings>

4.1. Así mismo se hará el siguiente cambio - en la línea de autentificación loginUrl (es solo para que sea algo distinto y poder familiarizarnos con los controladores y acciones).
<authentication mode="Forms">
    <!--<forms loginUrl="~/Account/Login" timeout="2880"/>-->
    <forms loginurl="~/Login/Login" timeout="20">
    </forms>
</authentication>

5.  Ahora con la entidad creada, se creará un nuevo directorio de nombre Repositorio (contendrá las clases de conexión a datos), y se implementara las clases de acceso a datos.
Dentro del directorio se implementa la clase Login y su interfaz

    5.1. Como les menciones al inicio, para esta caso utilizare Dapper para la manipulación de datos, para esto haré uso de NuGet.
Clic en el menú Herramientas, seleccionar Administrador de paquetes de biblioteca y clic en Administrar paquetes NuGet para la solución


Realizar la búsqueda y clic en Instalar

En nuestro caso solo contamos con un solo proyecto, pero si hubiera mas proyecto tendríamos que seleccionar el proyecto donde se desea instalar y clic en Aceptar

Si la instalación se realizo correcto indicará el aspa y clic en cerrar el administrador de NuGet.

    5.2. Ahora con todo la instalación del dapper iniciamos la implementación de nuestra clase Login.cs. Importamos las librerías necesarias como el using System.Configuration (para la referencia a nuestra cadena de conexión), using PRO_SEGURIDAD.Models (para la referencia a nuestro modelo login - creado en el punto 3) y por ultimo el using Dapper la que acabos de instalar y los métodos a crear son:

getIdUsuario: Invoca al procedimiento almacenado  SP_GET_IDUSUARIO, es decir es el encargado de captura el id del usuario.
getRolIdUsuario: Invoca al procedimiento almacenado SP_GET_DES_ROL_IDUSUARIO, es decir es el encargado de captura la descripción del rol al que pertenece el usuario.
public string getRolIdUsuario(string UserId)
{
 using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["ConnectionBD"].ToString()))
   {
         var dpara = new DynamicParameters();
         dpara.Add("@PN_ID_USUARIO", UserId);
   return con.Query("SP_GET_DES_ROL_IDUSUARIO", dpara, nulltrue, 0, CommandType.StoredProcedure).SingleOrDefault();
    }
}

public string getIdUsuario(string UserName)
{
 using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["ConnectionBD"].ToString()))
     {
          var dpara = new DynamicParameters();
          dpara.Add("@PV_USUARIO", UserName);
   return con.Query("SP_GET_IDUSUARIO", dpara, nulltrue, 0, CommandType.StoredProcedure).SingleOrDefault();
     }
}

5.3. Para concluir creamos la clase ILogin.cs. con los 2 métodos creados:


public interface ILoginData
{
    string getRolIdUsuario(string UserId);
    string getIdUsuario(string UserName);
}

Para concluir con esta fase, quiero dejar en claro que el modelo no solo es detallar una clase que contempla tu modelo entidad, es decir no solo es el valor del campo de la entidad a la cual se hace referencia; influye en tipo de implementación a acceso a datos que en realidad es el punto de partida para toda implementación sea MVC, Web Forms, Web Page o un Single Pages entro otros, en lo personal la mejor decisión es busca la herramienta o tecnología adecuada y plantear alternativas que mas se adecuan a la organización segun sus necesidades y visiones que tiene con la aplicación a implementar, así que no importar si uses un ORM o ADO.Net o que a uno le guste, es que en realidad lo que interesa es la correcta decisión a tomar en toda implementación.

Bueno, espero que les guste esta fase. Nos vemos en la siguiente fase.

Saludos.

sábado, 26 de diciembre de 2015

Crear Proyecto ASP.NET MVC - Fase I

Quizás llamarlo proyecto desde un inicio a esta fase inicial es algo interesante, que a lo largo  espero   profundizar en diferentes fases la implementación de un pequeño proyecto - módulo. Por ahora nos conformaremos en crear un proyecto básico en MVC que sera el inicio de nuestro modulo. Para este caso haré uso de Visual Studio 2015 ultimate, también es aplicable con la edición express, Framework 4 y puedes descargarlo desde la pagina oficial de Microsofto y MVC 4. Sin mayor detalles, manos a la obra.

Iniciamos creando nuestro proyecto:

Seleccionamos la aplicación de tipo ASP.NET MVC 4:

Determinamos nombre y ubicación del proyecto

Seleccionamos el tipo de plantilla básico. Para conocer los tipos y detalles de cada una de las plantilla puedes revisar en siguiente link Plantillas, motor de vista y pruebas unitarias ASP.NET MVC.

Esperamos que carga todos los archivo necesarios al crear el proyecto.

Esto son los archivos y carpetas que nos crear la plantilla básica.

Esto son los archivos y carpetas que nos crear la plantilla básica.

Detalles de los archivos y carpetas generadas

Ahora crearemos un controlador 


Definimos el nombre del controlador 

Controlador creado

Ahora agregamos una vista, clic derecho en la vista creada de nombre index y clic en agregar vista.

Para este caso se mantendrá el mismo nombre index y el motor de vista será razor (si deseas conocer acerca de este tema puede visitar el siguiente link Plantillas, motor de vista y pruebas unitarias ASP.NET MVC). Además, se asociara la vista maestra _Layout.cshtml

Asociar vista maestra

Index creado

Revisando el código generado se vera el titulo del index y la vista maestra en <h2></h2> se agregara al palabra Hola Index. Con estos pasos ejecutamos presionando F5.

Sorpresa, sorpresa... este es el punto interesante de MVC, digamos que aquí se vera la magia de las convenciones, es decir se debe definir el controlador index + la acción index. Por defecto nos trae el controlador Home.

Realicemos los cambios necesario, compilamos y presiones F5 para volver a ejecuta.

Como Resultado de nuestra primera fase tendremos este siguiente resultado.
Espero les sirva, nos vemos en el siguiente articulo donde implementaremos nuestro proyecto que acabamos de crear y explicar paso a paso; además en este apartado explicamos el paso a paso para agregar un controlador y su respectiva vista.

Plantillas, motor de vista y pruebas unitarias ASP.NET MVC

Después de haber conceptualizado algunos punto importantes de ASP.Net MVC, quiero darles a conocer algunas de las bondades que nos presenta al momento de crear un proyecto -  como son los tipos de plantillas, el motor de vista y proyecto de pruebas unitaria (más adelante realizaremos un tipo de proyecto especifico de este tipo). 

En ASP.NET MVC como framework de app's (aplicaciones) web, debemos conocer la herramienta que nos permite utilizar todo su potencial, en este caso el Visual Studio, como IDE bastante extenso que debemos enfocarnos primeramente en las funcionalidades que nos permitan empezar a desarrollar nuestras aplicaciones. Es decir las Plantillas MVC es una de las herramientas de gran importancia al iniciar todo proyecto MVC.

Al elegir una de estas plantillas nuestro proyecto heredará algunas estructuras y archivos que nos sirven de base. Para poder elegir una plantilla, primero debemos crear un nuevo proyecto (mas adelante detallaremos como crear proyectos MVC), por ahora debemos hacer referencia a la ventana de Nuevo proyecto de ASP.NETMVC:


Tal como vemos en la sección de seleccionar un plantilla contamos con 6 tipos de plantillas disponibles, vamos a describir cada una de ellos para tener un entendimiento del escenario de nuestros proyectos que desea crear y aprovechar todo lo necesario y útil cuando decidamos utilizar una u otra implementación.

Vacía o Empty: Esta plantilla nos crea solo la estructura básica para tener el esqueleto de nuestra aplicación, es utilizada más que todo cuando ya sabemos que queremos y no necesitamos de los componentes que nos pueda generar Visual Studio; a pesar de ser básica esta plantilla incluye algunas librerías Javascript que nos pueden ser útiles.

Básica o Basic: Similar al enfoque anterior nos crea solamente la estructura de carpetas necesaria para levantar una aplicación con ASP.NET MVC, al ser tan básica esta plantilla, requiere que creemos todo lo que vayamos a utilizar prácticamente desde cero. En lo personal me gusta usar esta plantillar porque puedo definir mi propia estructura del proyecto.

Aplicación de Internet o Internet Application: Inicia donde había quedado la plantilla vacía, contiene todo lo necesario visto en la mencionada plantilla vacía, sin embargo nos incluye un controlador inicial por defecto que nos lleva al home de la aplicación y adicionalmente nos crea un AccountController, es decir, un controlador para manejar todo lo concerniente a registro de usuarios y manejo de sesiones.

Aplicación de Intranet o Intranet Application: Funciona muy similar a la Aplicación de Internet, solamente que difiere en que está configurada para utilizar la autenticación basada en Windows, que es más deseable cuando trabajamos entornos de Intranet.

Aplicación Móvil o Mobile Application: Es otra variación de la aplicación de Internet que nos ofrece, sin embargo esta plantilla nos trae el framework de Javascript Jquery Mobile, que es enfocado a plataformas móviles como celulares y tablets, adicionalmente las vistas vienen optimizadas para ser mostradas en dispositivos móviles.

Web API: Como su nombre lo indica esta plantilla viene especializada para crear APIs RESTful, es decir podemos generar rápidamente servicios Web para alimentar otras aplicaciones que necesitemos comunicar con nuestra estructura.

Los Motores de vistaen MVC son los responsables del renderizar el HTML de las vistas. Por defecto el framework MVC incluye dos motores: ASPX (WebForms) y Razor, pero no quiere decir que son lo único  existen hay muchos más como Spark, NHaml o Bellevue (por mencionar algunos - espero revisarlo en su debido momento) que podemos mencionar a colección de view engines - Motores de vista de nuestro proyecto.

Se considera cuando devolvemos un objeto ViewResult en una acción de un controlador, por ejemplo a través del método View, el framework itera sobre los motores de vista registrados y por cada uno de ellos intenta localizar la plantilla que corresponde con el nombre solicitado. El primer view engine que lo encuentre será el motor que renderizará la vista, dejando de iterar sobre los restantes.

Así mismo, cada motor de vistas tiene su propia lógica para buscar las plantillas, normalmente lo hacen a través del sistema de archivos, es decir, por ubicación física. Los motores WebForms (.aspx, .ascx) y Razor (.cshtml, .vbhtml) implementados en las clases WebFormViewEngine y RazorViewEngine respectivamente, buscan las plantillas por ubicación. Quiere decir concretamente buscan el nombre de la plantilla con un determinado nombre de extensión en diferentes directorios.

Si ejecutamos una acción de un controlador haciendo referencia a una vista que no existe, recibiremos como respuesta el error que no se encuentra la vista o no hay un motor de búsqueda (en el siguiente apartado detallaremos más a fondo).

Los Proyecto de pruebas unitarias, quizás sea una de las ventajas de mucha importancia que brinda el uso de ASP.NET MVC. Es decir se puede implementar fácilmente pruebas unitarias en la aplicación web. Esto resulta especialmente cierto en comparación con el modelo de páginas de formularios Web Forms de ASP.NET, donde las pruebas unitarias son más complejas y tediosas, porque es difícil aislar una funcionalidad específica y porque las pruebas de las páginas de formularios Web Forms requieren la invocación del servidor web y la ejecución de la canalización de las páginas completas. ASP.NET MVC se ha diseñado para poder realizar pruebas sin dependencias del servidor IIS, de una base de datos o de clases externas, un gran punto a favor los que lo hacen (bueno, hasta ahora no lo uso mucho que digamos, solo como para ejemplos pequeños).

En fin, con esto pretendo familiarizar un poco con el tema de las herramientas que nos ofrece el IDE de VIsual Studio enfocado en ASP.Net MVC, espero lo aprovechen.

Saludos, nos vemos en el siguiente articulo.

viernes, 1 de mayo de 2015

Consumir servicio WCF - Fase IV

Siguiendo con los apartados de servicios WCF - ahora implementaremos una aplicación Asp.Net MVC para saber el cómo consumir un serivicio WCF.

Requisitos:
  • Visual Studio .Net 2010.
  • Framework 4.
  • Ajax, JQuery, JSON
  1. Iniciamos creando nuestro proyecto de tipo ASP.NET MVC 4 Web Application - desde la carpeta FrontEnd.



  2. Seleccionamos el template basic de MVC.

  3. Estructura de nuestro proyecto MCV - creado.

  4. Ahora creamos el controllers - con nombre Home.


    Determinamos el nombre
  5. Luego creamos el view - clic derecho en index de la clase del controller.


    En mi caso mantendré el mismo nombre que el controller

    Estructura de nuestro view creado
  6. Ahora iniciamos haciendo referencia al servicio que anteriormente se creo y publico - determinamos con nombre ServiceUbigeo.

  7. Ubicamos haciendo clic Discover - asignamos el nombre de ServiceUbigeo


    Servicio referenciado desde nuestro proyecto MCV
    1. Consideraciones: Al crear uno o varios servicios en nuestro archivo Web.config de manera automática se adicionara los endpoint que determinar la ruta para el compartimiento de información entre las parte involucradas en un servicio.
    
        
          
            
          
        
        
          
            
              
            
          
        
      
    
    
  8. Ahora adicionamos es nuestro modelo (ClassModelo.cs) los siguiente atributos.
    Favor de considerar los comentarios que están en el código fuente - color verte - partiendo desde este punto.

    public class UbiDepartamento //Cambiamos a UbiDepartamento (parecido a la entidad de la base de datos)
        {
            //Sólo adiciono los atributos que se manipulara
            public string CodDepartamento { get; set; }
            public string DesDepartamento { get; set; }
        }
    
  9. Ahora implementamos en nuestro controller el método que nos permitirá consumir el servicio a la cual hacemos referencia - el HttpPost y el JsonResult se entrará al detalle en otro apartado.
    [HttpPost]
            public JsonResult GetAllDepartamento()
            {
                try
                {
                    using (var client = new Service1Client())
                    {
                        List result = new List();//Invocamo a la entidad de nuestro modelo
                        var preResult = client.GetDepartamentoDataList();//Invocamos al método que es parte del servicio ubigeo
    
                        if (preResult != null && preResult.ToList().Count > 0)//validar la existencia de datos
                            foreach (var item in preResult) //recoremos los valores
                            {
                                result.Add(new UbiDepartamento //y vamos adicionando en nuestro modelo segun los atributos
                                {
                                    CodDepartamento = item.COD_DEPARTAMENTO.ToString(),
                                    DesDepartamento = item.DES_DEPARTAMENTO.ToString()
                                });
                            }
    
                        return Json(result, JsonRequestBehavior.AllowGet); //retornamos los valores recuperados
                    }
                }
                catch (Exception)
                {
                    throw;
                }
            }
    
  10. Para este caso solo implementaremos la carga de datos en un HTML input de tipo select que haremos uso de Ajax y JQuery con tipo de dato JSON.
    $(document).ready(function () {
    
        $.ajax({
            url: "Home/GetAllDepartamento",
            type: "POST",
            dataType: "json",
            data: "{}",
            success: function (data) {
    
                if (data == null) {
                    alert('Disculpe, No hay departamentos que mostrar.');
                    return
                } else {
                    for (var i = 0; i < data.length; i++) {
                        $("#SltDepartamento").append("");
                    }
                }
            },
            error: function (jqXHR, status, error) {
                alert('Disculpe, existió un problema');
            }
        });
    
    });
    
  11. Y para finalizar implementamos HTLM en el _Layout.cshtml  para poder mostrar los datos que nos devuelve el servicio.

    Resultado del servicio que estamos consumiendo
Proyecto C#

domingo, 19 de abril de 2015

Publicar Servicios WCF - Fase III

En el siguiente apartado demostraré a través de imágenes y breves explicaciones la publicación de un servicio (siguiendo las fases de servicios WCF) en el IIS – Internet Information Sever, SO – Sistema Operativo Windows Seven - Edition Ultimate (para cualquiera de las ediciones se realiza casi todos los pasos).

Requisitos:
  • Visual Studio .Net 2010.
  • IIS – Internet Information Sever.
  • Framework 4.
  • Independientemente hay que considerar las dll's del Enterprise Library.
  1. Iniciamos haciendo referencia a los tres proyectos para que se asocien al de PyWcfService.
  2. Ahora desde el Visual Studio .Net usamos la opción de publicar (genera todas la dll's y archivos necesarios para poder hacer la publicación en el IIS).

  3. Ahora Seleccionamos sistemas de archivos en la opción de método de publicación, ubicamos la ruta donde se copiaran los archivos, activamos la opción eliminar ... para poder eliminar todos los archivos cada que se realiza la opción publicar des de VS.Net y para finalizar clic en Publicar.
  4. Bueno, lo recomendable sería revisar los archivos generados después de hacer la publicación (lo que en realidad hace es solo copiar los archivos que serán publicados en IIS) desde VS.Net.
     Revisamos las dll's que se encuentran en la carpeta bin (El proyecto de servicios debe contener - referencia - todas los proyectos y dll's necesarias - por ejemplo - yo estoy usando Enterprise Library).
  5. Ahora en adelante se realizará la publicación en el IIS.
     Ingresamos a través del comando inetmgr o desde el panel de control
  6. Desde la opción Ayuda y Acerca de Internet Information Sever - revisamos la edición.
  7. Ahora creamos la aplicación a publicar.

    Ingresamos los datos, tal cual esta en la imagen donde el ALIAS es el nombre asignado de la apliación, SELECCIONAR el framework necesario en mi caso es el 4 y para finalizar ubicar la RUTA DE ACCESO FÍSICA (es la ruta del punto 3 - donde está la carpeta bin).
  8. Habilitamos la opción para poder ver el listado de directorios.
    Clic en habilitar y aplicar
  9. Para ir finalizando clic en la aplicación creada y clic en Examinar *.80 (http)
  10. Y si todo esta bien - podremos visualizar la lista de archivos que ahora se encuentran publicados.
  11. Y para testear el servicio clic Service1.svc
En el siguiente apartado veremos sobre el cómo consumir el servicio que acabamos de publicar.