Manejo de rutas en sitios web Dinámicos con ASP.NET

Hola, siguiendo con el anterior ejemplo, podemos cambiar la ruta de nuestras páginas web mediante acciones.

Veamos el global.asax completo, antes de iniciar con las modificaciones.

<%@ Application Language="C#" %>
<%@ Import Namespace="System.Web.Routing" %>
<%@ Import Namespace="System.Web.DynamicData" %>

<script RunAt="server">
    public static void RegisterRoutes(RouteCollection routes) {
        MetaModel model = new MetaModel();

        //                    IMPORTANT: DATA MODEL REGISTRATION 
        // Uncomment this line to register LINQ to SQL classes or an ADO.NET Entity Data
        // model for ASP.NET Dynamic Data. Set ScaffoldAllTables = true only if you are sure 
        // that you want all tables in the data model to support a scaffold (i.e. templates) 
        // view. To control scaffolding for individual tables, create a partial class for 
        // the table and apply the [Scaffold(true)] attribute to the partial class.
        // Note: Make sure that you change "YourDataContextType" to the name of the data context
        // class in your application.
        //model.RegisterContext(typeof(YourDataContextType), new ContextConfiguration() { ScaffoldAllTables = false });

        // The following statement supports separate-page mode, where the List, Detail, Insert, and 
        // Update tasks are performed by using separate pages. To enable this mode, uncomment the following 
        // route definition, and comment out the route definitions in the combined-page mode section that follows.
        routes.Add(new DynamicDataRoute("{table}/{action}.aspx") {
            Constraints = new RouteValueDictionary(new { action = "List|Details|Edit|Insert" }),
            Model = model
        });

        // The following statements support combined-page mode, where the List, Detail, Insert, and
        // Update tasks are performed by using the same page. To enable this mode, uncomment the
        // following routes and comment out the route definition in the separate-page mode section above.
        //routes.Add(new DynamicDataRoute("{table}/ListDetails.aspx") {
        //    Action = PageAction.List,
        //    ViewName = "ListDetails",
        //    Model = model
        //});

        //routes.Add(new DynamicDataRoute("{table}/ListDetails.aspx") {
        //    Action = PageAction.Details,
        //    ViewName = "ListDetails",
        //    Model = model
        //});
    }

    void Application_Start(object sender, EventArgs e) {
        RegisterRoutes(RouteTable.Routes);
    }

</script>

Como lo hemos hecho al principio hemos colocado nuestro contexto de datos.

model.RegisterContext(typeof(myDataContextDataContext),
          new ContextConfiguration() { ScaffoldAllTables = true });

Si checamos bien tenemos dentro de la carpeta de DynamicData, tenemos las plantillas, como puedes ver en la imagen.

 

Estas plantillas, nos van a servir y las vamos a tomar como acciones, dentro de nuestra base de datos dependiendo de la tabla que eligamos al principio.

 

Por ejemplo vamos a quitar el comentario de la parte de Routes (rutas), y en esta parte estamos indicando de que cuando presionemos que queramos ver la lista (List) de elementos según la tabla, nos redireccione a la plantilla ListDetails, o cualquiera que nosotros personalizemos.

routes.Add(new DynamicDataRoute("{table}/ListDetails.aspx") {
         Action = PageAction.List,
         ViewName = "ListDetails",
        Model = model
     });

Y si quitamos los siguientes comentarios, tendremos

Este código indica que si queremos ver los detalles de los elementos de la tabla escogida, entonces nos redireccione igual a la plantilla ListDetails.

routes.Add(new DynamicDataRoute("{table}/ListDetails.aspx")
           {
           Action = PageAction.Details,
           ViewName = "ListDetails",
           Model = model
       });

Código completo:

<%@ Application Language="C#" %>
<%@ Import Namespace="System.Web.Routing" %>
<%@ Import Namespace="System.Web.DynamicData" %>

<script RunAt="server">
    public static void RegisterRoutes(RouteCollection routes) {
        MetaModel model = new MetaModel();

        model.RegisterContext(typeof(myDataContextDataContext),
            new ContextConfiguration() { ScaffoldAllTables = true });

            routes.Add(new DynamicDataRoute("{table}/ListDetails.aspx") {
            Action = PageAction.List,
            ViewName = "ListDetails",
           Model = model
        });

            routes.Add(new DynamicDataRoute("{table}/ListDetails.aspx")
            {
            Action = PageAction.Details,
            ViewName = "ListDetails",
            Model = model
        });
    }

    void Application_Start(object sender, EventArgs e) {
        RegisterRoutes(RouteTable.Routes);
    }

</script>

Vemos en pantalla:

La gran ventaja de esto, es que el ejemplo anterior ocupabamos una página o plantilla para editar, para lista, para agregar elementos y en esta plantilla ListDetails, podemos hacerlo todo junto y la ruta  no va a cambiar.

Saludos.

Dynamic Data Web Site

Este ejemplo es muy sencillo, pero realmente útil.

1.- Creamos una página web utilizando la plantilla de Dynamic Data Web Site.

2.- Agregamos un archivo de base de datos SQL Server.

3.-Creamos nuestras tablas.

4.- Agregamos un archivo de tipo LINQ To SQL Classes

Agregamos nuestra tabla o tablas al diseñador.

5.- Nos vamos a Global.asax

6.- En este archivo, vamos a quitar el comentario y colocar nuestro contexto de datos, de acuerdo a como hemos llamado anteriormente.

model.RegisterContext(typeof(myDataContextDataContext),
 new ContextConfiguration() { ScaffoldAllTables = true});

Código completo:

<%@ Application Language="C#" %>
<%@ Import Namespace="System.Web.Routing" %>
<%@ Import Namespace="System.Web.DynamicData" %>

<script RunAt="server">
    public static void RegisterRoutes(RouteCollection routes) {
        MetaModel model = new MetaModel();

        model.RegisterContext(typeof(myDataContextDataContext),
            new ContextConfiguration() { ScaffoldAllTables = true });
        routes.Add(new DynamicDataRoute("{table}/{action}.aspx") {
            Constraints = new RouteValueDictionary(new { action = "List|Details|Edit|Insert" }),
            Model = model
        });
    }

    void Application_Start(object sender, EventArgs e) {
        RegisterRoutes(RouteTable.Routes);
    }

</script>

Vemos ejecutando la aplicación….

 

Vamos a agregar un elemento.

 

 

 

Saludos…

 

LINQ To SQL Classes Sample

Hola, he preparado un pequeño ejemplo muy sencillo, tal vez para aquellos que aún estén aprendiendo LINQ y SQL Server, este ejemplo se basa en como manejar datos con LINQ conectándose a un servidor de base de datos como SQLEXPRESS y a una base de datos de control de Alumnos, si quieren crear la tabla desde cero, aquí les dejo el script:

USE bdTecMina
GO
CREATE TABLE Alumnos
(
    AlumnoID nvarchar(10),
    Nombre     nvarchar(40),
    Semestre nvarchar(3),
    CONSTRAINT "PK_Alumnos" PRIMARY KEY CLUSTERED(AlumnoID),
)

INSERT INTO Alumnos VALUES('05231104','Edison García','7')
INSERT INTO Alumnos VALUES('05231106','Abraham Gomez García','9')
INSERT INTO Alumnos VALUES('05231108','Alejandre Carvajal','7')
INSERT INTO Alumnos VALUES('06231110','Luis Armando','10')

Ahora necesitaremos crear un Procedimiento Almacenado llamado InsertarAlumno:

SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO

CREATE PROCEDURE dbo.InsertarAlumno
(
    @AlumnoID nchar(5),
    @Nombre      nvarchar(40),
    @Semestre nchar(3)
)
AS
    INSERT INTO Alumnos
    (
        AlumnoID,
        Nombre,
        Semestre
    )
    VALUES
    (
        @AlumnoID,
        @Nombre,
        @Semestre
    )
GO

Creamos nuestro proyecto Windows Forms, y añadimos un nuevo elemento en el explorador de soluciones (Solution Explorer), y escogemos LINQ TO SQL Classes, pueden colocar cualquier nombre a su datacontext. (dml) a continuación se conectan al servidor de base de datos que tengan instalado, si tienen SQLEXPRESS se conectan y escogen la base de datos bdTecMina o la que hayan creado, y arrastran la Tabla Alumnos al diseñador.

A continuación buscan el Procedimiento Almacenado (Store Procedure) y lo colocan en el espacio que se marca en la figura de abajo.

[Dar clic para agrandar las imágenes]

Seleccionamos a continuación la tabla Alumnos y en sus propiedades seleccionamos Insert.

Seleccionamos el Procedimiento Almacenado que habíamos agregado al diseñador.

Nos vamos a diseñar nuestro formulario, muy simple pero es para hacer las pruebas.

Declaramos nuestro dataContext:

        bdSistemaDataContext db = new bdSistemaDataContext();

Agregamos el siguiente código para el botón de Agregar:

 private void button1_Click(object sender, EventArgs e)
        {

            string AlumnoID = txtID.Text;
            string Nombre = txtNombre.Text;
            string Semestre = txtSemestre.Text;
            try
            {
                db.InsertarAlumno(AlumnoID, Nombre, Semestre);
                db.SubmitChanges();
                MessageBox.Show("Se ha agregado correctamente");

            }
            catch (Exception ex)
            {
                MessageBox.Show("Ha ocurrido un error");
            }
            finally
            {
                txtID.Text = "";
                txtNombre.Text = "";
                txtSemestre.Text = "";  

            }
        }

En donde solo paso los valores de los textBoxs a variables string y de ahi al método del procedimiento almacenado, guardo los cambios y limpio los cuadros de textos.

Después visualizando en el DataGridView el código queda así:

private void button2_Click(object sender, EventArgs e)
        {
            var consulta = from alu in db.Alumnos
                           select alu;
            dataGridView1.Refresh();
            dataGridView1.DataSource = consulta.ToList();
        }

Hago una pequeña consulta en LINQ mostrando todos los elementos de la tabla Alumnos en el dataGridView.

Damos F5 y tenemos lo siguiente:

Descarga el código de este ejemplo

Saludos, espero este pequeño ejemplo sea de mucha utilidad, nos vemos en otro post con los siguientes métodos.

PD:Si te ha gustado este post, vota por mi blog (mredison.wordpress.com) en http://blogit.ms en la categoría de SQL Server, te lo agradeceré mucho.

Edison Daniel García Chiñas
Microsoft Student Partner | México

Como conectarme a una base de datos con LINQ

Hola, que tal, aqui respondiendo algunas preguntas, de como conectar una base de datos utilizando LINQ, muy facil. Les coloco el siguiente código:

1.- Primero que nada, tienen que importar el NameSpace

using System.Data.Linq;

2.- Creo un dbml

3.- Coloco las tablas que ocuparé.

4.- El dataContext es que el objeto que hara la conexión a la base de datos y me generará las clases dependiendo de las tablas que tenga en mi base de datos, a este proceso se le conoce como LINQ To SQL Classes.

Hago referencia a mi Tabla

miContextoDataContext db = new miContextoDataContext();
Table<Alumno> Alumnos = db.GetTable<Alumno>();

Coloco mi cadena de Conexion dentro del dataContexto y despues genero una tabla de la clase Alumno que así es como se llama mi Tabla dentro de la base de datos.

4.- Por último hago las consultas que yo quiero.

var consulta = from alu in Alumnos
                           select alu;

5.- Coloco la consulta para mostrarlo en un dataGridView

dataGridView1.DataSource = consulta.ToList();

Código Completo:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data.SqlClient;
using System.Data.Linq;

namespace ADONETconLINQ
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {

            miContextoDataContext db = new miContextoDataContext();
            Table<Alumno> Alumnos = db.GetTable<Alumno>();

            var consulta = from alu in Alumnos
                           select alu;
            dataGridView1.DataSource = consulta.ToList();

        }
    }
}

Saludos espero te sirva, nos vemos.

Como obtener una lista de directorios con C# y LINQ

Hola me pidieron hacer esta demo en C#, les coloco el código.

Ejemplo en Visual Basic. NET:

http://mredison.wordpress.com/2007/12/22/como-obtener-una-lista-de-directorios-con-linq/

Código en C#:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;

namespace Demo1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
        DirectoryInfo directorioInfo=new DirectoryInfo("c:\\");
        DirectoryInfo[] ArrayDeDirectorios = directorioInfo.GetDirectories();
        var miDirectorios = from dir in ArrayDeDirectorios
                            select dir;
        dataGridView1.DataSource = miDirectorios.ToList();

        }
    }
}

Saludos.

 

Tutorial de Silverlight 2 con WCF

Hola, les comparto un tutorial en donde utilizo las siguientes tecnologías:

• ASP.NET 3.5
• Silverlight 2 Beta 1
• Expression Blend 2.5
• WCF
• LINQ
• Expression Web

Antes que nada tenemos que tener instalado el Visual Studio 2008 y las extensiones de Silverlight 2 Beta 1, y expression Blend 2.5, eso lo pueden encontrar aquí

a) Iniciamos en Visual Studio 2008, Creamos un nuevo proyecto de tipo Silverlight:

b) Después nos aparece una ventana en donde escogemos la opción de tipo proyecto:

c) Nos crea el proyecto, escogemos el Page.xaml y le damos clic derecho abrir con Expression Blend :

d) Cambiamos el fondo en Expression Blend

e) Agregaremos un Rectangulo y lo agruparemos dentro de un StackPanel y le daremos un Color de Fondo:

F) Agregamos un control desde el Asset Library, el cual se llama WatermarkedTextBox,

g) Agregamos un boton, quedando de esta forma:

Guardemos y volvemos a Visual Studio 2008, le damos que Si a Todo.

Agregamos un nuevo elemento al proyecto Web que tenemos,en este caso será un dataContext que es propio del nuevo control de acceso a datos LINQ, escogemos LINQ to SQL Clases y colocamos el nombre de ” datos.dbml “.

Al dar agregar nos crea el diseñador visual, y le damos clic en Server Explorer, nos abre el explorador de servidores y damos en nueva conexión,

Selecciono la base de datos Northwind que si no la tienen pueden descargarla de aquí

Depues, selecciono las tablas de Categorias y Productos, las arrastro al diseñador visual de LINQ.

Quedando de esta forma, con sus relaciones:

Escogemos que el dataContext tenga en el modo de Serialización que sea Unidireccional.

Agregamos un nuevo elemento al proyecto, en este caso será un servicio de WCF.

En este caso, coloco una lista de la clase Productos, que en este caso me refiero a la tabla, y pido como parametro una variable de tipo string, en donde indicará la categoría del Producto:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;

namespace TutorialSilverlight2_Web
{
    [ServiceContract]
    public interface ImiServicio
    {
        [OperationContract]
        List<Product> ObtenerProductos(string NombreCategoria);
    }
}

 

Depues este buscamos el archivo de codigo del web service:

Borramos el metodo DoWork, que nos quede de tal forma así:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;

namespace TutorialSilverlight2_Web
{
    public class miServicio : ImiServicio
    {
    }
}

Ahora vamos a implementar nuestro servicio cual haya sido el nombre que ustedes le pusieron, dando clic en la I, de la interfaz:

#region ImiServicio Members

      public List<Product> ObtenerProductos(string NombreCategoria)
      {
      }

#endregion

Ahora, crearemos una variable de tipo DataContext.

var miDataContext = new datosDataContext();

Codificamos nuestra consulta de LINQ, que consiste en traernos a todos los productos del dataContext segun la categoría que le metamos como parámetro.

var miConsulta = from p in miDataContext.Products
                            where p.Category.CategoryName.Contains(NombreCategoria)
                            select p;

Retornaremos la consulta en forma de Lista de esta forma:

return miConsulta.ToList();

Quedando finalmente así:

public List<Product> ObtenerProductos(string NombreCategoria)
       {
           var miDataContext = new datosDataContext();
           var miConsulta = from p in miDataContext.Products
                            where p.Category.CategoryName.Contains(NombreCategoria)
                            select p;

           return miConsulta.ToList();
       }

Nos vamos al webconfig y le cambiamos al atributo binding del tag services, de wsHttpBinding a basicHttpBinding:

 

Esto con el fin de activar solo el modo básico al llamar a mi webservice desde la aplicación que lo solicitará.

Nos vamos ahora al proyecto y agregamos referencias Web, del servicio que acabamos de hacer:

 

 

Ahora agregaremos una referencia, que será la de System.Windows.Controls.Data, ya que colocaré un datagrid dentro de la aplicación Silverlight:

Ahora agregaremos ese referencia en el código XAML:

Después localizamos el control watermarkedTexBox y le colocamos un nombre:

<WatermarkedTextBox x:Name=”txtCategoria”  …../>

Nos vamos a Expression Blend 2.5 y agregamos un nuevo control que será un datagrid:

Nos vamos a Visual studio 2008 y en el tag del datagrid vamos a añadir los siguientes atributos:

x:Name=”Mostrar” AutoGenerateColumns=”True”

Después añadimos el evento click al boton:

Nos vamos al evento clic del botón:

private void Button_Click(object sender, RoutedEventArgs e)
        {

        }

  Agrego a los namespaces la referencia:

using TutorialSilverlight2.ServiceReference1;

Dentro del evento clic copiamos esto:

var proxy=new ServiceReference1.ImiServicioClient();
            proxy.ObtenerProductosAsync(txtCategoria.Text);

 Despues vamos a crear el siguiente metodo:

Quedando de esta forma:

private void Button_Click(object sender, RoutedEventArgs e)
      {
          var proxy=new ServiceReference1.ImiServicioClient();
          proxy.ObtenerProductosCompleted += new EventHandler<ObtenerProductosCompletedEventArgs>(proxy_ObtenerProductosCompleted);
          proxy.ObtenerProductosAsync(txtCategoria);

      }

      void proxy_ObtenerProductosCompleted(object sender, ObtenerProductosCompletedEventArgs e)
      {
      }

Ahora dentro del metodo que creamos colocaremos:

void proxy_ObtenerProductosCompleted(object sender, ObtenerProductosCompletedEventArgs e)
        {
            Mostrar.ItemsSource = e.Result;
        }

  Y damos visualizar o F5

Saludos… Si quieren el proyecto completo, me dicen, para colocar la liga de descarga… Nos vemos en el proximo tutorial.

Operadores de consulta estándar con LINQ

Language Integrated Query (LINQ) permite a los desarrolladores escribir consultas similares a SQL con el código de Microsoft® .NET Framework 3.5 usando una sintaxis con establecimiento inflexible de tipos. Distintos proveedores de LINQ, como LINQ to Objects (que le permite escribir las consultas con jerarquías de objetos) y LINQ to Entities (que le permiten escribir consultas con el modelo conceptual de Entity Framework), podrán procesar estas consultas de manera eficaz en función de las particularidades de sus almacenes de datos representativos.

Hablemos de LINQ (2)

Cómo trabaja LINQ?

Ya después de haber aprendido los conceptos básicos sobre LINQ en el post anterior, vamos a checar como trabaja, cuando escribimos el siguiente código:

Customer[] Customers = GetCustomers();
vary query  = from c in Customers
                    where c.Country ==”Italy”
                    select c;

El compilador nos genera el siguiente código:

Customer[] Customers = GetCustomers();
IEnumerable <Customer> query =
                        Customers
                        .Where (c=> c.Country === “Italy”);

Cuando la consulta es larga como:

vary query  = from c in Customers
    where c.Country ==”Italy”
    orderby c.Name
    select new { c.Name, c.City };

El código generado es también largo:

var query= Customers
    .Where (c => c.Country == “Italy”);
    .OrderBy (c => c.Name)
    .Select (c => new { c.Name, c.City});

Como podemos ver, el codigo llama a miembros instanciados en un objeto retornado desde la llamada anterior. Podemos checar que la implementación de los métodos del Where, OrderBy y Select llamados desde una consulta, dependen del tipo de Customers y sobre el namespaces especificos usado en las expresiones anteriores.

Existen métodos que nos ayudan a poder ver el resultado de una consulta por ejemplo:

var query = from c in Customers ….
foreach ( string name in query)….

Y también métodos que producen una copia de la información en memoria por ejemplo el método Tolist produce una colección tipada List<T>.

var query = from c in Customers …
List <Customer> customers = query.ToList();

Cuando las consultas de  LINQ trabajan sobre la información que esta en una base de datos relacional (podemos decir un Microsoft SQL Server), estas consultas LINQ generan una sentencia SQL equialente en lugar de trabajar en copias (memoria) de tablas de datos.