un programa que quiero hacer, que cuando se ejecute puedas poner opciones

[Sentex]

Hola!

Necesito ayuda en un programa que quiero hacer.
Necesito que el programa sea en vb o C# pero en aplicacion de consola.
Pero no se hacer que cuando se ejecute puedas poner opciones.

Ejemplo test.exe -ftp ftp.server.com -p hola123 -u user

Algo asi se podria hacer?

· Los titulos deben ser descriptivos
>aquí las reglas del foro
-Engel Lex

[engel lex]

si, se puede hacer en cualquier lenguaje, pero primero tienes que aprender a programar lo basico en el

esto se llaman argumentos argumentos por linea de comandos

[Sentex]

Se lo basico.

[PalitroqueZ]

en POO la función huerfana permite capturar argumentos externos.

[Eleкtro]

Aquí tienes todo lo que necesitas saber:

• Main() and Command-Line Arguments (C# Programming Guide) | docs.microsoft.com

( 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 (vbnet) [Seleccionar] Expandir

''' <summary>
''' Specifies the prefix character that indicates the start of the parameter's name of a <see cref="CommandLineParameter"/>
''' </summary>
Public Enum CommandLineParameterPrefix As Integer

   ''' <summary>
   ''' The dash character "-"
   ''' <para></para>
   ''' For example: "-ParameterName"
   ''' </summary>
   Dash = 0

   ''' <summary>
   ''' The slash character "/"
   ''' <para></para>
   ''' For example: "/ParameterName"
   ''' </summary>
   Slash = 1

   ''' <summary>
   ''' The slash character "\"
   ''' <para></para>
   ''' For example: "\ParameterName"
   ''' </summary>
   BackSlash = 2

End Enum

''' <summary>
''' Specifies the suffix character that delimits the parameter's name from the parameter's value of a <see cref="CommandLineParameter"/>
''' </summary>
Public Enum CommandLineParameterSuffix As Integer

   ''' <summary>
   ''' The equals sign character "="
   ''' <para></para>
   ''' For example: "/ParameterName=Value"
   ''' </summary>
   EqualsSign = 0

   ''' <summary>
   ''' The colon character ":"
   ''' <para></para>
   ''' For example: "/ParameterName:Value"
   ''' </summary>
   Colon = 1

End Enum

CommandLineParameter.vb

Código (vbnet) [Seleccionar] Expandir

#Region " Command-Line Parameter "

   ''' <summary>
   ''' Represents a command-line parameter that does not takes any value.
   ''' </summary>
   Public Class CommandLineParameter

#Region " Properties "

       ''' <summary>
       ''' Gets or sets the prefix character that indicates the start of the parameter's name.
       ''' <para></para>
       ''' For example: "/ParameterName" where "/" is the prefix.
       ''' </summary>
       Public Property Prefix As CommandLineParameterPrefix = CommandLineParameterPrefix.Slash

       ''' <summary>
       ''' Gets the name of the parameter.
       ''' </summary>
       Public ReadOnly Property Name As String
           Get
               Return Me.nameB
           End Get
       End Property
       Private nameB As String

       ''' <summary>
       ''' Gets or sets the short name of the parameter.
       ''' <para></para>
       ''' A short name should be an abbreviated name of the parameter. A short name is optional and can de null.
       ''' </summary>
       Public Property ShortName As String
           Get
               Return shortNameB
           End Get
           <DebuggerStepThrough>
           Set(ByVal value As String)
               Me.TrySetShortName(value)
           End Set
       End Property
       Private shortNameB As String

       ''' <summary>
       ''' Gets the full name of the parameter including the prefix.
       ''' <para></para>
       ''' For Example: "/ParameterName"
       ''' </summary>
       Public ReadOnly Property FullName As String
           Get
               Return Me.ToString()
           End Get
       End Property

       ''' <summary>
       ''' Gets the full short name of the parameter including the prefix.
       ''' <para></para>
       ''' For Example: "/ParameterShortName"
       ''' </summary>
       Public ReadOnly Property FullShortName As String
           Get
               If Not String.IsNullOrEmpty(Me.shortNameB) Then
                   Return String.Format("{0}{1}", Me.GetPrefixChar(), Me.shortNameB)

               Else
                   Return Me.ToString()

               End If
           End Get
       End Property

       ''' <summary>
       ''' Gets or sets a value indicating whether this parameter is required for the application.
       ''' <para></para>
       ''' A value of <see langword="False"/> means the user needs to pass this parameter to the application.
       ''' <para></para>
       ''' A value of <see langword="True"/> means this is an optional parameter so no matter if the user pass this parameter to the application.
       ''' </summary>
       Public Property IsOptional As Boolean

#End Region

#Region " Constructors "

       ''' <summary>
       ''' Prevents a default instance of the <see cref="CommandLineParameter"/> class from being created.
       ''' </summary>
       Private Sub New()
       End Sub

       ''' <summary>
       ''' Initializes a new instance of the <see cref="CommandLineParameter" /> class.
       ''' </summary>
       ''' <param name="name">
       ''' The name of the parameter.
       ''' </param>
       Public Sub New(ByVal name As String)
           If String.IsNullOrWhiteSpace(name) Then
               Throw New ArgumentNullException()
           End If

           Me.TrySetName(name)
       End Sub

#End Region

#Region " Public Methods "

       ''' <summary>
       ''' Returns a <see cref="String"/> that represents this <see cref="CommandLineParameter"/>.
       ''' </summary>
       Public Overloads Function ToString() As String
           Return String.Format("{0}{1}", Me.GetPrefixChar(), Me.nameB)
       End Function

       ''' <summary>
       ''' Gets the prefix character that indicates the start of the parameter's name.
       ''' <para></para>
       ''' For Example: "/"
       ''' </summary>
       Public Function GetPrefixChar() As Char
           Select Case Me.Prefix
               Case CommandLineParameterPrefix.Dash
                   Return "-"c
               Case CommandLineParameterPrefix.Slash
                   Return "/"c
               Case CommandLineParameterPrefix.BackSlash
                   Return "\"c
               Case Else
                   Throw New InvalidEnumArgumentException()
           End Select
       End Function

#End Region

#Region " Private Methods "

       ''' <summary>
       ''' Evaluates an attempt to assign the parameter name.
       ''' </summary>
       <DebuggerStepThrough>
       Protected Overridable Sub TrySetName(ByVal name As String)

           For Each c As Char In name
               If Not Char.IsLetterOrDigit(c) Then
                   Throw New ArgumentException(message:="The name of the parameter only can contain letters and digits.",
                                               paramName:="name")
               End If
           Next c

           Me.nameB = name

       End Sub

       ''' <summary>
       ''' Evaluates an attempt to assign the short name of the parameter.
       ''' </summary>
       <DebuggerStepThrough>
       Protected Overridable Sub TrySetShortName(ByVal shortName As String)

           If Not String.IsNullOrEmpty(shortName) Then

               For Each c As Char In shortName
                   If Not Char.IsLetterOrDigit(c) Then
                       Throw New ArgumentException(message:="The short name of the parameter only can contain letters and digits.",
                                                   paramName:="shortName")
                   End If
               Next c

               If (shortName.Equals(Me.nameB, StringComparison.OrdinalIgnoreCase)) Then
                   Throw New ArgumentException(message:="The short name of the parameter cannot be equals than the parameter's name.",
                                               paramName:="shortName")
               End If

           End If

           Me.shortNameB = shortName

       End Sub

#End Region

   End Class

#End Region

CommandLineValueParameter(Of T As IConvertible).vb

Código (vbnet) [Seleccionar] Expandir

#Region " Command-Line Value Parameter (Of T) "

   ''' <summary>
   ''' Represents a command-line parameter that takes a value of specific <see cref="Type"/>.
   ''' </summary>
   Public Class CommandLineValueParameter(Of T As IConvertible) : Inherits CommandLineParameter

#Region " Properties "

       ''' <summary>
       ''' Gets or sets the suffix character that delimits the parameter's name from the parameter's value.
       ''' <para></para>
       ''' For example: "/ParameterName=Value" where "/" is the prefix and "=" the suffix.
       ''' </summary>
       Public Property Suffix As CommandLineParameterSuffix = CommandLineParameterSuffix.EqualsSign

       ''' <summary>
       ''' Gets or sets the parameter's value defined by the end-user.
       ''' <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="CommandLineValueParameter(Of T).DefaultValue"/> property instead.
       ''' </summary>
       Public Property Value As T

       ''' <summary>
       ''' Gets or sets the default parameter's value.
       ''' <para></para>
       ''' This value should be take into account if, after parsing the command-line arguments of the application,
       ''' <see cref="CommandLineValueParameter(Of T).Value"/> is <see langword="Nothing"/>,
       ''' meaning that the end-user did not assigned any value to this parameter.
       ''' </summary>
       Public Property DefaultValue As T

#End Region

#Region " Constructors "

       ''' <summary>
       ''' Initializes a new instance of the <see cref="CommandLineValueParameter(Of T)" /> class.
       ''' </summary>
       ''' <param name="name">
       ''' The name of the parameter.
       ''' </param>
       Public Sub New(ByVal name As String)
           MyBase.New(name)
       End Sub

#End Region

#Region " Public Methods "

       ''' <summary>
       ''' Returns a <see cref="String"/> that represents this <see cref="CommandLineValueParameter(Of T)"/>.
       ''' </summary>
       Public Overloads Function ToString() As String
           Return String.Format("{0}{1}""{2}""", MyBase.ToString(), Me.GetSuffixChar(),
                                                 If(Me.Value IsNot Nothing, Me.Value.ToString(Nothing), Me.DefaultValue.ToString(Nothing)))
       End Function

       ''' <summary>
       ''' Gets the suffix character that delimits the parameter's name from the parameter's value.
       ''' <para></para>
       ''' For Example: "="
       ''' </summary>
       Public Function GetSuffixChar() As Char
           Select Case Me.Suffix
               Case CommandLineParameterSuffix.Colon
                   Return ":"c
               Case CommandLineParameterSuffix.EqualsSign
                   Return "="c
               Case Else
                   Throw New InvalidEnumArgumentException()
           End Select
       End Function

#End Region

#Region " Operator Conversion "

       ''' <summary>
       ''' Performs an implicit conversion from <see cref="CommandLineValueParameter(Of IConvertible)"/> to <see cref="CommandLineValueParameter(Of T)"/>.
       ''' </summary>
       <DebuggerStepThrough>
       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of IConvertible)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of IConvertible)(cmd)
       End Operator

       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of String)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of String)(cmd)
       End Operator

       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Char)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Char)(cmd)
       End Operator

       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Boolean)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Boolean)(cmd)
       End Operator

       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Date)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Date)(cmd)
       End Operator

       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Byte)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Byte)(cmd)
       End Operator

       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of SByte)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of SByte)(cmd)
       End Operator

       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Short)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Short)(cmd)
       End Operator

       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of UShort)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of UShort)(cmd)
       End Operator

       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Integer)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Integer)(cmd)
       End Operator

       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of UInteger)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of UInteger)(cmd)
       End Operator

       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Long)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Long)(cmd)
       End Operator

       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of ULong)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of ULong)(cmd)
       End Operator

       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Single)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Single)(cmd)
       End Operator

       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Double)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Double)(cmd)
       End Operator

       Public Shared Widening Operator CType(ByVal cmd As CommandLineValueParameter(Of Decimal)) As CommandLineValueParameter(Of T)
           Return CommandLineValueParameter(Of T).ConvertCommandLineValueParameter(Of Decimal)(cmd)
       End Operator

#End Region

#Region " Private Methods "

       ''' <summary>
       ''' Converts a <see cref="CommandLineValueParameter(Of IConvertible)"/> to <see cref="CommandLineValueParameter(Of T)"/>.
       ''' </summary>
       Private Shared Function ConvertCommandLineValueParameter(Of I As IConvertible)(ByVal cmd As CommandLineValueParameter(Of I)) As CommandLineValueParameter(Of T)
           Return New CommandLineValueParameter(Of T)(cmd.Name) With
                  {
                       .Prefix = cmd.Prefix,
                       .Suffix = cmd.Suffix,
                       .ShortName = cmd.ShortName,
                       .DefaultValue = DirectCast(CObj(cmd.DefaultValue), T),
                       .Value = DirectCast(CObj(cmd.Value), T),
                       .IsOptional = cmd.IsOptional
                   }
       End Function

#End Region

   End Class

#End Region

CommandLineParameterCollection.vb

Código (vbnet) [Seleccionar] Expandir

#Region " CommandLineParameter Collection "

   ''' <summary>
   ''' Represents a strongly typed list of <see cref="CommandLineParameter"/> that can be accessed by an index.
   ''' </summary>
   <Serializable>
   <XmlRoot("Items")>
   <DebuggerDisplay("Count = {Count}")>
   <DefaultMember("Item")>
   Public Class CommandLineParameterCollection : Inherits Collection(Of CommandLineParameter)

#Region " Constructors "
       Public Sub New()
       End Sub
#End Region

#Region " Indexers "

       ''' <summary>
       ''' Gets or sets the <see cref="CommandLineParameter"/> that matches the specified key name.
       ''' </summary>
       ''' <param name="paramName">
       ''' The parameter name.
       ''' </param>
       Default Public Overloads Property Item(ByVal paramName As String) As CommandLineParameter
           <DebuggerStepThrough>
           Get
               Return Me.Find(paramName)
           End Get
           <DebuggerStepThrough>
           Set(ByVal value As CommandLineParameter)
               Me(Me.IndexOf(paramName)) = value
           End Set
       End Property

#End Region

#Region " Public Methods "

       ''' <summary>
       ''' Adds a <see cref="CommandLineParameter"/> to the end of the <see cref="CommandLineParameterCollection"/>.
       ''' </summary>
       <DebuggerStepThrough>
       Public Shadows Sub Add(ByVal param As CommandLineParameter)
           If Me.Contains(param.Name) OrElse Me.Contains(param.ShortName) Then
               Throw New ArgumentException(message:="Parameter already exists.", paramName:="refParam")
           Else
               MyBase.Add(param)
           End If
       End Sub

       ''' <summary>
       ''' Adds the specified parameters to the end of the <see cref="CommandLineParameterCollection"/>.
       ''' </summary>
       <DebuggerStepThrough>
       Public Shadows Sub AddRange(ByVal params As CommandLineParameter())
           For Each param As CommandLineParameter In params
               Me.Add(param)
           Next param
       End Sub

       Public Shadows Sub Remove(ByVal param As CommandLineParameter)
           Dim indexOf As Integer = Me.IndexOf(param)
           If (indexOf = -1) Then
               Throw New ArgumentException(message:="Parameter doesn't exists.", paramName:="param")
           Else
               MyBase.RemoveAt(indexOf)
           End If
       End Sub

       Public Shadows Sub Remove(ByVal name As String)
           Dim indexOf As Integer = Me.IndexOf(name)
           If (indexOf = -1) Then
               Throw New ArgumentException(message:="Parameter doesn't exists.", paramName:="name")
           Else
               MyBase.RemoveAt(indexOf)
           End If
       End Sub

       ''' <summary>
       ''' Determines whether the <see cref="CommandLineParameterCollection"/> contains a <see cref="CommandLineParameter"/> that
       ''' matches the specified key name.
       ''' </summary>
       ''' <returns>
       ''' <see langword="True"/> if the <see cref="CommandLineParameterCollection"/> contains the <see cref="CommandLineParameter"/>,
       ''' <see langword="False"/> otherwise.
       ''' </returns>
       <DebuggerStepThrough>
       Public Overloads Function Contains(ByVal name As String) As Boolean
           Return (From param As CommandLineParameter In MyBase.Items
                   Where param.Name.Equals(name, StringComparison.OrdinalIgnoreCase) OrElse
                         param.ShortName.Equals(name, StringComparison.OrdinalIgnoreCase)).Any
       End Function

       ''' <summary>
       ''' Searches for an <see cref="CommandLineParameter"/> that matches the specified parameter name,
       ''' and returns the first occurrence within the entire <see cref="CommandLineParameterCollection"/>.
       ''' </summary>
       <DebuggerStepThrough>
       Public Overloads Function Find(ByVal name As String) As CommandLineParameter
           Return (From param As CommandLineParameter In MyBase.Items
                   Where param.Name.Equals(name, StringComparison.OrdinalIgnoreCase) OrElse
                         param.ShortName.Equals(name, StringComparison.OrdinalIgnoreCase)).
                   DefaultIfEmpty(Nothing).
                   SingleOrDefault()
       End Function

       ''' <summary>
       ''' Searches for an <see cref="CommandLineParameter"/> that matches the specified key name and
       ''' returns the zero-based index of the first occurrence within the entire <see cref="CommandLineParameterCollection"/>.
       ''' </summary>
       ''' <returns>
       ''' The zero-based index of the first occurrence of <see cref="CommandLineParameter"/> within the entire <see cref="CommandLineParameterCollection"/>, if found;
       ''' otherwise, <c>–1</c>.
       ''' </returns>
       <DebuggerStepThrough>
       Public Overloads Function IndexOf(ByVal name As String) As Integer

           Dim index As Integer = 0
           Dim found As Boolean = False

           For Each param As CommandLineParameter In Me.Items

               If param.Name.Equals(name, StringComparison.OrdinalIgnoreCase) OrElse
                  param.ShortName.Equals(name, StringComparison.OrdinalIgnoreCase) Then
                   found = True
                   Exit For
               End If

               index += 1

           Next param

           If (found) Then
               Return index

           Else
               Return -1

           End If

       End Function

#End Region

   End Class

#End Region

CommandLineValueParameterCollection.vb

Código (vbnet) [Seleccionar] Expandir

#Region " CommandLineValueParameter Collection "

   ''' <summary>
   ''' Represents a strongly typed list of <see cref="CommandLineValueParameter"/> that can be accessed by an index.
   ''' </summary>
   <Serializable>
   <XmlRoot("Items")>
   <DebuggerDisplay("Count = {Count}")>
   <DefaultMember("Item")>
   Public Class CommandLineValueParameterCollection : Inherits Collection(Of CommandLineValueParameter(Of IConvertible))

#Region " Constructors "

       Public Sub New()
       End Sub

#End Region

#Region " Indexers "

       ''' <summary>
       ''' Gets or sets the <see cref="CommandLineValueParameter"/> that matches the specified key name.
       ''' </summary>
       ''' <param name="name">
       ''' The parameter name.
       ''' </param>
       Default Public Overloads Property Item(ByVal name As String) As CommandLineValueParameter(Of IConvertible)
           <DebuggerStepThrough>
           Get
               Dim result As CommandLineValueParameter(Of IConvertible) = Me.Find(name)
               If (result Is Nothing) Then
                   Throw New NullReferenceException(message:="Item not found with the specified name.")
               End If
               Return result
           End Get
           <DebuggerStepThrough>
           Set(ByVal value As CommandLineValueParameter(Of IConvertible))
               Me(Me.IndexOf(name)) = value
           End Set
       End Property

#End Region

#Region " Public Methods "

       Public Shadows Sub Add(ByVal param As CommandLineValueParameter(Of IConvertible))

           If Me.Contains(param.Name) OrElse Me.Contains(param.ShortName) Then
               Throw New ArgumentException(message:="Parameter already exists.", paramName:="param")

           Else
               MyBase.Add(refParam)

           End If

       End Sub

       Public Shadows Sub AddRange(ByVal params As CommandLineValueParameter(Of IConvertible)())

           For Each param As CommandLineValueParameter(Of IConvertible) In params
               Me.Add(param)
           Next param

       End Sub

       Public Shadows Sub Remove(ByVal param As CommandLineValueParameter(Of IConvertible))

           Dim indexOf As Integer = Me.IndexOf(param)

           If (indexOf = -1) Then
               Throw New ArgumentException(message:="Parameter doesn't exists.", paramName:="param")

           Else
               MyBase.RemoveAt(indexOf)

           End If

       End Sub

       Public Shadows Sub Remove(ByVal name As String)
           Dim indexOf As Integer = Me.IndexOf(name)
           If (indexOf = -1) Then
               Throw New ArgumentException(message:="Parameter doesn't exists.", paramName:="name")
           Else
               MyBase.RemoveAt(indexOf)
           End If
       End Sub

       ''' <summary>
       ''' Determines whether the <see cref="CommandLineValueParameterCollection"/> contains a <see cref="CommandLineValueParameter"/> that
       ''' matches the specified key name.
       ''' </summary>
       ''' <returns>
       ''' <see langword="True"/> if the <see cref="CommandLineValueParameterCollection"/> contains the <see cref="CommandLineValueParameter"/>,
       ''' <see langword="False"/> otherwise.
       ''' </returns>
       <DebuggerStepThrough>
       Public Overloads Function Contains(ByVal name As String) As Boolean
           Return (From param As CommandLineValueParameter(Of IConvertible) In MyBase.Items
                   Where param.Name.Equals(name, StringComparison.OrdinalIgnoreCase) OrElse
                         param.ShortName.Equals(name, StringComparison.OrdinalIgnoreCase)).Any
       End Function

       ''' <summary>
       ''' Searches for an <see cref="CommandLineValueParameter"/> that matches the specified parameter name,
       ''' and returns the first occurrence within the entire <see cref="CommandLineValueParameterCollection"/>.
       ''' </summary>
       <DebuggerStepThrough>
       Public Overloads Function Find(ByVal name As String) As CommandLineValueParameter(Of IConvertible)
           Return (From param As CommandLineValueParameter(Of IConvertible) In MyBase.Items
                   Where param.Name.Equals(name, StringComparison.OrdinalIgnoreCase) OrElse
                         param.ShortName.Equals(name, StringComparison.OrdinalIgnoreCase)).
                   DefaultIfEmpty(Nothing).
                   SingleOrDefault()
       End Function

       ''' <summary>
       ''' Searches for an <see cref="CommandLineValueParameter"/> that matches the specified key name and
       ''' returns the zero-based index of the first occurrence within the entire <see cref="CommandLineValueParameterCollection"/>.
       ''' </summary>
       ''' <returns>
       ''' The zero-based index of the first occurrence of <see cref="CommandLineValueParameter"/> within the entire <see cref="CommandLineValueParameterCollection"/>, if found;
       ''' otherwise, <c>–1</c>.
       ''' </returns>
       <DebuggerStepThrough>
       Public Overloads Function IndexOf(ByVal name As String) As Integer
           Dim index As Integer = 0
           Dim found As Boolean = False

           For Each param As CommandLineValueParameter(Of IConvertible) In Me.Items

               If param.Name.Equals(name, StringComparison.OrdinalIgnoreCase) OrElse
                  param.ShortName.Equals(name, StringComparison.OrdinalIgnoreCase) Then
                   found = True
                   Exit For
               End If

               index += 1

           Next param

           If (found) Then
               Return index

           Else
               Return -1

           End If
       End Function

#End Region

   End Class

#End Region



Un ejemplo de uso:

Código (vbnet) [Seleccionar] Expandir

Module Module1

   Dim params As New CommandLineValueParameterCollection From {
       New CommandLineValueParameter(Of String)("ParameterName1") With {
           .Prefix = CommandLineParameterPrefix.Slash,
           .Suffix = CommandLineParameterSuffix.EqualsSign,
           .ShortName = "Param1",
           .DefaultValue = "",
           .IsOptional = False
       },
       New CommandLineValueParameter(Of Boolean)("ParameterName2") With {
           .Prefix = CommandLineParameterPrefix.Slash,
           .Suffix = CommandLineParameterSuffix.EqualsSign,
           .ShortName = "Param2",
           .DefaultValue = False,
           .IsOptional = True
       },
       New CommandLineValueParameter(Of Integer)("ParameterName3") With {
           .Prefix = CommandLineParameterPrefix.Slash,
           .Suffix = CommandLineParameterSuffix.EqualsSign,
           .ShortName = "Param3",
           .DefaultValue = -1I,
           .IsOptional = True
       }
   }

   Public Function IsParameterAssignedInArgument(Of T As IConvertible)(ByVal parameter As CommandLineValueParameter(Of T), ByVal argument As String) As Boolean
       Return (argument.StartsWith(parameter.FullName & parameter.GetSuffixChar(), StringComparison.OrdinalIgnoreCase) OrElse
               argument.StartsWith(parameter.FullShortName & parameter.GetSuffixChar(), StringComparison.OrdinalIgnoreCase))
   End Function

   Public Sub SetParameterValue(Of T As IConvertible)(ByRef parameter As CommandLineValueParameter(Of T), ByVal argument As String)

       If IsParameterAssignedInArgument(parameter, argument) Then

           Dim value As String = argument.Substring(argument.IndexOf(parameter.GetSuffixChar()) + 1).Trim({ControlChars.Quote})

           If String.IsNullOrEmpty(value) Then
               parameter.Value = parameter.DefaultValue

           Else
               Try
                   parameter.Value = DirectCast(Convert.ChangeType(value, parameter.DefaultValue.GetType()), T)

               Catch ex As InvalidCastException
                   Throw

               Catch ex As FormatException
                   Throw

               End Try

           End If

       End If

   End Sub

   Sub Main()

       ' Parse command-line arguments to set the values of the parameters.
       ParseArguments(params, AddressOf OnSyntaxError, AddressOf OnMissingParameterRequired)

       ' Display the parameters and each value assigned.
       For Each param As CommandLineValueParameter(Of IConvertible) In params
           Console.WriteLine(param.ToString())
       Next

   End Sub

   ''' <summary>
   ''' Loop through all the command-line arguments of this application.
   ''' </summary>
   Friend Sub ParseArguments(ByVal cmds As CommandLineValueParameterCollection,
                             ByVal callbackSyntaxError As Action(Of CommandLineValueParameter(Of IConvertible)),
                             ByVal callbackMissingRequired As Action(Of CommandLineValueParameter(Of IConvertible)))

       ParseArguments(cmds, Environment.GetCommandLineArgs.Skip(1), callbackSyntaxError, callbackMissingRequired)

   End Sub

   Friend Sub ParseArguments(ByVal cmds As CommandLineValueParameterCollection,
                             ByVal args As IEnumerable(Of String),
                             ByVal callbackSyntaxError As Action(Of CommandLineValueParameter(Of IConvertible)),
                             ByVal callbackMissingRequired As Action(Of CommandLineValueParameter(Of IConvertible)))

       If Not (args.Any) Then
           PrintHelp()
       End If

       ' Required parameters. Not optional ones.
       Dim cmdRequired As List(Of CommandLineValueParameter(Of IConvertible)) =
           (From cmd As CommandLineValueParameter(Of IConvertible) In cmds
            Where Not cmd.IsOptional).ToList()

       For Each arg As String In args

           For Each cmd As CommandLineValueParameter(Of IConvertible) In cmds

               If arg.Equals("/?") Then
                   PrintHelp()
               End If

               If IsParameterAssignedInArgument(cmd, arg) Then

                   If (cmdRequired.Contains(cmd)) Then
                       cmdRequired.Remove(cmd)
                   End If

                   Try
                       SetParameterValue(Of IConvertible)(cmd, arg)

                   Catch ex As Exception
                       callbackSyntaxError.Invoke(cmd)

                   End Try

               End If

           Next cmd

       Next arg

       If (cmdRequired.Any) Then
           callbackMissingRequired.Invoke(cmdRequired.First())
       End If

   End Sub

   Friend Sub OnSyntaxError(ByVal cmd As CommandLineValueParameter(Of IConvertible))
       Console.WriteLine(String.Format("[X] Syntax error in parameter: {0})", cmd.FullName))
       Environment.Exit(exitCode:=1)
   End Sub

   Friend Sub OnMissingParameterRequired(ByVal cmd As CommandLineValueParameter(Of IConvertible))
       Console.WriteLine(String.Format("[X] Parameter {0} is required. ", cmd.FullName))
       Environment.Exit(exitCode:=1)
   End Sub

   Friend Sub PrintHelp()
       Dim sb As New StringBuilder
       sb.AppendLine("Commands Help:")
       For Each param As CommandLineValueParameter(Of IConvertible) In params
           sb.AppendFormat("{0} {{{1}}}", param.FullName, param.DefaultValue.GetType().Name)
           sb.AppendLine()
       Next
       Console.WriteLine(sb.ToString())
       Environment.Exit(exitCode:=1)
   End Sub

End Module

Resultados de ejecución:

Ayuda del programa:

Código [Seleccionar] Expandir

ConsoleApp1.exe /?
Commands Help:
/ParameterName1 {String}
/ParameterName2 {Boolean}
/ParameterName3 {Int32}

Error-handling de parametros requeridos no especificados:

Código [Seleccionar] Expandir

ConsoleApp1.exe /param2=true  /param3=100
[X] Parameter "/ParameterName1" is required.

Error-handling de fallos en el parsing de valores:

Código [Seleccionar] Expandir

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 [Seleccionar] Expandir

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.