Cita:
Iniciado por Malenko 
Varios puntos a comentar:
- .NET no es un lenguaje de programación sino un framework que usan varios lenguajes, entre ellos C#, Visual Basic.NET, C++/CLR, etc.
- Porque en ".NET" hay ofuscar el código? En que te basas? Cualquiera puede leer el código de un programa en .NET? En cambio un programa que no están en ILASM sino en código máquina es meno legible? Bajo que premisas haces esa afirmación?
- Con .NET (o con Java, C++, ...) puedes crear un programa en versión "shareware" y con herramientas como NSIS crear instaladores independientemente de con que lenguaje se programó.
- Un programa en .NET es tan facil de descompilar como un programa "antiguo" nativo o en VB6.
Creo que las premisas que usas para la elección del lenguaje no son las apropiadas. Tienes que basarte en la curva de aprendizaje, cosas que te permitirá hacer, etc. En tu caso, viniendo de Visual Basic 6 lo más fácil sería empezar con Visual Basic. NET. Ojo, lo más fácil, pero no lo mejor. Yo personalmente optaría por .NET o por Java pero depende de a que sistemas operativos quieras acceder, etc.
Gracias por responder:
- Totalmente de acuerdo, disculpa por no haberme expresado bien, cuando me referí a .NET quise decir "lenguaje Visual Basic .NET".
- Nuevamente disculpas por mi ignorancia si en algo me equivoco: estudié algo, poca cosa de VB.Net hace años, como primera opción para saltar de VB6.0, y lo que tengo entendido es que MSIL (MicroSoft Intermediate Languaje) es el lenguaje interno de .NET Framework, cercano al código máquina.
Y todos los lenguajes compatibles .NET (da igual su sintaxis) se compilan a este MSIL que es un pseudo-código propio solo entendible por la máquina virtual o framework .NET, que a su vez hace de intermediario con el microprocesador que solo entiende código máquina, ensamblador, assembler, código nativo, binario o como queramos llamarlo.
Y que la plataforma (framework) .NET, cada vez que ejecuta un .EXE de .Net, lo que ejecuta es ese pseudo-código, INTERPRETÁNDOLO cada vez al código máquina x86.
Cita: Por qué en ".NET" hay ofuscar el código? En que te basas? Cualquiera
puede leer el código de un programa en .NET?
Obviamente para "intentar" que no me lo pirateen, al menos
dificultarlo en lo posible.
Cita: "Cualquiera puede leer el código de un programa en .NET?"
Hombre, mi abuela no, pero aunque suene duro, la respuesta es SÍ: Cualquiera,
cualquier estudiante o aficionado a la programación que acaba de instalar Visual Studio (como yo novato en .Net), tendrá el Desensamblador de IL (IL DASM) en Microsoft Windows SDK Tools, del menú MS VS2010. Lo demuestro y como ej. si le arrastro un .EXE de VB6.0 me da error "exe no valid" como era previsible. En cambio si le meto un .EXE generado con VB.NET en VS2010, me da lo siguiente:
Código:
// Source File 'C:\Users\Enrique\documents\visual studio 2010\Projects\TablaMultiplicar\TablaMultiplicar\Module1.vb'
//000003: Sub Main()
IL_0000: nop
//000004: Dim tabla As Integer
//000005: Dim n As Integer
//000006: Dim resultado As Integer
//000007:
//000008: Console.Write("Escriba la tabla de multiplicar que quiere calcular: ")
IL_0001: ldstr "Escriba la tabla de multiplicar que quiere calcula"
+ "r: "
IL_0006: call void [mscorlib]System.Console::Write(string)
IL_000b: nop
//000009: tabla = Console.ReadLine()
IL_000c: call string [mscorlib]System.Console::ReadLine()
IL_0011: call int32 [Microsoft.VisualBasic]Microsoft.VisualBasic.CompilerServices.Conversions::ToInteger(string)
IL_0016: stloc.2
//000010: Console.WriteLine("")
IL_0017: ldstr ""
IL_001c: call void [mscorlib]System.Console::WriteLine(string)
IL_0021: nop
//000011: 'Bucle de la tabla de multiplicar
//000012: For n = 0 To 10
IL_0022: ldc.i4.0
IL_0023: stloc.0
//000013: resultado = tabla * n
IL_0024: ldloc.2
IL_0025: ldloc.0
IL_0026: mul.ovf
IL_0027: stloc.1
//000014: 'Impresión en pantalla
//000015: Console.WriteLine(" {0} x {1} = {2}", tabla, n, resultado)
IL_0028: ldstr " {0} x {1} = {2}"
IL_002d: ldloc.2
IL_002e: box [mscorlib]System.Int32
IL_0033: ldloc.0
IL_0034: box [mscorlib]System.Int32
IL_0039: ldloc.1
IL_003a: box [mscorlib]System.Int32
IL_003f: call void [mscorlib]System.Console::WriteLine(string,
object,
object,
object)
IL_0044: nop
//000016: Next
IL_0045: nop
IL_0046: ldloc.0
IL_0047: ldc.i4.1
IL_0048: add.ovf
IL_0049: stloc.0
//000017:
//000018: Call salir()
//000019: End Sub
//000020:
//000021: Sub salir()
//000022: Console.WriteLine("")
//000023: Console.WriteLine("Pulsa intro para salir...")
//000024: Console.ReadLine()
//000025: End Sub
//000026:
//000027: End Module
IL_004a: ldloc.0
IL_004b: ldc.i4.s 10
IL_004d: stloc.3
IL_004e: ldloc.3
IL_004f: ble.s IL_0024
//000018: Call salir()
IL_0051: call void TablaMultiplicar.Module1::salir()
IL_0056: nop
//000019: End Sub
IL_0057: nop
IL_0058: ret
} // end of method Module1::Main
.method public static void salir() cil managed
{
// Code size 31 (0x1f)
.maxstack 8
//000020:
//000021: Sub salir()
IL_0000: nop
//000022: Console.WriteLine("")
IL_0001: ldstr ""
IL_0006: call void [mscorlib]System.Console::WriteLine(string)
IL_000b: nop
//000023: Console.WriteLine("Pulsa intro para salir...")
IL_000c: ldstr "Pulsa intro para salir..."
IL_0011: call void [mscorlib]System.Console::WriteLine(string)
IL_0016: nop
//000024: Console.ReadLine()
IL_0017: call string [mscorlib]System.Console::ReadLine()
IL_001c: pop
//000025: End Sub
IL_001d: nop
IL_001e: ret
} // end of method Module1::salir
} // end of class TablaMultiplicar.Module1
Como se ve es una mezcla de instrucciones código máquina MSIL con sus instrucciones equivalentes, variables originales... hasta los comentarios que hice en VB.NET y a continuación el listado original de dicho código fuente. Es un sencillo ejercicio que en consola muestra la tabla de multiplicar elegida por el usuario:
Código:
Module Module1
Sub Main()
Dim tabla As Integer
Dim n As Integer
Dim resultado As Integer
Console.Write("Escriba la tabla de multiplicar que quiere calcular: ")
tabla = Console.ReadLine()
Console.WriteLine("")
'Bucle de la tabla de multiplicar
For n = 0 To 10
resultado = tabla * n
'Impresión en pantalla
Console.WriteLine(" {0} x {1} = {2}", tabla, n, resultado)
Next
Call salir()
End Sub
Sub salir()
Console.WriteLine("")
Console.WriteLine("Pulsa intro para salir...")
Console.ReadLine()
End Sub
End Module
En Visual Basic 6.0 tienes 2 opciones a la hora de compilar: a P-Code (Pseudo-Código más lento y creo que sí podrías recuperar el código fuente desensamblando aunque jamás usé esta opción) o a Código Nativo (Código Máquina x86, rápido, sin posibilidad de código fuente) aunque en honor a la verdad, jamás he intentado desensamblar.
Cita: - Un programa en .NET es tan facil de descompilar como un programa
"antiguo" nativo o en VB6.
OK, de acuerdo, pero una cosa es descompilar a código máquina, que no lo entiendo ni yo a pesar de que hace ya mucho estudié y trabajé el Zilog Z80, y otra muy diferente descompilar a MSIL con el código fuente VB.NET al lado o entremezclado.
No obstante, si conoces o alquien más, alguna forma de evitar esto, alguna opción que evite el código fuente visible dentro del ejecutable distribuible, quizás en nuevas versiones de Visual Studio, yo las desconozco, bienvenidas sean. Como bien dices, un tema importante es la curva de aprendizaje y VB.NET me interesaría por eso, pero lo descarté por lo ya expuesto.
Saludos