Question: Ex: 

Parse : `int inumber = int.Parse(Console.ReadLine());`

(*Data Type*): `int inumber = (int)(Console.Read());`

Pls explain for me (give the Ex is better :D )
Thanks! :)

Answer: 
Well, `Console.Read()` returns `int`, not `String` so the cast in the code is *redundant*:

<https://msdn.microsoft.com/en-us/library/system.console.read(v=vs.110).aspx>

you can put just

```
  int inumber = Console.Read(); // no need to (int) here

```

and please, notice than `Console.Read()` returns not the integer value you've input (say, `123456`), but

> 
> The next character from the input stream, or negative one (-1) if
>  there are currently no more characters to be read.
> 
> 
> 

As for `Console.ReadLine()` it returns `String` and if the string represents a valid integer (say, `"123"`) you can parse it

```
  int inumber = int.Parse(Console.ReadLine());

```

however, if input string can't be treated as integer (e.g. `"bla-bla-bla"`) you'll have an *exception* thrown. You may want `TryParse` method as well:

```
  int number;

  if (int.TryParse(Console.ReadLine(), out number)) {
    // ReadLine represents a valid integer which is parsed into number
  }
  else {
    // ReadLine can't be parsed into a valid integer 
  }

```
you are asking why when you need to 'convert' data from one type to another there are 2 different concepts: casting and parsing. Its actually a very good question. To old programmers like me the answer feels obvious: if the conversion is not very large then its a cast, otherwise you must usean explicit function (like Parse, or atol,...). But in fact thats a completely arbitrary distinction.

For C# numeric casts cast between types that are already numeric, int to long, double to int, .... 

The C# Parse functions typical work on a string that contains a text representation of something (in your case a number). In this case its converting a human readable things (string) to a machine readable internal representation (int).

Just to see how inconsistent this is, c++ has `static_cast<>` that basically does the number to number cast, and `lexical_cast<>` that does the Parse type thing

In you code sample the `(int)`Console.Read()` has taken the single character typed and cast it to an int. If you type '1', you will get 49. See if you can work out why - look here <http://www.asciitable.com/>