Preparing .NET Interview - Part 3 (Parameters)

Here are the links to previous articles:

• Preparing .NET Interview - Part 1 (Framework)
• Preparing .NET Interview - Part 2 (Basic Types)

I am here to continue series related to .NET interview preparation. Today we will discuss the questions related to parameters and present the answers in easy way.

So, let’s take questions one by one.

1. What’s the similarity and difference between ref and out parameters and when are they used?
   
   Answer:
   
   Ref and out parameters are essentially reference type parameters and used to pass reference of the parameters and due to that any change made in the parameters in the called function will also reflect in the calling function. But they differ in their uses scenario.
   
   Ref parameter is used when parameter is already initialized in the calling method whereas out is used when we want to enforce parameter initialization in the called method.
   
   When using ref, failing to initialize parameter in the calling method will give an error and in case of out failing to initialize parameter in the called method with also throw an error.
   
   Example: Regular parameters
   

   static void Add(int a, int b)
   {
       a = 5;
       b = 6;
       Console.WriteLine("Addition in the method: {0}", a + b);
   }
   static void Main()
   {
       int num1 = 3;
       int num2 = 4;
       Console.WriteLine("Addition before calling method: {0}", num1 + num2);
       Add(num1, num2);
       Console.WriteLine("Addition after calling method: {0}", num1 + num2);
   }

   Output
   
   
   
   Here you can see that in the called function, copy of parameters is passed, hence change made in variables (a, b) is not reflecting back in calling function (i.e. printing 7 only).
   
   Example: ref parameters
   

   static void Add(refint a, refint b)
   {
       a = 5;
       b = 6;
       Console.WriteLine("Addition in the method: {0}", a + b);
   }
   static void Main()
   {
       int num1 = 3; ////int num1; will throw an error
       int num2 = 4; ////int num2; will throw an error
       Console.WriteLine("Addition before calling method: {0}", num1 + num2);
       Add(refnum1, refnum2);
       Console.WriteLine("Addition after calling method: {0}", num1 + num2);
   }

   Output
   
   
   
   As you can see here that in the called function, since reference of parameters is passed, the change made in variables (a, b) is reflecting back in calling function (i.e. printing 11). Also if we don’t initialize variables (keep intnum1;) it will throw an error as in case of ref, parameter have to be initialized before it passed in the called function
   
   Example: out parameters
   

   static void Add(out int a, out int b)
   {
       a = 5; ////Assignment is required else it won't compile.
       b = 6; ////Assignment is required else it won't compile.
       Console.WriteLine("Addition in the method: {0}", a + b);
   }
   static void Main()
   {
       int num1; ////Initialization is not required.
       int num2; ////Initialization is not required.
       Add(outnum1, outnum2);
       Console.WriteLine("Addition after calling method: {0}", num1 + num2);
   }

   Output
   
   
   
   Here you can see that when using out parameters, initialization of parameters are not required in the calling function, however these parameters must be initialized in the called function else compile time error will be thrown. Further since out parameter also uses reference behind the scene, change made in variables (a, b) is reflecting back in calling function (i.e. printing 11).
   
   
2. Can you return multiple values from a method in C#? If yes, then how?
   
   Answer:
   
   By definition, return statement can only return one object or value however there are few workarounds to achieve multiple returns as following.
   
   • Create an instance of a class or struct which have multiple member variables or properties and assign the values to them and return the class or struct object.
   

   class MyClass
   {
       public string Name
       {
           get;
           set;
       }
       public string City
       {
           get;
           set;
       }
       public string State
       {
           get;
           set;
       }
       public int Salary
       {
           get;
           set;
       }
   }
   public class Client
   {
       static MyClassReturnMultiple()
       {
           MyClass myClass = new MyClass();
           myClass.Name = "Prakash";
           myClass.City = "Satna";
           myClass.State = "MP";
           myClass.Salary = 1000;
           return myClass;
       }
       static void Main()
       {
           MyClass myClass = ReturnMultiple();
           Console.WriteLine("Name: {0}\nCity: {1}\nState: {2}\nSalary: {3}", myClass.Name, myClass.City, myClass.State, myClass.Salary);
       }

   Output
   
   
   
   As you can see that using class (or struct) as a return type, we can return multiple values at once.
   
   • Using output parameters, as in the question 1 above, we saw that values of parameters (a, b) set in called method were later available on the calling method as well hence we were able to return values implicitly.
   
   
3. Can you create a method which can take variable number of arguments? If yes, then what are the constraints attached to it?
   
   Answer:
   
   We can pass variable number of parameters using params keyword. When using params, method parameter can vary from zero to infinite in numbers.
   
   Let’s understand this by simple example.
   

   static void TestRegularAddition(int[] numbers)
   {
       int sum = 0;
       foreach(int in numbers)
       {
           sum = sum + i;
       }
       Console.WriteLine("Inside TestRegularAddition: {0}", sum);
   }
   static void TestParamsAddition(params int[] numbers)
   {
       int sum = 0;
       foreach(int in numbers)
       {
           sum = sum + i;
       }
       Console.WriteLine("Inside TestParamsAddition: {0}", sum);
   }
   static void TestParamsConcatenation(params string[] strings)
   {
       string str = string.Empty;
       foreach(string s in strings)
       {
           str = str + ' ' + s;
       }
       Console.WriteLine("Inside TestParamsConcatenation: {0}", str);
   }
   static void Main()
   {
       //TestRegularAddition(); //Error: No argument passed
       //TestRegularAddition(1); //Error: cannot convert int to int[]
       //TestRegularAddition(1,2); //Error: no overload for method TestRegularAddition takes 2 arguments
       TestRegularAddition(newint[]
       {
           1,
           2,
           3
       }); //Correct
       TestParamsAddition(); //Correct
       TestParamsAddition(1); //Correct
       TestParamsAddition(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); //Correct
       TestParamsConcatenation(); //Correct
       TestParamsConcatenation("Prakash"); //Correct
       TestParamsConcatenation("Prakash", "Tripathi", "Beeda", "Amarpatan", "Satna", "MP"); //Correct
   }

   Output
   
   
   
   As you can see that regular way of passing parameters has some strict rules whereas params allows us to pass either no parameter or any number of parameters.
   
   The constraint is that when params is used, additional parameters are not allowed after the params keyword however additional parameters can appear before the params keyword.
   
   
4. What are named and optional parameters in C# and how to use them?
   
   Answer:
   
   Named parameter introduced to avoid remembering the order of parameters if we know the names of them. If we are using named parameter along with regular or positioned parameter then named parameter should appear in the last.
   
   Optional parameter on the other hand allows us to send only required parameters. The conditions when using optional are that optional parameters need to define the default values while declaration also for optional parameters must be defined in the last or after all the required parameters.
   
   Let’s understand this by simple example.
   

   static void TestNamedParameter(int principle, float rate, int year)
   {
       Console.WriteLine("Inside TestNamedParameter, Simple Interest is: {0}", (principle * rate * year) / 100);
   }
   static void TestOptionalParameter(int principle, float rate, int year = 1)
   {
       Console.WriteLine("Inside TestOptionalParameter, Simple Interest is: {0}", (principle * rate * year) / 100);
   }
   static void Main()
   {
       //TestNamedParameter(rate: 9, principal: 10000, 1); //Error: named parameter should be in last.
       TestNamedParameter(10000, 9, 1); //Positioned parameter
       TestNamedParameter(10000, rate: 9, year: 1); //Correct
       TestNamedParameter(principle: 10000, rate: 9, year: 1); //Correct
       //TestOptionalParameter(10000); //Error: all required parameters are not passed
       TestOptionalParameter(10000, 9, 1); //All parameters are passed
       TestOptionalParameter(10000, 9);
   }

   Output
   
   
   
   Hope you have liked the article. Look forward for your comments/suggestions.