El tema ha sido movido a .NET.

http://foro.elhacker.net/index.php?topic=445958.0

Un año más vengo a hacerles esta pequeña, pequeñisima contribuición en forma de regalo navideño simplemente por ser miembros de este magnifico foro...

Vengo a regalar un cupón para acceder gratuitamente al servicio uploaded.net Premium durante 48 horas.

Para no generar ningún tipo de favoritismo u ofensa o cualquier otro conflicto similar por mi parte, se lo regalaré al primero que responda en este hilo incluyendo en su mensaje esta frase: "YO LO QUIERO".
( si lo pide con otras palabras entonces ignoraré la petición. )

Requisitos:
- Tener al menos un año de antiguedad en el foro.
- Tener más de 100 mensajes publicados (los mensajes del foro libre no cuentan).
- No pertenecer al Staff de elhacker.net (lo siento chicos, es un regalo para los usuarios )

Saludos!

.Net nos ofrece varias alternativas para guardar la configuración de usuario, cómo la serialización de datos, la infrastructura My.Settings, o recurrir al registro de windows, sin embargo, y al menos para mi, un archivo de inicialización (archivo.INI) sigue siendo la mejor forma para portabilizar la configuración de un software, ya que el formato es muy amistoso de cara al end-user (¿quien no sabe editar un INI?), es perfecto para desarrollar software portable y mantener la misma configuración de usuario al copiarlo de un PC a otro, así que he ideado este algoritmo en conjunción para la manipulación de archivos INI usando código administrado (un parser de cosecha propia, sin recurrir a código no administrado con las funciones de la API de Windows que leen archivos INI).

El resultado de todo esto es bastante código, un Type para representar una sección INI, otro Type para representar una llave de una sección INI, etc, pero solo es necesario copiar y pegar todo el código que he desarrollado, ya que su utilización es tan simple como lo que voy a mostrar a continuación...

Ejemplo de uso para crear un INI con una sección y un valor booleano:

Dim ini As New IniManager("C:\File.ini", Encoding.Default)
 
With ini
 
    .Clear()
 
    .Sections.Add("SectionName")
    .Sections("SectionName").Keys.Add("KeyName", value:="", comment:="Commentary")
    .Sections("SectionName").Keys("KeyName").Value = "True"
 
    .Save()
 
End With
 
Console.WriteLine(ini.ToString)

Para obtener el valor, lo hariamos así:

Dim setting As Boolean = CBool(ini.Sections("SectionName").Keys("KeyName").Value)

Tiene métodos de búsqueda de secciones y llaves, y demás.

---

IniSection, representa una sección INI:
http://pastebin.com/8mJUZ2Nb

IniKey, representa una llave INI:
http://pastebin.com/eE1ZSnFG

IniSectionCollection, representa una colección de secciones INI:
http://pastebin.com/jcFJ0yYd

IniKeyCollection, representa una colección de llaves INI:
http://pastebin.com/CLfBtB1h

IniManager, lo más importante, la class que administra de manera abstracta los Types mencionados para la manipulación de un archivo INI:
http://pastebin.com/xgy93Saq

Espero que a alguien más le sirva.

Saludos!

El tema ha sido movido a Programación General.

http://foro.elhacker.net/index.php?topic=445689.0

Buenas

Os dejo este sencillo y pequeño algoritmo para generar captchas para nuestras aplicaciones.

Se puede extender para añadir "ruido" en la imagen, o alterar la posición y la rotación de las letras, pero eso no lo he implementado ya que me parece algo excesivo para "autentificar" una simple aplicación de escritorio.

       
 
Modo de empleo:

Dim captcha As KeyValuePair(Of Bitmap, String) = GenerateCaptcha(length:=5, size:=PictureBox1.Size)
 
PictureBox1.BackgroundImage = captcha.Key
Console.WriteLine(captcha.Value)

Código fuente:

    Dim rand As New Random
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' Generates a captcha image.
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <example> This is a code example.
    ''' <code>
    ''' Dim captcha As KeyValuePair(Of Bitmap, String) = GenerateCaptcha(5, PictureBox1.ClientSize)
    ''' PictureBox1.BackgroundImage = captcha.Key
    ''' </code>
    ''' </example>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <param name="length">
    ''' The character length.
    ''' </param>
    ''' 
    ''' <param name="size">
    ''' The image size.
    ''' </param>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <returns>
    ''' A <see cref="KeyValuePair(Of Bitmap, String)"/> that contains the captcha image and the resulting string.
    ''' </returns>
    ''' ----------------------------------------------------------------------------------------------------
    <DebuggerStepThrough>
    Public Shared Function GenerateCaptcha(ByVal length As Integer,
                                           ByVal size As Size) As KeyValuePair(Of Bitmap, String)
 
        Return GenerateCaptcha(length, size.Width, size.Height)
 
    End Function
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' Generates a captcha image.
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <example> This is a code example.
    ''' <code>
    ''' Dim captcha As KeyValuePair(Of Bitmap, String) = GenerateCaptcha(5, PictureBox1.Width, PictureBox1.Height)
    ''' PictureBox1.BackgroundImage = captcha.Key
    ''' </code>
    ''' </example>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <param name="length">
    ''' The character length.
    ''' </param>
    ''' 
    ''' <param name="width">
    ''' The image width.
    ''' </param>
    ''' 
    ''' <param name="height">
    ''' The image height.
    ''' </param>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <returns>
    ''' A <see cref="KeyValuePair(Of Bitmap, String)"/> that contains the captcha image and the resulting string.
    ''' </returns>
    ''' ----------------------------------------------------------------------------------------------------
    <DebuggerStepThrough>
    Public Shared Function GenerateCaptcha(ByVal length As Integer,
                                           ByVal width As Integer,
                                           ByVal height As Integer) As KeyValuePair(Of Bitmap, String)
 
        Dim captcha As New Bitmap(width, height)
        Dim fontHeight As Integer = (height \ 2)
        Dim vLineSpacing As Integer = 2
        Dim hLineSpacing As Integer = 2
        Dim str As String = String.Join("", (From c As Char In "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                                     Order By rand.Next Select c).Take(length))
 
        Using g As Graphics = Graphics.FromImage(captcha)
 
            g.InterpolationMode = InterpolationMode.High
            g.SmoothingMode = SmoothingMode.HighQuality
            g.TextRenderingHint = TextRenderingHint.AntiAliasGridFit
            g.CompositingQuality = CompositingQuality.HighQuality
 
            Using gradientBrush As New LinearGradientBrush(New Point(0, (height \ 2)),
                                                           New Point(width, (height \ 2)),
                                                           Color.FromArgb(rand.Next(&HFF7D7D7D, &HFFFFFFFF)),
                                                           Color.FromArgb(rand.Next(&HFF7D7D7D, &HFFFFFFFF)))
 
                ' Draw gradient background.
                g.FillRectangle(gradientBrush, New Rectangle(0, 0, width, height))
 
            End Using ' gradientBrush
 
            Using linesPen As New Pen(Brushes.Black, 1)
 
                ' Draw vertical lines.
                For i As Integer = 1 To width
                    Dim ptop As New Point(i * vLineSpacing, 0)
                    Dim pBottom As New Point(i * vLineSpacing, height)
                    g.DrawLine(linesPen, ptop, pBottom)
                Next i
 
                ' Draw horizontal lines.
                For i As Integer = 1 To height
                    Dim ptop As New Point(0, i * hLineSpacing)
                    Dim pBottom As New Point(width, i * hLineSpacing)
                    g.DrawLine(linesPen, ptop, pBottom)
                Next i
 
            End Using ' linesPen
 
            Using font As New Font("Arial", fontHeight)
 
                Using path As New GraphicsPath
 
                    For i As Integer = 0 To (str.Length - 1)
 
                        Dim charX As Integer =
                            (((i * (width - (g.MeasureString(str(i), font, width).ToSize.Width \ length)))) \ length)
 
                        Dim charY As Integer = (height \ 2)
 
                        path.AddString(str(i), font.FontFamily, FontStyle.Bold, fontHeight,
                                       New Point(charX, charY), New StringFormat With {.LineAlignment = StringAlignment.Center})
 
                    Next i
 
                    ' Draw characters.
                    g.DrawPath(Pens.Black, path)
                    g.FillPath(Brushes.Gainsboro, path)
 
                End Using
 
            End Using ' font
 
        End Using ' g
 
        Return New KeyValuePair(Of Bitmap, String)(captcha, str)
 
    End Function

Saludos

Hola

Publico el tema aquí, por que creo que me podrá servir de más ayuda.

Estoy tratando de implementar la estructura DEVMODE en C#:
https://msdn.microsoft.com/en-us/library/windows/desktop/dd183565%28v=vs.85%29.aspx
( y no me sirven las implementaciones de pinvoke.net u otros ejemplos online, ya que todas las que he visto hasta ahora son erroneas o desactualizadas en algún sentido )



He estado comparando los offsets en C++ y C#, en C++ con la macro offsetof y en C# con la función Marshal.OffsetOf, hasta llegar al miembro dmFields todo es correcto;
el problema que tengo, es que el offset del miembro dmColor es 60 en C++, mientras que en mi implementación es 68, esto quiere decir que mi implementación de los miembros de la primera union es incorrecta.

Según un experto en código no administrado, mi representación de las unions y el enfoque que le stoy dando es correcto, pero no debe ser del todo así, ya que las posiciones/offsets son distintas.

    [StructLayout(LayoutKind.Sequential)]
    public struct DevMode {
    	private const int CchDeviceName = 32;
    	private const int CchFormName = 32;
 
    	[MarshalAs(UnmanagedType.ByValTStr, SizeConst = CchDeviceName)]
    	public string DeviceName;
    	public short SpecVersion;
    	public short DriverVersion;
    	public short Size;
    	public short DriverExtra;
    	public DeviceModeFields Fields;
    	public UnionDevMode1 test1;
    	public short Color;
    	public short Duplex;
    	public short YResolution;
    	public short TTOption;
    	public short Collate;
    	[MarshalAs(UnmanagedType.ByValTStr, SizeConst = CchFormName)]
    	public string FormName;
    	public short LogPixels;
    	public int BitsPerPixel;
    	public int PixelsWidth;
    	public int PixelsHeight;
    	public UnionDevMode2 test2;
    	public int DisplayFrequency;
    	public int IcmMethod;
    	public int IcmIntent;
    	public int MediaType;
    	public int DitherType;
    	public int Reserved1;
    	public int Reserved2;
    	public int PanningWidth;
    	public int PanningHeight;
    }
 
    [StructLayout(LayoutKind.Explicit)]
    public struct UnionDevMode1 {
    	[FieldOffset(0)] public SubUnionDevMode1 subUnion1;
    	[FieldOffset(0)] public SubUnionDevMode2 subUnion2;
    }
 
    [StructLayout(LayoutKind.Sequential)]
    public struct SubUnionDevMode1 {
    	public short Orientation;
    	public short PaperSize;
    	public short PaperLength;
    	public short PaperWidth;
    	public short Scale;
    	public short Copies;
    	public short DefaultSource;
    	public short PrintQuality;
    }
 
    [StructLayout(LayoutKind.Sequential)]
    public struct SubUnionDevMode2 {
    	public Win32.Types.Point Position;
    	public DeviceModeDisplayOrientation DisplayOrientation;
    	public int DisplayFixedOutput;
    }
 
    [StructLayout(LayoutKind.Explicit)]
    public struct UnionDevMode2 {
 
    	[FieldOffset(0)] public int DisplayFlags;
    	[FieldOffset(0)] public int Nup;
 
    }

El problema está en el miembro UnionDevMode1 , o al menos todo me indica eso, mejor dicho en alguno de los miembros de la estructura  SubUnionDevMode1 o  SubUnionDevMode2 , sin embargo, me he asegurado de que los types ocupan el mismo tamaño que en C++, vease:

POINTL = 8 bytes.
Win32.Types.Point = 8 bytes.

DeviceModeFields = int (4 bytes)
DeviceModeDisplayOrientation = int (4 bytes)

Teniendo esto en cuenta, ¿alguien es capaz de ver en lo que estoy fallando?.

Hola

Me gustaría saber si alguien con experiencia en C++ podría indicarme los offests de los miembros de la estructura DEVMODE:
https://msdn.microsoft.com/en-us/library/windows/desktop/dd183565%28v=vs.85%29.aspx

Esto es por que estoy tratanto de trasladar las unions de dicha estructura a .Net, pero necesito saber los offsets de los miembros en C++ para comparar el resto de miembros, ya que algo hice mal, probablemente el tamaño de alguno de mis miembros declarados sea incorrecto en comparación con el tamaño definido en la estructura de C++.

Me han comentado que esto se hace con la macro offsetof:

Creo que no pido mucho, debe ser una cosa sencilla para quien maneje C++, pero si me equivoco disculpen y diganme más o menos como podría hacerlo yo mismo...

Saludos

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

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

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

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

Saludos

Buenas.

Siempre me he preguntado lo siguiente y espero poder resolver mi duda en este foro, por que nadie sabe nada respecto a esto...

Ahí va:



Si yo quisiera buscar temas parecidos a los temas de los videos de aquí abajo, ¿por qué estilo de música en concreto debería buscar?.

Ya todos lo sabrán pero para los que no lo sepan esta música se conoce comunmente como "música épica", pero eso no es un estilo ...no es nada de nada, es como quien dice que le gusta el "EDM" (música electrónica), que bien puede ser un tema hard-electro o una canción tecno-pop en Catalán, todo en el mismo saco y nada que ver, vaya. Por ese mismo motivo si me pongo a buscar por "música orquestral" o "sinfonias...¿?" o incluo "música épica" se que me va a salir todo tipo de música que la mayoría no se van a parecer en nada a estos temas de los videos, aparte, es que simplemente quiero saber el nombre de lo que estoy escuchando.

¿Alguien tiene mejor idea de que estilo de música es exactamente esto?. Y añado otra pregunta a ser posible que lo sepan, ¿conocen alguna página donde descargar solamente álbums de este estilo de música? (álbums comerciales o simplemente packs de temas sueltos de "música épica", vaya)

   

   

Otro ejemplo de lo que busco exactamente:
http://audiojungle.net/item/epic-music-pack-3/9768334

Típicas bandas sonoras en general, de películas y videojuegos "épicos"... jeje.

Saludos

He estado refactorizando un viejo snippet, el cual es de mis favoritos, por ese motivo lo posteo aquí para hacer una mención especial y no en el apartado de snippets.

Lo que voy a mostrar es la forma más sencilla (copy&paste) para añadir magnetismo a una ventana.

Personalmente considero que todos deberiamos implementar esta funcionalidad en nuestras aplicaciones, ya que es una funcionalidad muy útil para mantener la organizción de las ventanas en la pantalla, cosa que cualquier usuario-final de su aplicación lo sabrá agradecer.

El magnetismo de ventanas consiste en que, al mover la ventana/Form cerca de un borde de la pantalla, la ventana se adhiera a dicho borde.



Nota: Esta funcionalidad estará incluida en la próxima versión de mi API ElektroKit: http://foro.elhacker.net/net/elektrokit_v10_api_de_proposito_general_para_desarrolladores_de_net-t444997.0.html

---

El siguiente código está escrito en Vb.Net (es suficiente con copiar, pegar y usar) pero se puede compilar en una dll para desarrolladores de código-C#.

La Class tiene dos propiedades importantes de personalización, la primera propiedad es WindowMagnetizer.Threshold, que indica el margen, en píxeles, en el que se debe producir el magnetismo. Yo suelo utilizar un valor de 35 píxeles ya que soy muy basto moviendo el ratón, pero creo que un valor de 20 seria lo apropiado de forma generalizada.

La otra propiedad se llama WindowMagnetizer.AllowOffscreen, que como su propio nombre indica por si mismo, sirve para habilitar o deshabilitar el poder mover la ventana fuera de los límites de la pantalla activa. (he tenido en cuenta la existencia de una pantalla dual).

El uso de esta class es muy, muy sencillo, tanto como esto:

Private magnetizer As New WindowMagnetizer(Me) With
    {
        .Enabled = True,
        .AllowOffscreen = True,
        .Threshold = 30
    }

private WindowMagnetizer magnetizer;
 
private void Form1_Load(object sender, EventArgs e) {
 
   magnetizer = new WindowMagnetizer(this)
                    {
                        Enabled = true,
                        AllowOffscreen = true,
                        Threshold = 30
                    };  
}

Sin más, el código fuente:

' ***********************************************************************
' Author   : Elektro
' Modified : 01-December-2015
' ***********************************************************************
 
#Region " Public Members Summary "
 
#Region " Constructors "
 
' WindowMagnetizer.New(IWin32Window)
 
#End Region
 
#Region " Properties "
 
' WindowMagnetizer.Handle As IntPtr
' WindowMagnetizer.OwnerWindow As IWin32Window
' WindowMagnetizer.Threshold As Integer
' WindowMagnetizer.Enabled As Boolean
' WindowMagnetizer.AllowOffscreen As Boolean
 
#End Region
 
#Region " Methods "
 
' WindowMagnetizer.Dispose()
 
#End Region
 
#End Region
 
#Region " Usage Examples "
 
'Private magnetizer As New WindowMagnetizer(Me) With
'    {
'        .Enabled = True,
'        .AllowOffscreen = True,
'        .Threshold = 30
'    }
 
#End Region
 
#Region " Option Statements "
 
Option Explicit On
Option Strict On
Option Infer Off
 
#End Region
 
#Region " Imports "
 
Imports System
Imports System.ComponentModel
Imports System.Drawing
Imports System.Linq
Imports System.Runtime.InteropServices
Imports System.Windows.Forms
 
' Imports Elektro.Interop.Win32
' Imports Elektro.Interop.Win32.Enums
' Imports Elektro.Interop.Win32.Types
 
#End Region
 
#Region " Window Magnetizer "
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' Add magnetism to the edges of a window,
    ''' in this way, by bringing the window to a screen edge, the edge of the window adheres it to the edge of the screen.
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <example> This is a code example.
    ''' <code>
    ''' Private magnetizer As New WindowMagnetizer(Me) With
    '''     {
    '''         .Enabled = True,
    '''         .AllowOffscreen = True,
    '''         .Threshold = 30
    '''     }
    ''' </code>
    ''' </example>
    ''' ----------------------------------------------------------------------------------------------------
    Public Class WindowMagnetizer : Inherits NativeWindow : Implements IDisposable
 
#Region " Private Fields "
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Determines whether the owner window is being resized by one of its edges.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        Protected isResizing As Boolean
 
#End Region
 
#Region " Properties "
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Gets the window that owns this <see cref="WindowMagnetizer"/> instance.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <value>
        ''' The window.
        ''' </value>
        ''' ----------------------------------------------------------------------------------------------------
        Public Overridable ReadOnly Property OwnerWindow As IWin32Window
            <DebuggerStepThrough>
            Get
                Return Me.ownerWindowB
            End Get
        End Property
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' ( Backing field )
        ''' The window that owns this <see cref="WindowMagnetizer"/> instance.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        Protected ownerWindowB As IWin32Window
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Gets the handle for the window that owns this <see cref="WindowMagnetizer"/> instance.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <value>
        ''' The handle.
        ''' </value>
        ''' ----------------------------------------------------------------------------------------------------
        Public Overridable Shadows ReadOnly Property Handle As IntPtr
            <DebuggerStepThrough>
            Get
                Return MyBase.Handle
            End Get
        End Property
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Gets or sets, in pixels, the minimum threshold that the magnetic window needs to dock it on the nearest window border.
        ''' <para></para>
        ''' (Default value is <c>20</c>))
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <value>
        ''' The minimum threshold that the magnetic window needs to dock it on the nearest window border.
        ''' </value>
        ''' ----------------------------------------------------------------------------------------------------
        Public Overridable Property Threshold As Integer
            <DebuggerStepThrough>
            Get
                Return Me.thresholdB
            End Get
            <DebuggerStepThrough>
            Set(ByVal value As Integer)
                Me.thresholdB = value
            End Set
        End Property
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' ( Backing field )
        ''' The minimum threshold that the magnetic window needs to dock it on the nearest window border.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        Protected thresholdB As Integer
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Gets or sets a value indicating whether the magnetizer is enabled.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <value>
        ''' <see langword="True"/> if the magnetizer is enabled, otherwise, <see langword="False"/>.
        ''' </value>
        ''' ----------------------------------------------------------------------------------------------------
        Public Overridable Property Enabled As Boolean
            <DebuggerStepThrough>
            Get
                Return Me.enabledB
            End Get
            <DebuggerStepThrough>
            Set(ByVal value As Boolean)
                Me.enabledB = value
            End Set
        End Property
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' ( Backing field )
        ''' A value indicating whether the magnetizer is enabled.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        Protected enabledB As Boolean
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Gets or sets a value indicating whether the window can be moved off-screen.
        ''' <para></para>
        ''' Default value is <see langword="True"/>.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <value>
        ''' <see langword="True"/> if the window can be moved off-screen, otherwise, <see langword="False"/>.
        ''' </value>
        ''' ----------------------------------------------------------------------------------------------------
        Public Overridable Property AllowOffscreen As Boolean
            <DebuggerStepThrough>
            Get
                Return Me.allowOffscreenB
            End Get
            <DebuggerStepThrough>
            Set(ByVal value As Boolean)
                Me.allowOffscreenB = value
            End Set
        End Property
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' ( Backing field )
        ''' A value indicating whether the window can be moved off-screen.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        Protected allowOffscreenB As Boolean
 
#End Region
 
#Region " Constructors "
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Prevents a default instance of the <see cref="WindowMagnetizer"/> class from being created.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        <DebuggerNonUserCode>
        Private Sub New()
        End Sub
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Initializes a new instance of the <see cref="WindowMagnetizer"/> class.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="window">
        ''' The <see cref="IWin32Window"/> window that owns this instance (eg. a <see cref="Form"/> window).
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        <DebuggerStepThrough>
        Public Sub New(ByVal window As IWin32Window)
 
            Me.allowOffscreenB = True
            Me.thresholdB = 20
            Me.ownerWindowB = window
 
            MyBase.AssignHandle(window.Handle)
 
        End Sub
 
#End Region
 
#Region " Private Methods "
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' If the margin between the specified <paramref name="window"/> 
        ''' and the nearest border of the active screeen is lower than the value specified in <paramref name="threshold"/>,
        ''' then it docks the window to the border. 
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="window">
        ''' The magnetic window.
        ''' </param>
        ''' 
        ''' <param name="windowPosHandle">
        ''' A pointer to a <see cref="Interop.Win32.Types.WindowPos"/> structure that contains the 
        ''' new size and position of the <paramref name="window"/>.
        ''' </param>
        ''' 
        ''' <param name="threshold">
        ''' The minimum threshold that the window needs to dock it on the nearest desktop border.
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        Protected Overridable Sub DockToNearestScreenBorder(ByVal window As IWin32Window,
                                                            ByVal windowPosHandle As IntPtr,
                                                            Optional ByVal threshold As Integer = 0I)
 
            Dim workingArea As Rectangle =
                Screen.FromControl(DirectCast(window, Control)).WorkingArea ' Active screen.
 
            workingArea.Width = 0
            workingArea.Height = 0
 
            Screen.AllScreens.ToList.ForEach(
                Sub(scr As Screen)
                    workingArea.Width += scr.WorkingArea.Width
                    workingArea.Height += scr.WorkingArea.Height
                End Sub)
 
            Dim windowPos As WindowPos =
                CType(Marshal.PtrToStructure(windowPosHandle, GetType(WindowPos)), WindowPos)
 
            If (windowPos.Y = 0) OrElse (windowPos.X = 0) Then
                ' Nothing to do.
                Exit Sub
            End If
 
            Dim win32Rect As Rect
            Dim rect As Rectangle
            NativeMethods.GetWindowRect(window.Handle, win32Rect)
            rect = win32Rect
 
            ' Top border
            If ((windowPos.Y >= -threshold) AndAlso
               ((workingArea.Y > 0) AndAlso (windowPos.Y <= (threshold + workingArea.Y)))) _
            OrElse ((workingArea.Y <= 0) AndAlso (windowPos.Y <= threshold)) Then
 
                windowPos.Y = workingArea.Y
 
            End If
 
            ' Left border
            If (windowPos.X >= (workingArea.X - threshold)) AndAlso
               (windowPos.X <= (workingArea.X + threshold)) Then
 
                windowPos.X = workingArea.X
 
            ElseIf (windowPos.X <= (workingArea.X - threshold)) AndAlso
                   Not (Me.allowOffscreenB) Then
 
                windowPos.X = workingArea.X
 
            End If
 
            ' Right border.
            If ((windowPos.X + rect.Width) <= (workingArea.Right + threshold)) AndAlso
               ((windowPos.X + rect.Width) >= (workingArea.Right - threshold)) Then
 
                windowPos.X = (workingArea.Right - rect.Width)
 
            ElseIf ((windowPos.X + rect.Width) >= (workingArea.Right + threshold)) AndAlso
                   Not (Me.allowOffscreenB) Then
 
                windowPos.X = (workingArea.Right - rect.Width)
 
            End If
 
            ' Bottom border.
            If ((windowPos.Y + rect.Height) <= (workingArea.Bottom + threshold)) AndAlso
               ((windowPos.Y + rect.Height) >= (workingArea.Bottom - threshold)) Then
 
                windowPos.Y = (workingArea.Bottom - rect.Height)
 
            ElseIf ((windowPos.Y + rect.Height) >= (workingArea.Bottom + threshold)) AndAlso
                   Not (Me.allowOffscreenB) Then
 
                windowPos.Y = (workingArea.Bottom - rect.Height)
 
            End If
 
            ' Marshal it back.
            Marshal.StructureToPtr(structure:=windowPos, ptr:=windowPosHandle, fDeleteOld:=True)
 
        End Sub
 
#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="T:Message"/> that is associated with the current Windows message.
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        <DebuggerStepThrough>
        Protected Overrides Sub WndProc(ByRef m As Message)
 
            Select Case m.Msg
 
                Case WindowsMessages.WmSizing
                    Me.isResizing = True
 
                Case WindowsMessages.WmExitSizeMove
                    Me.isResizing = False
 
                Case WindowsMessages.WmWindowPosChanging
 
                    If Not (Me.isResizing) AndAlso (Me.enabledB) Then
                        Me.DockToNearestScreenBorder(window:=Me.ownerWindowB,
                                                     windowPosHandle:=m.LParam,
                                                     threshold:=Me.thresholdB)
                    End If
 
            End Select
 
            MyBase.WndProc(m)
 
        End Sub
 
#End Region
 
#Region " Hidden Base Members "
 
        <EditorBrowsable(EditorBrowsableState.Never)>
        <DebuggerNonUserCode>
        Public Shadows Function ReferenceEquals(ByVal objA As Object, ByVal objB As Object) As Boolean
            Return Object.ReferenceEquals(objA, objB)
        End Function
 
        <EditorBrowsable(EditorBrowsableState.Never)>
        <DebuggerNonUserCode>
        Public Shadows Function GetHashCode() As Integer
            Return MyBase.GetHashCode
        End Function
 
        <EditorBrowsable(EditorBrowsableState.Never)>
        <DebuggerNonUserCode>
        Public Shadows Function [GetType]() As Type
            Return MyBase.GetType
        End Function
 
        <EditorBrowsable(EditorBrowsableState.Never)>
        <DebuggerNonUserCode>
        Public Shadows Function Equals(ByVal obj As Object) As Boolean
            Return MyBase.Equals(obj)
        End Function
 
        <EditorBrowsable(EditorBrowsableState.Never)>
        <DebuggerNonUserCode>
        Public Shadows Function ToString() As String
            Return MyBase.ToString
        End Function
 
        <EditorBrowsable(EditorBrowsableState.Never)>
        <DebuggerNonUserCode>
        Public Shadows Sub AssignHandle(ByVal handle As IntPtr)
            MyBase.AssignHandle(handle)
        End Sub
 
        <EditorBrowsable(EditorBrowsableState.Never)>
        <DebuggerNonUserCode>
        Public Shadows Sub CreateHandle(ByVal cp As CreateParams)
            MyBase.CreateHandle(cp)
        End Sub
 
        <EditorBrowsable(EditorBrowsableState.Never)>
        <DebuggerNonUserCode>
        Public Shadows Sub DestroyHandle()
            MyBase.DestroyHandle()
        End Sub
 
        <EditorBrowsable(EditorBrowsableState.Never)>
        <DebuggerNonUserCode>
        Public Shadows Sub ReleaseHandle()
            MyBase.ReleaseHandle()
        End Sub
 
        <EditorBrowsable(EditorBrowsableState.Never)>
        <DebuggerNonUserCode>
        Public Shadows Function FromHandle(ByVal handle As IntPtr) As NativeWindow
            Return NativeWindow.FromHandle(handle)
        End Function
 
        <EditorBrowsable(EditorBrowsableState.Never)>
        <DebuggerNonUserCode>
        Public Shadows Function GetLifeTimeService() As Object
            Return MyBase.GetLifetimeService
        End Function
 
        <EditorBrowsable(EditorBrowsableState.Never)>
        <DebuggerNonUserCode>
        Public Shadows Function InitializeLifeTimeService() As Object
            Return MyBase.InitializeLifetimeService
        End Function
 
        <EditorBrowsable(EditorBrowsableState.Never)>
        <DebuggerNonUserCode>
        Public Shadows Function CreateObjRef(ByVal requestedType As Type) As System.Runtime.Remoting.ObjRef
            Return MyBase.CreateObjRef(requestedType)
        End Function
 
        <EditorBrowsable(EditorBrowsableState.Never)>
        <DebuggerNonUserCode>
        Public Shadows Sub DefWndProc(ByRef m As Message)
            MyBase.DefWndProc(m)
        End Sub
 
#End Region
 
#Region " IDisposable Implementation "
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' To detect redundant calls when disposing.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        Protected 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
 
                With Me
                    .enabledB = False
                    .AllowOffscreen = True
                    .thresholdB = 0
                End With
 
                MyBase.ReleaseHandle()
                MyBase.DestroyHandle()
 
            End If
 
            Me.isDisposed = True
 
        End Sub
 
#End Region
 
    End Class
 
#End Region

P/Invokes:

        <SuppressUnmanagedCodeSecurity>
        <DllImport("user32.dll", SetLastError:=True)>
        Public Shared Function GetWindowRect(ByVal hwnd As IntPtr,
                                             ByRef rect As Rect
        ) As <MarshalAs(UnmanagedType.Bool)> Boolean
        End Function

Public Enum WindowsMessages As Integer
 
        WmSizing = &H214
        WmExitSizeMove = &H232
        WmWindowPosChanging = &H46
 
End Enum

Imports System
Imports System.Diagnostics
Imports System.Linq
Imports System.Runtime.InteropServices
 
#Region " Window Pos "
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' Contains information about the size and position of a window.
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <remarks>
    ''' <see href="http://msdn.microsoft.com/en-us/library/windows/desktop/ms632612%28v=vs.85%29.aspx"/>
    ''' </remarks>
    ''' ----------------------------------------------------------------------------------------------------
    <DebuggerStepThrough>
    <StructLayout(LayoutKind.Sequential)>
    Public Structure WindowPos
 
#Region " Fields "
 
        ''' <summary>
        ''' A handle to the window.
        ''' </summary>
        Public Hwnd As IntPtr
 
        ''' <summary>
        ''' The position of the window in Z order (front-to-back position). 
        ''' This member can be a handle to the window behind which this window is placed, 
        ''' or can be one of the special values listed with the 'SetWindowPos' function. 
        ''' </summary>
        Public HwndInsertAfter As IntPtr
 
        ''' <summary>
        ''' The position of the left edge of the window.
        ''' </summary>
        Public X As Integer
 
        ''' <summary>
        ''' The position of the top edge of the window.
        ''' </summary>
        Public Y As Integer
 
        ''' <summary>
        ''' The window width, in pixels.
        ''' </summary>
        Public Width As Integer
 
        ''' <summary>
        ''' The window height, in pixels.
        ''' </summary>
        Public Height As Integer
 
        ''' <summary>
        ''' Flag containing the window position.
        ''' </summary>
        Public Flags As Integer
 
#End Region
 
    End Structure
 
#End Region

Imports System
Imports System.Diagnostics
Imports System.Drawing
Imports System.Linq
Imports System.Runtime.InteropServices
 
#Region " Rect "
 
    ''' ----------------------------------------------------------------------------------------------------
    ''' <summary>
    ''' Defines the coordinates of the upper-left and lower-right corners of a rectangle.
    ''' </summary>
    ''' ----------------------------------------------------------------------------------------------------
    ''' <remarks>
    ''' <see href="http://msdn.microsoft.com/en-us/library/windows/desktop/dd162897%28v=vs.85%29.aspx"/>
    ''' <para></para>
    ''' <see href="http://www.pinvoke.net/default.aspx/Structures/rect.html"/>
    ''' </remarks>
    ''' ----------------------------------------------------------------------------------------------------
    <DebuggerStepThrough>
    <StructLayout(LayoutKind.Sequential)>
    Public Structure Rect
 
#Region " Properties "
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Gets or sets the x-coordinate of the upper-left corner of the rectangle.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <value>
        ''' The x-coordinate of the upper-left corner of the rectangle.
        ''' </value>
        ''' ----------------------------------------------------------------------------------------------------
        Public Property Left As Integer
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Gets or sets the y-coordinate of the upper-left corner of the rectangle.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <value>
        ''' The y-coordinate of the upper-left corner of the rectangle.
        ''' </value>
        ''' ----------------------------------------------------------------------------------------------------
        Public Property Top As Integer
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Gets or sets the x-coordinate of the lower-right corner of the rectangle.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <value>
        ''' The x-coordinate of the lower-right corner of the rectangle.
        ''' </value>
        ''' ----------------------------------------------------------------------------------------------------
        Public Property Right As Integer
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Gets or sets the y-coordinate of the lower-right corner of the rectangle.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <value>
        ''' The y-coordinate of the lower-right corner of the rectangle.
        ''' </value>
        ''' ----------------------------------------------------------------------------------------------------
        Public Property Bottom As Integer
 
#End Region
 
#Region " Constructors "
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Initializes a new instance of the <see cref="Rect"/> struct.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="left">
        ''' The x-coordinate of the upper-left corner of the rectangle.
        ''' </param>
        ''' 
        ''' <param name="top">
        ''' The y-coordinate of the upper-left corner of the rectangle.
        ''' </param>
        ''' 
        ''' <param name="right">
        ''' The x-coordinate of the lower-right corner of the rectangle.
        ''' </param>
        ''' 
        ''' <param name="bottom">
        ''' The y-coordinate of the lower-right corner of the rectangle.
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        Public Sub New(ByVal left As Integer,
                       ByVal top As Integer,
                       ByVal right As Integer,
                       ByVal bottom As Integer)
 
            Me.Left = left
            Me.Top = top
            Me.Right = right
            Me.Bottom = bottom
 
        End Sub
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Initializes a new instance of the <see cref="Rect"/> struct.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="rect">
        ''' The <see cref="Rectangle"/>.
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        Public Sub New(ByVal rect As Rectangle)
 
            Me.New(rect.Left, rect.Top, rect.Right, rect.Bottom)
 
        End Sub
 
#End Region
 
#Region " Operator Conversions "
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Performs an implicit conversion from <see cref="Rect"/> to <see cref="Rectangle"/>.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="rect">The <see cref="Rect"/>.
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <returns>
        ''' The resulting <see cref="Rectangle"/>.
        ''' </returns>
        ''' ----------------------------------------------------------------------------------------------------
        Public Shared Widening Operator CType(rect As Rect) As Rectangle
 
            Return New Rectangle(rect.Left, rect.Top, (rect.Right - rect.Left), (rect.Bottom - rect.Top))
 
        End Operator
 
        ''' ----------------------------------------------------------------------------------------------------
        ''' <summary>
        ''' Performs an implicit conversion from <see cref="Rectangle"/> to <see cref="Rect"/>.
        ''' </summary>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <param name="rect">The <see cref="Rectangle"/>.
        ''' </param>
        ''' ----------------------------------------------------------------------------------------------------
        ''' <returns>
        ''' The resulting <see cref="Rect"/>.
        ''' </returns>
        ''' ----------------------------------------------------------------------------------------------------
        Public Shared Widening Operator CType(rect As Rectangle) As Rect
 
            Return New Rect(rect)
 
        End Operator
 
#End Region
 
    End Structure
 
#End Region

Espero que esto les pueda servir de ayuda.

Saludos!