Mensajes

Comparto unos temitas del género Post-hardcore Rock con vocalistas femeninas:

Dream State - Rebuild, Recreate
[youtube=640,360]https://www.youtube.com/watch?v=wuvaCOrjjaw[/youtube]

Conquer Divide - Nightmares
[youtube=640,360]https://www.youtube.com/watch?v=uXGRYW-C8gQ[/youtube]

Tonight Alive - Showcase (en directo)
[youtube=640,360]https://www.youtube.com/watch?v=uYsfyY_mchM[/youtube]





Más temazos de Rock vocal femenino:

The Strangers - Madness
[youtube=640,360]https://www.youtube.com/watch?v=EaGMNlgaEz0[/youtube]

Halocene - Sometimes
[youtube=640,360]https://www.youtube.com/watch?v=EB9dOyE-DBU[/youtube]

Stateside - The Way We Were
[youtube=640,360]https://www.youtube.com/watch?v=4w7d98670D0[/youtube]

Stitched up heart - Finally Free
[youtube=640,360]https://www.youtube.com/watch?v=acZbW-CmUTA[/youtube]

Eclipses For Eyes - Left Of You
[youtube=640,360]https://www.youtube.com/watch?v=kdqH6Y9eFWQ[/youtube]





Y un poco de Post-hardcore masculino!:

Annisokay - What's Wrong
[youtube=640,360]https://www.youtube.com/watch?v=K3emXVfcELc[/youtube]

The Plot In You - Feel Nothing
[youtube=640,360]https://www.youtube.com/watch?v=pjX3J9EpAr0[/youtube]

I see stars - Till The World Ends
[youtube=640,360]https://www.youtube.com/watch?v=885qb6s6URs[/youtube]

Saint Asonia - Fairytale
[youtube=640,360]https://www.youtube.com/watch?v=DMzxHjo13WA[/youtube]

[Scribd.com]

Aparte de Scribd.com, siempre puedes recurrir a Archive.org.

Saludos

[NEBIRE]

PD.: Si no quieren mostrarme el codigo no importa. Pueden hacerme preguntas como: "Te fijaste lo que hiciste ahi o ahi" o "Te acuerdas que esto es asi y asi?"

Ese comentario creo que está de más, sinceramente. Me habría gustado profundizar en el concepto "comandos" y por qué carece de sentido su utilización en una GUI ...al menos a simple vista sin que expliques más sobre tus intenciones.



El compañero @NEBIRE está claro que pretende que trabajes mucho en implementar las cosas por ti mismo para que vayas aprendiendo conceptos y de todo un poco en general, jeje, pero tampoco sería un delito hacerte saber que la librería de clases de .NET Framework ya expone una representación abstracta de una Pila, mediante la colección LIFO genérica System.Collections.Generic.Stack<T> (o la no genérica: System.Collections.Stack), y una representación de una Cola, la colección FIFO genérica System.Collections.Generic.Queue<T> (o la no genérica: System.Collections.Queue):

Código (csharp) [Seleccionar] Expandir

Stack<string> pila = new Stack<string>(capacidad);
Queue<string> cola = new Queue<string>(capacidad);

Eso es en esencia todo lo que necesitarías para empezar a administrar el uso de una Pila (y de una Cola); ahora, y gracias al concepto de herencias, puedes tomar la clase Stack<T> y extenderla (para añadirle nuevos miembros/métodos/características) según las necesidades que tuvieses:

Código (csharp) [Seleccionar] Expandir

[ComVisible(false)]
[DebuggerDisplay("Count = {Count}")]
[DebuggerStepThrough()]
public class ExtendedStack<T> : Stack<T> {

   [DebuggerNonUserCode()]
   public ExtendedStack() : base() {}
   public ExtendedStack(int capacity) : base(capacity) {}
   public ExtendedStack(IEnumerable<T> collection) : base(collection) {}

   [EditorBrowsable(EditorBrowsableState.Always)]
   public void PushRange(IEnumerable<T> items) {
       foreach (T item in items) {
           this.Push(item);
       }
   }

   [EditorBrowsable(EditorBrowsableState.Always)]
   public T[] Pop(int amount) {
       if (this.Count < amount) {
           throw new ArgumentOutOfRangeException(paramName: "amount");
       }
       List<T> list = new List<T>();
       for (int x = 0; x <= (amount - 1); x++) {
           list.Add(this.Pop());
       }
       return list.ToArray();
   }

   [EditorBrowsable(EditorBrowsableState.Always)]
   public T[] Peek(int amount) {
       if (this.Count < amount) {
           throw new ArgumentOutOfRangeException(paramName: "amount");
       }
       Stack<T> tmpStack = new Stack<T>(Enumerable.Reverse(this));
       List<T> list = new List<T>();
       for (int x = 0; x <= (amount - 1); x++) {
           list.Add(tmpStack.Pop());
       }
       tmpStack.Clear();
       return list.ToArray();
   }

   [EditorBrowsable(EditorBrowsableState.Always)]
   public void Reverse() {
       Stack<T> tmpStack = new Stack<T>(Enumerable.Reverse(this));
       this.Clear();
       this.PushRange(tmpStack);
       tmpStack.Clear();
   }

}

...El código de arriba es tan solo un ejemplo demostrativo y escrito al vuelo (no del todo optimizado), lo cierto es que nada de eso te debería resultar necesario hacerlo, pero no está de más enseñarte un poco el abanico de posibilidades que tienes a tu alcance...

Sencillamente limítate a usar la clase Stack<T> tal cual para representar una pila de objetos, o el ejercicio en pseudo-code que te ha indicado @NEBIRE para poner en práctica los conocimientos que lleves aprendidos...

Saludos.

[Randomize]

gracias por nada

No hombre, gracias por nada a ti, sobre todo por el sentido común de haber mostrado la información esencial de los logs cuando te lo han pedido para intentar ayudarte de forma óptima/eficiente. Y también por tu gratitud al compartir la solución, gracias también por eso, como ya te dijo @Randomize.

En fin, en el mundo tiene que haber todo tipo de personas y este problema ya está resuelto, ¿verdad?, pues cierro el tema.

[Windows]

windows tiene crontab?

La respuesta es NO, al menos no como tal. El equivalente en Windows serían las tareas programadas del sistema, archivo: TaskSchd.msc, pudiendo además utilizar su versión CLI, archivo: SchTasks.exe para crear, modificar y eliminar tareas de forma programática, pero SchTasks no puede ayudar en nada a la pregunta que el usuario ha formulado, a menos que la intención fuese iniciar el script con privilegios de administrador a una hora determinada o al inicio de sesión del usuario o cuando se produjese otro evento específico en el sistema operativo.

Una solución sencilla de implementar sería utilizando el comando externo RunAs.exe, declarando en el script un argumento que sirva como señal para determinar si el script necesita "reiniciarse" usando el comando RunAs para obtener privilegios de administrador. Puedes intentar probar así:

( Lo escribí al vuelo, no lo he testeado por tener el UAC desactivado. De todas formas en Google deberías poder encontrar miles de ejemplos parecidos al mio. )

Código (dos) [Seleccionar] Expandir

@Echo OFF

Set "accountName=Administrador"

Set "elevatedArg=%~1"
If "%elevatedArg%" NEQ "elevated" (
   Start "" CMD /K "RunAs.exe /User:"%accountName%" "CMD.exe /C \"\"%~f0\" \"elevated\"\"""
   Exit /B 1
)

:: Tu código aquí...

Pause
Exit /B 0

...Sin embargo, esta metodología de "reiniciar el script" con RunAs tiene un contratiempo, y es que es necesario introducir la contraseña manualmente, es así por defecto, no se puede ignorar este paso por motivos de seguridad en Windows/RunAs.

Si te resulta incómodo tener que escribir el password cada vez, entonces puedes optar por otras soluciones alternativas, de código... pero son mucho más tediosas, como por ejemplo esta:

• How can I auto-elevate my batch file, so that it requests from UAC administrator rights if required? | StackOverflow

O también puedes utilizar herramientas de terceros como el comando "Elevate" de la aplicación command´line NirCMD (lo que te ahorraría muchos quebraderos de cabeza, pero dependerías de aplicacioens de terceros):

• http://nircmd.nirsoft.net/elevate.html

...Y también puedes hacerlo con alguna aplicación del paquete PSTools, pero no recuerdo ahora mismo exactamente cual era, ¿PSExec.exe quizás?, puedes buscarlo en Google.

• https://technet.microsoft.com/en-us/sysinternals/pstools.aspx

Saludos.

[point = New Point(280, &H98)]

Madre del amor hermoso, vaya un código, en el peor sentido posible... ¡qué código!. En el form1.vb hay +18.000 lineas de código, cualquier modificación de 1 solo caracter me tarda 1 minuto en aplicarse xD (en un disco SSD).

La hipótesis de que este código lo hayan generado mediante una herramienta que analice las instrucciones IL y mediante Reflection y tal represente el código en el lenguaje VB.NET, a mi no me convence demasiado, por que yo veo bastantes incongluencias las cuales considero que ese tipo de herramientas no generarían de forma intencionada, sin ir más lejos el echo de asignar un valor entero y otro hexadecimal en los argumentos de un constructor: point = New Point(280, &H98), pero bueno, quizás me equivoco.
En mi opinión, cabe la posibilidad de que simplemente hayan usado cualquier herramienta de automatización de traducción de C# a VB.NET para convertir el proyecto original escrito en C#, a VB.NET, y de ahí tantos errores de compilación, un completo desorden de estructurización del código, la completa ausencia de la clausula Handles, y otras cosas varias...

En el código fuente que has compartido, el tamaño y posición de los controles se estaba especificando mediante una variable llamada "point", y otra "size", esta última entraba en conflicto con la propiedad Form.Size. Las referencias de los controles, así como la asociación de eventos de los controles, estaban definidos mediante propiedades, lo cual es muy típico de ver en conversores de código C# a VB.NET.

En fin, he corregido todos los errores de compilación (no eran muchos), he reconstruido la parte del diseñador de Forms, y las asociaciones de eventos de los controles. Los warnings en el código fuente que has compartido, los cuales eran cerca de 850 los he ignorado todos, muchos de ellos se deben a estar utilizando miembros considerados obsoletos en la librería de clases de .NET Framework y a fin de cuentas no parecen entrar en conflicto con el funcionamiento de la aplicación.

...Casi toda la reconstrucción consistió en escribir pequeños algoritmos de parsing y edición de texto.

Este es el resultado final en el diseñador de Forms:



Y así es como se ve la interfáz de usuario tras compilar y ejecutar:



( por los colores oscuros no te preocupes, se ven así por que estoy utilizando un tema visual de terceros en Windows ... )

Aquí tienes el proyecto con las modificaciones que he realizado, en Visual Studio 2017.

• http://www.mediafire.com/file/74a2ajsxyebpdeb/LOTERIA+-+reconstructed.zip

Que aproveche .

Saludos!

[Alemán]

Hola!

Me he asustado al ver esto escrito en uno de tus programas: "Elektronisches Post"... no me me entero del Alemán , pero ya veo que eso significa "Correo electrónico".

En fin, todo lo que sea compartir me parece estupendo , gracias por tu colaboración. Eso sí, los que no entiendan de Alemán... lo van a tener dificil para comprender y analizar algunas partes de tu código, jeje.

Saludos!

[NEBIRE]

Es mi naturaleza no entender codigos. Es mi naturaleza tratar de seguir programando, sin entender  codigos. Perdon. Yo no tuve la posibilidad de hacer un curso. Tu si? Elektro?

Te limitaste bastante en hacerme criticas.

¿En realidad eso es lo que te pareció, que te hice críticas?. Dime que cosa te he criticado yo en todo el comentario que te respondí, de verdad, vuelve a leerlo, y dímelo, por que yo no consigo verlo.

Aquí estamos para intentar ayudar a los demás en su aprendizaje o a resolver problemas en sus códigos, no para criticar a nadie. Otra cosa bien distinta es que para que un programador pueda mejorar en lo que hace, hay que resaltarle los fallos que ha cometido en su código ...o las cosas que podría mejorar de éste, aunque eso tampoco sería una crítica como tal, sino una recomendación, pero claro, si a ti te da por tomártelo de forma negativa como si te estuviesen criticando, pues... macho, no era mi intención.

Es posible que el compañero @NEBIRE se haya excedido un poquito en hacer críticas, pero no me metas a mi en el mismo saco cuando sabes perfectamente que no te he criticado, y además a fin de cuentas las críticas de @NEBIRE fueron con la intención de ayudarte (y son comprensibles, por que simplemente hiciste un copy&paste del código que yo te mostré, sin saber muy bien lo que estabas haciendo, y ojo, no estoy criticando, solo estoy explicando el motivo de por qué me parece comprensiva su reacción).

Revisar las librerias de Visual Studio? No las entiendo.

En la página web de MSDN (Microsoft Developer Network), que es la referencia online oficial de la API/lirbería de clases de .NET Framework, y un lugar para el aprendizaje de todos los conceptos relacionados con la programación en general, aparte del aprendizaje completo de .NET Framework y de los lenguajes soportados por éste, pues allí te explican punto por punto el propósito/funcionalidad de cada uno de los miembros existentes en la librería de clases de .NET Framework, y en la mayoría de las ocasiones además incluyen ejemplos de código y documentados al pie de página. Por ese motivo, el echo de "no entender" no es una excusa aceptable teniendo a nuestra entera disposición una fuente de información y recursos tan amplia y detallada como la MSDN.

Te recomiendo echarle un vistazo a este comentario en donde encontrarás recursos de información para iniciarse en el aprendizaje de C# y .NET en general:

• Manuales de .NET | foro.elhacker.net

( no te pierdas tampoco los enlaces a la librería de códigos de Microsoft, donde encontrarás muchos códigos profesionales escritos en C#, que puedes analizar para aprender buenos hábitos y técnicas avanzadas de programación en general. )

Depurar el codigo? No puedo. Aprender eso? Tampoco.

¿No puedes, o no sabes, o quizás no te apetece?; en el segundo caso siempre puedes empezar a aprender... con tiempo y dedicación, y tampoco mucho empeño, no te creas, en realidad la depuración no es algo que te vaya a resultar muy complejo de entender y de efectuar... al menos de forma básica, y eso ya te será de mucha utilidad.

Me remito a las palabras que ya dije más arriba: el echo de "no poder" o no saber, no es un motivo aceptable teniendo la MSDN.

Te dejo por aquí unas guías de introducción con las que puedes aprenderlo todo lo relacionado con la depuración y el depurador de código en Visual Studio de principio a fin:

• Debugging in Visual Studio | MSDN
• Feature Tour of the Visual Studio Debugger | docs.microsoft.com

Es mi naturaleza tratar de seguir programando, sin entender  codigos.

Quizás me puedo equivocar al decirte lo siguiente, por que obviamente no te conozco ni puedo leerte el pensamiento, lo siento, pero no es una crítica:

Por todo lo que has dicho y de la manera en la que lo expresas, me transmites la sensación de que tú prefieres aprender a base de fallos, o dicho de otra manera aprender mediante el ensayo y error (o trial and error), me explico: encontrarse con un nuevo problema a resolver (ej. añadir elementos a una lista), en el que debes recurrir a la utilización de un miembro/método/concepto desconocido para ti, y al ponerlo en práctica ves que te sale mal, te da un fallo o no te da el resultado esperado, y entonces te ves en la necesidad de recurrir a la experiencia/ayuda de otras personas, entonces copias y pegas códigos esperando que eso resuelva tu problema específico, y si no lo resuelve y te da fallo entonces ponerte a buscar otro "parche" hasta poder resolverlo definitivamente, y esa no es ni de lejos una forma práctica de aprender ni de programar. Primero deberías documentarte sobre "X", comprender su propósito y todo lo que lo esté relacionado con su implementación (por ejemplo, si quisieramos documentarnos sobre el uso de la clase List, empezariamos por leer por encima las descripciones de todos los miembros/métodos públicos expuestos en dicha clase para tener una pequeña idea de qué podemos hacer con todo ello, y documentarnos más en profundidad sobre colecciones, Generics, enumeradores, y tampoco estaría de más: LINQ/LINQ to Objects), leer todo lo que haya que leer sobre él, vaya, y luego (no antes) poner en práctica lo estudiado sobre ese "X".



De verdad, no me gustaría que este tema se "cerrase" de una forma tan negativa por el tema que dijiste de las criticas, me sabe mal. @TickTack, no se muy bien si realmente debo darme aludido en el tema de criticarte, por que no me queda claro si te diriges a mi, o a @NEBIRE, o a los dos, pero bueno, no te he criticado, y lo que haya hecho o dicho @NEBIRE te lo habrá dicho con buena intención. Si tienes cualquier otra duda aquí estare(mos) para intentar ayudarte, no lo dudes.

Un saludo!

ahora como le hago para meter lo que contiene el array v a una matrix de (9,9) en una fila  como en la foto

Por mi parte ya he escrito y te he mostrado un código (en forma de extensión de método) que hace exactamente eso. ¿lo leiste?.

tampoco quiero convertirlo a integer que es el código que me pusistes Elecktro

Irrelevante. El primer código de ejemplo que te mostré, es eso, un ejemplo que puedes adaptar a tus necesidades, pero de todas formas en el ejemplo que deberías fijarte es en el segundo ejemplo que te mostré... con las tres primeras lineas resaltadas en otro color.

Saludos

[collection(indexer)]

declaro una matriz de 1x10 así

Código (vbnet) [Seleccionar] Expandir


dim matriz(1,9) as string


En realidad eso no es 1x10, sino 2x10 (2 filas, 10 columnas). Ten presente que el índice siempre empieza por Cero para cualquier dimensión del Array e indexador en general ( collection(indexer) ).

Antes de proseguir con más explicaciones ...¿estás seguro de que no será esto lo que realmente pretendes lograr?:

Código (vbnet) [Seleccionar] Expandir

Dim str As String = "0-1-2-3-4-5-6-7-8-9"
Dim arr As Integer() = Array.ConvertAll(str.Split({"-"c}, StringSplitOptions.RemoveEmptyEntries), Function(s As String) Integer.Parse(s))

Es decir, partir una cadena de texto en base a un caracter delimitador, y transformar la secuencia de elementos resultantes en un Array unidimensional de enteros (una secuencia de diez elementos, arr(0) hasta arr(9)).

Me da la sensación de que eso es lo que en realidad quieres conseguir pero le diste demasiadas vueltas de tuerca innecesarias, por que básicamente la idea de construir un Array 2D con solo 1 índice o fila, tendrá practicamente el mismo efecto que si creases un array unidimensional ( Dim arr As Integer() = {1, 2, 3, etc...} ). A lo mejor me equivoco y realmente lo que pretendes es crear un Array 2D con más de 1 "fila", no lo se, simplemente te propongo la sugerencia de arriba por que yo no le encuentro sentido práctico alguno a hacer lo que estás haciendo en el ejemplo de código que has mostrado... pero puede que el código original no lo hayas mostrado y sea bien distinto (donde realmente si que necesites usar un array bidimensional), como ya digo, no lo sé.



¿Cual es el problema que le encuentras a tener que escribir tres miserables lineas para un búcle?; en la mayoría de los casos la escritura de un búcle es la forma más eficiente de que implementemos ciertos algoritmos (y en este caso, probablemente sea la única forma también). Si me dijeras que la escritura de ese búcle es una tarea repetitiva que debes escribir en otras partes del código fuente, pues aun te entendería, pero al parecer das a entender que solo lo tienes que escribir una única vez ese búcle en tu código fuente...
De todas formas si te incomoda tener que escribir tres lineas para un For, entonces siempre puedes decorar la lógica del algoritmo en una función rehutilizable de uso genérico para no tener que volver a escribirlo en el futuro nunca más y así optimizar tu productividad, por ejemplo de esta forma que he ideado para ti:

Código (vbnet) [Seleccionar] Expandir

<HideModuleName>
Public Module RectangularIndexedArrayExtensions ' Two dimensional indexed array extensions

   ''' ----------------------------------------------------------------------------------------------------
   ''' <summary>
   ''' Fills the indices (or columns) of the specified index bound (or row) of the source array,
   ''' using the given collection of elements.
   ''' </summary>
   ''' ----------------------------------------------------------------------------------------------------
   ''' <typeparam name="T">
   ''' The <see cref="Type"/> of the source array.
   ''' </typeparam>
   '''
   ''' <param name="sender">
   ''' The source array.
   ''' </param>
   '''
   ''' <param name="boundIndex">
   ''' The bound index (or row) of the first dimension in the source array.
   ''' </param>
   '''
   ''' <param name="collection">
   ''' A collection of elements to fill the indices (or columns) of the second dimension in the source array.
   ''' </param>
   ''' ----------------------------------------------------------------------------------------------------
   ''' <exception cref="IndexOutOfRangeException">
   ''' The specified 'boundIndex' value is greater than the bounds of the first dimension in the source array.
   ''' or
   ''' The amount of elements in 'collection' is greater than the bounds of the second dimension in the source array.
   ''' </exception>
   ''' ----------------------------------------------------------------------------------------------------
   <Extension>
   Public Sub FillBounds(Of T)(ByRef sender As T(,), ByVal boundIndex As Integer, ByVal collection As T())

       Dim dim2Length As Integer = sender.GetLength(1)

       If (sender.GetUpperBound(0) < boundIndex) Then
           Throw New IndexOutOfRangeException(
               message:="The specified 'boundIndex' value is greater than the bounds of the first dimension in the source array.")
       End If

       If (dim2Length < collection.Count) Then
           Throw New IndexOutOfRangeException(
               message:="The amount of elements in 'collection' is greater than the bounds of the second dimension in the source array.")
       End If

       For i As Integer = 0 To (dim2Length - 1)
           sender(boundIndex, i) = collection(i)
       Next i

   End Sub

End Module

Modo de empleo:

Código (vbnet,1,2,3) [Seleccionar] Expandir

Dim str As String = "0-1-2-3-4-5-6-7-8-9"
Dim arr2D(0, 9) As String
arr2D.FillBounds(0, str.Split({"-"c}, StringSplitOptions.RemoveEmptyEntries))

For i As Integer = 0 To (arr2D.GetLength(1) - 1)
   Debug.WriteLine(arr2D(0, i))
Next

Flamer, en serio, yo te sugiero intentar no caer en el error o malos habitos de querer evitar la escritura de búcles como tal, eso son gilipolleces. Con la simplificación de código, en el sentido de los búcles, ganarás elegancia, reduciras la escritura de algunas lineas de código, pero al mismo tiempo perderás eficiencia (en terminos de velocidad de ejecución de código) y también las ventajas de poder realizar una correcta depuración de código con o sin breakpoints... por ejemplo al simplificar el bloque de código de un búcle de 5 lineas, a una consulta LINQ equivalente y de 1 linea.

Bueno, espero que el código de arriba te haya servido de ayuda, y con todo lo demás que ya te dijo el compañero @NEBIRE.

EDITO:

NEBIRE no me entendiste?

sin un bucle for
y si es posible meterlo ala matriz con el comando split

Disculpadme los dos por entrometerme en vuestra conversación, pero... Flamer, sinceramente a mi me parece que ni tan siquiera has llegado a leer el post de @NEBIRE... o el que no lo has entendido en todo caso eres tú, por que basicamente él te da respuesta y explicación detallada a todas esas dudas. Si yo fuese él, me cabrearía si alguien me respondiese lo que has respondido tú xD.

Saludos!