Obtener los nombres de tus archivos de c# de una determinada ruta

Publicado por fernandelmore en 8:51 on martes, 1 de octubre de 2013
Muy buen día.


Hoy les comparto un pequeño programa que te permite obtener todos tus archivos con extensión .cs de una carpeta determinada.

lo que tienes que realizar, es crear un proyecto de WPF, y en el MainWindow, tienes que remplazar el codigo tanto del code behind asi como del xaml.

aqui tenemos el xaml que tienes que pegar en tu pantalla MainWindow

<Window x:Class="viwer.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="File Viewer" Height="350" Width="525">
    <Grid>
        <Button Content="Show .cs files" Height="23" HorizontalAlignment="Right" Margin="0,24,12,0" Name="btnGetFiles" VerticalAlignment="Top" Width="114" Click="btnGetFiles_Click" />
        <TextBox Height="23" HorizontalAlignment="Left" Margin="12,24,0,0" Name="txtPath" VerticalAlignment="Top" Width="359" />
        <TextBox Height="246" HorizontalAlignment="Left" Margin="12,53,0,0" Name="TxtFilesBox" VerticalAlignment="Top" Width="479" />
    </Grid>
</Window>

Y aquí tenemos el code-behind:

using System;
using System.Windows;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Windows.Documents;

namespace viwer
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void btnGetFiles_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                string path = txtPath.Text;

                string files = String.Empty;

                string[] listOfFiles = Directory.GetFiles(path);

                List<string> listOfNameOfFiles = new List<string>();

                foreach (var file in listOfFiles)
                {
                    FileInfo infoFile = new FileInfo(file);
                    if (infoFile.Name.Contains(".cs"))
                        listOfNameOfFiles.Add(infoFile.Name.Split('.')[0]);
                    
                }

                foreach (string file in listOfNameOfFiles)
                    files += file + "\n";

                TxtFilesBox.Text = files;
            }
            catch
            {
                MessageBox.Show("Error to try to get the files of the current path");
            }
        }
    }
}

Analicemos un poco la siguiente clase invocando a su método estático.

Directory.GetFiles(path)

La clase Directory nos permite utilizar muchas funcionalidades útiles a la hora de manipular directorios de Windows, en este caso, estamos haciendo uso del método estático GetFiles(string path).
Con este método obtendremos todos los archivos con su ruta completa.
Para poder obtener solamente el nombre del archivo, tenemos que hacer uso de otra clase llamada:

FileInfo    

Esta clase tiene una propiedad con nombre Name, es la que nosotros utilizaremos para consultar nuestros archivos “.cs”


Veamos como se ve en ejecución.



viewer
Etiquetas: , 0 comentarios

Herencia

Publicado por fernandelmore en 18:55 on martes, 10 de septiembre de 2013


Herencia.


Es un pilar del paradigma orientado a objetos que tiene como fin reutilizar componentes entre clases, como también tener una mejor clasificación de objetos y así poder representar en código una parte del mundo real.


Les dejo un link donde pueden leer una definición mucho mas completa de lo que es la herencia:
 

El objetivo de este post es representar los conceptos básicos de la herencia a través del código de una manera digerible y simple

Comencemos:


Implementación de herencia.

public class BaseClass
{
    public BaseClass()
    {
        Console.WriteLine("No message of my BaseClass");      
    }

    public BaseClass(string valueOfBaseClass)
    {
        Console.WriteLine("Constructor of BaseClass with value: {0}", valueOfBaseClass);
    }

    public void MyBaseMethod()
    {
        Console.WriteLine("my method of my base class");
    }
}

En este ejemplo creamos una clase base, como pueden notar, no es una clase abstracta, este tópico se explicara más adelante.



Como podrán observar, esta clase tiene dos constructores, uno con parámetro y el otro sin parámetros, esto es con el fin de identificar ciertas propiedades de herencia al momento de trabajar con este pilar de la programación orientada a objetos.



Tenemos un método público, no es ni virtual ni abstract, esto también se explicara más adelante.



Esto con el fin de hacer más didáctico el ejemplo.



Ahora construiremos una clase concreta que herede las características de nuestra clase anterior.



public class ConcreteClass:BaseClass
{
    public ConcreteClass()
    {
        Console.WriteLine("No message of my ConcreteClass");
    }

    public ConcreteClass(string valueOfConcreteClass)
    {
        Console.WriteLine("Constructor of ConcreteClass with value: {0}", valueOfConcreteClass);
    }

    public ConcreteClass(string valueOfConcreteClass, string valueOfBaseClass):base(valueOfBaseClass)
    {
        Console.WriteLine("Constructor of ConcreteClass with value: {0}", valueOfConcreteClass);
    }

    public void MyConcreteMethod()
    {
        Console.WriteLine("My method of my concrete class");
    }
}

Como verán, la diferencia entre saber aplicar herencia o no saber, está a dos puntos de distancia
 

La sintaxis es la siguiente:

public class ConcreteClass:BaseClass
{
}


A diferencia de la clase anterior, aquí tenemos 3 constructores:

Uno sin parámetros, uno con dos parámetros y otro con solo un parámetro.

Con la herencia, podemos mandar parámetros directamente al constructor base de nuestra clase base, con el fin de que cumpla funcionamiento especifico.

Para pasar argumentos, es necesario usar la palabra reservada base, como esta en el constructor que toma dos parámetros:

    public ConcreteClass(string valueOfConcreteClass, string valueOfBaseClass):base(valueOfBaseClass)

La clase concreta tiene un metodo que solo ella puede utilisar, pero la diferencia es que nuestra clase concreta puede usar todos los metodos publicos, propiedades y los atributos (que esten como protected o internal) de una clase base.

Ahora veamos la implementación de nuestras clases.


using System;

namespace herenciaYpolimorfismo
{
    using System.Threading;

    class Program
    {
        static void Main(string[] args)
        {
            ConcreteClass myConcreteClass = new ConcreteClass();
            Console.ReadKey();

            ConcreteClass myConcreteClass2 = new ConcreteClass("My Message For My Concrete Class");
            Console.ReadKey();

            ConcreteClass myConcreteClass3 = new ConcreteClass("My Message For My ConcreteClass", "My message for my base class");
            Console.ReadKey();

            myConcreteClass.MyBaseMethod();
            myConcreteClass.MyConcreteMethod();
            Console.ReadKey();
        }
    }
}

Al hacer una instancia de una clase concreta, lo primero que se va a instanciar es la clase base, lo podrán ver a continuación.

herencia


 pueden ver tambien este post sobre los objetos y su instancia a una clase: 



Ya por ultimo les dejo todo el código complete para que lo puedan correr en sus máquinas y les puedan quedar más claros los conceptos.


using System;

namespace herenciaYpolimorfismo
{
    using System.Threading;

    class Program
    {
        static void Main(string[] args)
        {
            ConcreteClass myConcreteClass = new ConcreteClass();
            Console.ReadKey();
            Console.WriteLine("-----------------------------------------------------------");

            ConcreteClass myConcreteClass2 = new ConcreteClass("My Message For My Concrete Class");
            Console.ReadKey();
            Console.WriteLine("-----------------------------------------------------------");

            ConcreteClass myConcreteClass3 = new ConcreteClass("My Message For My ConcreteClass", "My message for my base class");
            Console.ReadKey();
            Console.WriteLine("-----------------------------------------------------------");

            myConcreteClass.MyBaseMethod();
            myConcreteClass.MyConcreteMethod();
            Console.WriteLine("-----------------------------------------------------------");
            Console.ReadKey();
        }
    }
}


public class BaseClass
{
    public BaseClass()
    {
        Console.WriteLine("No message of my BaseClass");      
    }

    public BaseClass(string valueOfBaseClass)
    {
        Console.WriteLine("Constructor of BaseClass with value: {0}", valueOfBaseClass);
    }

    public void MyBaseMethod()
    {
        Console.WriteLine("my method of my base class");
    }
}

public class ConcreteClass:BaseClass
{
    public ConcreteClass()
    {
        Console.WriteLine("No message of my ConcreteClass");
    }

    public ConcreteClass(string valueOfConcreteClass)
    {
        Console.WriteLine("Constructor of ConcreteClass with value: {0}", valueOfConcreteClass);
    }

    public ConcreteClass(string valueOfConcreteClass, string valueOfBaseClass):base(valueOfBaseClass)
    {
        Console.WriteLine("Constructor of ConcreteClass with value: {0}", valueOfConcreteClass);
    }

    public void MyConcreteMethod()
    {
        Console.WriteLine("My method of my concrete class");
    }
}

Y bueno, esto seria todo.



Espero que este material resulte didactico y practico para todos aquellos que quieran conocer los conecptos de la programacion orientada a objetos.



Toda opinion y retroalimentación es bienvenida, mientras mas aportemos mejor.
Que pasen buen dia.
 


Etiquetas: , 0 comentarios
Suscribirse a: Entradas (Atom)