Functions Interview Questions C#.NET

Functions Interview Questions and Answers C#.NET

In this article, I am going to discuss most frequently asked Functions Interview Questions and Answers on C#.NET.

Can we Overload main() method in C#?

Yes, We can overload main() method. A C# class can have any number of main() methods.

But to run the C# class, the class should have main() method with signature as “public static void main(String[] args)”. If we do any modification to this signature, the compilation will be successful. But, we will get the runtime error as the main method not found.

Why is C# main method static?

The main method is static because it is available to run when our program starts and as it is the entry point of the program it runs without creating an instance of the class. In other words, static functions exist before a class is instantiated so static is applied to the main entry point (Main method).

Static methods are the methods which do not require any object whenever they are called. These methods are loaded even before the class is loaded in the memory. It means that even before the object is being created, the method is already loaded into the memory.

Other than this, Main() is the door for any program. It means whenever we run a program, the compiler looks out for the Main method. If there is the main method then the content inside it is executed. The main method is the first access point for any program and has to be called automatically. Since it is static it gets loaded automatically even before the object of that class is being created and Main() does not require any object to be called

You have a component with 5 parameters and deployed to client-side now you changed your method which takes 6 parameters. How can you deploy this without affecting the client’s code?

Instead of adding the 6th parameter to the existing method, write new overloaded method with 6 parameters.

So when the old application calls this method, the method with 5 parameters will execute and method with 6 parameters will be used by the new application. In this way, we can provide backward compatibility to old application.

Is the following code legal?
namespace Demo
{
    class Program
    {
        public static void Main()
        {
        }
        public void Sum(int FirstNumber, int SecondNumber)
        {
            int Result = FirstNumber + SecondNumber;
        }

        public int Sum(int FirstNumber, int SecondNumber)
        {
            int Result = FirstNumber + SecondNumber;
        }
    }
}

No, the above code does not compile. You cannot overload a method based on the return type. To overload, a method in C# either the number or type of parameters should be different. In general, the return type of a method is not part of the signature of the method for the purposes of method overloading. However, it is part of the signature of the method when determining the compatibility between a delegate and the method that it points to.

What is the difference between method parameters and method arguments? Give an example.

In the example below FirstNumber and SecondNumber are method parameters whereas FN and SN are method arguments. The method definition specifies the names and types of any parameters that are required. When calling code calls the method, it provides concrete values called arguments for each parameter. The arguments must be compatible with the parameter type but the argument name (if any) used in the calling code does not have to be the same as the parameter named defined in the method.

namespace Demo
{
    class Program
    {
        public static void Main()
        {
            int FN = 10;
            int SN = 20;
            int Result = Sum(FN, SN);
        }
        public static int Sum(int FirstNumber, int SecondNumber)
        {
            return FirstNumber + SecondNumber;
        }
    }
}
Explain the difference between passing parameters by value and passing parameters by reference with an example?

We can pass parameters to a method by value or by reference. By default, all value types are passed by value whereas all reference types are passed by reference. By default, when a value type is passed to a method, a copy is passed instead of the object itself. Therefore, changes to the argument have no effect on the original copy in the calling method. An example is shown below.

namespace Demo
{
    class Program
    {
        public static void Main()
        {
            int I = 10;
            int K = Function(I);

            Console.WriteLine("I = " + I);
            Console.WriteLine("K = " + K);
        }
        public static int Function(int Number)
        {
            int ChangedValue = Number + 1;
            return ChangedValue;
        }
    }
}

By default, reference types are passed by reference. Whenever an object of a reference type is passed to a method the reference type points to the original object, not a copy of the object. Changes made through this reference will, therefore, be reflected in the calling method. Reference types are created by using the class keyword as shown in the example below.

namespace Demo
{
    class Program
    {
        public static void Main()
        {
            ReferenceTypeExample Object = new ReferenceTypeExample();
            Object.Number = 20;
            Console.WriteLine("Original Object Value = " + Object.Number);
            Function(Object);
            Console.WriteLine("Object Value after passed to the method= " + Object.Number);
        }
        public static void Function(ReferenceTypeExample ReferenceTypeObject)
        {
            ReferenceTypeObject.Number = ReferenceTypeObject.Number + 5;
        }
    }

    class ReferenceTypeExample
    {
        public int Number;
    }
}
Can you pass value types by reference to a method?

Yes, we can pass value types by reference to a method. An example is shown below.

namespace Demo
{
    class Program
    {
        public static void Main()
        {
            int I = 10;
            Console.WriteLine("Value of I before passing to the method = " + I);
            Function(ref I);
            Console.WriteLine("Value of I after passing to the method by reference= " + I);
        }
        public static void Function(ref int Number)
        {
            Number = Number + 5;
        }
    }
}
If a method’s return type is void, can you use a return keyword in the method?

Yes, Even though a method’s return type is void, you can use the return keyword to stop the execution of the method as shown in the example below.

namespace Demo
{
    class Program
    {
        public static void Main()
        {
            SayHi();
        }
        public static void SayHi()
        {
            Console.WriteLine("Hi");
            return;
            Console.WriteLine("This statement will never be executed");
        }
    }
}
What is the difference between static class and class with static methods? In which case I should use either of them?


If your class has only static members you never need an instance of that class so you should make the class itself static but if your class has instance members (non-static) then you have to make your class an instance class to access its instance members via instances of your class.

About the Static class: We cannot instantiate, inherit the static class. 

About the class with full of static methods: We can instantiate this class. But logically we are not going to do anything with these instances. So practically this scenario doesn’t exist. However, it might be useful in inheriting. But practically I haven’t come across such a situation anywhere.

When it some to the static class, we use it to extend a particular object. For example, we have accounts object. We need to add a method HasBalance(). We can do it by extension method.

However, it is very common to have classes with both static and non-static methods.

What is a recursive function in c#? Give an example. 

A recursive function is a function that calls itself. Let’s look at an example of computing factorial of a number with and without recursion. 

SUMMARY

In this article, I try to explain most frequently asked Functions Interview Questions and Answers on C#.NET. I hope this article will help you with your need. I would like to have your feedback. Please post your feedback, question, or comments about this article.

Follow Us

Leave a Reply

Your email address will not be published. Required fields are marked *