Tecnologías Microsoft

Web Development
Editor WYSIWYG para ASP.NET

Que tal muchos de nosotros nos dedicamos al desarrollo web y a veces los clientes nos piden que actualizemos los contenidos del sitio web, para esto es sumamente recomendable que utilizemos algún editor WYSIWYG (What You See Is What You Get).

En ASP.NET podemos integrar el editor FCKeditor el cual desde su página podemos descargar el control de servidor y registrarlo dentro de nuestra página ASP.NET.

URL: http://ckeditor.com/download

1.- Descomprimir el archivo de .NET, navegamos dentro de la carpeta Bin 2.0 encontraremos la .dll llamada FredCK.FCKeditorV2.dll , en donde la agregaremos como referencia dentro de nuestro proyecto.

fckeditorASPNET_02

2.- Descargamos también los archivos completos del FCKeditor y los descomprimimos dentro de nuestra carpeta del sitio web. (Es recomendable que nuestro sitio web esté hospedado dentro de un servidor IIS).

3.- Ahora nos toca registrar el control de servidor para que podamos utilizarlo dentro de nuestas página web con la directiva @Register colocando el Assembly, NameSpace y nuestro TagPrefix personalizado, de la siguiente forma:

<%@ Page Language="C#" AutoEventWireup="true"  
CodeFile="Default.aspx.cs" Inherits="_Default" %>

<%@ Register Assembly="FredCK.FCKeditorV2" 
Namespace="FredCK.FCKeditorV2" TagPrefix="Editor" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server">   
    <Editor:FCKeditor ID="Editor" runat="server"></Editor:FCKeditor>
    </form>
</body>
</html>

fckeditorASPNET_01

En esta ocasión mostraremos como manipular archivos .txt para leer y escribir desde el FCKeditor.

4.- Agregamos una clase llamada Archivo.cs: Necesitamos agregar el espacio de nombres System.IO

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace iEduSoft
{
   public class Archivo
    {
       public static string LeerTXT(string rutaArchivo)
       {
           string contenido="";
           using(StreamReader lector = File.OpenText(rutaArchivo))
           {
               contenido = lector.ReadToEnd();
               contenido = contenido.Replace(Environment.NewLine, "<br>");
           }
           return contenido;
       }

       public static void EscribirTXT(string rutaArchivo,string contenido)
       {
           using (StreamWriter escritor = File.CreateText(rutaArchivo))
           {
               escritor.Write(contenido);
           }
       }
    }
}

En esta clase tenemos dos métodos uno para leer archivos .txt y el otro para sobreescribir o escribir texto en ellos.

5.- Agregamos un botón de Actualizar.

fckeditorASPNET_03

6.- Dentro del evento Page Load podemos agregar nuestro método de lectura de archivo y dentro del evento click del botón el de escritura.

public partial class _Default : System.Web.UI.Page 
{
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!Page.IsPostBack)
        {
            Editor.Value = Archivo.LeerTXT(Server.MapPath("Documentos/Post1.txt"));
        }
    }
    protected void btnActualizar_Click(object sender, EventArgs e)
    {
       Archivo.EscribirTXT(Server.MapPath("Documentos/Post1.txt"), Editor.Value);
    }
  
}

7.- Corremos la aplicación, y listo tenemos un editor online para nuestros sitios web ASP.NET.

Si lo vinculamos a alguna base de datos es mucho más fácil.

fckeditorASPNET_04

Saludos.

Edison Daniel García Chiñas

Posted: 28/7/2010 2:35 por Edison Daniel García | con no comments
Archivado en: ,
Como obtener las bases de datos de una instancia SQL Server en ASP.NET

En la clase Connection existe una implementación del método GetSchema() que nos permite obtener información acerca de la base de datos en el que estamos actualmente conectados y si nosotros mandamos a llamar ese método nos regresará un DataTable con la información solicitada.

Dentro de los parametros que le podamos pasar a este método, se encuentra  “Databases” para obtener las bases de datos que están dentro de la instancia actual. Veamos el ejemplo:

Código C#:

 public static DataTable GetDataBases()
    {
         SqlConnection connection = new SqlConnection(ConnectionString);
         DataTable dtDataBases = new DataTable();
        try
        {
            connection.Open();
            dtDataBases = connection.GetSchema("Databases");
        }
        catch (SqlException ex)
        {
            throw ex;
            
        }
        finally
        {
            connection.Close();
        }
        return dtDataBases;
    }

Diseño: DropdownList

GetDatabases-SQLSERVER-01

Código ASP.NET

        ddDataBases.DataSource = GetDataBases();
        ddDataBases.DataTextField = "database_name";
        ddDataBases.DataValueField = "database_name";
        ddDataBases.DataBind();

Preview:

GetDatabases-SQLSERVER-02

Edison Daniel García Chiñas

Microsoft Student Partner | Microsoft México

Posted: 24/6/2010 14:16 por Edison Daniel García | con no comments
Archivado en:
Manejar archivos CSV y cargarlos a un GridView en ASP.NET

En este post se mostró como manipular los datos desde un archivo csv y guardarlo en tablas en SQL Server 2005:

http://geeks.ms/blogs/mredison/archive/2009/04/08/tip-manejo-de-archivos-csv-con-sql-server.aspx

Pero este post simplemente se basa en cargar un archivo a un directorio dentro del proyecto web, leer dicho archivo y mostrar los datos en una regilla de datos (GridView) sin hacer uso del servidor de base de datos.

El formulario que se ocupará tendrá estos controles web:

  • Un control FileUpload.
  • Dos botones de comando.
  • Dos labels
  • Un gridView

CsvFilesUpload_01

HTML:

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server" method="post">
    <div>
    
        <asp:FileUpload ID="FileUpload1" runat="server" />
        <asp:Button ID="Button1" runat="server" onclick="Button1_Click" Text="Subir" />
    
        <asp:Button ID="Button2" runat="server" Text="Cargar Datos-Tabla" 
            onclick="Button2_Click" />
    
    </div>
    <asp:Label ID="lblOculto" runat="server" Text="" Visible="false"></asp:Label>
    <br />
    <asp:Label ID="Label1" runat="server" Text=""></asp:Label>
    <asp:GridView ID="GridView1" runat="server" Height="251px" Width="420px">
    </asp:GridView>
    </form>
</body>
</html>

 

Código:

En Default.aspx.cs crearemos estos métodos.

 private DataTable CrearTabla(String fila)
    {
        int cantidadColumnas;
        DataTable tabla = new DataTable("Datos");
        String[] valores = fila.Split(new char[] { ',' });
        cantidadColumnas = valores.Length;
        int idx = 0;
        foreach (String val in valores)
        {
            String nombreColumna = String.Format("{0}", idx++);
            tabla.Columns.Add(nombreColumna, Type.GetType("System.String"));
        }
        return tabla;
    }

 

En este primer método se creará la tabla de acuerdo a la cantidad de columnas que se obtengan y que se hayan guardado en un arreglo de tipo string.

Posteriormente crearemos el método AgregarFila:

private DataRow AgregarFila(String fila, DataTable tabla)
    {
        int cantidadColumnas = 100;
        String[] valores = fila.Split(new char[] { ',' });
        Int32 numeroTotalValores = valores.Length;
        if (numeroTotalValores > cantidadColumnas)
        {
            Int32 diferencia = numeroTotalValores - cantidadColumnas;
            for (Int32 i = 0; i < diferencia; i++)
            {

                String nombreColumna = String.Format("{0}", (cantidadColumnas + i));
                tabla.Columns.Add(nombreColumna, Type.GetType("System.String"));
            }
            cantidadColumnas = numeroTotalValores;
        }
        int idx = 0;
        DataRow dfila = tabla.NewRow();
        foreach (String val in valores)
        {
            String nombreColumna = String.Format("{0}", idx++);
            dfila[nombreColumna] = val.Trim();
        }
        tabla.Rows.Add(dfila);
        return dfila;
    }

Método CargarDatos:

Teniendo listos los primeros dos métodos de crearTabla y agregarFilas a la tabla, procedemos a cargar los datos mediante una ruta como parametro:

 private void CargarDatos(string strm)
    {
        DataTable tabla = null;
        StreamReader lector = new StreamReader(strm);
        String fila = String.Empty;
        Int32 cantidad = 0;
        do
        {
            fila = lector.ReadLine();
            if (fila == null)
            {
                break;
            }
            if (0 == cantidad++)
            {
                tabla = this.CrearTabla(fila);
            }
            this.AgregarFila(fila, tabla);
        } while (true);

        GridView1.DataSource = tabla;
        GridView1.DataBind();
    }

Este método checa si existen datos en el archivo,  crea la tabla y agrega las filas a dicha tabla, además de mostrarlos en el GridView.

Carga de Archivos con FileUpload:

Haremos un método de tipo bool, que determinará que tipo de archivo solo quiero que suba el usuario.

 bool ChecarExtension(string fileName)
    {
        string ext = Path.GetExtension(fileName);
        switch (ext.ToLower())
        {
            case ".csv":
                return true;
            default:
                return false;
        }
    }

Posteriormente en el botón de Subir, agregaremos el siguiente código:

public void Button1_Click(object sender, EventArgs e)
    {
        
        
        if (FileUpload1.HasFile)
        {
            if (ChecarExtension(FileUpload1.FileName))
            {
                FileUpload1.SaveAs( MapPath("Archivos/" + FileUpload1.FileName));
                

                 Label1.Text =FileUpload1.FileName +" cargado exitosamente";

                 lblOculto.Text = MapPath("Archivos/" + FileUpload1.FileName);
            }
        }
        else
        {
            Label1.Text = "Error al subir el archivo o no es el tipo .CSV"; 
        }

    }

 

En esta parte indicamos en que directorio se colocará dicho archivo y obtenemos la ruta que posteriormente pasaremos como parametro al método CargarDatos(); a continuación:

 

CsvFilesUpload_02

protected void Button2_Click(object sender, EventArgs e)
    {
        try
        {

            CargarDatos(lblOculto.Text);
        }
        catch
        {
            Response.Write("Ocurrió un error debe cargar antes el archivo");
        }
    }

CsvFilesUpload_03

 

Descarga el archivo de código: CSV.zip-download

Posted: 8/4/2009 10:40 por Edison Daniel García | con 1 comment(s)
Archivado en: ,
Entrenamiento de apoyo para el examen de certificación 70-536 TS: Microsoft .NET Framework Application Development Foundation

MVP Miguel Muñoz, director de la comunidad de desarrolladores de Puebla en México, nos comparte un entrenamiento completo de apoyo para el 70-536. Aprovéchenlo. Saludos.

Para desarrolladores avanzados
Introducción al desarrollo de aplicaciones Microsoft .NET utilizando Visual Studio 2008 (Para principiantes.)
Posted: 8/4/2009 10:34 por Edison Daniel García | con 5 comment(s)
Archivado en:
Tip: Manejo de Archivos CSV con SQL Server

Wikipedia:

Los ficheros CSV (del inglés comma-separated values) son un tipo de documento sencillo para representar datos en forma de tabla, en las que las columnas se separan por comas (o punto y coma en donde la coma es el separador decimal: España, Francia, Italia...) y las filas por saltos de línea. Los campos que contengan una coma, un salto de línea o una comilla doble deben ser encerrados entre comillas dobles.

El formato CSV es muy sencillo y no indica un juego de caracteres concreto, ni cómo van situados los bytes, ni el formato para el salto de línea. Estos puntos deben indicarse muchas veces al abrir el fichero, por ejemplo, con una hoja de cálculo.

Fuente: http://es.wikipedia.org/wiki/CSV

¿Cómo sacar provecho de este tipo de archivos en SQL Server?

CREATE DATABASE ESCUELA
USE  ESCUELA

CREATE TABLE ALUMNOS(
    NOCONTROL INT NOT NULL,
    NOMBRE VARCHAR(50) NOT NULL,
    SEMESTRE INT
)
ALTER TABLE ALUMNOS ADD CONSTRAINT PK_ALUMNOS PRIMARY KEY(NOCONTROL)

Tenemos este ejemplo muy sencillo de una tabla Alumnos.
 
Ahora vamos a utilizar un archivo CSV, pueden crearlo desde notepad o Microsoft Excel y guardarlo como .csv, en este caso puede utilizar comas para separar entre campos.
 
ARCHIVOSCVS

BULK INSERT ALUMNOS 
    FROM 'c:\Alumnos.csv' 
    WITH 
    ( 
        FIRSTROW = 1, 
        MAXERRORS = 0, 
        FIELDTERMINATOR = ',', 
        ROWTERMINATOR = '\n' 
    )
    

Ahora ocuparemos una sentencia T-SQL llamada BULK INSERT con este comando puedes importar algun documento a sql server desde un txt, xml, etc. y agregar registros a la tabla correspondiente.
 
Damos un select a la tabla alumnos.
 
ARCHIVOSCVS2

Muy práctico para agregar registros a una tabla desde script.

Saludos.

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

Microsoft Data Access Application Block

Son pequeñas clases que nos ayudan mucho a los desarrolladores, en este caso para manipular los datos desde código, existe un archivo llamado SQLHelper que contiene métodos reutilizables para llamar procedimientos almacenados y comandos SQL en forma de texto.

Les recomiendo que lo descarguen y lo utilizen para sus proyectos.

URL: http://www.microsoft.com/downloads/details.aspx?FamilyID=f63d1f0a-9877-4a7b-88ec-0426b48df275&displaylang=en

Servidor Web HTTP, FTP, HTTPs en Windows Server 2008

Como instalar un servidor HTTP en Windows Server 2008:

1.- Vaya a Inicio – Server Manager

InstallIIS01

2.-Vaya a Roles y de agregar un Rol o función

InstallIIS02

3.- Escoga de la lista la función Web Server (IIS) y de clic en siguiente:

InstallIIS03 

4.-Active todas las casillas.

InstallIIS04

5.- Una vez seleccionadas de clic en Instalar.

InstallIIS05 

InstallIIS06

6.- Active el servicio de FTP Publising para utilizarlo más adelante.

InstallIIS07

7.- Abra un explorador Web y teclee http://localhost

InstallIIS07-1

8.- Cree una carpeta para colocar su sitio web, puede eliminar los archivos iistart y welcome.

InstallIIS07-2

9.- Cheque en C:/inetpub/  existen dos carpetas wwwroot y ftproot.

InstallIIS07-3

10.-El siguiente paso es ir a IIS 7, existen dos formas, una es por medio de las Herramientas Administrativas – IIS y la otra en ejecutar colocamos el comando inetmgr.exe

InstallIIS08

11.-Estando en IIS7, vamos agregar un nuevo sitio web y apuntando a la carpeta que creo anteriormente, recuerdo asignar la ip, puede ser la de su computadora en modo privada para forma local, o una ip pública.

InstallIIS09

12.- Coloque los archivos de su sitio web en la carpeta, en este caso haré un index.htm de prueba.

InstallIIS10

13.- Vaya a http://localhost si no asigno ninguna ip anteriormente o a http://direccionIp

InstallIIS11

 

Como instalar un servidor FTP

1.- Primer paso entrar al IIS 7 e ir a la opción FTP Sites. Abrir el Internet Information Services 6.0.

InstallIIS12

2.- Agregar un nuevo Sitio FTP.

InstallIIS13

3.- Colocar una descripción

InstallIIS14

4.- Asignar alguna dirección IP y el puerto 21.

InstallIIS15

5.- Dar en Do not isolate users.

InstallIIS16

6.- Apuntar a la carpeta c:\inetpub\ftproot

InstallIIS17

7.- Agregar algunos archivos a esa carpeta y checarlo en el IIS.

InstallIIS18

8.- Cheque tecleando ftp://direccionIP

InstallIIS19

9.- Es recomendable agregar cuenta de tipo Everyone para que puedan acceder al servidor ftp.

InstallIIS20

También es importante en el windows Firewall, tener activado la excepción de FTP Server.

InstallIIS21

10.- Si se requiere ver en internet con el modem de Infinitum puedes hacer entrando a la configuración y agregando el servicio de servidor FTP a la computadora, este te dará una dirección ip pública el cual le tendrás que asignar con los pasos anteriores.

InstallIIS22 

Como instalar un servidor HTTPs

1.- Vaya al servidor IIS y de clic en Server Certifications

InstallIIS23

2.- Agregue un certificado, dando clic en Create Self-Signed Certificate

InstallIIS24

3.- Vaya a su sitio web y seleccione la opción Bindings.

InstallIIS25

4.- De agregar y seleccione tipo https, la ip y el puerto 443, y el certificado creado.

InstallIIS25-1

5.- Una vez hecho eso, tendrá algo de esta forma:

InstallIIS26

 

6.- Vaya a un explorador web y teclee https://direccionIp

Verá algo como esto:

InstallIIS27

7.- Clic en continuar.

InstallIIS28

 

NOTA: Para Windows Vista se instala el IIS en Activar o Quitar Características de Windows.

Importante, para las versiones Windows Vista Business, Ultimate, se puede activar la casilla de Servidor FTP, para las versiones Home, HomePremium solo el Web Server, y enWindows Vista Basic no soporta ASP.NET.

De igual modo se hacen los pasos para Windows Vista.

Saludos, cualquier pregunta por este medio.

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.

linqtosqlclasessample01

[Dar clic para agrandar las imágenes]

linqtosqlclasessample02

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

linqtosqlclasessample03

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

linqtosqlclasessample04

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

linqtosqlclasessample05

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:

linqtosqlclasessample06

linqtosqlclasessample07

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

Posted: 29/11/2008 10:13 por Edison Daniel García | con 1 comment(s)
Archivado en: ,
Maratón SQL SERVER 2008

Les comparto los videos de la maratón SQL:

  • Gestión del Servidor mediante facetas
  • Diseño de cubos con Analysis Services
  • Introducción al Declarative Management Framework
  • Instalando SQL Server 2008 en Windows Server 2008
  • Manejo de recursos mediante Resource Governor
  • Nuevos tipos de datos en SQL Server 2008
  • Compresión de datos en SQL Server 2008
  • Monitoreando el desempeño mediante Performance Data Collector
  • Administración mediante Políticas 1
  • Administración mediante Políticas 2
  • Administración mediante Políticas 3

pag_tech_landing_heroes 

URL: http://www.microsoft.com/latam/technet/maratonsql/

Personalizar una Instalación Silverlight

A veces cuando desarrollamos aplicaciones Silverlight, cuando le decimos a un amigo, compañero, etc, cheque nuestra aplicación en el Internet, por lo regular no tienen instalado el plugin de Silverlight, como a continuación:

PersonalizateSilverlightInstallation

El usuario no tiene idea de que debe instalar el plugin, o para que me va a servir eso, que pasa usualmente, si una persona que no conoce esa tecnología cerraría la página.

Como podemos detener o cambiar eso, simplemente personalizandolo, de esta forma:

Supongamos que estamos en nuestro proyecto Silverlight y tenemos el siguiente código:;

PersonalizateSilverlightInstallation1

Lo que debemos hacer es lo siguiente dentro del tag asp:Silverlight tenemos una propiedad llamada PluginNotInstalledTemplate, que va a hacer la que nos permitira personalizar esta instalación.

Añadimos una imagen personalizada.

PersonalizateSilverlightInstallation2

Agregamos lo siguiente:

<PluginNotInstalledTemplate>
               <img src="logoPersonalizado.png" />
                <br />

                <a href=http://go.microsoft.com/fwlink/?LinkID=115261 a style="text-decoration: none;">
                 <img src="http://go.microsoft.com/fwlink/?LinkId=108181" alt="Obtener el plugin de  Silverlight" style="border-style: none "/>
                  </a>
</PluginNotInstalledTemplate>

Ejecutamos y listo.

PersonalizateSilverlightInstallation3

Esto hará que el usuario no cierre nuestra página web y se anime a instalar el plugin.

PersonalizateSilverlightInstallation4

Espero lo puedan implementar en sus websites que ya cuenten con contenido Silverlight. Recuerden siempre la experiencia de usuario!!

Saludos.

Curso E-Learning Silverlight

Les comparto el siguiente curso muy interesante sobre Silverlight, esta muy bueno, espero les sirva mucho.

Silve3rlightelearning

Silve3rlightelearning01

URL: http://www.microsoft.com/learning/_silverlight/learningsnacks/silverlight/snack01/Default.html

Importante - Atención MSPs y estudiantes de TI de México!!

Microsoft Students To Business ha posteado 10 vacantes para trabajar en Microsoft, México, a continuación los detalles.

Información del Proyecto
  • Nombre: Development Consultant Trainee
  • Fecha de Inicio 21/08/2008
  • Fecha de Terminación 21/08/2009
  • Duración 1año
  • Lugares Disponibles 10
  • Lugares restantes 9
  • Ciudad: Ciudad de México
  • Región: Distrito Federal
  • País Mexico
  • Idiomas: Ingles
Partner
Habilidades de TI
  • C#
    Desktop Application
  • .Net Framework 3.0
    Desktop Application
  • Visual Studio .Net
    Client Tools
  • ASP
    Web Development
    Tipos de Grado
  • Bachelor Degree
    Categorias en Curso
  • Ciencias Computacionales
  • Engineering
Archivos de proyecto

wordPPP

  • Development Consultant Trainee Job Description
  • Job Description file. Word Version.
  • 13,46 Kb

Si cumples con este perfil, que esperás registrate inmediatamente en

URL: http://s2bprogram.com/Mexico y completa tu perfil con los conocimientos que tienes además, adjunta tu CV, en la opción de archivos que aparece ahi.

Nota: Tips para realizar tu CV aquí 

 

URL:http://s2bprogram.com/Mexico/Projects.aspx

Academic Cells - Microsoft México

y1pmShFkujlcjOYbvvQKxjlONBp5VMRdegJfJ70cX1b1R4tuMlII0K_AFR1muVLv97g Hola que tal les hago una cordial invitación para que visiten el blog de Ivette Pérez
(Community Operation Manager de Microsoft, México), en el cual pueden encontrar información de los diversos programas Academicos de Microsoft.

En estas fechas habrá un lanzamiento del programa para estudiantes llamado Microsoft Student Clubs, así para que esten al pendientes y puedan participar en este nuevo programa a nivel México no dejen de visitar este blog, además pueden encontrar noticias y convocatorias para Microsoft Student Partners, etc.

http://academiccellsms.spaces.live.com/

Información y Contacto:

Ivette Pérez

Community Operation Manager , Microsoft México

academic_cells@hotmail.com

Atención Profesores de TI (Microsoft Educación)

 

mssstudent Hola, que tal, de vez en cuando a los profesores se les hace muy dificil conseguir material para dar en clases. Microsoft nos deja unos buenos recursos.

Les comparto algunos, espero y les pueda servir, estos temas vienen con diapositivas, documentos de word, examenes, y ejercicios para los profesores.

 

 

Saludos.

Microsoft Students to Business

Una iniciativa de la comunidad Microsoft, que pretende conectar la industria de Partners con las Universidades y Estudiantes del país proveyéndoles experiencia laboral en el campo real.

Con lo anterior se pretende brindar las habilidades y competencias necesarias para impulsar la innovación y empleo de las siguientes generaciones.

 s2bmexico02

¿Por qué S2B?
  • Forma escalable para generar talento de TI.
  • Demuestra oportunidades en el sector de las TI.
  • Crea nuevas oportunidades de empleo.
  • Apoya a los requerimientos locales en la industria.
  • Brinda a empresarios recursos motivados.
  • Promueve el empleo en carreras de IT.
  • Desarrolla estudiantes con mayor talento en tecnología

No lo pienses mas y únete a http://www.s2bprogram.com/latam

Microsoft, Latinoamerica

Gratis E-book Microsoft Press - SQL Server 2008

ms_sql_srv_cvr

    Gratis 2 Capítulos

  • Chapter 1: Policy-based Management
  • Chapter 11: Transact-SQL Enhancement
  • URL: http://csna01.libredigital.com/

    MSPressLogo-Hero-Sm

    Seguimiento de Imagine Cup 2008 Microsoft, México

    Hola que tal, solo para comentarle que  a través de mi blog http://mredison.wordpress.com se podrá seguir minuto a minuto lo que estará ocurriendo hoy en las finales de Imagine Cup 2008 en  las oficinas de Microsoft, México, DF, en donde un servidor esta reportando a cada equipo finalista, al igual pueden checar la dirección de Alejandro Martínez http://twitter.com/imixe
    Al finalizar el día tendremos publicado el video en Channel 8 de MSDN http://channel8.msdn.com , con todo el reporte del equipo ganador y los proyectos realizados. Saludos, y estamos en sintonía...

    http://channel8.msdn.com/

    logoImagineCup2008

    http://www.imaginecup.com
    Nota: Vota por el nuevo Diseño de Imagine Cup 2009 aquí : http://www.mondorobot.com/microsoft/IC2009

    Tutorial de Silverlight 2 con WCF

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

    • Silverlight 2 Beta 1
    • Expression Blend 2.5
    • WCF
    • LINQ

    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:

    silverlight2_tutorial01

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

    silverlight2_tutorial02

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

    silverlight2_tutorial03

    d) Cambiamos el fondo en Expression Blend

    silverlight2_tutorial04

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

    silverlight2_tutorial05

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

    silverlight2_tutorial06 silverlight2_tutorial07

    g) Agregamos un boton, quedando de esta forma:

    silverlight2_tutorial08

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

    silverlight2_tutorial09

    h) 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 ".

    silverlight2_tutorial10

    i)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,

    silverlight2_tutorial11

    j)Selecciono la base de datos Northwind que si no la tienen pueden descargarla de ">'>aquí

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

    silverlight2_tutorial12

    Quedando de esta forma, con sus relaciones:

    silverlight2_tutorial13

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

    silverlight2_tutorial14

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

    silverlight2_tutorial15

    n) 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);
        }
    }

     

    o) Depues este buscamos el archivo de codigo del web service:

    silverlight2_tutorial16

    p) 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
        {
        }
    }

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

    silverlight2_tutorial17

    #region ImiServicio Members

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

    #endregion

    r) Ahora, crearemos una variable de tipo DataContext.

    var miDataContext = new datosDataContext();

    s) 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;

    y) 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();
           }

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

     silverlight2_tutorial18

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

    silverlight2_tutorial19

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

     

     silverlight2_tutorial20

    silverlight2_tutorial21

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

    silverlight2_tutorial22

    y) Ahora agregaremos ese referencia en el código XAML:

    silverlight2_tutorial23

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

    <WatermarkedTextBox x:Name="txtCategoria"  ...../>

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

    silverlight2_tutorial25

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

    x:Name="Mostrar" AutoGenerateColumns="True"

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

    silverlight2_tutorial24

    Nos vamos al evento clic del botón:

    private void Button_Click(object sender, RoutedEventArgs e)
            {

            }

    a4) Agrego a los namespaces la referencia:

    using TutorialSilverlight2.ServiceReference1;

    a5) Dentro del evento clic copiamos esto:

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

    a6) Despues vamos a crear el siguiente metodo:

    silverlight2_tutorial26

    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)
          {
          }

    a7) Ahora dentro del metodo que creamos colocaremos:

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

    a8) Y damos visualizar, podemos ingresar una categoría de la tabla y nos dará los productos que estan ligados a esa categoría...

    silverlight2_tutorial27

    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.

     

     

    Además de la sintaxis con establecimiento inflexible de tipos, las consultas de LINQ tienen también un arsenal de operadores de consulta estándar para mejorar su funcionalidad. Estos operadores de consulta estándar funcionan en secuencias y le permiten realizar operaciones como determinar si un valor existe en la secuencia y realizar una función agregada, como una suma, sobre una secuencia.

    En la columna de este mes, se realizarán consultas y operaciones prácticas con LINQ, usando tanto LINQ to Objects como LINQ to Entities. Se realizará una consulta sobre una colección de entidades y me sumergir en un conjunto jerárquico de entidades mediante sus propiedades de navegación. Se mostrará también cómo puede aplicar muchos de los operadores de consulta estándar a matrices y colecciones. Se demostrará cómo se mejoran los operadores de consulta estándar de LINQ mediante expresiones lambda y cómo les permite analizar información concreta a partir de una secuencia. También aprenderán a realizar una lógica compleja sobre una secuencia. Todos los ejemplos de código están disponibles en la descarga de esta columna (consulte msdn.microsoft.com/msdnmag/code08.aspx).

    Operadores y LINQ

    LINQ es muy eficaz por sí mismo, independientemente de que use LINQ to XML, LINQ to Datasets, LINQ to Entities, LINQ to Objects o cualquier otro proveedor de LINQ que surja. El punto fuerte de LINQ radica en su sintaxis de consulta con establecimiento inflexible de tipos, que puede usarse para operar con cualquiera de estos proveedores. Al combinar LINQ con uno o varios operadores de consulta estándar, el resultado es un conjunto de herramientas aún más eficaz que le proporciona un control granular sobre un conjunto de datos.

    Los operadores de consulta estándar se encuentran en el ensamblado System.Core.dll dentro del espacio de nombres System.Linq como métodos de extensión en las clases estáticas Enumerable y Queryable. Pueden usarse en objetos que implementan IEnumerable<T> o IQueryable<T>. Esto les permite operar con varios tipos, desde colecciones y matrices (secuencias) en memoria hasta bases de datos remotas que usan proveedores como LINQ to Entities y LINQ to SQL.

    Es fácil determinar qué conjunto de operadores tiene a su disposición para realizar una tarea específica. Cuando desee usar un operador en una consulta de LINQ, puede utilizar un operador de la lista disponible de métodos de extensión en la clase estática Queryable. Cuando desee usar un operador en una secuencia que implementa IEnumerable<T>, puede usar uno de los métodos de extensión encontrados en la clase estática Enumerable. Tenga presente, sin embargo, que no todos los operadores encontrados en la clase Queryable son aplicables al almacén de datos subyacente y que, por tanto, es posible que algunos presenten problemas de compatibilidad durante el tiempo de ejecución.

    Tipos de operadores

    Hay muchos tipos diferentes de operadores (que pueden encontrarse mediante el explorador de objetos para mirar en las clases Enumerable y Queryable). La Figura A muestra una categorización de los distintos tipos de operadores por orden alfabético. Le ofrece una visión de la funcionalidad que los operadores ofrecen. Voy a demostrar un subconjunto de estos operadores usando tanto LINQ to Objects como LINQ to Entities para mostrar cómo pueden ser beneficiosos en una aplicación real.

    FiguraA

    Expresiones lambda

    Muchos operadores de consulta estándar usan delegados Func para procesar elementos individuales conforme operan sobre una secuencia. Las expresiones lambda pueden funcionar en este caso junto con los operadores de consulta estándar para representar a los delegados. Una expresión lambda es una forma abreviada para crear una implementación de un delegado y puede utilizarse en cualquier lugar donde se pueda usar un delegado anónimo. Las expresiones lambda se admiten tanto en C# como en Visual Basic® .NET. Sin embargo, es importante tener en cuenta que, puesto que Visual Basic .NET no admite aún métodos anónimos, las expresiones lambda pueden constar de una única instrucción.

    Vamos a ver cómo se puede usar el operador Single en una matriz de enteros. Se crea una matriz de enteros, donde cada elemento representa una potencia de 2 del 1 al 10. Después se usará el operador Single para recuperar el elemento del entero que reúne la condición especificada en la expresión lambda:

     

    int[] nums = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 };
    int singleNum = nums.Single(x => x > 16 && x < 64);
    Console.WriteLine(singleNum.ToString());
    

    Las expresiones lambda tienen unos cuantos elementos clave. La expresión lambda se inicia con la definición de las variables que se pasan al delegado. En el ejemplo de código anterior, x (declarado a la izquierda del operador =>) es el argumento que representa cada elemento de la matriz numérica que se pasa a él. El resto de la expresión lambda representa la lógica que se evalúa para cada elemento de la matriz. La expresión anterior se podría haber rescrito fácilmente usando un delegado anónimo, como se muestra a continuación:

     

    int singleNum = nums.Single<int>(
      delegate(int x) {return (x > 16 && x < 64); }
    ) ;
    

    Sin embargo, este código es menos legible que usar la expresión lambda. C# 2.0 introdujo delegados anónimos, lo que simplificó en gran medida el paso de delegados. Sin embargo, las expresiones lambda simplificaron el proceso exponencialmente gracias a la brevedad de su sintaxis.

    First y Single

    Cuando es necesario obtener un solo valor de una secuencia, los operadores First, FirstOrDefault, Single y SingleOrDefault son muy útiles. El método First devuelve el primer elemento de una secuencia. Hay un método sobrecargado para First que le permite pasar una expresión lambda para representar una condición. Por ejemplo, si desea devolver el primer elemento de una secuencia de enteros donde el elemento entero es mayor que 50, podría usar el siguiente ejemplo de código:

     

    int[] nums = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 };
    int num1 = nums.First<int>();
    int num2 = nums.First<int>(x => x > 50);
    int num3 = nums.FirstOrDefault<int>(x => x > 5000);
    
    Console.WriteLine(
      num1.ToString() + "-" + 
      num2.ToString() + "-" + 
      num3.ToString());
    

    Este código encontrará el primer elemento (1), el primer elemento mayor que 50 (64) y el primer elemento mayor que 5.000. Debido a que no hay ningún elemento en la matriz que satisfaga la tercera expresión lambda (ningún entero de la matriz es superior a 5.000), se generará una excepción si el código usó el operador First en lugar de FirstOrDefault. Al usar el operador FirstOrDefault, se devuelve 0 si ningún elemento satisface la expresión lambda. También se puede usar el operador First en una consulta de LINQ to Entities, como puede ver a continuación:

     

    using (Entities entities = new Entities())
    {
      var query = (from c in entities.Customers
                   select c).First(c => c.City.Equals("London"));
      Console.WriteLine(query.CompanyName);
    }
    

    En este ejemplo, se devolverá el primer cliente en la ciudad de Londres. Como puede ver, la sintaxis para usar el método First no cambia cuando se usa con distintos proveedores de LINQ (en este caso, LINQ to Objects y LINQ to Entities).

    El operador First es muy útil en el contexto de LINQ to Entities, sobre todo cuando sabe que la consulta devolverá un único registro. Por ejemplo, podría tener una consulta que siempre obtiene un registro de cliente cuando se proporciona CustomerID. En esta situación, siempre se devolvería 0 o 1 registro, por lo que una secuencia no ayuda tanto como la entidad en sí misma. En otras palabras, simplemente recogería la entidad Customer en lugar de una secuencia de la entidad 1 Customer. Este es un caso en el que el método First puede ayudar, tal y como se muestra en el fragmento de código que sigue. Debido a que Entity Framework no intenta distribuir la ejecución de una consulta entre cliente y servidor, el método Single no se admite en LINQ to Entities, por lo que usar el método First es una alternativa fácil.

     

    using (Entities entities = new Entities())
    {
      var query = (from c in entities.Customers
                   where c.CustomerID.Equals("BOLID")
                   select c).First();
      Console.WriteLine(query.CompanyName);
    }
    

    Agregados, jerarquías y proyecciones

    Usar un operador agregado como Sum en una consulta LINQ to Entities puede ayudar a simplificar una consulta. Por ejemplo, el código siguiente recupera una secuencia de pedidos donde la cantidad total es superior a 10.000 USD:

     

    using (Entities entities = new Entities())
    {
      var query = from o in entities.Orders
                  where o.OrderDetails.Sum(
                    od => od.UnitPrice * od.Quantity) >= 10000
                  select o;
      foreach (Orders order in query)
        Console.WriteLine(order.OrderID);
    }  
    

    Como LINQ puede realizar una consulta sobre las recopilaciones de entidades jerárquicas, los operadores de consulta estándar también se pueden usar para realizar operaciones sobre las secuencias anidadas de entidades. Esto puede ser muy útil cuando los datos derivados deben calcularse o interrogarse. Los datos derivados sólo pueden existir en sus formularios base. Éste es el caso, por ejemplo, cuando los detalles de los pedidos del cliente sólo tienen valores para el precio por unidad y la cantidad. En este caso, los datos agregados que representan la cantidad total correspondiente a un pedido no se proporcionan en ningún punto del modelo. Sin embargo, al aplicar el operador Sum a su consulta de LINQ, podrá seguir recuperando todos los clientes que hayan gastado más de 20.000 USD, tal y como vemos aquí:

     

    using (Entities entities = new Entities())
    {
      var query = from c in entities.Customers
                  where c.Orders.Sum(
                    o => o.OrderDetails.Sum(
                      od => od.UnitPrice * od.Quantity)) >= 25000
                  select c;
      foreach (Customers customer in query)
        Console.WriteLine(customer.CompanyName);
    }
    

    Este ejemplo muestra cómo puede aplicar los operadores de consulta estándar en varios niveles de una consulta de LINQ. La consulta devuelve finalmente una secuencia de entidades Customers, pero para llegar hasta allí, deberá sumergirse primero en los pedidos del cliente y en cada detalle del pedido para obtener los datos que necesita. Así, se puede calcular el precio de cada elemento de línea, sumar el total de los elementos de línea correspondiente a cada pedido y sumar los totales del pedido para cada cliente.

    El operador Count es otro operador de consulta estándar agregado. Puede determinar cuántos clientes gastaron más de 25.000 USD con el siguiente código:

     

    using (Entities entities = new Entities())
    {
      var query = (from c in entities.Customers
                   where c.Orders.Sum(
                     o => o.OrderDetails.Sum(
                       od => od.UnitPrice * od.Quantity)) >= 25000
                   select c).Count();
      Console.WriteLine(query);
    }
    

    Se puede usar el operador Max para determinar el mejor cliente. El siguiente código de ejemplo devolverá la cantidad desembolsada por el cliente que más gasta. Usa una combinación de los agregadores Sum y Max en varios niveles de una jerarquía:

     

    using (Entities entities = new Entities())
    {
      var query = (from c in entities.Customers
                   select new
                   {
                     c.CustomerID, 
                     Total = c.Orders.Sum(
                       o => o.OrderDetails.Sum(od => od.UnitPrice))
                   }).Max(c2 => c2.Total);
      Console.WriteLine(query);
    }
    

    Proyecciones y ordenación

    Puede que haya notado que en el ejemplo anterior he introducido una proyección. Antes usar el operador Max, la consulta LINQ no devuelve una lista de clientes. En su lugar, devuelve una proyección, que crea una entidad nueva que contiene una propiedad para CustomerID y otra para Total (el importe total del gasto del cliente). Las proyecciones son una parte integral de LINQ y, cuando se proyectan en secuencias, tal y como se muestra en el ejemplo anterior, se pueden seguir procesando mediante operadores de consulta estándar.

    La Figura 1 muestra cómo crear una proyección de una nueva entidad que contiene un CustomerID y la suma de los totales de pedidos del cliente (con el operador Sum que se ha descrito anteriormente). La Figura 1 usa el operador OrderByDescending para ordenar la secuencia de entidades proyectadas en función del total calculado. Si dos clientes tuvieran el mismo total, se podría usar un operador de ordenación adicional para ampliar la definición de la ordenación. Por ejemplo, la instrucción foreach que aparece en la Figura 1 se podría corregir para usar el siguiente código y seguir calificando las reglas de ordenación:

    Figura 1 Agregados, proyecciones y ordenación

     

    using (Entities entities = new Entities())
    {
      var query = from c in entities.Customers
                  where c.Orders.Sum(
                    o => o.OrderDetails.Sum(od => od.UnitPrice)) > 0
                  select new
                  {
                    c.CustomerID, 
                    Total = c.Orders.Sum(
                      o => o.OrderDetails.Sum(od => od.UnitPrice))
                  };
      foreach (var item in query.OrderByDescending(x => x.Total))
        Console.WriteLine(item.CustomerID + " == " + item.Total);
    }
    
    

     

    foreach (var item in 
      query.OrderByDescending(x => x.Total)
      .ThenBy(x => x.CustomerID))
    {
      Console.WriteLine(item.CustomerID + " == " + item.Total);
    }
    

    En este fragmento de código, agregué el operador ThenBy y una expresión lambda para indicar que la secuencia debe ordenarse primero en orden descendente por la propiedad Total y después en orden ascendente por la propiedad CustomerID de la proyección.

    Cuantificadores y conversión

    Si necesita determinar si existe un valor en una secuencia, puede usar el operador de consulta estándar Any. Los cuantificadores como Any, All y Contains buscan una secuencia de elementos y evalúan si la secuencia cumple o no una condición de la expresión lambda. Esto puede ser muy útil cuando necesita examinar una secuencia para determinar, por ejemplo, si el cliente de una dirección específica existe, si todos los clientes son del mismo país o cualquier otra pregunta analítica.

    Por ejemplo, la siguiente consulta LINQ comprueba si todos los clientes del Reino Unido se encuentran en Londres. Usa el cuantificador All y le pasa la expresión lambda que evalúa si la ciudad es Londres. Si cada elemento en la secuencia cumple este criterio y devuelve true desde la expresión lambda, entonces el operador All devolverá true:

     

    using (Entities entities = new Entities())
    {
      bool allUKCustomerAreFromLondon = (from c in entities.Customers
                                         where c.Country == "UK"
                                         select c).All(
                                           c => c.City.Equals("London"));
      Console.WriteLine(allUKCustomerAreFromLondon ? "Yes" : "No");
    }            
    

    Otra pregunta que quizás necesite respuesta en esta consulta es si hay alguna entidad en la secuencia de la ciudad de Cowes en el Reino Unido. Con esta pregunta, puede usar el cuantificador Any para operar en la secuencia, tal y como se muestra aquí:

     

    using (Entities entities = new Entities())
    {
      bool isOneUKCustomerFromCowes = (from c in entities.Customers
                                       where c.Country == "UK"
                                       select c).Any(
                                         c => c.City.Equals("Cowes"));
      Console.WriteLine(isOneUKCustomerFromCowes? "Yes" : "No");
    }
    

    El operador Contains es similar al operador Any en tanto que evalúa si la secuencia contiene lo que está buscando. El operador Any puede determinar si un valor existe dentro de un elemento en la secuencia, pero el operador Contains determina si un elemento concreto existe en la secuencia. Por ejemplo, antes de agregar un objeto a una secuencia, es posible que desee asegurarse de que la secuencia no contiene ese objeto. La Figura 2 muestra cómo hacerlo.

    Figure 2 Uso de Contains y conversión

     

    using (Entities entities = new Entities())
    {
        Customers customerBSBEV = (from c in entities.Customers
                                   where c.CustomerID == "BSBEV"
                                   select c).First();
    
        var customersUK = from c in entities.Customers
                          where c.Country == "UK"
                          select c;
    
        bool isCustomerInSequence = customersUK.Contains(customerBSBEV);
    
        Console.WriteLine(isCustomerInSequence? "Yes" : "No");
    }
    
    

    Tenga en cuenta que en la Figura 2 se recupera una entidad Customers para el cliente BSBEV. A continuación, se recupera la secuencia de entidades Customers de clientes del Reino Unido. Finalmente, se usa el operador Contains para comprobar si la secuencia de clientes contiene la versión mantenida por la variable customerBSBEV.

    La implementación del operador Contains que se muestra en la Figura 2 funciona en situaciones donde puede comparar de forma segura objetos basados en la versión actual. Sin embargo, ¿qué ocurre si necesita comprobar el operador Contains en función de una identidad lógica? Afortunadamente, el operador Contains cuenta con una sobrecarga que le permite pasar un objeto que implementa la interfaz de IEqualityComparer<T>. Para usar Contains en función de CustomerID, el código de la Figura 2 puede volver a escribirse de la siguiente manera:

     

    using (Entities entities = new Entities())
    {
      ...
    
      bool isCustomerInSequence = customersUK.Contains(customerBSBEV,
        new CustomerComparer());
    
      Console.WriteLine(isCustomerInSequence? "Yes" : "No");
     }
    

    donde CustomerComparer se define como

     

    private class CustomerComparer : IEqualityComparer<Customers>
    {
      public bool Equals(Customers x, Customers y) {
        if (x == null || y == null)
          return false;
        return x.CustomerID.Equals(y.CustomerID);
      }
    
      ...
    }
    

    Conclusión

    Hay muchos operadores de consulta estándar que se definen como métodos de extensión para las clases de secuencias Enumerable y Queryable. Estos operadores pueden ayudar a ampliar la funcionalidad de LINQ, tal y como he mostrado en este artículo. He demostrado también cuántas de las nuevas mejoras realizadas a .NET Framework 3.5 (incluidas las expresiones lambda, LINQ, Entity Framework y las variables con establecimiento implícito de tipos) se unen para facilitar la escritura de código y lógica robustos.

    Código lo encuentras en:

    URL: http://msdn2.microsoft.com/es-mx/magazine/cc337979.aspx?pr=blog

    Posted: 30/4/2008 16:12 por Edison Daniel García | con no comments
    Archivado en:
    Windows Live Quick Applications (beta)

    En que consiste, muy facil Microsoft nos brinda algunas aplicaciones web realizadas con servicios de Windows Live, y nos da la posibilidad de descargar el código de la aplicación, con el fin de que nosotros lo usemos de buena manera. Checa algunas aplicaciones como:

    • Tafiti
    • Adventure Works Resorts
    • Contoso Bicycle Club
    • Video Show
    • ContosoISV
    • Contoso University
    • Visit Planner

    vistiplannerwqlacontosoujniwaqltafitiwlqastreaminwqla

    Checa online estas aplicaciones, están de lujo.

    URL y Características: http://dev.live.com/quickapps/

    Más artículos Página siguiente >