ponte : nivel:100

el problema CREATE DATABASE permission denied in database 'master'

Gabriel Flores — Fri, 04 Jan 2013 23:44:00 GMT

Me encontraba haciendo ejercicios de programación usando database migrations cuando al hacer un update-database me ocurre el error:

CREATE DATABASE permission denied in database 'master'

Algo raro pues uso Visual Studio con mi cuenta con derechos de Administrador, además de ejecutarlo con el "Run as Administrator" e investigando un poco di con problemas al querer migrar de ambiente de desarrollo a producción la aplicación, cosa que no es mi caso. Al final di con el problema, y no caí en cuenta de que en este equipo mi cuenta fue creada después de tener instalado SQL Server Express, por lo que mi cuenta de usuario no figuraba con derechos de administración sobre la instancia de SQL Server actual. Es algo más o menos sencillo de hacer pero siguiendo la filosofía de "si alguien más ya batalló con esto" encontré un script para agregar al usuario de sistema actual con derechos de sysadmin de la instancia de SQL Server. Este fue publicada en los anales de MSDN por lo que su uso me pareció lo suficientemente seguro, además de que me resolvió el problema.

Recursos:

Script to add the current user to the SQL Server 'sysadmin' role

Regreso a las bases: Memoria (Parte 2)

Gabriel Flores — Wed, 16 Dec 2009 05:00:00 GMT

Lo que sigue es una traducción de una sección del ebook gratuito Foundations of Programming de Karl Seguin.

Apuntadores

Para muchos desarrolladores, aprender sobre apuntadores en la escuela fue una experiencia dolorosa. Representan la verdaderamente real indirección que existe entre código y hardware. Muchos más desarrolladores nunca tuvieron la experiencia de aprender sobre ellos - saltaron directamente a programar en un lenguaje que no los expone directamente. La verdad sin embargo es que cualquiera que diga que C# o Java son lenguajes sin apuntadores es simplemente un error. Como los apuntadores son el mecanismo con el cual todos los lenguajes almacenan valores en el heap, es más bien tonto no entender como son usados.

Los apuntadores representan el nexus del modelo de memoria de un sistema – esto es, los apuntadores son el mecanismo donde el stack y el heap trabajan juntos para proveer el subsistema de memoria requerido por su programa. Como discutimos anteriormente, cuando instancia un objeto new, .NET asigna un bloque de memoria al heap y regresa un apuntador al inicio de este bloque de memoria. Esto es todo lo que un apuntador es: la dirección de inicio para el bloque de memoria que contiene un objeto. La dirección no es nada más que un número único, generalmente representado en formato hexadecimal. Por lo tanto, un apuntador no es nada más que un número único que le dice a .NET donde está el objeto mismo en memoria. Esta indirección es transparente en Java o .NET, pero no en C o C++ donde se puede manipular la dirección de memoria directamente con un apuntador aritmético. En C o C++ se puede tomar un apuntador y agregar 1 a él, y así arbitrariamente cambiar a donde está apuntando (y seguramente hacer tronar el programa debido a esto).

Donde se pone interesante es donde el apuntador está realmente almacenado. Ellos en realidad siguen las mismas reglas descritas arriba: como enteros son almacenados en el stack – al menos, claro, que ellos formen parte de una referencia a un objeto y entonces estarán en el heap con el resto del objeto. Puede no ser claro aún, pero esto significa que ultimadamente, todos los objetos heap están enraizados al stack (posiblemente a través de numerosos niveles de referencias). Veamos primero este ejemplo simple:

static void Main(string[] args)

{

int x = 5;

string y = "codebetter.com";

}

Del código de arriba, terminaremos con 2 valores en el stack, el entero 5 y el apuntador a nuestra cadena, así como también precisamente el valor en el heap. Aquí una representación gráfica:

Cuando salimos de nuestra function main (olvidémonos del hecho de que el programa se parará), nuestro stack liberará todos los valores locales, lo que significa que tanto el valor de x como de y se perderán. Esto es significativo porque la memoria asignada en el heap todavía contiene nuestra cadena, pero hemos perdido toda referencia a ella (no hay algún apuntador apuntándola). En C o C++ esto resulta en una fuga de memoria – sin una referencia a nuestra dirección en el heap no podemos liberarla de la memoria). En C# o Java, nuestro confiable recolector de basura detectará el objeto sin referencia y lo liberará.

Veremos ejemplos más complejos, que aparte de tener más flechas apuntando, es básicamente el mismo.

public class Empleado

{

private int _empleadoId;

private Empleado _gerente;

public int EmpleadoId

{

get { return _empleadoId; }

set { _empleadoId = value; }

}

public Empleado Gerente

{

get { return _gerente; }

set { _gerente = value; }

}

public Empleado(int empleadoId)

{

_empleadoId = empleadoId;

}

public class Prueba

{

private Empleado _subordinado;

void HacerAlgo()

{

Empleado jefe = new Empleado(1);
_subordinado = new Empleado(2);

_subordinado.Gerente = _jefe;

}

Interesantemente, cuando salimos de nuestro método, la variable jefe se liberará del stack, pero el subordinado, que está definido por el alcance padre, no. Esto significa que el recolector de basura no tendrá nada que limpiar porque los dos valores del heap seguirán siendo referenciados (uno directamente del stack, y el otro indirectamente del stack a través del objeto referenciado.

Como puede ver, los apuntadores definitivamente juegan una parte importante tanto en C# como en VB.NET. Como el apuntador aritmético no está disponible en ninguno de estos lenguajes, los apuntadores son grandemente simplificados y con suerte fácilmente entendidos.

Regreso a las bases: Memoria

Gabriel Flores — Mon, 14 Dec 2009 17:08:00 GMT

Lo que sigue es una traducción de una sección del ebook gratuito Foundations of Programming de Karl Seguin.

Regreso a las bases: Memoria

Por más que se intente, los lenguajes modernos de programación no pueden abstraer completamente los aspectos fundamentales de los sistemas computacionales. Por ejemplo, podemos asumir que usted se ha encontrado con las siguientes excepciones .NET: NullReferneceException, OutOfMemoryException, StackOverflowException y ThreadAbortException. Tan importante como es para desarrolladores adopter varios patrones y técnicas de alto nivel, es igualmente importante comprender el ecosistema en el cual su programa se ejecuta. Mirando por encima de las capas proveídas por el compilar de C# (o VB.NET), el CLR y el sistema operativo, nos encontramos con la memoria. Todos los programas hacen uso extensivo de la memoria del sistema e interaccionan con ella en maravillas maneras, es difícil ser un buen programador sin comprender esta interacción fundamental.
Mucha de la confusión sobre la memoria nace del hecho de que tanto C# y VB.NET son lenguajes administrados y que el CLR provee la recolección automática de basura. Esto ha causado que muchos desarrolladores asuman erróneamente que no necesitan preocuparse por la memoria.

Asignación de Memoria

En .NET, como en muchos otros lenguajes, cada variable que se defina está almacenada en el stack o en el heap . Estos son dos espacios separados asignados en la memoria de sistema que sirven un propósito distinto, aunque complementario. Lo que va donde está predeterminado: valores de tipos van en el stack, mientras que la referencia a tipos va en el heap. En otras palabras, todos los tipos de sistema, como char, int, long, byte, enum y cualquier estructura (ya sean definidas por.NET o por usted) van en el stack. La única excepción a esta regla son los valores de tipos que pertenecen a referencias de tipos – por ejemplo la propiedad Id de una clase User va en el heap junto con la instancia de la clase User misma.

El Stack

Aunque estamos acostumbrados al mágico colector de basura, los valores en el stack son automáticamente administrados aún en un mundo sin colector de basura (como en C). Esto es porque cuando sea que entramos a un nuevo alcance (como un método o una sentencia If) los valores son empujados al stack y cuando salen del stack los valores son liberados. Esta es la razón por la que un stack es sinónimo a LIFO - last-in first-out (último en entrar primero en salir). Puede pensarlo en este modo: cuando se crea un nuevo alcance, por ejemplo un método, un marcador es puesto en el stack y los valores son añadidos como se necesiten. Cuando se deja ese alcance, todos los valores son liberados incluyendo el marcador del método. Esto funciona en cualquier nivel de anidado.
Hasta que veamos la interacción entre el heap y el stack, la única manera real de meterse en problemas con el stack es con StackOverflowException. Esto significa que ha usado todo el espacio disponible del stack. 99.9% del tiempo, esto indica una llamada recursiva interminable (una función que se llama a sí misma ad infinitum). En teoría esto puede ser causado por un muy muy mal diseño de sistema, aunque nunca he visto una llamada no recursiva usando todo el espacio del stack.

El Heap

La asignación de memoria en el heap no es tan simple como el stack. La mayoría de la asignación de memoria basada en el heap ocurre cuando creamos un objeto new. El compilador averigua cuanta memoria necesitaremos (lo cual no es tan difícil, aún con objetos con referencias anidadas), toma un apropiado montón de memoria y regresa el apuntador a la memoria asignada (más acerca de esto en un momento). El ejemplo más sencillo es una cadena, si cada carácter en una cadena toma 2 bytes, y creamos una nueva cadena con el valor de “Hola Mundo”, entonces el CLR necesitará asignar 22 bytes (11x2) más cualquier adicional necesitado.
Hablando de cadenas, seguramente ha oído que las cadenas son inmutables – esto es, una vez que ha sido declarada una cadena y asignado un valor, si se modifica esa cadena (cambiando el valor o concatenando otra cadena a ella), entonces una nueva cadena se crea. Esto realmente puede tener implicaciones de rendimiento negativas, y por ello la recomendación general es usar un StringBuilder para cualquier manipulación de cadenas significativa. La verdad es que cualquier objeto almacenado en el heap es inmutable con respecto a la asignación de tamaño, y cualquier cambio en el tamaño subyacente requerirá una nueva asignación. El StringBuilder, junto con algunas colecciones, parcialmente pueden sacar la vuelta a esto usando buffers internos. Una vez que el buffer se llena, la misma reasignación ocurre y algún tipo de algoritmo de crecimiento es usado para determinar el nuevo tamaño (el más simple siendo antiguoTamaño * 2). Siempre que sea posible es buena idea especificar la capacidad inicial de dichos objetos para evitar este tipo de reasignación (el constructor para tanto el StringBuilder y el ArrayList (entre muchas otras colecciones) le permiten especificar capacidad inicial).
Recolectar basura del heap es una tarea no trivial. A diferencia del stack donde el último alcance puede simplemente liberarlo, los objetos del heap no son locales a un determinado alcance. En lugar de ello, la mayoría son referencias profundamente anidadas de otros objetos referenciados. En lenguajes como en C, cuando un programador causa que la memoria sea asignada al heap, debe asegurarse también de remover del heap cuando ha terminado con él. En lenguajes administrados, el motor en tiempo de ejecución se encarga de limpiar los recursos (.NET usa un Recolector de Basura Generacional que está brevemente descrito en la Wikipedia).
Hay muchos incidentes horribles que pueden molestar a los desarrolladores mientras trabajan con el heap. Fugas de memoria no solo son posibles sino muy comunes, la fragmentación de memoria puede causar todo tipo de caos, y varios problemas de rendimiento pueden generarse gracias a comportamiento de asignación extraño o interacción con código sin administrar (lo cual .NET hace mucho debajo del agua).

Screencasts sobre ADO.NET Entity Framework con C#

Gabriel Flores — Tue, 15 Sep 2009 13:13:00 GMT

En esta serie de screencasts vemos como hacer cosas sencillas con ADO.NET Entity Framework, para un primer contacto con esta tecnología.

Introducción

Northwind y pubs:
Para saber como tener instaladas las bases de datos de prueba Northwind y pubs, proveídas por Microsoft

Usando C# en ASP.NET con ADO.NET Entity Framework
Un ejemplo rápido para ver como es el contexto de uso del ADO.NET Entity Framework

Tareas específicas

Búsqueda en ADO.NET Entity Framework con C#
Paso inicial para el resto de las tareas

Alta de registros con ADO.NET Entity Framework con C#
Como agregar registros

Baja de registros con ADO.NET Entity Framework con C#
Como eliminar registros

Cambios a registros en ADO.NET Entity Framework con C#
Como hacer modificaciones

No abre http://localhost Visual Studio

Gabriel Flores — Tue, 09 Jun 2009 03:57:20 GMT

Hace unos días unos compañeros de la universidad me advirtieron de un problema que les ocurría en común a máquinas donde tuvieran Visual Studio 2008 y particularmente en sistema operativo Windows Vista. Se trata de que al intentar correr alguna aplicación ASP.NET desde el entorno de desarrollo les salía Internet Explorer con la infame “Internet Explorer cannot display the webpage” y pues, estaban sin poder continuar con sus trabajos.

Al principio me imaginaba que era algo que tenía que ver con el archivo de hosts y después de investigar un poco más, me dieron la razón.

Lo que debes hacer es usar un editor de texto (como Notepad o Notepad++) y abrir desde el directorio C:\Windows\System32\Drivers\Etc\ un archivo que se llama hosts (sin extensión) y remover la línea que dice algo de localhost. Te puede aparecer así:

::1 localhost

o así

127.0.0.1 www.localhost.com

Ahora nada más graba este archivo otra vez, cuidando que no se anexe la extensión txt (y si se anexa, se la quitas). Parece medio absurdo, pero puede ser que si te ocurre este problema, quizás sea por esto.

Comunidades Virtuales

Gabriel Flores — Thu, 21 May 2009 15:19:00 GMT

De la Facultad de Contaduría, Administración e Informática de la UABC, me invitaron a dar una plática acerca de Comunidades Virtuales en la cual les comenté acerca de como los foros, sitios de redes sociales y otros conforman lo que a todas luces es comunidad que aunque virtuales, llevan un gran sentido de pertenencia y participación, además como la Comunidad .NET Tijuana en particular hace uso de estas herramientas para complementar esta comunidad presencial. Aquí algunas fotos y la presentación misma:

Comunidades Virtuales

View more presentations from Gabriel Flores.

Por cierto, un agradecimiento a Sergio Quijada y su equipo por la invitación.

ADO.NET Entity Framework y llaves foráneas

Gabriel Flores — Thu, 30 Apr 2009 16:37:12 GMT

Es algo muy normal trabajar con tablas que están relacionadas con otras por medio de llaves foráneas. Si has usado ADO.NET Framework para hacer algunas operaciones con la BD y para mostrar datos en una página ASP.NET, quizás te hayas encontrado con el dilema de mostrar los campos relacionados de la tabla externa a la que estás mostrando.

Por ejemplo, tomando como ejemplo la clásica base de datos de Northwind, y teniendo las tablas de Products y Categories, y si definimos nuestro modelo de Entidades de esta forma:

Podemos mostrar en un GridView el contenido de Products haciendo la referencia correspondiente:

        NorthwindModel.NorthwindEntities ne = 
            new NorthwindModel.NorthwindEntities();

        var products = from p in ne.Products
                       select p;

        grdProductos.DataSource = products;
        grdProductos.DataBind();

Pero ¿qué tal si quiero mostrar en el mismo GridView la descripción de la categoría? Basta incluir en la declaración del campo la propiedad Include para que se pueda cargar ese dato.

        NorthwindModel.NorthwindEntities ne = 
            new NorthwindModel.NorthwindEntities();

        var products = from p in ne.Products
                       .Include("Categories")
                       select p;

        grdProductos.DataSource = products;
        grdProductos.DataBind();

Y con esto tenemos acceso a los campos de la segunda tabla para de esa manera mostrar como fuente de datos de alguna columna del grid algún campo. En este caso, con un Template Field hacemos un Bind usando simplemente Categories.Description que sería la manera de ligar desde Products a ese campo:

    <asp:TemplateField HeaderText="Category">
        <EditItemTemplate>
            <asp:TextBox ID="TextBox1" runat="server" 
                Text='<%# Bind("Categories.Description") %>'>
                </asp:TextBox>
        </EditItemTemplate>
        <ItemTemplate>
            <asp:Label ID="Label1" runat="server" 
                Text='<%# Bind("Categories.Description") %>'>
            </asp:Label>
        </ItemTemplate>
    </asp:TemplateField>

Por supuesto que en lugar de esto pudiéramos usar Vistas desde el servidor SQL Server con todos los campos que ocupemos, pero esta sería una de las formas de resolver como mostrar los campos en tablas mediante llaves foráneas usando código de ADO.NET Entity Framework.

Formato de fecha en Gridview

Gabriel Flores — Fri, 03 Apr 2009 22:01:00 GMT

No está de más recordar que cuando tienes un GridView con un campo tipo fecha, puedes definir el formato de la cadena a lo que tú gustes, en lugar de los valores por default de fecha completa:

Para definir el formato de salida de la cadena en campos ligados, es sencillo, usando la propiedad DataFormatString:

<asp:BoundField DataField="Fecha" DataFormatString="{0:d}" />

Pero ¿qué pasa si tenemos TemplateFields, sencillo, usando la misma función Bind donde especificamos en el enlace al campo de datos para agregarle el formato que necesitamos:

<asp:TemplateField HeaderText="Fecha">
  <EditItemTemplate>
    <asp:TextBox ID="TextBox1" runat="server"

             Text='<%# Bind("Fecha","{0:d}") %>'>

    </asp:TextBox>
  </EditItemTemplate>
  <ItemTemplate>
    <asp:Label ID="Label1" runat="server"

              Text='<%# Bind("Fecha","{0:d}") %>'>

     </asp:Label>
  </ItemTemplate>
</asp:TemplateField>

De esta manera podemos mostrar a nuestra conveniencia el formato de los datos que mostramos en un gridview:

Algunas funciones Javascript útiles para ASP.NET (en C#)

Gabriel Flores — Fri, 06 Mar 2009 00:28:00 GMT

Nunca está de más conocer algunas funciones útiles para hacer más efectiva la programación web en ASP.NET, entre los que uso bastante son:

Ventana de Confirmación (Messagebox del lado del cliente)

Muy útil para pedirle confirmación al usuario cuando se va a hacer algún proceso del cual se puede arrepentir, por ejemplo, pedirle confirmación para borrar algún registro. En el botón donde se va a agregar la lógica para hacerlo, se le agrega el detalle para abrir una ventana y pedir confirmación. En el evento Load de la página es un buen lugar para hacerlo:

    protected void Page_Load(object sender, EventArgs e)
    {
         btnEliminar.Attributes.Add("onclick", 
         "return confirm('¿Eliminar registro?');");
    }

Si el usuario presiona Ok, se ejecutará el código para borrar el registro, si no, es como si nunca hubiera tocado el botón.

Mostrar una ventana con tamaño determinado

A veces necesitamos mostrar una ventana extra independiente del área de trabajo del usuario para información, algún proceso pequeño o algo que para demostrar atención no puedes abrir en un nuevo tab o en otra ventana del navegador. De esta forma incluso podemos dimensionar la ventana emergente con el tamaño adecuado para nuestros fines.

    protected void Page_Load(object sender, EventArgs e)
    {
        btnNueva.Attributes.Add("OnClick", 
         "window.open('Nueva.aspx',null,'height=220,width=480');");
    }

A tomar en cuenta es que el usuario puede tener bloqueadas las ventanas emergentes, así que una buena idea es mostrar en algún lado de la aplicación que desactive para tu sitio este bloqueo.

Cerrar una ventana

Para casos como el anterior donde después de abrir una ventana donde se espera generar trabajo pero no se puede confiar o resultaría muy engorroso para el usuario cerrar manualmente la ventana, conviene usar este método. En el ejemplo está en el evento Click de un botón pero bien puede figurar después de terminado alguna función.

    protected void btnCerrar_Click(object sender, EventArgs e)
    {
        Response.Write("<script>window.close();</script>");
    }

Estas son algunas funciones donde es necesario hacer trabajo del lado del cliente para determinado comportamiento, por lo mismo no es para todas las situaciones y eventos posibles. Lo único es preguntarse si son cosas que no se pueden hacer del lado del servidor o que serían más rápidas y sencillas que se hicieran del lado del cliente.

Verifica tus nulos

Gabriel Flores — Wed, 24 Sep 2008 14:29:00 GMT

Es muy sencillo verificar si una variable tiene referencia a null:

if (dFecha == null)

Pero ¿y si los datos que quieres evaluar vienen de una base de datos? Cuando se trata de un campo de tipo fecha no es suficiente evaluarlo contra null, y asignarlo a una variable DateTime te requiere hacer un cast para que te permita usarla, pero si está en null, no te permite hacer esta asignación:

//Si es null el campo, no permite hacer este cast
dFecha = (DateTime)miDataReader["Fecha"];

La solución está en evaluarla contra DBNull, que contiene precisamente el valor null a nivel de base de datos:

if ( miDataReader["Fecha"] == DBNull.Value )

Evaluando de esta forma nuestros campos de la base de datos, podremos tener mejor código y más probado.

Parámetros en aplicaciones

Gabriel Flores — Thu, 17 Jul 2008 20:49:00 GMT

Muchas veces necesitas llamar o recuperar los parámetros en la aplicación en C# que estés desarrollando. Lo más sencillo es usar el Environment.GetCommandLineArgs() que nos regresa un arreglo con los parámetros que están mandándonos.

Lo que es importante tomar en cuenta es que si se está enviando una cadena que contiene espacios, por ello mismo nos coloca cada parámetro en distinta posición del arreglo y sólo es suficiente armando de nuevo ese argumento:

static void Main()
{
   string[] args = Environment.GetCommandLineArgs();
   if (args.GetUpperBound() > 1)
   {
      string sArg = args[1] + " " + args[2] + " " + args[3] + " " + args[4];
   }
}

Visual Studio Express 2008 liberado

Gabriel Flores — Mon, 19 Nov 2007 20:39:00 GMT

Ya están disponibles las versiones Express de Visual C#, Visual Basic .NET, Visual C++ y Visual WebDeveloper 2008. Y tiene de interesante bastantes mejoras que puedes encontrar en Visual Studio 2008 (que también liberó su RTM), como son:

Desarrollo de aplicaciones con WPF
Aplicaciones con SQL Server Compact Edition
LINQ integrado (también con intellisense)
Mayor integración con Popfly
Toolkit de desarrollo P2P para Vista

Developer kit para Facebook

Y mucho más. Descarga la versión que más te guste, aprende lo nuevo y empieza a crear tus mejores aplicaciones.

Gráficas fáciles para web

Gabriel Flores — Tue, 28 Aug 2007 17:20:00 GMT

Una necesidad recurrente en cualquier tipo de proyecto es darle presentación a datos de una manera que rápidamente sea aprovechable y útil para quien toma decisiones. La presentación en gráficas comparativas es algo a lo que ya está acostumbrada la mayoría de las personas aunque para generarlas no siempre se cuenta con la herramienta adecuada.

Carlos Aguilar creó hace unos años un control gratuito para ello, el WebChart. Y usarlo es tan sencillo como ponerlo en tu Toolbox de Visual Studio y arrastrárlo a la página que estás creando. En tu código de la página aparecerá así:

<%@ Page Language="C#" %>
<%@ Register tagPrefix="Web" Namespace="WebChart" Assembly="WebChart" %>
<%@ Import Namespace="System.Drawing" %>
<html>
<head><title>WebChart Sample</title></head>
<body>
<Web:ChartControl Width="500" Height="350" id="ChartControl1" runat="Server" />
</body>
</html>

Para darle funcionalidad es tan simple como cargar un dataset:

    //en CrearDataSet está la funcionalidad de conexión a BD
    DataSet dsPrioridades = CrearDataSet();

    PieChart priorityChart = new PieChart();
    priorityChart.DataSource = dsPrioridades.Tables[0].DefaultView;

Y asignarle cuales campos comprenderán tu eje Y y tu eje X, además de cargarlo en el control:

    priorityChart.DataXValueField = "Prioridad";
    priorityChart.DataYValueField = "Proyectos";
    priorityChart.DataBind();
    ChartControl1.Charts.Add(priorityChart);
    ChartControl1.RedrawChart();

El resultado es una buena gráfica:

En la misma página de WebChart puedes descargar el archivo de ayuda que te permitirá saber como manipular todas las propiedades y métodos que tiene para lograr resultados más acordes a lo que necesitas. También hay bastantes ejemplos y código de mejoras a las gráficas que puedes generar.

Technorati tags: webchart, asp.net, c#

.NET Framework 3.0

Gabriel Flores — Tue, 17 Apr 2007 19:56:29 GMT

Esta versión se incorpora al .NET Framework 2.0 y combina este marco de trabajo con nuevas tecnologías para crear:

Experiencias de usuario visualmente atractivas
Comunicación interoperable confiable
Modelos de procesos de negocio

Siendo una evolución del .NET Framework, proveé una experiencia de desarrollo consistente y familiar para millones de desarrolladores que programan en este ambiente.

Para lograr estos objetivos, se tiene:

Windows Presentation Foundation (WPF), provee clases para construir aplicaciones cliente de siguiente generación que combinan interfaz de usuario, documentos y medios.

Windows Workflow Foundation (WF), con un modelo de programación, motor y herramientas para construir aplicaciones habilitadas para flujos de trabajo que modelan procesos de negocio.

Windows Communication Foundation (WCF), un modelo de pogramación unificado para construir aplicaciones orientados a servicios.

Microsoft Windows Cardspace (antes InfoCard), tecnología para simplificar y mejorar la seguridad al acceder a recursos y compartir información personal de identidad en línea.

Espera en las próximas entradas un poco más de detalle de estos componentes del .NET Framework 3.0.

Referencias para .NET 3.0

Gabriel Flores — Thu, 22 Mar 2007 20:53:00 GMT

Algunas ligas útiles para desarrollo de aplicaciones con .NET 3.0:

Para empezar a desarrollar:

Ejemplos, demos y código:

Webcast: Building a Sudoku Game Using Windows Presentation Foundation

ASP.NET AJAX Versión 1.0 disponible ya

Gabriel Flores — Fri, 26 Jan 2007 23:35:28 GMT

Ya está disponible la versión no beta de ASP.NET Ajax que en su versión 1 nos da componentes Ajax reusables, soporte en los navegadores más populares y sobre todo, que puedes extender sitios web actuales con funcionalidades modernas de manera muy sencilla directamente desde Visual Studio 2005 . El Ajax Control Toolkit tiene nuevos controles como calendario, textbox con máscara, pestañas, autocompletado y otros ya populares como el del acordeón, menú flotante, calificación y dropdown en cascada que puedes ver en vivo en el sitio web de ASP.NET Ajax Control Toolkit.

En español, ya puedes acceder a webcasts pregrabados para que empieces a generar tus aplicaciones web de manera muy rápida y sencilla. Sólo tienes que registrarte en el enlace del webcast que más te interese:

Y para empezar ya, descárgalo ahora mismo y puedes irte familiarizando con los controles y ejecutar las aplicaciones de muestra que ASP.NET AJAX te ofrece.

Parámetros opcionales en C#

Gabriel Flores — Sun, 24 Dec 2006 16:22:00 GMT

Un manejo bastante fácil de parámetros opcionales en C# es usando la palabra reservada params, así:

    public string concatena(params string[] cadenas)
    {
        string sResult = "";
        foreach (string str in cadenas)
        {
            sResult = sResult + str + " ";
        }
        return sResult;
    }

Y se usaría tan sencillo como esto:

Label1.Text = concatena("uno");

Label1.Text = concatena("primero", "segundo", "tercero");

Sin embargo, se debe tomar en cuenta que esto limita el Intellisense en el proyecto, ya que no se tiene idea de los parámetros que se están pasando a la función. La recomendación políticamente correcta (en términos de POO al menos), es usar funciones con parámetros sobrecargados según se necesiten. Por ejemplo:

    static string concatena(string str)
    {
        return str;
    }

    static string concatena(string str1, string str2)
    {
        return str1 + " " + str2;
    }

    static string concatena(string str1, string str2, string str3)
    {
        return str1 + " " + str2 + " " + str3;
    }

Aunque, claro está, en ejemplos tan sencillos como este nos veremos tentados a usar params, es bueno tomar en cuenta alternativas propias del lenguaje. Cuando escalemos implementaciones, nos agradeceremos a nosotros mismos seguir las reglas del juego apropiadamente.

Más info:

Using Params Keyword

Optional Parameters

How to read optional parameters

Technorati tags: C#, parámetros, code, programación, código, programming

Nuevo Atlas Control Toolkit

Gabriel Flores — Sat, 12 Aug 2006 20:00:00 GMT

El toolkit del que he hablado en artículos anteriores ha sido actualizado con algunas mejoras, algunas correciones y sobre todo, nuevos controles:

DynamicPopulate: es un extender para llenar el contenido de un control con el resultado de un webservice o un método.
FilteredTextBox: un extender para el TextBox que valida que no se inserten caracteres inválidos.
PagingBulletedList: para agregar opciones de páginado y ordenamiento para el control BulletedList.
PasswordStrenght: permite ver que nivel de seguridad tiene el password que le tecleas, como en el password de Hotmail.
Rating: para seleccionar el número de estrellas de calificación que el usuario elija de manera muy dinámica.

Todos ellos vienen mejor explicados en el sitio del Atlas Control Toolkit y lo puedes descargar ya mismo de CodePlex.

Atlas para ASP.NET

Gabriel Flores — Sun, 28 May 2006 20:07:00 GMT

A fin de cuentas, lo que importa es lo de adentro, ¿cierto? Pues es correcto, pero si le puedes brindar al usuario una mejor experiencia de uso, mejor usabilidad y más productividad, hace de tu solución de software algo más que sólo la solución, la hace querer ser usada, la hace imprescindible.

Una forma de hacerlo es con Ajax, tan de moda ahorita. ¿De qué se trata? En una página de internet la interacción usuario -> sitio se daba con intercambios de datos entre el navegador del usuario y el servidor. Botones, navegación entre páginas y otros complementos hacían que este ir y venir entre una máquina y otra una experiencia práctica para los fines de las aplicaciones hechas para esta plataforma, pero no precisamente lo más apegado a una usabilidad deseable.

Se dejan venir aplicaciones Web 2.0 como gMail, con todos esos componentes visuales que no están sólo de adorno, sino que realmente hacen un tipo de trabajo y al parecer ¡sin tener que esperar a una respuesta del servidor! Se pueden arrastrar objetos en la página web, colapsar paneles, calcular al vuelo datos con un botón que no requiere esperar al servidor para completarse.

Y son cosas sumamente simples, cosas al estilo ¿porqué no se me había ocurrido antes? Pero súmamente útiles. Como este ejemplo del CascadingDropDown. ¿Porqué esperar varias vueltas al servidor si sólo son datos auxiliares que se complementan a otros para dar un resultado? En ese ejemplo, la meta es seleccionar un auto, se puede elegir de la marca, modelo y color. En lugar de mostrar 3 ListBox con todos los modelos, marcas y colores disponibles, mejor hacerlo un poco más dinámico, pero ojo, sin tener que afectar la usabilidad deseada (y la paciencia) del usuario. Selecciono primero una marca y se me filtran para esa marca el modelo. Lo mismo pasa al seleccionar el modelo y se me filtran los colores disponibles. La belleza de esto es que incluso se pueden poblar los comboboxes con datos extraídos de una base de datos, por lo que las posibilidades son ilimitadas.

Una característica de estos controles y este marco de trabajo Atlas para ASP.NET, es que te permite crear tus propios extenders para los controles que actualmente uses. En el ejemplo, se está usando un contorl ComboBox y se agrega un extender para darle esa usabilidad à la Ajax de una manera muy sencilla. Ahí en el Atlas Control Toolkit encontrarás varios ya hechos con explicaciones de como empezar a usarlos desde ya en tus aplicaciones web y hacerlas unas joyas de usabilidad y productivada.

Algunas aplicaciones llamadas Web 2.0:

Writely (por cierto hecho con .NET)
gMail
netvibes
Live