elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: [Aporte] Mejores practicas en Java


  Mostrar Mensajes
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 [13] 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 ... 1017
121  Programación / Programación General / Re: ¿Que tipo de VPS seleccionar para ejecutar 100 hilos? en: 31 Julio 2017, 06:35
disculpa, nunca me metí en el lio de mono... pero no era super limitaday era una vago intento de netframework incompleto?... eso recuerdo hasta la ultima vez que vi el proyecto :s

Pienso algo parecido (limitada e innecesaria) pero yo no apoyo el uso de Mono, simplemente era una alternativa y como tal me sentí en la obligación moral de mencionarla. Hay muchas cosas sin implementar, empezando por la odiosa ausencia de soporte para utilizar diréctamente el lenguaje VB.NET, al igual que la ausencia de muchas librerías 7 namespaces de la librería de clases de .NET Framework, y además de eso no soporta todas las tecnologías de .NET Framework:


Pero bueno, por otro lado tampoco voy a menospreciar Mono demasiado, ya que tengo bien sabido que para los programadores de Unity (por ejemplo) Mono es la única opción que tienen para programar en ".NET" y por eso es de agradecer cuanto más se actualice Mono para proveerles caracteristicas esenciales y time-savers de la programación en C# (como el poder utilizar tipos genéricos, LINQ y colecciones Enumerables, que hasta no hace mucho tengo entendido que no podían usar nada de eso por la incopatibilidad de Mono).

Saludos
122  Programación / Programación Visual Basic / Re: Deplazar imágen en: 31 Julio 2017, 06:30
¿VB6, o VB.NET?.

En caso de ser en VB.NET, puedes traducir este ejemplo para C#:

Más ejemplos probablemente aquí:
Saludos
123  Programación / .NET / Re: un programa que quiero hacer, que cuando se ejecute puedas poner opciones en: 31 Julio 2017, 05:54
Aquí tienes todo lo que necesitas saber:
( revisa las distintas secciones de la guía, en el panel lateral izquierdo de la página. )



El siguiente código lo puedes usar tal cual, o si lo prefieres tomarlo como un simple ejemplo que estudiar. Todo este código es un extracto reducido de mi framework comercial ElektroKit para .NET Framework, que si a alguien le interesa lo puede encontrar en mi firma de usuario...

Mediante la clase CommandLineParameter se pueden representar parámetros sin valor ( ej. /Command1 ), mediante la clase CommandLineValueParameter(Of T) parámetros con valor ( ej. /Path="C:\Directory\" ). Mediante la clase CommandLineParameterCollection una coleccion de CommandLineParameter, y por último, mediante la clase CommandLineValueParameterCollection una coleccion de CommandLineValueParameter(Of T).

Como puedas usar esas clases, es algo que depende de las necesidades de cada programador.

Hay tres tipos de prefijos que puedes usar al asignar el nombre del parámetro: /Nombre \Nombre y -Nombre
Y dos tipos de sufijos o separadores disponibles para los parámetros con valor: /Nombre:Valor y /Nombre=Valor

(Sí, la sintaxis está enfocada al modo de empleo de argumentos command-line en el sistema de Microsoft Windows. )

Si por cualquier motivo no gusta o no entiendes como utilizar mi implementación, entonces puedes buscar otras en Google (que hay bastantes implementaciones en C# y VB.NET para representar argumentos command-line, la verdad).

En fin, aquí tienes el código:

Código
  1. ''' <summary>
  2. ''' Specifies the prefix character that indicates the start of the parameter's name of a <see cref="CommandLineParameter"/>
  3. ''' </summary>
  4. Public Enum CommandLineParameterPrefix As Integer
  5.  
  6.    ''' <summary>
  7.    ''' The dash character "-"
  8.    ''' <para></para>
  9.    ''' For example: "-ParameterName"
  10.    ''' </summary>
  11.    Dash = 0
  12.  
  13.    ''' <summary>
  14.    ''' The slash character "/"
  15.    ''' <para></para>
  16.    ''' For example: "/ParameterName"
  17.    ''' </summary>
  18.    Slash = 1
  19.  
  20.    ''' <summary>
  21.    ''' The slash character "\"
  22.    ''' <para></para>
  23.    ''' For example: "\ParameterName"
  24.    ''' </summary>
  25.    BackSlash = 2
  26.  
  27. End Enum
  28.  
  29. ''' <summary>
  30. ''' Specifies the suffix character that delimits the parameter's name from the parameter's value of a <see cref="CommandLineParameter"/>
  31. ''' </summary>
  32. Public Enum CommandLineParameterSuffix As Integer
  33.  
  34.    ''' <summary>
  35.    ''' The equals sign character "="
  36.    ''' <para></para>
  37.    ''' For example: "/ParameterName=Value"
  38.    ''' </summary>
  39.    EqualsSign = 0
  40.  
  41.    ''' <summary>
  42.    ''' The colon character ":"
  43.    ''' <para></para>
  44.    ''' For example: "/ParameterName:Value"
  45.    ''' </summary>
  46.    Colon = 1
  47.  
  48. End Enum

CommandLineParameter.vb
Código
  1. #Region " Command-Line Parameter "
  2.  
  3.    ''' <summary>
  4.    ''' Represents a command-line parameter that does not takes any value.
  5.    ''' </summary>
  6.    Public Class CommandLineParameter
  7.  
  8. #Region " Properties "
  9.  
  10.        ''' <summary>
  11.        ''' Gets or sets the prefix character that indicates the start of the parameter's name.
  12.        ''' <para></para>
  13.        ''' For example: "/ParameterName" where "/" is the prefix.
  14.        ''' </summary>
  15.        Public Property Prefix As CommandLineParameterPrefix = CommandLineParameterPrefix.Slash
  16.  
  17.        ''' <summary>
  18.        ''' Gets the name of the parameter.
  19.        ''' </summary>
  20.        Public ReadOnly Property Name As String
  21.            Get
  22.                Return Me.nameB
  23.            End Get
  24.        End Property
  25.        Private nameB As String
  26.  
  27.        ''' <summary>
  28.        ''' Gets or sets the short name of the parameter.
  29.        ''' <para></para>
  30.        ''' A short name should be an abbreviated name of the parameter. A short name is optional and can de null.
  31.        ''' </summary>
  32.        Public Property ShortName As String
  33.            Get
  34.                Return shortNameB
  35.            End Get
  36.            <DebuggerStepThrough>
  37.            Set(ByVal value As String)
  38.                Me.TrySetShortName(value)
  39.            End Set
  40.        End Property
  41.        Private shortNameB As String
  42.  
  43.        ''' <summary>
  44.        ''' Gets the full name of the parameter including the prefix.
  45.        ''' <para></para>
  46.        ''' For Example: "/ParameterName"
  47.        ''' </summary>
  48.        Public ReadOnly Property FullName As String
  49.            Get
  50.                Return Me.ToString()
  51.            End Get
  52.        End Property
  53.  
  54.        ''' <summary>
  55.        ''' Gets the full short name of the parameter including the prefix.
  56.        ''' <para></para>
  57.        ''' For Example: "/ParameterShortName"
  58.        ''' </summary>
  59.        Public ReadOnly Property FullShortName As String
  60.            Get
  61.                If Not String.IsNullOrEmpty(Me.shortNameB) Then
  62.                    Return String.Format("{0}{1}", Me.GetPrefixChar(), Me.shortNameB)
  63.  
  64.                Else
  65.                    Return Me.ToString()
  66.  
  67.                End If
  68.            End Get
  69.        End Property
  70.  
  71.        ''' <summary>
  72.        ''' Gets or sets a value indicating whether this parameter is required for the application.
  73.        ''' <para></para>
  74.        ''' A value of <see langword="False"/> means the user needs to pass this parameter to the application.
  75.        ''' <para></para>
  76.        ''' A value of <see langword="True"/> means this is an optional parameter so no matter if the user pass this parameter to the application.
  77.        ''' </summary>
  78.        Public Property IsOptional As Boolean
  79.  
  80. #End Region
  81.  
  82. #Region " Constructors "
  83.  
  84.        ''' <summary>
  85.        ''' Prevents a default instance of the <see cref="CommandLineParameter"/> class from being created.
  86.        ''' </summary>
  87.        Private Sub New()
  88.        End Sub
  89.  
  90.        ''' <summary>
  91.        ''' Initializes a new instance of the <see cref="CommandLineParameter" /> class.
  92.        ''' </summary>
  93.        ''' <param name="name">
  94.        ''' The name of the parameter.
  95.        ''' </param>
  96.        Public Sub New(ByVal name As String)
  97.            If String.IsNullOrWhiteSpace(name) Then
  98.                Throw New ArgumentNullException()
  99.            End If
  100.  
  101.            Me.TrySetName(name)
  102.        End Sub
  103.  
  104. #End Region
  105.  
  106. #Region " Public Methods "
  107.  
  108.        ''' <summary>
  109.        ''' Returns a <see cref="String"/> that represents this <see cref="CommandLineParameter"/>.
  110.        ''' </summary>
  111.        Public Overloads Function ToString() As String
  112.            Return String.Format("{0}{1}", Me.GetPrefixChar(), Me.nameB)
  113.        End Function
  114.  
  115.        ''' <summary>
  116.        ''' Gets the prefix character that indicates the start of the parameter's name.
  117.        ''' <para></para>
  118.        ''' For Example: "/"
  119.        ''' </summary>
  120.        Public Function GetPrefixChar() As Char
  121.            Select Case Me.Prefix
  122.                Case CommandLineParameterPrefix.Dash
  123.                    Return "-"c
  124.                Case CommandLineParameterPrefix.Slash
  125.                    Return "/"c
  126.                Case CommandLineParameterPrefix.BackSlash
  127.                    Return "\"c
  128.                Case Else
  129.                    Throw New InvalidEnumArgumentException()
  130.            End Select
  131.        End Function
  132.  
  133. #End Region
  134.  
  135. #Region " Private Methods "
  136.  
  137.        ''' <summary>
  138.        ''' Evaluates an attempt to assign the parameter name.
  139.        ''' </summary>
  140.        <DebuggerStepThrough>
  141.        Protected Overridable Sub TrySetName(ByVal name As String)
  142.  
  143.            For Each c As Char In name
  144.                If Not Char.IsLetterOrDigit(c) Then
  145.                    Throw New ArgumentException(message:="The name of the parameter only can contain letters and digits.",
  146.                                                paramName:="name")
  147.                End If
  148.            Next c
  149.  
  150.            Me.nameB = name
  151.  
  152.        End Sub
  153.  
  154.        ''' <summary>
  155.        ''' Evaluates an attempt to assign the short name of the parameter.
  156.        ''' </summary>
  157.        <DebuggerStepThrough>
  158.        Protected Overridable Sub TrySetShortName(ByVal shortName As String)
  159.  
  160.            If Not String.IsNullOrEmpty(shortName) Then
  161.  
  162.                For Each c As Char In shortName
  163.                    If Not Char.IsLetterOrDigit(c) Then
  164.                        Throw New ArgumentException(message:="The short name of the parameter only can contain letters and digits.",
  165.                                                    paramName:="shortName")
  166.                    End If
  167.                Next c
  168.  
  169.                If (shortName.Equals(Me.nameB, StringComparison.OrdinalIgnoreCase)) Then
  170.                    Throw New ArgumentException(message:="The short name of the parameter cannot be equals than the parameter's name.",
  171.                                                paramName:="shortName")
  172.                End If
  173.  
  174.            End If
  175.  
  176.            Me.shortNameB = shortName
  177.  
  178.        End Sub
  179.  
  180. #End Region
  181.  
  182.    End Class
  183.  
  184. #End Region

CommandLineValueParameter(Of T As IConvertible).vb
Código
  1. #Region " Command-Line Value Parameter (Of T) "
  2.  
  3.    ''' <summary>
  4.    ''' Represents a command-line parameter that takes a value of specific <see cref="Type"/>.
  5.    ''' </summary>
  6.    Public Class CommandLineValueParameter(Of T As IConvertible) : Inherits CommandLineParameter
  7.  
  8. #Region " Properties "
  9.  
  10.        ''' <summary>
  11.        ''' Gets or sets the suffix character that delimits the parameter's name from the parameter's value.
  12.        ''' <para></para>
  13.        ''' For example: "/ParameterName=Value" where "/" is the prefix and "=" the suffix.
  14.        ''' </summary>
  15.        Public Property Suffix As CommandLineParameterSuffix = CommandLineParameterSuffix.EqualsSign
  16.  
  17.        ''' <summary>
  18.        ''' Gets or sets the parameter's value defined by the end-user.
  19.        ''' <para></para>
  20.        ''' This value should be initially <see langword="Nothing"/> before parsing the commandline arguments of the application.
  21.        ''' <para></para>
  22.        ''' The value of the parameter should be assigned by the end-user when passing an argument to the application.
  23.        ''' <para></para>
  24.        ''' To set a default value for this parameter, use <see cref="CommandLineValueParameter(Of T).DefaultValue"/> property instead.
  25.        ''' </summary>
  26.        Public Property Value As T
  27.  
  28.        ''' <summary>
  29.        ''' Gets or sets the default parameter's value.
  30.        ''' <para></para>
  31.        ''' This value should be take into account if, after parsing the command-line arguments of the application,
  32.        ''' <see cref="CommandLineValueParameter(Of T).Value"/> is <see langword="Nothing"/>,
  33.        ''' meaning that the end-user did not assigned any value to this parameter.
  34.        ''' </summary>
  35.        Public Property DefaultValue As T
  36.  
  37. #End Region
  38.  
  39. #Region " Constructors "
  40.  
  41.        ''' <summary>
  42.        ''' Initializes a new instance of the <see cref="CommandLineValueParameter(Of T)" /> class.
  43.        ''' </summary>
  44.        ''' <param name="name">
  45.        ''' The name of the parameter.
  46.        ''' </param>
  47.        Public Sub New(ByVal name As String)
  48.            MyBase.New(name)
  49.        End Sub
  50.  
  51. #End Region
  52.  
  53. #Region " Public Methods "
  54.  
  55.        ''' <summary>
  56.        ''' Returns a <see cref="String"/> that represents this <see cref="CommandLineValueParameter(Of T)"/>.
  57.        ''' </summary>
  58.        Public Overloads Function ToString() As String
  59.            Return String.Format("{0}{1}""{2}""", MyBase.ToString(), Me.GetSuffixChar(),
  60.                                                  If(Me.Value IsNot Nothing, Me.Value.ToString(Nothing), Me.DefaultValue.ToString(Nothing)))
  61.        End Function
  62.  
  63.        ''' <summary>
  64.        ''' Gets the suffix character that delimits the parameter's name from the parameter's value.
  65.        ''' <para></para>
  66.        ''' For Example: "="
  67.        ''' </summary>
  68.        Public Function GetSuffixChar() As Char
  69.            Select Case Me.Suffix
  70.                Case CommandLineParameterSuffix.Colon
  71.                    Return ":"c
  72.                Case CommandLineParameterSuffix.EqualsSign
  73.                    Return "="c
  74.                Case Else
  75.                    Throw New InvalidEnumArgumentException()
  76.            End Select
  77.        End Function
  78.  
  79. #End Region
  80.  
  81. #Region " Operator Conversion "
  82.  
  83.        ''' <summary>
  84.        ''' Performs an implicit conversion from <see cref="CommandLineValueParameter(Of IConvertible)"/> to <see cref="CommandLineValueParameter(Of T)"/>.
  85.        ''' </summary>
  86.        <DebuggerStepThrough>
  87.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of IConvertible)) As CommandLineValueParameter(Of T)
  88.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of IConvertible)(cmd)
  89.        End Operator
  90.  
  91.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of String)) As CommandLineValueParameter(Of T)
  92.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of String)(cmd)
  93.        End Operator
  94.  
  95.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Char)) As CommandLineValueParameter(Of T)
  96.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Char)(cmd)
  97.        End Operator
  98.  
  99.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Boolean)) As CommandLineValueParameter(Of T)
  100.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Boolean)(cmd)
  101.        End Operator
  102.  
  103.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Date)) As CommandLineValueParameter(Of T)
  104.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Date)(cmd)
  105.        End Operator
  106.  
  107.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Byte)) As CommandLineValueParameter(Of T)
  108.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Byte)(cmd)
  109.        End Operator
  110.  
  111.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of SByte)) As CommandLineValueParameter(Of T)
  112.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of SByte)(cmd)
  113.        End Operator
  114.  
  115.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Short)) As CommandLineValueParameter(Of T)
  116.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Short)(cmd)
  117.        End Operator
  118.  
  119.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of UShort)) As CommandLineValueParameter(Of T)
  120.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of UShort)(cmd)
  121.        End Operator
  122.  
  123.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Integer)) As CommandLineValueParameter(Of T)
  124.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Integer)(cmd)
  125.        End Operator
  126.  
  127.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of UInteger)) As CommandLineValueParameter(Of T)
  128.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of UInteger)(cmd)
  129.        End Operator
  130.  
  131.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Long)) As CommandLineValueParameter(Of T)
  132.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Long)(cmd)
  133.        End Operator
  134.  
  135.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of ULong)) As CommandLineValueParameter(Of T)
  136.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of ULong)(cmd)
  137.        End Operator
  138.  
  139.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Single)) As CommandLineValueParameter(Of T)
  140.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Single)(cmd)
  141.        End Operator
  142.  
  143.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Double)) As CommandLineValueParameter(Of T)
  144.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Double)(cmd)
  145.        End Operator
  146.  
  147.        Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Decimal)) As CommandLineValueParameter(Of T)
  148.            Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Decimal)(cmd)
  149.        End Operator
  150.  
  151. #End Region
  152.  
  153. #Region " Private Methods "
  154.  
  155.        ''' <summary>
  156.        ''' Converts a <see cref="CommandLineValueParameter(Of IConvertible)"/> to <see cref="CommandLineValueParameter(Of T)"/>.
  157.        ''' </summary>
  158.        Private Shared Function ConvertCommandLineValueParameter(Of I As IConvertible)(ByVal cmd As CommandLineValueParameter(Of I)) As CommandLineValueParameter(Of T)
  159.            Return New CommandLineValueParameter(Of T)(cmd.Name) With
  160.                   {
  161.                        .Prefix = cmd.Prefix,
  162.                        .Suffix = cmd.Suffix,
  163.                        .ShortName = cmd.ShortName,
  164.                        .DefaultValue = DirectCast(CObj(cmd.DefaultValue), T),
  165.                        .Value = DirectCast(CObj(cmd.Value), T),
  166.                        .IsOptional = cmd.IsOptional
  167.                    }
  168.        End Function
  169.  
  170. #End Region
  171.  
  172.    End Class
  173.  
  174. #End Region

CommandLineParameterCollection.vb
Código
  1. #Region " CommandLineParameter Collection "
  2.  
  3.    ''' <summary>
  4.    ''' Represents a strongly typed list of <see cref="CommandLineParameter"/> that can be accessed by an index.
  5.    ''' </summary>
  6.    <Serializable>
  7.    <XmlRoot("Items")>
  8.    <DebuggerDisplay("Count = {Count}")>
  9.    <DefaultMember("Item")>
  10.    Public Class CommandLineParameterCollection : Inherits Collection(Of CommandLineParameter)
  11.  
  12. #Region " Constructors "
  13.        Public Sub New()
  14.        End Sub
  15. #End Region
  16.  
  17. #Region " Indexers "
  18.  
  19.        ''' <summary>
  20.        ''' Gets or sets the <see cref="CommandLineParameter"/> that matches the specified key name.
  21.        ''' </summary>
  22.        ''' <param name="paramName">
  23.        ''' The parameter name.
  24.        ''' </param>
  25.        Default Public Overloads Property Item(ByVal paramName As String) As CommandLineParameter
  26.            <DebuggerStepThrough>
  27.            Get
  28.                Return Me.Find(paramName)
  29.            End Get
  30.            <DebuggerStepThrough>
  31.            Set(ByVal value As CommandLineParameter)
  32.                Me(Me.IndexOf(paramName)) = value
  33.            End Set
  34.        End Property
  35.  
  36. #End Region
  37.  
  38. #Region " Public Methods "
  39.  
  40.        ''' <summary>
  41.        ''' Adds a <see cref="CommandLineParameter"/> to the end of the <see cref="CommandLineParameterCollection"/>.
  42.        ''' </summary>
  43.        <DebuggerStepThrough>
  44.        Public Shadows Sub Add(ByVal param As CommandLineParameter)
  45.            If Me.Contains(param.Name) OrElse Me.Contains(param.ShortName) Then
  46.                Throw New ArgumentException(message:="Parameter already exists.", paramName:="refParam")
  47.            Else
  48.                MyBase.Add(param)
  49.            End If
  50.        End Sub
  51.  
  52.        ''' <summary>
  53.        ''' Adds the specified parameters to the end of the <see cref="CommandLineParameterCollection"/>.
  54.        ''' </summary>
  55.        <DebuggerStepThrough>
  56.        Public Shadows Sub AddRange(ByVal params As CommandLineParameter())
  57.            For Each param As CommandLineParameter In params
  58.                Me.Add(param)
  59.            Next param
  60.        End Sub
  61.  
  62.        Public Shadows Sub Remove(ByVal param As CommandLineParameter)
  63.            Dim indexOf As Integer = Me.IndexOf(param)
  64.            If (indexOf = -1) Then
  65.                Throw New ArgumentException(message:="Parameter doesn't exists.", paramName:="param")
  66.            Else
  67.                MyBase.RemoveAt(indexOf)
  68.            End If
  69.        End Sub
  70.  
  71.        Public Shadows Sub Remove(ByVal name As String)
  72.            Dim indexOf As Integer = Me.IndexOf(name)
  73.            If (indexOf = -1) Then
  74.                Throw New ArgumentException(message:="Parameter doesn't exists.", paramName:="name")
  75.            Else
  76.                MyBase.RemoveAt(indexOf)
  77.            End If
  78.        End Sub
  79.  
  80.        ''' <summary>
  81.        ''' Determines whether the <see cref="CommandLineParameterCollection"/> contains a <see cref="CommandLineParameter"/> that
  82.        ''' matches the specified key name.
  83.        ''' </summary>
  84.        ''' <returns>
  85.        ''' <see langword="True"/> if the <see cref="CommandLineParameterCollection"/> contains the <see cref="CommandLineParameter"/>,
  86.        ''' <see langword="False"/> otherwise.
  87.        ''' </returns>
  88.        <DebuggerStepThrough>
  89.        Public Overloads Function Contains(ByVal name As String) As Boolean
  90.            Return (From param As CommandLineParameter In MyBase.Items
  91.                    Where param.Name.Equals(name, StringComparison.OrdinalIgnoreCase) OrElse
  92.                          param.ShortName.Equals(name, StringComparison.OrdinalIgnoreCase)).Any
  93.        End Function
  94.  
  95.        ''' <summary>
  96.        ''' Searches for an <see cref="CommandLineParameter"/> that matches the specified parameter name,
  97.        ''' and returns the first occurrence within the entire <see cref="CommandLineParameterCollection"/>.
  98.        ''' </summary>
  99.        <DebuggerStepThrough>
  100.        Public Overloads Function Find(ByVal name As String) As CommandLineParameter
  101.            Return (From param As CommandLineParameter In MyBase.Items
  102.                    Where param.Name.Equals(name, StringComparison.OrdinalIgnoreCase) OrElse
  103.                          param.ShortName.Equals(name, StringComparison.OrdinalIgnoreCase)).
  104.                    DefaultIfEmpty(Nothing).
  105.                    SingleOrDefault()
  106.        End Function
  107.  
  108.        ''' <summary>
  109.        ''' Searches for an <see cref="CommandLineParameter"/> that matches the specified key name and
  110.        ''' returns the zero-based index of the first occurrence within the entire <see cref="CommandLineParameterCollection"/>.
  111.        ''' </summary>
  112.        ''' <returns>
  113.        ''' The zero-based index of the first occurrence of <see cref="CommandLineParameter"/> within the entire <see cref="CommandLineParameterCollection"/>, if found;
  114.        ''' otherwise, <c>–1</c>.
  115.        ''' </returns>
  116.        <DebuggerStepThrough>
  117.        Public Overloads Function IndexOf(ByVal name As String) As Integer
  118.  
  119.            Dim index As Integer = 0
  120.            Dim found As Boolean = False
  121.  
  122.            For Each param As CommandLineParameter In Me.Items
  123.  
  124.                If param.Name.Equals(name, StringComparison.OrdinalIgnoreCase) OrElse
  125.                   param.ShortName.Equals(name, StringComparison.OrdinalIgnoreCase) Then
  126.                    found = True
  127.                    Exit For
  128.                End If
  129.  
  130.                index += 1
  131.  
  132.            Next param
  133.  
  134.            If (found) Then
  135.                Return index
  136.  
  137.            Else
  138.                Return -1
  139.  
  140.            End If
  141.  
  142.        End Function
  143.  
  144. #End Region
  145.  
  146.    End Class
  147.  
  148. #End Region

CommandLineValueParameterCollection.vb
Código
  1. #Region " CommandLineValueParameter Collection "
  2.  
  3.    ''' <summary>
  4.    ''' Represents a strongly typed list of <see cref="CommandLineValueParameter"/> that can be accessed by an index.
  5.    ''' </summary>
  6.    <Serializable>
  7.    <XmlRoot("Items")>
  8.    <DebuggerDisplay("Count = {Count}")>
  9.    <DefaultMember("Item")>
  10.    Public Class CommandLineValueParameterCollection : Inherits Collection(Of CommandLineValueParameter(Of IConvertible))
  11.  
  12. #Region " Constructors "
  13.  
  14.        Public Sub New()
  15.        End Sub
  16.  
  17. #End Region
  18.  
  19. #Region " Indexers "
  20.  
  21.        ''' <summary>
  22.        ''' Gets or sets the <see cref="CommandLineValueParameter"/> that matches the specified key name.
  23.        ''' </summary>
  24.        ''' <param name="name">
  25.        ''' The parameter name.
  26.        ''' </param>
  27.        Default Public Overloads Property Item(ByVal name As String) As CommandLineValueParameter(Of IConvertible)
  28.            <DebuggerStepThrough>
  29.            Get
  30.                Dim result As CommandLineValueParameter(Of IConvertible) = Me.Find(name)
  31.                If (result Is Nothing) Then
  32.                    Throw New NullReferenceException(message:="Item not found with the specified name.")
  33.                End If
  34.                Return result
  35.            End Get
  36.            <DebuggerStepThrough>
  37.            Set(ByVal value As CommandLineValueParameter(Of IConvertible))
  38.                Me(Me.IndexOf(name)) = value
  39.            End Set
  40.        End Property
  41.  
  42. #End Region
  43.  
  44. #Region " Public Methods "
  45.  
  46.        Public Shadows Sub Add(ByVal param As CommandLineValueParameter(Of IConvertible))
  47.  
  48.            If Me.Contains(param.Name) OrElse Me.Contains(param.ShortName) Then
  49.                Throw New ArgumentException(message:="Parameter already exists.", paramName:="param")
  50.  
  51.            Else
  52.                MyBase.Add(refParam)
  53.  
  54.            End If
  55.  
  56.        End Sub
  57.  
  58.        Public Shadows Sub AddRange(ByVal params As CommandLineValueParameter(Of IConvertible)())
  59.  
  60.            For Each param As CommandLineValueParameter(Of IConvertible) In params
  61.                Me.Add(param)
  62.            Next param
  63.  
  64.        End Sub
  65.  
  66.        Public Shadows Sub Remove(ByVal param As CommandLineValueParameter(Of IConvertible))
  67.  
  68.            Dim indexOf As Integer = Me.IndexOf(param)
  69.  
  70.            If (indexOf = -1) Then
  71.                Throw New ArgumentException(message:="Parameter doesn't exists.", paramName:="param")
  72.  
  73.            Else
  74.                MyBase.RemoveAt(indexOf)
  75.  
  76.            End If
  77.  
  78.        End Sub
  79.  
  80.        Public Shadows Sub Remove(ByVal name As String)
  81.            Dim indexOf As Integer = Me.IndexOf(name)
  82.            If (indexOf = -1) Then
  83.                Throw New ArgumentException(message:="Parameter doesn't exists.", paramName:="name")
  84.            Else
  85.                MyBase.RemoveAt(indexOf)
  86.            End If
  87.        End Sub
  88.  
  89.        ''' <summary>
  90.        ''' Determines whether the <see cref="CommandLineValueParameterCollection"/> contains a <see cref="CommandLineValueParameter"/> that
  91.        ''' matches the specified key name.
  92.        ''' </summary>
  93.        ''' <returns>
  94.        ''' <see langword="True"/> if the <see cref="CommandLineValueParameterCollection"/> contains the <see cref="CommandLineValueParameter"/>,
  95.        ''' <see langword="False"/> otherwise.
  96.        ''' </returns>
  97.        <DebuggerStepThrough>
  98.        Public Overloads Function Contains(ByVal name As String) As Boolean
  99.            Return (From param As CommandLineValueParameter(Of IConvertible) In MyBase.Items
  100.                    Where param.Name.Equals(name, StringComparison.OrdinalIgnoreCase) OrElse
  101.                          param.ShortName.Equals(name, StringComparison.OrdinalIgnoreCase)).Any
  102.        End Function
  103.  
  104.        ''' <summary>
  105.        ''' Searches for an <see cref="CommandLineValueParameter"/> that matches the specified parameter name,
  106.        ''' and returns the first occurrence within the entire <see cref="CommandLineValueParameterCollection"/>.
  107.        ''' </summary>
  108.        <DebuggerStepThrough>
  109.        Public Overloads Function Find(ByVal name As String) As CommandLineValueParameter(Of IConvertible)
  110.            Return (From param As CommandLineValueParameter(Of IConvertible) In MyBase.Items
  111.                    Where param.Name.Equals(name, StringComparison.OrdinalIgnoreCase) OrElse
  112.                          param.ShortName.Equals(name, StringComparison.OrdinalIgnoreCase)).
  113.                    DefaultIfEmpty(Nothing).
  114.                    SingleOrDefault()
  115.        End Function
  116.  
  117.        ''' <summary>
  118.        ''' Searches for an <see cref="CommandLineValueParameter"/> that matches the specified key name and
  119.        ''' returns the zero-based index of the first occurrence within the entire <see cref="CommandLineValueParameterCollection"/>.
  120.        ''' </summary>
  121.        ''' <returns>
  122.        ''' The zero-based index of the first occurrence of <see cref="CommandLineValueParameter"/> within the entire <see cref="CommandLineValueParameterCollection"/>, if found;
  123.        ''' otherwise, <c>–1</c>.
  124.        ''' </returns>
  125.        <DebuggerStepThrough>
  126.        Public Overloads Function IndexOf(ByVal name As String) As Integer
  127.            Dim index As Integer = 0
  128.            Dim found As Boolean = False
  129.  
  130.            For Each param As CommandLineValueParameter(Of IConvertible) In Me.Items
  131.  
  132.                If param.Name.Equals(name, StringComparison.OrdinalIgnoreCase) OrElse
  133.                   param.ShortName.Equals(name, StringComparison.OrdinalIgnoreCase) Then
  134.                    found = True
  135.                    Exit For
  136.                End If
  137.  
  138.                index += 1
  139.  
  140.            Next param
  141.  
  142.            If (found) Then
  143.                Return index
  144.  
  145.            Else
  146.                Return -1
  147.  
  148.            End If
  149.        End Function
  150.  
  151. #End Region
  152.  
  153.    End Class
  154.  
  155. #End Region



Un ejemplo de uso:
Código
  1. Module Module1
  2.  
  3.    Dim params As New CommandLineValueParameterCollection From {
  4.        New CommandLineValueParameter(Of String)("ParameterName1") With {
  5.            .Prefix = CommandLineParameterPrefix.Slash,
  6.            .Suffix = CommandLineParameterSuffix.EqualsSign,
  7.            .ShortName = "Param1",
  8.            .DefaultValue = "",
  9.            .IsOptional = False
  10.        },
  11.        New CommandLineValueParameter(Of Boolean)("ParameterName2") With {
  12.            .Prefix = CommandLineParameterPrefix.Slash,
  13.            .Suffix = CommandLineParameterSuffix.EqualsSign,
  14.            .ShortName = "Param2",
  15.            .DefaultValue = False,
  16.            .IsOptional = True
  17.        },
  18.        New CommandLineValueParameter(Of Integer)("ParameterName3") With {
  19.            .Prefix = CommandLineParameterPrefix.Slash,
  20.            .Suffix = CommandLineParameterSuffix.EqualsSign,
  21.            .ShortName = "Param3",
  22.            .DefaultValue = -1I,
  23.            .IsOptional = True
  24.        }
  25.    }
  26.  
  27.    Public Function IsParameterAssignedInArgument(Of T As IConvertible)(ByVal parameter As CommandLineValueParameter(Of T), ByVal argument As String) As Boolean
  28.        Return (argument.StartsWith(parameter.FullName & parameter.GetSuffixChar(), StringComparison.OrdinalIgnoreCase) OrElse
  29.                argument.StartsWith(parameter.FullShortName & parameter.GetSuffixChar(), StringComparison.OrdinalIgnoreCase))
  30.    End Function
  31.  
  32.    Public Sub SetParameterValue(Of T As IConvertible)(ByRef parameter As CommandLineValueParameter(Of T), ByVal argument As String)
  33.  
  34.        If IsParameterAssignedInArgument(parameter, argument) Then
  35.  
  36.            Dim value As String = argument.Substring(argument.IndexOf(parameter.GetSuffixChar()) + 1).Trim({ControlChars.Quote})
  37.  
  38.            If String.IsNullOrEmpty(value) Then
  39.                parameter.Value = parameter.DefaultValue
  40.  
  41.            Else
  42.                Try
  43.                    parameter.Value = DirectCast(Convert.ChangeType(value, parameter.DefaultValue.GetType()), T)
  44.  
  45.                Catch ex As InvalidCastException
  46.                    Throw
  47.  
  48.                Catch ex As FormatException
  49.                    Throw
  50.  
  51.                End Try
  52.  
  53.            End If
  54.  
  55.        End If
  56.  
  57.    End Sub
  58.  
  59.    Sub Main()
  60.  
  61.        ' Parse command-line arguments to set the values of the parameters.
  62.        ParseArguments(params, AddressOf OnSyntaxError, AddressOf OnMissingParameterRequired)
  63.  
  64.        ' Display the parameters and each value assigned.
  65.        For Each param As CommandLineValueParameter(Of IConvertible) In params
  66.            Console.WriteLine(param.ToString())
  67.        Next
  68.  
  69.    End Sub
  70.  
  71.    ''' <summary>
  72.    ''' Loop through all the command-line arguments of this application.
  73.    ''' </summary>
  74.    Friend Sub ParseArguments(ByVal cmds As CommandLineValueParameterCollection,
  75.                              ByVal callbackSyntaxError As Action(Of CommandLineValueParameter(Of IConvertible)),
  76.                              ByVal callbackMissingRequired As Action(Of CommandLineValueParameter(Of IConvertible)))
  77.  
  78.        ParseArguments(cmds, Environment.GetCommandLineArgs.Skip(1), callbackSyntaxError, callbackMissingRequired)
  79.  
  80.    End Sub
  81.  
  82.    Friend Sub ParseArguments(ByVal cmds As CommandLineValueParameterCollection,
  83.                              ByVal args As IEnumerable(Of String),
  84.                              ByVal callbackSyntaxError As Action(Of CommandLineValueParameter(Of IConvertible)),
  85.                              ByVal callbackMissingRequired As Action(Of CommandLineValueParameter(Of IConvertible)))
  86.  
  87.        If Not (args.Any) Then
  88.            PrintHelp()
  89.        End If
  90.  
  91.        ' Required parameters. Not optional ones.
  92.        Dim cmdRequired As List(Of CommandLineValueParameter(Of IConvertible)) =
  93.            (From cmd As CommandLineValueParameter(Of IConvertible) In cmds
  94.             Where Not cmd.IsOptional).ToList()
  95.  
  96.        For Each arg As String In args
  97.  
  98.            For Each cmd As CommandLineValueParameter(Of IConvertible) In cmds
  99.  
  100.                If arg.Equals("/?") Then
  101.                    PrintHelp()
  102.                End If
  103.  
  104.                If IsParameterAssignedInArgument(cmd, arg) Then
  105.  
  106.                    If (cmdRequired.Contains(cmd)) Then
  107.                        cmdRequired.Remove(cmd)
  108.                    End If
  109.  
  110.                    Try
  111.                        SetParameterValue(Of IConvertible)(cmd, arg)
  112.  
  113.                    Catch ex As Exception
  114.                        callbackSyntaxError.Invoke(cmd)
  115.  
  116.                    End Try
  117.  
  118.                End If
  119.  
  120.            Next cmd
  121.  
  122.        Next arg
  123.  
  124.        If (cmdRequired.Any) Then
  125.            callbackMissingRequired.Invoke(cmdRequired.First())
  126.        End If
  127.  
  128.    End Sub
  129.  
  130.    Friend Sub OnSyntaxError(ByVal cmd As CommandLineValueParameter(Of IConvertible))
  131.        Console.WriteLine(String.Format("[X] Syntax error in parameter: {0})", cmd.FullName))
  132.        Environment.Exit(exitCode:=1)
  133.    End Sub
  134.  
  135.    Friend Sub OnMissingParameterRequired(ByVal cmd As CommandLineValueParameter(Of IConvertible))
  136.        Console.WriteLine(String.Format("[X] Parameter {0} is required. ", cmd.FullName))
  137.        Environment.Exit(exitCode:=1)
  138.    End Sub
  139.  
  140.    Friend Sub PrintHelp()
  141.        Dim sb As New StringBuilder
  142.        sb.AppendLine("Commands Help:")
  143.        For Each param As CommandLineValueParameter(Of IConvertible) In params
  144.            sb.AppendFormat("{0} {{{1}}}", param.FullName, param.DefaultValue.GetType().Name)
  145.            sb.AppendLine()
  146.        Next
  147.        Console.WriteLine(sb.ToString())
  148.        Environment.Exit(exitCode:=1)
  149.    End Sub
  150.  
  151. End Module

Resultados de ejecución:

Ayuda del programa:
Código:
ConsoleApp1.exe /?
Commands Help:
/ParameterName1 {String}
/ParameterName2 {Boolean}
/ParameterName3 {Int32}

Error-handling de parametros requeridos no especificados:
Código:
ConsoleApp1.exe /param2=true  /param3=100
[X] Parameter "/ParameterName1" is required.

Error-handling de fallos en el parsing de valores:
Código:
ConsoleApp1.exe /param2=nul
[X] Syntax error in parameter: /ParameterName2 {Boolean}

Resultado de asignación de valores de cada parámetro tras un parsing exitoso de los argumentos command-line:
Código:
ConsoleApp1.exe /param1="hello world" /param2=true /param3=100
/ParameterName1="hello world"
/ParameterName2="True"
/ParameterName3="100"

PD: El código de arriba es solo un ejemplo, se puede extender para controlar nombres de parámetros que no existen y/o nombres repetidos, por ejemplo.

Saludos.
124  Programación / Programación General / MOVIDO: Regex + split con dos delimitadores en c# en: 30 Julio 2017, 15:38
El tema ha sido movido a .NET.

http://foro.elhacker.net/index.php?topic=472972.0
125  Programación / .NET / Re: Regex + split con dos delimitadores en c# en: 30 Julio 2017, 15:38
Hola.

1. Estás en un foro de programación, por favor publica los bloques de código con el formato adecuado utilizando las etiquetas GeShi.

2. Las preguntas sobre C# van en el subforo de programación .NET

3. Está prohibido hacer doble post, puedes usar el botón "Modificar" (para algo está). Lee las reglas del foro por favor...



El código que has mostrado hace lo que debe, partir el string en base a las capturas/coincidencias de la expresión que le has indicado.

En tu expresión regular hay dos agrupaciones, la agrupación 0 (todo), y la agrupación 1 (lo que está dentro del primer grupo de paréntesis). Solamente quieres quedarte con las capturas de la agrupación 1, pues eso debes hacerlo especificando el índice del grupo "1" o en su defecto también puedes asignarle un nombre:

Código
  1. string str = "1213.hola$123.que$213.tal$234";
  2. Regex rgx = new Regex(@"\.(?<nombre_de_grupo>[^\.\$]+)\$", RegexOptions.None);
  3. MatchCollection matches = rgx.Matches(str);
  4.  
  5. foreach (Match match in matches) {
  6.    Console.WriteLine(match.Groups["nombre_de_grupo"].Value);
  7. }

Resultado de ejecución:
Código:
hola
que
tal

Saludos
126  Foros Generales / Foro Libre / Re: Piloto de vuelos profesional afirma que la Tierra es plana + experimento Física en: 29 Julio 2017, 18:01
Ademas si la Tierra fuera plana como bien intentas afirmar, siempre veríamos las mismas estrellas, no importa si estuviéramos en el hemisferio norte o el sur.  

Estás poniendo palabras en mi boca que yo no he dicho. Creo que no has leido todos mis comentarios de este hilo, por que siempre aclaro varias veces que yo solo cuestiono, no afirmo nada... excepto que los alienígenas existen por que tengo pruebas visuales de su tecnología (una nave alienígena gigante en el cielo, ya sabes, estarás aburrido también de que yo diga esto), y a raíz de eso afirmo sin lugar a dudas que la NASA es un fraude por que saber lo primero implica una evidencia en esto otro, pero poco más puedo afirmar.

No tengo nada más que responderle a nadie en los comentarios de este hilo, prefiero no hacerlo... pero tenía que aclararle eso a @El_Andaluz, por que yo en ningún momento he afirmado.

Saludos
127  Foros Generales / Foro Libre / Re: Mr Robot: "asegurate de que el microprocesador esté selecciondo" en: 29 Julio 2017, 16:46
Doblajes...

No hay nada mejor que Dragon Ball en valenciano, creedme  :)

 :o !!

Si no te "conociera", diria que me estás haciendo la pelota... creía que yo era el único por estos lares que sabía apreciar la MAESTRÍA del doblaje en Valenciano. Desde luego el doblaje en Español es de put@ pena, cancer, sida...



Saludos!
128  Programación / Scripting / Re: Descargar imagen de una 'URI' en: 29 Julio 2017, 15:56
Ahora me pregunto... como hago para que autoit se comunique con java?? podria ser por medio de la consola de windows? enviando "java nombre"?

Sería una posibilidad, por supuesto, puedes desarrolllar una aplicación de consola en Java y desde AutoIt la puedes iniciar y capturar la respuesta/código de salida del programa en el bufer de salida StdOut (me refiero, en caso de que lo necesites). Puedes hacer lo mismo con una aplicación .NET (VB.NET, C#, F#, VC++), un script JScript, o un script PowerShell, etc...


De todas formas en realidad yo no creo que necesites recurrir a lenguajes adicionales... ya que es de suponer que en el propio AutoIt debas poder decodificar un string BASE64:

...Probablemente aquí puedas encontrar más utilidades:



PD:Eleкtro estuve viendo tus codigos y aunque no los manejo para nada me parece que en el de VB.NET podrias omitir definir la primer variable ya que despues la dejas sin nada dentro podrias haber hecho directamente:

Dim base64 As String ="R0lGODlhAQABAIAAAAAAAAAAACH5BAAAAAAALAAAAAABAAEAAAICTAEAOw=="
Dim raw As Byte() = Convert.FromBase64String(base64)

Si estoy equivocado corrigeme por favor.

No, no te equivocas en absoluto, pero tiene una explicación lógica: la variable "content" tan solo la declaré para denotar o diferenciar que el contenido no forma parte de la codificación BASE64, o dicho de otra forma: lo escribí como mera formalidad para evitar generarte posibles confusiones puesto que al principio parecias un poco "perdido" con el tema de la codificación BASE64. Es por ese motivo que en los tres códigos lo primero que hago es declarar la variable content ("data:image/png;base64,") y la concateno con el string BASE64 para luego seguidamente borrar lo que he concatenado ("data:image/png;base64,"), es evidente que hacer eso en un escenario real sería de lo más absurdo (sin sentido ninguno), pero en ese código tan solo era un ejemplo demostrativo para denotar las diferencias y tratar de no despistarte.

Me alegra saber que hayas analizado los códigos que se te ofrecieron, que te hayas dado cuenta de eso por ti mismo, y que lo hayas cuestionado.

Saludos!
129  Programación / Programación General / MOVIDO: Error undefined reference to WinMain@16 en: 29 Julio 2017, 12:34
El tema ha sido movido a Programación C/C++.

http://foro.elhacker.net/index.php?topic=472944.0
130  Programación / Programación Visual Basic / MOVIDO: ¿Que tipo de VPS seleccionar para ejecutar 100 hilos? en: 29 Julio 2017, 12:08
El tema ha sido movido a .NET.

http://foro.elhacker.net/index.php?topic=472938.0
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 [13] 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 ... 1017
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines