C# int tipusú változó bekérése?

hogy ne lenne... és utasításszámban pont ugyanannyi, 1 darab hívás...

a te példáddal:

int valtozo = int.Parse(Console.Readline());

Persze ebben az esetben nem javaslom ezt a módot. Ha konzolról vagy olyan helyről olvasol be ahonnan bármi jöhet: int.TryParse, ahogy te si mondtad.

Ha elvileg ellenőrzött helyről ahol ha nem megfelelő adat jön az "nagy gond", tehát nem gond, ha pl az egész beolvasás elszáll a formátum miatt, akkor int.Parse.

  static void NumericTest(string input)

        {

            Console.WriteLine("Előjelesek: ");

            try

            {

                sbyte sbyteVar = Convert.ToSByte(input);

                WriteVariableData(sbyteVar, nameof(sbyteVar));

                SByte SByteVar = Convert.ToSByte(input);

                WriteVariableData(SByteVar, nameof(SByteVar));

            }

            catch (Exception ex)

            {

                Console.WriteLine($"sbyte: {ex.GetType()} - {ex.Message}");

            }

            try

            {

                short shortVar = Convert.ToInt16(input);

                WriteVariableData(shortVar, nameof(shortVar));

                Int16 Int16Var = Convert.ToInt16(input);

                WriteVariableData(Int16Var, nameof(Int16Var));

            }

            catch (Exception ex)

            {

                Console.WriteLine($"short: {ex.GetType()} - {ex.Message}");

            }

            try

            {

                int intVar = Convert.ToInt32(input);

                WriteVariableData(intVar, nameof(intVar));

                Int32 Int32Var = Convert.ToInt32(input);

                WriteVariableData(Int32Var, nameof(Int32Var));

            }

            catch (Exception ex)

            {

                Console.WriteLine($"int: {ex.GetType()} - {ex.Message}");

            }

            try

            {

                long longVar = Convert.ToInt64(input);

                WriteVariableData(longVar, nameof(longVar));

                Int64 Int64Var = Convert.ToInt64(input);

                WriteVariableData(Int64Var, nameof(Int64Var));

            }

            catch (Exception ex)

            {

                Console.WriteLine($"long: {ex.GetType()} - {ex.Message}");

            }

            Console.WriteLine("\nElőjelnélküliek: ");

            try

            {

                byte byteVar = Convert.ToByte(input);

                WriteVariableData(byteVar, nameof(byteVar));

                Byte ByteVar = Convert.ToByte(input);

                WriteVariableData(ByteVar, nameof(ByteVar));

            }

            catch (Exception ex)

            {

                Console.WriteLine($"byte: {ex.GetType()} - {ex.Message}");

            }

            try

            {

                ushort ushortVar = Convert.ToUInt16(input);

                WriteVariableData(ushortVar, nameof(ushortVar));

                UInt16 UInt16Var = Convert.ToUInt16(input);

                WriteVariableData(UInt16Var, nameof(UInt16Var));

            }

            catch (Exception ex)

            {

                Console.WriteLine($"ushort: {ex.GetType()} - {ex.Message}");

            }

            try

            {

                uint uintVar = Convert.ToUInt32(input);

                WriteVariableData(uintVar, nameof(uintVar));

                UInt32 UInt32Var = Convert.ToUInt32(input);

                WriteVariableData(UInt32Var, nameof(UInt32Var));

            }

            catch (Exception ex)

            {

                Console.WriteLine($"uint: {ex.GetType()} - {ex.Message}");

            }

            try

            {

                ulong ulongVar = Convert.ToUInt64(input);

                WriteVariableData(ulongVar, nameof(ulongVar));

                UInt64 UInt64Var = Convert.ToUInt64(input);

                WriteVariableData(UInt64Var, nameof(UInt64Var));

            }

            catch (Exception ex)

            {

                Console.WriteLine($"ulong: {ex.GetType()} - {ex.Message}");

            }

            Console.WriteLine("\nLebegőpontosak: ");

            try

            {

                float floatVar = Convert.ToSingle(input);

                WriteVariableData(floatVar, nameof(floatVar));

                Single SingleVar = Convert.ToSingle(input);

                WriteVariableData(SingleVar, nameof(SingleVar));

            }

            catch (Exception ex)

            {

                Console.WriteLine($"float: {ex.GetType()} - {ex.Message}");

            }

            try

            {

                double doubleVar = Convert.ToDouble(input);

                WriteVariableData(doubleVar, nameof(doubleVar));

                Double DoubleVar = Convert.ToDouble(input);

                WriteVariableData(DoubleVar, nameof(DoubleVar));

            }

            catch (Exception ex)

            {

                Console.WriteLine($"double: {ex.GetType()} - {ex.Message}");

            }

            try

            {

                decimal decimalVar = Convert.ToDecimal(input);

                WriteVariableData(decimalVar, nameof(decimalVar));

                Decimal DecimalVar = Convert.ToDecimal(input);

                WriteVariableData(DecimalVar, nameof(DecimalVar));

            }

            catch (Exception ex)

            {

                Console.WriteLine($"decimal: {ex.GetType()} - {ex.Message}");

            }

        }

        static void WriteVariableData(object var,string name)

        {

            Type varType = var.GetType();

            Console.WriteLine($"nevem: {name,-12} tipusom: {varType,-16} méretem: {System.Runtime.InteropServices.Marshal.SizeOf(var)+" "+"B",-8} értékem: {var}");

        }

        static void Main(string[] args)

        {

            Console.Write("írj be egy számot: ");

            string input = Console.ReadLine();

             NumericTest(input);

            Console.ReadKey();

        }

Tegyük tisztába a dolgokat!

A "sima" int az ugyanaz, mint az Int32. [link] Csak C#-ban a legtöbb típusnak két neve van, van egy "hagyományos" neve, meg van egy .NET-es, logikusan felépített neve, amiről egyből látod, hogy az hány bites, és milyen értéket tárol. Ízlés kérdése, hogy ki melyiket használja.

A "sima" int, mint írtam, megegyezik az Int32-vel, szóval semmivel nem vagy vele előbbre.

Hogy mindenhol Convert.ToInt32 lenne? Ez butaság. Én is számtalanszor konvertáltam már "kisebb" típusra. Az más kérdés, hogy sokan "reflexből" mindig Int32-re konvertálnak, ez puszta megszokás, és sokszor elég rossz gyakorlat. Simán lehet Int16-ra vagy Byte-ra konvertálni: [link]

Az pedig, hogy spórolni akarsz a memóriával, egy becsülendő dolog, és tényleg sokan példát vehetnének erről a hozzáállásról; viszont egy kicsikét azért túlreagálod. Mennyi RAM van a gépedben? Az enyémben 12 GB. Most az, hogy egy változó 1, vagy 4 bájtot foglal el, ilyen környezetben annyira már nem számottevő. (Pláne, hogy a fordító általában olyan kódot generál, ami "pazarol" kicsit a memóriával, annak érdekében, hogy 4-gyel (vagy 8-cal) osztható címen kezdődjön a változó, mivel így gyorsabban tudja kiolvasni.) Ettől persze még egy jó gyakorlat az, hogy ami eleve nem fog 255-nél nagyobb értéket felvenni, azt Byte-ként deklarálod. Konvertálásnál pedig a Convert.ToByte-ot használod.

Az értéktartományokat persze nem választhatod meg szabadon, tehát nem tudsz olyan adattípust létrehozni, ami pont annyi memóriát foglal le, ami egy 0 és 10 közé eső számnak kell. Csak kerek számú bájtokat tud kezelni a rendszer, tehát 1 teljes bájtot mindenképp elhasznál, akkor is, ha mondjuk elméletben 4 bit is elég lenne.

"Pláne, hogy a fordító általában olyan kódot generál, ami "pazarol" kicsit a memóriával, annak érdekében, hogy 4-gyel (vagy 8-cal) osztható címen kezdődjön a változó, mivel így gyorsabban tudja kiolvasni.)"

Ezt honnan veszed?