| Printable Version
C# Methods
By Michael Youssef
Introduction to C# Methods :
Just in the beginning I like to remind all of you that Computer programs
exist to solve a problems and there are methods for solving those problems.
That's how I can explain the meaning of C# methods. All C# programs
constructed from a number of classes and those classes contain methods that
solve the problems for the program. So a methods is a kind of building blocks
that solve a small problem.
For example you have a problem in your program. You need a method to convert
a string to integer array for some reason. You can use the following method :
private int[]
ToIntArray(string s)
{
int o = s.Length;
int[] iArray =
new
int[o];
for(int
x = 0; x < s.Length; x++)
{
iArray[x] = Convert.ToInt32(s.Substring(x,1));
}
return iArray;
}
So with this method we solve the problem we have here (
if we have a string like "911" this method will convert it to integer array
[9,1,1] ). We will not talk about the code written inside the method now but we
will focus on introducing you to methods and later we will take a lot of
examples. Just note that we use the .NET Framework Class Library (FCL) methods
(like ToInt32(), Substring()) inside our methods to create a new methods. That's
make our job as a programmers much easier.
When you declare a variable in your method then it's a
local variable to that method and no other method can know anything about that
variable.
Methods also very useful if you will use a block of
code many times in your program so instead of writing the same block of code
many times in the program we can put that code in a method and call it whenever
we need it to do the job.
How we write C# methods ?
After reading this section you will be able to write
methods and understand the concept of (Parameters, Return Value)
We have a line of code and we need to put it inside a
method so we understand how we can write C# methods.
Console.WriteLine(Math.Sqrt(9));
This line of code use the Sqrt method of the class Math to get the square
root of 9 . We need to create a method to write to the console screen the square
root just when we use it (when we call it, Invoke it). Let's take a look
at this method :
static void
SqrtToConsole(double
x)
{
Console.WriteLine(Math.Sqrt(x));
}
to understand this method we need to explain the concept of parameters.
Parameters and parameters value :
A lot of times the method you call will need some information from you to
complete its task. For example the ToIntArray() method in the article take one
parameter as a string :
private int[]
ToIntArray(string s)<---------------
This is called a parameter
So this place where we will put the string into called a parameter. We
just tell the method "You have one place (a parameter) where can the user put a
value here (a parameter value) and you need this value to finish your task". So when
you create the method you specify the parameters that the method will use and
when you call it you will specify the parameters value for the parameters.
parameters value
are the values that you specify for your parameters when you call the function.
Every parameters in your method has a data type exactly like variables and you
must specify it when you create the method. When you call the method you must
specify the parameters value of the same data type or to a type that can be
converted to that type. The parameters of any method not accessible outside the
method because it's considered as local variables for that method.
Consider the following example :
static void
SqrtToConsole(double
x)<---------------
This is called a parameter
{
Console.WriteLine(Math.Sqrt(x));
}
We just created a method called SqrtToConsole that take only one parameter.
Now we need to call the method ( I mean we need to use the method).
SqrtToConsole(9)<---------------
This is called a parameter value
We called the method SqrtToConsole
with 9 as a parameter value for the parameter x.
I think after you understand the concept of Parameters we can explain the
code written in the method SqrtToConsole.
static void
SqrtToConsole(double
x)
{
Console.WriteLine(Math.Sqrt(x));
}
We just created a method called
SqrtToConsole with one parameter called x of double data type. We use 2
FCL functions here (WriteLine(),Sqrt())
to complete the task.
The Console.WriteLine() method take one parameter value to write it to the
console. Note that the parameter value of this parameter can be an expression .
There are 18 overloaded version of Console.WriteLine() method and you can check
them in Visual Studio.NET Documentation. Some of them take a parameter value as
a string, int, double, object and other data types.
The Math.Sqrt() method take also one parameter value to get its job done.
Here we just create our method and inside it we call the Console.WriteLine()
with a parameter value as the result of the following method call
Math.Sqrt(x).
Note : Don't forget that x is the parameter of the
SqrtToConsole() method and we just use
it in the Math.Sqrt(x) method so that
we tell the compiler to take the parameter value of
SqrtToConsole()
method and give it to the Math.Sqrt()so
the result will write to the console application.
Return Value :
Let's look at the
Math.Sqrt() again please. This method takes a parameter of double data type and
Returns the square root of that parameter so this is the return value
that we are talking about here in C# methods.
Consider the following method :
private
int AddIntegers(int
x, int
y)
{
return x + y ;
}
Here the AddIntegers() method takes 2 integer numbers and
return the result as integer too.
The return value must have a type so here in our method the
return value is of type int and we must write int keyword before the method name
to specify the return type. Also we use the
return
keyword as the end of our method to exit the method and return the value to the
method which called the AddIntegers() ( I will explain how we can call method
from other method later ) . So when you use the
return
keyword you tell the compiler to end the method and return a value of the
specified type to the calling code. If your method does not return a value then
you must use the void
keyword in the same place as you do with the return value type ( before the
method name).
You must understand something called Method Signature or Method Definition.
The group of method name, parameter list, return value type specify the method
signature or method definition. For example the method
AddIntegers() signature is :
1- The return data type
(int)
2- The method name (
AddIntegers
)
3- The parameter list (
(int
x, int
y) )
How we call a method ?
As you might know that the Main method is the
entry point of any C# program so it's the first method that the compiler will
invoke. So any method we created or any method we used it from FCL will be
called from the Main method. Consider the following example :
We have 2 methods as following :
private
void
Parent()
{
// We don't need any code here
}
private
void
Son(int x)
{
// We don't need any code here
}
We need to call this methods from our Main method. All what we need to do
like that
static void
Main(string[]
args)
{
Parent();
Son(23);
}
We called the 2 methods simply by typing the name of the method with 2 empty
parenthesis if the method's parameter list is empty or the with parameters
values inside the parenthesis if the method's parameter list contains
parameters.
Note : a user-defined method can call other methods like another user-defined
method or FCL method.
So far I think I have introduced C# methods and in my next article I will
talk complete our discussion about methods and introduce some advanced concepts.
I hope that you will find my articles useful.
About the author :
Michael Youssef is 20 years old and he's working with Microsoft technologies
since he was 17. He is working with VB, VB.NET, C#,ASP, ASP. NET, XML Web
services, COM+, SQL Server 2000, Windows 2000 Server, Active Directory, Networks
design. He is MCSD.NET, MCDBA, MCSE, MCSA and he's working now as a .NET Trainer
in Egypt. Michael can be reached at
michaellabibat@hotmail.com .
|