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


 


Tema destacado: Cifrar documentos-carpetas con GnuPG en Linux y Windows


  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 ... 944
121  Programación / Scripting / Re: Comando Copy con: de archivo .bat en: 1 Abril 2017, 22:09
En lugar de tener que estar escribiendo >>Archivo.txt al final de cada linea, puedes usar los operadores de agrupación de comando (los paréntesis) para simplificarlo así:

Código
  1. (
  2. Echo Linea1
  3. Echo Linea2
  4. Echo Linea3
  5. Echo etc...
  6. )>"Output.txt"

¡Saludos!
122  Programación / .NET / Re: Librería de Snippets para VB.Net !! (Compartan aquí sus snippets) en: 1 Abril 2017, 17:55
¿Cómo determinar cual es la versión más reciente instalada de .NET Framework en la máquina actual?.

Aquí les dejo el código fuente completo:

Código
  1. ''' ----------------------------------------------------------------------------------------------------
  2. ''' <summary>
  3. ''' Determines which is the most recent version of the .NET Framework runtimes installed on the current machine.
  4. ''' </summary>
  5. ''' ----------------------------------------------------------------------------------------------------
  6. ''' <example> This is a code example.
  7. ''' <code>
  8. ''' Dim frameworkVersion As Version = GetMostRecentInstalledFrameworkVersion()
  9. ''' Console.WriteLine(frameworkVersion.ToString())
  10. ''' </code>
  11. ''' </example>
  12. ''' ----------------------------------------------------------------------------------------------------
  13. ''' <remarks>
  14. ''' Credits to Microsoft: <see href="http://msdn.microsoft.com/en-us/library/hh925568(v=vs.110).aspx"/>
  15. ''' </remarks>
  16. ''' ----------------------------------------------------------------------------------------------------
  17. ''' <returns>
  18. ''' The resulting .NET Framework <see cref="Version"/>.
  19. ''' </returns>
  20. ''' ----------------------------------------------------------------------------------------------------
  21. <DebuggerStepperBoundary>
  22. Private Shared Function GetMostRecentInstalledFrameworkVersion() As Version
  23.  
  24.    ' .NET 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1
  25.    Using ndpKey As RegistryKey =
  26.        RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).
  27.                    OpenSubKey("SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full\", writable:=False)
  28.  
  29.        If (ndpKey IsNot Nothing) AndAlso (ndpKey.GetValue("Release") IsNot Nothing) Then
  30.            Dim releaseVersion As Integer = CInt(ndpKey.GetValue("Release"))
  31.            Select Case releaseVersion
  32.                Case >= 394254
  33.                    Return New Version(4, 6, 1)
  34.                Case >= 393295
  35.                    Return New Version(4, 6)
  36.                Case >= 379893
  37.                    Return New Version(4, 5, 2)
  38.                Case >= 378675
  39.                    Return New Version(4, 5, 1)
  40.                Case >= 378389
  41.                    Return New Version(4, 5)
  42.            End Select
  43.        End If
  44.    End Using
  45.  
  46.    ' .NET 1.0, 2.0, 3.0, 3.5, 4.0
  47.    Using ndpKey As RegistryKey =
  48.        RegistryKey.OpenRemoteBaseKey(RegistryHive.LocalMachine, "").
  49.                    OpenSubKey("SOFTWARE\Microsoft\NET Framework Setup\NDP\", writable:=False)
  50.  
  51.        For Each versionKeyName As String In ndpKey.GetSubKeyNames().OrderByDescending(Function(x As String) x)
  52.            If versionKeyName.ToLower().StartsWith("v") Then
  53.                Return New Version(versionKeyName.ToLower().TrimStart("v"c))
  54.            End If
  55.        Next versionKeyName
  56.    End Using
  57.  
  58.    Return New Version()
  59.  
  60. End Function

Personálmente recomiendo decorar esta funcionalidad mediante una propiedad de sólo lectura, tal que así:
Código
  1. ''' ----------------------------------------------------------------------------------------------------
  2. ''' <summary>
  3. ''' Gets a value that determines which is the most recent version of the .NET Framework runtimes installed
  4. ''' on the current machine.
  5. ''' </summary>
  6. ''' ----------------------------------------------------------------------------------------------------
  7. ''' <value>
  8. ''' A value that determines which is the most recent version of the .NET Framework runtimes installed
  9. ''' on the current machine.
  10. ''' </value>
  11. ''' ----------------------------------------------------------------------------------------------------
  12. Public Shared ReadOnly Property MostRecentInstalledFrameworkVersion As Version
  13.    <DebuggerStepThrough>
  14.    Get
  15.        Return GetMostRecentInstalledFrameworkVersion()
  16.    End Get
  17. End Property

Modo de empleo:
Código
  1. Dim frameworkVersion As Version = GetMostRecentInstalledFrameworkVersion()
  2. Console.WriteLine(frameworkVersion.ToString())

Notas: Faltaría implementar la versión de .NET 4.6.2. Aparte de eso no he podio testear en profundidad el resultado obtenido en un equipo que tenga instalado .NET 1.0, 2.0, 3.0, 3.5 o 4.0, si encuentran algún error diganmelo.



Códigos de error Win32.

Esto que voy a compartir a continuación es una enumeración con todos los errores Win32 de la API de Windows, en total son +13.000 lineas de código, así que os dejo un enlace externo:


El propósito de gigantesca enumeración es proveer una manera sencilla, directa y eficiente de determinar que error nos devuelve en ocasiones una función de la API de Windows y cual es el significado de dicho código de error.

No confundir un código de error Win32 con un código de error H_RESULT, esto último define muchos errores Win32 pero con otros valores.

Recordad que la librería de clases de .NET Framework expone algunos miembros muy útiles para la evaluación de errores de funciones no administradas, Marshal.GetLastWin32Error(), Marshal.GetHRForLastWin32Error() y Marshal.ThrowExceptionForHR() así como el tipo excepción System.ComponentModel.Win32Exception que podemos invocar para informarle de un error Win32 específico al usuario.



¿Cómo prevenir el Flickering de un control Win32?.

Uno de los mayores problemas estéticos y también de lo más común al trabajar con los controles de la tecnología WindowsForms es el Flickering. El Flicker consiste en un desagradable parpadeo de la imagen en donde la imagen desaparece por un breve tiempo lapso de tiempo hasta que vuelve a aparecer, como un parpadeo. Es un problema visual que afecta a la estética del control, y suele producirse muy a menudo cuando el control necesita realizar operaciones de dibujo muy expensivas, o cuando estamos trabajando con transparencias.

Una descripción más detallada del flickering: https://en.wikipedia.org/wiki/Flicker_(screen)

¿Cómo se soluciona el Flickering?, pues lamentablemente no se puede solucionar completamente, pero si que podemos llegar a reducir el Flickering considerablemente y en el mejor de los casos hasta llegar a dejar de percibirlo del todo y poder decir que ya no hay Flickering en el control, ¿pero cómo se hace?, pues una solución cotidiana sería con un bufer doble de memoria, o double buffering.

Cuando el double buffering está activado, todas las operaciones de dibujado del control son renderizadas primero a un bufer de memoria en vez de ser renderizadas directamente a la superficie de dibujado en la pantalla. Cuando todas las operaciones de dibujado han sido completadas, el bufer de memoria es copiado directamente a la superficie de dibujado asociada a él.

Para tratar de solventar los problemas de Flickering cuando estamos desarrollando un control de usuario, he desarrollado una interfáz con nombre IBufferedControl, la cual implementariamos en nuestro control:

Código
  1. ' ***********************************************************************
  2. ' Author   : Elektro
  3. ' Modified : 20-March-2017
  4. ' ***********************************************************************
  5.  
  6. #Region " Public Members Summary "
  7.  
  8. #Region " Properties "
  9.  
  10. ' CreateParams As CreateParams
  11. ' DoubleBuffered As Boolean
  12. ' PreventFlickering As Boolean
  13.  
  14. #End Region
  15.  
  16. #End Region
  17.  
  18. #Region " Option Statements "
  19.  
  20. Option Strict On
  21. Option Explicit On
  22. Option Infer Off
  23.  
  24. #End Region
  25.  
  26. #Region " Imports "
  27.  
  28. Imports System.ComponentModel
  29. Imports System.Windows.Forms
  30.  
  31. #End Region
  32.  
  33. #Region " IBufferedControl "
  34.  
  35. Namespace Types
  36.  
  37.    ''' ----------------------------------------------------------------------------------------------------
  38.    ''' <summary>
  39.    ''' Provides simple double buffering (anti flickering) functionality for a Windows Forms <see cref="Control"/>,
  40.    ''' such for example a <see cref="TextBox"/>.
  41.    ''' </summary>
  42.    ''' ----------------------------------------------------------------------------------------------------
  43.    Public Interface IBufferedControl
  44.  
  45.        ''' ----------------------------------------------------------------------------------------------------
  46.        ''' <summary>
  47.        ''' Gets the required creation parameters when the control handle is created.
  48.        ''' </summary>
  49.        ''' ----------------------------------------------------------------------------------------------------
  50.        ''' <value>
  51.        ''' The creation parameters.
  52.        ''' </value>
  53.        ''' ----------------------------------------------------------------------------------------------------
  54.        <Browsable(False)>
  55.        <EditorBrowsable(EditorBrowsableState.Advanced)>
  56.        ReadOnly Property CreateParams As CreateParams
  57.        ' Implementation Exmple:
  58.        '
  59.        ' Protected Overrides ReadOnly Property CreateParams As CreateParams Implements IBufferedControl.CreateParams
  60.        '     Get
  61.        '         If (Me.preventFlickeringB) Then
  62.        '             Dim cp As CreateParams = MyBase.CreateParams
  63.        '             cp.ExStyle = (cp.ExStyle Or CInt(WindowStylesEx.Composited))
  64.        '             Return cp
  65.        '         Else
  66.        '             Return MyBase.CreateParams
  67.        '         End If
  68.        '     End Get
  69.        ' End Property
  70.  
  71.        ''' ----------------------------------------------------------------------------------------------------
  72.        ''' <summary>
  73.        ''' Gets or sets a value indicating whether this control should redraw its surface using a secondary buffer
  74.        ''' to reduce or prevent flicker.
  75.        ''' </summary>
  76.        ''' ----------------------------------------------------------------------------------------------------
  77.        ''' <value>
  78.        ''' <see langword="True"/> if the surface of the control should be drawn using double buffering;
  79.        ''' otherwise, <see langword="False"/>.
  80.        ''' </value>
  81.        ''' ----------------------------------------------------------------------------------------------------
  82.        <Browsable(True)>
  83.        <EditorBrowsable(EditorBrowsableState.Always)>
  84.        <DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)>
  85.        <Localizable(True)>
  86.        <Category("Behavior")>
  87.        <Description("Indicates whether this control should redraw its surface using a secondary buffer to reduce or prevent flicker.")>
  88.        <DefaultValue(GetType(Boolean), "True")>
  89.        Property DoubleBuffered As Boolean
  90.        ' Implementation Exmple:
  91.        '
  92.        ' Public Overridable Shadows Property DoubleBuffered As Boolean Implements IBufferedControl.DoubleBuffered
  93.        '     Get
  94.        '         Return MyBase.DoubleBuffered
  95.        '     End Get
  96.        '     Set(ByVal value As Boolean)
  97.        '         Me.SetStyle(ControlStyles.DoubleBuffer, value)
  98.        '         MyBase.DoubleBuffered = value
  99.        '     End Set
  100.        ' End Property
  101.  
  102.        ''' ----------------------------------------------------------------------------------------------------
  103.        ''' <summary>
  104.        ''' Gets or sets a value that indicates whether the control should avoid unwanted flickering effects.
  105.        ''' <para></para>
  106.        ''' If <see langword="True"/>, this will avoid any flickering effect on the control, however,
  107.        ''' it will also have a negative impact by slowing down the responsiveness of the control about to 30% slower.
  108.        ''' <para></para>
  109.        ''' This negative impact doesn't affect to the performance of the application itself,
  110.        ''' just to the performance of this control.
  111.        ''' </summary>
  112.        ''' ----------------------------------------------------------------------------------------------------
  113.        ''' <value>
  114.        ''' A value that indicates whether the control should avoid unwanted flickering effects.
  115.        ''' </value>
  116.        ''' ----------------------------------------------------------------------------------------------------
  117.        <Browsable(True)>
  118.        <EditorBrowsable(EditorBrowsableState.Always)>
  119.        <DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)>
  120.        <Localizable(True)>
  121.        <Category("Behavior")>
  122.        <Description("Indicates whether the control should avoid unwanted flickering effects. If True, this will avoid any flickering effect on the control, however, it will also have a negative impact by slowing down the responsiveness of the control about to 30% slower.")>
  123.        <DefaultValue(GetType(Boolean), "False")>
  124.        Property PreventFlickering As Boolean
  125.        ' Implementation Exmple:
  126.        '
  127.        ' Public Overridable Property PreventFlickering As Boolean Implements IBufferedControl.PreventFlickering
  128.        '     Get
  129.        '         Return Me.preventFlickeringB
  130.        '     End Get
  131.        '     Set(ByVal value As Boolean)
  132.        '         Me.preventFlickeringB = value
  133.        '     End Set
  134.        ' End Property
  135.        ' ''' ----------------------------------------------------------------------------------------------------
  136.        ' ''' <summary>
  137.        ' ''' ( Backing Field )
  138.        ' ''' A value that indicates whether the control should avoid unwanted flickering effects.
  139.        ' ''' </summary>
  140.        ' ''' ----------------------------------------------------------------------------------------------------
  141.        ' Private preventFlickeringB As Boolean
  142.  
  143.    End Interface
  144.  
  145. End Namespace
  146.  
  147. #End Region

Un ejemplo de implementación:
Código
  1. <DisplayName("MyControl")>
  2. <Description("A extended control.")>
  3. <DesignTimeVisible(True)>
  4. <DesignerCategory("UserControl")>
  5. <ToolboxBitmap(GetType(UserControl))>
  6. <ToolboxItemFilter("System.Windows.Forms", ToolboxItemFilterType.Require)>
  7. <PermissionSet(SecurityAction.Demand, Name:="FullTrust")>
  8. Public Class MyControl : Inherits UserControl : Implements IBufferedControl
  9.  
  10.    ''' ----------------------------------------------------------------------------------------------------
  11.    ''' <summary>
  12.    ''' Gets the required creation parameters when the control handle is created.
  13.    ''' <para></para>
  14.    ''' The information returned by the <see cref="CreateParams"/> property is used to pass information about the
  15.    ''' initial state and appearance of this control, at the time an instance of this class is being created.
  16.    ''' </summary>
  17.    ''' ----------------------------------------------------------------------------------------------------
  18.    ''' <value>
  19.    ''' The creation parameters.
  20.    ''' </value>
  21.    ''' ----------------------------------------------------------------------------------------------------
  22.    <Browsable(False)>
  23.    <EditorBrowsable(EditorBrowsableState.Advanced)>
  24.    <Description("The required creation parameters when the control handle is created.")>
  25.    Protected Overrides ReadOnly Property CreateParams As CreateParams Implements IBufferedControl.CreateParams
  26.        Get
  27.            If (Me.preventFlickeringB) Then
  28.                Dim cp As CreateParams = MyBase.CreateParams
  29.                cp.ExStyle = (cp.ExStyle Or CInt(WindowStylesEx.Composited))
  30.                Return cp
  31.            Else
  32.                Return MyBase.CreateParams
  33.            End If
  34.        End Get
  35.    End Property
  36.  
  37.    ''' ----------------------------------------------------------------------------------------------------
  38.    ''' <summary>
  39.    ''' Gets or sets a value indicating whether this control should redraw its surface using a secondary buffer
  40.    ''' to reduce or prevent flicker.
  41.    ''' </summary>
  42.    ''' ----------------------------------------------------------------------------------------------------
  43.    ''' <value>
  44.    ''' <see langword="True"/> if the surface of the control should be drawn using double buffering;
  45.    ''' otherwise, <see langword="False"/>.
  46.    ''' </value>
  47.    ''' ----------------------------------------------------------------------------------------------------
  48.    <Browsable(True)>
  49.    <EditorBrowsable(EditorBrowsableState.Always)>
  50.    <DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)>
  51.    <Localizable(True)>
  52.    <Category("Behavior")>
  53.    <Description("Indicates whether this control should redraw its surface using a secondary buffer to reduce or prevent flicker.")>
  54.    <DefaultValue(GetType(Boolean), "False")>
  55.    Public Overridable Shadows Property DoubleBuffered As Boolean Implements IBufferedControl.DoubleBuffered
  56.        Get
  57.            Return MyBase.DoubleBuffered
  58.        End Get
  59.        Set(ByVal value As Boolean)
  60.            Me.SetStyle(ControlStyles.DoubleBuffer, value)
  61.            MyBase.DoubleBuffered = value
  62.        End Set
  63.    End Property
  64.  
  65.    ''' ----------------------------------------------------------------------------------------------------
  66.    ''' <summary>
  67.    ''' Gets or sets a value that indicates whether the control should avoid unwanted flickering effects.
  68.    ''' <para></para>
  69.    ''' If <see langword="True"/>, this will avoid any flickering effect on the control, however,
  70.    ''' it will also have a negative impact by slowing down the responsiveness of the control about to 30% slower.
  71.    ''' <para></para>
  72.    ''' This negative impact doesn't affect to the performance of the application itself,
  73.    ''' just to the performance of this control.
  74.    ''' </summary>
  75.    ''' ----------------------------------------------------------------------------------------------------
  76.    ''' <value>
  77.    ''' A value that indicates whether the control should avoid unwanted flickering effects.
  78.    ''' </value>
  79.    ''' ----------------------------------------------------------------------------------------------------
  80.    <Browsable(True)>
  81.    <EditorBrowsable(EditorBrowsableState.Always)>
  82.    <DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)>
  83.    <Localizable(False)>
  84.    <Category("Behavior")>
  85.    <Description("Indicates whether the control should avoid unwanted flickering effects. If True, this will avoid any flickering effect on the control, however, it will also have a negative impact by slowing down the responsiveness of the control about to 30% slower.")>
  86.    <DefaultValue(GetType(Boolean), "False")>
  87.    Public Overridable Property PreventFlickering As Boolean Implements IBufferedControl.PreventFlickering
  88.        Get
  89.            Return Me.preventFlickeringB
  90.        End Get
  91.        Set(ByVal value As Boolean)
  92.            Me.preventFlickeringB = value
  93.        End Set
  94.    End Property
  95.    ''' ----------------------------------------------------------------------------------------------------
  96.    ''' <summary>
  97.    ''' ( Backing Field )
  98.    ''' A value that indicates whether the control should avoid unwanted flickering effects.
  99.    ''' </summary>
  100.    ''' ----------------------------------------------------------------------------------------------------
  101.    Private preventFlickeringB As Boolean
  102.  
  103.    Public Sub New()
  104.        MyBase.SuspendLayout()
  105.        ' MyBase.DoubleBuffered = True
  106.        ' Me.preventFlickeringB = True
  107.        MyBase.ResumeLayout(performLayout:=False)
  108.    End Sub
  109.  
  110. End Class



¿Cómo calcular la distancia (de 2 dimensiones) entre dos puntos?.

Código
  1. ''' ----------------------------------------------------------------------------------------------------
  2. ''' <summary>
  3. ''' Calculates the distance between two points in two dimensions in the coordinate system.
  4. ''' </summary>
  5. ''' ----------------------------------------------------------------------------------------------------
  6. ''' <remarks>
  7. ''' Pythagorean theorem: <see href="http://en.wikipedia.org/wiki/Pythagorean_theorem"/>
  8. ''' </remarks>
  9. ''' ----------------------------------------------------------------------------------------------------
  10. ''' <example> This is a code example.
  11. ''' <code>
  12. ''' Dim distance As Double = CalculateDistance2D(New PointF(1, 1), New PointF(2, 2))
  13. ''' </code>
  14. ''' </example>
  15. ''' ----------------------------------------------------------------------------------------------------
  16. ''' <param name="pointA">
  17. ''' The first point.
  18. ''' </param>
  19. '''
  20. ''' <param name="pointB">
  21. ''' The second point.
  22. ''' </param>
  23. ''' ----------------------------------------------------------------------------------------------------
  24. ''' <returns>
  25. ''' The resulting distance.
  26. ''' </returns>
  27. ''' ----------------------------------------------------------------------------------------------------
  28. Public Shared Function CalculateDistance2D(ByVal pointA As PointF, ByVal pointB As PointF) As Double
  29.  
  30.    ' Pythagoras theorem: c^2 = a^2 + b^2
  31.    ' thus c = square root(a^2 + b^2)
  32.    Dim a As Double = (pointB.X - pointA.X)
  33.    Dim b As Double = (pointB.Y - pointA.Y)
  34.  
  35.    Return Math.Sqrt(a * a + b * b)
  36.  
  37. End Function



¿Cómo subscribirnos a eventos del sistema?.

Microsoft Windows expone una infraestructura llamada WMI (Windows Management Instrumentation) mediante la que provee una serie de classes que podemos utilizar para subscribbirnos a eventos del sistema o dicho coloquiálmente "monitorizar eventos", como por ejemplo cambios de hardware, cambios de aplicaciones instaladas o desinstaladas, cambios en el nivel de batería de un portatil, cambios en el registro de Windows, y un largo etcétera.

La lista de classes podemos encontrarla en MSDN: https://msdn.microsoft.com/en-us/library/aa394554(v=vs.85).aspx

Hay varios tipos de classes, un tipo de classes serían representativas, es decir para representar información de consultas realizadas a WMI, y otro tipo serían las classes de eventos. Una class de evento la utilizariamos para subscribirnos al tipo de evento que provee.

Para subscribirnos a una clase de evento, la librería de clases de .NET Framework espone la clase ManagementEventWatcher. Yo he desarrollado la siguiente class que hereda de la class ManagementEventWatcher, con la intención de añadir algunos constructores específicos para facilitar todavía más su uso y abstraer en mayor medida el nivel de complejidad.

Código
  1. ' ***********************************************************************
  2. ' Author   : Elektro
  3. ' Modified : 21-March-2017
  4. ' ***********************************************************************
  5.  
  6. #Region " Public Members Summary "
  7.  
  8. #Region " Constructors "
  9.  
  10. ' New(String)
  11. ' New(String, Single)
  12. ' New(String, Timespan)
  13. ' New(String, String, Single)
  14. ' New(String, String, Timespan)
  15. ' New(String, String, String(), UInteger)
  16. ' New(String, String, String(), Timespan)
  17.  
  18. ' New(SelectQuery)
  19. ' New(SelectQuery, Single)
  20. ' New(SelectQuery, Timespan)
  21. ' New(SelectQuery, UInteger)
  22.  
  23. #End Region
  24.  
  25. #Region " Events "
  26.  
  27. ' EventArrived As EventArrivedEventHandler
  28.  
  29. #End Region
  30.  
  31. #Region " Methods "
  32.  
  33. ' Start()
  34. ' Stop()
  35. ' Dispose()
  36.  
  37. #End Region
  38.  
  39. #End Region
  40.  
  41. #Region " Option Statements "
  42.  
  43. Option Strict On
  44. Option Explicit On
  45. Option Infer Off
  46.  
  47. #End Region
  48.  
  49. #Region " Imports "
  50.  
  51. Imports System.ComponentModel
  52. Imports System.Management
  53.  
  54. #End Region
  55.  
  56. #Region " WMI Event Watcher "
  57.  
  58.    ''' ----------------------------------------------------------------------------------------------------
  59.    ''' <summary>
  60.    ''' A WMI event monitor that notifies about event arrivals for the subscribed event class.
  61.    ''' </summary>
  62.    ''' ----------------------------------------------------------------------------------------------------
  63.    <DesignerCategory("code")>
  64.    <ImmutableObject(False)>
  65.    Public Class WMIEventWatcher : Inherits ManagementEventWatcher
  66.  
  67. #Region " Constructors "
  68.  
  69.        ''' ----------------------------------------------------------------------------------------------------
  70.        ''' <summary>
  71.        ''' Prevents a default instance of the <see cref="WMIEventWatcher"/> class from being created.
  72.        ''' </summary>
  73.        ''' ----------------------------------------------------------------------------------------------------
  74.        <DebuggerNonUserCode>
  75.        Private Sub New()
  76.        End Sub
  77.  
  78.        ''' ----------------------------------------------------------------------------------------------------
  79.        ''' <summary>
  80.        ''' Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
  81.        ''' </summary>
  82.        ''' ----------------------------------------------------------------------------------------------------
  83.        ''' <param name="eventClassName">
  84.        ''' The name of the WMI event class to subscribe for.
  85.        ''' </param>
  86.        ''' ----------------------------------------------------------------------------------------------------
  87.        <DebuggerStepThrough>
  88.        Public Sub New(ByVal eventClassName As String)
  89.  
  90.            Me.New(eventClassName, condition:=String.Empty, withinInterval:=1.0F)
  91.  
  92.        End Sub
  93.  
  94.        ''' ----------------------------------------------------------------------------------------------------
  95.        ''' <summary>
  96.        ''' Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
  97.        ''' </summary>
  98.        ''' ----------------------------------------------------------------------------------------------------
  99.        ''' <param name="eventClassName">
  100.        ''' The name of the WMI event class to subscribe for.
  101.        ''' </param>
  102.        '''
  103.        ''' <param name="withinInterval">
  104.        ''' The interval, in seconds, that WMI will check for changes that occur to instances of the events of the
  105.        ''' specified class in the <paramref name="eventClassName"/> parameter.
  106.        ''' </param>
  107.        ''' ----------------------------------------------------------------------------------------------------
  108.        <DebuggerStepThrough>
  109.        Public Sub New(ByVal eventClassName As String,
  110.                       ByVal withinInterval As Single)
  111.  
  112.            Me.New(eventClassName, condition:=String.Empty, withinInterval:=withinInterval)
  113.  
  114.        End Sub
  115.  
  116.        ''' ----------------------------------------------------------------------------------------------------
  117.        ''' <summary>
  118.        ''' Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
  119.        ''' </summary>
  120.        ''' ----------------------------------------------------------------------------------------------------
  121.        ''' <param name="eventClassName">
  122.        ''' The name of the WMI event class to subscribe for.
  123.        ''' </param>
  124.        '''
  125.        ''' <param name="withinInterval">
  126.        ''' The interval, in seconds, that WMI will check for changes that occur to instances of the events of the
  127.        ''' specified class in the <paramref name="eventClassName"/> parameter.
  128.        ''' </param>
  129.        ''' ----------------------------------------------------------------------------------------------------
  130.        <DebuggerStepThrough>
  131.        Public Sub New(ByVal eventClassName As String,
  132.                       ByVal withinInterval As TimeSpan)
  133.  
  134.            Me.New(eventClassName, condition:=String.Empty, withinInterval:=withinInterval)
  135.  
  136.        End Sub
  137.  
  138.        ''' ----------------------------------------------------------------------------------------------------
  139.        ''' <summary>
  140.        ''' Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
  141.        ''' </summary>
  142.        ''' ----------------------------------------------------------------------------------------------------
  143.        ''' <param name="eventClassName">
  144.        ''' The name of the WMI event class to subscribe for.
  145.        ''' </param>
  146.        '''
  147.        ''' <param name="condition">
  148.        ''' The condition to be applied to events of the specified class in the
  149.        ''' <paramref name="eventClassName"/> parameter.
  150.        ''' </param>
  151.        '''
  152.        ''' <param name="withinInterval">
  153.        ''' The interval, in seconds, that WMI will check for changes that occur to instances of the events of the
  154.        ''' specified class in the <paramref name="eventClassName"/> parameter.
  155.        ''' </param>
  156.        ''' ----------------------------------------------------------------------------------------------------
  157.        <DebuggerStepThrough>
  158.        Public Sub New(ByVal eventClassName As String,
  159.                       ByVal condition As String,
  160.                       ByVal withinInterval As Single)
  161.  
  162.            Me.New(eventClassName, condition, TimeSpan.FromSeconds(withinInterval))
  163.  
  164.        End Sub
  165.  
  166.        ''' ----------------------------------------------------------------------------------------------------
  167.        ''' <summary>
  168.        ''' Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
  169.        ''' </summary>
  170.        ''' ----------------------------------------------------------------------------------------------------
  171.        ''' <param name="eventClassName">
  172.        ''' The name of the WMI event class to subscribe for.
  173.        ''' </param>
  174.        '''
  175.        ''' <param name="condition">
  176.        ''' The condition to be applied to events of the specified class in the
  177.        ''' <paramref name="eventClassName"/> parameter.
  178.        ''' </param>
  179.        '''
  180.        ''' <param name="withinInterval">
  181.        ''' The interval, in seconds, that WMI will check for changes that occur to instances of the events of the
  182.        ''' specified class in the <paramref name="eventClassName"/> parameter.
  183.        ''' </param>
  184.        ''' ----------------------------------------------------------------------------------------------------
  185.        <DebuggerStepThrough>
  186.        Public Sub New(ByVal eventClassName As String,
  187.                       ByVal condition As String,
  188.                       ByVal withinInterval As TimeSpan)
  189.  
  190.            MyBase.Query = New WqlEventQuery(eventClassName:=eventClassName,
  191.                                             condition:=condition,
  192.                                             withinInterval:=withinInterval)
  193.  
  194.        End Sub
  195.  
  196.        ''' ----------------------------------------------------------------------------------------------------
  197.        ''' <summary>
  198.        ''' Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
  199.        ''' </summary>
  200.        ''' ----------------------------------------------------------------------------------------------------
  201.        ''' <param name="eventClassName">
  202.        ''' The name of the WMI event class to subscribe for.
  203.        ''' </param>
  204.        '''
  205.        ''' <param name="condition">
  206.        ''' The condition to be applied to events of the specified class in the
  207.        ''' <paramref name="eventClassName"/> parameter.
  208.        ''' </param>
  209.        '''
  210.        ''' <param name="groupByPropertyList">
  211.        ''' The properties in the event class by which the events should be grouped.
  212.        ''' </param>
  213.        '''
  214.        ''' <param name="groupWithinInterval">
  215.        ''' The interval, in seconds, of the specified interval at which WMI sends one aggregate event,
  216.        ''' rather than many events.
  217.        ''' </param>
  218.        ''' ----------------------------------------------------------------------------------------------------
  219.        <DebuggerStepThrough>
  220.        Public Sub New(ByVal eventClassName As String,
  221.                       ByVal condition As String,
  222.                       ByVal groupByPropertyList As String(),
  223.                       ByVal groupWithinInterval As UInteger)
  224.  
  225.            Me.New(eventClassName, condition, groupByPropertyList, TimeSpan.FromSeconds(groupWithinInterval))
  226.  
  227.        End Sub
  228.  
  229.        ''' ----------------------------------------------------------------------------------------------------
  230.        ''' <summary>
  231.        ''' Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
  232.        ''' </summary>
  233.        ''' ----------------------------------------------------------------------------------------------------
  234.        ''' <param name="eventClassName">
  235.        ''' The name of the WMI event class to subscribe for.
  236.        ''' </param>
  237.        '''
  238.        ''' <param name="condition">
  239.        ''' The condition to be applied to events of the specified class in the
  240.        ''' <paramref name="eventClassName"/> parameter.
  241.        ''' </param>
  242.        '''
  243.        ''' <param name="groupByPropertyList">
  244.        ''' The properties in the event class by which the events should be grouped.
  245.        ''' </param>
  246.        '''
  247.        ''' <param name="groupWithinInterval">
  248.        ''' The interval, in seconds, of the specified interval at which WMI sends one aggregate event,
  249.        ''' rather than many events.
  250.        ''' </param>
  251.        ''' ----------------------------------------------------------------------------------------------------
  252.        <DebuggerStepThrough>
  253.        Public Sub New(ByVal eventClassName As String,
  254.                       ByVal condition As String,
  255.                       ByVal groupByPropertyList As String(),
  256.                       ByVal groupWithinInterval As TimeSpan)
  257.  
  258.            MyBase.Query = New WqlEventQuery(eventClassName:=eventClassName,
  259.                                             condition:=condition,
  260.                                             groupWithinInterval:=groupWithinInterval,
  261.                                             groupByPropertyList:=groupByPropertyList)
  262.  
  263.        End Sub
  264.  
  265.        ''' ----------------------------------------------------------------------------------------------------
  266.        ''' <summary>
  267.        ''' Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
  268.        ''' </summary>
  269.        ''' ----------------------------------------------------------------------------------------------------
  270.        ''' <param name="query">
  271.        ''' The WMI select query of the event class to subscribe for.
  272.        ''' </param>
  273.        ''' ----------------------------------------------------------------------------------------------------
  274.        <DebuggerStepThrough>
  275.        Public Sub New(ByVal query As SelectQuery)
  276.  
  277.            Me.New(query.ClassName, condition:=query.Condition, withinInterval:=1.0F)
  278.  
  279.        End Sub
  280.  
  281.        ''' ----------------------------------------------------------------------------------------------------
  282.        ''' <summary>
  283.        ''' Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
  284.        ''' </summary>
  285.        ''' ----------------------------------------------------------------------------------------------------
  286.        ''' <param name="query">
  287.        ''' The WMI select query of the event class to subscribe for.
  288.        ''' </param>
  289.        '''
  290.        ''' <param name="withinInterval">
  291.        ''' The interval, in seconds, that WMI will check for changes that occur to instances of the events of the
  292.        ''' specified class in the <paramref name="query"/> parameter.
  293.        ''' </param>
  294.        ''' ----------------------------------------------------------------------------------------------------
  295.        <DebuggerStepThrough>
  296.        Public Sub New(ByVal query As SelectQuery,
  297.                       ByVal withinInterval As Single)
  298.  
  299.            Me.New(query.ClassName, condition:=query.Condition, withinInterval:=TimeSpan.FromSeconds(withinInterval))
  300.  
  301.        End Sub
  302.  
  303.        ''' ----------------------------------------------------------------------------------------------------
  304.        ''' <summary>
  305.        ''' Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
  306.        ''' </summary>
  307.        ''' ----------------------------------------------------------------------------------------------------
  308.        ''' <param name="query">
  309.        ''' The WMI select query of the event class to subscribe for.
  310.        ''' </param>
  311.        '''
  312.        ''' <param name="withinInterval">
  313.        ''' The interval, in seconds, that WMI will check for changes that occur to instances of the events of the
  314.        ''' specified class in the <paramref name="query"/> parameter.
  315.        ''' </param>
  316.        ''' ----------------------------------------------------------------------------------------------------
  317.        <DebuggerStepThrough>
  318.        Public Sub New(ByVal query As SelectQuery,
  319.                       ByVal withinInterval As TimeSpan)
  320.  
  321.            Me.New(query.ClassName, condition:=query.Condition, withinInterval:=withinInterval)
  322.  
  323.        End Sub
  324.  
  325.        ''' ----------------------------------------------------------------------------------------------------
  326.        ''' <summary>
  327.        ''' Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
  328.        ''' </summary>
  329.        ''' ----------------------------------------------------------------------------------------------------
  330.        ''' <param name="query">
  331.        ''' The WMI select query of the event class to subscribe for and its selected properties.
  332.        ''' </param>
  333.        '''
  334.        ''' <param name="groupWithinInterval">
  335.        ''' The interval, in seconds, of the specified interval at which WMI sends one aggregate event,
  336.        ''' rather than many events.
  337.        ''' </param>
  338.        ''' ----------------------------------------------------------------------------------------------------
  339.        <DebuggerStepThrough>
  340.        Public Sub New(ByVal query As SelectQuery,
  341.                       ByVal groupWithinInterval As UInteger)
  342.  
  343.            Dim strArray As String() = New String(query.SelectedProperties.Count - 1) {}
  344.            query.SelectedProperties.CopyTo(strArray, 0)
  345.  
  346.            MyBase.Query = New WqlEventQuery(eventClassName:=query.ClassName,
  347.                                             condition:=query.Condition,
  348.                                             groupWithinInterval:=TimeSpan.FromSeconds(groupWithinInterval),
  349.                                             groupByPropertyList:=strArray)
  350.  
  351.        End Sub
  352.  
  353. #End Region
  354.  
  355.    End Class
  356.  
  357. #End Region

Ejemplo de uso para subscribirnos a la class Win32_VolumeChangeEvent, la cual nos informa de cambios de volumen, del montaje y desmontaje de particiones del sistema:

Código
  1. Public NotInheritable Class Form1 : Inherits Form
  2.  
  3.    Private WithEvents eventWatcher As New WMIEventWatcher("Win32_VolumeChangeEvent", withinInterval:=0.5F)
  4.  
  5.    Private Sub Form1_Load(ByVal sender As Object, ByVal e As EventArgs) Handles Me.Load
  6.        Me.eventWatcher.Scope = New ManagementScope("root\CIMV2", New ConnectionOptions() With {.EnablePrivileges = True})
  7.        Me.eventWatcher.Start()
  8.    End Sub
  9.  
  10.    Private Sub Form1_FormClosing(ByVal sender As Object, ByVal e As FormClosingEventArgs) Handles Me.FormClosing
  11.        Me.eventWatcher.Dispose()
  12.    End Sub
  13.  
  14.    Private Sub EventWatcher_EventArrived(ByVal sender As Object, ByVal e As EventArrivedEventArgs) _
  15.    Handles eventWatcher.EventArrived
  16.        Dim driveName As String = CStr(e.NewEvent.Properties("DriveName").Value)
  17.        Dim eventType As Integer = CInt(e.NewEvent.Properties("EventType").Value)
  18.  
  19.        Console.WriteLine(String.Format("Drive Name: {0}", driveName))
  20.        Console.WriteLine(String.Format("Event Type: {0}", eventType))
  21.    End Sub
  22.  
  23. End Class

Ejemplo de uso para subscribirnos a la class Win32_LogicalDisk, mediante la cual con el uso de una condición en la consulta de WMI, nos reportará cambios de inserción y eyección en dispositivos de CD-ROM:

Código
  1. Public Class Form1 : Inherits Form
  2.  
  3.    Private WithEvents eventWatcher As New WMIEventWatcher(
  4.        "__InstanceModificationEvent",
  5.        condition:="TargetInstance ISA 'Win32_LogicalDisk' and TargetInstance.DriveType = 5",
  6.        withinInterval:=0.5F
  7.    )
  8.  
  9.    Private Sub Form1_Load(ByVal sender As Object, ByVal e As EventArgs) Handles Me.Load
  10.        Me.eventWatcher.Scope = New ManagementScope("root\CIMV2", New ConnectionOptions() With {.EnablePrivileges = True})
  11.        Me.eventWatcher.Start()
  12.    End Sub
  13.  
  14.    Private Sub Form1_FormClosing(ByVal sender As Object, ByVal e As FormClosingEventArgs) Handles Me.FormClosing
  15.        Me.eventWatcher.Dispose()
  16.    End Sub
  17.  
  18.    Private Sub EventWatcher_EventArrived(ByVal sender As Object, ByVal e As EventArrivedEventArgs) Handles eventWatcher.EventArrived
  19.  
  20.        Using mo As ManagementBaseObject = DirectCast(pd.Value, ManagementBaseObject)
  21.  
  22.            Dim name As String = Convert.ToString(mo.Properties("Name").Value)
  23.            string label = Convert.ToString(mo.Properties("VolumeName").Value);
  24.  
  25.            Dim di As DriveInfo = (From item In DriveInfo.GetDrives()
  26.                                   Where String.IsNullOrEmpty(item.Name)
  27.                                  ).Single()
  28.  
  29.            If Not String.IsNullOrEmpty(di.VolumeLabel) Then
  30.  
  31.                Console.WriteLine(String.Format("CD has been inserted in drive {0}.", di.Name))
  32.            Else
  33.  
  34.                Console.WriteLine(String.Format("CD has been ejected from drive {0}.", di.Name))
  35.  
  36.            End If
  37.  
  38.        End Using
  39.  
  40.    End Sub
  41.  
  42. End Class
Nota: No he podido testear el ejemplo del dispositivo CD-ROM.



Todas estas funcionalidades y muchísimas más las podrán encontrar en mi Framework de pago ElektroKit.
123  Programación / .NET / Re: Librería de Snippets para VB.Net !! (Compartan aquí sus snippets) en: 1 Abril 2017, 16:22
Hace mucho tiempo que no publico nada aquí...

Vamos allá:



¿Cómo validar el número de una tarjeta de crédito?

Para ello podemos implementar el algoritmo Luhn.

Código
  1. ''' ----------------------------------------------------------------------------------------------------
  2. ''' <summary>
  3. ''' Uses the Luhn algorithm to determines whether the specified credit card number is valid.
  4. ''' <para></para>
  5. ''' Please de aware that not all valid credit cards can be verified with the Luhn algorithm because
  6. ''' it not covers all range of card numbers, however the Luhn algorithm does work for many, if not most, major credit cards.
  7. ''' <para></para>
  8. ''' The Luhn algorithm is simply used to prevent transpositional errors,
  9. ''' it is useful as a sanity check prior to submitting card numbers to a payment gateway,
  10. ''' but not suitable to absolutely validate whether a number is a valid card number.
  11. ''' <para></para>
  12. ''' The only way to absolutely verify a credit card number is to validate it via a payment gateway.
  13. ''' </summary>
  14. ''' ----------------------------------------------------------------------------------------------------
  15. ''' <remarks>
  16. ''' Luhn algorithm: <see href="https://en.wikipedia.org/wiki/Luhn_algorithm"/>
  17. ''' <para></para>
  18. ''' Microsoft's Luhn algorithm implementation: <see href="http://referencesource.microsoft.com/#System.ComponentModel.DataAnnotations/DataAnnotations/CreditCardAttribute.cs"/>
  19. ''' <para></para>
  20. ''' Credits to: <see href="http://www.vcskicks.com/credit-card-verification.php"/>
  21. ''' </remarks>
  22. ''' ----------------------------------------------------------------------------------------------------
  23. ''' <example> This is a code example.
  24. ''' <code>
  25. ''' Dim visaNumber As String = "4012888888881881"
  26. ''' Dim isValid As Boolean = ValidateCreditCardNumber(visaNumber)
  27. ''' </code>
  28. ''' </example>
  29. ''' ----------------------------------------------------------------------------------------------------
  30. ''' <param name="cardNumber">
  31. ''' The credit card number.
  32. ''' </param>
  33. ''' ----------------------------------------------------------------------------------------------------
  34. ''' <returns>
  35. ''' <see langword="True"/> if the specified card number is a valid card number; otherwise, <see langword="False"/>.
  36. ''' </returns>
  37. ''' ----------------------------------------------------------------------------------------------------
  38. Public Shared Function ValidateCreditCardNumber(ByVal cardNumber As String) As Boolean
  39.  
  40.    cardNumber = cardNumber.Replace(" ", "").Replace("-", "").Trim()
  41.  
  42.    ' FIRST STEP: Double each digit starting from the right
  43.    Dim doubledDigits As Integer() = New Integer(cardNumber.Length / 2 - 1) {}
  44.    Dim k As Integer = 0
  45.    For i As Integer = cardNumber.Length - 2 To 0 Step -2
  46.        Dim digit As Integer
  47.        If Not Integer.TryParse(cardNumber(i), digit) Then
  48.            Return False
  49.        End If
  50.        doubledDigits(k) = digit * 2
  51.        k += 1
  52.    Next i
  53.  
  54.    ' SECOND STEP: Add up separate digits
  55.    Dim total As Integer = 0
  56.    For Each i As Integer In doubledDigits
  57.        Dim number As String = i.ToString()
  58.        For j As Integer = 0 To (number.Length - 1)
  59.            total += Integer.Parse(number(j).ToString())
  60.        Next j
  61.    Next i
  62.  
  63.    ' THIRD STEP: Add up other digits
  64.    Dim total2 As Integer = 0
  65.    For i As Integer = cardNumber.Length - 1 To 0 Step -2
  66.        Dim digit As Integer = Integer.Parse(cardNumber(i).ToString())
  67.        total2 += digit
  68.    Next i
  69.  
  70.    ' FOURTH STEP: Total
  71.    Dim final As Integer = (total + total2)
  72.  
  73.    Return (final Mod 10 = 0) ' Well formed will divide evenly by 10.
  74.  
  75. End Function

Modo de empleo:
Código
  1. ' http://www.paypalobjects.com/en_US/vhelp/paypalmanager_help/credit_card_numbers.htm
  2. Dim visaNumber As String = "4012888888881881"
  3. Dim isValid As Boolean = ValidateCreditCardNumber(visaNumber)

Aquí les dejo unos números de tarjetas de crédito para testear:
Código
  1. ''' ----------------------------------------------------------------------------------------------------
  2. ''' <summary>
  3. ''' Contains a collection of credit card numbers for testing purposes.
  4. ''' </summary>
  5. ''' ----------------------------------------------------------------------------------------------------
  6. ''' <remarks>
  7. ''' <see href="http://www.paypalobjects.com/en_US/vhelp/paypalmanager_help/credit_card_numbers.htm"/>
  8. ''' </remarks>
  9. ''' ----------------------------------------------------------------------------------------------------
  10. ''' <example> This is a code example.
  11. ''' <code>
  12. ''' For Each card As KeyValuePair(Of String, String()) In CreditCardsTestNumbers
  13. '''     For Each cardnumber As String In card.Value
  14. '''         Dim isValidNumber As Boolean = ValidateCreditCardNumber(cardnumber)
  15. '''         Console.WriteLine("Card type: '{0}'; Number: '{1}'; Is Valid?: {2}", card.Key, cardnumber, isValidNumber)
  16. '''     Next cardnumber
  17. ''' Next card
  18. ''' </code>
  19. ''' </example>
  20. ''' ----------------------------------------------------------------------------------------------------
  21. Public Shared ReadOnly CreditCardsTestNumbers As New Dictionary(Of String, String())(StringComparison.OrdinalIgnoreCase) From {
  22.    {"American Express", {"378282246310005", "371449635398431"}},
  23.    {"American Express Corporate", {"378734493671000"}},
  24.    {"Australian BankCard", {"5610591081018250"}},
  25.    {"Dankort (PBS)", {"5019717010103742", "76009244561"}},
  26.    {"Diners Club", {"30569309025904", "38520000023237"}},
  27.    {"Discover", {"6011111111111117", "6011000990139424"}},
  28.    {"JCB", {"3530111333300000", "3566002020360505"}},
  29.    {"Mastercard", {"5555555555554444", "5105105105105100"}},
  30.    {"Switch/Solo (Paymentech)", {"6331101999990016"}},
  31.    {"VISA", {"4111111111111111", "4012888888881881", "4222222222222"}}
  32. }



¿Cómo auto-eliminar el executable de nuestra aplicación?

Para ello podemos escribir las instrucciones de eliminación en un archivo.bat externo, e iniciarlo.

¿Por qué Batch?, bueno, en un principio podriamos pensar en una solución usando puro código .NET por ejemplo compilando un código fuente en tiempo de ejecución para generar un executable de .NET temporal con las instrucciones de terminación del proceso y de eliminación del archivo, pero al hacer esto nos estaríamos metiendo en un círculo vicioso ya que el executable externo no se podría eliminar a si mismo, por ende, esta es una de las pocas ocasiones en las que Batch sirve para salvarnos de un apuro.

Código
  1. ''' ----------------------------------------------------------------------------------------------------
  2. ''' <summary>
  3. ''' Deletes the self application executable file.
  4. ''' </summary>
  5. ''' ----------------------------------------------------------------------------------------------------
  6. Public Shared Sub DeleteSelfApplication()
  7.    DeleteSelfApplication(TimeSpan.FromMilliseconds(0))
  8. End Sub
  9.  
  10. ''' ----------------------------------------------------------------------------------------------------
  11. ''' <summary>
  12. ''' Deletes the self application executable file.
  13. ''' </summary>
  14. ''' ----------------------------------------------------------------------------------------------------
  15. ''' <param name="delay">
  16. ''' A delay interval to wait (asynchronously) before proceeding to automatic deletion.
  17. ''' </param>
  18. ''' ----------------------------------------------------------------------------------------------------
  19. Public Shared Async Sub DeleteSelfApplication(ByVal delay As TimeSpan)
  20.  
  21.    If (delay.TotalMilliseconds > 0.0R) Then
  22.        Dim t As New Task(Sub() Thread.Sleep(delay))
  23.        t.Start()
  24.        Await t
  25.    End If
  26.  
  27.    Dim script As String = <a>
  28. @Echo OFF
  29.  
  30. Set "exeName=%~nx1"
  31. Set "exePath=%~f1"
  32.  
  33. :KillProcessAndDeleteExe
  34. (TaskKill.exe /F /IM "%exeName%")1>NUL 2>&amp;1
  35. If NOT Exist "%exePath%" (GoTo :SelfDelete)
  36. (DEL /Q /F "%exePath%") || (GoTo :KillProcessAndDeleteExe)
  37.  
  38. :SelfDelete
  39. (DEL /Q /F "%~f0")
  40. </a>.Value
  41.  
  42.    Dim tmpFile As New FileInfo(Path.Combine(Path.GetTempPath, Path.GetTempFileName))
  43.    tmpFile.MoveTo(Path.Combine(tmpFile.DirectoryName, tmpFile.Name & ".cmd"))
  44.    tmpFile.Refresh()
  45.    File.WriteAllText(tmpFile.FullName, script, Encoding.Default)
  46.  
  47.    Using p As New Process()
  48.        With p.StartInfo
  49.            .FileName = tmpFile.FullName
  50.            .Arguments = String.Format(" ""{0}"" ", Application.ExecutablePath)
  51.            .WindowStyle = ProcessWindowStyle.Hidden
  52.            .CreateNoWindow = True
  53.        End With
  54.        p.Start()
  55.        p.WaitForExit(0)
  56.    End Using
  57.  
  58.    Environment.Exit(0)
  59.  
  60. End Sub

Modo de empleo:
Código
  1. ' Auto destruir el executable al instante:
  2. DeleteSelfApplication()
  3.  
  4. ' Auto destruir el executable de forma asincrónica con un tiempo de espera de 5 segundos:
  5. DeleteSelfApplication(TimeSpan.FromSeconds(5))

El contenido del archivo.bat generado sería el siguiente:
Código
  1. @Echo OFF
  2.  
  3. Set "exeName=%~nx1"
  4. Set "exePath=%~f1"
  5.  
  6. :KillProcessAndDeleteExe
  7. (TaskKill.exe /F /IM "%exeName%")1>NUL 2>&amp;1
  8. If NOT Exist "%exePath%" (GoTo :SelfDelete)
  9. (DEL /Q /F "%exePath%") || (GoTo :KillProcessAndDeleteExe)
  10.  
  11. :SelfDelete
  12. (DEL /Q /F "%~f0")
...Lo primero que hará el script será entrar en un búcle infinito donde se intentará matar el proceso, y una vez conseguido se dispondrá a eliminar el archivo, y por último eliminarse a sí mismo.



¿Cómo guardar y restaurar el estado expandido/colapsado de los nodos de un TreeView?

Pongámonos en situación, imaginemos que tenemos un control de tipo TreeView en el que tenemos que crear y destruir algunos de sus nodos o todos ellos de forma dinámica, y al hacerlo perderiamos el estado expandido/colapsado de cada nodo al refrescar la lista de nodos.

U otra situación distinta, en la que simplemente quisieramos guardar el estado del TreeView al cerrar la aplicación, para cargar ese estado en el próximo inicio de la aplicación.

Bien, pues para solucionar ese tipo de problema primero crearíamos la siguiente función que nos devolverá una lista con todos los nodos y sus nodos hijos de un TreeView:

Código
  1. ''' ----------------------------------------------------------------------------------------------------
  2. ''' <summary>
  3. ''' Gets all the parent nodes and all its child nodes in the source <see cref="TreeView"/>.
  4. ''' </summary>
  5. ''' ----------------------------------------------------------------------------------------------------
  6. ''' <example> This is a code example.
  7. ''' <code>
  8. ''' Dim nodeList As List(Of TreeNode) = Me.TreeView1.GetAllNodesAndChildnodes()
  9. '''
  10. ''' For Each node As TreeNode In nodeList
  11. '''     ' ...
  12. ''' Next node
  13. ''' </code>
  14. ''' </example>
  15. ''' ----------------------------------------------------------------------------------------------------
  16. ''' <param name="sender">
  17. ''' The source <see cref="TreeView"/>.
  18. ''' </param>
  19. ''' ----------------------------------------------------------------------------------------------------
  20. ''' <returns>
  21. ''' A <see cref="List(Of TreeNode)"/> containing all the parent nodes and all its child nodes.
  22. ''' </returns>
  23. ''' ----------------------------------------------------------------------------------------------------
  24. Public Shared Function GetAllNodesAndChildnodes(ByVal sender As TreeView) As List(Of TreeNode)
  25.  
  26.    Dim nodes As New List(Of TreeNode)
  27.    Dim stack As New Stack(Of TreeNode)
  28.  
  29.    ' Bang all the top nodes into the queue.
  30.    For Each top As TreeNode In sender.Nodes
  31.        stack.Push(top)
  32.    Next
  33.  
  34.    While (stack.Count > 0)
  35.        Dim node As TreeNode = stack.Pop()
  36.        If (node IsNot Nothing) Then
  37.            ' Add the node to the list of nodes.
  38.            nodes.Add(node)
  39.  
  40.            If (node.Nodes IsNot Nothing) And (node.Nodes.Count > 0) Then
  41.                ' Enqueue the child nodes.
  42.                For Each child As TreeNode In node.Nodes
  43.                    stack.Push(child)
  44.                Next child
  45.            End If
  46.        End If
  47.    End While
  48.  
  49.    stack.Clear()
  50.    stack = Nothing
  51.    Return nodes
  52.  
  53. End Function

Ahora solo tenemos que crear una función para iterar los nodos obtenidos y así crear un "estado de guardado" (o save state), el cual consistitía en un diccionario que contendrá el código hash identificador de cada nodo, y un valor boolean indicando si el nodo está expandido o colapsado.

Código
  1. ''' ----------------------------------------------------------------------------------------------------
  2. ''' <summary>
  3. ''' Saves the state of the source <see cref="TreeView"/> into a <see cref="Dictionary(Of Integer, Boolean)"/>
  4. ''' containing the hash code of each node and its expansion state.
  5. ''' </summary>
  6. ''' ----------------------------------------------------------------------------------------------------
  7. ''' <example> This is a code example.
  8. ''' <code>
  9. ''' Dim saveState As Dictionary(Of Integer, Boolean) = Me.TreeView1.SaveTreeState()
  10. ''' </code>
  11. ''' </example>
  12. ''' ----------------------------------------------------------------------------------------------------
  13. ''' <param name="sender">
  14. ''' The source <see cref="TreeView"/>.
  15. ''' </param>
  16. ''' ---------------------------------------------------------------------------------------------------
  17. ''' <returns>
  18. ''' A <see cref="Dictionary(Of Integer, Boolean)"/> containing the hash code of each node and its expansion state.
  19. ''' </returns>
  20. ''' ----------------------------------------------------------------------------------------------------
  21. Public Shared Function SaveTreeState(ByVal sender As TreeView) As Dictionary(Of Integer, Boolean)
  22.  
  23.    Dim nodeList As List(Of TreeNode) = GetAllNodesAndChildnodes(sender)
  24.    Dim nodeStates As New Dictionary(Of Integer, Boolean)()
  25.  
  26.    For Each node As TreeNode In nodeList
  27.        nodeStates.Add(node.GetHashCode(), node.IsExpanded)
  28.    Next
  29.  
  30.    Return nodeStates
  31.  
  32. End Function

Y por último la función para restaurar un estado de guardado:
Código
  1. ''' ----------------------------------------------------------------------------------------------------
  2. ''' <summary>
  3. ''' Restores a state of the source <see cref="TreeView"/> previously saved using the <see cref="SaveTreeState"/> function.
  4. ''' </summary>
  5. ''' ----------------------------------------------------------------------------------------------------
  6. ''' <example> This is a code example.
  7. ''' <code>
  8. ''' Dim saveState As Dictionary(Of Integer, Boolean)
  9. '''
  10. ''' Private Sub Button_SaveTreeState(sender As Object, e As EventArgs) Handles Button_SaveTreeState.Click
  11. '''     saveState = Me.TreeView1.SaveTreeState()
  12. ''' End Sub
  13. '''
  14. ''' Private Sub Button_RestoreTreeState(sender As Object, e As EventArgs) Handles Button_RestoreTreeState.Click
  15. '''     Me.TreeView1.RestoreTreeState(saveState)
  16. ''' End Sub
  17. ''' </code>
  18. ''' </example>
  19. ''' ----------------------------------------------------------------------------------------------------
  20. ''' <param name="sender">
  21. ''' The source <see cref="TreeView"/>.
  22. ''' </param>
  23. ''' ----------------------------------------------------------------------------------------------------
  24. ''' <param name="saveState">
  25. ''' A <see cref="Dictionary(Of Integer, Boolean)"/> containing the hash code of each node and its expansion state.
  26. ''' </param>
  27. ''' ----------------------------------------------------------------------------------------------------
  28. Public Shared Sub RestoreTreeState(ByVal sender As TreeView, ByVal saveState As Dictionary(Of Integer, Boolean))
  29.  
  30.    Dim nodeList As List(Of TreeNode) = GetAllNodesAndChildnodes(sender)
  31.  
  32.    For Each node As TreeNode In nodeList
  33.  
  34.        Dim hash As Integer = node.GetHashCode()
  35.  
  36.        If saveState.ContainsKey(hash) Then
  37.  
  38.            If saveState(hash) Then
  39.                node.Expand()
  40.            Else
  41.                node.Collapse()
  42.            End If
  43.  
  44.        End If
  45.  
  46.    Next
  47.  
  48. End Sub



Todas estas funcionalidades y muchísimas más las podrán encontrar en mi Framework de pago ElektroKit.
124  Sistemas Operativos / Windows / Re: Precargar un programa propio en imagen de Windows 10 en: 1 Abril 2017, 12:46
seria posible, al igual que cuando reinstalas windows te aparece con algunos programas precargados del fabricante, tipo antivirus con 1 mes de prueba y cosas así, poder meter un programa yo para que al reinstalar windows se instale automáticamente??

Por supuesto que se puede, tan solo hay que editar la imagen Install.WIM del DVD de Windows la cual contiene las imágenes de instalación del sistema con todos los archivos y directorios que se instalan por defecto, se debe montar la imagen y realizar las modificaciones deseadas, pero esto es un procedimiento que requiere un mínimo de conocimiento sobre todo lo que ello implica.

Hay aplicaciones enfocadas a la edición de imágenes WIM para guiarte de una forma automatizada (y también limitada), como por ejemplo WinToolkit: https://www.wincert.net/forum/index.php?/files/file/5-win-toolkit/

Si prefieres aventurarte para realizar las modificacione de una forma más "manual" con la mayor libertad de posibilidades, aquí publiqué un tutorial:




La pregunta es porque me han robado mi tablet recientemente que viene con Windows 10, y aunque he visto formas de localizarla por GPS de nada vale si el ladrón la formatea y reinstala windows, de ahi mi duda, si esto es posible hacerlo, para que cuando formateen la tablet automáticamente se instale un programa de seguimiento y me facilite donde esta la tablet en caso de futuros robos.

No tiene sentido eso. De nada te serviría preinstalar una aplicación en una imagen/DVD de Windows si luego un ladrón formatea el disco duro, donde se pierde todo, y además el susodicho ladrón al momento d instalar Windows utilizaría un DVD de Windows distinto donde no estaría preinstalada tu aplicación...
Evidéntemente no podría persistir a un formateo.

¡Saludos!
125  Foros Generales / Foro Libre / Re: ¿Cual es mejor? Trump o Putin en: 1 Abril 2017, 12:25
Los dos individuos serían "malas elecciones", pero uno siempre será peor que el otro... ningún ruso gana a un presidente Yankee a hijo de... "fruta", eso.



126  Programación / .NET / Re: Como obtengo el nombre de un recurso embedido o la ruta? en: 1 Abril 2017, 02:48
Mi pregunta como puedo obtener la ruta o nombre de un recursos embedido

No existe tal ruta, pues se trata de un recurso, embedido... en el archivo de recursos del executable compilado.

Ya que lo llamare por medio de la funcion
 RunInterna("la ruta del recurso embedido", "pass");

...¿?. Intenta explicar de forma clara que es lo que estás intentando hacer.

Si pretendes ejecutar un archivo binario que has embedido como recurso, entonces lee aquí:

Y aquí te dejo lo siguiente por si te sirve, un código de uso genérico (extraido de mi framework de pago ElektroKit) para ejecutar recursos binarios en memoria, es decir, sin extraerlos previamente al disco:
( puedes usar cualquier conversor online a C# )

¡Saludos!
127  Programación / .NET / Re: No encuentro evento de DataGridViewComboBoxCell en: 1 Abril 2017, 01:22
Hola.

Si no te he entendido mal quieres ser capaz de controlar el evento ComboBox.SelectedIndexChanged de los ComboBoxes que existan en las celdas de tu DataGridView, y obtener el número de columna y fila de la celda cada que que dicho evento se dispare.

Bien, pues para ello puedes controlar el evento DataGridView.EditingControlShowing de la siguiente manera. Te muestro un ejemplo que puedas adaptar a tus necesidades:

Código
  1. Public NotInheritable Class Form1 : Inherits Form
  2.  
  3.    Private Sub Form1_Shown(sender As Object, e As EventArgs) Handles MyBase.Shown
  4.  
  5.        Dim column As New DataGridViewComboBoxColumn()
  6.        With column
  7.            .DataSource = "qwerty".ToArray()
  8.            .ValueType = GetType(Char)
  9.        End With
  10.  
  11.        Me.DataGridView1.Columns.Add(column)
  12.  
  13.    End Sub
  14.  
  15.    Private Sub DataGridView1_EditingControlShowing(sender As Object, e As DataGridViewEditingControlShowingEventArgs) _
  16.    Handles DataGridView1.EditingControlShowing
  17.  
  18.        Dim cb As ComboBox = DirectCast(e.Control, ComboBox)
  19.        ' Eliminar un posible controlador de evento que haya sido agregado anteriormente, para evitar agregar varios.
  20.        RemoveHandler cb.SelectedIndexChanged, AddressOf Me.ComboBox_SelectedIndexChanged
  21.        ' Aasociar el nuevo controlador.
  22.        AddHandler cb.SelectedIndexChanged, AddressOf Me.ComboBox_SelectedIndexChanged
  23.  
  24.    End Sub
  25.  
  26.    Private Sub ComboBox_SelectedIndexChanged(sender As Object, e As EventArgs)
  27.  
  28.        Dim cb As ComboBox = DirectCast(sender, ComboBox)
  29.  
  30.        If (cb.SelectedIndex <> -1) Then
  31.            Dim dgv As DataGridView = DirectCast(cb.Parent.Parent, DataGridView)
  32.            Dim cell As DataGridViewCell = dgv.CurrentCell
  33.            Dim colIndex As Integer = cell.ColumnIndex
  34.            Dim rowIndex As Integer = cell.RowIndex
  35.  
  36.            Dim sb As New StringBuilder()
  37.            sb.AppendLine(String.Format("Selected index changed: {0}", cb.SelectedIndex))
  38.            sb.AppendLine(String.Format("Column Index: {0}, Row Index: {1}", colIndex, rowIndex))
  39.            MessageBox.Show(sb.ToString())
  40.        End If
  41.  
  42.    End Sub
  43.  
  44. End Class

¡Saludos!
128  Programación / Programación General / MOVIDO: Ayuda con este crypter en autoit en: 31 Marzo 2017, 23:12
El tema ha sido movido a Scripting.

http://foro.elhacker.net/index.php?topic=467337.0
129  Foros Generales / Dudas Generales / Re: ¿Qué programa de TTS y que voz han usado en estos videos? en: 31 Marzo 2017, 17:53
Esta voz la tengo escuchada yo, sea para convertir audiolibros, o sea pars plugin de navegador. Si doy con el programa ya diré que lo tengo en otro dispositivo

Ojalá la encuentres. Precisamente yo la quiero para convertir libros y que me vaya leyendo la voz de la tia esa :xD, por que a diferencia de cualquiera otra voz TTS que yo haya escuchado hasta ahora, es sencillamente perfecta, parece que te esté hablando un humano, en serio no tiene nada que ver con la porquería de voces de Loquendo, Ivona y programas similares... que en cada palabra pronunciada se nota que es una voz sintética.

mmmmm... me parece recordar que se llama "Teresa" y no estoy seguro de si efectivamente era de Loquendo, pero de hace entre 15 y 20 años...

Eso es algo imposible, la calidad del software de sintetización de hace < 6-8 años era simplemente ridícula, la síntesis de Loquendo es muy mala.

Fíjate en la sofisticación de la voz femenina de esos dos videos que he compartido, apenas se nota que haya 1 solo corte al pronunciar las palabras, de echo si no te dijera que es una voz sintética probablemente te costaría reconocer que lo es. Sin embargo con voces/programas de hace 10 años... se nota al instante, por que las voces producidas están llenas de glitches.

La sintesis de esta voz no tiene nada que se le pueda comparar a Loquendo, uf, sencilalmente es muy sofisticada, es de otro nivel superior, nunca habia visto una voz con tanto nivel de calidad. Por eso me intriga, quiero saber que voz es y que programa han usado.

¡Saludos!
130  Programación / .NET / Re: en el CLR, por que? en: 31 Marzo 2017, 15:37
da error en el CLR, por que?

El tipo de error que recibirías en este caso, System.IndexOutOfRangeException y el mensaje de error que lo acompaña, "Índice fuera de los límites de la matriz" son lo suficientemente auto-descriptivos para hacerte una idea de lo que ocurre.



El índice de un Array en la programación .NET empieza por el número Cero, y la propiedad Count / Length devuelve el número de elementos en un Array.

Lo explicaré de otra forma:
Si tu añades cinco elementos a un array, el margen numérico que podrás utilizar en el indexer de ese array será desde el 0 hasta el 4:
Ejemplo:
Código
  1. Dim arr As Object() = {item1, item2, item3, item4, item5}
Es decir que puedes usar desde arr(0) hasta arr(4).

Cuando llamas a la propiedad arr.Count / arr.Length, ésta devolverá la cantidad de elementos del array, es decir un valor de 5, puesto que el array contiene 5 elementos;
Entonces, al intentar iterar los elementos de la siguiente manera, estarías intentando acceder al índice arr(5), el cual no existe, y por lo tanto lanzaría un error:
Código
  1. For i As Integer = 0 To arr.Length  ' 0 To 5
  2.    Console.WriteLine(arr(i))
  3. Next

Por eso se le debe descontar 1 al valor que devuelve la propiedad Count / Length:
Código
  1. For i As Integer = 0 To (arr.Length - 1) ' 0 To (5 - 1)
  2.    Console.WriteLine(arr(i))
  3. Next

Lo mismo se aplicaría al ejemplo que pusiste de un búcle con la incrementación de la instrucción Step:
Código
  1. For i As Integer = 0 To (arr.Length - 1) Step 1 ' 0 To (5 - 1) Increment 1
  2.    Console.WriteLine(arr(i))
  3. Next



pero por eso se pone el -1? para que no salga del limite?
y que no llegue al 5 sino que se quede en el 4????

Exacto. Puesto que el índice de un array empieza por 0, la propiedad Count / Length siempre devolverá un valor mayor (un 1 más) puesto que lo que hace es contrar la cantidad de elementos del array, así que si un array contiene 1 elementos, Count / Length devolverá el valor "1", no "0"... evidéntemente.

¡Saludos!
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 ... 944
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines