Hace unos días, un excompañero de trabajo me pidio consejo de como solucionaba unos “problemas”, que se te pueden plantear cuando trabajas con Windows Azure. Por eso pense en este post, ya que una persona me lo pidio, por que no me lo van a pedir otras 
? todo sea por ayudar. En concreto, los “problemas” eran los siguientes:
- Backup Sql Azure
- Monitorización del deploy.
Yo he solucionado estos problemas con 2 software de terceros (de pago). Se que mucha gente no comparte el tema de comprar herramientas, pero en mi caso no es así, a mi si realmente merece la pena no me importa. También es cierto que en este caso lo paga mi empresa ^^
Backup Sql Azure
La herramnienta es de Red Gate, una de las empresas que se dedica a crear herramientas en su mayor parte para sql. El nombre es “Sql Azure Backup” http://www.red-gate.com/products/dba/sql-azure-backup/.
La utilización es muy sencilla, a continuación os adjunto 2 “screenshots” que nos permite crear el backup.
Aquí tenéis los 3 pasos a seguir, veréis que es increíblemente simple
Monitorización Azure
Para solventar este problema implementamos Azure Diagnostics(El siguiente post será sobre esto.) , para poder consumir los datos utilizamos Azure diganostics Manager http://www.cerebrata.com/Products/AzureDiagnosticsManager/
Aquí os dejo un video, yo creo que será de utilidad.
http://cerebrata.blob.core.windows.net/onlinedemos/azurediagnosticsmanager/performancecounters/performancecountersdemo.html?
Con esto doy por finalizado el post, antes de nada, perdón por las imágenes que están editadas muy mal… cualquier comentario será bien recibido…
Quique
Después de varios intentos y falta de tiempo, he decidido, ponerme como tarea, el escribir, por que así, plasmare todo lo que aprendo cada día 
, espero que sirva de ayuda alguno de mis posts.
En la actualidad, las aplicaciones en Silverlight no nos permiten seleccionar y copiar texto de una manera cómoda, sin utilizar las llamadas “Hot Keys”. En este sería “Control + C”, pero como ya comentaba antes, no es cómodo para el usuario tener que conocer estos métodos, es por eso que haremos el siguiente control para poder hacer esta tarea con el típico clic del botón derecho de nuestro ratón.
Lo primero será crea un control, que hereda de “Text box” y ahí gestionar todos los eventos y propiedades del control, el código será el siguiente:
namespace Silverlight.Common.Controls
{
public class TextBoxWithCopyControl : TextBox
{
ContextMenu menu = null;
MenuItem item;
public TextBoxWithCopyControl()
{
this.MouseRightButtonDown += new MouseButtonEventHandler(TextBoxWithCopyControlMouseRightButtonDown);
this.MouseRightButtonUp += new MouseButtonEventHandler(TextBoxWithCopyControlMouseRightButtonUp);
}
void TextBoxWithCopyControlMouseRightButtonUp(object sender, MouseButtonEventArgs e)
{
menu = new ContextMenu();
item = new MenuItem();
item.Header = "Copiar";
menu.Items.Add(item);
item.Click += new RoutedEventHandler(item_Click);
menu.IsOpen = true;
menu.HorizontalOffset = e.GetPosition(null).X;
menu.VerticalOffset = e.GetPosition(null).Y;
}
static void TextBoxWithCopyControlMouseRightButtonDown(object sender, MouseButtonEventArgs e)
{
e.Handled = true;
}
void item_Click(object sender, RoutedEventArgs e)
{
Clipboard.SetText(this.Text);
}
}
}
Después de crear el control, tenemos que crear un estilo, ya que al heredar de “TextBox” la presentación en pantalla puede no ser la esperada, por ello creamos el siguiente estilo.
<Style x:Key="SelectableTextBoxStyle" TargetType="TextBox">
<Setter Property="IsReadOnly" Value="true"/>
<Setter Property="Background" Value="Transparent"/>
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="TextBox">
<Grid x:Name="RootElement">
<ScrollViewer x:Name="ContentElement" Background="{TemplateBinding Background}" Padding="{TemplateBinding Padding}" BorderThickness="0"/>
</Grid>
</ControlTemplate>
</Setter.Value>
</Setter>
</Style>
Ahora solo nos queda aplicar el control a esos textos que queremos darle esta propiedad, dejo aquí un ejemplo:
<Controls:TextBoxWithCopyControl x:Name="txtDescription" TextWrapping="Wrap"
Style="{StaticResource SelectableTextBoxStyle}" HorizontalAlignment="Left" FontSize="21.333" Foreground="#FF1F1F1F" FontWeight="Bold" FontFamily="Tahoma"
Width="365" Text="{Binding Question.Description, Mode=OneWay}" Margin="4" />
Ahora podemos seleccionar texto y al pulsar botón derecho, nos permitirá copiarlo.
Normal
0
false
21
false
false
false
ES
X-NONE
X-NONE
Bueno, después del cambio de trabajo y mil cosas, va un
intento por retomar el blog, ahora lo que queda es proponérselo… he borrado 3 artículos
a medias porque al releerlos no me gustaban…
Ahora empezamos con la temática del post, es sobre VSTO y
Outlook, antes del mini proyecto que se me asigno nunca había tocado nada de
Addins para office y la verdad que se pueden hacer cosas muy chulas para
usuarios finales de office. Des de crearte tu propia Ribbon para agrupar tus menús,
hasta substituir el form de “New Email”, esto último es lo que he pensado para
el post, algo rápido, pero que ayudará a la gente que nunca haya hecho nada de
addins y quiera tener una idea global, de lo que puede llegar a hacer.
Lo primero de todo, es crear un proyecto en VS2010, en mi
caso C#, vamos a Office 2010 y dentro de este escogemos Outlook AddIn. En el
momento de darle el nombre y créalo veremos que automáticamente nos crea una
estructura en la que tenemos lo típico de un proyecto, references, propierties
y Outlook, aquí es donde ira la base de nuestro proyecto. En el momento de
crear el proyecto, dentro de la clase Outlook, vemos el ThisAddIn.cs, aquí es donde automáticamente
nos ha generado 2 cosas a tener encuentra.
Primero:
El lanzador de nuestro AddIn, que se ejecuta al iniciar
Outlook.
private void
InternalStartup()
{
this.Startup
+= new System.EventHandler(ThisAddIn_Startup);
this.Shutdown
+= new System.EventHandler(ThisAddIn_Shutdown);
}
Y después, los métodos que se pueden ver en el
InternalStartup.
private void
ThisAddIn_Startup(object sender, System.EventArgs e)
{
}
private
void ThisAddIn_Shutdown(object sender, System.EventArgs
e)
{
}
Como ya seguro que habéis intuido, el ThisAddIn_Startup,
se llama al iniciar la aplicación (aquí es donde tendremos que llamar, a muchas
delas funciones, capturar inspectores, llamar a nuevos forms, etc...) y ThisAddIn_Shutdown,
que es el que se llama al cerrar la aplicación.
Como ya he comentado en la introducción, este post va sobre, utilizar
otro form de envió de emails, para ello necesitamos capturar el “inspector” que
llama Outlook, en el momento que se pulsa el botón de nuevo email, la hot key o
cualquier atajo que se tengan para abrir el formulario que nos permite enviar
un email.
Ahora, que es un Inspector?, según MSDN :
La clase Microsoft.Office.Interop.Outlook.Inspector
representa una ventana que muestra un único elemento, como por ejemplo, un
mensaje de correo electrónico, tarea o cita en la interfaz de usuario de
Outlook. La clase Inspector incluye métodos y propiedades, que
se pueden utilizar para modificar la ventana, y eventos que se generan cuando
la ventana cambia.
Después de está maravillosa definición, que creo que todos
entendemos, vamos a ponernos a escribir
un poco de código, lo primero, preparar el Nuevo form, cada uno que lo haga a
su gusto :P, el mio será muy simple.
Aquí está:
Ahora que ya tenemos el diseño del Form, queda programar los
dos botones, lo dejo acontinuación.
private void btnCancelar_Click(object
sender, EventArgs e)
{
this.Close();
}
private void btnAceptar_Click(object
sender, EventArgs e)
{
try
{
Outlook.MailItem _mail = new Outlook.MailItem();
_mail.To = this.txtTO.Text;
_mail.Subject = this.txtSubject.Text;
_mail.Body = this.txtMessage.Text;
_mail. Send();
}
catch
(Exception _ex)
{
MessageBox.Show(_ex.Message,
"Error", MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
Ahora, lo queda la programación del Addin, para que cuando
se pulse en el botón Nuevo Email, llame a nuestro formulario y no al de Outlook
por defecto.
Voy a poner primero la lista, de cosas que se tienen que
hacer y después el código, espero que está manera os guste o sino comentarlo
por favor, y para el siguiente cambio de manera de hacerlo.
·
Declaramos las variables Inspector y Mail.
·
Creamos el método que nos crea un nuevo
inspector.
·
Creamos el método, que nos permite capturar los
eventos de Outlook.
·
Y en el método Startup, programamos el tema de los
inspectors.
#region
using
System;
using
System.Windows.Forms;
using
System.Collections.Generic;
using
System.Linq;
using
System.Text;
using
System.Xml.Linq;
using
Outlook = Microsoft.Office.Interop.Outlook;
using
Microsoft.Office.Interop.Outlook;
using
System.Diagnostics;
using
Microsoft.Office.Core;
using
Application =
Microsoft.Office.Interop.Outlook.Application;
#endregion
namespace OutlookAddIn2010
{
public partial class ThisAddIn
{
public Inspectors Inspectors { get;
set; }
public MailItem Mail { get;
set; }
private
void ThisAddIn_Startup(object
sender, System.EventArgs e)
{
this.Inspectors
= this.Application.Inspectors;
this.Inspectors.NewInspector
+= this.InspectorsNewInspector;
}
private
void ThisAddIn_Shutdown(object sender, System.EventArgs
e)
{
}
#region VSTO
generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void
InternalStartup()
{
this.Startup
+= new System.EventHandler(ThisAddIn_Startup);
this.Shutdown
+= new System.EventHandler(ThisAddIn_Shutdown);
}
#endregion
/// <summary>
/// Lanzado por VSTO cuando
se produce la edición de cualquier objeto
/// </summary>
/// <param
name="inspector">Objeto a
inspeccionar</param>
public void InspectorsNewInspector(Inspector
inspector)
{
try
{
this.CaptureOpenAction(inspector);
}
catch
(System.Exception _ex)
{
MessageBox.Show(_ex.Message);
}
}
private
void Mail_OpenCancel(ref
bool Cancel)
{
Cancel = true;
}
private
void CaptureOpenAction(Inspector
inspector)
{
try
{
//Al hacer el set de la variable mail, si es
un NewEmail, seguirá y abrirá el form, en caso
//contrario, se va por el catch y no hace
nada.
this.Mail = (MailItem)inspector.CurrentItem;
//Abrimos nuestro formulario de Nuevo
Email
Forms.NewEmail
_form = new Forms.NewEmail();
_form.ShowDialog();
//Cancelamos que se abra el formulario por
defecto de Nuevo Mail
Mail.Open += Mail_OpenCancel;
}
catch
{ }
}
}
}
Y hasta aquí, el post sobre VSTO,
solo espero poder dedicarme a tope con el blog y que algún post os sirva de
ayuda.
Hasta la próxima :D
Y gracias un compañero (Jaume), que me dio una mini formación en VSTO, en el momento que me hizo falta ;)
Quería que el primer artículo del blog fuera de un tema sencillo, para soltarme un poco, pensando en que escribir, he recordado una duda que se me planteo el otro día en el trabajo y que un compañero me ayudo a resolver a “su manera”; tenía que crear una función que modificase/crease un bloque en un fichero XML.
Hay muchas maneras de crear ficheros XML, una es crearlo con StreamWriter línea a línea de una manera muy prehistórica como por ejemplo:
Código Prehistórico
private void Prehistorico()
{
String Nombre, Apellido, Posicion;
Nombre = this.txtNombre.Text;
Apellido = this.txtApellido.Text;
Posicion = this.cmbPosicion.SelectedText;
using (StreamWriter writer = new StreamWriter("Sample2.xml"))
{
writer.WriteLine("<equipo>");
writer.WriteLine("<ficha>");
writer.WriteLine("<ID>"+ID+"</ID>");
writer.WriteLine("<nombre>"+Nombre+"</nombre>");
writer.WriteLine("<apellido>" + Apellido + "</apellido>");
writer.WriteLine("<posicion>" + Nombre + "</posicion>");
writer.WriteLine("</ficha>");
writer.WriteLine("</equipo>");
}
}
En el caso de modificar, un fichero XML, de está forma tendríamos que ir línea a línea y buscar el tag ID, para saber si existe o no, de forma que tenemos que tenemos que abrir el fichero, recorrerlo y después cerrarlo, esto no es muy útil cuando el framework nos ofrece otras formas de trabajar con el XML.
Después tenemos dos métodos que desde mi punto de vista son los mejores que podemos usar (siempre desde mi punto de vista ;) y se aceptan sugerencias/discusiones).
Una seria XmlTextWriter (http://msdn.microsoft.com/es-es/library/system.xml.xmltextwriter.aspx) y la otra DataSet.WriteXmlSchema (http://msdn.microsoft.com/es-es/library/system.data.datatable.readxml%28v=VS.80%29.aspx).
El motivo de este artículo viene aquí, en los problemas que me da el XmlTextWriter al intentar añadir elementos nuevos a un XML ya creado y comprobar previamente, que no exista ya un elemento dentro del fichero XML. Ya que ir nodo a nodo, e hijo a hijo, puede llegar a ser pesado.
Es ahí donde entra el DataSet.WriteXmlSchema, que realmente lo hace de una forma sencilla.
A grandes rasgos lo que hace es, cargar todo el xml dentro de un dataset y después lo podemos recorrer como hacemos siempre y ahí es donde comprobamos si existo o no nuestro nuevo bloque.
A continuación escribiré el de código, en C# y asi intentare demostrar que es todo más fácil con DataSet.WriteXmlSchema . (Siempre des de mi punto de vista)
Función al pulsar el botón XmlDataset
private void btnXmlDataset_Click(object sender, EventArgs e)
{
DataSet ds = new DataSet();
DataTable dt = new DataTable();
bool flag= false;
int i=0;
ds.ReadXml("Sample3.xml");
while (i< ds.Tables[0].Rows.Count)
{
//Sabemos que el ID, es Unique
if (ds.Tables[0].Rows[0].ItemArray[0].ToString().Equals(this.txtID.Text))
{
MessageBox.Show("El ID que intentas ingresar, ya está dentro del XML");
flag = true;
}
i++;
}
if (!flag)
{
DataRow dr = ds.Tables[0].NewRow();
dr[0] = this.txtID.Text;
dr[1] = this.txtNombre.Text;
dr[2] = this.txtApellido.Text;
dr[3] = this.cmbPosicion.SelectedItem.ToString();
ds.Tables[0].Rows.Add(dr);
ds.WriteXml("Sample3.xml");
}
}
Si quisiéramos, modificar solo abría que poner el código dentro del if, que contiene el MessageBox, guardar la row y escribir el xml con el dataset.
Si usaramos la clase XmlWriter directamente, tendríamos que buscar nodo a nodo e hijo a hijo, cosa que a nivel de código puede ocupar más, pero yo creo que de está forma es más sencillo.
Espero que el post, haya sido de vuestro agrado ;)
Nos leemos
P.D Aún estoy jugando, con el blog para poder insertar código de una manera decente, perdonar si no se entiende algo.
Quique
Bueno antes de nada,
quiero agradecer a Toni Recio, el poder estar aquí, ya que él fue quien me puso en contacto con Rodrigo Corral, para poder formar parte de esta comunidad de
bloggers tan conocida, ahora me presento para que seáis un poco más de mí.
Me llamo Quique Martínez,
soy analista programador en Pasiona Consulting (BCN), llevo más de 5 años en
este mundo, por lo que me queda mucho que aprender, y es por eso que pienso que
tener un blog en Geeks, me puede ayudar a plantearme cosas nuevas y aportar un
granito de arena a la comunidad .Net, también colaboro con SecondNug, que os recomiendo
que visitéis si no lo hacéis ya ;).
Voy a hacer todo lo
posible por meterle caña al blog y hacer artículos de calidad, para poder estar al nivel que ya hay en esta
comunidad.
Cualquier duda,
sugerencia u opinión sobre el blog, serán bien recibidas, hasta aquí el primer
post y empezamos ;)
Nos leemos ;)
Quique