elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: ¿Eres nuevo? ¿Tienes dudas acerca del funcionamiento de la comunidad? Lee las Reglas Generales


  Mostrar Mensajes
Páginas: 1 2 3 4 [5] 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ... 1054
41  Programación / .NET / Re: textbox con autocompletar desde la tercera letra? en: 9 Enero 2018, 14:42
como hago barra ese botón de la parte inferior redondeadao en su defecto evitar que se redimensione (cambie su tamaño con el mouse al hacerle clic)

Es así por diseño, no puedes configurar (no de forma administrada) ese comportamiento. Si consiguieras obtener el controlador de la ventana del menú de autocompletado, con el consiguiente P/Invoking a la APi de Windows que ello implicaria, entonces si podrías, pero no te merece la pena el esfuerzo...


Si realmente consideras necesario imposibilitar el redimensionado de la ventana de autocompletado, entonces en mi opinión sería mucho más factible que utilizases implementaciones de terceras personas... como por ejemplo podría ser esta de aquí abajo que al parecer no tiene ese grip para redimensionar la ventana:


Saludos.
42  Programación / .NET / Re: Duda carga de objetos POO en: 9 Enero 2018, 13:48
No sé si es una manera correcta de trabajar, o es mejor cargar los Puestos y según necesite ir cargando y descargando las listas. Si quisiera cargar todos los puestos, tendría en memoría muchísimos datos, y no sé si eso está bien.

Es precisamente por esa necesidad que existe la interfáz IEnumerable<T> (o IEnumerable(Of T) en VB.NET) de evaluación vaga y el tipo Lazy<T> (o Lazy(Of T) en VB.NET) para la inicialización/instanciación vaga de objetos.

La interfáz IEnumerable, o colección enumerable, provee lo que se conoce como un enumerador, que es un mecanismo para obtener el elemento actual en la colección enumerable, mover al siguiente elemento, y reiniciar. El enumerador solamente debe preocuparse por saber como obtener el siguiente elemento en la colección enumerable, por lo que no es necesario que la colección entera esté alojada en memoria ni saber cuantos elementos hay en total; este comportamiento o implementación se traduce en una optimización de varios aspectos, empezando por el más obvio: el consumo de memoria.

Practicamente todas las colecciones disponibles en los espacios de nombre de la librería de .NET Framework implementan la la interfáz IEnumerable, como los tipos List, Dictionary, Array, Stack, Collection y etcétera, pero ojo, eso no quiere decir que todos los tipos de colecciones sean de evaluación vaga, cada tipo tiene una implementación distinta para servir a un propósito específico, así que si quieres asegurarte de beneficiarte de la evaluación vaga entonces usa directamente la interfáz IEnumerable.

El tipo Lazy<T>, por lo general lo usarías en escenarios de programación asincrónica y para prevenir la inicialización de una instancia que sea bastante pesada... hasta que realmente necesites acceder/leer ese objeto.

Te recomiendo unas lecturas importantes para comprender los conceptos básicos:

Citar
Lazy initialization of an object means that its creation is deferred until it is first used. (For this topic, the terms lazy initialization and lazy instantiation are synonymous.) Lazy initialization is primarily used to improve performance, avoid wasteful computation, and reduce program memory requirements.

Citar
By initializing objects in a lazy manner, you can avoid having to create them at all if they are never needed, or you can postpone their initialization until they are first accessed



Bien, ahora que ya he explicado que es cada cosa, te mostraré como puedes reproducir las diferencias a través de varios ejemplos (básicos) basados en el escenario o problema que propones...

Primero de todo, para estos ejemplos crearemos un tipo como éste para representar la información básica de un cliente:

Código
  1. Public NotInheritable Class Customer
  2.  
  3.    Public Property Name As String
  4.    Public Property Surname As String
  5.    Public Property Buffer As Byte()
  6.  
  7.    Public ReadOnly Property InstanceId As Guid
  8.        Get
  9.            If (Me.instanceIdB = Guid.Empty) Then
  10.                Me.instanceIdB = Guid.NewGuid()
  11.            End If
  12.            Return Me.instanceIdB
  13.        End Get
  14.    End Property
  15.    Private instanceIdB As Guid
  16.  
  17.    Private Sub New()
  18.    End Sub
  19.  
  20.    Public Sub New(name As String, surname As String)
  21.        Me.Name = name
  22.        Me.Surname = surname
  23.        Me.Buffer = New Byte(4096) {}
  24.    End Sub
  25.  
  26.    Public Overrides Function ToString() As String
  27.        Return Me.InstanceId.ToString()
  28.    End Function
  29.  
  30. End Class

...es solo un ejemplo cualquiera, mi intención al escribir este ejemplo ha sido que una instancia del tipo Customer ocupe bastantes bytes.



Bien, por lo general, podriamos decidir crear una colección genérica de tipo List<T> (o List(Of T) en VB.NET) para almacenar varias instancias de la clase Customer, e iterar la colección para mostrar cualquier tipo de información de cada Customer, quedando algo parecido a esto:

Código
  1. Imports System
  2. Imports System.Collections.Generic
  3. Imports System.Threading
  4.  
  5. Public Module Module1
  6.  
  7.    Private customers As List(Of Customer)
  8.    Private customerCount As Integer
  9.  
  10.    Private Sub BuildCustomers(ByRef collection As List(Of Customer), ByVal amount As Integer)
  11.        If (collection Is Nothing) Then
  12.            collection = New List(Of Customer)
  13.        ElseIf (collection.Any) Then
  14.            collection.Clear()
  15.        End If
  16.  
  17.        For i As Integer = 0 To (amount - 1)
  18.            collection.Add(New Customer(String.Empty, String.Empty))
  19.        Next i
  20.    End Sub
  21.  
  22.    Public Sub Main()
  23.        ' Construimos la lista de clientes.
  24.        Module1.BuildCustomers(Module1.customers, 100000)
  25.        ' En este punto, la instanciación de todos los objetos en la colección
  26.        ' habrá alcanzado un consumo de memoria sobre los 500 megabytes aprox.
  27.  
  28.        ' Mostramos la cantidad de elementos en la lista
  29.        ' (la propiedad Count debe realizar una iteración completa, así que puede tardar unos segundos).
  30.        Console.WriteLine(String.Format("Customers Count: {0}", Module1.customers.Count))
  31.  
  32.        ' Iteramos cada elemento en la lista.
  33.        For Each c As Customer In Module1.customers
  34.            Console.WriteLine(String.Format("Customer {0}; Unique Id: {1}",
  35.                                            Interlocked.Increment(Module1.customerCount), c.ToString()))
  36.        Next c
  37.  
  38.        ' Ya no necesitamos la lista, así que liberarariamos recursos administrados innecesarios,
  39.        ' y forzamos una recolección del GarbageCollector para un efecto inmediato.
  40.        Module1.customers.Clear()
  41.        Module1.customers = Nothing
  42.        GC.Collect()
  43.        GC.WaitForPendingFinalizers()
  44.        GC.WaitForFullGCApproach()
  45.        GC.WaitForFullGCComplete()
  46.        ' En este punto, la carga de objetos en memoria se reduce al máximo posible,
  47.        ' en mi caso el consumo total es de 80 mb aprox.
  48.  
  49.        Console.WriteLine("Press any key to exit...")
  50.        Console.ReadKey(intercept:=True)
  51.        Environment.Exit(0)
  52.    End Sub
  53.  
  54. End Module

¿Qué ocurre con esto?, pues que todos los elementos de la colección se inicializan, se asigna un espacio en el bloque de memoria para cada elemento de la colección, y evidentemente si tenemos en cuenta el tamaño en bytes de una única instancia de la classe Customer pues... 100.000 instancias simultaneas resultan en un gran consumo de memoria...





Cuando un elemento Customer ha sido inicializado y ya hemos trabajado con él, no necesitamos que siga albergando espacio en memoria, queremos desechar ese consumo adicional que ya no necesitamos para nada, y aquí es donde .NET Framework nos ofrece la solución al problema: IEnumerable<T>.

Este código de aquí abajo es practicamente lo mismo que el anterior con el uso de List<T>, solo que ha sido adaptado para el uso de IEnumerable<T> mediante una función iteradora y así demostrar el beneficio que nos interesa obtener...

Código
  1. Imports System
  2. Imports System.Collections.Generic
  3. Imports System.Threading
  4.  
  5. Public Module Module1
  6.  
  7.    Private customers As IEnumerable(Of Customer)
  8.    Private customerCount As Integer
  9.  
  10.    Private Iterator Function BuildCustomers(ByVal amount As Integer) As IEnumerable(Of Customer)
  11.        For i As Integer = 0 To amount
  12.            Yield New Customer(String.Empty, String.Empty)
  13.        Next i
  14.    End Function
  15.  
  16.    Public Sub Main()
  17.        ' Construimos la colección de clientes.
  18.        Module1.customers = Module1.BuildCustomers(100000)
  19.        ' En este punto, el consumo de memoria es mínimo, alcanzando los 12 mb aprox.
  20.  
  21.        ' Mostramos la cantidad de elementos en la colección
  22.        Console.WriteLine(String.Format("Customers Count: {0}", Module1.customers.Count))
  23.  
  24.        ' Iteramos cada elemento en la colección.
  25.        For Each c As Customer In Module1.customers
  26.            Console.WriteLine(String.Format("Customer {0}; Unique Id: {1}",
  27.                                            Interlocked.Increment(Module1.customerCount), c.ToString()))
  28.        Next c
  29.        ' En este punto, el consumo de memoria es mínimo, sin cambios, puesto que al iterar, los elementos se han evaluado de forma vaga.
  30.  
  31.        Module1.customers = Nothing
  32.        Console.WriteLine("Press any key to exit...")
  33.        Console.ReadKey(intercept:=True)
  34.        Environment.Exit(0)
  35.    End Sub
  36.  
  37. End Module

El beneficio en la optimización del consumo de memoria queda bastante claro:





Te muestro un ejemplo para el uso del tipo Lazy:

Código
  1. Imports System
  2. Imports System.Collections.Generic
  3. Imports System.Threading
  4.  
  5. Public Module Module1
  6.  
  7.    Private lazyCustomers As List(Of Lazy(Of Customer))
  8.    Private customerCount As Integer
  9.  
  10.    Private Function BuildCustomers(ByVal amount As Integer) As List(Of Lazy(Of Customer))
  11.        Dim collection As New List(Of Lazy(Of Customer))
  12.        For i As Integer = 0 To amount
  13.            collection.Add(New Lazy(Of Customer)(
  14.                           Function() As Customer
  15.                               Return New Customer(String.Empty, String.Empty)
  16.                           End Function))
  17.        Next i
  18.        Return collection
  19.    End Function
  20.  
  21.    Public Sub Main()
  22.        ' Construimos la instancia de inicialización vaga con la colección de clientes.
  23.        Module1.lazyCustomers = Module1.BuildCustomers(100000)
  24.        ' En este punto, el consumo de memoria es mínimo, alcanzando los 12 mb aprox,
  25.        ' puesto que todavía NO hemos inicializado ningún elemento de la colección.
  26.  
  27.        Console.WriteLine(String.Format("Lazy Customers Count: {0}", Module1.lazyCustomers.Count))
  28.  
  29.        For Each lz As Lazy(Of Customer) In Module1.lazyCustomers
  30.            Console.WriteLine(String.Format("Customer {0}; Unique Id: {1}",
  31.                                            Interlocked.Increment(Module1.customerCount), lz.Value.ToString()))
  32.        Next lz
  33.        ' Cuando accedemos a la propiedad 'Lazy(Of T).Value' es cuando inicializamos el objecto de inicialización vaga,
  34.        ' así que al terminar la iteración hemos inicializaco todos los elementos, por lo que en este punto el consumo de memoria rondará los 500 megabytes aprox, como en el primer ejemplo.
  35.  
  36.        ' Ya no necesitamos la colección, así que liberarariamos recursos administrados innecesarios,
  37.        ' y forzamos una recolección del GarbageCollector para un efecto inmediato.
  38.        Module1.lazyCustomers.Clear()
  39.        Module1.lazyCustomers = Nothing
  40.        GC.Collect()
  41.        GC.WaitForPendingFinalizers()
  42.        GC.WaitForFullGCApproach()
  43.        GC.WaitForFullGCComplete()
  44.        ' En este punto, la carga de objetos en memoria se reduce al máximo posible,
  45.        ' en mi caso el consumo total es de 20 mb aprox.
  46.  
  47.        Console.WriteLine("Press any key to exit...")
  48.        Console.ReadKey(intercept:=True)
  49.        Environment.Exit(0)
  50.    End Sub
  51.  
  52. End Module



Por supuesto podemos combinar el tipo Lazy<T> e IEnumerable<T>:

Código
  1. Imports System
  2. Imports System.Collections.Generic
  3. Imports System.Threading
  4.  
  5. Public Module Module1
  6.  
  7.    Private lazyCustomers As IEnumerable(Of Lazy(Of Customer))
  8.    Private customerCount As Integer
  9.  
  10.    Private Iterator Function BuildCustomers(ByVal amount As Integer) As IEnumerable(Of Lazy(Of Customer))
  11.        For i As Integer = 0 To amount
  12.            Yield New Lazy(Of Customer)(
  13.                           Function() As Customer
  14.                               Return New Customer(String.Empty, String.Empty)
  15.                           End Function)
  16.        Next i
  17.    End Function
  18.  
  19.    Public Sub Main()
  20.        ' Construimos la instancia de inicialización vaga con la colección de clientes.
  21.        Module1.lazyCustomers = Module1.BuildCustomers(100000)
  22.        ' En este punto, el consumo de memoria es mínimo, alcanzando los 12 mb aprox,
  23.        ' puesto que todavía NO hemos inicializado ningún elemento de la colección.
  24.  
  25.        Console.WriteLine(String.Format("Lazy Customers Count: {0}", Module1.lazyCustomers.Count))
  26.  
  27.        For Each lz As Lazy(Of Customer) In Module1.lazyCustomers
  28.            Console.WriteLine(String.Format("Customer {0}; Unique Id: {1}",
  29.                                            Interlocked.Increment(Module1.customerCount), lz.Value.ToString()))
  30.            ' Cuando accedemos a la propiedad 'Lazy(Of T).Value' es cuando inicializamos el objecto de inicialización vaga.
  31.        Next lz
  32.        ' Al terminar la iteración, en este punto no hay cambios en el consumo de memoria,
  33.        ' puesto que hemos utilizado una colección enumerable.
  34.  
  35.        Module1.lazyCustomers = Nothing
  36.        Console.WriteLine("Press any key to exit...")
  37.        Console.ReadKey(intercept:=True)
  38.        Environment.Exit(0)
  39.    End Sub
  40.  
  41. End Module



IEnumerable y Lazy son dos propuestas para fines distintos, aunque combinables para un mismo fin, y yo solo te he mostado ejemplos básicos de su utilización en escenarios sincrónicos; al final la solución más óptima y adecuada a tu problema siempre dependerá de lo que realmente quieras hacer y como sea realmente necesario hacerlo...

Espero que esto haya servido de ayuda, al menos.

Saludos.
43  Foros Generales / Noticias / Re: Firefox 59 simplifica el control de notificaciones y tu privacidad en: 8 Enero 2018, 17:39
Ya pueden meterle al Chomefox este todos los ajustes personalizables de seguridad y privacidad que quieran hasta llegar a la versión 60, 70, 80, 90 y 100, que mientras sus desarrolladores no se dignen a implementar una API para la creación de toolbars como reclama toda la comunidad de desarrolladores de extensiones de Firefox para soportar la extensión Tabs Mix Plus (y cualquier otra extensión de personalización), le van a dar por culo a este navegador y a su tecnología web-extensions...


Saludos.
44  Foros Generales / Foro Libre / Re: Nomofobia. ¿Eres adicto al móvil? descúbrelo. en: 8 Enero 2018, 15:45
Curioso nombre, ¿se supone que "nomo" viene del latín como suelen hacer los científicos al ponerle nombre a las fobias y demás?, por que yo no le encuentro relación alguna entre "nomo" y teléfono móvil...

A ver si algún experto nos ilustra de donde viene eso de "nomo", creo que nisiquiera en la wikipedia hacen referencia a ello...

EDITO: pues si, si que lo explica en la wikipedia, y sabiendo ahora el significado, me parece una soberana gilipollez usar lo de "nomo" para describir una adicción de cualquier tipo...

Citar
The latter derives from the Greek nomos (a law, rule or regulation) seen in such other words as astronomy (rules about the stars), gastronomy (rules about food and eating), autonomy (ruling oneself), economy (rules governing the finances of the state or household), antinomy (a law contrary to another law), metronome (a device to regulate metre or beat), nomocracy (the rule of law in society), nomography (the law in written form), nomology (the study or science of law), nomothete (a lawgiver), and the archaic anomy (lawlessness). The neologistic meaning referred to in this article, relating to mobile phones, seems to have been adopted by the younger generations, and by those without a deeper understanding of the Oxford guidelines on word construction, in which typically Greek words are attached to Greek words (and Latin to Latin, etc.).

Saludos
45  Programación / .NET / Re: programar en C# con Visul Studio . en: 5 Enero 2018, 18:18
. . .

¿Tan siquiera has probado a hacer doble click sobre un archivo de código fuente de C# antes de invertir tu tiempo en formular este tipo de pregunta?, es obvio que no. Abrirlo y editarlo lo vas a poder hacer, por supuesto, ahora, otra cosa muy distinta sería que la sintaxis de C# empleada para el desarrollo de dicho código fuente sea o no sea compatible con tu versión de Visual Studio.

Con respecto al archivo de configuración de proyecto de C# (archivo.csproj), si es de una versión anterior de Visual Studio entonces tendrás que actualizarlo (el procedimiento será automático y por lo general con un resultado satisfactorio), pero si es de una versión más reciente de Visual Studio entonces en el "peor" de los casos tendrás que actualizar tu versión de Visual Studio para asegurar la compatibilidad, o realizar una edición manualmente en el archivo para arreglar/eliminar las propiedades de la configuración que no sean soportadas por tu versión actual de Visual Studio, o diréctamente volver a generar el archivo usando tu versión de Visual Studio.

No te conviene nada seguir estancado en una versión de software e IDE tan antigua.

Saludos!
46  Foros Generales / Foro Libre / Re: Feliz año Nuevo 2018 para toda la comunidad del elhacker.net en: 5 Enero 2018, 16:11
Otro año y yo sigo leyendo igual de mal tus comentarios. Tienes que cambiarlo:

Pues si, no hay remedio, yo tengo que usar unas gafas especiales y además calibrar el color y el brillo de mi monitor cada vez que quiero leer un comentario de @El_Andaluz xD...

47  Programación / .NET / Re: Matar proceso segun su uso de cpu o memoria ram Window 7 en: 5 Enero 2018, 15:49
El caso es que me di a la tarea y ya tengo algunos codigos de ejemplos sobre la lista de procesos y como matarlos en VB.NET como me sugirió (jeje le escribo como si me hubieran retado).

Pues para no saber practiamente nada, con una simple recomendación (o "reto" xD) ya has hecho mucho más de lo que otros han hecho en tu misma situación... ¡se nota que te esfuerzas en resolver las cosas!... y con las cosas que vayas aprendiendo poco a poco haciendo eso. EDITO: pero si veo que incluso estás usando el framework de DotNetBar, ¿seguro que nunca antes habias programado en VB.NET? xD.

no sabria como pegar los codigos de forma correcta y fucionarlos con su ejemplo de arriba

Bueno, eso depende del objetivo que tengas en mente... debes adaptar el ejemplo que te mostré, a tus necesidades.

He escrito este otro ejemplo algo más extenso por si te sirve de mejor ayuda, aunque no se si te voy a conseguir ayudar o por lo contrario voy a conseguir confundirte...puesto que en el código hago uso de técnicas de programación asincrónica mediante la aplicación del paralelismo para acelerar el procedimiento de ejecución (puesto que la función GetProcessCPUPercentUsage necesariamente es una llamada bloqueante de 500-1000 ms, y no queremos tener que esperar 500-1000 ms por cada proceso que haya...¿verdad que no?, jeje).  

...nótese que declaré una variable en la que especifico que el máximo válido de porcentaje de CPU para un proceso es 6.0%; si el límite se sobrepasa, se intenta matar al proceso.

Código
  1. Imports System
  2. Imports System.Collections.Concurrent
  3. Imports System.Collections.Generic
  4. Imports System.Diagnostics
  5. Imports System.Linq
  6. Imports System.Threading
  7. Imports System.Threading.Tasks
  8.  
  9. Public Module Module1
  10.  
  11.    Public Sub Main()
  12.        Dim maxCpuUsage As Double = 6.0R '%
  13.  
  14.        ' White-listed process names.
  15.        Dim whlNames As IEnumerable(Of String) =
  16.            {
  17.              "csrss", "dwm", "fontdrvhost", "idle", "lsass", "runtimebroker",
  18.              "services", "sihost", "smss", "svchost", "System", "taskhostw",
  19.              "wininit", "winlogon"
  20.            }
  21.  
  22.        ' Current processes sequence.
  23.        Dim prcsQuery As ParallelQuery(Of Process) =
  24.            (From prc As Process In Process.GetProcesses()
  25.             Where Not whlNames.Contains(prc.ProcessName, StringComparer.OrdinalIgnoreCase)
  26.            ).AsParallel().AsUnordered()
  27.  
  28.        Dim action As New Action(Of Process)(
  29.            Sub(prc As Process)
  30.                If (prc Is Nothing) Then
  31.                    Exit Sub
  32.                End If
  33.  
  34.                Dim cpuPercent As Double = GetProcessCPUPercentUsage(prc)
  35.                Dim pName As String = prc.ProcessName
  36.                Dim pid As Integer = prc.Id
  37.  
  38.                If (cpuUsage < maxCpuUsage) Then
  39.                    Console.WriteLine(String.Format("[ GOOD ] Name: {0}; PID: {1}; CPU: {2}%", pName, pid, cpuPercent))
  40.  
  41.                Else
  42.                    Console.WriteLine(String.Format("[ BAD  ] Name: {0}; PID: {1}; CPU: {2}%", pName, pid, cpuPercent))
  43.                    Console.WriteLine(String.Format("[ ...  ] Attempting to kill process '{0}' with PID '{1}'...", pName, pid))
  44.  
  45.                    Try
  46.                        If Not (prc.HasExited) Then
  47.                            prc.Kill()
  48.                        End If
  49.                        Console.WriteLine("[ ...  ] Process was killed successfuly.")
  50.  
  51.                    Catch ex As Exception
  52.                        Console.WriteLine("[ ...  ] Error trying to kill process...")
  53.                        Throw
  54.  
  55.                    End Try
  56.                End If
  57.  
  58.            End Sub)
  59.  
  60.        Parallel.ForEach(Of Process)(prcsQuery, New ParallelOptions(), action)
  61.    End Sub
  62.  
  63.    Friend Function GetProcessCPUPercentUsage(ByVal p As Process) As Double
  64.        Using perf As New PerformanceCounter("Process", "% Processor Time", p.ProcessName, True)
  65.            perf.NextValue()
  66.            Thread.Sleep(TimeSpan.FromMilliseconds(500)) ' Recommended value: 1 second
  67.            Return (Math.Round(perf.NextValue() / Environment.ProcessorCount, 1))
  68.        End Using
  69.    End Function
  70.  
  71. End Module

Resultado de ejecución:
Código:
...

[ GOOD ] Name: GameOverlayUI; PID: 7404; CPU: 0,2%
[ GOOD ] Name: sidebar; PID: 4836; CPU: 0,3%
[ GOOD ] Name: ScriptedSandbox64; PID: 9552; CPU: 0,3%
[ GOOD ] Name: BEService; PID: 10952; CPU: 0,4%
[ BAD  ] Name: ShooterGame; PID: 5136; CPU: 6,3%
[ ...  ] Attempting to kill process 'ShooterGame' with PID '5136'...
[ ...  ] Process was killed successfuly.
[ GOOD ] Name: Start10_64; PID: 2576; CPU: 0%
[ GOOD ] Name: CTAudSvc; PID: 1916; CPU: 0,1%
[ GOOD ] Name: NVDisplay.Container; PID: 1184; CPU: 0%

...

PD: si quieres ordenar las lineas de salida por el nombre del proceso... es algo que requeriría modificar casi por completo el código del ejemplo, en cuyo caso no debes intentar ordenar la secuencia paralela, en su lugar declara una clase o estructura para representar la información necesaria de un proceso (el nombre, PID, y porcentaje de cpu) a la que podriamos llamar "ProcessInfo", entonces creas una nueva colección genérica de tipo List(Of ProcessInfo) (o bien un SortedSet(Of ProcessInfo) pasándole un IComparer(Of ProcessInfo), primero deberías crear el comparer), y el bloque del Parallel.ForEach( ... ) (el método declarado en la variable "action") lo usarías solamente para obtener el porcentaje de cpu e ir añadiendo elementos "ProcessInfo" a la lista, ordenarla, y por último ya podrías iterar la lista de forma ordenada. Se que sin mostrar un ejemplo de código, estas explicaciones no serán muy fáciles de entender o de aplicar, pero tampoco se lo que quieres hacer exactamente, ni si necesitas mosrar los resultados en consola, ni si necesitas hacerlo de forma ordenada, y ponerme a escribir variaciones de un mismo código sin saber cual te va a servir... es tontería hacerlo xD.

Saludos!
48  Programación / .NET / Re: Librería de Snippets para VB.Net !! (Compartan aquí sus snippets) en: 5 Enero 2018, 09:22
Como obtener el uso de porcentaje de CPU de un proceso

Código
  1.    ''' ----------------------------------------------------------------------------------------------------
  2.    ''' <summary>
  3.    ''' Gets the CPU percentage usage for the specified <see cref="Process"/>.
  4.    ''' </summary>
  5.    ''' ----------------------------------------------------------------------------------------------------
  6.    ''' <returns>
  7.    ''' The resulting CPU percentage usage for the specified <see cref="Process"/>.
  8.    ''' </returns>
  9.    ''' ----------------------------------------------------------------------------------------------------
  10.    <DebuggerStepThrough>
  11.    Public Shared Function GetProcessCPUPercentUsage(ByVal p As Process) As Double
  12.  
  13.        Using perf As New PerformanceCounter("Process", "% Processor Time", p.ProcessName, True)
  14.            perf.NextValue()
  15.            Thread.Sleep(TimeSpan.FromMilliseconds(250)) ' Recommended value: 1 second
  16.            Return (Math.Round(perf.NextValue() / Environment.ProcessorCount, 1))
  17.        End Using
  18.  
  19.    End Function
  20.  

primero hay que activar el uso de los contadores de rendimiento en el archivo de manifiesto de nuestra aplicación:
Código
  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <configuration>
  3. ...
  4.  
  5.  <system.net>
  6.    <settings>
  7.      <performanceCounters enabled="true"/>
  8.    </settings>
  9.  </system.net>
  10.  
  11. ...
  12. </configuration>

Modo de empleo:
Código
  1. Do While True
  2.  
  3.    Using p As Process = Process.GetProcessesByName("NOMBRE DEL PROCESO").SingleOrDefault()
  4.        Dim str As String =
  5.            String.Format("Process Name: {0}; CPU Usage: {1}%",
  6.                          p.ProcessName, GetProcessCPUPercentUsage(p))
  7.  
  8.        Console.WriteLine(str)
  9.    End Using
  10.  
  11. Loop
49  Foros Generales / Noticias / Re: Se espera subida de precios de tarjetas gráficas de gama media y alta en: 5 Enero 2018, 09:16
Pura especulación...

No es especulación, te acaban de mostrar los precios que demuestran los planes de las empresas...

Recomiendo ver este video donde explican más a fondo las razones del elevado precio:

...en teoría, si lo que dice este chico es cierto (pocas o ninguna vez le he visto equivocarse en sus augurios), no veremos ninguna bajada de precio hasta el año 2020 como mínimo xD.

Saludos
50  Programación / Scripting / Re: Ejecutar un exe a un bat en: 5 Enero 2018, 03:07
es posible que un archivo exe, pueda llamar a un bat para que esta se ejecute automáticamente(con solo ejecutar el exe,  se tiene que ejucutar el bat)

No entiendo muy bien el problema que planteas, si tienes el código fuente de ese executable que has compilado entonces le añades una instrucción para ejecutar el archivo.bat y listo.

Si por otro lado te refieres a un executable que no has compilado tú, pretender que al iniciar un executable cualquiera se inicie adicionálmente otro archivo... entonces mejor olvídate de hacer eso (a menos que domines a un nivel avanzado varios conceptos de programación para llevar a cabo un api hook).

EDITO: bueno, una solución alternativa a la programación sería utilizar cualquier software de tipo "file binder" ( https://en.wikipedia.org/wiki/File_binder ) para empacar o "juntar" el archivo.exe y el archivo.bat en un nuevo executable; ese nuevo executable sería un simple "loader" que extraería e iniciaría los archivos que le hayas añadido (el archivo.exe original y el archivo.bat). Con herramientas de compresión tipo WinRAR lo puedes hacer también, puedes crear un archivo autoextraible (SFX) que contenga los archivos que tu quieras e iniciar aquellos archivos que desees iniciar al mismo tiempo.

Saludos!
Páginas: 1 2 3 4 [5] 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ... 1054
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines