[C++]Unire più file .exe

[cionci]

Ma grazie a quella shell si può fare...in pratica è un equivalente del comando eval di tanti linguaggi interpretati ?

[fek]

Originariamente inviato da cdimauro

Non è questione di vantaggio o meno: in Python non serve dover definire una classe con un metodo Main statico (come in Java) per poter lanciare un qualunque pezzo di codice.

Perche' lo fa implicitamente l'ambiente, non c'entra con il linguaggio!

[fek]

Originariamente inviato da cionci

Ma grazie a quella shell si può fare...in pratica è un equivalente del comando eval di tanti linguaggi interpretati ?

Si'.
E' molto piu' flessibile, ma credo non ci voglia molto a scrivere l'esatto equivalente di un eval.

Esempietto:

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.CSharp;
using System.CodeDom.Compiler;
class Program
{
    static void Main(string[] args)
    {
        var csc = new CSharpCodeProvider(new Dictionary<string, string>() { { "CompilerVersion", "v3.5" } });
        var parameters = new CompilerParameters(new[] { "mscorlib.dll", "System.Core.dll" }, "foo.exe", true);
        parameters.GenerateExecutable = true;
        CompilerResults results = csc.CompileAssemblyFromSource(parameters,
        @"using System.Linq;
            class Program {
              public static void Main(string[] args) {
                var q = from i in Enumerable.Rnge(1,100)
                          where i % 2 == 0
                          select i;
              }
            }"
         );
        results.Errors.Cast<CompilerError>().ToList().ForEach(error => Console.WriteLine(error.ErrorText));
    }
}

Al posto di quella stringa puoi passare un file, ad esempio, con il codice da mettere dentro il main per avere l'esatto equivalente di Python in 10 righe di codice.
Poi un sistema piu' robusto richiedera' un po' piu' di lavoro (ad esempio il parsing delle clausole using), ma concettualmente e' tutto qui.

[cdimauro]

Scusami, ma nelle specifiche del (linguaggio) C# è previsto che il codice "di partenza" venga eseguito da una classe che abbia un metodo Main statico?

Nelle specifiche di Python (linguaggio) no.

L'ambiente non l'ho tirato in mezzo.

[fek]

Originariamente inviato da cdimauro

Scusami, ma nelle specifiche del (linguaggio) C# è previsto che il codice "di partenza" venga eseguito da una classe che abbia un metodo Main statico?

No. E' una specifica dell'ambiente di .NET.
Il CLR si va a cercare nell'assembly una classe con un Main statico e la esegue.
Se il codice C#, ad esempio, viene eseguito da NUnit, l'ambiente si va a cercare tutti i metodi con un attributo Test ed esegue quelli.
Il linguaggio specifica solo la grammatica.

L'ambiente non l'ho tirato in mezzo.

E qui sta il tuo errore, quale metodo, codice, classe lanciare e' un problema definito dall'ambiente host, non dal linguaggio.

Esempio di valutatore di espressioni matematiche scritte in C#:

http://www.c-sharpcorner.com/UploadF...d-f253533dc018

[cdimauro]

OK, ho capito cosa intendi finalmente (lo so: sono duro ).

Io m'ero lasciato ingannare da questo http://download.microsoft.com/downlo...cification.doc

The Hello class declared by the “Hello, World” program has a single member, the method named Main. The Main method is declared with the static modifier. While instance methods can reference a particular enclosing object instance using the keyword this, static methods operate without reference to a particular object. By convention, a static method named Main serves as the entry point of a program.

Comunque qui parla di convenzione, in effetti: non è un obbligo.

[DioBrando]

Originariamente inviato da cionci

Ti spiego, questo perché l'unico che posta quando qualcuno chiede "con quale linguaggio posso fare questo" è sempre e solo Cesare e la risposta è sempre e solo Python. Una situazione del genere mi sembra più vicina al tentativo di indottrinamento che al consiglio sulla base delle effettive qualità del linguaggio e le necessità del richiedente. E' per questo che questa volta mi sono permesso non solo di consigliare una strada alternativa, ma anche di giustificarla. Spesso non lo faccio (e lascio che non ci siano contraddittori), ma questa volta mi è sembrato giusto, visto che la situazione lo richiedeva.
Obiettivamente, visti gli scopi di chi ha creato il thread, cioè creare un programma di monitoraggio e rilevamento della caratteristiche hardware, avresti consigliato Python ? Questo un giorno potrebbe avere la necessità di scrivere un driver...e gli si consiglia Python ?

Sinceramente non ho seguito bene tutto il thread quindi non sò quali siano le esigenze dell'autore; in ogni caso sempre se non ho capito male mi pare sia a digiuno quasi totale dell'argomento programmazione quindi sostanzialmente si trattava di consigliare uno strumento affinchè potesse imparare.
In questo contesto immagino entri il consiglio di Cesare, che per altro non è vero che raccomanda sempre e solo Python: se vai a rileggerti gli ultimi thread (anche piuttosto lunghi a dire il vero) che hanno toccato questo argomento, i consigli suoi sono quelli + o - di tutti, ovvero di cominciare con un linguaggio piuttosto didattico che con strumenti di sviluppo adeguati al livello di esperienza e che consentano una curva di apprendimento bilanciata tra il tempo investito ad imparare come funzionano rispetto alla necessità di essere produttivi (Java, C#, Python, Ruby, sempre quelli sono).
Che poi questo debba essere valutato anche in un'ottica di esigenze soggettive sono d'accordo ma fino a un certo punto, perchè alla fine l'obiettivo è quello di imparare a programmare e i primi passi saranno uguali per tutti a prescindere dal futuro lavorativo e la branca di specializzazione scelta.

A me sembra stiate montando un caso per niente, finchè si scherza ok, poi però lo scherzo a un certo punto finisce...
Sulla non sufficiente conoscenza di C# per poter fare un confronto a tutto tondo si è espresso lui stesso più volte e mi sembra si possa dire serenamente che non ci siano problemi se qualcosa sfugga tra gli interlocutori.

Originariamente inviato da cionci

Quindi secondo te uno che inizia dovrebbe automaticamente cominciare con Python sempre e comunque ? Secondo me dipende anche dalle motivazioni per cui inizia a programmare.
Di conseguenza io ho consigliato C# per diminuire il suo percorso di apprendimento, visto che un giorno vorrebbe andare a lavorare a basso livello.
Credo che un percorso di apprendimento Python -> C# -> C++ sia ben più lungo di un percorso C# -> C++, nonostante la supposta facilità di apprendimento del Python rispetto al C#, soprattutto considerando la distanza fra questi due linguaggi.

Partendo dal presupposto che imparare a programmare per poter scrivere driver mi sembra fare un percorso un po' troppo vincolante (anche perchè suppongo, presumo che l'autore del thread se mai dovesse diventare un programmatore, se mai dovesse lavorare nel settore, dubito si trovi a scrivere driver per tutta la sua vita e basta...o almeno me lo auguro ), il tuo consiglio è ragionevole ma non dimenticare che Python può essere esteso tramite librerie native C e C++ (quest'ultimo attraverso Boost per esempio).
Il core stesso è stato scritto in C (progetto PyPy a parte).

Quindi se è vero che dal punto di vista sintattico ci siano delle differenze tra Python e i linguaggi C-like, non è vero per quanto riguarda il supporto e gli strumenti messi a disposizione.
E quindi un percorso diverso da quello che hai messo in luce tu non è così assurdo.
Chiaramente per poterlo consigliare e prenderlo in esame bisogna anche averci lavorato, oltre che leggere qualche specifica qui e là...questo sempre nel discorso di cui ti facevo sopra riguardo all'esperienza.

[cionci]

Originariamente inviato da DioBrando

i consigli suoi sono quelli + o - di tutti, ovvero di cominciare con un linguaggio piuttosto didattico che con strumenti di sviluppo adeguati al livello di esperienza e che consentano una curva di apprendimento bilanciata tra il tempo investito ad imparare come funzionano rispetto alla necessità di essere produttivi (Java, C#, Python, Ruby, sempre quelli sono).

Mai detto il contrario, infatti ho consigliato C#.

Originariamente inviato da DioBrando

Che poi questo debba essere valutato anche in un'ottica di esigenze soggettive sono d'accordo ma fino a un certo punto, perchè alla fine l'obiettivo è quello di imparare a programmare e i primi passi saranno uguali per tutti a prescindere dal futuro lavorativo e la branca di specializzazione scelta.

Invece secondo me è fondamentale, se il linguaggio con cui si inizia permette di avvicinarsi all'obiettivo che ci siamo prefissi sarà sicuramente più divertente imparare e molto più appagante.

Chiaro che non debba, fare solo driver, infatti gli ho consigliato C#

Cesare è libero di consigliare sempre Python come io sono libero di elencarne quali secondo me sono i difetti di tale linguaggio ed i motivi per cui me ne tengo lontano (sempre partendo da quello che ho letto).
Quindi davvero secondo te conviene partire da Python e non da C# se una persona si pone l'obiettivo di scrivere programmi che interagiscono a basso livello con l'hardware ? Secondo me è un'assurdità.
Nota bene che io non dico che sia un'assurdità imparare a programmare con Python, tutt'altro, dico che è assurdo in questo caso.

[okay]

Originariamente inviato da cionci

Mai detto il contrario, infatti ho consigliato C#.

Invece secondo me è fondamentale, se il linguaggio con cui si inizia permette di avvicinarsi all'obiettivo che ci siamo prefissi sarà sicuramente più divertente imparare e molto più appagante.

Chiaro che non debba, fare solo driver, infatti gli ho consigliato C#

Cesare è libero di consigliare sempre Python come io sono libero di elencarne quali secondo me sono i difetti di tale linguaggio ed i motivi per cui me ne tengo lontano (sempre partendo da quello che ho letto).
Quindi davvero secondo te conviene partire da Python e non da C# se una persona si pone l'obiettivo di scrivere programmi che interagiscono a basso livello con l'hardware ? Secondo me è un'assurdità.
Nota bene che io non dico che sia un'assurdità imparare a programmare con Python, tutt'altro, dico che è assurdo in questo caso.

scusa cionci... sono rientrato adesso e mi metto a riposare sono stato a cena e sono alticcio...

Non è il caso che apro un 3d (ma leggendo questo che seguo) mi viene da chiederti una cosa.

Hai chiuso il 3d a quell'utente che chiedeva un programmino perchè il suo amico aveva al massimo 50 ore di adsl ecc ecc e gli hai messo il link di dove scaricarei programma già bello che pronto... okay và bene.

Io però gli avevo promesso che gli è lo avrei fatto per lunedì/martedi mentre invece l'ho finito... l'ho fatto solo per mio divertimento (hobby nei ritagli di tempo)... và bhè.

Dunque anche se non gli passo il programma (free naturalmente) mi sono fermato su questa cosa, che ora sono alticcio e non mi di ragionarci (domani magari...) tanto per finire il prg iniziato.


Dunque ho fatto una cosa semplice si lancia il prg e si dà lo start prendo il Timer e controllo i secondi passati:

la classica cosa per il tempo

iTimeLeft = Timer - iTime
iTime = Timer
'la classica cosa...

questa è la funzione in cui stampo i valori di hh:mm:ss

Public Function MyFormat(ByVal iTime As Double) As String
    hh = iTime \ 3600
    iTime = iTime - hh * 3600
    mm = iTime \ 60
    iTime = iTime - mm * 60
    ss = iTime
MyFormat0 = Format(hh, "00") & ":" & Format(mm, "00") & ":" & Format(ss, "00")

End Function

okay


ora quando esce dal programma salvo le ore i minuti e i secondi

quindi all'apertura del prg rileggo in input ore, minuti e secondi bene la domanda è:

Considerando che faccio per conteggiare il tempo Timer

Come faccio, supponendo che il formato di partenza è ora es.: 02:12:08

a riprendere da quì e continuare con il conteggio?

Devo per caso aggiungere a Timer (che sono i secondi trascorsi) 2*3600+12*60+8...???

ora vado a cuccia... a domani

[cdimauro]

Originariamente inviato da cionci

Quindi davvero secondo te conviene partire da Python e non da C# se una persona si pone l'obiettivo di scrivere programmi che interagiscono a basso livello con l'hardware ? Secondo me è un'assurdità.
Nota bene che io non dico che sia un'assurdità imparare a programmare con Python, tutt'altro, dico che è assurdo in questo caso.

from ctypes import *
hw = windll.WinRing0

def c_intToStr(Value):
  return ''.join(chr((Value >> Shift) & 255) for Shift in (0, 8, 16, 24))

def c_intToNibbles(Value):
  return tuple((Value >> Shift) & 15 for Shift in(0, 4, 8, 12, 16, 20, 24, 28))

def BitSetToStringList(Value, Names):
  List = []
  for Name in Names:
    if Name and (Value & 1):
      List.append(Name)
    Value >>= 1
  return List

def CPUID(Function):
  eax = c_int(); ebx = c_int(); ecx = c_int(); edx = c_int()
  hw.Cpuid(Function, byref(eax), byref(ebx), byref(ecx), byref(edx))
  return eax.value, ebx.value, ecx.value, edx.value

EDXFeatures = ('Floating-point unit on-Chip',
  'Virtual Mode Extension',
  'Debugging Extension',
  'Page Size Extension',
  'Time-Stamp Counter',
  'Model Specific Registers',
  'Physical Address Extension',
  'Machine Check Exception',
  'CMPXCHG8 Instruction Supported',
  'On-chip APIC Hardware Supported',
  '',
  'Fast System Call',
  'Memory Type Range Registers',
  'Page Global Enable',
  'Machine Check Architecture',
  'Conditional Move Instruction Supported',
  'Page Attribute Table',
  '36-bit Page Size Extension',
  'Processor serial number is present and enabled',
  'CLFLUSH Instruction supported',
  '',
  'Debug Store', 
  'Thermal Monitor and Software Controlled Clock Facilities supported',
  'Intel Architecture MMX technology supported',
  'Fast floating point save and restore',
  'Streaming SIMD Extensions supported',
  'Streaming SIMD Extensions 2',
  'Self-Snoop',
  'Multi-Threading',
  'Thermal Monitor supported',
  'IA64 Capabilities',
  'Pending Break Enable')

ECXFeatures = ('Streaming SIMD Extensions 3',
  '',
  '64-Bit Debug Store',
  'MONITOR/MWAIT',
  'CPL Qualified Debug Store',
  'Virtual Machine Extensions',
  'Safer Mode Extensions',
  'Enhanced Intel SpeedStep Technology',
  'Thermal Monitor 2',
  'Supplemental Streaming SIMD Extensions 3',
  'Context ID',
  '',
  '',
  'CMPXCHG16B',
  'Send Task Priority Messages',
  'Performance Capabilities MSR',
  '',
  '',
  'Direct Cache Access',
  'Streaming SIMD Extensions 4.1',
  'Streaming SIMD Extensions 4.2',
  '',
  '',
  'POPCNT instruction',
  '',
  '',
  '',
  '',
  '',
  '',
  '',
  'RAZ')

try:
  hw.InitializeDll()

  eax, ebx, ecx, edx = CPUID(0)
  print 'CPU VendorID is:', c_intToStr(ebx) + c_intToStr(edx) + c_intToStr(ecx)

  eax, ebx, ecx, edx = CPUID(0x80000002)
  Brand = c_intToStr(eax) + c_intToStr(ebx) + c_intToStr(ecx) + c_intToStr(edx)
  eax, ebx, ecx, edx = CPUID(0x80000003)
  Brand += c_intToStr(eax) + c_intToStr(ebx) + c_intToStr(ecx) + c_intToStr(edx)
  eax, ebx, ecx, edx = CPUID(0x80000004)
  Brand += c_intToStr(eax) + c_intToStr(ebx) + c_intToStr(ecx) + c_intToStr(edx)
  print 'CPU Brand is:', ''.join(Ch for Ch in Brand if Ch != '\x00')

  eax, ebx, ecx, edx = CPUID(1)
  print 'CPU Stepping: %s, Model: %s, Family: %s, Processor Type: %s' % c_intToNibbles(eax)[ : 4]

  print 'CPU Features:'
  for Feature in BitSetToStringList(edx, EDXFeatures) + BitSetToStringList(ecx, ECXFeatures):
    print ' ', Feature
finally:
  hw.DeinitializeDll()

OUTPUT:

CPU VendorID is: AuthenticAMD
CPU Brand is: AMD Athlon(tm) 64 Processor 2800+
CPU Stepping: 0, Model: 12, Family: 15, Processor Type: 0
CPU Features:
  Floating-point unit on-Chip
  Virtual Mode Extension
  Debugging Extension
  Page Size Extension
  Time-Stamp Counter
  Model Specific Registers
  Physical Address Extension
  Machine Check Exception
  CMPXCHG8 Instruction Supported
  On-chip APIC Hardware Supported
  Fast System Call
  Memory Type Range Registers
  Page Global Enable
  Machine Check Architecture
  Conditional Move Instruction Supported
  Page Attribute Table
  36-bit Page Size Extension
  CLFLUSH Instruction supported
  Intel Architecture MMX technology supported
  Fast floating point save and restore
  Streaming SIMD Extensions supported
  Streaming SIMD Extensions 2

E' abbastanza assurdo per te?

P.S. Il programma ha bisogno che i file WinRing0.dll e WinRing0.sys della cartella "release" del progetto http://openlibsys.org/ siano presenti nella cartella da cui verrà lanciato (oppure che si trovino nel path).

[gugoXX]

Dai, cosi' torniamo anche un po' In-Topic.
Comunque scherzo, lasciami questa licenza poetica.
Tanto l'ho capito che lo puoi fare in IronPython (forse)
E comunque questo sottolinea come la liberia (Framework) faccia tantissimo.
E qui sto solo interrogando il processore.
Ce ne sarebbe da tirare fuori... si potrebbe fare un bel clone di SisoftSandra.
Forse anche qualcosa di piu'.

Ahiahiahi signora Longari, quanto codice

ManagementClass mc = new ManagementClass("Win32_Processor");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
    Console.WriteLine("---------------");
    Console.WriteLine(mo.Properties["DeviceID"].Value);
    Console.WriteLine("---------------");
    var props=mo.Properties.Cast<PropertyData>();
    var sysprops = mo.SystemProperties.Cast<PropertyData>();
    var insieme = props.Union(sysprops);
    var filtrino = insieme.Where(u => u.Value != null);
    var ordino = filtrino.OrderBy(u => u.Name);
    
    foreach (var inst in ordino)
    {  
        Console.WriteLine("{0} - {1}", inst.Name, inst.Value);
    }
}

Risultato

---------------
CPU0
---------------
__CLASS - Win32_Processor
__DERIVATION - System.String[]
__DYNASTY - CIM_ManagedSystemElement
__GENUS - 2
__NAMESPACE - root\cimv2
__PATH - \\INTELE6600\root\cimv2:Win32_Processor.DeviceID="CPU0"
__PROPERTY_COUNT - 44
__RELPATH - Win32_Processor.DeviceID="CPU0"
__SERVER - INTELE6600
__SUPERCLASS - CIM_Processor
AddressWidth - 32
Architecture - 0
Availability - 3
Caption - x86 Family 6 Model 15 Stepping 6
CpuStatus - 1
CreationClassName - Win32_Processor
CurrentClockSpeed - 3000
CurrentVoltage - 13
DataWidth - 32
Description - x86 Family 6 Model 15 Stepping 6
DeviceID - CPU0
ExtClock - 332
Family - 2
L2CacheSize - 4096
Level - 6
LoadPercentage - 0
Manufacturer - GenuineIntel
MaxClockSpeed - 3000
Name - Intel(R) Core(TM)2 CPU          6600  @ 2.40GHz
PowerManagementSupported - False
ProcessorId - BFEBFBFF000006F6
ProcessorType - 3
Revision - 3846
Role - CPU
SocketDesignation - Socket 775
Status - OK
StatusInfo - 3
Stepping - 6
SystemCreationClassName - Win32_ComputerSystem
SystemName - INTELE6600
UpgradeMethod - 4
Version - Model 15, Stepping 6
---------------
CPU1
---------------
__CLASS - Win32_Processor
__DERIVATION - System.String[]
__DYNASTY - CIM_ManagedSystemElement
__GENUS - 2
__NAMESPACE - root\cimv2
__PATH - \\INTELE6600\root\cimv2:Win32_Processor.DeviceID="CPU1"
__PROPERTY_COUNT - 44
__RELPATH - Win32_Processor.DeviceID="CPU1"
__SERVER - INTELE6600
__SUPERCLASS - CIM_Processor
AddressWidth - 32
Architecture - 0
Availability - 3
Caption - x86 Family 6 Model 15 Stepping 6
CpuStatus - 1
CreationClassName - Win32_Processor
CurrentClockSpeed - 3000
CurrentVoltage - 13
DataWidth - 32
Description - x86 Family 6 Model 15 Stepping 6
DeviceID - CPU1
ExtClock - 332
Family - 2
L2CacheSize - 4096
Level - 6
LoadPercentage - 0
Manufacturer - GenuineIntel
MaxClockSpeed - 3000
Name - Intel(R) Core(TM)2 CPU          6600  @ 2.40GHz
PowerManagementSupported - False
ProcessorId - BFEBFBFF000006F6
ProcessorType - 3
Revision - 3846
Role - CPU
SocketDesignation - Socket 775
Status - OK
StatusInfo - 3
Stepping - 6
SystemCreationClassName - Win32_ComputerSystem
SystemName - INTELE6600
UpgradeMethod - 4
Version - Model 15, Stepping 6

[DioBrando]

Originariamente inviato da cionci

Mai detto il contrario, infatti ho consigliato C#.

Non hai capito quello che ho scritto.
Io mi riferivo al fatto che adducevi ma non solo tu, che Cesare ogni volta che ci sia una richiesta di consiglio su quale linguaggio utilizzare lui spunti fuori sempre e solo con Python.
Questo non è vero, ti invito a prendere i thread di cui sopra per accertartene, i consigli che dà sono quelli che diamo + o - tutti (perchè sono quelli + sensati, per chi si avvicina alla programmazione da neofita).

Invece secondo me è fondamentale, se il linguaggio con cui si inizia permette di avvicinarsi all'obiettivo che ci siamo prefissi sarà sicuramente più divertente imparare e molto più appagante.

Peccato che dietro questa motivazione poi si diano consigli allucinanti quali quelli di iniziare con C o C++.
Ah poi ci sono i geni della lampada che citano Assembly o dicono che la allocazione/deallocazione della memoria, insieme alle eccezioni sono mattoni fondamentali per imparare a programmare.
Ma vabbè qui scendiamo nel paranormale...

Chiaro che non debba, fare solo driver, infatti gli ho consigliato C#

Cesare è libero di consigliare sempre Python come io sono libero di elencarne quali secondo me sono i difetti di tale linguaggio ed i motivi per cui me ne tengo lontano (sempre partendo da quello che ho letto).

Cionci, tu forse non hai capito la critica che ti sto muovendo e il fatto per cui tu debba ogni volta "crocifiggere Python", quindi te la riscrivo in parole più chiare.
Partendo dal presupposto ( e ci mancherebbe) che ognuno è libero di dire quello che vuole e che vi sono caratteristiche di un linguaggio che possano piacere o non piacere a prescindere, trovo che la critica mossa a priori sempre e comunque da chi in Python non ci ha mai sviluppato seriamente sia un po' debole rispetto a chi l'ha fatto, sia che lo critichi sia che invece ne apprezzi le caratteristiche.

Quindi davvero secondo te conviene partire da Python e non da C# se una persona si pone l'obiettivo di scrivere programmi che interagiscono a basso livello con l'hardware ?

Rileggi quel che ti ho scritto, perchè il significato che hai inteso non è quello che le mie parole dicono.
Ho scritto che pensare ad un percorso come quello prospettato da Cesare non è così assurdo, non che sia migliore o preferibile rispetto al tuo (per altro non avendo mai avuto esperienze simili nè essendomi mai trovato a scrivere driver, trovo difficile dare dei consigli così netti come fate voi).

Secondo me è un'assurdità.
Nota bene che io non dico che sia un'assurdità imparare a programmare con Python, tutt'altro, dico che è assurdo in questo caso.

Ok allora spiegami quale sarebbe l'assurdità.
Hai la possibilità di interfacciarti con le librerie C/C++ piuttosto facilmente, hai la possibilità di accedere alle API di Windows, gli ambienti di sviluppo sono comuni (alcuni peculiari per Python come ce ne sono per C++ ecc. ma la maggiorparte, quelli multilinguaggio supportano sia Python che C++ che C#...), dove starebbe il problema?
Sintassi a parte, qualche caratteristica che può non piacere...ok ma siamo lontani da quello che definisco io come "assurdo".
Io almeno, per cui vorrei sapere i motivi per cui definisci un percorso come quello prospettato in questi termini così decisi e "sprezzanti".

[cionci]

Cesare: non sei riuscito a rilevare i dati che aveva messo nel suo esempio:

Visto che la libreria non ci arriva ora come fai ?

DioBrando: mi sembra di non essere stato solo io ad aver notato che Cesare consiglia sempre Python, anche quando non c'entra assolutamente niente con l'argomento. Quindi un fondo di verità forse c'è ?
Io per obiettare sull'uso di Python mi baso su quello che ho visto di Python (chiaro che un minimo me lo sia guardato) e su quello che dice Cesare. Io obietto direttamente sugli argomenti che tira fuori lui come vantaggio. C'è qualcosa di errato in questa pratica ?
Ad esempio la questione multiparadigma: ho fatto la stessa critica decine di volte per quanto riguarda C++, Cesare lo cita come argomento a favore di Python, perché non posso muovere la stessa critica che muovo a C++ anche a Python ?

[okay]

OT x cionci come da mia richiesta di ieri sera:

ho risolto così:

iTimeLeft = Timer + iTimeLeft - iTime

okay tutto ok

[cdimauro]

Originariamente inviato da cionci

Cesare: non sei riuscito a rilevare i dati che aveva messo nel suo esempio:

Visto che la libreria non ci arriva ora come fai ?

Riccardo, il tuo problema è che parli senza nemmeno conoscere, e per giunta andando fuori tema.

Quello di sopra era un esempio che ho tirato fuori IN RISPOSTA A PRECISE COSE che avevi scritto in un messaggio, e che tra l'altro avevo pure sottolineato.

Giusto per ricordartelo, sostenevi questo:

obiettivo di scrivere programmi che interagiscono a basso livello con l'hardware

dico che è assurdo in questo caso

Ti ho dimostrato con un esempio "minchione" (leggi: è un banale "proof of concept") che posso accedere tranquillamente all'hardware anche con Python, e per far questo mi affido a una libreria che è stata scritta allo scopo e che fornisce esempi esclusivamente in C++ e C#.

Nessun altro mi risulta l'abbia usata finora con Python (ho fatto un po' di ricerche, ma non ho trovato nulla), per cui ho dovuto studiarmi quel tanto che basta della libreria standard ctypes per poterla usare allo scopo (ben 5 minuti!!!) e poi ho perso MOLTO più tempo a rispolverare i rispettivi manuali di Intel e AMD sull'argomento CPUID.

Per il resto con la shell interattiva ho smanettato un po' e man mano mi sono costruito tutto ciò che mi serviva, arrivando alla versione finale del programma, che se è tanto lungo è esclusivamente perché ho voluto fornire un output carino con informazioni più umane che una banale sfilza di 0 e 1 spiattellati per visualizzare le "feature" della CPU.

Come vedi con Python accedere a una QUALUNQUE libreria è una cazzata immane: bastano DUE righe di codice:

from ctypes import *
hw = windll.WinRing0

Niente include, niente namespace da definire che eseguono il wrapping delle funzionalità esposte, ma da adesso in poi posso utilizzare TUTTE le API che espone la libreria WinRing0.

Il resto è mero esercizio accademico.

Se vuoi ottenere TUTTE le informazioni presenti nell'immagine che hai riportato basta che vai a recuperare la documentazione di AMD sui suoi processori, e ti spulci gli altri registri di CPUID, i machine register, il real time clock, ed eventualmente le porte di I/O: tutte cose a cui puoi accedere tranquillamente e MOLTO semplicemente tramite quella libreria.

DioBrando: mi sembra di non essere stato solo io ad aver notato che Cesare consiglia sempre Python, anche quando non c'entra assolutamente niente con l'argomento. Quindi un fondo di verità forse c'è ?

Ma dove, scusa? Fammi un esempio in cui la soluzione che ho proposto non fosse attinente al topic.

Ad esempio ti ho appena fatto vedere che per lo scopo del thread Python si può usare tranquillamente, quando invece sono stato crocifisso soltanto perché avevo consigliato questo linguaggio per IMPARARE A PROGRAMMARE (vatti a rileggere il thread).

Io per obiettare sull'uso di Python mi baso su quello che ho visto di Python (chiaro che un minimo me lo sia guardato) e su quello che dice Cesare. Io obietto direttamente sugli argomenti che tira fuori lui come vantaggio. C'è qualcosa di errato in questa pratica ?
Ad esempio la questione multiparadigma: ho fatto la stessa critica decine di volte per quanto riguarda C++, Cesare lo cita come argomento a favore di Python, perché non posso muovere la stessa critica che muovo a C++ anche a Python ?

Perché non hai ancora capito come funziona Python, dove gli elementi con cui lavori sono tutti oggetti che... espongono delle funzionalità che puoi "combinare" come vuoi per simulare diversi paradigmi di programmazione.

Pura programmazione a oggetti, quindi (quasi: con Python 3.0 verrà rimosso qualche "refuso", tipo l'istruzione print che diventerà un oggetto built-in di tipo "funzione"; ma si tratta di quisquilie: pochissima roba che non inficia la generalità del discorso, e che comunque verranno sistemate con la prossima "major release" del linguaggio).

Tra l'altro hai fatto critiche a funzionalità che espongono tranquillamente linguaggi come Haskell che sono particolarmente apprezzate dai matematici, che non si scandalizzano certamente per un meccanismo come le list comprehension visto che lo trovano perfettamente "naturale".

Sui gusti non si discute, e se non ti piacciono certe cose io non ho nulla da dire, ma non mi pare il caso di muovergli una critica a tutto tondo, tra l'altro provando, da un esempio, a generalizzare sulla "bontà" del linguaggio, come hai fatto in passato, che non mi sembra un atteggiamento corretto...

[cdimauro]

Originariamente inviato da gugoXX

Dai, cosi' torniamo anche un po' In-Topic.
Comunque scherzo, lasciami questa licenza poetica.
Tanto l'ho capito che lo puoi fare in IronPython (forse)
E comunque questo sottolinea come la liberia (Framework) faccia tantissimo.
E qui sto solo interrogando il processore.
Ce ne sarebbe da tirare fuori... si potrebbe fare un bel clone di SisoftSandra.
Forse anche qualcosa di piu'.

Ahiahiahi signora Longari, quanto codice

Sì, con IronPython puoi accedere al framework e quindi alle stesse informazioni. Il listato per fare le STESSE cose sarà, quindi, simile (e corto).

Detto ciò, non so quali informazioni mette a disposizione la libreria che hai usato, ma ad esempio non noto tutte le informazioni sulle "feature" della CPU che, invece, ho tirato fuori col mio programmino.

Comunque la libreria che ho usato ha esempi esclusivamente per C++ e C#, quindi potresti provare a realizzare tu il codice necessario per tirare fuori le STESSE informazioni che ho visualizzato io (magari con lo stesso output).

Potrebbe essere un confronto utile, che ne dici?

[gugoXX]

Ma, sinceramente volevo provare a vedere se sarei riuscito a tirare fuori quello che serviva al nostro amico all'inizio, ovvero
-Frequenza CPU, nome CPU, Frequenza BUS e temperature.
I primi sono li', ma sono anche poi riuscito a tirare fuori la temperatura.

Comunque non e' una libreria generica.
E' l'incapsulamento di tutta la WMI messa a disposizione per .net, direttamente dalla Microsoft.
E' davvero immensa, penso che in qualche modo abbiano anche portato fuori le informazioni della CPUID, ma non ne sono sicuro.

Fra le sole Win32_Classes c'e' da sbizzarrirsi. Riporto qui un elenco
http://msdn2.microsoft.com/en-us/lib...84(VS.85).aspx

Ce ne sono anche tante altre. La temperatura (in decimi di Kelvin!!) l'ho trovata qui dentro, in mezzo ad altre cose.
root\WMI MSAcpi_ThermalZoneTemperature
I valori non sono tutti in sola lettura. Per esempio ho potuto cambiare la frequenza di campionamento della temperatura. Non mi ha dato errore, ma non ho controllato se e' stata recepita.
Ovviamente la tua utenza deve avere i privilegi per farlo, tipicamente administrator.

Se vuoi provare a leggere la WMI direttamente in Python con l'SDK puoi farlo, ma non so se e' altrettanto agevole.
Le classi bisogna scriverle almeno una volta, e io non l'ho dovuto fare perche' erano gia' tutte belle pronte.

Comunque per la sola CPUID e' chiaro che il programma e' una palla, il 90% delle tue righe erano solo la descrizione di ciascuno dei bit.
Se proprio dovessi eseguirla prenderei la strada con il minimo sforzo.
Poiche' in .net posso linkare progetti che arrivano da diversi linguaggi, nella soluzione aggiungerei semplicemente un progetto C++, con una sola funzione, il cui corpo sarebbe

public int getCPUID()
{
  int ret;
  __asm{
      mov eax, 1
      cpuid
      mov ret, eax
  }
  return ret;
}

Dovrebbe funzionare anche al di fuori del ring0, ma mi riservo di provare.
In C# poi, per trasformare l'intero nei singoli bit userei semplicemente:

BitArray ba = new BitArray(BitConverter.GetBytes(fromCPUID));

Da li' si tratterebbe solo di stampare le stringhe pallosissimamente messe.

[fek]

Originariamente inviato da cdimauro

Sì, con IronPython puoi accedere al framework e quindi alle stesse informazioni. Il listato per fare le STESSE cose sarà, quindi, simile (e corto).

E meno leggibile.
Piu' corto non vuol dire migliore, piu' leggibile e piu' mantenibile. Meno punti funzionali vuol dire (generalmente) piu' semplice, non meno caratteri.

Secondo me in molti esempi di Python che ti ho visto scrivere fai un errore: ti fai prendere dallo scrivere "cute code" sfruttando caratteristiche del linguaggio. E questo e' sbagliato. Io spesso non capisco a prima vista il codice che riporti in Python, lo devo rileggere, poi andarmi a guardare quello che scrivi e cercare la caratteristica del linguaggio che hai usato.

Al contrario, spesso, io faccio leggere il mio codice ad un artista e se mi dice che non capisce quello che sto facendo, quando ho tempo, lo riscrivo in maniera piu' chiara.

Le caratteristiche del linguaggio vanno usate per scrivere codice piu' chiaro e leggibile, non perche' fa figo.

E ora per cortesia non riportarmi un paio di righe di Python dicendo "a me sembrano chiare", perche' nove su dieci lo sembrano solo a te e a chi conosce bene Python

[fek]

Originariamente inviato da gugoXX

Poiche' in .net posso linkare progetti che arrivano da diversi linguaggi, nella soluzione aggiungerei semplicemente un progetto C++, con una sola funzione, il cui corpo sarebbe

Farei anch'io cosi'. Quando per gioco ho scritto un engine 3d consumabile da .NET il lavoro era piacevolissimo. Scrivevo la classe .NET in C++/CLI (che e' molto simile a C#), dentro lo stesso metodo iniziavo a scrivere C++ nativo che faceva il lavoro sporco di pilotare D3D native. C# o Comega (al tempo) consumavano le classi ad alto livello per la gestione di Mesh, Fisica, Texture, etc. Comodo ed elegantissimo.

[^TiGeRShArK^]

Originariamente inviato da gugoXX

Dai, cosi' torniamo anche un po' In-Topic.
Comunque scherzo, lasciami questa licenza poetica.
Tanto l'ho capito che lo puoi fare in IronPython (forse)
E comunque questo sottolinea come la liberia (Framework) faccia tantissimo.
E qui sto solo interrogando il processore.
Ce ne sarebbe da tirare fuori... si potrebbe fare un bel clone di SisoftSandra.
Forse anche qualcosa di piu'.

Ahiahiahi signora Longari, quanto codice

ManagementClass mc = new ManagementClass("Win32_Processor");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
    Console.WriteLine("---------------");
    Console.WriteLine(mo.Properties["DeviceID"].Value);
    Console.WriteLine("---------------");
    var props=mo.Properties.Cast<PropertyData>();
    var sysprops = mo.SystemProperties.Cast<PropertyData>();
    var insieme = props.Union(sysprops);
    var filtrino = insieme.Where(u => u.Value != null);
    var ordino = filtrino.OrderBy(u => u.Name);
    
    foreach (var inst in ordino)
    {  
        Console.WriteLine("{0} - {1}", inst.Name, inst.Value);
    }
}

fichissimo, pure io ho un Q6600@3.0 sulla mia workstation