Tranquilo, ya te lo aclaro yo:

NI UNA FECHA NI LA OTRA.

NASA no se va a molestar en enviar a hombrecillos blancos a Marte, igual que no van a construir ninguna nave para vivir en las nubes de Venus, ni van a hacer ninguna de tantas otras estúpidas chorradas que solo cuentan o mejor dicho inventan para lucrarse economicamente, fingiendo planes de futuro que para empezar no tienen ni una base en la que apoyarse ni argumento con el que sostenerse, ridículo es el único adjetivo con el que se puede calificar a todo lo actual que hace y dice la NASA. Pero claro, como es NASA ... solo por llamarse así ya tiene creedibilidad, y quien diga lo contrario es un conspiranoico.
Tal vez lo hagan, tal vez envien a seres humanos a Marte, pero eso será de aquí a los próximos 1.000 años no se sabe cuando, cuando ya no les sea rentable su publicidad psicológica o subliminal sobre el tema, entonces lo harán, cuando ya no exista ilusión por ir, y ya hayan vendido todo lo que se pueda vender en el mercado sobre temática Marte.

Tengo ganas de que pasen 20 años para volver a este post (suponiendo que el foro siga existiendo), y reabrir el tema para decir solamente que...

OS LO DIJE.

Me pongo a la espera, mientras tanto especulen lo que deseen sobre las fechas.

Saludos!

Buenas

Estaba observando el catálogo de HDDs de varias tiendas y me he percatado que actualmente, en España, 1 TeraByte equivale a 40-60€, pudiendo ser más dependiendo de la calidad o prestaciones tecnológicas generales del HDD (que si es un NAT, o un HDD especial para video-vigilancia, o un HDD especial para juegos, o chorradas semajantes como estas dos últimas).

Entonces, creo que si analizamos el único HDD que existe (para el consumidor casero) de 8 TB de Seagate el cual vale 287 €, no está nada mal su relación entre calidad/precio/capacidad
http://www.pccomponentes.com/seagate_archive_hdd_8tb_sata3.html

Por supuesto hoy en día no deja de ser caro 8 TBs como 1 miserable TB, pero bueno, está dentro de ese margen estándar de precio por TB siendo 35€ por cada TB (sin IVA), de hecho, sería 25-40€ más caro comprar dos WD-Green de 4 TBs que este HDD de 8 TB, y eso lo hace más interesante si cabe.

---

Actualmente tengo tengo distribuidos mis discos en la torre, de esta manera:

• HDD de 1 TB para el S.O., las aplicaciones, proyectos informáticos, y las descargas o documentos temporales.
• HDD de 2 TB para el ocio, música, fotografías y documentos importantes, etc.
• HDD de 2 TB para ocio, películas HD.
• HDD de 4 TB para ocio, películas HD.
• HDD de 2 TB (desconectado de la torre) para copias de seguridad de los archivos más importantes.

En total tengo unos 6,5 TB ocupados que distribuyo en los discos de ocio y documentos importantes, lo que me cabría todo-en-uno en la capacidad formateada de un disco de 8TB, es decir, 7,2 TB.

Entonces, mi idea de distribuición es la siguiente:

• SSD de 256 GB para el S.O., las aplicaciones, proyectos informáticos, y las descargas o documentos temporales.
• HDD de 8 TB para el ocio, música, películas HD, fotografías y documentos importantes, etc.
• HDD de 4 TB (desconectado de la torre) para copias de seguridad de los archivos más importantes.

Como ven, lo que he hecho ha sudo sustituir el HDD de 1 TB por un disco SSD, los 3 HDDs de ocio y documentos personales por el disco de 8 TB de Seagate, y por último el disco de 4 TB que ya lo tengo, el cual su nueva funcionalidad sería para almacenar backups.

En pocas palabras, adquiriendo el disco de 8 TB de Seagate, la nueva distribuición pasaría de ser 4 discos SATA conectados, a solo 2, uno SATA y el otro SSD.

Mis preguntas respecto a todo esto en general, son las siguientes:

• Siendo lo más realista posible, ¿cuanto tiempo estiman que puede tardar el mercado tecnológico en ofrecer competencia para este disco, y por ende, precios más bajos?
   
• ¿Si necesitasen almacenar 8 TB de datos, comprarían este HDD, o distribuirian el espacio en varios HDDs?
    (por favor evaluen el consumo que supone tener varios HDDs, la refrigeración que también supone, o los posibles fallos de depender de solo 1 HDD para todo, etc)
   
• Con la nueva distribuición de HDDs que he planteado en mi torre, ¿disminuiría mucho el consumo de electricidad... como cuanto exactamente traducido a Watts y Euros?,
    ¿y qué hay de las temperaturas del PC ...cuanto disminuirían más o menos? ..por que supuestamente deberían disminuir, ¿no?.
    (por favor necesito una respuesta precisa a esto, por que realmente no consigo hacerme una idea concisa de los beneficios que supondria reemplazar 4 HDDs por 2 HDDs traducido a temperaturas y euros, y tampoco se si existe alguna diferencia relacionada con eso cuando el disco es SSD o SATA)
   

Aparte de esto, cualquier consejo es bienvenido.

Gracias por leer.

Saludos!

La velocidad es un factor muy irrelevante cuando se trara de intentar recuperar información valiosa .

Al hacer un escaneo profundo (que eso es lo que tarda horas y horas dependiendo de la capacidad total del HDD) es cuando aumenta en gran medida las posibilidades de éxito en la búsqueda de archivos a recuperar.

No me tomen por ningún experto en la restauración de HDDs o recuperación de datos, pero la herramienta que yo recomendaría es Wondershare Data Recovery, sobre todo por que la previsualización de archivos ayuda bastante.

➢ http://www.wondershare.com/data-recovery/

Saludos!

Zorronde, tras probar Windows 10 (Preview) solo puedo decirte que...

ACTUALÍZATE

De forma muy resumida se puede afirmar que Windows 10 es un buen sucesor como lo fue el Win7 al VISTA o en menor medida Win8.1 a Win8, aunque del mismo modo aquí la diferencia entre Win 8.1 a Win10 no sea tan abismal ni vaya a afectar tan positivamente al usuario final (por que de por si en Win8.1 no habia tantas pegas, tiene buenas críticas en general),
pero como buen sucesor que es Win10, tiene más comodidades, nuevas características, características refactorizadas, y menos spam de Microsoft;
así que, ¿qué más se le puede pedir a una nueva versión de un S.O? ...¿Que haga mágia?, simplemente es un S.O. nuevo y globálmente mejor.

Di sí a la actualización.

Saludos!

Son muchas cosas las que se deberían mencionar como para hacer una alusión a cada una de ellas en unas pocas lineas, pero te diré lo que considero que es más importante en general.

---

1. Usar las declaraciones Option.

Activa las declaraciones Option (excepto Option Inffer, e ignorando el valor de Option Compare) por defecto para todos los archivos de los nuevos proyectos, accediendo al menú Tools -> Options... -> Projects and solutions -> VB Defaults

También puedes hacerlo manualmente escribiendo lo siguiente en la cabecera de cualquier clase/módulo, los cambios solamente afectaran a ese archivo:

Option Explicit On
Option Strict On
Option Infer Off
 
Class ClassName
' ...
End Class

Esto que he mencionado es lo primero que debes hacer, ya que es una medida que conseguirá que adquieras buenas prácticas de programación desde el principio, ya que, entre otras cosas, evitará que puedas escribir y compilar burradas como esta:

Dim form As Object = Nothing
form.Close()

Sin embargo, será algo muy fastidioso si necesitases crear un tipo anónimo como este de abajo, ya que no lo permitirá compilar:

Dim colors = From value In [Enum].GetValues(GetType(ConsoleColor))
             Select New With {
                              .Value = value,
                              .Name = value.ToString
                             }

...Pero precisamente este tipo de cosas son las que debes evitar hacer. Siempre puedes rsolver el problema definiendo un Type personalizado:

<Serializable>
Public NotInheritable Class ColorThing
    Public Property Name As String
    Public Property Value As Integer
End Class
 
Dim colors As IEnumerable(Of ColorThing) =
    From value As ConsoleColor In [Enum].GetValues(GetType(ConsoleColor)).Cast(Of ConsoleColor)()
    Select New ColorThing With {
                                .Value = value,
                                .Name = value.ToString
                               }

---

2. Leer, aprender y practicar las convenciones de código y de nombres.

¿Por qué?, pues ...entre otras razones, por que cada lenguaje tiene su estándar, así que al escribir un nombre preciso y del modo correcto estarás ayudando al compiler a identificar el miembro en cuestión, lo que se puede traducir cmo mayor estabilidad y velocidad en general (por ínfima que sea en la mayoría de casos).

Aquí tienes por donde empezar, aunque aquí se menciona solamente una pequeña porción:
➢ Manuales de .NET


Otras convenciones a tener en cuenta:

• Debes ignorar cualquier uso de los miembros contenidos en el namespace Microsoft.VisualBasic (Microsoft.VisualBasic.Left, Microsoft.VisualBasic.Mid, Microsoft.VisualBasic.IsDate y en fin, cualquier nombre de función vista en VisualBasic 6)
   
• Debes evitar usar prefijos como "_" para declarar variables (tanto en VB.net como en C#), esto es una mala práctica que ha sido adoptada de forma muy común, pongamos como ejemplo esta propiedad con un backing field, la mayoría de personas lo harían así:
   

Public ReadOnly Property Thing As Boolean
    Get
        Return Me._thing
    End Get
End Property
Private _thing As Boolean = False

Sin embargo, ya he mencionado que el prefijo no se debe usar, así que puedes optar por escribir por ejemplo una "B" al final del nombre, para saber que se trata de un backing field:

Public ReadOnly Property Thing As Boolean
    Get
        Return Me.thingB
    End Get
End Property
Private thingB As Boolean = False

• Debes escribir los nombres de los métodos, funciones, Classes, Modules, Structures, Properties, y muchos más miembros en Word-Casing, y los nombres de las variables generalmente en Camel-Casing, pero se debe tener en cuenta que el estándar de nombre depende de la visibilidad asignada al miembro (public, private, shared, etc), por ejemplo así es como deberías escribir el nombre de una variable en dos casos distintos:

Public MyObject As Object

Private myObject As Object

• Al practicar el P/Invoking (o Platform Invoking), debes comprender que C++ no es C# ni tampoco VB.Net, como ya dije cada lenguaje tiene su estándar de convenciones, y un error muy común en el P/Invoking es copiar o traducir las definiciones de C++ (desde la MSDN o de páginas como www.pinvoke.net) tal y como están escritas para C++, por ejemplo estructuras que llevan nombres completamente en mayúscula, lo que es completamente incorrecto en .Net.
   
• Utilizar la directiva Using para asegurarte de que un objeto libera sus recursos cuando ya no los necesita, o en su defecto un bloque Try/Catch/Finally
   
• Asignar siempre un valor de retorno al definir la firma de una función.
   
• Sustituir a una Class por un Module siempre y cuando sea mejor y óptimo para el compiler, no simplemente para poder usar miembros compartidos/globales.
   
• Inicializar siempre las variables con un valor por defecto, excepto en casos innnecesarios donde ya se inicializan con un valor por defecto como por ejemplo variables con un datatype Boolean (False) o Integer (0).
   
• Utilizar el keyword WithEvents al declerar una variable que exponga eventos, y en su lugar omitir el uso de AddHandler/RemoveHandler para usarlos solamente cuando realmente sea necesario.
   
• Asignarle siempre la firma a un event-handler (un método que controla un evento).
   
• No hacer uso de ninguna técnica resursiva, es decir evitar cualquier método o función recursiva, ya que inevitablemente la recursividad implica un desborde de la pila (o Stack Overflow).
   
• No hacer uso del keyword GoTo ni por ende de los labels.
   
• No utilizar los nombres internos de datatypes como por ejemplo [Int32] en lugar de Integer.
   
• Muchas cosas más.
   

---

3. Aprender a utilizar las características de Visual Studio para detectar y corregir conflictos.

Aparte de la depuración con el uso de break points, la ventana de Autos, etc, Visual Studio tiene una herramienta llamada Code Analysis a la que puedes acceder en el menú Build -> Run Code Analysis,
como su propio nombre indica, sirve para analizar el código, y al analizarlo detectará y prevendrá posibles conflictos que se te hayan podido pasar por alto, como por ejemplo una fuga de memoria por un objeto sin liberar, un objeto que liberas más de una vez, o cosas tan específicas como un conflicto de portabilización (x86/x64) en una definición de un miembro de la API de Windows.

Es tan imprescindible para desarrollar un buen código como todo lo demás (igual que los tests de unidad), pero lamentablemente pocas personas le sacan provecho a la tan maravillosa IDE que tienen, Visual Studio.

Nota: Creo que esta herramienta no está disponible en las versiones Express y Community de Visual Studio, pero no estoy seguro. Yo uso VS2013 Ultimate, y VS2015 Profesional.

Otra cosa que podrías hacer ...aunque esto personálmente me parece MUY EXCESIVO excepto para proyectos comerciales, ni yo mismo lo practico generálmente, sería crear tests de unidad (o Unit Test).
Una unidad consiste en una porción de código, una porción puede ser una variable, un método individual o una class entera.
El test de unidad, digamos que sería una forma automatizada de llevar a cabo diversos análisis para determinar si las funcionalidades de tu código fuente realmente funcionan como es esperado.

Una buenísima herramienta para los tests de unidad es NCrunch.

---

4. Utilizar herramientas profesionales para corregir los errores de principiante (y de no tan principiante).

Siempre es bueno utilizar una especie de guía, maestro o ayudante en forma de herramienta digital, la cual te vaya indicando los errores que has cometido en tiempo real, y así aprender de ellos para la próxima vez,
mi herramienta o mejor dicho extensión favorita es Telerik JustCode, aunque hay otras extensiones muy buenas como ReSharper (exclusivamente para C#).

---

5. Refactorizar el código.

El término Refactorización (o Refactor) consiste en rediseñar un código/algoritmo para simplificarlo y/o para mejorarlo sin que el código pierda su funcionalidad, principalmente para conseguir hacer lo mismo en menos pasos o para aplicar buenas prácticas de programación a un código "feo", pero simplificar no siempre implica escribir menos.

Esto sería un ejemplo de un código que no ha pasado por la etapa de refactorización:

Dim value1 As Integer = 1
Dim value2 As Integer = 2
Dim value3 As Integer = 3
Dim result As Integer = (value1 + value2 + value3)
 
MsgBox(value1 & "+" & value2 & "+" & value3 & " = " & result)

El código refactorizado (tener en cuenta que se le podría dar distintos enfoques):

Dim values As IEnumerable(Of Integer) = {1I, 2I, 3I}
MessageBox.Show(String.Format("{0}={1}", String.Join("+", values), Enumerable.Sum(values)))

---

6. Desarrollar código rehusable.

Deberías tratar de transformar un código hardcodeado en código genérico, rehusable.
(aquí cuidado no confundir el término genérico o Generics, que tiene un significado distinto en lo que se refiere a los Types genéricos de un lenguaje de programación)

Es decir, tratar de evitar escribir un código que haga "X" funcionalidad específica solamente para el proyecto que estás desarrollando, la razón es muy sencilla, si en el futuro necesitas volver a desarrollar un código parecido, probablemente lo empezarás desde Cero otra vez, tal vez tomes ese antiguo código como referencia pero igualmente le harás cambios específicos, y eso se traduce en PERDER tiempo.

Ejemplo de un algoritmo sencillo el cual comprueba si una colección contiene un valor específico:

Dim values As String() = {"a", "b", "c", "d", "e"}
Dim exists As Boolean = False
 
For Each value As String In values
 
    If value.Equals("C", StringComparison.OrdinalIgnoreCase) Then
        exists = True
        Exit For
    End If
 
Next value

Como se puede comprobar, el código solo sirve para una colección de tipo String, todo está "pre-establecido" para que funcione así.

Ahora, este sería un ejemplo del mismo código o funcionalidad, refactorizada, documentada, genérica, y rehusable:

Dim exists As Boolean = {"a", "b", "c", "d", "e"}.Exists("C", StringComparer.OrdinalIgnoreCase)

#Region " Option Statements "
 
Option Strict On
Option Explicit On
Option Infer Off
 
#End Region
 
#Region " Imports "
 
Imports System
Imports System.Linq
Imports System.Diagnostics
Imports System.Runtime.CompilerServices
 
#End Region
 
''' <summary>
''' Contains custom extension methods applicable to <see cref="IEnumerable(Of T)"/>.
''' </summary>
Public Module EnumerableExtensions
 
#Region " Public Extension Methods "
 
    ''' ------------------------------------------------------------------
    ''' <summary>
    ''' Determines whether the specified value exists inside the given collection.
    ''' </summary>
    ''' ------------------------------------------------------------------
    ''' <typeparam name="T"></typeparam>
    ''' 
    ''' <param name="sender">
    ''' The collection.
    ''' </param>
    ''' 
    ''' <param name="find">
    ''' The value to find.
    ''' </param>
    ''' ------------------------------------------------------------------
    ''' <returns>
    ''' <c>true</c> if value exists, <c>false</c> otherwise.
    ''' </returns>
    ''' ------------------------------------------------------------------
    <Extension>
    <DebuggerHidden>
    <DebuggerStepThrough>
    Public Function Exists(Of T)(ByVal sender As IEnumerable(Of T),
                                 ByVal find As T,
                                 ByVal comparer As IComparer(Of T)) As Boolean
 
        If (sender Is Nothing) Then
            Throw New ArgumentNullException(paramName:="sender")
 
        Else
            For Each value As T In sender
 
                If comparer.Compare(value, find) = 0 Then
                    Return True
                End If
 
            Next value
 
            Return False
 
        End If
 
    End Function
 
#End Region
 
End Module

---

7. Documentar el código fuente.

Ser un programador que documenta su trabajo otorga un mayor nivel de respeto o privilegio por aquello que haces de cara al interés o satisfacción del cliente o de las compañias informáticas, el esfuerzo se ve recompensado,
pero además, una razón igual de importante también, es que documentar te obliga a extender tus habilidades de programación, por que documentar un código en muchas ocasiones implica investigar, leer y aprender sobre aquello que estás llevando a cabo, por ejemplo si haces un copy/paste de un código que no entiendes ...pues así no aprendes nada, pero si intentas documentar ese código que no entiendes, probablemente llegarás a entenderlo de principio a fin con la suficiente dedicación,
por supuesto otra razón no menos importante es que mantener una buena documentación del código ...ya sea usando documentación XML o lineas de comentario, te ayudaría a recordar lo que hace un código que dejaste olvidado años atrás, lo que reduciría el tiempo necesario de refactorización o del tiempo invertido en programar en egeneral.

Se mire por donde se mira, la documentación es una práctica muy buena que te podrá llevar a otro nivel superior de entendimiento (bueno, quizás exagero un poco jaja) si la prácticas constantemente con mucha dedicación por lo que haces.

Hay muchas herramientas de terceros que te ayudarán a aplicar la documentación XML, como por ejemplo:
➢ GhostDoc (tiene una versión gratuita, y realmente no necesitas más)
+
➢ [SOURCE] Snippet Tool Extension For Visual Studio (C#/VB)

---

Vuelvo a repetir que hay muchas cosas más que se deberían mencionar como por ejemplo realizar Profillings de rendimiento y memoria, o todo lo que ha comentado el compañero @El Benjo, pero no se puede hablar sobre todo en un post ...ni en dos.

Creo que con todo esto que mencioné ya es suficiente por hoy, espero que algo de esto le sirva a quien lo lea, por que practicamente (casi) todo lo mencionado es aplicable a C# también.

Saludos!

¿De que otra forma piensas que se podría mover un control si no utilizas "algo" (como un Timer, o el método Threading.Sleep) para asignarle unas coordenadas distintas a las actuales y así moverlo?.

No soy experto en gráficos, pero vaya creo que no puede haber otra forma en esencia es eso...

---

Simplemente utiliza el evento Paint para dibujar:

    ' Create points that define curve. 
    Dim point1 As New Point(50, 50)
    Dim point2 As New Point(100, 25)
    Dim point3 As New Point(200, 5)
    Dim point4 As New Point(250, 50)
    Dim point5 As New Point(300, 100)
    Dim point6 As New Point(350, 200)
    Dim point7 As New Point(250, 250)
 
    Dim curvePoints As Point() =
        {
            point1, point2,
            point3, point4,
            point5, point6,
            point7
        }
 
    ''' <summary>
    ''' Handles the <see cref="E:Paint" /> event.
    ''' </summary>
    ''' <param name="e">A <see cref="T:System.Windows.Forms.PaintEventArgs" /> that contains the event data.</param>
    Protected Overrides Sub OnPaint(ByVal e As PaintEventArgs)
 
        MyBase.OnPaint(e)
 
        Using graphPath As New GraphicsPath
 
            graphPath.AddCurve(curvePoints)
 
            Using pathPen As New Pen(Color.Red)
                e.Graphics.DrawPath(pathPen, graphPath)
            End Using
 
        End Using
 
    End Sub

Para mover un elemento por el trazo, necesitas averiguar algunos factores, yo no soy muy bueno en la aritmética así que he sacado (y refactorizado) un ejemplo que encontré aquí:
http://www.dreamincode.net/forums/topic/293148-getting-an-object-to-follow-a-bezier-curve/

 MoveControl(ctrl:=Me.PictureBox1, speed:=200, path:=curvePoints)

''' <summary>
''' Moves a control through a path.
''' </summary>
''' <param name="ctrl">The control to move.</param>
''' <param name="speed">The animation speed.</param>
''' <param name="path">The path to follow.</param>
Public Shared Sub MoveControl(ByVal ctrl As Control,
                              ByVal speed As Integer,
                              ByVal path As IEnumerable(Of Point))
 
    For index As Integer = 1 To (path.Count - 1)
 
        Dim m As Double = (path(index).Y - path(index - 1).Y) / (path(index).X - path(index - 1).X)
        Dim c As Double = (path(index).Y) - (m * path(index).X)
        Dim sign As Integer = Math.Sign(path(index).X - path(index - 1).X)
 
        While (ctrl.Left <> path(index).X)
 
            Application.DoEvents()
            ctrl.Left += (sign * 5)
            ctrl.Top = CInt(m * CDbl(ctrl.Left) + c)
            Thread.Sleep(speed)
 
        End While
 
    End Sub

---

¿A qué tipo de prácticas te refieres exactamente?, ¿a mover un elemento por la UI, o desarrollar un juego?.

Para lo primero ...simplemente es mover el control y ya está, cualquiera puede hacerlo sin una librería que nos haga de "ayudante" xD, sin embargo, existe una librería dedicada a efectos/transiciones para la UI, la cual proporciona un método para mover un elemento de un punto a otro, la utilización sería algo así:

(el control se mueve mal, pero es solo un ejemplo on-the-fly, como ya dije los cálculos de los ángulos en fin la trayectoria se me da mal)

Imports Transitions
 
Public NotInheritable Class Form1 : Inherits Form
 
    ' Create points that define curve. 
    Dim point1 As New Point(50, 50)
    Dim point2 As New Point(100, 25)
    Dim point3 As New Point(200, 5)
    Dim point4 As New Point(250, 50)
    Dim point5 As New Point(300, 100)
    Dim point6 As New Point(350, 200)
    Dim point7 As New Point(250, 250)
 
    Dim curvePoints As Point() =
        {
            point1, point2,
            point3, point4,
            point5, point6,
            point7
        }
 
    Private Sub Form1_Shown(ByVal sender As Object, ByVal e As EventArgs) _
    Handles MyBase.Shown
 
        Dim speed As Integer = 200
        Dim transitions As New List(Of Transition)
 
        For index As Integer = 0 To (curvePoints.Count - 2) Step 2
 
            Dim transition As New Transition(New TransitionType_Linear(iTransitionTime:=speed))
            With transition
                .add(PictureBox1, "Left", curvePoints(index).X)
                .add(PictureBox1, "Top", curvePoints(index + 1).Y)
            End With
 
            transitions.Add(transition)
 
        Next
 
        Transition.runChain()
 
    End Sub
 
End Class

Para lo segundo, suponiendo que estés desarrollando un juego (por las imágenes de los coches, y ahora las curvas), entonces estás empezando mal, deberías utilizar librerías especializadas en esa temática, cualquier librería basada en DirectX u OpenGL, o el framework XNA de Microsoft (aunque está deprecado ya), etc.

➢ SharpDX

Sin embargo, es una temática muy compleja de manejar, crear una forma y dibujarla lo puede hacer cualquier (aunque solo eso ya necesita unas cuantas lecturas de manual xD), yo intenté hacer algo simple hace un tiempo y me agobié por completo al final xD.

Saludos

Claro, te hablé sobre los comandos por que es la alternativa sencilla, solo tienes que darle foco a la instancia de Visual Studio (pero recuerda que es una aplicación multi-instancia así que deberás manejarte con eso), una vez la ventana esté activa puedes simular la pulsación de la combinación Contorl+Alt+A (como lo estés haciendo en tu código) para mostrar y activar la ventana de comandos, y pur último simular las pulsaciones del teclado que desees para escribir el nombre del comando y los argumentos que éste toma.

---

En cualquier aplicación puedes hacerlo al menos de dos maneras (a falta de poder usar otras técnicas IPC), la primera y más sencilla sería enviando pulsaciones del teclado a la ventana en cuestión,
la manera compleja (pero muchísimo más eficiente) sería localizando el control en la UI para modificar su texto (eliminarle, añadirle, etc), haciendo un espionaje (App-Spy) a la aplicación.

Para la segunda manera puedes utilizar Microsoft UI Automation (o en su defecto la API de Windows, funciones FindWindowEx, EnumChildWindows, SendMessage, etc), en los miembros del namespace System.Windows.Automation, pero cada aplicación es un mundo con estructura distinta, classnames distintos, etc, así que cada aplicación requeríra un análisis personalizado. Es bastante tedioso.

El Notepad está bastante explotado en ese sentido por que es la aplicación con la que se suele experimentar el App-Spy, así que no creo que encuentres complicaciones para buscar y encontrar información al respecto si buscas por sus classnames en Google, aunque de todas formas puedes obtener toda la información que necesites de una aplicación por ti mismo con las herramientas de Microsoft UI Automation que puedes encontrar en el interior del paquete de la SDK de Windows, u otras herramientas de terceros como WinSpy o Xaml Spy.

Lo de ir a una linea ya lo veo mucho más complicado, al menos no se me ocurre como hacerlo con el notepad.

Nota: Recuerdo que en el Notepad, el nombre de la ventana a la que le puedes enviar texto (texto, no confundir con pulsaciones) se llama "EDIT".

---

¡Aaah, bueno!, en ese caso si, por supuesto que puedes:

➢ Get Started with Speech Recognition - MSDN
➢ System.Speech.Recognition - MSDN
➢ Speech recognition, speech to text, text to speech, and speech synthesis in C# - CodeProject
➢ Google

Nota: Aunque, debo decirte que este tema nunca lo he llegado a investigar ni mucho menos a practicar, así que no puedo ayudarte mejor respecto a ese tema.



Que tengas suerte y ánimos con la idea y el desarrollo.

Saludos!

La API para manipular internamente Visual Studio es su SDK, la cual es gratuita.

Para ir aprendiendo lo básico, échale un vistazo a estos enlaces:
➢ Manuales de .NET

---

A lo que realmente te estás refiriendo son combinaciones de teclado de acceso rápido, hotkeys.

Los comandos existentes en Visual Studio que invocan un verbo/acción, puedes utilizarlos de dos maneras:

1. Usando la SDK de Visual Studio, es decir, programando. (pero te advierto que para un principiante en la SDK, resulta MUY complejo al principio)

2. Escribiendo el nombre del comando en la ventana de comandos, a la que puedes acceder desde el menú View -> Other Windows -> Command Window o con el hotkey Control+Alt+A.

Aquí tienes una breve lista de algunos comandos de la IDE:
➢ Visual Studio Commands - MSDN

Para ver la lista completa (incluyendo los comandos ocultos o añadidos por extensiones de terceros) debes mirarlo desde las opciones de la IDE, en el menú Tools -> Options... -> Environment -> Keyboard, por defecto hay alrededor de 4.000 comandos disponibles para el disfrute, casi nah .

---

Lo que te voy a explicar es la forma de hacerlo mediante los comandos, usando la SDK de Visual Studio sería muy distinto, aunque por otro lado, también puedes recurrir a la utilización de comandos usando la SDK si lo prefirieses así.

Comando Edit.GoTo "36"


Si la class se llama de la misma manera que el archivo, entonces con el comando File.OpenFile "FormPrincipal.vb".
Para buscar un nombre, el comando Edit.Find "FormPrincipal" + Edit.FindNext


Comando Edit.Find "actualizarTabla" + Edit.FindNext


Comando Edit.LineDownExtend hasta que Linea.TrimStart.StartsWith("End Sub") o Linea.TrimStart.StartsWith("}") para C#;
por último, comando Edit.Copy.

En C# sería una tarea más tediosa, por que el bracket de cierre se puede colocar tanto al pricnipio de una linea vacía como al final de una instrucción:

private void MyMethod() {
    code;}

Obviamente no existe comando para una tarea tan particular, debes programar el algoritmo.


Para el parsing/reconocimiento de los lenguajes de la plataforma .Net, puedes usar el motor Roslyn, que es el mismo que usa Visual Studio, y también es gratuito (y Open Source).

Aunque si te estás refiriendo a utilizar la voz para escribir código con la sintaxis de C#, pues no hay nada que te ayude más que desarrollar tu propio intérprete/traductor para reconocer la voz y luego indicar los caracteres que se deben typear...

---

Solo la teoría suena excelente, por que la práctica sería una auténtica ruina insufrible, a menos que se quiera hacer un "Hola mundo" y ya está.

Las manos trabajan mejor que la voz en muchos casos, por ejemplo al escribir operaciones aritméticas, o al copiar y pegar cadenas de texto o bloques de código.

Y si no, ponte a deletrear cualquier cifra empezando por una cifra pequeña como por ejemplo los primeros decimales del número PI, comparándolo con el tiempo en que eres capaz de escribirlo:

float pi = 3.1415926536f;

(eso es solo un pequeñísimo ejemplo de demostración, mucho más se tardaróa en "programar" una operación aritmética compleja, claro está).


Quítale todo a esa frase y deja el "más tiempo", en eso se resumiría la idea, en consumir más tiempo (del que realmente sería necesiario, usando las manos).

Pero bueno, si a ti te gusta no te lo discuto, quizás tu puedas sacarle provecho a tu idea.

Un saludo!

¿Por qué usas 6 métodos distintos solamente para asignar el valor de una variable?, es demasiado código para llevar a cabo la misma acción, en su lugar puedes asignar 6 variables con nombre dinámico (_1, _2, _3, etc) o mucho mejor, simular un Array:


Saludos

Claro, ¿qué otra cosa iban a poner los teams de cracking?, "Me importa una mierd@ el dinero que les hago perder a las compañias de videojuegos, estimados agentes del F.B.I, vengan a por mi, no les tengo miedo"...¿?

Que conste que estoy a favor de la piratería por el mismo motivo que lo estamos TODOS (por que no somos ricos), pero ...pf, seamos realistas, el motivo por el cual los teams que lanzan releases de música, películas, juegos, y etc ponen ese tipo de frasecitas es obvio, no es por amor al arte ni por tener un detalle, sino una (mala) estrategia de evasión a demandas/denuncias etc.

---

Me parece una mala lógica, por que de siempre el público de los cines ha pagado (o en las compras de las películas), ¿entonces de que sirve tener el doble de publico por descarga digital, si es publico que no paga ni un duro?, yo desde luego tampoco querría tener leechers público así.

Pero es que de todas formas los directores de cine hace mucho que dejaron de hacer películas por pasión y por hacer disfrutar al espectador, ahora lo hacen exclusivamente por dinero, y solo algunos grandes del género que ya tienen todo el dinero que quieren se pueden dar el lujo de hacer lo que hacen también por pasión (ej: Spielberg).

PD: Hablo de los cineastas orientados al cine yankee.

Saludos