CODEWITHSUNDEEP
c#methodsint
Arthur Mamou-Mani
Arthur Mamou-Mani

Reputation: 2333

In a C# public method, what does the `int` indicate apart from the type integer?

In C#, when defining a public method like: 

public int myMethod(String someString)
{  
   //code  
}

What does the int indicate apart from the type integer? What confuses me is that the method is using a String as arguments in this case.

Upvotes: 9

Views: 8457

Answers (5)

Olivier Jacot-Descombes
Olivier Jacot-Descombes

Reputation: 112334

It is the return type of the method. In this case a 32-bit signed integer with a range of 

-2,147,483,648 .. +2,147,483,647

It corresponds to the .NET type System.Int32. int is just a handy C# alias for it.

You would return a value like this

public int Square(int i)
{
    return i * i;
}

And you could call it like this

int sqr = Square(7); // Returns 49
// Or
double d = Math.Sin(Square(3));

If you do not need the return value, you can safely ignore it.

int i;
Int32.TryParse("123", out i); // We ignore the `bool` return value here.

If you have no return value you would use the keyword void in place of the type. void is not a real type.

public void PrintSquare(int i)
{
    Console.WriteLine(i * i);
}

And you would call it like this

PrintSquare(7);

The method in your example accepts a string as input parameter and returns an int as result. A practical example would be a method that counts the number of vowels in a string.

public int NumberOfVowels(string s)
{
    const string vowels = "aeiouAEIOU";

    int n = 0;
    for (int i = 0; i < s.Length; i++) {
        if (vowels.Contains(s[i])) {
            n++;
        }
    }
    return n;
}

Upvotes: 8

jacqijvv
jacqijvv

Reputation: 880

Everyone is correct here but the definition from msdn:

"Int32 is an immutable value type that represents signed integers with values that range from negative 2,147,483,648 (which is represented by the Int32.MinValue constant) through positive 2,147,483,647 (which is represented by the Int32.MaxValue constant. The .NET Framework also includes an unsigned 32-bit integer value type, UInt32, which represents values that range from 0 to 4,294,967,295."

Found here on MSDN: Int32 Structure

I suggest you read the documentation found in the link above. It is extremely useful.

Upvotes: 1

Diego
Diego

Reputation: 18359

It stands for "integer", and it means the method returns an integer number of 32 bits, also known in C# as Int32.

Upvotes: 6

Ashley Davies
Ashley Davies

Reputation: 1893

As previously stated, it's what the method returns.

For example:

public string x()
{
 return 5;
}

Would error. 5 is definitely not a string!

public int x()
{
 return 5;
}

Would be correct; since 5 can be considered an int (Short for integer, which is, basically, just a number which cannot have a decimal point. There's also float, double, long and decimal, which are worth reading about)

There must be no way of it not returning, for example, if you do:

public int x()
{
 if (false)
 {
  return 5;
 }
}

It will error because if the expression is false (It is of course) it won't be returning an int, it won't return anything.

If you use the keyword void, it means it does not return anything. Ex:

public void x()
{
 someFunction("xyz");
}

It's fine that it doesn't return as it's a void method.

I don't think you're new to programming judging by your reputation, but just in case, when you return something you pass it back from the method, for example:

int x;

public int seven()
{
 return 7;
}

x = seven();

x will become the return value of the function seven.

Note that the 'dynamic' type works here:

public dynamic x(int x, int y)
{
 if (x == y)
 {
  return "hello";
 }
 return 5
}

But if you're new to C# don't get caught up in dynamic typing just yet. :)

Upvotes: 5

David Heffernan
David Heffernan

Reputation: 612934

It is the type of the return value.

Upvotes: 3

Related Questions