Integer Do's And Don'ts

[John Baker]

When declaring an integer, you can specify the size by using int16,
int32, or int64, with plain integer being int32.

Is integer the accepted default in the programming community?

If so, is there a way to remove the ones with size predefined from the
autolisting of types when I am declaring something?
--
To Email Me, ROT13 My Shown Email Address

[Ken Dopierala Jr.]

Hi,

I don't think you can remove them from the drop down. The best bet is to
use just plain Integer. That will assure that you are using a 32-bit
integer and right now it is the fastest because it plays well with 32bit
boundaries that are using in 32bit programming models. If you are going to
mix them up then remember to put Option Strict On at the top of your code
pages. This will save you headaches when it comes to converting between
them in calculations and assignments. Good luck! Ken.

--
Ken Dopierala Jr.
For great ASP.Net web hosting try:
http://www.webhost4life.com/default.asp?refid=Spinlight
If you sign up under me and need help, email me.

"John Baker" <wb********@wzw freivprf.pbz> wrote in message
news:Sy******** *********@fe1.c olumbus.rr.com. ..

When declaring an integer, you can specify the size by using int16,
int32, or int64, with plain integer being int32.

Is integer the accepted default in the programming community?

If so, is there a way to remove the ones with size predefined from the
autolisting of types when I am declaring something?
--
To Email Me, ROT13 My Shown Email Address

[Gerald Hernandez]

At one time I got the impression that Integer was a generic term that would
map to the native integer size of the environment in which you were running.
There was also some sort of guarantee that it would not be smaller than
Int32. This would ensure you would get the best performance if you did not
need a particular size.
In the future, Integer might map to Int64, Long might map to Int128, or
whatever.

However, I have also read a number of things countering this saying Integer
will always map to Int32. The first argument made more sense to me, but I
truly do not know the future plans.

But to be on the safe side, here is what I do.
If all I need is a generic integer of at least size Int32, then just use the
Integer keyword, which is almost always the case.
If I am dealing with things like bit-fields or reading datablocks from files
that I know are a specific size, then I explicitly declare the integer size.

Gerald

"John Baker" <wb********@wzw freivprf.pbz> wrote in message
news:Sy******** *********@fe1.c olumbus.rr.com. ..

When declaring an integer, you can specify the size by using int16,
int32, or int64, with plain integer being int32.

Is integer the accepted default in the programming community?

If so, is there a way to remove the ones with size predefined from the
autolisting of types when I am declaring something?
--
To Email Me, ROT13 My Shown Email Address

[Herfried K. Wagner [MVP]]

"John Baker" <wb********@wzw freivprf.pbz> schrieb:

When declaring an integer, you can specify the size by using int16,
int32, or int64, with plain integer being int32.

Is integer the accepted default in the programming community?
There are different standpoints on the question of preferring the aliases
over the type names as they can be found in the .NET Framework.

Personally, I use 'Integer', 'Short', ... when I am writing fully managed
code. When interoperating with unmanaged code, I prefer the more low-level
names, 'Int32', 'Int16', ...
If so, is there a way to remove the ones with size predefined from the
autolisting of types when I am declaring something?

No.

--
Herfried K. Wagner [Microsoft MVP]
<URL:http://dotnet.mvps.org/>

[Cor Ligthert]

John,

Because there are different opinions, I go for as far as now posted Ken.
What is almost the same as for Gerald, however your question was Integer not
any other special format that has to be used, because it is needed in that
special format, so I am not sure what he mean with that, however I think the
same as Ken and me.

The Integer keyword ensures you that after recompiling the machine most
properiate format is used. Any other format can lead (now or in future) to
extra processing time when it is not optimized by the compiler.

Just my thought

Cor

"John Baker" <wb********@wzw freivprf.pbz>

When declaring an integer, you can specify the size by using int16, int32,
or int64, with plain integer being int32.

Is integer the accepted default in the programming community?

If so, is there a way to remove the ones with size predefined from the
autolisting of types when I am declaring something?
--
To Email Me, ROT13 My Shown Email Address

[Larry Serflaten]

"Cor Ligthert" <no************ @planet.nl> wrote

The Integer keyword ensures you that after recompiling the machine most
properiate format is used.

Is that documented? Where?

LFS

[Cor Ligthert]

Larry,

The Integer keyword ensures you that after recompiling the machine most
properiate format is used.

Is that documented? Where?

Larry read the answer again, there is in my opinion not any need for
documentation, do you think that Int16 ensures you that (read in the
question as well and see that we are talking about integers).

Cor

[Cor Ligthert]

Larry,

When sending my previous answer about CDate to somebody else, I remembered
me that it is documented in this page.

This is the text
Data Type Width
The most efficient data types are those that use the native data width of
the run-time platform. On current platforms, the data width is 32 bits, for
both the computer and the operating system.

Consequently, Integer is currently the most efficient data type in Visual
Basic .NET. Next best are Long, Short, and Byte, in that order of
efficiency. You can improve the performance of Short and Byte by turning off
integer overflow checking, for example by setting the RemoveIntegerCh ecks
property, but this incurs the risk of incorrect calculations due to
undetected overflows. You cannot toggle this checking on and off during run
time; you can only set its value for the next build of your application.

If you need fractional values, the best choice is Double, because the
floating-point processors of current platforms perform all operations in
double precision. Next best are Single and Decimal, in that order of
efficiency.

http://msdn.microsoft.com/library/de...tchPerfOpt.asp

I hope this is where you are looking for when your question was purely about
the documentation and not for discussion.

Cor

[Herfried K. Wagner [MVP]]

Larry,

"Larry Serflaten" <se*******@usin ternet.com> schrieb:

The Integer keyword ensures you that after recompiling the machine most
properiate format is used.

Is that documented? Where?

Nope. 'Integer' always maps to 'System.Int32'. That's documented here:

Visual Basic Language Reference -- 'Integer' Data Type
<URL:http://msdn.microsoft. com/library/en-us/vblr7/html/vadatinteger.as p>

--
Herfried K. Wagner [MVP]
<URL:http://dotnet.mvps.org/>

[Larry Serflaten]

"Cor Ligthert" <no************ @planet.nl> wrote

The most efficient data types are those that use the native data width of
the run-time platform. <...> Consequently, Integer is currently the most efficient data type in Visual
Basic .NET.

But that does not say what you indicated, that using Integer will ensure you get
the most efficient (native) type. An Integer is always 32 bits on every system:

"Integer variables are stored as signed 32-bit (4-byte) integers ranging in value from -2,147,483,648 through 2,147,483,647"
The only two that I have heard of, that do change on different systems is
the IntPtr and UIntPtr types:

"The IntPtr type is designed to be an integer whose size is platform-specific. That is, an instance of this type is expected to
be 32-bits on 32-bit hardware and operating systems, and 64-bits on 64-bit hardware and operating systems."

HTH
LFS