Mensajes

[Mecano]

Pues eso, ¿alguien es capaz de reconocer la voz de esta cantante flamenca?:

• http://www.mediafire.com/download/14yjsmq6m77b7ak/Una+Rosa+Es+Una+Rosa+%28192kbit%29.m4a

Para ser sinceros llevo un buen rato buscando y nada... solo encontré muchas versiones distintas del mismo tema cantado por otros/as artistas.

La canción no me interesa, solo el nombre de la que canta el tema, pero por si sirve de algo es una versión del tema original de Mecano, "Una rosa es una rosa", del año 1991.

Saludos

[params]

Ahora vamos con la manera tediosa, pero más eficiente y sobre todo organizada.

Primero de todo, creamos un Type para representar un parámetro command-line.

Lo que deberiamos tener en cuenta en el diseño del modelo es al menos lo siguiente:

• El nombre del parámetro
• El símbolo que separa al nombre del parámetro del valor que indique el usuario en el argumento.
• El valor por defecto del parámetro (para parámetros que son opcionales, o también para argumentos vacíos. )
• El valor que le da el usuario (valor que parsearemos en los argumentos de la aplicación)
• Un flag que indique si este parámetro es opcional o no. Si no es opcional entonces deberiamos mostrar un error cuando el usuario no usa este parámetro.

( A la lista que cada cual le añada otros factores que sean importantes para sus necesidades, como pro ejemplo el orden en el que se reciben los parámetros en los argumentos. )

Ahí va (lo he convertido a C# pero no he testeado la sintaxis) :

Código (csharp) [Seleccionar] Expandir

// ***********************************************************************
// Author   : Elektro
// Modified : 09-December-2015
// ***********************************************************************

using Microsoft.VisualBasic;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;

namespace Types
{

#region " Commandline Parameter (Of T) "

/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// Represents a Commandline Parameter.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
/// <typeparam name="T">
/// The type of value that the parameter takes.
/// </typeparam>
/// ----------------------------------------------------------------------------------------------------
public class CommandlineParameter<T>
{

#region " Properties "

/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// Gets or sets a value indicating whether this parameter is required for the application.
/// <para></para>
/// A value of <see langword="true"/> means the user needs to assign a value for this parameter.
/// <para></para>
/// A value of <see langword="false"/> means this is an optional parameter so no matter if the user sets a custom value.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
/// <value>
/// <see langword="true"/> if this parameter is required for the application; otherwise, <see langword="false"/>.
/// </value>
/// ----------------------------------------------------------------------------------------------------
public bool IsRequired { get; set; }

/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// Gets or sets the parameter name.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
/// <value>
/// The parameter name.
/// </value>
/// ----------------------------------------------------------------------------------------------------
public string Name {
[DebuggerStepThrough()]
get { return this.nameB; }
[DebuggerStepThrough()]
set { this.EvaluateName(value); }
}
/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// ( Backing Field )
/// The parameter name.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
private string nameB;

/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// Gets or sets the parameter separator.
/// <para></para>
/// This character separates the parameter from the value in the argument.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
/// <value>
/// The parameter separator.
/// </value>
/// ----------------------------------------------------------------------------------------------------
public char Separator {
[DebuggerStepThrough()]
get { return this.separatorB; }
[DebuggerStepThrough()]
set { this.EvaluateSeparator(value); }
}
/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// ( Backing Field )
/// The parameter separator.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
private char separatorB;

/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// Gets or sets the parameter value.
/// <para></para>
/// This value should be initially <see langword="Nothing"/> before parsing the commandline arguments of the application;
/// <para></para>
/// the value of the parameter should be assigned by the end-user when passing an argument to the application.
/// <para></para>
/// To set a default value for this parameter, use <see cref="CommandlineParameter(Of T).DefaultValue"/> property instead.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
/// <value>
/// The parameter value.
/// </value>
/// ----------------------------------------------------------------------------------------------------
public T Value { get; set; }

/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// Gets or sets the default parameter value.
/// <para></para>
/// This value should be take into account if, after parsing the commandline arguments of the application,
/// <see cref="CommandlineParameter(Of T).Value"/> is <see langword="Nothing"/>,
/// meaning that the end-user didn't assigned any custom value to this parameter.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
/// <value>
/// The default parameter value.
/// </value>
/// ----------------------------------------------------------------------------------------------------
public T DefaultValue { get; set; }

#endregion

#region " Operator Overloading "

/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// Performs an implicit conversion from <see cref="CommandlineParameter(Of T)"/> to <see cref="CommandlineParameter"/>.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
/// <param name="param">
/// The <see cref="CommandlineParameter(Of T)"/> to convert.
/// </param>
/// ----------------------------------------------------------------------------------------------------
/// <returns>
/// The result of the conversion.
/// </returns>
/// ----------------------------------------------------------------------------------------------------
public static implicit operator CommandlineParameter(CommandlineParameter<T> param)
{

return new CommandlineParameter {
Name = param.Name,
Separator = param.Separator,
DefaultValue = param.DefaultValue,
Value = param.Value,
IsRequired = param.IsRequired
};

}

#endregion

#region " Private Methods "

/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// Evaluates an attempt to assign the parameter name.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
/// <param name="name">
/// The parameter name.
/// </param>
/// ----------------------------------------------------------------------------------------------------
/// <exception cref="ArgumentException">
/// The parameter name cannot contain the separator character.;name
/// </exception>
/// ----------------------------------------------------------------------------------------------------

protected virtual void EvaluateName(string name)
{
if (!(this.separatorB.Equals(null)) && (name.Contains(this.separatorB))) {
throw new ArgumentException(message: "The parameter name cannot contain the separator character.", paramName: "name");

} else {
this.nameB = name;

}

}

/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// Evaluates an attempt to assign the parameter separator.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
/// <param name="separator">
/// The parameter separator.
/// </param>
/// ----------------------------------------------------------------------------------------------------
/// <exception cref="ArgumentException">
/// The parameter separator cannot be any character contained in the parameter name.;separator
/// </exception>
/// ----------------------------------------------------------------------------------------------------

protected virtual void EvaluateSeparator(char separator)
{
if (!(string.IsNullOrEmpty(this.nameB)) && (this.nameB.Contains(separator))) {
throw new ArgumentException(message: "The parameter separator cannot be any character contained in the parameter name.", paramName: "separator");

} else {
this.separatorB = separator;

}

}

#endregion

}

#endregion

#region " Commandline Parameter (Of Object) "

/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// Represents a Commandline Parameter.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
public sealed class CommandlineParameter : CommandlineParameter<object>
{}

#endregion

}

//=======================================================
//Service provided by Telerik (www.telerik.com)
//=======================================================



Una vez tenemos la base de como representar de forma abstracta un parámetro commandline, creamos las instancias de nuestro Type para crear los parámetros.

( En este ejemplo creo un parámetro que toma como valor una cadena de texto, otro parámetro que toma como valor un booleano, y un array con dichos parámetros. )

Código (csharp) [Seleccionar] Expandir

private readonly CommandlineParameter<string> param1 = new CommandlineParameter<string> {
Name = "/Switch1",
Separator = '=',
DefaultValue = "Hello World",
IsRequired = true
};

private readonly CommandlineParameter<bool> param2 = new CommandlineParameter<bool> {
Name = "/Switch2",
Separator = '=',
DefaultValue = false,
IsRequired = false
};

CommandlineParameter[] @params = {
param1,
param2
};

El modo en que se usuaría la aplicación sería el siguiente:

Código [Seleccionar] Expandir

Aplicación.exe /switch1="valor1" /switch2="true" o "false"
(el orden de los parámetros no importa, y las comillas dobles tampoco, excepto para encerrar strings con espacios en blanco)



Ahora nos faltaría desarrollar el algoritmo de un método que tome como argumento (pasando por referencia) la representación de los parámetros para asignarles los valores y (pasando por valor) los argumentos commandline de la aplicación.

Nota: Adicionalmente le añadí dos parámetros que toman delegados para notificar cuando se encuentra un error de sintaxis o un parámetro requerido que no ha sido encontrado en los argumentos.

Código (csharp) [Seleccionar] Expandir

/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// Loop through all the command-line arguments of this application.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
/// <param name="params">
/// The commandline parameters.
/// </param>
///
/// <param name="callbackSyntaxError">
/// An encapsulated method that is invoked if a syntax error is found in one of the arguments.
/// </param>
///
/// <param name="callbackMissingRequired">
/// An encapsulated method that is invoked if a required parameter is missing in the arguments.
/// </param>
/// ----------------------------------------------------------------------------------------------------
private void ParseArguments(ref CommandlineParameter[] @params, Action<CommandlineParameter> callbackSyntaxError, Action<CommandlineParameter> callbackMissingRequired) {
ParseArguments(ref @params, Environment.GetCommandLineArgs.Skip(1), callbackSyntaxError, callbackMissingRequired);
}

/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// Loop through all the command-line arguments of this application.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
/// <param name="params">
/// The commandline parameters.
/// </param>
///
/// <param name="args">
/// The collection of commandline arguments to examine.
/// </param>
///
/// <param name="callbackSyntaxError">
/// An encapsulated method that is invoked if a syntax error is found in one of the arguments.
/// </param>
///
/// <param name="callbackMissingRequired">
/// An encapsulated method that is invoked if a required parameter is missing in the arguments.
/// </param>
/// ----------------------------------------------------------------------------------------------------
private void ParseArguments(ref CommandlineParameter[] @params, IEnumerable<string> args, Action<CommandlineParameter> callbackSyntaxError, Action<CommandlineParameter> callbackMissingRequired) {

List<CommandlineParameter> paramRequired = (from param in @paramswhere param.IsRequired).ToList;

foreach (string arg in args) {

foreach (CommandlineParameter param in @params) {

if (arg.StartsWith(param.Name, StringComparison.OrdinalIgnoreCase)) {
if (!arg.Contains(param.Separator)) {
callbackSyntaxError.Invoke(param);
return;

} else {
string value = arg.Substring(arg.IndexOf(param.Separator) + 1);

if ((paramRequired.Contains(param))) {
paramRequired.Remove(param);
}

if (string.IsNullOrEmpty(value)) {
param.Value = param.DefaultValue;
continue;

} else {
try {
param.Value = Convert.ChangeType(value, param.DefaultValue.GetType());
continue;

} catch (Exception ex) {
callbackSyntaxError.Invoke(param);
return;

}

}

}

}

}

}

if ((paramRequired.Any)) {
callbackMissingRequired.Invoke(paramRequired.First);
}

}

//=======================================================
//Service provided by Telerik (www.telerik.com)
//=======================================================



Por último, así es como usariamos dicho método:

Código (csharp) [Seleccionar] Expandir

static void Main(string[] args) {
   ParseArguments(ref @params, args, Parameter_OnSyntaxError, Parameter_OnMissingRequired)
   // Llegados a este punto todo fue exitoso. Continuar con la lógica...
}

private void Parameter_OnSyntaxError(CommandlineParameter param) {
Console.WriteLine(string.Format("[X] Syntax error in parameter: {0}", param.Name));
Environment.Exit(exitCode: 1);
}

private void Parameter_OnMissingRequired(CommandlineParameter param) {
Console.WriteLine(string.Format("[X] Parameter required: {0}", param.Name));
Environment.Exit(exitCode: 1);
}

Nota: La declaración del array params está en el código de arriba.

Una imagen:




No se si este tocho que he escrito será demasiado tedioso (demasiado código para vagos xD) pero ahí lo dejo para quien le sirva la idea.

Saludos!

[C# read console arguments]

La verdad que no sabia ni por donde empezar, y a pesar de buscarlo con mis palabras, no conseguia encontrar nada.

Desde mi ignorancia me atrevo a decir que probablemente no encuentras información al respecto por que la intentas buscar en Español.
( excepto si utilizases el buscador de la MSDN en Español, claro está. )

Digo yo que una simple búsqueda en Google por palabras clave como "C# read console arguments" te habría sobrado para salir de dudas, y como ves usando términos que ya conocías.

Muchísimas gracias Elektro , por cierto, felicitarte por la API que has publicado hace poco, muy buena, y por lo del magnetismo para las ventanas.

Gracias a ti por el comentario.

Venga, te lo has ganado, no quería ponertelo del todo facl en la parte más importante pero por si te sirve de algo te mostraré como suelo parsear los argumentos (argumentos que sigan las reglas de sintaxis que te comenté en el otro comentario. )

Primero te comentaré la manera más facil (o vaga); lo que yo suelo hacer es declarar una variable por cada argumento en el código fuente (ya que se supone que cada argumento que el usuario pase debe corresponder a un objeto/variable cuyo valor sea asignado en el código fuente),
y entonces con este método parseo los argumentos y le asigno los valores a esas variables:

( Esto es un código traducido al vuelo de Vb.Net a C# )

Código (csharp) [Seleccionar] Expandir

private string variable;

private void ParseArguments(IEnumerable<string> args = null) {

foreach (string arg in args) {
switch (true) {
case arg.StartsWith("/?"):
                                // Print Help.
break;

case arg.StartsWith("/Switch1=", StringComparison.OrdinalIgnoreCase):
variable = arg.Substring(arg.IndexOf("=") + 1);
break;
}

}
}

//=======================================================
//Service provided by Telerik (www.telerik.com)
//=======================================================

Es una solución simple pero efectiva hasta cierto punto ya que no hay controles de errores, pero siempre puedes adaptarlo para que sea tan sofisticado que quieras que sea.

Saludos!

[Environment.GetCommandLineArgs - MSDN]

Para obtener los argumentos que se han pasado por linea de comandos, puedes utilizar el siguiente método:

• Environment.GetCommandLineArgs - MSDN

Para "enviar una respuesta" lo harías escribiendo en el buffer de la consola, con el siguiente método:

• Console.WriteLine - MSDN

(o Console.Write)

Al finalizar la ejecución de la aplicación no olvides enviar un código de salida apropiado utilizando el siguiente método:

• Environment.Exit - MSDN

Para parsear la sintaxis de los argumento en cuestión eso siempre es trabajo del programador, mediante la manipulación de string (un split, un substring, etc).

Código [Seleccionar] Expandir

miprograma.exe --show "Hello World"

En ese ejemplo que has mostrado tienes que comprobar que el primer argumento sea un identificador (--cosa) y que exista un string adicional, y que ese string adicional no sea otro identificador sino el valor del parámetro que esperas (ya que el usuario se puede equivocar, y eso requiere un control de errores);
Yo te sugiero utilizar una sintaxis mucho más cómoda y apropiada para el parsing de argumentos command-line (tomando como ejemplo el diseño de algunas aplicaciones de la SDK de Microsoft):

Código [Seleccionar] Expandir

Aplicación.exe /Switch="Valor"
o si lo prefieres así...:

Código [Seleccionar] Expandir

Aplicación.exe --Switch="Valor"

De esa manera lo tienes todo en un único string o argumento facilmente delimitable mediante el símbolo "=", evitando la necesidad de parsear/evaluar un argumento adicional.

Saludos.

Una de las razones de que sea tan popular es por que la libertad de expresión allí es ...sin censura, por así decirlo. A la gente le encanta trollear, y ese es el lugar favorito de los trolls de máximo nivel.

En otras palabras, lo que ha dicho @Drvy.

Saludos

[Epic Music World I]

El torrent que mencioné ayer ya se me ha descargado, uf, es genial, hay de todo.

Aparte, acabo de encontrar varios canales en youtube que solo suben temas sueltos de música épica, y por suerte son bastante organizados en lo que se refiere a poner el título del tema. Los dejo aquí por si a alguien le interesa:

• Epic Music World I
• Epic Music World II
  
• Trailer Music World I
• Trailer Music World II
  
• Epic Music VN

Es perfecto para descargar las listas de reproducción con JDownloader u otro administrador de descargas .

Saludos

[nada de nada]

El código de arriba en F# ejecuta la entrada:
...
No se si esto es normal.

¿Realmente esto de aquí abajo no te dice nada de nada?, por que ya te expliqué el motivo en otro post recientemente.

Código (csharp,1,2,3) [Seleccionar] Expandir

let  cmdLine = System.Environment.GetCommandLineArgs()
if   cmdLine.Length < 2
   then System.Console.WriteLine "Error: archivo READTAPE"
else ReadRaw cmdLine.[1]

De todas formas el código de ese snippet está adaptado para leer el puerto de un dispositivo en específico que envia una cantidad de datos en particular; en lugar de copiar/pegar y traducir códigos aleatorios deberías empezar a practicar con otras cosas mucho más simples en C# (o F#), empezando por búcles, ifs, tipos de excepciones de .Net framework, etc, para ir entendiendo muchas cosas básicas que te ayuden a avanzar. Ya es hora de que te introduzcas en ese aspecto para adquirir características resolutivas a todo tipo de problemas (como este). Ponte a practicar otras cosas generales, ese es mi consejo.

Saludos

Se me ocurren varias opciones.

1. Un mensaje privado mediante el foro.
2. Un email mediante el email que aparece en el perfil de usuario del moderador en particular.
3. Un email a staff@elhacker.net
4. Haciendo uso del botón "reportar mensaje".
   El reporte lo recibe el moderador que modera esa sección, y tambien el resto de moderadores globales.
5. En el canal IRC no oficial de elhacker.net, que si no tengo mal entendido, suele o solia estar casi siempre presente un moderador global muy conocido (no digo su nombre para evitar que le acosen a preguntas por allá xD).

Saludos

[[SOURCE] Imgur Uploader.Net v1.1]

Aprovecho para recomendar una de mis aplicaciones públicas, la cual personalmente me resulta muy util para ahorrarme tiempo al querer compartir en el foro imágenes que tengo en mi PC.
Simplemente instalar, click derecho en cualquier imagen local, y listo.

• [SOURCE] Imgur Uploader.Net v1.1

Saludos

[Serial Port Reader in F#]

saber si se puede usar el puerto serie en F#.

Que no haya un código demostrativo en MSDN no significa que no se pueda, a veces solo hay ejemplos para Vb.Net, C#, o C++ administrado, pero excepto algunas diferencias todos pueden realizar practicamente lo mismo usando código administrado (la librería de classes de .Net Framework), aunque a veces no es así.

F# es un lenguaje multi-plataforma desarrollado por Microsoft (entre otros) completamente soportador por .Net Framework.

• Serial Port Reader in F#

Lo único es que creo que tiene ciertas limitaciones para el desarrollo de aplicación con interfáz gráfica.

Saludos