Expresiones Regulares

Capturando Grupos:

• C#:

using System.Text.RegularExpressions;

//...

Regex myRegex = new Regex(@".*(?RegexLoQueSea).*"
   ,RegexOptions.IgnoreCase|RegexOptions.Multiline|...);

MatchCollection myMatchCollection = myRegex.Matches(inputText);

foreach (Match myMatch in myMatchCollection)
{
    string encontrado = myMatch.Groups["MyGroup"].Value;
}

Recursos:

• Para probar las espresiones regulares:

http://regexpal.com/

http://erik.eae.net/playground/regexp/regexp.html

 

DataSet to Excel (c#)

Buenas,

Para pasar las tablas contenidas en uno o mas DataSet(s).
Es un poco básico ya que no escribo los nombres de las columnas ni nada, pero espero que le sirva de ayuda a alguien. También es probable que haya formas más eficientes de hacer esto, pero puede servir como base.

Acordaros de añadir las refencias en el proyecto.

using Excel = Microsoft.Office.Interop.Excel;
...
public static string DatasetToExcel(List<DataSet> Lds, String name)
        {
            //compruebo a ver si puedo crear el fichero.
            string excelPath = Path.Combine(System.IO.Path.GetTempPath(),name+".xls");
            if (File.Exists(excelPath))
            {
                try
                {
                    File.Delete(excelPath);
                }
                catch (Exception e)
                {
                    throw e;
                }
            }

            //creo el excel
            object misValue = System.Reflection.Missing.Value;
            Excel.Application excelApp;
            Excel.Workbook myworkbook;
            Excel.Worksheet myWorkSheet;

            //nueva aplicación excel.
            excelApp = new Excel.Application();
            
            //añadimos un workbook
            myworkbook = excelApp.Workbooks.Add(Excel.XlWBATemplate.xlWBATWorksheet);

            int worksheetIndex = 1;
            foreach (DataSet ds in Lds)
            {
                foreach (DataTable dt in ds.Tables)
                {
                    //una worksheet para cada tabla nueva.
                    myworkbook.Worksheets.Add(misValue,
excelApp.ActiveWorkbook.Worksheets[excelApp.ActiveWorkbook.Worksheets.Count], worksheetIndex, misValue);
                    
                    //selecciono la última worksheet creada para escribir ahí los datos
                    myWorkSheet = (Excel.Worksheet)myworkbook.Sheets[worksheetIndex];

                    int rowIndex = 1;
                    foreach (DataRow row in dt.Rows)
                    {
                        int columnIndex = 1;
                        
                        foreach (object dc in row.ItemArray)
                        {
                            myWorkSheet.Cells[rowIndex, columnIndex] = dc.ToString();
                            columnIndex++;
                        }
                        rowIndex++;
                    }
                    worksheetIndex++;
                }
            }

            myworkbook.SaveAs(excelPath, Excel.XlFileFormat.xlWorkbookNormal, misValue, misValue, misValue, misValue, Excel.XlSaveAsAccessMode.xlExclusive, misValue, misValue, misValue, misValue, misValue);
            myworkbook.Close(true, misValue, misValue);
            excelApp.Quit();

            return excelPath;
        }

Y recordad…

Iteraciones sobre listas con condicionales (Linq)

Supongamos que tenemos una lista de objetos de tipo persona (objeto que puede tener campos como edad, altura, peso, etc.) llamada “personas”
Supongamos que queremos contar cuantas personas que tienen 35 años.

int contador = Personas.Where( p  => p.Edad == 35).Count();

En el método “where” se debe poner una función de tipo booleano que se aplicará a cada elemento de la lista.
El metodo crea automáticamente un objeto del tipo de la lista con el que podremos hacer la comprobación deseada. El nombre del objeto lo ponemos nosotros y puede ser el que nos venga en gana (he puesto ‘p’ como podría haber puesto “persona”).

Si hubiesemos querido devolver una lista con las personas de dicha edad solo tendríamos que haber hecho lo siguiente:

var treintaYtantos = Personas.Where( p => p.Edad == 35).ToList();

String to Hex (c#)

Supongamos que tenemos dos campos en una tabla de una BBDD:

-Dato (varchar)= 04000000
-TipoDeDato (varchar): Dword

Lo que nosotros obtenemos son dos string. Si queremos pasar dicho el dato a su verdadero tipo, que es un DWORD, para trabajar con el:

int32 numero = Convert.ToInt32(_value, 16); 
//_value=04000000
//numero= 0x04000000 (67108864 en decimal)

Si ademas el valor en hexadecimal guardado en BBDD estaba en Little Endian, lo podemos pasar a Big endían de la siguiente forma:

int32 numero = IPAddress.HostToNetworkOrder(Convert.ToInt32(HexValueString,16))
//_value=04000000
//numero= 0x00000004 (4 en decimal)

Para pasar el número decimal obtenido a hexadecimal:

string hexString = numero.ToString("X");

Y eso es todo.

Collate (SQL)

Cuando se realizan consultas entre distintas bases de datos puede pasar que cada una una utilice distintas codificaciones para guardar la información. En ese caso habrá que convertir los campos correspondientes a la misma codificación para que SQL pueda realizar las comparaciones correctamente.

La clausula collate debe ir detras de los campos que difieran de la codificación.

Pej:

select Field1,
from table
where Field1 not in (select AnotherDBField collate SQL_Latin1_General_CP1_CI_AS
        from [DBServer].[DataBase].[dbo].Table
        where AnotherDBField collate SQL_Latin1_General_CP1_CI_AS like '%X%' )

Mas info: Aquí

Usando BCP

Se puede usar el comando bcp para introducir datos a una BBDD en bloque (al igual que un bulk insert). La ventaja del bcp es que al ser un ejecutable, se puede automatizar fácilmente.

Se recomienda crear un fichero de formato de la tabla donde se van a insertar los datos para mayor coherencia. Para crearlo (en XML):

bcp [DBname].[dbo].[TableName] format nul -f FicheroSalida.xml -x -n -S ServerName -U User -P Pswdr

Más info: Aquí

Una vez creado el fichero únicamente queda ejecutar el bcp:

bcp [DBname].[dbo].[TableName] in FicheroAImportar.txt -S ServerName -U Usr -P Pswrd -f FormatFile.xml

Mas información sobre el BCP: Aquí

Control de errores en perl

Si necesitamos realizar operaciones complejas cuando se produce un error y no solo imprimirlo por pantalla podemos probar con lo siguiente:

Primero crear la función que hará lo que queramos.

sub ControlDeErrores{
    my $error= shift;
    my $subject;
    my $body;
    ... 
    ...

    AUX_SendMail($subject,$subject,$body);
    #En otro post explico el envío de mails
}   

Después solo hay que llamar a esa función donde creamos conveniente:

...
open (MYFILE,">.\\path\\".$fileName) or die ControlDeErrores($!);
#La variable especial $! es la que contiene el msg de error
...