sábado, 18 de octubre de 2008

Silverlight 2 ya es realidad

La versión final de Silverlight 2 ya está disponible. Para comenzar a desarrollar necesitan instalar:

  • Visual Studio SP1 ó Visual Web Designer Express SP1

  • Silverlight Tools For Visual Studio

  • Microsoft Blend 2 Service Pack 1

Estas herramientas están disponibles para descargarlas aquí. También van a encontrar material de capacitación en la misma página.


sábado, 27 de septiembre de 2008

Silverlight 2 Release Candidate 0

Ya está disponible el Release Candidate 0 de Silverlight 2.
Se trata de un release exclusivo para desarrolladores, por lo que todavía no vamos a ver páginas que lo utilicen.
Para los que quieran más información pueden ver los blogs de Scott Guthrie y Jesse Liberty (quien va a estar publicando un artículo diario comentando las novedades y cambios con respecto a la Beta 2).
Seguramente en poco tiempo vamos a estar viendo la versión final. Mientras tanto, a probarlo!!!

jueves, 25 de septiembre de 2008

Fotos 2º Presentacion

El Viernes 12 de Septiembre se ralizo una nueva presentacion, aqui hay algunas fotos...



A seguir por mas...

viernes, 19 de septiembre de 2008

CodeCamp 2008

Hola a todos.
Aprovecho este espacio para invitarlos al CodeCamp 2008.
El mismo se realizará el día sábado 4 de Octubre en la Ciudad de Buenos Aires, en el Auditorio de la Universidad Abierta Interamericana.

jueves, 24 de julio de 2008

Primer encuentro de Desarrolladores .NET de Jujuy: Confirmado

El día 22 de agosto en el auditorio de la UCSE - DASS (Lavalle 333 - San Salvador de Jujuy) de 17 a 21 hs. realizaremos el Primer Encuentro de Desarrolladores .NET de Jujuy.
Este es un encuentro gratuito organizado en conjunto por las Células Académicas Jujuy ASP NET y THE ASP-BERRIES.
Los temas a tratar y los oradores son:


  • Diego Ortega (Líder THE ASP-BERRIES) y Octavio Daniel Coro (Profesor THE ASP-BERRIES) - AJAX: Fundamentos teóricos e introducción. La necesidad de incorporar la tecnología al desarrollo de Páginas Web para una mejor interacción con el usuario. Herramientas disponibles para ASP.NET. Ejemplos prácticos. Modalidad: PPT + demo. 45 min.

  • Guillermo Bellmann (Líder Jujuy ASP NET) - LINQ: Evolución del acceso a datos. Integración en el lenguaje. Simplificando y unificando el acceso a cualquier tipo de datos. Modalidad: PPT + demo. 45 min.

  • Federico Medrano (Vicelíder Jujuy ASP NET) y Lucas Bolívar (Miembro Jujuy ASP NET) - ASP.NET MVC: Implementación del patrón de diseño para ASP.NET. Descripción y esquema de funcionamiento. Ventajas aportadas. Integrando el framework MVC al desarrollo en Visual Studio 2008. Modalidad: PPT + demo. 45 min.

  • Antonio Jarma (Vicelíder THE ASP-BERRIES) - Reflection: Fundamentos teóricos e importancia. Potencialidad de Reflection en el desarrolo de aplicaciones. Aplicación del mismo en la plataforma .NET. Ejemplos prácticos y desarrollo de herramientas. Modalidad: PPT + demo. 45 min.

  • Elvio Velázquez (Miembro THE ASP-BERRIES) - Interfaces personalizadas con Web Parts, conceptos desarrollo y configuración, comunicacion y persistencia. Ejemplos Prácticos. Modalidad: PPT + demo. 45 min.



Todos los que quieran participar están invitados, el link para inscribirse es el siguiente:
http://msevents.microsoft.com/CUI/InviteOnly.aspx?EventID=96-91-12-BF-BE-0F-70-14-A4-86-D0-5C-78-39-28-90&Culture=es-AR
Va a haber regalos y sorteos.
Los esperamos!!

jueves, 17 de julio de 2008

Primer encuentro de Desarrolladores .NET de Jujuy

El día 22 de agosto vamos a realizar un pequeño encuentro junto con los chicos de THE ASP-BERRIES.
Los temas que vamos a tratar son: AJAX, LINQ, Reflection, WebParts y ASP.NET MVC.
Al detalle de las charlas y el link para inscribirse los publico en breve.
Los esperamos!

Ya somos célula activa!

Hola a todos.
El martes 15 de julio me comunicaron que ya estamos en estado de Célula Activa!!
Felicidades a todos los miembros del equipo por el laburo que se viene haciendo.
Espero que se siga con estas ganas!

domingo, 6 de julio de 2008

Hojas de Estilo Dinámicas

Veamos un ejemplo de cómo el usuario final puede cambiar la hoja de estilo en tiempo de ejecución.

La idea es que la persona que está navegando en nuestro sitio pueda cambiar la presentación, al menos algunos aspectos de ella: colores o tamaño de letras (se puede hacer más pero este ejemplo solo muestra esa parte).

Esta es la página que tiene tres áreas o contenedores donde pondremos lo que deseamos motrar.

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

<!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>CSS Style Sheet Change Demo</title>
<link id="cssLink" runat="server" href="Stylesheet1.css" rel="stylesheet" type="text/css" />
</head>
<body>
<form id="form1" runat="server">
<asp:ScriptManager ID="ScriptManager1" runat="server" />
<div style="float:right">
Estilos Disponibles
&nbsp;
<asp:DropDownList ID="ddlStyles" runat="server" AutoPostBack="True"
onselectedindexchanged="ddlStyles_SelectedIndexChanged">
<asp:ListItem Value="Stylesheet1.css">Verde y Azul</asp:ListItem>
<asp:ListItem Value="Stylesheet2.css">Suave</asp:ListItem>
</asp:DropDownList>
</div>
<div>
<div class="arriba">
Esto esta en el contenedor cuya clase es arriba
</div>
<div class="izquierda">
Esto esta en el contenedor cuya clase es izquierda
</div>
<div class="derecha">
Esto esta en el contenedor cuya clase es derecha
</div>
</div>
</form>
</body>
</html>


Observen que hay un drop down list, en el que se cuenta con dos entradas para poder selecciónar las hojas de estilo.

Es importante destacar que al link para referenciar la hoja de estilo le pusimos un id y le decimos que se ejecuta en el lado del servidor. Esto se conoce como convertir un control HTML en un control HTML de lado del servidor, nos permite manipular las propiedades del control cuando se procesa la página.

Bién ahora veamos el código asociado a la página:


using System;

namespace CSSStyleChangeDemo
{
public partial class _Default : System.Web.UI.Page
{
/// <summary>
/// Se dispara antes de renderizar la página
/// </summary>
/// <param name="sender">Objeto que ejecuta el evento</param>
/// <param name="e">Argumentos del evento</param>
protected void Page_Prerender(object sender, EventArgs e)
{
if (Session["CSSStyle"] == null)
{
Session["CSSStyle"] = cssLink.Href;
}
else
{
cssLink.Href = (string) Session["CSSStyle"];
}
}

/// <summary>
/// Se dispara cuando se carga la página
/// </summary>
/// <param name="sender">Objeto que ejecuta el evento</param>
/// <param name="e">Argumentos del evento</param>
protected void Page_Load(object sender, EventArgs e)
{

}

/// <summary>
/// Se dispara cuando se cambia la selección en el drop down list
/// </summary>
/// <param name="sender">Objeto que ejecuta el evento</param>
/// <param name="e">Argumentos del evento</param>
protected void ddlStyles_SelectedIndexChanged(object sender, EventArgs e)
{
if (ddlStyles.SelectedIndex != -1)
{
string cssFile = ddlStyles.SelectedValue;
Session["CSSStyle"] = cssFile;
}
}
}
}
En este caso es necesario atrapar el evento Prerender de la página, es en ese momento en el que se debe ajustar los valores de hojas de estilo (incluso master page).

Tengan en cuenta que utilizamos una variable de "session" para guardar el nombre de la hoja de estilo que está vigente. En realidad esto tendría que estar en algún lugar por cada persona que visita el sitio, de esa forma "recordaríamos" como lo quiere ver cada visitante, eso se puede hacer con una Cookie, pero es tema de otra publicación.

Bueno, los estilos son los siguientes:

Stylesheet1.css

body
{
}
.arriba {
left: 0px;
width: 100%;
height: 80px;
font-size: 14px;
text-align: center;
background: Green;
}
.izquierda {
float: left;
left: 0;
width: 30%;
min-height: 500px;
font-size: 10px;
background: Blue;
color: White;
}
.derecha {
float: right;
width: 68%;
min-height: 500px;
font-size: 12px;
background: White;
border-left-style: double;
border-left: 2px;
}

Stylesheet2.css

body
{
}
.arriba {
left: 0px;
width: 100%;
height: 80px;
font-size: 14px;
text-align: center;
background: Gray;
}
.izquierda {
float: left;
left: 0;
width: 30%;
min-height: 500px;
font-size: 10px;
background: Silver;
color: White;
}
.derecha {
float: right;
width: 68%;
min-height: 500px;
font-size: 12px;
background: Silver;
border-left-style: solid;
border-left: 2px;
}

Bueno espero que les sirva, al menos pueden comenzar con estas pocas líneas y armar un sitio totalmente configurable por el visitante.

Nota: estoy utilizando el Source Code Formatter que hicieron Guille y Fede (ta espectacular !!!)

miércoles, 2 de julio de 2008

Definiciones para el Proyecto

Después de pensar, discutir y jugar con el prototipo del proyecto ya tenemos algunas definiciones.



Definiciones


No perdemos de vista los objetivos Aprender, Practicar y Comunicar. En base a ello definimos que este motor de blog no es para competir con los ya existentes, en consecuencia las caracteríscitas básicas que esperamos del proyecto son las siguientes:


  1. Presentación configurable o parametrizable. Con esto lo que pretendemos es que el administrador (dueño) del blog pueda configurar la presentación del mismo, para una segunda etapa estamos pensando en permitir que los lectores del blog puedan organizar ciertos componentes que el dueño pone a su disposición. Para realizar esto vamos a utilizar hojas de estilo, skins, themes, master pages y webparts.

  2. Satisfacción del usuario final. Esta definición impone la utilización de la última tecnología disponible con lo que nos referimos a AJAX y Silverlight. De hecho las herramientas (lenguajes de desarrollo) son diferentes, sin embargo existe un grado de compatibilidad en la arquitectura que se utiliza; en la medida que se pueda incorporaremos ambas tecnologías.

  3. Persistencia en un motor de base de datos. Obviamente uno de Microsoft, en relación con esta definición, pretendemos utilizar LINQ. También se está manejando la idea de contar con diferentes proveedores de datos, de ese modo podremos organizar la persistencia de diferentes maneras.

  4. Redes sociales. Con esto apuntamos a la web semántica y toda la interacción entre aplicaciones que existe actualmente; con esta definición nos vamos a meter en WebServices tanto para proveerlos como para consumirlos.




Especificaciones Generales de Desarrollo


Obviamente el motor de un blog se ejecuta en un servidor web, en consecuencia los diferentes componentes deben probarse en esas condiciones; esto implica que los desarrolladores deben instalar Internet Information Server - IIS, mejor si podemos probarlo en diferentes versiones; habilitar un directorio virtual apuntando al directorio donde se encuentra el sitio (local) donde ejecutamos la aplicación. Más adelante veremos la manera de contar con un lugar en algun servidor de la Web.


Respetar las capas de desarrollo, se debe lograr que sean diferentes capas las que realicen o logren los objetivos del desarrollo. La cantidad de capas por lo menos deben ser tres: Presentacion (View), Lógica (Control) y Model (Modelo de Datos). Pueden haber más capas, por ejemplo el modelo de datos puede implementar una capa de clases de negocio, la que utiliza otra capa de acceso a datos la que a su vez puede utilizar otras de acuerdo al tipo de persistencia que realice. El esquema de codificación que nos facilita ASP NET ya ofrece dos niveles el de la página o control de la web y el de código asociado, sin embargo se debe estar atentos a las posibilidades de encapsular propiedades y comportamiento común ya sea en controles de usuario y/o clase utilitarias.


La presentación se debe lograr siempre por medio de estilos o skins, lo que nos permitirá camnbiarlos sin tener que alterar el resto de las capas. Del mismo modo la lógica de control no debe interferir con los mecanismos de persistencia ni con las condiciones de presentación.


Si hace falta se crean tantos proyectos como sean necesarios, algunos serán para testear aspectos del desarrollo o para aprender algún concepto, otros serán componentes o módulos de la aplicación.


La codificación debe ser documentada, es obligatorio utilizar el documentador en línea que nos facilita el Visual Studio, es muy facil darle a las tres barras (///) en la línea anterior de cada método o propiedad e incorporar los comentarios correspondientes. La compilación se realizara en el mayor nivel de control, de manera que luego se puede revisar que falta.


El seguimiento del código se hace de a poco, no es bueno esconderse durante tres semanas escribiendo código y luego subirlo al servidor de versiones arruinando lo que hicieron todos los demás. La modalidad de trabajo es concentrarse en una o dos partes concretas, codificar y compilar hasta que no de errores y subir al servidior de manera que se genere un "code set" controlable; de este modo el resto de los desarrolladores pueden actualizar lo que están haciendo con esa pequeña porción y además controlar que no interfiera con su parte de trabajo.


Para minimizar los conflictos de versionado se debe aclarár quiénes trabajan con que aspectos del desarrollo, a veces es inevitable trabajar sobre una misma clases, implementando diferentes comportamientos de manera que en realidad no hay conflicto; para evitar esta situación es importante mantener las porciones de código donde están, no es bueno reorganizar el codigo porque nos gusta que los metodos estén despues de las propiedades o al reves; si esta situación se realiza es porque hace falta hacerlo corrigiendo alguna situación caso contrario no se hace.


Siempre es bueno hacer una copia de seguridad de lo que tenemos en nuestro equipo antes de bajarse (update) el último conjunto de código. Por supuesto antes de subir (commit) se debe hacer un update para estar seguros que lo que vamos a subir se hace sobre el último conjunto de cambios, de otro modo el conflito se puede producir en el servidor y será un laborioso resolverlo. Hacerlo en nuestro equipo es mucho más facil dado que podemos tomar deciciones cuando el programa de versionado no sabe que hacer.



Filosofía de Desarrollo


Desde el punto de vista del desarrollo de software, la simplicidad no es lo contrario de la complejidad.

Las porciones de código simples son faciles de entender, mantener, extender y reutilizar; y entre todas completan una aplicación compleja, en consecuencia para realizar este proyecto que es del tipo EEP - Eaten an Elephant by Parts, vamos a utilizar la filosofía KISS - Keep It Simple and Stupid.

lunes, 30 de junio de 2008

Primer proyecto finalizado!

Ya está la Versión 1.0 del Formateador de código fuente que vamos a usar tanto en el motor de blog que estamos desarrollando junto con THE ASP-BERRIES como para publicar los ejemplos acá en el blog.
La idea surgió de la incomodidad que presenta formatear el código fuente para que se vea como corresponde (como en el editor de Visual Studio 2008).
Formatea código C#, JavaScript, VisualBasic y ASPX/HTML/XML (también soporta JavaScript entre <script> y </script> y C# entre <% y %> en el ASPX).
El código fuente (incluye una página de prueba) y la versión 1.0 están en CodePlex, en el proyecto Source Code Formatter.
Enjoy!!

domingo, 29 de junio de 2008

Tratamiento de Cadenas en C#

El lenguaje C#, al ser un derivado del lenguaje C, tiene ciertos caracteres que tienen un significado particular, y al ser incluidos en una cadena de texto deben ir precedidos por el caracter de escape ("\").
Por ejemplo: para escribir "C:\" en una cadena deberemos escribir "C:\\".
Pero, qué pasa si queremos escribir una cadena como la cadena de conexión del ejemplo de Conexión a la base de Datos de Diego?
Puede resultar muy engorroso tener que escribir "\\" por cada subdirectorio. Lo que además resulta complicado de leer. (Ni hablar si se está escribiendo una expresión regular!!!)
Para esto existe una solución!!!
Se debe anteponer a la cadena el símbolo "@", para que la cadena sea tomada tal como está (internamente el compilador tendrá que poner todos los caracteres de escape que necesite).
Ejemplo:
La cadena de conexion original tenía lo siguiente:

string strConexion = "Data Source=.\\SQLEXPRESS;AttachDbFilename=E:\\sql\\MSSQL.1\\MSSQL\\Data\\Celula.mdf;Inte...";

Para que quede más legible la podemos reescribir de la siguiente manera:

string strConexion = @"Data Source=.\SQLEXPRESS;AttachDbFilename=E:\sql\MSSQL.1\MSSQL\Data\Celula.mdf;Inte...";

miércoles, 25 de junio de 2008

2 x 1

En estos poco más de dos meses que llevamos juntos logramos que se una gente a nuestra célula. Tanto es así que llegó un momento que había gente que estaba colaborando pero no podía inscribirse como un miembro más ya que habíamos alcanzado el límite de 10 personas.
Viendo esta situación es que la semana pasada decidimos dividirnos en dos células. Ambas trabajando, por ahora, sobre el mismo proyecto.
El nombre de la nueva célula es THE ASP-BERRIES, su líder es Diego y el blog está en http://aspberries.blogspot.com/.
En nombre de la gente que quedó de este lado, les deseo muchos éxitos!!!
Cuenten con todos nosotros para lo que necesiten.

jueves, 19 de junio de 2008

Memoria y Performance

C# es el lenguaje de programación que actualmente se utiliza en el desarrollo de aplicaciones ASP.NET, una de sus principales ventajas es que cuenta con "recolector de basura" o Garbage Collector.
Esto es un proceso que revisa la memoria buscando aquellas asignaciones que los programadores ya no utilizamos.
Por ejemplo: si en alguna parte de la aplicación tenemos algo como

1: public void AlgunMetodo()
2: {
3: AlgunaClase miObjeto = new AlgunaClase();
4: // hacemos lo que tenemos que hacer con el objeto
5: ...
6: }


Cuando la ejecución del metodo finaliza, la memoria utilizada por "miObjeto" pasa a ser inaccesible dado que no tenemos la referencia a esa zona de memoria. En algún momento el Garbage Collector encontrará esa zona de memoria y se dará cuenta que ya no se puede acceder desde la aplicación y la devolvera al sistema de manera que se pueda volver a utilizar.

Antes de la existencia del Garbage Collector, los programadores teníamos que tener mucho cuidado y liberar la memoria antes de perder la referencia correspondiente.

El problema es que el Garbage Collector comienza a funcionar cuando se ha consumido el 90% de la memoria !!!
Esto significa que en ese punto ya estamos hasta las manos, y como si fuera poco se agrega un proceso al pool de ejecución que baja la performance de forma notable.

La solución a esta situación es implementar la interfaz IDisposable.

Esta interfaz obliga a las clases que la implementan a codificar el método Dispose(), en el ejemplo anterior si en la definición de AlgunaClase se implementa la interfaz, podríamos hacer lo siguiente:



1: public void AlgunMetodo()
2: {
3: AlgunaClase miObjeto = new AlgunaClase();
4: // hacemos lo que tenemos que hacer con el objeto
5: miObjeto.Dispose();
6: }


Con eso ya solucionamos el problema, dado que el metodo Dispose() devuelve la memoria ocupada sin tener que llegar al 90%.
El problema que tenemos ahora es que debemos acordarnos de invocar al metodo para todos los objetos que utilizamos, es para volverse locos.

Entonces veamos cómo hay que implementar IDispose para una clase:


1: public class AlgunaClase : IDisposable
2: {
3: // Este es el constructor de la clase
4: public AlgunaClase()
5: {
6: // se crea un arreglo de 100 elementos
7: // hay que considerar que _Datos es una
8: // referencia a un arreglo creado en el
9: // momento en que se crea una instancia
10: // de esta clase
11: _Datos = new OtraClase[100];
12: }
13: private OtraClase[] _Datos;
14:
15: // Este es el destructor o finalize de
16: // la clase, se invoca automáticamente
17: // cuando un objeto es destruido.
18: // Esto ocurre cuando se sale del ámbito
19: // de existencia del objeto.
20: public ~AlgunaClase()
21: {
22: // Invoca a Dispose, la sobrecarga que
23: // utiliza argumento para liberar los
24: // recursos propios de la instancia
25: // en este ejemplo es _Datos pero no
26: // libera la memoria asignada al arreglo
27: Dispose(false);
28: }
29:
30: // Aquí va lo que esta clase necesita
31: ...
32:
33: // Este es el método que debe implmentarse
34: // para cumplir con la interfaz
35: public void Dispose()
36: {
37: // En este caso se invoca el metodo con
38: // un parametro que obliga a liberar los
39: // recursos consumidos internamente en la
40: // instancia.
41: Dispose(true);
42: // Con esto se le avisa al Garbage Collector
43: // que no debe hacer nada con esta instancia
44: GC.SuppressFinalize(this);
45: }
46:
47: // Este campo se utiliza para indicar que una
48: // instancia de esta clase ya ejecutó el Dispose
49: private bool _IsDisposed = false;
50:
51: // Este metodo es el que realmente libera la
52: // memoria del objeto cuando el argumento es
53: // verdadero, se liberan los recursos consumidos
54: // dentro del objeto, como ser otro objeto creado
55: // con el operador new.
56: // cuando el argumento es falso, solamente se
57: // liberan recursos no administrados.
58: protected virtual void Dispose(bool disposing)
59: {
60: if (!_IsDisposed)
61: {
62: if (disposing)
63: {
64: // Aquí se trabaja con los recursos administrados
65: // se debe liberar cada uno de los elementos de la
66: // otra clase, se asume que OtraClase también
67: // implementa un metodo Dispose.
68: if (_Datos != null)
69: {
70: foreach(OtraClase o in _Datos)
71: {
72: o.Dispose();
73: }
74: // la referencia _Datos se libera cuando la
75: // instancia es destruida.
76: }
77: }
78: // Aquí se trabaja con los recursos no administrados
79: // como ser una handler a un archivo abierto.
80: }
81: // Finalmente indicamos que ya se hizo el Dispose.
82: this._IsDisposed = true;
83: }
84: }


Observesé que cuando una instancia de AlgunaClase se destruye no se libera la memoria asignada en el arreglo de objetos de OtraClase, esto se puede solucionar invocando al metodo protegido con un parámetro true.

Lo que ocurre es que el diseñador de clases debe analizar mediante algún diagrama de secuencias cómo se utilizan las instancias. En este caso, el destructor está pensado para liberar solo los campos internos de la clase y no los recursos creados internamente; esto es así porque se piensa utilizar las instancias en un bloque using, como se muestra a continuación:

1: using(AlgunaClase miObjeto = new AlgunaClase())
2: {
3: // Hacer lo que se tenga que hacer
4: }


Cuando se codifica de este modo, el compilador genera el siguiente código:

1: AlgunaClase miObjeto = new AlgunaClase();
2: try
3: {
4: // Hacer lo que se tenga que hacer
5: }
6: finally
7: {
8: if (miObjeto != null)
9: miObjeto.Dispose();
10: }


Con lo que se asegura la liberación de los recursos creados internamente en la instancia dado que el método público Dispose invoca al metodo protegido con el argumento true.

Por supuesto es mucho más cómodo utilizar la sentencia using, dejando que el compilador haga su trabajo.

Finalmente me gustaría comentar que tampoco es cuestión de poner código como este para todas las clases que una aplicación necesita, siempre hace falta un mínimo análisis de que es lo que se va a hacer y cómo se hara.

La información sobre todo estó la encontré en MSDN, incluso pueden ver un ejemplo para clases derivadas.

viernes, 13 de junio de 2008

Silverlight 2 Beta 2

Ya está disponible la Beta 2 de Silverlight 2.
Los links para la descarga de las herramientas y documentación en el blog de Ivana.
A probarlo!!!

viernes, 6 de junio de 2008

Cadenas en .NET


Las cadenas del tipo System.String en .NET son inmutables. Esto quiere decir que cualquier cambio a una cadena provoca que el entorno de ejecución cree una nueva cadena y abandone la vieja. Esto es invisible, y muchos programadores se podrán asombrar al aprender que el siguiente código almacena cuatro nuevas cadenas en la memoria:


string s;

s = "Uno"; // "Uno"
s += " Dos"; // "Uno Dos"
s += " Tres"; // "Uno Dos Tres"
s += " Cuatro"; // "Uno Dos Tres Cuatro"
Console.WriteLine(s);

Sólo la última cadena tiene una referencia, las demás serán desechadas en el proceso de recolección de basura. Evitar este tipo de cadenas temporales ayuda a evitar recolección de basura innecesaria, lo que mejora la performance. Existen varias maneras de evitar las cadenas temporales:

  • Usar los métodos Concat, Join, o Format de la clase String para unir múltiples elementos en una sola declaración.

  • Usar la clase StringBuilder para crear cadenas dinámicas (mutables).


El uso de la clase StringBuilder es la solución más flexible. El siguiente código muesta el uso de la clase StringBuilder:


System.Text.StringBuilder sb = new System.Text.StringBuilder(30);
sb.Append("Uno"); // Construir la cadena
sb.Append(" Dos");
sb.Append(" Tres");
sb.Append(" Cuatro");
string s = sb.ToString(); // Copiar el resultado en la cadena
Console.WriteLine(s);

lunes, 2 de junio de 2008

Prototipo de Administración

Ya tenemos el prototipo que nos permitirá explorar las alternativas de la administración del motor de blog.

Contamos con un editor de publicaciones el TinyMCE, que por ahora está con todas las opciones; hay que revisar eso y definir que opciones quedan, probablemente haga falta dos o tres variantes.
En la página oficial de TinyMCE se puede hallar un proyecto que implementa una interfaz o control que permite utilizar el editor, por ahora me pareció más cómodo utilizarlo directamente sin embargo ya estoy viendo que al incorporar más de un textarea en la misma página se duplicará todo el código en javascritp.

Hay un prototipo de clase base para la mayoría de los objetos (post, páginas, comentarios), se debe revisar los estandares de WeblogAPI y RSS para ver que más hace falta.

En el prototipo se está almacenando las páginas en App_Data/Pages en formato XML, incorpore una clase utilitaria que implementa extensiones vean este post sobre ese tema. Desde luego la persistencia se hará en una base de datos, lo que pasa es que esto es más rapido para probar la interfáz y lógica.
Cuidado, si van a probar el sitio con IIS deben asignar derechos de escritura en esa carpeta.


Bueno ahora hay que armar un prototipo de como funcionaría el motor de blog para los lectores.

jueves, 29 de mayo de 2008

Primeros Pasos

Mientras definimos la funcionalidad del motor de blog, estuve incorporando cuestiones básicas en el proyecto.

En la solución hay un proyecto MVC, está como la crea el Visual Studio, todavía no me animo con esto; ya le vamos a meter las garras.

Estuve trabajando sobre un sitio web con AJAX al que incorporé lo necesario para crear usuarios y grupos. Copie de MiniCommerce (dashCommerce) un poco de código que modifiqué para poder utilizarlo.

También está un proyecto de clases que vamos a utilizar de modo global. Justamente en este proyecto está la clase base para las páginas de administración ahí puse unos métodos para mostrar mensajes tipo gmail (sorry Microsoft); pero todavía tengo algunos problemas, a ver si alguien puede revisar esto.

miércoles, 28 de mayo de 2008

Error en la instalación de Visual Studio 2008

Para todos aquellos que recibieron un error en la instalación de Visual Studio 2008 diciendo que no podían continuar con la instalación, parecido al de la imagen:



Seguramente ya se rompieron la cabeza tratando de solucionarlo, así que acá va la solución:

El problema es causado por el paquete InfoPath MUI 2007 (Se instala si instalaron Office 2007)
Lo que hay que hacer es ir a Inicio > Ejecutar y colocar lo siguiente:

msiexec /x {30120000-0044-0C0A-0000-0000000FF1CE}

Con esto se desinstalará el paquete que está causando el problema y van a poder instalar Visual Studio 2008 sin problemas.

domingo, 25 de mayo de 2008

El Proyecto

Despues de darle vueltas al asunto buscando un tema que nos permita aprender y practicar diferentes aspectos de las actuales tecnologías decidimos realizar un motor de blog.

Silverlight y AJAX son aspectos que nos interesan, por eso vamos a intentar que el motor de blog pueda intercambiar la interfaz de usuario.

Otra cuestión que nos llama la atención es el modelo de desarrollo MVC (Model View Controller) de manera que vamos a probar este framework.

Para manipular los datos utilizaremos LINQ.

En principio vamos a plantear una aplicación que mantega dos interfaces de usuarios para el mísmo modelo de datos y lógica de negocio.

El proyecto se puede hallar en CodePlex bajo el nombre de An Other Blog.

Por ahora estamos deciendo sobre la funcionalidad que incorporaremos al motor de blog; en cuanto esté lista se dará a conocer.

viernes, 23 de mayo de 2008

Objetivos de la célula

Los objetivos de la célula Jujuy ASP NET son: Aprender, Practicar y Comunicar las tecnologías de desarrollo de software.

Encontramos en Microsoft Net Cell 2.0 un espacio donde desarrollar estas inquietudes, obviamente vamos a trabajar sobre las tecnologías que nos ofrece el gigante azul, sin embargo también veremos otras.

Para aquellos que les interesa comenzar con estas tecnologías, les recomendamos visitar el programa Desarrollador 5 Estrellas, donde se puede practicar incluso rendir evaluaciones para ver como estamos.

sábado, 10 de mayo de 2008

lunes, 28 de abril de 2008

Bienvenida

Bienvenidos al Blog de la célula Jujuy ASP NET. Aquí estaremos publicando nuestros avances, actividades y demás cosas de interés.