20 C# Beginner Interview Questions & Answers

All development shops will (or should) use some sort of source code control application to retain version history of their code. You should be able to explain what application you use for this purpose, how you use it, and most importantly, how often. You should save early and often and performed several times a day during the course of your development. For .NET development Azure DevOps is now the standard for saving code in the cloud. You may be running a legacy Team Foundation Server (TFS) in your shop as well.

It will always be important to document your code for your fellow team members. This becomes extremely important when your team provides a software solution for clients to use. In C#, there are many documentation <tags> that you can use in your code:

<summary>, <remarks>, <returns>, <value>,<example>,<code>,<param> are just a few.

        /// <summary>
        /// Describe what your method does
        /// </summary>
        /// <remarks>
        /// Provide additional information regarding your method
        /// </remarks>
        /// <returns>The sum of two input parameters</returns>
        /// <param name="a">The first integer parameter to provide</param>
        /// <param name="b">The second integer paramter to provide</param>
        /// 
        /// ---- The example tag is used in conjunction with the code tag to provide
        /// an example of how this method would be used
        /// <example>
        /// <code>
        /// 
        ///     int a = 1, int b  =2
        ///     
        ///     SummaryDocumentation(1,2)
        ///     
        ///     -- returns 3
        /// 
        /// </code>
        /// </example>
        public static int SummaryDocumentation(int a, int b) { 
        
            return a + b;
        
        }

        
        public int SomeProperty
        {
            /// The value tag provides information of a class property
            ///<value>Returns the value of some property</value>
            get
            {

                return 1;
            }
        }

/** You can then use the command line or visual studio to generate an XML document, which you can use internally or provide to your customers.  In the above example, the document will look like this: **/

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>ConsoleApp1</name>
    </assembly>
    <members>
        <member name="M:ConsoleApp1.Program.SummaryDocumentation(System.Int32,System.Int32)">
            <summary>
            Describe what your method does
            </summary>
            <remarks>
            Provide additional information regarding your method
            </remarks>
            <returns>The sum of two input parameters</returns>
            <param name="a">The first integer parameter to provide</param>
            <param name="b">The second integer paramter to provide</param>
            
            ---- The example tag is used in conjunction with the code tag to provide
            an example of how this method would be used
            <example>
            <code>
            
                int a = 1, int b  =2
                
                SummaryDocumentation(1,2)
                
                -- returns 3
            
            </code>
            </example>
        </member>
    </members>
</doc>

Attributes are keyword-like declarative descriptions that provide useful metadata for methods, properties, and other fields within your classes. When your code is compiled, these descriptions are discoverable through reflection and provides the user of the class with other helpful information. Attributes can be applied at the class and assembly level.

/**

This example shows how you would you the ObsoleteAttribute to communicate to the user of the method to not use it and to use another method instead
**/

    [Obsolete("This method will no longer be supported in future versions.  Please use MethodThatShouldBeUsed() instead")]
        public static void MethodWithAnAttribute() { }

        public static void MethodThatShouldBeUsed() { }


/** When you compile the code above, you will see a compiler warning: 
'Program.MethodWithAnAttribute()' is obsolete: 'This method will no longer be supported in future versions.  Please use MethodThatShouldBeUsed() instead'
**/

For collections, the most straightforward way to iterate through the members is to use a foreach loop.

Provide a list of integers from 1 to 5

   public static System.Collections.Generic.List<int> ProvideListOfIntegers()
        {

            System.Collections.Generic.List<int> ints = new System.Collections.Generic.List<int>();
            

            for (int counter = 1;counter < 5; counter++)
            {
                ints.Add(counter);
            }
            
            return ints;

        }

/**

	Now interate through that list in your main method:
**/

  System.Collections.Generic.List<int> sample = new System.Collections.Generic.List<int>();
            sample = ProvideListOfIntegers();
            foreach (int i in sample)
            {
                Console.WriteLine("This is the current integer: "+i);

            }

/** output:
This is the current integer: 1
This is the current integer: 2
This is the current integer: 3
This is the current integer: 4
This is the current integer: 5
**/

As in many other languages, data structures are a basic feature of C#, allowing the programmer to conveniently hold data or reference value collections for further processing in your code. There are other data structures that contain other useful properties and methods. For example, in C#, they are:

1. Array,
2. List,
3. Dictionary,
4. URI
5. DateTime

As a developer, you will ultimately encounter a situation where you will need to perform a regular expression search in your code. In C#, this is done using the System.Text.RegularExpressions.Regex class. Regular expression methods require two basic pieces of information, the regular expression to identify in your text and the text to parse. Once you've identified the matching text, you can then perform logic based on that string. Use cases for using regular expressions parsing a string to determine whether or not it is a valid email address or determining if a series of strings conform to a specific format, like social security or telephone number.

The namespace is the key signature of code layout in C#. It provides a way of organizing your classes.
The system is a namespace that contains base C# classes. You use the "using" directive and the name of the namespace to refer to the appropriate class or classes to be used in your code

using System; 
namespace MyNamespace
{

  public MyClass {}	

}

The escape sequence is a fundamental element of not only C# but many other coding languages. For C#, this is the backslash (\) and indicates that the character following it is interpreted literally and is a special character. For example, the following are escape sequences:

o \n - Newline character
o \b - Backspace
o \\ - Backslash
o \' - Single quote
o \'' - Double Quote

Unit testing is the exercise whereby the developer tests each individual code block to ensure it performs its expected purpose. This is often done for each method within a class in object oriented programming. An interviewer will want to know how you've set up your unit tests in the chosen framework. Integration testing ensures that he entire program process works from start to finish. This is typically done by the quality assurance team in larger shops, but regardless, both unit and integration testing are integral parts of the software development life cycle and should be performed before implementing an application for production use.

This is a method that calls itself within the body of the method. Care must be taken when using a recursive method to ensure that there is a condition that must be met to terminate the method, otherwise you may end up in an endless loop that could result in a memory error.

You have developed an application (web or desktop-based) that allows the user to search for pet products, place an online order, check for order status and submit survey information after the customer has placed an order. Gather as much information from the Help Line as possible. When did users experience the issue? Was it approximately at the same time? Were there any error messages that were displayed? Can the issue be replicated? If the issue occurred at roughly the same time for multiple users, more than likely the problem lies at the application and/or database server level. Do you have load-balanced web servers? If so, then the problem likely lies at the database level. Depending upon what database your application uses, you would use the available tools to look for queries doing table scans. Having found those queries, add indexes to the affected table to see if that alleviates the performance issue. It is important to convey to your interviewer what your thinking process and problem-solving abilities are and how you would logically arrive at the conclusions that you did.

Inheritance - this is a concept where a child class inherits attributes and properties from a parent class. This allows code re-use, meaning, the child class will have access to elements from the parent's class so you will not need to re-code those elements.

Encapsulation - this refers to an object's ability to hide data and behavior from the user of an object. For example, a calling program or class does not care how a method is implemented, but just that it will function in a specific way or return an expected type of value.

Polymorphism - Polymorphism goes hand in hand with inheritance. When you define a base or parent class with its properties, attributes and methods, an inherited class can change or override a method inherited from the parent class. The runtime will then determine which method to execute from the child class.

These are keywords that have a specific meaning in a particular language and cannot be used outside of that meaning within the code. In C#, for example, you cannot use 'virtual', 'throws', 'finally', 'try' outside of the context in which they are used.

Most modern IDE's will have a built in debugger. In Visual Studio for .NET development, for example, you would set a break point in the part of the code you want to initiate the debugging session in. You execute the program in debug mode. During the debugging session, you can either step-in to the code (if the debugger is at the point where another method is referenced, it will then step into the method code) or you can step-over (the debugger will move on to the next line of code) and complete the debugging process until the program terminates.

- Syntax error - this error will occur when there is a syntax issue with your code. It will manifest itself when trying to compile your code. For example, forgetting to add a line terminator (a semi-colon; in the case of C#).
- Runtime error - in this case, the code will compile but an error occurs when you try to execute your compiled code. For example, if your code depends on connectivity to a database, it will compile just fine, however, it will throw an error if the database is offline.
- Logic error - The code compiles fine and runs without issue, however, the results are not what was expected.

// this is an example of a logic error
 int a = 1, b = 1;

            if (a == b)
            {
                Console.WriteLine("a is indeed b");
                Console.WriteLine("I don't want to execute this line, but I forgot to put this outside of the if statement");
            }

// Syntactically, the code runs fine, but you inadvertently added the second line within the if statement so //it executes as well.

Aside from conveying to an interviewer the basics of a given development platform, she will want to know the specifics of the task. Be ready to describe the requirements, why it was a challenge, and what your approach was to satisfy the requirement. What were alternatives to your approach and why did you choose the one that you did? What features are offered in your coding framework or platform, not offered in other stacks, that greatly reduced complexity?

It is import to convey to your interviewer that you are resourceful and you are willing to take advantage of the existing tools you have available. If you were working on a team, you can say that you would confer with a colleague or colleagues on the problem to come up with a resolution. You can also mention online resources, for example, StackOverflow.com, various programming forums, etc. Simply Googling the question works also. If you were working under a deadline, you should also mention that you'd be in constant communication with the stakeholder, be it a project manager, business analyst or client, to let them know of the status, what you are doing to try to resolve the issue, and an estimate on when you expect to complete the task.

The "throw" expression is normally placed within the catch code block. The expectation is that the calling program will handle the thrown exception and implement their own error handling. This is commonly seen in API design, where it is not really known how the consumer of the method call will want to handle the exception. They may implement a custom logging solution or they may decide to throw it as well.

try {

// code that may throw an exception
 
}
catch (SomeException e) { 

	//you can handle the exception
	// code to implement if handling or
	throw e; // if you do this, code execute stops

}

A try block defines a block of statements where you expect an exception to be thrown. The catch block defines a series of statements to execute if an exception is thrown. In Java and in C#, you can specify the exact types of exception you expect to catch which will allow the programmer to code the catch block depending upon the type of exception being caught. Without the try/catch block, the exception will then percolate up the call stack until the exception is caught in another block or an error is displayed in the front end.

On Windows IIS servers, look in the web root at the following path: %System%\Inetpub\log\LogFiles\W3SVC site ID numbers
All IIS requests should go to these log files. If logging is disabled, the request you are looking for may not have been captured in IIS so you can also look at C:\Windows\System32\LogFiles\HTTPERR. If neither of those options yield any useful information, you can also look at the Windows Event viewer. There, you can review the Application, Security, System, and Setup folder to see if there is any useful information there. The best practice is to implement error handling within your application, regardless of the development platform used.