3ENGINE

Programación y otros cachivaches

Etiqueta: .NET

Página 1/7

Tecnologia

Acceso a IIS Express desde un equipo remoto


IIS Express es el servidor de desarrollo de ASP.NET que viene incorporado en Visual Studio y que también está disponible de manera gratuita para su descarga.

Esta versión recortada de IIS es perfectamente válida para desarrollos aunque esto no quita que al final para entornos de producción debas hacer el deploy en un IIS real.

Acceso desde un equipo remoto

A veces necesitamos hacer público el acceso al IIS Express para hacer pública nuestra aplicación. Por ejemplo para comprobar que la aplicación funciona en otros navegadores no disponibles en el entorno de producción, para que otras personas del equipo validen los desarrollos o simplemente porque no disponemos de un IIS real, etc..

Pasos

  1. Permitir conexiones de entrada
  2. * En Windows casi todas la conexiones de entrada están bloqueadas. Para comprobar conexiones de entrada permitidas ejecuta:

    > netsh http show urlacl
    

    * Para permitir conexiones ejecuta:

    > netsh http add urlacl url=http://08APC0501:61277/ user=todos
    

    donde url es la IP o nombre de máquina + puerto a publicar y user el nombre de usuario o grupo de usuarios (‘todos’ es ‘everyone’ si el S.O está en inglés)

  3. Añadir un regla al Firewall de Windows
  4. > netsh advfirewall firewall add rule name="IISExpressWeb" dir=in protocol=tcp localport=61277 profile=private remoteip=localsubnet action=allow
    

  5. Modificar applicationhost.config
  6. Es posible que necesites modificar el archivo de configuración de IIS Express.
    Normalmente se encuentra en C:\Users\TuUsuario\Documents\IISExpress\config\applicationhost.config

    <site name="NombreDeTuAplicacion" id="11">
    <application path="/" applicationPool="Clr4IntegratedAppPool">
       <virtualDirectory path="/" physicalPath="C:\Projectes\TuProyecto\NombreProyecto" />
    </application>
    [....]
    <bindings>
    <binding protocol="http" bindingInformation="*:61277:localhost" />
    <binding protocol="http" bindingInformation="*:61277:08APC0501" />
    </bindings>
    </site>
    




Tecnologia

Cómo generar archivos Excel en C# con Open XML


Office Open XML es un formato de archivo abierto y estándar cuyas extensiones más comunes son .docx, .xlsx y .pptx. Principalmente contiene datos en XML comprimidos en un .zip. .NET dispone de librerias capaces de trabajar con este formato y de esta manera prescindir de instalar Office y sus temidas Microsoft.Office.Interop.

Generar archivos Excel en C# con Open XML

Para la demo es necesario instalar el paquete DocumentFormat.OpenXml:

generar archivos Excel en C# con Open XML

O desde la consola de Nuget:

Install-Package DocumentFormat.OpenXml 

El código es el siguiente:

 
namespace SaveExcelApp
{
    public static class SaveExcel
    {
        
        public static void BuildExcel(DataTable dataTable, string ExcelPath)        
        {
            using (SpreadsheetDocument myWorkbook = 
                SpreadsheetDocument.Create(ExcelPath, 
                SpreadsheetDocumentType.Workbook))
            {
                // workbook Part
                WorkbookPart workbookPart = myWorkbook.AddWorkbookPart();
                var worksheetPart = workbookPart.AddNewPart();
                string relId = workbookPart.GetIdOfPart(worksheetPart);

                // file Version
                var fileVersion = new FileVersion { ApplicationName = "Microsoft Office Excel" };

                // sheets               
                var sheets = new Sheets();
                var sheet = new Sheet { Name = dataTable.TableName, SheetId = 1, Id = relId };
                sheets.Append(sheet);

                // data
                SheetData sheetData = new SheetData(CreateSheetData(dataTable));

                // add the parts to the workbook and save
                var workbook = new Workbook();
                workbook.Append(fileVersion);
                workbook.Append(sheets);
                var worksheet = new Worksheet();
                worksheet.Append(sheetData);
                worksheetPart.Worksheet = worksheet;
                worksheetPart.Worksheet.Save();
                myWorkbook.WorkbookPart.Workbook = workbook;
                myWorkbook.WorkbookPart.Workbook.Save();
                myWorkbook.Close();
            }
        }

        private static List CreateSheetData(DataTable dataTable)
        {
            List elements = new List();

            // row header
            var rowHeader = new Row();
            Cell[] cellsHeader = new Cell[dataTable.Columns.Count];
            for (int i = 0; i < dataTable.Columns.Count; i++)
            {
                cellsHeader[i] = new Cell();
                cellsHeader[i].DataType = CellValues.String;
                cellsHeader[i].CellValue = new CellValue(dataTable.Columns[i].ColumnName);
            }
            rowHeader.Append(cellsHeader);
            elements.Add(rowHeader); 
            
           // rows data
           foreach (DataRow rowDataTable in dataTable.Rows)
           {     
                var row = new Row();
                Cell[] cells = new Cell[dataTable.Columns.Count];

                for (int i = 0; i < dataTable.Columns.Count; i++)
                {
                    cells[i] = new Cell();
                    cells[i].DataType = CellValues.String;
                    cells[i].CellValue = new CellValue((string)rowDataTable[i]);
                }
                row.Append(cells); 
                elements.Add(row);            
            }                      
            return elements;
        }
    }
}

Para mi demo los datos que deseo guardar en el archivo Excel los tengo en un DataTable. Al método BuildExcel se le pasa el DataTable con los datos y la ruta completa del archivo Excel a generar. El método CreateSheetData se encarga de leer los datos del DataTable y generar las celdas. El nombre de la hoja Excel se obtiene del nombre de la tabla.

Se trata de un código sencillo pero que puede servir como punto de partida.

Y ahora una pequeña demo:

var demoTable = new DataTable("mi demo");
demoTable.Columns.Add("name");
demoTable.Columns.Add("surname");
demoTable.Columns.Add("favorite color");
demoTable.Rows.Add(new Object[] { "David", "Miro", "blue" });
demoTable.Rows.Add(new Object[] { "Pablo", "Iglesias", "yellow" });
demoTable.Rows.Add(new Object[] { "Ratoncito", "Perez", "green" });
SaveExcel.BuildExcel(demoTable, "demo.xlsx");

Y el archivo generado:

generar archivos Excel en C# con Open XML

Enlace a la demo: SaveExcel.zip




Tecnologia

ORA-00932: inconsistent datatypes: expected DATE got NUMBER


Si estas lanzando una query con Oracle Data Access y te da un error ORA-00932: inconsistent datatypes: expected DATE got NUMBER:

using (OracleConnection connection = new OracleConnection(connectionString))
{
    connection.Open();
    try
    {
        var sql = "UPDATE FILE SET CREATIONDATE = :CREATIONDATE WHERE ID = :ID";
        var cmd = new OracleCommand(sql, connection);
        cmd.Parameters.Add("ID", 5);
        cmd.Parameters.Add(new OracleParameter("IMPORTDATE", DateTime.Now));
        cmd.ExecuteNonQuery();
    }
    finally
    {
        connection.Close();
    }
}

Aunque parezca increible :-D, la razón mas probable es que el orden de los parámetros en la query no coincide con el orden en que se agregaron a la colección Parameters. Por lo tanto la solución al ejemplo anterior es cambiar el orden de inserción de los parámetros:

cmd.Parameters.Add(new OracleParameter("IMPORTDATE", DateTime.Now));
cmd.Parameters.Add("ID", 5);




Tecnologia

Campo autonumerico en Oracle


Oracle no dispone de un campo autonumérico. Para conseguir emular un campo autonumérico necesitaremos una secuencia y un trigger. A continuación los pasos.

1. Crear la tabla

CREATE TABLE NAMES
(
ID       NUMBER (10) NOT NULL,
NAME     NVARCHAR2 (200) NOT NULL
CONSTRAINT PK_NAMES PRIMARY KEY (ID)
)

2. Crear la secuencia

CREATE SEQUENCE NAMES_SEQ
START WITH 1
INCREMENT BY 1
CACHE 20;

3. Crear el trigger

CREATE OR REPLACE TRIGGER TRG_NAMES_SEQ BEFORE INSERT OR UPDATE ON NAMES
FOR EACH ROW
DECLARE
v_newVal NUMBER(12) := 0;
BEGIN
  IF INSERTING THEN
    SELECT CAFILELOG_SEQ.NEXTVAL INTO v_newVal FROM DUAL;
    :NEW.ID := v_newVal;
  END IF;
END;

Hasta aqui perfecto. Ahora puedes insertar un registro en la tabla NAMES sin preocuparte de asignarle un identificador. Ahora bien, si necesitas averiguar el identificar asignado utiliza NAMES_SEQ.CURRVAL:

INSERT INTO NAMES (NAME) VALUES ("My name");
SELECT NAMES_SEQ.CURRVAL FROM DUAL;

Con PL/SQL puedes averiguar el identificador mediante RETURNING INTO. Por ejemplo con .NET queda así:

static decimal InsertName(string name)
{
using (OracleConnection connection = new OracleConnection(connectionString))
{
decimal id = 0;
connection.Open();
OracleTransaction transaction = connection.BeginTransaction(IsolationLevel.ReadCommitted);
try
{
OracleCommand cmd = new OracleCommand("INSERT INTO NAMES (NAME) VALUES (:name) RETURNING ID INTO :myId", connection);
cmd.Parameters.Add(new OracleParameter("name", name));
cmd.Parameters.Add(new OracleParameter("myId", OracleDbType.Decimal, ParameterDirection.Output));
cmd.ExecuteNonQuery();                            
id = ((OracleDecimal)(cmd.Parameters["myId"].Value)).Value;             
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
}
finally
{
connection.Close();
}
return id;
}
}

Con Entity Framework con Code First, esto se hace con la opción DatabaseGeneratedOption.Identity de la data annotation DatabaseGenerated:

[Table("FILE", Schema = "MI")]
public class File
{
    [Key]
    [Column("ID")]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public decimal Id { get; set; }

    [Column("FILENAME")]
    public string Filename {get; set;}

    public virtual ICollection<Lines> Lines { get; set; }
}