Newsgroup: it.comp.lang.visual-basic
Titolo: integer-wrapper

integer in vb è un tipo primitivo, mentre per java int è il tipo
primitivo ed integer è il corrispondente wrapper
 
esiste una corrispondente wrapper di integer per vb?
 
grazie, ciao, Jasmine
--
 
Wataya Noboru non doveva difendere nulla.Per questo 
poteva concentrare tutti i suoi sforzi nella conduzione
pura e semplice della battaglia. 
L'uccello che girava le viti del mondo,Murakami Haruki

 esiste una corrispondente wrapper di integer per vb?
 
In 
VB.NET
 Integer è un alias di System.Int32 definito in .NET. Nel 
codice scrivere Integer o Int32 è la stessa cosa.
Stessa cosa per int C#.
 
-- 
Saluti
VITRIOL

Stessa cosa per int C#.
 
 
e il suo corrispondente wrapper qual'č?
 
ps. quando parlo di vb intendo  
vb.net
 


e il suo corrispondente wrapper qual'è?
 
 
cioè il mio problema è questo... se Integer in vb è un tipo primitivo
come posso fare cose come Integer.Parse?
 
in Java non posso fare qualcosa come int parse direttamente
ma devo utilizzare l'equivalente classe wrapper
(che in java è Integer) e poi fare il parse


 e il suo corrispondente wrapper qual'è?
 
Se mi dici cosa intendi per wrapper...
 
System.Int32 è la struttura primaria che in .NET definisce l'intero a 32 
bit, mentre Integer è un sinonimo 
VB.NET
 di System.Int32.
Se questo vuol dire che Integer è un wrapper di System.Int32, allora OK :-)
Io lo chiamo alias.
 
-- 
Saluti
VITRIOL

 (che in java è Integer) e poi fare il parse
 
Potrei tranquillamente sbagliare, ma in .NET non credo che esista una 
differenza del genere. L'intero è già un oggetto, ed è definito nella 
classe System.Int32 del framework stesso.
 
-- 
Saluti
VITRIOL

Se mi dici cosa intendi per wrapper...
 
 
in java i tipi primitivi hanno un corrispondente tipo classe
il quale (tipo classe) fornisce, quando non è  istanziato, metodi
statici per poter operare con oggetti del proprio tipo primitivo
corrispondente;
invece se lo istanzi fornisce un wrapper (involucro) di tipo classe
cosa che mi serve se devo operare con un tipo classe ma ho a che fare
con valori di tipo primitivo.
 
Ecco, io volevo sapere (non riesco a trovare) se funziona analogamente
con vb-net
cioè:
perchè posso fare qualcosa come Integer.parse
se integer per vb è un tipo primitivo?
H E L P!


classe System.Int32 del framework stesso.
grazie! era quello che volevo sapere


 (che in java è Integer) e poi fare il parse
        Dim p As String
        Dim risultato As Integer
        p = "122342"
        If Integer.TryParse(p, risultato) Then
            MessageBox.Show("YUHUUU! Conversione completata", "OK", 
MessageBoxButtons.OK, MessageBoxIcon.Information)
        Else
            MessageBox.Show("ARRRGH! Conversione impossibile", 
"Errore", MessageBoxButtons.OK, MessageBoxIcon.Error)
        End If
        p = "afaf1114"
        If Integer.TryParse(p, risultato) Then
            MessageBox.Show("YUHUUU! Conversione completata", "OK", 
MessageBoxButtons.OK, MessageBoxIcon.Information)
        Else
            MessageBox.Show("ARRRGH! Conversione impossibile", 
"Errore", MessageBoxButtons.OK, MessageBoxIcon.Error)
        End If
        p = "1.25252"
        If Integer.TryParse(p, risultato) Then
            MessageBox.Show("YUHUUU! Conversione completata", "OK", 
MessageBoxButtons.OK, MessageBoxIcon.Information)
        Else
            MessageBox.Show("ARRRGH! Conversione impossibile", 
"Errore", MessageBoxButtons.OK, MessageBoxIcon.Error)
        End If
INTEGER è il "wrapper"
infatti credo che su un S.O. 32 sia un int32 su un S.O.64 sia un int64
concordo con quello che forse vuoi dire
io non specifico mai int32 o int64 (a maeno che non usi grafica o 
strutture di bit...o api)lascio che decida lui!
Quindi usa INTEGER.TryParse(Valorestringa,VariabiledaValorizzare) che 
ti ritorna true o false
Nota bene VariabileDaValorizzare è un ByRef è passata per riferimento 
(giustamente)
-- 
----- Italliaaaaa 3227! -----
Please, visits website, but please visit Italy. We’re t’best country in 
the world in terms of: Culture, Landscapes, Arts, History, Cities, 
Villages, Beautiful countryside, seaside, mountains. That is Italy. You 
know, perhaps, you dreaming about. But please, visit or country. We 
will welcome you warmly and with a better organization.
(Francesco Rutelli Video a: 
http://www.martek.it/dblog/mostraVideo.asp?p=/public/dblog/Rutelli1.wmv
 
)

 ciao, Jasmine
 
Leggi quello che ti ho scritto
 
-- 
----- Italliaaaaa 3227! -----
Soldato Joker, cosa ci fa il soldato Palla di Lardo con quel fucile in 
mano nel mio fottutissimo bagno?
 
Sergente Artman [ da: "Full Metal Jacket" ]
 
 

strutture di bit...o api)lascio che decida lui!
 
 
ok, grazie: quindi in Vb.net i tipi primitivi sono comunque sempre
considerati come tipi classe


 
 
I tipi di dati in .Net (e in JAva) hanno dimensione fissa (non dipendenti 
dalla piattaforma). Int32 sarà sempre a 32bit e Integer è mappato su quello. :)
 

 infatti credo che su un S.O. 32 sia un int32 su un S.O.64 sia un int64
 
Non lo so, Balena sembra sostenere il contrario. Dice letteralmente 
"Ogni tipo primitivo Visual Basic corrisponde ad un tipo di dati nativo 
del .NET Framework [...] La corrispondenza è perfetta, e si possono 
anche dichiarare le proprie variabili utilizzando il tipo di dato .NET 
se si preferisce". Poi segue tabella che riporta la mappatura precisa.
 
-- 
Saluti
VITRIOL

 ha scritto:

E' così infatti, Integer è mappat su Int32 e Long su Int64 :) etcetc
 
 

 ciao, Jasmine
 
sono oggetti...! Non hai il codice dei predefiniti quindi non hai la 
"classe"!
Ma come oggetti hanno metodi statici e di istanza....e addirittura 
metodi ridefinibili(dipende non tutti)
Derivano tutti da un oggetto "superpadre" (o "supermadre") 
System.Object
 
Se poi ci vogliamo spingere nel tecnico (e io sono il meno adatto)
Int32 è una STRUTTURA....ossia è un tipo VALORE
http://msdn.microsoft.com/it-it/library/system.int32.aspx
 
 
La differenza fra tipi valore e riferimento....passa attraverso 
concetti di boxing unboxing che probabilmente anche il java avrà!
 
 
 
 
ho detto sopra una cazzata...nei forum microsoft si dice che 
ATTUALMENTE Integer punta ANCORA ad un int32. Nel futuro però potrebbe 
cambiare. in vb6 per dire un integer era un int16!
 
-- 
----- Italliaaaaa 3227! -----
Ci sono cattivi esploratori che pensano che non ci siano terre dove 
approdare solo perché non riescono a vedere altro che mare attorno a 
sé.
(Francesco Bacone)
 
 

 considerati come tipi classe
 
I tipi sono tutti oggetti, anche se possono essere tipi valore 
(strutture) o tipi riferimento (classi).
 
-- 
Saluti
VITRIOL

 ha scritto:
E' mappato così ora!
E non sai se sarà mappato così in seguito!
Quindi se vuoi tagliare la testa al toro devi usare Int32 e anche su 
VB22 su OS 256bit avrà quella dimensione!
Altrimenti usa Integer e stai alal sorte di come il compilatore 
sostituirà questo "wrapper" "alias" "coso"
ehm...è già successo no?
ci si ricorda che in Vb6 si usava long per sfruttare il massimo di 
velocità del compilatore?
Infatti si tende(va) a far compilare con la lunghezza della WORD del 
processore...era più veloce!
Ora chissà che word avrà un Intel "oppelamaiella" 256bit 
"mammaquanti"core....usa integer e fidati del tuo compilatore
-- 
----- Italliaaaaa 3227! -----
Là dove l'uomo scopre un minimo di ordine, immediatamente ne suppone 
troppo.
(Francesco Bacone)

 "mammaquanti"core....usa integer e fidati del tuo compilatore
 
http://msdn.microsoft.com/query/dev10.query?appId=Dev10IDEF1&l=IT-IT&k=k(VB.INTEGER);k(TargetFrameworkMoniker-%22.NETFRAMEWORK%2cVERSION%3dV4.0%22);k(DevLang-VB)&rd=true
 
 
cito
Il tipo di dati Integer consente di ottenere prestazioni ottimali su 
processori a 32 bit. Gli altri tipi integrali vengono caricati e 
memorizzati più lentamente.
 
Io non sono un guru e quindi mi cheto
ma a meno di "incredibili finezze" sw/hw sarei portato a dire che su 
una cpu 64bit ciò non sia più vero...a meno che Integer non sia 
"wrappato" a un int64...ma sembra di no!
 
-- 
----- Italliaaaaa 3227! -----
Era Cecco, il figlio del fornaio; era un orribile butterato napoletano, 
col culo molto basso ed un alito agghiacciante tipo fogna di Calcutta.
(Fantozzi)
 
 

 
Esatto, infatti i tipi sono per la CLR , e questa ha il suo standard. come 
Java.
Queste tecnologie, per ora, non hanno i problemi tipici del C/C++ e tutti 
quelli dipendenti dall'architettura software/harwdare.

"classe"!
 
 
e dove sono istanziati?
Non in System.object...
 
scusa la confusione e grazie per la risposta
 
abbi pazienza!


 
 
i tipi numerici sono ValueType in .Net che in ultima istanza derivano da 
System.Object (per cui sono classi anche loro).
La differenza più "evidente" è che vengono allocati su stack e non su heap 
(come i ReferenceType).
 
 


Non capisco che te frega dove sono istanziati!....dentro NET
ossia dentro MSCORLIB Namespace System
 
"Visual Basic 2010 Guida Completa per lo sviluppatore" Hoepli
Pag.7
Sintesi
Sono chiamati Tipi Primitivi e risiedono Nella CLS Common Language 
Specification.
Tipi Primitivi
System.Boolean
System.Byte
System.Char
System.DateTime
System.Decimal
System.Double
System.int 16 32 64
System.single
System.timespan
System.string
System.Array
System.Object
....pag.9
2 categorie fondamentali di tipi
Tipi valore : GRAN PARTE (non tutti) dei tipi primitivi,enumerazioni, 
STRUTTURE
Tipi riferimento: Classi (aggiungo System.String)
 
I tipi valore contengono...IL VALORE
i tipi riferimento il puntatore alla zona di memoria che CONTIENE il 
valore.
....
I tipi valore non possono contenere un valore nullo e NON devono essere 
creati ESPLICITAMENTE (niente new)
I tipi riferimento....l'esatto contrario....
 
....il resto fai da te....comprati un buon libro....così non ne esci!!!
 
-- 
----- Italliaaaaa 3227! -----
Quando vedi la tua verità fiorire sulle labbra del tuo nemico, devi 
gioire, perché questo è il segno della vittoria.
(Giorgio Almirante)
 
 

 I tipi riferimento....l'esatto contrario....
quindi
 
Class Semaforo
  private dim _segnale as string
  public readonly property Lampada as string
    Get
      return _segnale
    End get
  end property
 
sub new(lamp as integer)
  if lamp=0 then
      _segnale="libero"
   else
      _segnale="occupato"
   end if
end sub
end class
 
 
proviamo ad usarlo
 
sub test
  dim Valore as integer
  dim PostoAuto1 as Semaforo
  Valore=1
  PostoAuto1 = new Semaforo(Valore)
  msgbox PostoAuto1.Lampada
end sub
 
Ho scritto al volo a ricordo....come vede NON devi istanziare 
ESPLICITAMENTE l'oggetto INTEGER...ma LO DEVI FARE con l'oggetto 
"Semaforo"!!!
 
-- 
----- Italliaaaaa 3227! -----
Verace o finta, è da temersi sempre  pietà di plebe.
(Vittorio Alfieri)
 
 

ossia dentro MSCORLIB Namespace System
 
 
se non riesco a capire esattamente cosa sto facendo, continuerň a fare
errori e a non comprendere perchč vengano sollevate determinate
eccezioni...
per quanto riguarda un buon libro... io avevo comprato un libro
"visual basic spiegato a mia nonna" che doveva essere un libro per
principianti assoluti ma certi argomenti non li tratta


 ciao, Jasmine
 
Qual'è il tuo dubbio? Hai letto la mia risposta?
 

 e dove sono istanziati?
 
Intendi dire perché non è necessario usare esplicitamente la parola 
chiave New? Se è così, secondo me è semplicemente perché il compilatore 
la sottintende.
Se scrivo Dim a As New Integer, non si lamenta.
Ad esempio New è necessario se si vuole popolare una array al volo:
 
Dim a() As Integer = New Integer() {1, 2, 3, 4, 5}
 
-- 
Saluti
VITRIOL

 sottintende.
ARGH!
Imho una ripassatina anche a te non ti farebbe male!!!
Una matrice è un tipo RIFERIMENTO che eredita da System.Array...in 
quanto tale il new va benissimo!
 
Cambio libro...Francesco Balena VB.net Nozioni di base
pag.63
la matrice di  
vb.net
 è un tipo riferimento ....ed infatti  ci sono 
cautele nel copiare matrici
 
-- 
----- Italliaaaaa 3227! -----
Che giovano a quell'uomo ottant'anni passati senza far niente?... 
Costui non è vissuto, ma si è attardato nella vita; né è morto 
tardi,... ma ha impiegato molto tempo per morire!
 
Lucio Anneo Seneca
 
 

 quanto tale il new va benissimo!
 
Va bene, ma alla fine per i tipi valore il New è sottinteso :-)
Una struttura, che è un tipo valore, può venire istanziata con o senza 
New, non è un errore in nessuno dei due casi.
 
-- 
Saluti
VITRIOL

 Non in System.object...
 
la domanda non ha senso :-)
 
facciamo un po' di chiarezza:
 
- in .Net tutto deriva da "Object", il tipo Object è tipo base per 
*tutti* i tipi del framework e implictamente anche per tutti i tuoi 
tipi.
 
- ogni linguaggio ha bisogno, per semplificare la vita a noi poveretti 
fondamentalmente, del concetto di immutabilità: che equivale a dire che 
una volta che ho assegnato un valore ad una locazione di memoria questo 
valore non può cambiare (punto).
 
- in .Net l'immutabilità viene realizzata attraverso le strutture, una 
struttura è immutabile mentre una classe è mutabile, cosa significa 
questa eresia?
 
Facciamo un esempio:
 
Int32 a = 0;
Int32 b = a;
 
a = 1;
 
All'inizio a vale 0, b ha lo stesso valore di a, ma siccome un intero è 
una struttura immutabile il valore di a viene _copiato_ in b, a questo 
punto la terza riga cambia ovviamente il solo valore di a.
 
Con le classi il giochetto funziona in maniera diversa, ovviamente:
 
class Person
{
   public Int32 Age;
}
 
Person a = new Person();
a.Age = 0;
 
Person b = a;
 
a.Age = 38;
b.Age??? => 38 :-)
 
In questo caso a e b sono devi veri e propri puntatori, a "punta" ad 
una locazione di meoria (che accidentalmente sta sullo heap) dove ci 
sono belli allineati tutti i valori che compogono l'istanza di Person, 
b punta semplicemente alla stessa locazione di memoria.
 
Una struttura, ad esempio un intero, viene definita ValueType e viene 
sempre passata per valore, mentre una classe viene definita 
ReferenceType e viene sempre passata per riferimento...interessante, 
quindi:
 
class Sample
{
   public void Execute( Int32 value )
   {
      value = 12;
   }
}
 
var v = 0;
var s = new Sample();
s.Execute( v );
 
v varrà sempre 0...perchè essendo v una struttura quando viene passata 
come argomento al metodo Execute il suo valore viene copiato.
 
class Sample
{
   public void Execute( Person p )
   {
      p.Age = 12;
   }
}
 
var person = new Person();
var s = new Sample();
s.Execute( person );
 
a questo piunto person.Age vale 12 perchè al metodo Execute viene 
passato il riferimento alla locazione di memoria dove di trovano i dati 
di person in quel momento, quindi a Execute viene a tutti gli effetti 
passato un puntatore che ha lo stesso indirizzo di person, ergo person 
e p "vedono" gli stessi dati.
 
Questa cosa è sempre vera? sni :-) nel senso che hai una keyword 
apposita per cambiare questo comportamento (ref in C# e ByRef/ByVal in 
VB.Net)
 
class Sample
{
   public void Execute( ref Int32 value )
   {
      value = 12;
   }
}
 
var v = 0;
var s = new Sample();
s.Execute( ref v );
 
stiamo passando v per reference, quindi stiamo passando il riferimento 
alla locazione di memoria dove stanno i dati ergo al termine di execute 
anche v varrà 12 :-)
 
A questo punto...la domanda curiosa è: ha senso una dichiarazione di 
questo genere?
 
class Sample
{
   public void Execute( ref Person p )
   {
      //...
   }
}
 
Person è già un reference type perchè passarlo per riferimento? questo 
è uno scenario abbastanza contorto che però val la pena capire:
quando passi un rifeimento sta passando un puntatore, o una cosa molto 
simile, che altro non è che un indirizzo di memoria...ergo che succede 
in uno scenario come questo:
 
class Sample
{
   public void Execute( Person p )
   {
      if( p == null )
      {
         p = new Person();
      }
      p.Age = 12;
   }
}
 
Person person = null;
var s = new Sample();
s.Execute( person );
 
Al termine di Excute person è? null...mannaggia ma non è un 
riferimento...? :-)
Certo che lo è, ma quello che succede è:
- person è un puntatore all'area di memoria;
- person punta a nulla;
- person è un "indirizzo";
- person viene passato a Excute;
- l'indirizzo viene copiato;
- ma person non punta a nessun indirizzo, quindi p è la copia di 
qualcosa che non punta a nulla;
- a questo punto person resta un indirizzo che non punta a nulla;
 
Se invece lo passi per riferimento funziona, il che in certi scenari 
limite è un paraculo non da poco :-)
 
Prima di smettere di tediarti un'ultima nota importante: in giro si 
legge che la differenza fondamentale tra value e reference è che i 
primi vengono allocati sullo stack mentre i secondi sullo heap, è 
falso, o meglio nell'implementazione attuale del CLR è così (neanche in 
tutti i i casi) ma non c'è scritto da nessuna parte che deve essere 
così, quindi ad esempio Mono o prossime versioni del CLR possono fare 
scelte diverse. In generale comunque è un problema che non ti tocca.
 
.m
 
-- 
è corta
 
 

VITRIOL ha pensato forte :

Che c'entra questo?....leggiti la risposta di Mauro!
Allora anche un microonde è uguale ad un pc....dentro c'è sempre una 
cpu!
 
-- 
----- Italliaaaaa 3227! -----
Il grande maestro di pittura meta-gastro-fisica Luciano Lupoletti in:
David Arlequin
http://www.lupoletti.com/public/lupoletti/09-10-24-12-05-21@David%20Arlequin%20-%20Olio%20su%20tela.jpg
 
 
(ROTFL: oddio mi ribalto)
 
 

 
 
Volendo essere pignoli in realtà lo stack è puramente indicativo. 
 

 Che c'entra questo?....leggiti la risposta di Mauro!
 
Ma quello credo di saperlo... una variabile è un puntatore, alla quale 
può venire assegnato un oggetto, e si comporta in modo differente se 
l'oggetto è un valore o un riferimento.
Però forse il mio era un discorso diverso. Se dichiaro un tipo valore 
(es. una struttura) con o senza New, cambia qualcosa? La risposta può 
essere solo sì o no. Io avevo detto no, ma posso sbagliarmi facilmente :-)
 
-- 
Saluti
VITRIOL

Ciao VITRIOL,

facendo una prova e spulciando nell'IL generato si evince che per i 
value type:
 
int x = 10
int y = new Int32();
 
in nessun caso esiste la "newobj", ma c'è sempre e solo:
 
ldc.i4.s 10 //carico il valore 10 in un intero
stloc.0 //assegno alla prima "variabile" il valore caricato
 
.m
 
-- 
è corta
 
 

 Volendo essere pignoli in realtà lo stack è puramente indicativo.
 
non ho capito
 
.m
 
-- 
è corta
 
 

Qual'� il tuo dubbio? Hai letto la mia risposta?
 
 
 si l'ho letta, ma leggendo la tua risposta ora non capisco
piu' cosa intendesse dire Wodka
 
Qui dice questo:
http://msdn.microsoft.com/it-it/library/aa711900%28v=vs.71%29.aspx
 
 
 
dice che i tipi primitivi sono impossibili da distinguere dal tipo
struttura di cui costituiscono un alias
 
praticamente in visual basic non esistono dei tipi realmente
primitivi come esistono in java
 
in java int � diverso da integer anche se boxing e unboxing
automatici rendono la differenza poco percepibile


la sottintende.
 
 
certo


 stloc.0 //assegno alla prima "variabile" il valore caricato
 
ok, non ho studiato a memoria le specifiche ISO 23271 ma a quanto 
ricordo quell'IL viene utilizzato solo se il value type fa parte di 
quelli noti al CLR (tipicamente i "numeri", o cmq quelli che cle 
specifiche ISO definiscono come "built-in data types"), mentre il codice 
IL dovrebbe essere differente per un DateTime o per una structure 
Persona. Appena ho 10 min mi armo di standard ISO+Reflector e torno 
sull'argomento (inutile, ma sempre interessante).
 
-- 
.A
GUISA - 
http://www.guisa.org
 
UGIdotNET - 
http://www.ugidotnet.org
 
Read my blog at: 
http://blogs.ugidotnet.org/pape
 

scelte diverse. In generale comunque � un problema che non ti tocca.
non dovrebbe toccarmi, per questioni di performance?


 automatici rendono la differenza poco percepibile
si, � una delle feature di Java "ispirate" da .NET (come le annotazioni) :-)


 non dovrebbe toccarmi, per questioni di performance?
 
no, piuttosto perchè a te non cambia nulla sapere dove è allocato un 
determinato oggetto.
 
.m
 
-- 
è corta
 
 


oki, ho "trovato" i 10 minuti :-)
 
Ecco il codice "originale" e il corrispondente IL:
 
VB:
	Dim now As DateTime = DateTime.Now
IL:
	call valuetype [mscorlib]System.DateTime 
[mscorlib]System.DateTime::get_Now()
 
VB:
	Din d2 As New DateTime(1974, 11, 13)
 
IL:
	ldc.i4 0x7b6
     	ldc.i4.s 11
     	ldc.i4.s 13
     	newobj instance void [mscorlib]System.DateTime::.ctor(int32, 
int32, int32)
 
VB:
     	Dim p As New Persona With { _
         	.Nome = "Mario" _
     	}
 
IL:
	ldloca.s p
	initobj TheNamespace.Persona
	ldloca.s p	
	ldstr "Mario"
     	call instance void TheNamespace.Persona::set_Nome(string)
 
 
VB:
	Dim p2 As New Persona With { _
         	.Nome = "Luca" _
     	}
 
IL:
	ldloca.s p2
	initobj TheNamespace.Persona
	ldloca.s p2	
	ldstr "Luca"
     	call instance void TheNamespace.Persona::set_Nome(string)	
 
 > ok, non ho studiato a memoria le specifiche ISO 23271 ma a quanto
 > ricordo quell'IL viene utilizzato solo se il value type fa parte di
 > quelli noti al CLR (tipicamente i "numeri", o cmq quelli che cle
 > specifiche ISO definiscono come "built-in data types"), mentre il codice
 > IL dovrebbe essere differente per un DateTime o per una structure
 > Persona.
 
è esattamente come (nonostante l'età che avanza...) ricordavo: ad 
eccezione dei tipi "built-in" nel CLR (IntXX, Single/Double, ... per 
intenderci, quelli "mappabili" sul type system nativo di una CPU/FPU 
"fisica", perchè così il CLR può "barare" quando JIT-ta), anche i value 
type usano newobj/initobj, indipendentemente dal fatto che siano "BCL" 
(es: DateTime) o custom (es: Persona).


 Persona).
 
ottimo :-)
Aggiungo alla discussione tre spettacolari post di Eric Lippert (che 
per inciso è uno che ne sa parecchio) sulla "questione" stack/heap:
 
http://blogs.msdn.com/b/ericlippert/archive/2009/04/27/the-stack-is-an-implementation-detail.aspx
 
 
http://blogs.msdn.com/b/ericlippert/archive/2010/09/30/the-truth-about-value-types.aspx
 
 
http://blogs.msdn.com/b/ericlippert/archive/2010/10/11/debunking-another-myth-about-value-types.aspx
 
 
.m
 
-- 
è corta
 
 

Correva il 22/09/2011 e rincorrendolo Andrea Saltarello scriveva:
zac
Tradotto (non me ne volete guru non mi permetto affatto di mettere in 
discussione nulla di quanto detto....potete anche ballare con i piedi 
sulla mia faccia...) in parole terra terra
Per quanto virtuale sia java o net ...prima o poi sempre da una cpu 
VERA ,di silicio, passa!
In questo passaggio l'ambiente java o net cerca di barare il piï¿œ 
possibile per non fa storcere il naso a john e nostalgici di C e 
puntatori vari con le loro piangine sulla velocitï¿œ!
per farlo usa il piï¿œ possibile i registri interni della CPU....
Non puï¿œ farlo con un "oggetto" ANCHE VALORE fatto da me 
programmatore...
ma puï¿œ farlo con alcuni TIPI standard (ad esempio l'integer che ci sta 
benissimo in una word della cpu).
Questi tipi predefiniti vengono sparati nei registri della CPU per fare 
le cose il piï¿œ veloce possibile.
DI questi tipi non hai il controllo sono predefiniti. Poi vengono come 
ti han detto inseriti in namespace e robe simili per avere una COERENZA 
 formale di utilizzo
quindi un Integer.TryParse ï¿œ lecito....pensalo come vuoi...new 
nascosto...emanazione plenaria di zioBill...tutto quello che 
vuoi....non ti cambia nulla.....sono cazzi del compilatore gestirselo!
A te RILEVA che ha una struttura formale coerente con l'ambiente di 
sviluppo:
tipi valore
tipi riferimento
Strutture
Classi
Metodi di Istanza
Metodi Statici
e via andare
....perï¿œ permettimi dopo tanti post che faccia IO qualche domanda a te:
MA PERCHE' un post del genere?
Che ragione c'ï¿œ?
Un post del genere scatena i guru come hai visto per trovare il pelo 
nell'uovo....a che pro? Che problema cosi particolare...anzi 
iper-particolarissimo...hai per invischiarti in questo ginepraio?
Stai costruendo una cpu virtuale? Un nuovo compilatore?
Tu parlavi di "errori"....ma che errori ti vengono chiariti da una 
discussione del genere?
Parla un po tu.....a che ti serve una discussione del genere???
-- 
----- Italliaaaaa 3227! -----
Mi disturba la morte, ï¿œ vero. Credo che sia un errore del padreterno. 
Non mi ritengo per niente indispensabile,
ma immaginare il mondo senza di me: che farete da soli?
(Vittorio Alfieri)

Parla un po tu.....a che ti serve una discussione del genere???
 
 
a me serve perchč sto studiando contemporaneamente (per dei corsi
serali che sto facendo), sia java che visual basic (o meglio il corso
su vb č finito, ma non so bene quando, avro' un esame
che mi terrorizza alquanto, mi terrorizza l'idea di poter prendere
o 2 o 3)
 
di vb capisco ben poco mentre - almeno credo- mi trovo meglio con java
quindi sto cercando di ricondurre vb a java per venirne fuori.
 
Tutto qui.
 
Poi, cmq non capisco perchč mi si rimproveri di aver scatenato
un'ecezzione... ops di aver innescato una discussione che mi sembra
molto interessante.
 
Ciao, Jasmine


23271. 
Benissimo, grazie mille


Jasmine scriveva il 22/09/2011 :
io non ti rimprovero nulla ci mancherebbe ...ogni tanto una discussione 
diversa va benissimo!
solo che è una discussione TROPPO tecnica per un corso serale!
 
della serie...prima di arrivare ai registri della CPU mi sembra che ce 
ne siano di cose da chiarire ed assimilare!
 
Cito Jasmine
On Wed, 21 Sep 2011 15:41:57
"se non riesco a capire esattamente cosa sto facendo, continuerò a fare
errori e a non comprendere perchè vengano sollevate determinate
eccezioni..."
 
ecco io mi concentrerei su questo fossi i te: perchè mi escono 
eccezioni nei miei programmi?
Che tipo di eccezioni?
 
quello che hai detto finora....scusami...interessantissimo...ma assai 
poco attinente con quanto detto
a meno che tu non faccia
dim A as integer = "PIPPO27"
 
Quindi non sto riprendendo nessuno....anzi.....finalmente qualcuno che 
ci prova a capire
MA
permettimi....
senza uno step by step con un buon insegnante e/o libro...
e lo dico da autodidatta che c'è passato
si fa solo casino mentale!
 
Figurati tu che metti l'arrosto sul fuoco DOtNet e il fritto misto 
Java!!!
 
:D
 
 

 wrote:
zac
 
Ti segnalo
http://totemslair.org/guide/vb.php
 
la solita guida....facile...chiara...esaustiva il giusto per 
padroneggiare le basi....fare programmi senza troppi errori ...e 
cominciare ad esplorare autonomamente il framework dotNet
 
Gratis in italiano con supporto MySql
 
 

dim A as integer = "PIPPO27"
 
dim A as Integer= Integer.Parse("PIPPO027")
 
 
dovrebbe essere possibile, giusto?
 
ciao, Jasmine


 dovrebbe essere possibile, giusto?
E che intero sarebbe PIPPO027?
-- 
Saluti
VITRIOL

E che intero sarebbe PIPPO027?
 
 
anche se non avesse un senso...
sarebbe cmq possibile?
 
voglio dire un char comunque corrisponde ad un valore
numerico, una stringa invece?
non è un po' come un array di char?


 sarebbe cmq possibile?
Per il metodo Parse guardati CultureInfo e FormatProvider per vedere 
cosa pu� convertire.
Per quanto riguarda le stringhe credo si possano trattare come un array 
di char, ad esempio:
	Dim s As String = "PIPPO027"
         Dim c As Char = s(2)
Se invece vuoi convertire un char nel suo codice numerico (credo 
unicode) puoi fare:
         Dim i As Integer = Convert.ToInt32(c)
-- 
Saluti
VITRIOL

 wrote:
e poi non hai letto ....o non hai capito quello che ti avevo postato
 
CI RIPROVO
 
 Dim a As Integer
 
        Dim c As String = "pippo27"
        Dim d As String = "56"
 
        If Integer.TryParse(c, a) Then
            MsgBox(a.ToString)
 
        End If
        If Integer.TryParse(d, a) Then
            MsgBox(a.ToString)
 
        End If
 
 
Invalid cast non ne escono
 
a = DirectCast(c, Integer) ....ti segnala prima che non puoi farlo!
l'IDE si rifiuta!
....mentre non si rifiuta e solo in sede di run ti segnala il cast 
sbagliato
a = CType(c, Integer)
 
Considera che esiste una cosa chiamata TIPIZZAZIONE FORTE
non puoi scambiare PERE con BULLONI...ne far finta che sia così!
 
Lo ripeto...senza un libro non ne esci!