lunes, 19 de diciembre de 2011

Entendiendo las propiedades de dependencia en Silverligth

He decidido escribir este post, como ayuda para la cápsula de Silverligt relacionada con la implementación de Content Controls, en donde se requiere definir para el Content Control una propiedad de este tipo.

Haber, las propiedades de dependencia, aunque sin de pronto saberlo, las has usado cada vez que le asignas su valor a una propiedad de las principales de los controles que hemos visto: TextBox, CheckBox, Button o TextBlock. Ello porque las propiedades principales de los controles que mayormente usamos, todas permiten en un momento determinado la aplicación de: Animaciones, Estilos o Enlace a datos, como se verá en otras cápsulas.

Las propiedades de dependencia son entonces propiedades que permiten extender la funcionalidad de la propia propiedad. Es decir, tomemos como ejemplo, la propiedad Text del control TextBlock. Con esta propiedad, podemos definir el texto que muestra el TextBlock, allí usamos la funcionalidad normal de la propiedad Text. Sin embargo, como veremos en cápsulas sucesivas, se puede utilizar la propiedad Text, para mostrar la información proveniente de una fuente de datos, es decir, podemos enlazar la propiedad a una fuente de datos con una sintaxis dada:

<TextBlock Text="{Binding Team.TeamName}"/>

En este caso, la propiedad Text se enlaza a una fuente de datos, para tomar el nombre de un equipo.

Por ello, la propiedad Text es una propiedad de dependencia, porque, en un momento dado, permite extender su funcionalidad básica que es definir el texto para el TextBlock y, en este caso particular, enlazarse previamente a una fuente de datos para tomar la información.

Los objetos o controles de Silverligt son objetos DependencyObject y deben serlo porque la mayoría de ellos permiten la animación, enlazado a datos o la aplicación de estilos de al menos una propiedad y para permitir dichas acciones sobre la propiedad éstas deben ser propiedades de dependencia que solo se pueden definir en objetos de dependencia.

Para que un objeto permita en una propiedad de dependencia, el enlazado a datos, debe también heredar de FrameworkElement.

En el caso del TextBlock, podemos enlazar la propiedad Text a una fuente de datos y como muestra la imagen, vemos, en su jerarquía de clase, que hereda de FrameworkElement:

JerarquiaHerenciaTextBlock

También, vemos como es un DependencyObject.

En Silverligth, nosotros podemos definir nuestras propias propiedades de dependencia para proporcionarles a los Content Controles, User Controls o demás tipos de controles que implementemos, propiedades que permitan el enlazado de datos, el establecimiento de animaciones o la aplicación de estilos cuando sea requerido.

Las propiedades de dependencia se definen, en código, de manera similar a las propiedades convencionales clásicas que se respaldaban en un campo privado. A continuación, el comparativo:

Propiedad clásica convencional

Propiedad de dependencia

private bool isSpinning;

 

 

 

 

 

public bool IsSpinning

{

get { return isSpinning;}

set { isSpinning = value;}

}

public static readonly DependencyProperty IsSpinningProperty =

DependencyProperty.Register(

"IsSpinning", typeof(Boolean),

typeof(SilverlightExampleClass), null

);

 

public bool IsSpinning

{

get { return (bool)GetValue(IsSpinningProperty); }

set { SetValue(IsSpinningProperty, value); }

}

Es decir, en lugar del campo privado se usa el tipo DependencyProperty estático público y de solo lectura, que por convención lleva el nombre de la propiedad de dependencia seguido del término Property (<NombrePropiedad>Property. Ejemplo:IsSpinningProperty);  y para obtener y asignar el valor de la propiedad se deben usar los métodos GetValue y SetValue.

También notar como la propiedad de dependencia se debe registrar utilizando el método DependencyProperty.Register.

Que recibe como parámetros:

  • El nombre de la propiedad de dependencia a registrar
  • Su tipo
  • El tipo de la clase donde se registra la propiedad de dependencia
  • Y, por último, de manera opcional, información de metadata de la propiedad de dependencia.

En resumen, entonces, tenemos que las propiedades de dependencia permiten extender la funcionalidad de la propiedad para permitir: Animaciones, enlace a datos o aplicación de estilos. Sin embargo, las propiedades de dependencia presentan otra característica importante y es la de proporcionar devoluciones de llamada que puedan propagar sus cambios a otras propiedades. Es decir, las devoluciones de llamada se pueden utilizar para notificar o cambiar los valores de las propiedades relacionadas, de un modo sincrónico en general.

Para usar las devoluciones de llamada, las definimos en la información de metadata del método de registro. Por ejemplo:

public static readonly DependencyProperty HeaderContentProperty =
    DependencyProperty.Register("HeaderContent", typeof(object), typeof(MiContentControl),
    new PropertyMetadata(new TextBlock() { Text="Usar un TextBlock"}, new PropertyChangedCallback(OnHeaderContentChanged)));
 
static void OnHeaderContentChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
    MiContentControl miContentControl = (MiContentControl)sender;
 
    if (!(e.NewValue is TextBlock))
    {
        miContentControl.ClearValue(HeaderContentProperty);
    }
}
 
public object HeaderContent { 
    get { return (object)GetValue(HeaderContentProperty); } 
    set { SetValue(HeaderContentProperty, value); } 
}



Notar como, en este caso, definimos valor para la información de Metadata, en el método de registro:


new PropertyMetadata(new TextBlock() { Text="Usar un TextBlock"}, new PropertyChangedCallback(OnHeaderContentChanged))


El objeto PropertyMetadata recibe dos parámetros:



  • El valor por defecto de la propiedad. Que para el caso es:

        new TextBlock() { Text="Usar un TextBlock"}



  • La definición de la devolución de la llamada. Y corresponde a:

         new PropertyChangedCallback(OnHeaderContentChanged)


Es en la implementación de la devolución de llamada donde se puede hacer la modificación de las propiedades relacionadas con base al valor de la propiedad de dependencia.


En el ejemplo, la implementación de la devolución de la llamada corresponde a:




static void OnHeaderContentChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
    MiContentControl miContentControl = (MiContentControl)sender;
 
    if (!(e.NewValue is TextBlock))
    {        
 
       //Se asigna de nuevo como valor de la propiedad el definido por defecto
        miContentControl.ClearValue(HeaderContentProperty);
    }
}


Donde se define lo que ocurre cuando se modifica el encabezado de un Content Control.

Por defecto (resaltado de azul), se define que su valor será un TextBlock con el texto: Usar un TextBlock y en la implementación de la devolución de llamada, se controla que si el valor de la propiedad, luego de modificado por el usuario (NewValue), no es un TextBlock; se le asigna su valor por defecto. Esto se logra al llamar el método ClearValue pasándole como parámetro la propiedad de dependencia.

De esta forma, se usa la devolución de llamada, para controlar que solo se pueda usar un TextBlock como encabezado.

El código precedente, entonces, también ilustra otras características que poseen las propiedades de dependencia que son: la posibilidad de definirles un valor por defecto y la posibilidad de restablecer ese valor por defecto, en cualquier momento, por medio del método ClearValue que recibe como parámetro la propiedad de dependencia.

Finalmente, como también es ilustrado, en la implementación de la devolución de la llamada podemos acceder a la información de los distintos valores de la propiedad de dependencia para la toma de decisiones:

NewValue: Valor después de realizado el cambio del valor de la propiedad de dependencia.

OldValue: Valor de la propiedad antes de realizado el cambio.

Resumen, en mapa conceptual:

ResumenPropiedadDependencia

martes, 13 de diciembre de 2011

Base de conocimiento

Categoría
Descripción
Observación
Silverligth La propiedad FontStretch del TextBlock y TextBox se encuentra definida solo por compatibilidad con WPF. En Silverligth esta propiedad no tiene efecto, ni siquiera para fuentes OpenType como era en el caso de WPF. http://forums.silverlight.net/
p/126686/284601.aspx

Silverligth En lo que respecta a la programación asíncrona, en Silverligth, no es soportada la forma de llamar al método BeginInvoke desde un delegado.

Delegate.BeginInvoke

 

martes, 6 de diciembre de 2011

Otros controles contenedores – WrapPanel

En esta cápsula estudiaremos otro contenedor de controles, el WrapPanel. El WrapPanel al igual que el DockPanel no es un control de los básicos que se pueden usar con solo instalar SilverLigth (como si lo son Canvas, StackPanel y Grid). Para poder usar el WrapPanel debes instalar si no los has hecho el ToolKit para Silverligth 4. El Toolkit lo puedes obtener de la siguiente dirección:

http://silverlight.codeplex.com/releases/view/43528

Si deseas más información sobre este control contenedor, puedes visitar el sitio:

http://msdn.microsoft.com/es-es/library/system.windows.controls.wrappanel.aspx

Estudio del control WrapPanel

Si tienen comentarios, sugerencias o preguntas. Favor, realizarlas, estaré atento para colaborarles en lo que pueda.

lunes, 5 de diciembre de 2011

Otros controles contenedores – DockPanel

 

Motivado por la comunidad a la que pertenezco Avanet, he comenzado a realizar una serie  de videos de enseñanza o pequeñas cápsulas de conocimiento sobre un tema, para mi apasionante, Silverligth.

La idea es ir abordando tema tras tema de una forma tranquila y lograr así el entendimiento general sobre el mismo.

A continuación, entonces, la primera:

En esta cápsula estudiaremos el DockPanel. El DockPanel a diferencia que en WPF (Windows Presentation Foundation) no es un control de los básicos que se pueden usar con solo instalar SilverLigth (como si lo son Canvas, StackPanel y Grid). Para poder usar el DockPanel debes instalar si no los has hecho el ToolKit para Silverligth 4. El Toolkit lo puedes obtener de la siguiente dirección:

http://silverlight.codeplex.com/releases/view/43528

Si deseas más información sobre este control contenedor, puedes visitar el sitio:

http://msdn.microsoft.com/es-es/library/system.windows.controls.dockpanel.aspx

Explicación del uso del control DockPanel en SilverLigth

Si tienen comentarios, sugerencias o preguntas. Favor, realizarlas, estaré atento para colaborarles en lo que pueda.

viernes, 25 de marzo de 2011

Herramienta para generación de Scripts de inserción de datos de forma ágil en SQL Server

 

Una tarea que puede tomar, algunas veces mucho tiempo y que puede ser desgastante, es generar scripts de inserción de datos, en tablas. Y lo frustrante, es que, en muchos escenarios, la información ya se tiene en las propias tablas, pero para facilitar el cargado inicial de datos, en otras bases de datos o el transporte de la misma información, se requiere disponer del Script de inserción de datos.
 
En este escenario, aplica muy bien, la herramienta o procedimiento almacenado InsertGenerator que se puede obtener en este enlace:
http://www.codeproject.com/KB/database/InsertGeneratorPack.aspx
 
Lo que se hace es crear el procedimiento almacenado, en la base de datos, donde se encuentran las tablas con la información, que se desea tener en el Script de inserción y ejecutarlo pasándole, como parámetro, la tabla, para la que se desea generar el Script, así:
 
exec InsertGenerator ClasificacionesVehiculo
 
Con sólo eso, ya, en la ventana de resultados de ejecución de las consultas, de la herramienta de ejecución de consultas de SQL Server, aparece, el Script de Insert.

blog1

Nada más fácil. ¡Que vacano!.
 
Sin embargo, como lo que se quería era sacar la información o script de inserción de varias tablas, se investigó un poco más y, primero que todo, se creó un Script, para generar las instrucciones de insert sobre las tablas requeridas:
 
exec BDHERMESPROD20110310.dbo.InsertGenerator ClasificacionesVehiculo
exec BDHERMESPROD20110310.dbo.InsertGenerator FormasPago
exec BDHERMESPROD20110310.dbo.InsertGenerator GruposUsuario
exec BDHERMESPROD20110310.dbo.InsertGenerator Menus
exec BDHERMESPROD20110310.dbo.InsertGenerator Formularios
exec BDHERMESPROD20110310.dbo.InsertGenerator Plataformas
 

 
Fijarse como, se indica la base de datos donde se encuentra definido el procedimiento almacenado InsertGenerator y el propósito de ello es ejecutar el Script desde la consola del DOS, a través de la utilidad SQLCMD y poder generar, así, de una vez, el script de inserción, para cada tabla, de una forma aún más rápida:
 
sqlcmd -SMVMsb102 -UIUSR_HERMES -PIUSR_HERMES -i GeneScriptsTiposBasicos.sql -o insert.sql
 
Aquí, entonces,
 
S: El servidor es MVMsb102
U: EL usuario IUSR_HERMES
P: La clave, la misma
i: El Script a ejecutar, en este caso, GeneScriptsTiposBasicos.sql, que contiene las instrucciones de generación del insert sobre las tablas, mostradas arriba.
o: El archivo donde quedará el resultado de la ejecución del Script GeneScriptsTiposBasicos.sql
 
Al dar enter y ejecutar el comando, efectivamente, se genera el Script, con las instrucciones de inserción sobre las tablas. Así:


blog2 

Lo que resta  entonces es utilizar la instrucción USE, para indicar la base de datos donde se ejecutarán los Scripts de inserción y modificar los textos del tipo:
(x filas afectadas)
Por la palabra reservada GO, como se muestra a continuación y listo.

blog3

De esta forma,  se obtienen los Scripts de inserción de datos sobre varias tablas, de una forma ágil y rápida.


Resumen de pasos:
1.       Crear el procedimiento InsertGenerator en la BD donde se encuentran las tablas con la información.
2.       Crear el Script de generación de inserts sobre tablas
Ejemplo:
exec BDHERMESPROD20110310.dbo.InsertGenerator ClasificacionesVehiculo
exec BDHERMESPROD20110310.dbo.InsertGenerator FormasPago
3.       Ejecutar la instrucción:
sqlcmd -S -U -P -i –o
 
En la consola de DOS.
Especificando, apropiadamente:
El servidor, el usuario y clave de conexión a la BD, el Script a ejecutar y el nombre del archivo con el resultado
4.       Adecuar el Script, para su ejecución, en SQL Server. Es decir, indicar la base de datos con USE y colocar los GO.

Espero que esta herramienta sea de utilidad.

miércoles, 23 de marzo de 2011

Covarianza y contravarianza en C#

 

Esto son otros nuevos conceptos que vienen con el Framewrok 4.0 de C# y son duros de entender. Mi propósito en este articulo, como el de muchos autores, es dar a entender los conceptos que hay detrás de la covarianza y contravarianza, para que así estos conceptos se puedan aplicar de una manera más natural, en los desarrollos de Software que así lo requieran.
 
Empecemos por indicar que, desde el punto de la física,
 
Co y Contra: Implican dualidad, lo que significa que los términos van juntos.
Varianza: implica movimiento.
 
Se puede inferir, entonces, que en estos términos, Covarianza significa “Con el movimiento” y Contravarianza “Contra el movimiento o en sentido opuesto al movimiento”.
 
Ahora, en nuestro campo, la programación orientada a objetos, en el marco del concepto de herencia, identificamos dos tipos de objetos:
 
1.       Tipos base
2.       Tipos derivados
 
Así las cosas, podemos imaginarnos a un tipo base interactuando en un programa (es decir, tener un movimiento o acción o cambio)  y sustituir el tipo base por el tipo derivado, ya que el tipo derivado “es un” tipo base. Por tanto, cuando es equivalente tener a un tipo derivado en lugar del tipo base, estamos ante la covarianza. La acción o movimiento que afecte al tipo base, le afecta en igual medida al tipo derivado y, por ello, son covariantes.
 
En sentido opuesto, se define la contravarianza, en donde es el tipo derivado el que se puede sustituir por el tipo base.
 
En la siguiente imagen, se trata de ilustrar ambos conceptos:

 CoContraVarianza
 
Con el auge y manipulación de delegados, se pensó en incorporar, en el lenguaje, características que permitieran realizar manipulaciones de estos, esperadas, dada una relación de herencia entre tipos dados.
 
Ejemplo:
 
Gato hereda de Animal y, entonces, se puede tener el siguiente delegado genérico:
 
delegate T Func1<T>();
 
Siendo así las cosas, podemos tener una instancia de este delegado que retorne un gato:
 
 
public Cat MyFunc()
{
    return new Cat();
   }
 
    Func1<Cat> cat = MyFunc;
 
 
Debido a que un Gato es un Animal, tenderíamos a pensar, que debería ser viable asignar un Gato a un delegado que retorna un Animal, es decir, tener algo así:
 
Func1<Animal> animal = cat;
 
Sin embargo, hasta antes del Framework 4.0, una instrucción como esta sacaría error. A partir del Framework 4.0, es posible realizar la asignación, haciendo un cambio mínimo en la declaración del delegado. En particular, se requiere usar la palabra clave out, así:
 
delegate T Func1<out T>();
 
De esta forma, se puede lograr la asignación que hasta antes del Framework 4.0 no era posible y que se conoce como covarianza.
 
Ejemplo:
 
class Animal { }   

class Cat: Animal { }  

class Program    {    

delegate T Func1<out T>();      

static void Main(string[] args)      {          

   // Covariance           

   Func1<Cat> cat = () => new Cat();           

   Func1<Animal> animal = cat;           

}

}
 
La contravarianza tiende a ser más complicada de ilustrar. Aquí, se trata de sustituir el tipo derivado por el tipo base. Una de las situaciones donde a partir del Framework 4, se permite esta sustitución es en el paso de parámetros. La contravarianza se permite es en el paso de parámetros a diferencia de la covarianza que se permite en el retorno de tipos.
 
Ejemplo:
 
class Animal { }   

class Cat: Animal { }   

class Program    {     

delegate void Action1<in T>(T a);      

static void Main(string[] args)      {           

    // Contravariance           

             Action1<Animal> act1 = (ani) => { Console.WriteLine

                             (ani); };           

              Action1<Cat> cat1 = act1;           

           }
 
}
 
De nuevo, debido a que un Gato es un Animal, es esperable y deseable que los delegados que reciben parámetros de tipo Animal se puedan asignar a delegados que reciben Gatos como parámetro.
 
También, es posible, en Enumerados, utilizar las palabras in y out, en su definición, para lograr implementaciones de covarianza y contravarianza respectivamente. De hecho, en el Framework 4.0, ya la definición de la clase Enumerable<T> se modifica por Enumerable<Out T> y, por tanto, podemos tener este código:
 
IEnumerable<Cat> cats = new List<Cat>();
IEnumerable<Animal> animals = cats;
 
Es decir, podemos tener una covarianza, a nivel de enumerados.
 
De nuevo, esto es lo esperable y deseable, ya que como un Gato es un Animal se espera que un enumerado de gatos sea un enumerado de animales.
 
Otra forma de entender los conceptos de porque se llamarón covarianza y contravarianza, es dibujar flechas y asumir que la dirección de la flecha es la dirección del movimiento. Así:
 
En herencia tenemos una conversión de referencia implícita de Animal a Gato:
 
Animal → Gato
 
Y, como vimos, anteriormente, se permite en los enumerados, tener también un conversión de referencia implícita de IEnumerable<Animal> a IEnumerable<Gato>:
 
IEnumerable<Animal> → IEnumerable<Gato>
 
Se llama covarianza porque las flechas apuntan en la misma dirección o siguen el mismo movimiento.
 
En la contravarianza, la flecha va en el sentido contrario:
 
Animal → Gato
IComparable<Animal> ← IComparable<Gato>
 
En términos generales, se puede concluir que la covarianza y la contravarianza se refieren al uso de las palabras reservadas out e in respectivamente, en interfaces genéricas y delegados, para establecer relaciones entre tipos que mantienen la misma conversión de referencia implícita, que los tipos originales tenían en una relación de herencia (covarianza) o donde dicha conversión va en sentido inverso (contravarianza).

miércoles, 16 de marzo de 2011

Dynamics en C#

 

Woow estuve leyendo acerca de las nuevas características que tiene C# para la versión 4 del Framework y me pareció excelente la inclusión de la palabra clave dynamic.
 
Esto permite, postergar, hasta el tiempo de ejecución , la evaluación de tipos. Es decir, en tiempo de compilación no se detectan errores de asignación de tipos.
 
La palabra dynamic permite indicarle al compilador que no efectúe la comprobación de asignación de tipos.
 
En el artículo que se encuentra aca:
http://msdn.microsoft.com/en-us/magazine/gg598922.aspx
 
Se hace una diferenciación clara de lo que son las definiciones con: object, var y dynamic.
 
var: Permite inferir el tipo, pero si hay un error en la asignación de tipos, el compilador lo detecta.
object: Tipo básico de todos los objetos de .NET siempre es necesario efectuar Cast, para hacer la asignación de tipos y que no se genere error en tiempo de compilación.
dynamic: Permite postergar la detección de errores por asignación de tipos hasta el tiempo de ejecución. En tiempo de compilación no se reportan errores.
 
Desde mi punto de vista de desarrollador y relacionado a lo que, normalmente, trabajo. Lo que más me gustó, en cuanto al uso de dynamic, es en los siguientes escenarios:
 
Interoperación con otros lenguajes o frameworks
 
Sin dynamic se tendría que acceder a la característica de Reflexión, para poder acceder a los métodos de un objeto o assembly, con el que se desee interactuar.
 
Ejemplo:
 
1.  object calc = GetCalculator();
2.  Type calcType = calc.GetType();
3.  object res = calcType.InvokeMember(
4.    "Add", BindingFlags.InvokeMethod,
5.    null, new object[] { 10, 20 });
6.  int sum = Convert.ToInt32(res);


Usando dynamic es más simple y fácil de comprender el código:
 
dynamic calc = GetCalculator();int sum = calc.Add(10, 20);
Agregar métodos dinámicamente a objetos
 
1.  dynamic expando = new ExpandoObject();2.  expando.SampleProperty = 3.    "This property was added at run time";4.  expando.SampleMethod = (Action)(5.    () => Console.WriteLine(expando.SampleProperty));6.  expando.SampleMethod();Interoperar con COM
 
Es decir, poder interoperar de una forma más fácil con Office, esta fue la meta de Microsoft al extender C# con dynamic y, en general, el framework DLR ( Dynamic Languaje Runtime)
 
Ejemplo:
 
1.  // Add this line to the beginning of the file:

2.  // using Excel = Microsoft.Office.Interop.Excel;

3.  

4.  var excelApp = new Excel.Application();

5.  

6.  excelApp.Workbooks.Add();

7.  // excelApp.Workbooks.Add(Type.Missing);

8.  

9.  excelApp.Visible = true;

10.

11.Excel.Range targetRange = excelApp.Range["A1"];

12.// Excel.Range targetRange = excelApp.get_Range("A1", Type.Missing);

13.

14.targetRange.Value = "Name";

15.// targetRange.set_Value(Type.Missing, "Name");

16.

17.targetRange.Columns[1].AutoFit();

18.// ((Excel.Range)targetRange.Columns[1, Type.Missing]).AutoFit();

En comentarios se encuentra la forma como se tenía que escribir, antes, el mismo código. La facilidad y mejora son innegables.

viernes, 7 de enero de 2011

Peripecias para instalar Windows 7

 

Bueno, esta vez les contaré todos los problemas que tuve para poder instalar Windows 7. En primer lugar debo decir, que mi sistema operativo anterior era Windows XP Professional SP2. Pasar de Windows XP a Windows 7 no se puede hacer como una simple actualización, como sería lo ideal; se debe formatear el disco y luego hacer la gestión de instalación del sistema operativo. Hasta ahí, pues nada, suena fácil. Sin embargo, no pude hacer el proceso normal, porque mi Windows XP me falló, no se si por la intromisión de algún virus, el hecho era que no podía reconocer algunos sectores del disco, donde justo estaba, información crítica del sistema operativo y, por tanto, me empezó a fallar.

Mi equipo está constituido por 2 discos duros, el C y el F, en el C que es el disco primario, el de boot, y allí tenía instalado el sistema operativo Windows XP. Funcionando a medias, pero lo tenía, pude sacar Bkup de la información, mis datos, que tenía apropiadamente en el disco F. Luego me decidí a instalar Windows 7, presionado, un tanto, por el problema con mi Windows XP.  Como debía hacer formateo del equipo porque se trataba de instalar Windows 7 desde XP, intenté formatear el disco C, pero no podía ya que estaba siendo usado por el propio sistema operativo XP. Por tanto, formatee el disco F. La única forma que tenía para formatear el disco C, era arrancar el equipo por medio de un disco de arranque, de esta forma, el sistema operativo Windows XP no arrancaría el equipo y sería capaz de formatear el disco duro C, para luego adelantar la instalación del Windows 7. Sin embargo, no contaba con la suerte de tener un disco de arranque de Windows XP, la única forma que tenía para generar un disco de arranque era formatear una unidad de disquete y definir que quería realizar un disco de arranque de Windows XP, pero, desafortunadamente, mi unidad de disquete física no funciona, no funcionó desde la primera vez que compre el equipo, cosa a la que no le pare bolas , porque, supuestamente, los disquetes ya no se utilizaban. Pues, en ese momento, estaban de moda las USBs. ( A falta que me hizo la condenada unidad). La otra cosa hubiera sido tener el CD original de Windows XP, sí el que compre hace años y que no recordaba donde se encontraba, pero bueno esa es otra historia. Continuando, entonces, decidí instalar el Windows 7, en el disco que pude formatear, en el F y así lo hice. Mi idea, un tanto ingenua, era instalar Windows 7 y luego desde la utilización de ese sistema operativo, formatear el disco C.

Luego de instalar el Windows 7, al hacer el booting, aparecía la elección de si quería usar Windows 7 o una versión anterior, es decir, el disco duro C que era el de booting, reconocía que estaban presentes dos sistemas operativos: el Windows XP defectuoso en el disco C y el nuevo, el Windows 7, en el F. El Windows 7, perfecto. Desde Windows 7 quise formatear el disco D ( el C, de Windows XP), ( aprendí, que el disco donde se instala el Sistema operativo, queda como el C y los otros se renombran, en consecuencia) pero no podía, era como si el sistema operativo Windows 7 estuviera usándolo, lo cual me parecía extraño, ya que instale el Windows 7 en el F, en el que creía era otro disco duro. No obstante, fue Windows 7, el que me mostró la verdad de mis discos, que juro por Dios, que no recordaba y es que no tengo 2 discos sino uno, sólo que con dos particiones. En la parte de los datos, que había concebido en Windows XP, fue donde instalé Windows 7 y en la parte que destine, para el sistema; continuaba el defectuoso XP. De nuevo, me enfrentaba a la cuestión de como formatear esa partición  y con Windows 7, no encontré forma y la verdad quería recobrar todo ese espacio, para destinarlo al guardado de datos y de mi información en general.

Investigué e investigué y hallé la herramienta GParted que es un proyecto Free de la SourceForceNet y que permite administrar las pariciones de los discos, de forma gráfica en diversos sistemas operativos.

Gnome Partition Editor

Este entrada de mi blog, es una propaganda para esta herramienta. Me pareció, súper. Pues me salvo el día. Leí un poquito el tutorial en línea y pude usarla. La idea es:

1. Bajar el ISO

2. Copiar el ISO en un CD ( con Windows 7, es con clic derecho sobre el archivo ISO, una vez descargado)

3. Se reinicia el equipo y se pone a arrancar desde ese CD ( al principio, me parecía increíble porque vi el contenido de los archivos del CD y me pareció que todo era como Linux)

4.Cuando arranca el Boot, con ese CD, te da la opción de usar la utilidad Gparted Default o las otras opciones que se tenían antes. Es decir, arrancar Windows 7 o la versión anterior de Windows.

5. Indicar usar la opción por Default ( debido a que no conocía dicha herramienta, me pareció lo indicado).

6. Eso arranca y al principio es como cuando se arranca con un disco de inicio, aparece pura información, en formato DOS, información del escaneo que esa herramienta hace de los discos y sus particiones.

7. Al final, muestra de una forma gráfica las particiones y discos que encuentra. Claro las letras, como se reconoce a los Drives, tienen la notación de Linux, pero es fácil reconocer, por el tamaño y por el espacio libre; cual partición es cual, desde el punto de vista de Windows 7, es decir, se sabe cual es la partición que se desea formatear. Bueno y en mi caso, particular, la herramienta mostró que la partición que deseaba formatear tenía sectores defectuosos, es decir, era aún más fácil de identificar.

8. Aunque la herramienta, permite hacer muchas cosas lo que me interesaba a mi era formatear la partición del caso y ello se permitía con simplemente dar clic derecho sobre ella y elegir la opción. Sin más y dado que tenía backup de mi información, lo hice (increíble la rapidez con que realizó el formateo, nada que ver, como cuando se formatea algo en Windows).

Como formatee la partición del disco, que tenía la información del Booting, cuando quise volver a iniciar el sistema, no me cargaba el booting. Entonces, lo que hice fue entrar en la unidad de CD el CD de instalación de Windows 7 con la esperanza de reparar la instalación y lo logré. Reconoció que ya Windows 7 estaba instalado e indicó las acciones para hacer la recuperación del sistema, seguí el Wizard y listo!!. El equipo ya bootea y carga Windows 7, es decir, no coloca a elegir al usuario SO porque ahora es solo Windows 7 y recuperé el espacio en disco, de la partición formateada y feliz, me puse a escribir esta entrada desde mi nuevo sistema operativo.

martes, 4 de enero de 2011

El retorno del rey…

Yo siempre deseo escribir en mi blog, como parte de un ejercicio de escritura. Es divertido!. Lo bueno de escribir en un blog es que uno puede ser uno mismo. Es casi como un diario personal.

 

En este momento, me encuentro cacharreando con la herramienta Writer que vino con la nueva versión de Windows Mesaanger. Es increíble, corrige errores ortográficos . Ya que soy un chusografeador ( esa palabra la resaltó, pero en realidad, no existe en español) y en ocasiones se me escapan tildes, me es muy útil es como escribir en Word ni más ni menos. Es fácil realizar correcciones al texto.

 

Mi blog como todos saben está en Blogger y su herramienta para edición de entradas al blog no es muy buena, Esto es sensacional. Obtuvo el tema con el que me agrada publicar mis entradas.

 

Voy hacer una prueba de todo lo que ofrece, por ejemplo, crear una tabla:

 

Ranking de programas de televisión que me gustan:

Programa

Ranking

A prueba de todo 1
Un minuto para ganar 2
Cazadores de mitos 3

Bueno, definitivamente, muy fácil, como en Word. Sin embargo, no pude saber como cambiarle el color de fondo a la primera fila de tabla, que tiene el título de las columnas.

 

Ahora una imagen:

ZX-10R_Left

Y un video:

 

 

 

Esto ya me parece espectacular.

 

Como si fuera poco hipervínculos a otros sitios:

Videos de youtube

Tiene algo llamado etiquetas, probaré que es:

Etiquetas de Technorati:

No encontré tan beneficioso, esto de las etiquetes, pero se cacharreo que es lo importante.

Bueno también tiene la forma de incluir mapas, veré que sucede:

Excelente!!, Seguiré usando la herramienta Writter que viene con el Messanger, para editar mis blogs