Mensajes

[pero no he encontrado un software que se veloz]

Yo he tenido problemos similares pero no he encontrado un software que se veloz

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!

[ACTUALÍZATE]

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!

[1. Usar las declaraciones Option.]

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:

Código (vbnet) [Seleccionar] Expandir

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:

Código (vbnet) [Seleccionar] Expandir

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:

Código (vbnet) [Seleccionar] Expandir

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:

Código (vbnet) [Seleccionar] Expandir

<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

⇲ Estándares / Adquisición de buenas costumbres

• [VB] Coding Conventions
• [VB] Naming Conventions
• [VB] Program Structure and Code Conventions

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í:
  

Código (vbnet) [Seleccionar] Expandir

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:

Código (vbnet) [Seleccionar] Expandir

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:

Código (vbnet) [Seleccionar] Expandir

Public MyObject As Object

Código (vbnet) [Seleccionar] Expandir

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:

Código (vbnet) [Seleccionar] Expandir

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):

Código (vbnet) [Seleccionar] Expandir

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:

Código (vbnet) [Seleccionar] Expandir

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:

Código (vbnet) [Seleccionar] Expandir

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

Código (vbnet) [Seleccionar] Expandir

#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!

[DirectX]

Se me han ocurrido varias soluciones pero no las veo nada practicas.

como mover el picturebox por posciciones es decir ir asignadole cordenadas para dibujar la curva y moverlo con un timer.

¿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...

Mi duda mas concreta es como dibujo una curva (o un recorrido) y que el piturebox se mueva sobre ese recorrido, no se si me doy a entender.

Simplemente utiliza el evento Paint para dibujar:

Código (vbnet) [Seleccionar] Expandir

   ' 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/

Código (vbnet) [Seleccionar] Expandir

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

Código (vbnet) [Seleccionar] Expandir

''' <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

No se que librerias puedo usar para hacer este tipo de practica les agradeceria cualquier ayuda

¿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)

Código (vbnet) [Seleccionar] Expandir

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

[¿Es posible usar los comandos tal cual dentro de un programa y hacer que se ejecuten sobre el Visual Studio activo?]

He ejecutado algunos de los comandos que usted menciona y sí que funcionan. Pero, ¿en qué casos usaríamos la ventana de comandos?
Es decir, lo que deseo es incluir la funcionalidad de los comandos en un programa. ¿Es posible usar los comandos tal cual dentro de un programa y hacer que se ejecuten sobre el Visual Studio activo?

¿O para esto último la única opción posible es usar la SDK?

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.

si aprendo a escribir cosas sobre el clipboard, ir a una línea y pegar, podría hacerlo.

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".

Solo me refiero a que usando C# (supongo de la misma forma funciona con VB u otros) es posible reconocer lo que se dice por un micrófono y según ello actuar. Yo creí que sería un tema más complicado o que el reconocimiento sería muy deficiente, pero es bueno jeje.

¡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!

[Manuales de .NET]

API para manipular VS

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

⇲ Visual Studio SDK

• [VB/C#] Extending Visual Studio Overview
• [VB/C#] Visual Studio Extensibility Articles
• [VB/C#] Visual Studio 2013 SDK Samples
• [VB/C#] Learn VSX Now!

He buscado comandos de visual studio, y hay algunas combinaciones que permiten ir a la siguiente pestaña. Esto creo que lo puedo hacer, haciendo que se "presionen ciertas teclas".

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í.

- "Ir a la línea 36"
* "Estamos en la línea 36"

Comando Edit.GoTo "36"

- "Ir a la clase FormPrincipal"
* "Estamos en la clase FormPrincipal"

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

- "Ubicar el método actualizarTabla"
* "Método ubicado"

Comando Edit.Find "actualizarTabla" + Edit.FindNext

- "Copiar el contenido"
* "Se ha copiado el contenido del método actualizarTabla"

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:

Código (csharp) [Seleccionar] Expandir

private void MyMethod() {
   code;}

- "Crear un método estatíco que devuelva un objeto de tipo String"
* "Método estático creado"

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

- "Usar reconocimiento del lenguaje C#"
* "Reconociendo lenguaje C#"

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...

La verdad es que, programar sin usar el teclado/mouse sería excelente.

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:

Código (csharp) [Seleccionar] Expandir

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á).

De hecho, tendríamos más tiempo para dedicarnos en pensar la lógica que escribir o tener que ubicarnos en una pos determinada.

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:

Código [Seleccionar] Expandir

@Echo Off & Setlocal EnableDelayedExpansion

Set "reasons=Juicio;Apuesta;Error;Compra;Impuestos;Robo"

Set /A "rand=%RANDOM% %%6" & REM Número aleatorio del 0 al 5.
REM si prefieres utilizar un índice de 1, número aleatorio del 1 al 6:
:: REM %RANDOM% <(--- No eliminar esta linea de comentario REM. Es necesaria para inicializar correctamente RANDOM.
:: Call Set /A "rand=%RANDOM% * 6 / 32768 + 1"

Set /A "count=0"
For %%# in ( %reasons% ) Do (
If !count! EQU %rand% (Call :DirtyWork "!count!" "%%~#")
Set /A "count+=1"
)

Pause&Exit /B 0

:DirtyWork :: %1=Index, %2=Reason
Set /A "index=%~1"
Set    "reason=%~2"
Echo.Index : %index%
Echo.Reason: %reason%
REM buscar...

GoTo :EOF

Saludos

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

Incluso algunos repackers colocan un mensaje diciendo "Si te gusta el juego, cómpralo".

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.

Tambien tengamos en cuenta, que para algunos de esos "cineastas" el que alguien se baje su "obra de arte" por error implica casi que duplican su publico

La gente no quiere algunas cosas ni regaladas

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

Elektro: En esto entretienes en hacerle fotos a las cochinillas de tu casa jaja

Es que me podía la curiosidad, ¡siempre necesito saber que es todo lo que ven mis ojos!.

Podríamos hacer una investigación de bichos raros que aparecen en nuestra casa normalmente aparecen por el lavabo, bañeras ademas son tela de raro parecen de la época de los dinosaurios jaja y a mi por la noche me aparece babosas cuando hay humedad.

En mi casa no suelo ver ningún bicho excepto los que entran por las ventanas claro las moscas y mosquitos, o alguna cucaracha muy de vez en cuando (pero como dicen los expertos, por 1 cucaracha vista siempre habrá 20 más cerca escondidas... eso da muy mal rollo)

Cuando era pequeño con 12 o 13 años vi cerca de una lámpara de una casa una araña muy rara, de color amarillo... muy pequeña más o menos 1,5 cm de largo y 9 mm de alto, parecía muy fragil pero también muy agil, hasta día de hoy siempre he querido conocer el nombre de esa especie de araña que vi, a ver si me lo resuelves .

PD: Un colega por aquél entonces me dijo que era una "araña tigre", pero vamos, creo que me tomó el pelo xD.

Saludos

Está bien saber que son inofensivos (a parte de daños materiales)

Claro, hay que intentar informarse sobre todos los insectos que vemos en nuestras casas/baños, sobre todo los que intentamos respetar el resto de formas de vida y no matar todo lo que vemos, quiero decir, que si yo llego a saber que "mi bicho" era inofensivo entonces no lo habría matado, pero me pareció una amenaza de gérmenes al no saber nada respecto a su naturaleza, así que no hace falta decir como acabó su triste vida... pero para la próxima vez ya lo se.

Saludos!