Mensajes

[Moo0 File Monitor]

me gustaria saber como puedo abrir un exe de esos para ver el codigo de programacion que tienen , o sea ver que es lo que hace el programa, a que rutas accede y eso...

Aparte de lo que ya te han comentado, depende del parcheador, por que hay varios tipos de metodologías. Un parche puede tener la funcionalidad de escribir/manipular los offsets del executable objetivo, o simplemente el parche podría contener el archivo objetivo ya modificado y simplemente realizar una operación de reemplazamiento de archivos. O tal vez el parche en cuestión no modifica ningún exe objetivo sino claves de registro o archivos de text plano...

Para saber los archivos que manipula un executable/parche, te sirve con utilizar cualquier software de monitorización del sistema de archivos, como por ejemplo Moo0 File Monitor. Para saber que claves de registro se manipulan, lo mismo, un monitor de registro como por ejemplo Regshot (la versión Unicode de 64 Bits). Y para saber que cambios específicos se realizan en los offsets/bytes del executable objetivo a parchear (si alguno), pues lo que ya te han dicho, puedes usar un descompilador o desensamblador para analizar las instrucciones originales del programa, o también puedes utilizar cualquier software de comparación de archivos byte a byte (por método Diff) como por ejemplo Ultra Compare.

• http://www.moo0.com/?top=http://www.moo0.com/software/FileMonitor/
• https://sourceforge.net/projects/regshot/files/regshot/1.9.0/
• http://www.ultraedit.com/products/ultracompare.html

¡Saludos!

[todos]

Hola. Si te inicia sesión en Windows no creo que haya que alarmarse con respecto a los componentes de hardware. Eso de tener un corte de luz y que luego al intentar iniciar sesión en Windows se quede la pantalla en negro y no avance pero estés dentro de widnows por que te permite usar ctrl+alt+supr, me ha pasado antaño (y más de una vez), por eso te puedo asegurar que la gráfica no se te ha estropeado... en todo caso tal vez algún archivo crítico del sistema para el inicio de sesión se haya corrompido.

Prueba a usar ctrl+alt+supr para iniciar el administrador de tareas (taskmgr.exe) y comprueba los procesos que están activos. Si no ves el proceso explorer.exe, entonces intenta iniciarlo desde el menú del administrador de tareas: Archivo->Nueva tarea (Ejecutar...) si eso no resuelve el problema entonces inicia la consola de windows (cmd.exe) siguiendo el mismo procedimiento y utiliza el siguiente comando para verificar la integridad de los archivos del sistema y reparar los posibles fallos de forma automática:

Código [Seleccionar] Expandir

SFC.exe /SCANNOW
(y reinicia el PC cuando acabe de reparar)

Si eso tampoco te funcionase, intenta crear una nueva cuenta de usuario e intentar loguearte en ella.

Como último recurso para solucionar los problemas de inicio de sesión siempre puedes reinstalar Windows, conservarías todos tus archivos pero perderías la configuración de las aplicaciones que tuvieras instaladas.

¡Saludos!

[Homeopatia]

Y lo peor a margen de que sean unos estafadores, es que legalmente no se les pueda condenar por asesinato, lo cual merecerían

Una cosa que realmente me hace replantearme las supuestas buenas intenciones de la industria farmacéutica... ¡qué digo!, de los gobiernos de todos los paises en general, es que precisamente se permita el mercado fraudulento de la Homeopatia, la comercialización de sus productos y la pseudo-investigación para seguir desarrollando nuevas "fórmulas de tratamiento medicinal".

Lo cierto es que le duela a quien le duela, de cara al público la homeopatía está considerada como una rama de la ciencia, aunque es evidente que oficialmente no se considera ciencia y para cualquier médico y/o científico la homeopatía se aleja del verdadero significado de ciencia enfocada a la medicina (aunque si que hay algunos médicos que directamente le recomiendan al paciente la homeopatía, no me explicó donde estudiaron esas personas la medicina), pero para el resto de personas mortales que ignoren el proceso de elaboración de sus productos (que es de lo más absurdo) pues... para todas esas personas seguirán viéndolo como ciencia igual, cosa de la que estos fraudulentos "científicos" o "médicos" se aprovechan sin importarles la vida de sus pacientes.

Orubatosu, ¿tú sabes algo más en profundidad sobre este tema de los líimtes de la legalidad médica?. Me refiero: ¿por qué está permitido que se lleve a cabo este negocio de la Homeopatía?.

...Supuestamente los productos "homeopáticos" son APROBADOS y COMERCIALIZADOS en las farmacias, y los ancargados de aprobar su comercialización son precisamente las entidades farmaceuticas/sanitarias del gobierno que son conscientes del fraude que están comercializando y con las incontables vidas y personas ingenuas que están poniendo en peligro de muerte, así que yo no lo entiendo, no entiendo nada de lo que ocurre en el mundo...

¡Saludos!

[Install Builder]

Lo que quiero y no se si se puede es un programa que me permita modificar los exe para que saltase los siguientes y instalar y que se instale ni bien lo ejecute sin un mensaje. Lo que quiero es crear un .bat que me permita ejecutar varios .exe y los instale sin que yo le ponga siguiente, creo que me exprese bien.

Si, se podría simular y automatizar la interacción del usuario con los botones de la UI con un lenguaje de programación, pero no con uno tan limitado como Batch. De todas formas olvídate de eso, pues estás enfocando mal el problema y la resolución del mismo...

Un instalador se suele crear a partir de un software dedicado a la construcción de dicho tipo de instalador. A este tipo de software se le conoce por el término Install Builder, y una de sus características es implementar ciertas opciones que se presentan por defecto en los instaladores para que puedan ser instalados de forma silenciosa por linea de comandos (cosa que sí podrías hacer con Batch mismamente).

Así que lo que tienes que hacer simplemente es averiguar que tipo de instalador es ese executable o mejor dicho con que tipo de install builder se creó (InnoSetup, NSIS, VSIX, MSI, InstallShield, etc), y una vez que sepas eso tan solo debes averiguar que comandos provee ese Install Builder para permitir instalar de forma desatentida el instalador en cuestión (información que puedes obtener en la web del autor del programa o en Google).

Debido a que tienes varios instaladores cuya instalación quieres automatizar, sería lógico pensar que todos los instaladores no pertenecen al mismo autor, así que probablemente varios de esos instaladores hayan sido creados con distintos install builders, por ende, no se te puede ofrecer una ayuda en concreto ya que no has aportado los datos necesarios...

Estos son algunos de los comandos más comunes que puedes probar:

Código [Seleccionar] Expandir

Instalador.exe -s
Instalador.exe -S
Instalador.exe /s
Instalador.exe /S
Instalador.exe /silent
Instalador.exe /Silent
Nótese que algunos instaladores diferencian entre mayúscula y minúscula, por eso...

El tipo de install builder que se haya usado para crear un instalador es algo que se puede reconocer al instante y a simple vista simplemente analizando visuálmente la interfáz de usuario del instalador (a menos que haya sido personalizada en exceso), pero si tienes dificultades para averiguarlo entonces puedes recurrir a aplicaciones de identificación de tipos de archivo, como por ejemplo TrIDNet o PeID, siendo esta última más enfocada al análisis de executables.

También cabe mencionar que dependiendo del autor, me refiero, quien haya creado el instalador, éste puede presentar comandos personalizados para la instalación por linea de comandos, y de ser así entonces requeriría un análisis de ingeniería inversa en profundidad sobre el instalador en cuestión para averiguar los comandos que puedes usar (existen aplicaciones especializadas para obtener esa información, dependiendo del tipo de instalador también).

¡Saludos!.

[Is It True That Only 2 Or 3 % Of Cancer Patients Survive Chemotherapy?]

Hola.

He decidido escribir este post por que creo que a muchas personas que puedan tener amigos o familiares con problemas de cancer les podría servir para ayudarles a tomar la mejor decisión en sus tratamientos médicos o naturitistas...

Yo siempre he sido una persona escéptica con respecto a la honestidad y la eficia de algunos tratamientos de la medicina moderna. Me considero alguien abierto a distintas opiniones, y cuando una persona está dispuesta a escuchar una opinión distinta a la opinión científica u oficial, inevitablemente esa persona acabará escuchando conspiraciones... y deberá cuestionarse la información que le están brindando por ambas partes.

Creo que todos nosotros en alguna ocasión de nuestras vidas hemos escuchado hablar sobre la supuesta conspiración de la Quimioterapia o también conocida como "El negocio del Cancer". La opinión científica siempre nos ha dicho que la Quimio sirve para curar el cancer y lo hace dejando claro que no es un tratamiento 100% efectivo, mientras que otro gran porcentaje de la población siempre han dicho que la Quimio es más bien un método inmoral de comercio de la industria médica para cobrar beneficio por un tratamiendo millonario, y mientras que un porcentaje menor de la población también podría añadir que la Quimio es un método de genocidio, que sirve para controlar la natalidad de la población como una especie de eutanasia permitida, en el sentido de ser una intervención deliberada por parte de la medicina para poner fin a la vida de un paciente sin perspectiva de cura.

Ese porcentaje de gente negacionista no se suelen basar en sus propias experiencias con el tratamiento de cancer, sino más bien en una opinión popular de personajes que practican métodos alternativos de medicina (es decir, la competencia de la medicina moderna) cuyas intenciones de por si son poco fiables, y cuyas afirmaciones se han ido extendiendo como la pólvora con los años por todo el mundo y por toda la World Wide Web, llegando a todo tipo de sitios web de información alternativa y de canales de Youtube de conspiraciones, y etc, poniendo como ciertas tales afirmaciones...

Ellos se basan en un interpretación incorrecta (o una interpretación conveniente para el bolsillo de quien lo interpreta, según se mire) de los datos oficiales existentes, como por ejemplo los resultados de ciertos estudios científicos de algunas universidades que ponian a prueba la supuesta eficacia de la Quimioterapia. Lo más común es escuchar a alguien decir que existen estudios científicos que demuestran que la Quimio solo cura al 2% de los pacientes, ¿pero saben qué?, todo eso es falso, es una mala interpretación, ya que en realidad la Quimio supuestamente tiene un porcentaje de curación del 60% (estadísticas de hace 6 años ya, así que ahora mismo podrían ser incluso más). Las personas que no creen en este aspecto de la medicina moderna están equivocados, como lo he estado yo hasta el día de hoy, y es que la Quimio evidentemente no es capaz de sanar a todos los pacientes, pero si a un mayor porcentaje del que nos quieren hacer creer los conspiradores.

Yo me considero a mi mismo una persona benevolente, y pienso que cualquier persona por muy ingenua o intelegente que sea puede caer en el engaño de esta conspiración negacionista de la medicina moderna, y ese error puede resultar ser un peligro que puede acabar poniendo en riesgo las vidas de otras personas enfermas que nos rodean por aconsejarles que no se traten con Quimio. Por eso estoy haciendo este post, por que creo que es una de las mayores falacias médicas que existen en el mundo, y es común que salga el tema en conversaciones de medicina de nuestro día a día, algo con lo que nos estamos engañando constantemente y engañando a las personas que nos importan, así que pretendo advertir de esta mentira para dar a conocer la verdad del asunto...

Bueno. Despues de esta larga introducción lo cierto es que no tengo mucho más que añadir, por que toda la información que necesitan saber (la cual desmiente la opinión negacionista sobre la Quimio) se encuentra en el siguiente artículo de medicina que recopila fuentes de los estudios y desmiente las mentiras conspiranoicas que llevamos años creyendo sobre la Quimio, solo tienen que leerlo:

• Is It True That Only 2 Or 3 % Of Cancer Patients Survive Chemotherapy?

Espero de verdad que esta información le pueda servir a alguien más para cambiar su modo de pensar sobre la medicina moderna, en concreto sobre las terapias contra el cancer, y dejar de ser engañados por esos líderes de la conspiración, cienciólogos, o herboristas y sabelotodos de la medicina alternativa que creen estar en el poder absoluto de la verdad con sus plantas medicinales y acusando de farsantes a los médicos y de estafa a los tratamientos modernos que nos ofrecen cuya intención es curar a los pacientes, no matarlos.



En ese mismo blog que he compartido, podeis leer artículos igual de interesantes sobre los supuestos milagros que se le atribuye al tratamiento de enfermedades por medio del Canabbis:

• https://anaximperator.wordpress.com/2015/07/29/cannabis-anecdote/

( Lo considero muy interesante aunque se analice un caso médico en particular, y no los beneficios ni los peligros generales del Cannabbis como planta medicinal. )

¡Saludos!

[ClickBait]

Señorita Constance, nos has colado un "ClickBait" por toda la face . Me esperaba que eso que tienes en común fuese algo más interesante o más serio que una fecha de cumpleaños.

Si quieres tener algo más en común con Steve Jobs, tal vez te interesase leer uno de sus liros favoritos que le ayudaron a inspirarse, se titula "Autobiografía de un Yogi" del autor y yogi Paramahansa Yogananda. Te lo comento por que creo que tienes cierta curiosidad por los temas de espiritualidad. No es una recomendación personal ni nada por el estilo, solo es un dato curioso que te doy por si lo desconocias.

¡Saludos!

[Panel de control\Todos los elementos de Panel de control\Pantalla\Resolución de pantalla]

como hago que en cada una de las pantallas se vea algo distinto

Bueno, ¿y si explicas cual es el problema que encuentras al intentar hacer eso?, ¿y si explicas también que significa para ti "ver algo distinto"?, ¿y si además explicases si estás utilizando Windows, o Linux o qué?. No somos adivinos, y la falta de información solo sirve para generar suposiciones equívocas o confusión y hacerle perder el tiempo al personal escribiendo respuestas que podrían resultarte de inutilidad por una mala comprensión del problema.

De todas formas, creo que lo único que necesitas saber es que el programa de reproducción de video o de vigilancia de cámara o lo que sea que estés intentando correr debe ser un executable multi instancia, para que puedes abrir otra instancia adicional del mismo programa y colocarla en el áera visible de la otra pantalla. O simplemente que el programa de vigilancia ofrezca por si solo de una manera distinta la caracteristica que necesitas, por ejemplo permitiendo abrir una ventana adicional con la que trabajar desde la misma instancia del programa, pues como ya te han dicho depende del programa ...de como funcione. Y no se entiende bien lo que queires hacer.

Por último, y si estás en Windows, supongo que no hará falta mencionar lo siguiente, pero por si acaso: debes asegurarte de extender la resolución/límites visibles de la pantalla en Panel de control\Todos los elementos de Panel de control\Pantalla\Resolución de pantalla

¡Saludos!

[Elektrokit]

Hola.

La siguiente solución que voy a compartir es de forma gratuita pero también se puede encontrar junto a muchas otras diversas utilidades imprescindibles (must-have!) en mi framework de pago Elektrokit, el cual se encuentra a la venta por un módico precio en el mercado web de CodeCanyon, en Envato.

Bien. Primero empecemos con los miembros que compondrian el algoritmo que se suscribe a los eventos de inserción y extracción de dispositivos extraibles; la lógica de todo ello lo encapsulé en un tipo bautizado con el nombre DriveWatcher y cuyo modo de empleo es orientado a eventos, muy sencillo de manejar...

Simplemente tienes que copiar y pegar estas clases en tu proyecto:

DriveWatcher.vb

Código (vbnet) [Seleccionar] Expandir

' ***********************************************************************
' Author   : Elektro
' Modified : 16-December-2016
' ***********************************************************************

#Region " Public Members Summary "

#Region " Constructors "

' New()

#End Region

#Region " Events "

' DriveStatusChanged As EventHandler(Of DriveStatusChangedEventArgs)

#End Region

#Region " Properties "

' Drives As IEnumerable(Of DriveInfo)
' Handle As IntPtr
' IsRunning As Boolean

#End Region

#Region " Methods "

' Start()
' Stop()

#End Region

#End Region

#Region " Usage Examples "

#End Region

#Region " Option Statements "

Option Strict On
Option Explicit On
Option Infer Off

#End Region

#Region " Imports "

Imports WindowsApplication1.IO.Types.EventArgs
Imports WindowsApplication1.Win32.Enums
Imports WindowsApplication1.Win32.Types

' Imports Elektro.Core.Types
' Imports Elektro.Core.IO.Types.EventArgs
' Imports Elektro.Interop.Win32.Enums
' Imports Elektro.Interop.Win32.Types

#End Region

#Region " Drive Watcher "

Namespace IO.Types

   ''' ----------------------------------------------------------------------------------------------------
   ''' <summary>
   ''' A device insertion and removal monitor.
   ''' </summary>
   ''' ----------------------------------------------------------------------------------------------------
   ''' <example> This is a code example.
   ''' <code>
   ''' </code>
   ''' </example>
   ''' ----------------------------------------------------------------------------------------------------
   Public Class DriveWatcher : Inherits NativeWindow : Implements IDisposable ' : Inherits AestheticNativeWindow

#Region " Properties "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets the connected drives on this computer.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Public Overridable ReadOnly Property Drives As IEnumerable(Of DriveInfo)
           <DebuggerStepThrough>
           Get
               Return DriveInfo.GetDrives
           End Get
       End Property

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets a value that determines whether the monitor is running.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Public Overridable ReadOnly Property IsRunning As Boolean
           <DebuggerStepThrough>
           Get
               Return Me.isRunningB
           End Get
       End Property
       Protected isRunningB As Boolean

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets the handle for the <see cref="NativeWindow"/> that owns this <see cref="DriveWatcher"/> instance.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <value>
       ''' The handle.
       ''' </value>
       ''' ----------------------------------------------------------------------------------------------------
       Public Overridable Shadows ReadOnly Property Handle As IntPtr
           Get
               Return MyBase.Handle
           End Get
       End Property

#End Region

#Region " Enumerations "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Specifies a computer device type.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <remarks>
       ''' <see href="http://msdn.microsoft.com/en-us/library/windows/desktop/aa363246%28v=vs.85%29.aspx"/>
       ''' </remarks>
       ''' ----------------------------------------------------------------------------------------------------
       Private Enum DeviceType As Integer

           ' *****************************************************************************
           '                            WARNING!, NEED TO KNOW...
           '
           '  THIS ENUMERATION IS PARTIALLY DEFINED TO MEET THE PURPOSES OF THIS API
           ' *****************************************************************************

           ''' <summary>
           ''' Logical volume.
           ''' </summary>
           Logical = &H2

       End Enum

#End Region

#Region " Events "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' A list of event delegates.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Private ReadOnly events As EventHandlerList

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Occurs when a drive is inserted, removed, or changed.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Public Custom Event DriveStatusChanged As EventHandler(Of DriveStatusChangedEventArgs)

           <DebuggerNonUserCode>
           <DebuggerStepThrough>
           AddHandler(ByVal value As EventHandler(Of DriveStatusChangedEventArgs))
               Me.events.AddHandler("DriveStatusChangedEvent", value)
           End AddHandler

           <DebuggerNonUserCode>
           <DebuggerStepThrough>
           RemoveHandler(ByVal value As EventHandler(Of DriveStatusChangedEventArgs))
               Me.events.RemoveHandler("DriveStatusChangedEvent", value)
           End RemoveHandler

           <DebuggerNonUserCode>
           <DebuggerStepThrough>
           RaiseEvent(ByVal sender As Object, ByVal e As DriveStatusChangedEventArgs)
               Dim handler As EventHandler(Of DriveStatusChangedEventArgs) =
                   DirectCast(Me.events("DriveStatusChangedEvent"), EventHandler(Of DriveStatusChangedEventArgs))

               If (handler IsNot Nothing) Then
                   handler.Invoke(sender, e)
               End If
           End RaiseEvent

       End Event

#End Region

#Region " Event Invocators "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Raises <see cref="DriveStatusChanged"/> event.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="e">
       ''' The <see cref="DriveStatusChangedEventArgs"/> instance containing the event data.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Protected Overridable Sub OnDriveStatusChanged(ByVal e As DriveStatusChangedEventArgs)

           RaiseEvent DriveStatusChanged(Me, e)

       End Sub

#End Region

#Region " Constructors "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Initializes a new instance of <see cref="DriveWatcher"/> class.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Public Sub New()
           Me.events = New EventHandlerList
       End Sub

#End Region

#Region " Public Methods "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Starts monitoring.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <exception cref="Exception">
       ''' Monitor is already running.
       ''' </exception>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Public Overridable Sub Start()

           If (Me.Handle = IntPtr.Zero) Then
               MyBase.CreateHandle(New CreateParams())
               Me.isRunningB = True

           Else
               Throw New Exception(message:="Monitor is already running.")

           End If

       End Sub

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Stops monitoring.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <exception cref="Exception">
       ''' Monitor is already stopped.
       ''' </exception>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Public Overridable Sub [Stop]()

           If (Me.Handle <> IntPtr.Zero) Then
               Me.isRunningB = False
               MyBase.DestroyHandle()

           Else
               Throw New Exception(message:="Monitor is already stopped.")

           End If

       End Sub

#End Region

#Region " Private Methods "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets the drive letter stored in a <see cref="DevBroadcastVolume"/> structure.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="device">
       ''' The <see cref="DevBroadcastVolume"/> structure containing the device mask.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <returns>
       ''' The drive letter.
       ''' </returns>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Protected Overridable Function GetDriveLetter(ByVal device As DevBroadcastVolume) As Char

           Dim driveLetters As Char() = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray

           Dim deviceID As New BitArray(BitConverter.GetBytes(device.Mask))

           For i As Integer = 0 To deviceID.Length

               If deviceID(i) Then
                   Return driveLetters(i)
               End If

           Next i

           Return Nothing

       End Function

#End Region

#Region " Window Procedure (WndProc) "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Invokes the default window procedure associated with this window to process windows messages.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="m">
       ''' A <see cref="Message"/> that is associated with the current Windows message.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Protected Overrides Sub WndProc(ByRef m As Message)

           Select Case m.Msg

               Case DeviceEvents.Change ' The hardware has changed.

                   If (m.LParam = IntPtr.Zero) Then
                       Exit Select
                   End If

                   ' If it's an storage device then...
                   If Marshal.ReadInt32(m.LParam, 4) = DeviceType.Logical Then

                       ' Transform the LParam pointer into the data structure.
                       Dim currentWDrive As DevBroadcastVolume =
                           DirectCast(Marshal.PtrToStructure(m.LParam, GetType(DevBroadcastVolume)), DevBroadcastVolume)

                       Dim driveLetter As Char = Me.GetDriveLetter(currentWDrive)
                       Dim deviceEvent As DeviceEvents = DirectCast(m.WParam.ToInt32, DeviceEvents)
                       Dim driveInfo As New DriveInfo(driveLetter)

                       Me.OnDriveStatusChanged(New DriveStatusChangedEventArgs(deviceEvent, driveInfo))

                   End If

           End Select

           ' Return Message to base message handler.
           MyBase.WndProc(m)

       End Sub

#End Region

#Region " IDisposable Implementation "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Flag to detect redundant calls when disposing.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Private isDisposed As Boolean

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Releases all the resources used by this instance.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Public Sub Dispose() Implements IDisposable.Dispose

           Me.Dispose(isDisposing:=True)
           GC.SuppressFinalize(obj:=Me)

       End Sub

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
       ''' Releases unmanaged and, optionally, managed resources.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="isDisposing">
       ''' <see langword="True"/>  to release both managed and unmanaged resources;
       ''' <see langword="False"/> to release only unmanaged resources.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Protected Overridable Sub Dispose(ByVal isDisposing As Boolean)

           If (Not Me.isDisposed) AndAlso (isDisposing) Then
               Me.events.Dispose()
               If Me.isRunningB Then
                   Me.Stop()
               End If
           End If

           Me.isDisposed = True

       End Sub

#End Region

   End Class

End Namespace

#End Region


DriveStatusChangedEventArgs.vb

Código (vbnet) [Seleccionar] Expandir

' ***********************************************************************
' Author   : Elektro
' Modified : 10-November-2015
' ***********************************************************************

#Region " Public Members Summary "

#Region " Constructors "

' New(DeviceEvents, DriveInfo)

#End Region

#Region " Properties "

' DeviceEvent As DriveWatcher.DeviceEvents
' DriveInfo As DriveInfo

#End Region

#End Region

#Region " Option Statements "

Option Strict On
Option Explicit On
Option Infer Off

#End Region

#Region " Imports "

Imports WindowsApplication1.Win32.Enums

' Imports Elektro.Core.Types
' Imports Elektro.Interop.Win32.Enums

#End Region

#Region " DriveStatusChanged EventArgs "

Namespace IO.Types.EventArgs

   ''' ----------------------------------------------------------------------------------------------------
   ''' <summary>
   ''' Contains the event-data of a <see cref="DriveWatcher.DriveStatusChanged"/> event.
   ''' </summary>
   ''' ----------------------------------------------------------------------------------------------------
   Public NotInheritable Class DriveStatusChangedEventArgs : Inherits System.EventArgs ' : Inherits AestheticEventArgs

#Region " Properties "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets the device event that occurred.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <value>
       ''' The drive info.
       ''' </value>
       ''' ----------------------------------------------------------------------------------------------------
       Public ReadOnly Property DeviceEvent As DeviceEvents
           <DebuggerStepThrough>
           Get
               Return Me.deviceEventsB
           End Get
       End Property
       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' ( Backing field )
       ''' The device event that occurred.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Private ReadOnly deviceEventsB As DeviceEvents

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets the drive info.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <value>
       ''' The drive info.
       ''' </value>
       ''' ----------------------------------------------------------------------------------------------------
       Public ReadOnly Property DriveInfo As DriveInfo
           <DebuggerStepThrough>
           Get
               Return Me.driveInfoB
           End Get
       End Property
       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' ( Backing field )
       ''' The drive info.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Private ReadOnly driveInfoB As DriveInfo

#End Region

#Region " Constructors "

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

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Initializes a new instance of the <see cref="DriveStatusChangedEventArgs"/> class.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="driveInfo">
       ''' The drive info.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Public Sub New(ByVal deviceEvent As DeviceEvents, ByVal driveInfo As DriveInfo)

           Me.deviceEventsB = deviceEvent
           Me.driveInfoB = driveInfo

       End Sub

#End Region

   End Class

End Namespace

#End Region


DeviceEvents.vb

Código (vbnet) [Seleccionar] Expandir

' ***********************************************************************
' Author   : Elektro
' Modified : 10-November-2015
' ***********************************************************************

#Region " Option Statements "

Option Strict On
Option Explicit On
Option Infer Off

#End Region

#Region " Device Events "

Namespace Win32.Enums

   ''' ----------------------------------------------------------------------------------------------------
   ''' <summary>
   ''' Specifies a change to the hardware configuration of a device.
   ''' </summary>
   ''' ----------------------------------------------------------------------------------------------------
   ''' <remarks>
   ''' <see href="http://msdn.microsoft.com/en-us/library/windows/desktop/aa363480%28v=vs.85%29.aspx"/>
   ''' <para></para>
   ''' <see href="http://msdn.microsoft.com/en-us/library/windows/desktop/aa363232%28v=vs.85%29.aspx"/>
   ''' </remarks>
   ''' ----------------------------------------------------------------------------------------------------
   Public Enum DeviceEvents As Integer

       ' *****************************************************************************
       '                            WARNING!, NEED TO KNOW...
       '
       '  THIS ENUMERATION IS PARTIALLY DEFINED TO MEET THE PURPOSES OF THIS API
       ' *****************************************************************************

       ''' <summary>
       ''' The current configuration has changed, due to a dock or undock.
       ''' </summary>
       Change = &H219

       ''' <summary>
       ''' A device or piece of media has been inserted and becomes available.
       ''' </summary>
       Arrival = &H8000

       ''' <summary>
       ''' Request permission to remove a device or piece of media.
       ''' <para></para>
       ''' This message is the last chance for applications and drivers to prepare for this removal.
       ''' However, any application can deny this request and cancel the operation.
       ''' </summary>
       QueryRemove = &H8001

       ''' <summary>
       ''' A request to remove a device or piece of media has been canceled.
       ''' </summary>
       QueryRemoveFailed = &H8002

       ''' <summary>
       ''' A device or piece of media is being removed and is no longer available for use.
       ''' </summary>
       RemovePending = &H8003

       ''' <summary>
       ''' A device or piece of media has been removed.
       ''' </summary>
       RemoveComplete = &H8004

   End Enum

End Namespace

#End Region


DevBroadcastVolume.vb

Código (vbnet) [Seleccionar] Expandir

' ***********************************************************************
' Author   : Elektro
' Modified : 10-November-2015
' ***********************************************************************

#Region " Option Statements "

Option Strict On
Option Explicit On
Option Infer Off

#End Region

#Region " Imports "

Imports System.Runtime.InteropServices

#End Region

#Region " DevBroadcast Volume "

Namespace Win32.Types

   ''' ----------------------------------------------------------------------------------------------------
   ''' <summary>
   ''' Contains information about a logical volume.
   ''' </summary>
   ''' ----------------------------------------------------------------------------------------------------
   ''' <remarks>
   ''' <see href="http://msdn.microsoft.com/en-us/library/windows/desktop/aa363249%28v=vs.85%29.aspx"/>
   ''' </remarks>
   ''' ----------------------------------------------------------------------------------------------------
   <DebuggerStepThrough>
   <StructLayout(LayoutKind.Sequential)>
   Public Structure DevBroadcastVolume

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' The size of this structure, in bytes.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Public Size As UInteger

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Set to DBT_DEVTYP_VOLUME (2).
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Public Type As UInteger

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Reserved parameter; do not use this.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Public Reserved As UInteger

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' The logical unit mask identifying one or more logical units.
       ''' Each bit in the mask corresponds to one logical drive.
       ''' Bit 0 represents drive A, bit 1 represents drive B, and so on.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Public Mask As UInteger

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' This parameter can be one of the following values:
       ''' '0x0001': Change affects media in drive. If not set, change affects physical device or drive.
       ''' '0x0002': Indicated logical volume is a network volume.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Public Flags As UShort

   End Structure

End Namespace

#End Region




Por último, esto de aquí abajo seria uno de los posibles algoritmos que se podría elaborar para el copiado de archivos. Para llevarlo a cabo simplemente he reciclado y adaptado el código que ya te enseñé en este otro post:

• http://foro.elhacker.net/net/ayuda_con_un_contador-t464137.0.html;msg2106079#msg2106079

...por eso lo he dejado tan "en bruto" y con lineas comentadas, para denotar las diferencias entre uno y otro código.

Código (vbnet) [Seleccionar] Expandir

Imports System
Imports WindowsApplication1.IO.Types
Imports WindowsApplication1.IO.Types.EventArgs

Public NotInheritable Class Form1 : Inherits Form

   Friend WithEvents DriveMon As New DriveWatcher()
   Private ReadOnly outDir As String = "C:\Monitor\"

   ''' ----------------------------------------------------------------------------------------------------
   ''' <summary>
   ''' Handles the <see cref="DriveWatcher.DriveStatusChanged"/> event of the <see cref="DriveMon"/> instance.
   ''' </summary>
   ''' ----------------------------------------------------------------------------------------------------
   ''' <param name="sender">
   ''' The source of the event.
   ''' </param>
   '''
   ''' <param name="e">
   ''' The <see cref="DriveStatusChangedEventArgs"/> instance containing the event data.
   ''' </param>
   ''' ----------------------------------------------------------------------------------------------------
   Private Sub DriveMon_DriveStatusChanged(ByVal sender As Object, ByVal e As DriveStatusChangedEventArgs) Handles DriveMon.DriveStatusChanged

       Select Case e.DeviceEvent

           Case Win32.Enums.DeviceEvents.Arrival
               Dim sb As New StringBuilder
               With sb
                   .AppendLine("New drive connected...'")
                   .AppendLine(String.Format("Name: {0}", e.DriveInfo.Name))
                   .AppendLine(String.Format("Root.: {0}", e.DriveInfo.RootDirectory))
                   .AppendLine(String.Format("Label: {0}", e.DriveInfo.VolumeLabel))
                   .AppendLine(String.Format("Size.: {0} GB", (e.DriveInfo.TotalSize / (1024 ^ 3)).ToString("n1")))
               End With
               Console.WriteLine(sb.ToString())
               Console.WriteLine("Initializing copy...")

               Dim copyTask As Task(Of Integer) = Me.CopyFiles(e.DriveInfo.VolumeLabel, e.DriveInfo.RootDirectory.FullName, outDir)
               ' Await Task.WhenAll(copyTask)

           Case Win32.Enums.DeviceEvents.RemoveComplete
               Dim sb As New StringBuilder
               With sb
                   .AppendLine("Drive disconnected...'")
                   .AppendLine(String.Format("Name: {0}", e.DriveInfo.Name))
                   sb.AppendLine(String.Format("Root: {0}", e.DriveInfo.RootDirectory))
               End With
               Console.WriteLine(sb.ToString())

       End Select

   End Sub

   Private Sub StartMon_Click(ByVal sender As Object, ByVal e As EventArgs) Handles Button_StartMon.Click
       Me.DriveMon.Start()
   End Sub

   Private Sub StopMon_Click(ByVal sender As Object, ByVal e As EventArgs) Handles Button_StopMon.Click
       Me.DriveMon.Stop()
   End Sub

   Public Async Function CopyFiles(ByVal labelName As String, ByVal srcDirPath As String, ByVal dstDirPath As String) As Task(Of Integer)

       Dim filesDict As New Dictionary(Of FileInfo, FileInfo) ' {[Key: Source File], [Value: Destination File]}

       For Each file As FileInfo In New DirectoryInfo(srcDirPath).EnumerateFiles("*", SearchOption.AllDirectories)
           Dim srcRoot As String = file.Directory.Root.FullName
           Dim dstFilepath As String = file.FullName.Replace(srcRoot, Path.Combine(Me.outDir, labelName) & "\")
           filesDict.Add(file, New FileInfo(dstFilepath))
       Next file

       ' Dim maxFileCount As Integer = filesDict.Count()
       ' Dim curFileCount As Integer

       ' Dim updateLabelCallback As New SendOrPostCallback(
       '     Sub(ByVal state As Object)
       '         progressCtrl.Text = String.Format("{0} of {1} files copied...", CInt(state), maxFileCount)
       '     End Sub)

       Dim copySingleFileAction As New Action(Of KeyValuePair(Of FileInfo, FileInfo))(
           Sub(ByVal pair As KeyValuePair(Of FileInfo, FileInfo))
               Try
                   If Not (pair.Value.Directory.Exists) Then
                       pair.Value.Directory.Create()
                   End If
                   pair.Key.CopyTo(pair.Value.FullName, overwrite:=False)
                   ' SynchronizationContext.Current.Post(updateLabelCallback, Interlocked.Increment(curFileCount))
               Catch ex As Exception
               End Try
           End Sub)

       Dim copyAllFilesFunc As Func(Of Integer) =
           Function() As Integer
               ' Parallel.ForEach(Of KeyValuePair(Of FileInfo, FileInfo))(filesDict, copySingleFileAction)
               ' -- Sin paralelismo en este caso es más eficiente.
               For Each pair As KeyValuePair(Of FileInfo, FileInfo) In filesDict
                   copySingleFileAction(pair)
               Next
               ' Return curFileCount ' Return the amount of files that were copied.
           End Function

       If Not New DirectoryInfo(dstDirPath).Exists Then
           Directory.CreateDirectory(dstDirPath, Nothing)
       End If

       Dim t As New Task(Of Integer)(copyAllFilesFunc, TaskCreationOptions.LongRunning)
       t.Start()
       Await t

       Return t.Result
   End Function

End Class

De esa manera, se ejecutará de forma automática y asíncrona una tarea que iniciará el copiado de archivos por cada dispositivo extraible de almacenamiento que insertes en el PC en cuestión. Los archivos se copiarán del USB a la carpeta destino especificada, conservando la estructura de directorios de la ruta del archivo de origen a copiar. Si extraes un USB durante una operación de copiado, simplemente se disparará una excepción controlada que ignorará el copiado, y podrás reinsertar el mismo USB para seguir la copia, o insertar un nuevo USB. Puedes ocupar varias ranuras de USB de forma simultanea para copair varios dispositivos al mismo tiempo. Y creo que no me dejo nada destacable por mencionar sobre la funcionalidad del código.

Cabe mencionar que el código no está optimizado, tan solo es un ejemplo básico pero funcional para lograr lo que quieres, pues no voy a ponerme a hacerte yo todo el trabajo y escribir aquí la de Dios. Te recomiendo añadir controles de errores al menos para evaluar los permisos de usuario de la carpeta destino, además también podrías habilitar la capacidad de poder cancelar al instante una operación de copiado que esté en curso al momento de extraer un dispositivo USB, esto lo harias mediante el la creación y el uso de un token de cancelación el cual lo pasarías como argumento a una de las sobrecargas del método Task.Start(), y evaluarias una petición de cancelación en el bloque del método CopyFiles del código que te mostré. Otra cosa que se puede mejorar es el orden de iteración/copiado de archivos, podrías ordenar la colección para que se procesen los archivos de menor tamaño a mayor, dependiendo de tus necesidades.
En fin, puedes improvisar ese código de ejemplo de mil maneras distintas para perfeccionarlo.

¡Saludos!

[Mars One]

Ehm, mira, puedes decir lo que quieras, estás en todo tu derecho; pero creo que es importante (o al menos, mi responsabilidad) separar la doxa de lo fáctico. Me refiero puntualmente a que la NASA jamás hizo tal concurso.

Fue una empresa privada llamada Mars One

Y has hecho bien al aclararlo. Me doy cuenta del error que he cometido, gracias. Pues recuerdo que cuando se publicó la noticia del concurso, en los artículos de Internet donde lo leí, lo vendieron como si fuese algo de NASA (que NASA estaba detrás de ello, no una empresa privada) y en la misma web de Mars One (recuerdo que la dirección de la web tenía el nombre "mars-one") donde te inscribias al concurso, salia el logo de NASA por ahí, así que asumí que lo de "Mars One" era el nombre de un proyecto de NASA y no de empresa privada que supuestamente no tiene nada que ver con NASA, por que además se realizó en la época del hype de NASA en Marte (qué inteligentes son estos estafadores que aprovechan el mejor momento). Al parecer me comí el fraude con ración de patatas fritas incluidas.

Lo siento por la equivocación. De todas formas, siempre cabe la posibilidad de que esa empresa privada pudiese tener cierta relación con NASA... para que se hayan repartido a medias un trozo del pastel... quien sabe...

¡Saludos!

No entiendo tanta queja, la verdad.

El problema debería estar cuando quitan funcionalidades, no cuando las ponen.

Eso de "cuanto más, mejor" solo sirve con el sexo y con el dinero.

La sobreexplotación de funcionalidades puede ser igual de perjudicial que la escasez de las mismas, por varios motivos como por ejemplo su inutilidad, o un impacto negativo en el rendimiento del consumidor, pero sobre todo cuando se deciden implementar características con la intención de imitar a otro producto de la competencia ("inspiración" lo llaman algunos) para ofrecer las mismas funcionalidades (véase por ejemplo lo que hace Firefox desde hace unos años implementando características y cambios estéticos sin cesar para parecerse cada vez más a Chrome), y aquí es donde pueden comenzar las quejas con fundamento, por que precisamente si estamos usando un producto distinto al de la competencia es por que este producto nos convence más que lo que nos ofrece el producto de la competencia, pero si lo empiezan a copiar para que se parezca al producto de la competencia entonces acabaremos teniendo la misma mierd@ que desde un principio nunca quisimos tener.

¡Saludos!