Archivo de la categoría: C#

[WPF] Ventana sin bordes

Este no va a ser un artículo muy largo pues sólo se explicará cómo obtener una ventana sin bordes y agregar la funcionalidad de que se pueda mover, minimizar y cerrar.

Comencemos primero quitando los bordes de la ventana.

<Window x:Class="Windowless.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525"
        WindowStyle="None"
        AllowsTransparency="True" Background="Transparent">

</Window>

La propiedad WindowStyle nos ayudará a quitar el borde donde se encuentra los botones (maximizar, minimizar y cerrar); con la propiedad AllowsTransparency creará una zona donde se permita la transparencia, esto unido al Background transparente terminará en una ventana completamente transparente.

Ahora veamos el resto de código donde se muestra la creación de la barra de título y los botones.

<Border Margin="10" BorderBrush="Red" BorderThickness="0.5">
    <Border.Effect>
        <DropShadowEffect Color="Black"
                          Direction="320"
                          BlurRadius="15"
                          ShadowDepth="3" />
    </Border.Effect>
    <DockPanel LastChildFill="True" Background="White">
        <Grid DockPanel.Dock="Top" Height="25">
            <TextBlock Text="{Binding Path=Title, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=Window}}"
                       HorizontalAlignment="Center" />
            <Rectangle Name="titleBar"
                       Fill="Transparent"
                       MouseLeftButtonDown="titleBar_MouseLeftButtonDown"/>
            <Button Name="closeButton"
                    Style="{StaticResource CerrarStyle}"
                    HorizontalAlignment="Right"
                    Width="15" Margin="0,0,5,0" Height="15"
                    Click="closeButton_Click"/>
            <Button Name="minButton"
                    Style="{StaticResource MinimizarStyle}"
                    HorizontalAlignment="Right"
                    Width="15" Margin="0,0,25,0" Height="9"
                    Click="minButton_Click"/>
        </Grid>
        <Grid Name:"Contenido">

        </Grid>
    </DockPanel>
</Border>

Los eventos de los botones y el rectángulo están definidos así:

private void titleBar_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
    this.DragMove();
}

private void closeButton_Click(object sender, RoutedEventArgs e)
{
    this.Close();
}

private void minButton_Click(object sender, RoutedEventArgs e)
{
    this.WindowState = System.Windows.WindowState.Minimized;
}

Y eso sería todo para crear nuestra ventana sin bordes. Como siempre les dejo el archivo en C# (Windowless.zip), esta vez no publicaré el de VB.NET pues es bastante sencillo de convertir.

Anuncios

Leer y Escribir xml usando Linq

Este va a ser un pequeño artículo donde veremos cómo leer y escribir un documento xml usando Linq. La estructura que va a tener nuestro documento al final será la siguiente:

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Personas>
    <Persona>
        <Nombre> </Nombre>
        <Apellido> </Apellido>
        <Edad></Edad>
        <Correo> </Correo>
    </Persona>
</Personas>

Para leer un documento con esta estructura, debemos hacer esto usando Linq:

XDocument xdoc = XDocument.Load(archivo);

lista = (from x in xdoc.Descendants("Persona")
         select new Persona
         {
             Nombre = x.Element("Nombre").Value,
             Apellido = x.Element("Apellido").Value,
             Edad = Convert.ToInt32(x.Element("Edad").Value),
             Correo = x.Element("Correo").Value
         }).ToList();

Aclaremos ciertas cosas con respecto al código anterior: primero, la variable archivo es un string donde se guarda la ruta del archivo que deseamos leer; segundo, Persona es una clase la cual tiene como propiedades Nombre, Apellido, Edad y Correo; por último, la variable lista es una lista del tipo List<Persona> la cual contendrá todos los registros del archivo leído.

Para obtener más información puede mirar esto enlaces sobre Descendants y Element. Si desea aprender más de xml puede leer este tutorial en W3Schools.

Vayamos ahora a la parte de escribir el archivo xml:

if (dataGrid.ItemsSource != null)
{
    XDocument xdoc = new XDocument(new XDeclaration("1.0", "utf-8", "yes"),
            new XElement("Personas",
            from x in dataGrid.ItemsSource.Cast<Persona>()
            select
              new XElement("Persona",
                 new XElement("Nombre", x.Nombre),
                 new XElement("Apellido", x.Apellido),
                 new XElement("Edad", x.Edad),
                 new XElement("Correo", x.Correo)
              )
          )
    );
    xdoc.Save(archivo);
}

El proyecto está en WPF así que estoy usando un DataGrid donde cargo los datos por eso se aprecia ahí la propiedad ItemsSource, pero si usas Windows Form (WinForms) ¡espera! porque este artículo no es con respecto a la interfaz gráfica sino al lenguaje de programación. Para los que usan WinForms pueden cambiar esa parte del código por la variable lista. Como una nota para las personas que desarrollan usando WPF, si descargan el código podrán ver que he usado conceptos que expliqué en Validación en WPF y 2 Ventanas usando WPF de forma desacoplada para crear este proyecto.

Y así de fácil podemos crear y leer documentos xml utilizando Linq. Espero que a las personas que no han probado Linq, este artículo los mueva a aprender un poco más de este proyecto que ha revolucionado la forma en la que hacemos consultas. Aquí les dejo el código en C# XML2LINQ.zip y esta vez les debo el de VB.NET aunque en poco tiempo lo convertiré y aquí en VB.NET usando Windows Form XML2LINQ-VB.zip. Recuerden quitar la extensión .odt y dejar la .zip.

Asegurando nuestro código | Parte 1

En esta corta serie de artículos demostraré cómo asegurar nuestro código fuente para que este no sea copiado/robado. Supongamos que hemos creado un programa y ahora tenemos 3 opciones para difundirlo: vender licencias, como software libre o freeware.

En este caso hemos creado nuestro programa para venderlo o al menos difundirlo como freeware. El programa sirve para tomar fotos, grabar videos y aplicar filtros a las imágenes obtenidas desde una cámara web; está creado en C# y usa WPF (Windows Presentation Foundation) y además implementa el patrón MVVM (Model-View-ViewModel). Este es el aspecto visual:

Seguros de que es un buen programa hemos creado nuestra página para promocionarlo y además ponemos una descarga a una versión con limitaciones (en tiempo o funcionalidad). Observamos que nuestro programa lo han descargado muchas personas, pero al cabo de 2 o 3 meses alguien saca al mercado un programa bastante similar al de nosotros, para sorpresa nuestra, es en realidad EL MISMO PROGRAMA!!

¡Qué gran decepción, Nuestro trabajo ha sido robado!

Veamos cómo nos robaron el programa: Sigue leyendo

Usando una WebCam con Window Form | Parte 3: Aplicando Filtros

En este artículo de la serie: Usando una WebCam  con Window Forms vamos a aplicar algunos filtros que están contenidos en el Framework de Aforge.NET. Utilizaremos las librerías Aforge.Video y Aforge.Video.DirectShow como de costumbre, solo que esta vez agregaremos Aforge.Imaging para usar Filters.

El Formulario será sencillo como los anteriores. Esta vez tendremos 2 ComboBox (uno para los dispositivos de video y el otro para los distintos filtros que vamos a usar), 1 Button (para iniciar o detener la Cámara Web) y un PictureBox (para mostrar el video capturado por la Cámara Web). El diseño de esto debe ser algo como:

El código para hacer operar la cámara web es el mismo que el de los pasados artículos, por lo tanto, so lo voy  poner aquí el código que ha cambiado o se ha agregado. Primero veamos lo que hemos de agregar: Sigue leyendo

Usando una WebCam con Windows Form – Parte 2: Grabando

Siguiendo la serie de artículos Usando una WebCam  con Window Forms, esta vez crearemos un programa para grabar lo que veamos en la WebCam. En este caso vamos a usar las librerías Aforge.Video (para tener acceso a la clase NewFrameEventArgs), Aforge.Video.DirectShow (para usar la clase VideoCaptureDevice entre otras) y Aforge.Video.VFW (usaremos la clase AVIWriter para grabar un archivo .avi). Como comenté en el artículo pasado, debemos cambiar el Framework de Destino -si usamos .NET Framework 4.0– a .NET Framework 3.5. Vamos a usar un Form sencillo, solo un PictureBox que mostrará la cámara web, un ComboBox que va a contener los diferentes dispositivos de captura, un Button para iniciar el dispositivo seleccionado y otro para iniciar la grabación. El diseño quedaría así:

El código que vamos a usar es casi una copia exacta del artículo pasado, así que esta vez sólo voy a poner el código que he usado para grabar la WebCam. Sigue leyendo

Usando una WebCam con Windows Form | Parte 1: Captura

Uno de los programas que a las personas les gusta aprender a hacer es el de controlar una cámara web mediante .NET Framework. En este artículo utilizaremos las librerías que están incluidas en el Framework de Aforge.NET para hacer un programa que interactúe con nuestra cámara web.

Primero se debe aclarar que este Framework no funciona con .NET Framework 4.0, por eso debemos cambiar el Framework de Destino: Explorador de Soluciones –> Propiedades del Proyecto (Alt + Entrar) –> Aplicación.

Ahora comencemos con nuestro Form, utilizaremos 2 PictureBox (1 para mostrar la WebCam y otro para hacer una Captura), 3 Botones (1 Para Iniciar la WebCam, otro para capturar una imagen y otro para guardar la imagen capturada) y un ComboBox (mostrará los diferentes dispositivos de video). Nos debe quedar algo como:

Sigue leyendo

Averiguar las instancias de SQL Server instaladas

Ya hace un tiempo que en el primer artículo de este blog publiqué una de las formas de cómo obtener las instancias de SQL Server instaladas en el computador. He querido retomar ese artículo pero con una nueva propuesta:

using System.Data.Sql;

public static DataTable Instancias()
{
    DataTable enume = SqlDataSourceEnumerator.Instance.GetDataSources();
    return enume;
}
private void Form1_Load ( object sender, EventArgs e )
{
    dataGridView1.DataSource = Instancias ();
}

El resultado de pedazo de código va a ser una tabla con el nombre del Servidor, el nombre de la Instancia, IsClustered y la versión de la Instancia. Les dejo una imagen de cómo queda.

Nota: SqlDataSourceEnumerator retorna todas las instancias disponibles de SQL Server incluidas en la red local.