Mensajes

Tantos Troll hay foro coche ?  

Muchos más trolls de los que podamos imaginar.

Supuestamente (y esto es especulación, por que yo no tengo acceso a forocoches) los usuarios de forocoches planifican troleadas masivas de vez en cuando. Recuerdo un antiguo post que hablaba sobre una troleada que hicieron en un concurso de las galletas tostarica, donde niños pequeños enviaban sus dibujos y no recuerdo exactamente que pasó pero todos los usuarios de forocoches se pusieron a votar por un dibujo en concreto...

Yo creo que los administradores de ese foro no tienen dos dedos de frente, por que si siguen jodiendo al "sistema" por aquí y por allá a pequeñas empresas y ahora a la televisión, muy poco les va a durar el negocio por muy famoso que sea ese foro y por muchos años que siga en pie, al final un pequeño grupo de "mandamases" de distintas industrias se pondrán en contra de este foro por que no dejan de perjudicarlos, y acabarán muy mal. Pero bueno, esto es solo mi opinión.

saludos!

• Namespaces (C# Programming Guide) - MSDN
• Using Namespaces (C# Programming Guide) - MSDN
• Understanding and Using Namespaces in .NET - MSDN
  
• using Directive (C# Reference) - MSDN

[El otro día]

Parece que ese código es muy antiguo y no hay manera de hecharlo a andar.

Pero alma de cántaro, ¿tú lees las respuestas que te doy?:

El otro día me puse a escribirte un código

Supongo que tampoco te has parado a leer el código:

// Author   : Elektro
// Modified : 16-March-2017

Y mira que lo he intentado.

Los errores que has mostrado no tienen nada que ver con un mal funcionamiento del código. Tan solo tienes que añadir una referencia al ensamblado System.Management y el "using" necesario para importar el namespace de la clase que compartí, y ya podrás correr ese código para probarlo en condiciones.

Saludos

Hola:

Parece que va cogiendo forma, aún así hay dos errores que no me deja en paz.

Código (vbnet) [Seleccionar] Expandir

AddHandler Puerto_serie.DataReceived, AddressOf Me.Puerto_serie_DataReceived

Concretamente el Me.
https://msdn.microsoft.com/es-es/library/20fy88e0.aspx

Declara un método a nivel de clase, llámalo  "Puerto_serie_DataReceived" y úsalo para controlar el evento Puerto_serie.DataReceived.

En mi respuesta de arriba te puse un ejemplo de eso mismo.

Otro error es este:

Código (vbnet) [Seleccionar] Expandir

Gravedad Código Descripción Proyecto Archivo Línea Estado suprimido
Error BC30420 No se encontró 'Sub Main' en 'Recibir_archivo_desde_Arduino_consola_VB.Module1'. Recibir_archivo_desde_Arduino_consola_VB C:\Users\Usuario\documents\visual studio 2017\Projects\Recibir_archivo_desde_Arduino_consola_VB\Recibir_archivo_desde_Arduino_consola_VB\vbc 1 Activo


Llevo tiempo traquiniando y no lo campto.

El módulo principal de tu aplicación de consola necesita tener un punto de entrada (EntryPoint), tal y como en C#.

Código (vbnet) [Seleccionar] Expandir

Module Module1

    Public Sub Main()
        ' ...
    End Sub

End Module

Saludos

Ya que estamos...

¿Alguien tiene una invitación para forocoches?

[cheatengine.lpi]

Hola.

Primero que nada, si pretendes experimentar con el código fuente de Cheat Engine, entonces descárgate el código de la última versión (v6.6) desde el respositorio oficial en GitHub:

• https://github.com/cheat-engine/cheat-engine/releases/latest

Segundo, un programa no se suele componer de un único archivo, sino de múltiples archivos que representan las distintas ventanas, controles y diálogos de la aplicación, entre otras cosas.

Tercer y último punto, Cheat Engine está desarrollado con la IDE de Lazarus, lo cual hablando con propiedad de la palabra no es lo mismo que Delphi, ni la IDE Delphi, ni el lenguaje Delphi como tal; el Pascal que usa Delphi es distinto. Aparte, en ese video que has compartido el autor muestra la IDE Delphi 7, la cual tiene ya una década y media... es posible que esa persona haya descargado algún código fuente del cheat engine muy  antiguo que haya sido desarrollado en esa versión ya obsoleta de Delphi, lo cierto es que no lo sé, pero las versiones actuales de Cheat Engine no están desarrolladas en la IDE de Delphi.

En resumen: Descárgarte Lazarus (no Delphi / Embarcadero), y abre el archivo de proyecto principal cheatengine.lpi, ahí te saldrán todas o casi todas las ventanas con sus controles y podrás localizar y editar las cadenas de texto que desees.

Si prefieres realizar una edición más "manual" entonces puedes cojer tu editor de texto favorito y abrir los archivos con extensión .lfm (Lazarus Form) para modificar las las propiedades de texto de los controles.

¡Saludos!

Entonces la conclusión para ti sería que que no se puede pensar racionalmente sin poder ver ni oir

No mezclemos las cosas. Poder utilizar la mente para interpretar algo usando como punto de referencia un idioma y/o una imagen NO es pensar racionálmente solo por que otra persona carezca de esos puntos de referencia para interpretar lo mismo. Sencillamente esa otra persona lo interpretará usando otras cosas distintas, y quizás incluso a veces puedan ser más efectivas, de ahí que ciertos sentidos puedan ser mejor desarrollados por un ciego o un sordo, que por una persona como tú o yo.

osea que el pensamiento no es algo innato sino adquirido, ¿no?

¿Acaso conoces a alguna persona que carezca de la acción de pensamiento?. La habilidad de pensar es algo connatural al ser humano, y si nos vamos a la más pura especulación entonces también podriamos añadir que todas las formas de vida (desde los mamíferos hasta las plantas o una piedra y objetos inanimados) son una mente pensante antes que otra cosa.

¡Saludos!

[AddHandler]

El código es muy grande y no traduce bien todo. Voy partes por partes como este y este no convierte.

Código (vbnet) [Seleccionar] Expandir

Puerto_serie.DataReceived += New SerialDataReceivedEventHandler(DataReceivedHandler)

En VB.NET, para asociar eventos en tiempo de ejecución se hace con las sentencias AddHandler y AddressOf.

Código (vbnet) [Seleccionar] Expandir

AddHandler Puerto_serie.DataReceived, AddressOf Me.Puerto_serie_DataReceived

Pero a diferencia de C# en VB.NET esto es algo opcional, no es necesario asociarlo de esa manera a menos que el objeto en cuestión haya sido creado en tiempo de ejecución. En su lugar puedes usar al keyword Handles:

Código (vbnet) [Seleccionar] Expandir

Private Sub Puerto_serie_DataReceived(ByVal sender As Object, ByVal e As DataReceivedHandler) Handles Puerto_serie.DataReceived
   ' ...
End Sub

Código (csharp) [Seleccionar] Expandir

string[] data = indata.Split('A');

Código (vbnet) [Seleccionar] Expandir

Dim data As String() = indata.Split("A"c)

Esto ni siquiera tiene que ver con VB.NET. No existe ninguna sobrecarga del método String.Split en cuya firma acepte un caracter como parámetro, sino un array de caracteres. Al escribir "A"c se casteará automáticamente y puedes llamarlo así, pero no es un buen hábito hacerlo ya que no estás evitando el factor de error humano...

Código (csharp) [Seleccionar] Expandir

string[] data = indata.Split(new char[] { 'A' });

Código (vbnet) [Seleccionar] Expandir

Dim data As String() = indata.Split( { "A"c } )

Hay otra parte del código que traduce bien en teoría, pero hay muchos peros, da errores en VB .net.

A diferencia de C#, en VB.NET las cadenas de texto se concatenan usando el operador &, no +, el cual es un operador aritmético de suma. Se puede concatenar en ciertas circunstancias pero dará problemas ya que no es su propósito.

Aparte de eso, en VB.NET no es necesario escribir al final la sentencia Exit Select (break en C#). La instrucción ya va implícita en el código compilado.

Código (vbnet) [Seleccionar] Expandir

' Dim cantidadBytes As Integer

Dim sp As SerialPort = DirectCast(sender, SerialPort)
Dim indata As String = sp.ReadExisting()
Dim data As String() = indata.Split({"A"c})
cantidadBytes = Integer.Parse(data(0))

Select Case data(1).ToString()

   Case "1"
       Console.WriteLine("Tamaño: " & cantidadBytes & " Bytes.")
       Console.WriteLine("Foto: " & data(1) & ". Tipo de archivo: JPG")

   Case "2"
       Console.WriteLine("Tamaño: " & cantidadBytes & " Bytes.")
       Console.WriteLine("Foto: " & data(1) & ". Tipo de archivo: PNG.")

   Case Else
       Console.WriteLine("Cosas raras en 'data': " & data.ToString())

End Select

De todas formas tanto en C# como en VB.NET la concatenación tradicional (y fea) de strings puedes evitarlo, utilizando el método String.Format():

Código (vbnet) [Seleccionar] Expandir

Console.WriteLine(String.Format("Foto: {0}. Tipo de archivo: {1}.", data(1) ,"PNG"))


Todo lo que estás preguntando son cosas básicas que podrías averiguar con dos minutos en Google o leyendo la referencia de VB.NET y su modo de empleo en MSDN, hay ejemplos para todo.

[__InstanceModificationEvent]

si es posible que al meter la bandeja con la mano o pulsar el botón físicamente del lector, C# puede saber su estado, cunado está abierto y cuando está cerrado.

Si. Si el sistema operativo puede saberlo, tú desde C# / VB.NET / .NET puedes saberlo también.

Lo más sencillo sería subscribirse a un evento del instrumental de Windows (WMI) para notificar sobre cambios de hardware del tipo CD-ROM.

El otro día me puse a escribirte un código, pero tengo el lector del DVD-ROM jodido así que al final no he podido probarlo.

Lee sobre la clase de evento de WMI __InstanceModificationEvent, y la clase Win32_LogicalDisk:

• https://msdn.microsoft.com/en-us/library/aa394651(v=vs.85).aspx
• https://msdn.microsoft.com/en-us/library/aa394173(v=vs.85).aspx

En fin, la teoría sería esta:

Código (csharp) [Seleccionar] Expandir

// ***********************************************************************
// Author   : Elektro
// Modified : 16-March-2017
// ***********************************************************************

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Management;

#region " Public Members Summary "

#region " Constructors "

// New(String)
// New(String, Single)
// New(String, String, Single)
// New(String, String, String(), UInteger)
// New(SelectQuery)
// New(SelectQuery, Single)
// New(SelectQuery, UInteger)

#endregion

#region " Events "

// EventArrived As EventArrivedEventHandler

#endregion

#region " Methods "

// Start()
// Stop()
// Dispose()

#endregion

#endregion

#region " WMI Event Watcher "

namespace Types {

   /// ----------------------------------------------------------------------------------------------------
   /// <summary>
   /// A WMI event monitor that notifies about event arrivals for the subscribed event class.
   /// </summary>
   /// ----------------------------------------------------------------------------------------------------
   [DesignerCategory("Code")]
   [ImmutableObject(false)]
   public class WMIEventWatcher : ManagementEventWatcher {

       #region " Constructors "

       /// ----------------------------------------------------------------------------------------------------
       /// <summary>
       /// Prevents a default instance of the <see cref="WMIEventWatcher"/> class from being created.
       /// </summary>
       /// ----------------------------------------------------------------------------------------------------
       [DebuggerNonUserCode()]
       private WMIEventWatcher() {}

       /// ----------------------------------------------------------------------------------------------------
       /// <summary>
       /// Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
       /// </summary>
       /// ----------------------------------------------------------------------------------------------------
       /// <param name="eventClassName">
       /// The name of the WMI event class to subscribe for.
       /// </param>
       /// ----------------------------------------------------------------------------------------------------
       [DebuggerStepThrough()]
       public WMIEventWatcher(string eventClassName) :
           this(eventClassName, string.Empty, withinInterval: 1f) {}

       /// ----------------------------------------------------------------------------------------------------
       /// <summary>
       /// Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
       /// </summary>
       /// ----------------------------------------------------------------------------------------------------
       /// <param name="eventClassName">
       /// The name of the WMI event class to subscribe for.
       /// </param>
       ///
       /// <param name="withinInterval">
       /// The interval, in seconds, that WMI will check for changes that occur to instances of the events of the
       /// specified class in the <paramref name="eventClassName"/> parameter.
       /// </param>
       /// ----------------------------------------------------------------------------------------------------
       [DebuggerStepThrough()]
       public WMIEventWatcher(string eventClassName, float withinInterval) :
           this(eventClassName, condition: string.Empty, withinInterval: withinInterval) {}

       /// ----------------------------------------------------------------------------------------------------
       /// <summary>
       /// Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
       /// </summary>
       /// ----------------------------------------------------------------------------------------------------
       /// <param name="eventClassName">
       /// The name of the WMI event class to subscribe for.
       /// </param>
       ///
       /// <param name="condition">
       /// The condition to be applied to events of the specified class in the
       /// <paramref name="eventClassName"/> parameter.
       /// </param>
       ///
       /// <param name="withinInterval">
       /// The interval, in seconds, that WMI will check for changes that occur to instances of the events of the
       /// specified class in the <paramref name="eventClassName"/> parameter.
       /// </param>
       /// ----------------------------------------------------------------------------------------------------
       [DebuggerStepThrough()]
       public WMIEventWatcher(string eventClassName, string condition, float withinInterval) {
           base.Query = new WqlEventQuery(eventClassName: eventClassName,
                                          condition: condition,
                                          withinInterval: TimeSpan.FromSeconds(withinInterval));
       }

       /// ----------------------------------------------------------------------------------------------------
       /// <summary>
       /// Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
       /// </summary>
       /// ----------------------------------------------------------------------------------------------------
       /// <param name="eventClassName">
       /// The name of the WMI event class to subscribe for.
       /// </param>
       ///
       /// <param name="condition">
       /// The condition to be applied to events of the specified class in the
       /// <paramref name="eventClassName"/> parameter.
       /// </param>
       ///
       /// <param name="groupByPropertyList">
       /// The properties in the event class by which the events should be grouped.
       /// </param>
       ///
       /// <param name="groupWithinInterval">
       /// The interval, in seconds, of the specified interval at which WMI sends one aggregate event,
       /// rather than many events.
       /// </param>
       /// ----------------------------------------------------------------------------------------------------
       [DebuggerStepThrough()]
       public WMIEventWatcher(string eventClassName, string condition, string[] groupByPropertyList, uint groupWithinInterval) {
           base.Query = new WqlEventQuery(eventClassName: eventClassName,
                                          condition: condition,
                                          groupWithinInterval: TimeSpan.FromSeconds(groupWithinInterval),
                                          groupByPropertyList: groupByPropertyList);
       }

       /// ----------------------------------------------------------------------------------------------------
       /// <summary>
       /// Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
       /// </summary>
       /// ----------------------------------------------------------------------------------------------------
       /// <param name="query">
       /// The WMI select query of the event class to subscribe for.
       /// </param>
       /// ----------------------------------------------------------------------------------------------------
       [DebuggerStepThrough()]
       public WMIEventWatcher(SelectQuery query) :
           this(query.ClassName, condition: query.Condition, withinInterval: 1f) {}

       /// ----------------------------------------------------------------------------------------------------
       /// <summary>
       /// Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
       /// </summary>
       /// ----------------------------------------------------------------------------------------------------
       /// <param name="query">
       /// The WMI select query of the event class to subscribe for.
       /// </param>
       ///
       /// <param name="withinInterval">
       /// The interval, in seconds, that WMI will check for changes that occur to instances of the events of the
       /// specified class in the <paramref name="query"/> parameter.
       /// </param>
       /// ----------------------------------------------------------------------------------------------------
       [DebuggerStepThrough()]
       public WMIEventWatcher(SelectQuery query, float withinInterval) :
           this(query.ClassName, condition: query.Condition, withinInterval: withinInterval) {}

       /// ----------------------------------------------------------------------------------------------------
       /// <summary>
       /// Initializes a new instance of the <see cref="WMIEventWatcher"/> class.
       /// </summary>
       /// ----------------------------------------------------------------------------------------------------
       /// <param name="query">
       /// The WMI select query of the event class to subscribe for and its selected properties.
       /// </param>
       ///
       /// <param name="groupWithinInterval">
       /// The interval, in seconds, of the specified interval at which WMI sends one aggregate event,
       /// rather than many events.
       /// </param>
       /// ----------------------------------------------------------------------------------------------------
       [DebuggerStepThrough()]
       public WMIEventWatcher(SelectQuery query, uint groupWithinInterval) {
           string[] strArray = new string[query.SelectedProperties.Count];
           query.SelectedProperties.CopyTo(strArray, index: 0);
           base.Query = new WqlEventQuery(eventClassName: query.ClassName,
                                          condition: query.Condition,
                                          groupWithinInterval: TimeSpan.FromSeconds(groupWithinInterval),
                                          groupByPropertyList: strArray);
       }

       #endregion

   }

}

#endregion


Código (csharp) [Seleccionar] Expandir

using System;
using System.Data;
using System.IO;
using System.Linq;
using System.Management;
using System.Windows.Forms;
using Types;

namespace WindowsFormsApplication4
{
   public partial class Form1 : Form {

       public Form1() {
           InitializeComponent();
           this.FormClosing += this.Form1_FormClosing;
           this.Load += this.Form1_Load;
       }

       private WMIEventWatcher eventWatcher =  new WMIEventWatcher("__InstanceModificationEvent",
                               @"TargetInstance ISA 'Win32_LogicalDisk' and TargetInstance.DriveType = 5", 1f);

       private void Form1_Load(object sender, EventArgs e) {
           this.eventWatcher.EventArrived += this.EventWatcher_EventArrived;
           this.eventWatcher.Scope = new ManagementScope(@"root\CIMV2", new ConnectionOptions { EnablePrivileges = true });
           this.eventWatcher.Start();
       }

       private void Form1_FormClosing(object sender, FormClosingEventArgs e) {
           this.eventWatcher.Dispose();
       }

       private void EventWatcher_EventArrived(object sender, EventArrivedEventArgs e) {

           PropertyData pd = e.NewEvent.Properties["TargetInstance"];

           if ((pd != null)) {

               using (ManagementBaseObject mo = (ManagementBaseObject)pd.Value) {

                   string name = Convert.ToString(mo.Properties["Name"].Value);
                   // string label = Convert.ToString(mo.Properties["VolumeName"].Value);

                   DriveInfo di = (from item in DriveInfo.GetDrives()
                                   where string.IsNullOrEmpty(item.Name)
                                   select item).Single();

                   if (!string.IsNullOrEmpty(di.VolumeLabel)) {
                       Console.WriteLine(string.Format("CD has been inserted in drive {0}.", di.Name));

                   } else {
                       Console.WriteLine(string.Format("CD has been ejected from drive {0}.", di.Name));

                   }

               }

           }

       }

   }
}

Saludos

[método]

Para aclarar las cosas:
No es una función ni tampoco un evento, sino un método... Sub sería el equivalente a void en C# (un bloque de código que no devuelve un valor de retorno).

En VB.NET no se utiliza la sentencia Call para nada, eso es de VB. Cabe mencionar que también se puede utilizar en VB.NET, pero si existe es solo por motivos de compatibilidad. Nadie lo usa.

Lo he intentado llamar directamete así y no funciona.

Código (vbnet) [Seleccionar] Expandir

mensaje1()

No sirve.

Lo estás llamando correctamente. El problema probablemente sea que la clase donde declaraste ese método tenga un nivel de acceso inferior a la clase desde donde lo estés intentando llamar, o que no hayas instanciado la clase donde declaraste dicho método. Corrije el nivel de visibilidad del método y/o de la clase (ej. Public Shared Sub MiMetodo()).

De todas formas no somos adivinos, no sé que significa "no funciona" o "no sirve". Muestra el mensaje de error por lo menos. Esto ya deberías tenerlo más que presente como usuario habitual del foro de programación, proporciona los detalles necesarios. Muestra la definición de la clase o del módulo donde tengas declarado ese método.

EDITO:
Formas en las que puedes llamar a ese método:

Código (vbnet) [Seleccionar] Expandir

<HideModuleName>
Public Module MyModule1

   Public Sub MyMethod()
   End Sub

End Module

Código (vbnet) [Seleccionar] Expandir

MyModule1.MyMethod()

Código (vbnet) [Seleccionar] Expandir

Public NotInheritable Class MyClass1

   Public Sub New()
   End Sub

   Public Sub MyMethod()
   End Sub

End Class

Código (vbnet) [Seleccionar] Expandir

Dim instance As New MyClass1()
instance.MyMethod()

Código (vbnet) [Seleccionar] Expandir

Public NotInheritable Class MyClass2

   Private Sub New()
   End Sub

   Public Shared Sub MyMethod()
   End Sub

End Class

Código (vbnet) [Seleccionar] Expandir

MyClass2.MyMethod()

¡Saludos!