Category Archives: .NET

C# Interview Questions

A series of typical C# based interview questions that I have been asked, and also occasionally ask during interviews. These have been built up over a period of years and are regularly updated with newer technologies and techniques.

  1. What is C#?
    C# is an object oriented type safe and managed language that is compiled by .Net framework to generate Microsoft Intermediate Language.
  2. What are the types of comment in C#?
    Single line, Multi Line and XML Comments.

    
                // This is a single line comment - it starts with a double slash
    
                /* This is a multiple line comment
                it begins with a slash-star
                and ends with a star-slash */
    
                /// This is an XML comment
                /// it can be used to document code
                /// and provide intellisense help
    
                

  3. Can multiple catch blocks be executed?
    No, Multiple catch blocks cannot be executed. Once an individual catch section is executed, control is transferred to the finally block and then the code that follows the finally block gets executed.
  4. What is the difference between public, static and void?
    • Public declared variables or methods are accessible anywhere in the application.
    • Static declared variables or methods are globally accessible without creating an instance of the class. The compiler stores the address of the method as the entry point and uses this information to begin execution before any objects are created.
    • Void is a type modifier that states that the method or variable does not return any value.
  5. What is an Object?
    An object is an instance of a class through which we access the methods of that class. “New” keyword is used to create an object. A class that creates an object in memory will contain the information about the methods, variables and behaviour of that class.
  6. Define Constructors
    And the answer goes hereA constructor is a member function in a class that has the same name as its class. The constructor is automatically invoked whenever an object class is created. It constructs the values of data members while initializing the class.
  7. What are Jagged Arrays?
    An array which has elements of type array is called jagged array. The elements can be of different dimensions and sizes. We can also call a jagged array an Array of arrays.
  8. What is the difference between ref & out parameters?
    A ref parameter is two-ways, out is out only. For ref parameters, its necessary to initialize them before passing(compile time error, if not done). But out parameters need not to be initialized
  9. What is the purpose of a using statement in C#?
    The using block is used to obtain a resource and use it and then automatically dispose of when the execution of block completes. Note: Using objects must implement IDisposable. Good for types that access unmanaged resourced such as File and Font. This is the preferred method of using anything that implements IDisposable.
  10. What is serialization?

    When we want to transport an object through network then we have to convert the object into a stream of bytes. The process of converting an object into a stream of bytes is called Serialization. For an object to be serializable, it should inherit ISerializable Interface.

    De-serialization is the reverse process of creating an object from a stream of bytes.

  11. Can “this” be used within a static method?
    We can’t use ‘This’ in a static method because we can only use static variables/methods in a static method.
  12. What is difference between constants and read-only?
    Constant variables are declared and initialized at compile time. The value can’t be changed after wards. Read-only variables will be initialized only from the Static constructor of the class. Read only is used only when we want to assign the value at run time.
  13. What is an interface class?
    An Interface is a class which has only public methods and the methods only have the declaration and not the definition. These methods must be implemented in the inherited classes.
  14. What are value types and reference types?
    Value types are stored in the Stack whereas reference types are
    stored on heap. Value types are therefore quicker.

    Value types: int, enum, byte, decimal, double, float, long

    Reference Types: string, class, interface, object

  15. What are sealed classes?
    We create sealed classes when we want to restrict the class to be inherited. Sealed modifier used to prevent derivation from a class. If we forcefully specify a sealed class as base class then a compile-time error occurs.
  16. What is method overloading?
    Method overloading is creating multiple methods with the same name with unique signatures in the same class. When we compile, the compiler uses overload resolution to determine the specific method to be invoke.
  17. What is the difference between Array and Arraylist?
    In an array, we can have items of the same type only. The size of the array is fixed. An arraylist is similar to an array but it doesn’t have a fixed size.
  18. Can a private virtual method be overridden?
    No, because they are not accessible outside the class.
  19. Describe the accessibility modifier “protected internal”
    Protected Internal variables/methods are accessible within the same assembly and also from the classes that are derived from this parent class.
  20. What are the differences between System.String and System.Text.StringBuilder classes?
    System.String is immutable. When we modify the value of a string variable then a new memory is allocated to the new value and the previous memory allocation released. System.StringBuilder was designed to have concept of a mutable string where a variety of operations can be performed without allocation separate memory location for the modified string.
  21. What’s the difference between the System.Array.CopyTo() and System.Array.Clone()?
    Using the Clone() method, we create a new array object containing all the elements in the original array and using CopyTo() method, copies of all the elements of existing array are copied into another existing array. Both the methods perform a shallow copy.
  22. How can we sort the elements of the array in descending order?
    Using Sort() methods followed by Reverse() method, alternatively we can use Linq with an OrderByDescending() clause
  23. What’s the difference between an interface and abstract class?
    Interfaces have all the methods having only declaration but no definition. In an abstract class, we can have some concrete methods. In an interface class, all the methods are public. An abstract class may have private methods.
  24. What is the difference between Finalize() and Dispose() methods?
    Dispose() is called when we want for an object to release any unmanaged resources with them. On the other hand Finalize() is used for the same purpose but it doesn’t assure the garbage collection of an object.
  25. What are circular references?
    Circular reference is situation in which two or more resources are interdependent on each other causes a lock condition and making the resources unusable.
  26. What are generics
    Generics are used to make reusable code classes, to decrease code duplication, reduce redundancy, increase type safety and performance. Generics use parameterized types, rather than fixed types.
  27. What are the commonly used types of exceptions in .Net?
    ArgumentException, ArgumentNullException, ArgumentOutOfRangeException, ArithmeticException, DivideByZeroException, OverflowException, IndexOutOfRangeException, InvalidCastException, InvalidOperationException, IOEndOfStreamException, NullReferenceException, OutOfMemoryException, StackOverflowException etc.
  28. What are Custom Exceptions?
    Sometimes there are some errors that need to be handled as per specific requirements. Custom exceptions are used for them and are used defined exceptions.
  29. What are delegates?
    Delegates are same are function pointers in C++ but the only difference is that they are type safe unlike function pointers. Delegates are required because they can be used to write much more generic type safe functions.
  30. How do you inherit a class into other class in C#?
    Colon is used as inheritance operator in C#. Just place a colon and then the class name.
  31. What is the base class in .net from which all the classes are derived from?
    System.Object
  32. What is the difference between method overriding and method overloading?
    In method overriding, we change the method definition in the derived class that changes the method behaviour. Method overloading is creating a method with the same name within the same class having different signatures.
  33. What are the different ways a method can be overloaded?
    Methods can be overloaded using different data types for parameter, different order of parameters, and different number of parameters.
  34. Why can’t you specify the accessibility modifier for methods inside the interface
    In an interface, we have virtual methods that do not have method definition. All the methods are there to be overridden in the derived class. That’s why they all are public.
  35. How can we set class to be inherited, but prevent the method from being over-ridden
    Declare the class as public and make the method sealed to prevent it from being overridden.
  36. What happens if the inherited interfaces have conflicting method names?
    Implement is up to you as the method is inside your own
    class. There might be problem when the methods from different interfaces expect
    different data, but as far as compiler cares you’re okay.
  37. What is the difference between a Struct and a Class
    Structs are value-type variables and classes are reference
    types. Structs stored on the stack, causes additional overhead but faster
    retrieval. Structs cannot be inherited
  38. How do you use nullable types in .Net
    Value types can take either their normal values or a null value. Such types are called nullable types and are represented with a question mark after the type e.g. int? or bool?.
  39. How we can create an array with non-default values?
    We can create an array with non-default values using Enumerable.Repeat, or we can populate it with an initializer.
  40. What is difference between is and as operators in c#
    “is” operator is used to check the compatibility of an object with a given type and it returns the result as Boolean.
    “as” operator is used for casting of object to a type or a class.
  41. What are C# attributes and their use
    C# provides developers a way to define declarative tags on certain entities eg. Class, method etc. are called attributes. The attribute’s information can be retrieved at runtime using Reflection
  42. Is C# code is managed or unmanaged code
    C# is managed code because the Common language runtime (CLR) compiles C# code to Intermediate language
  43. What are namespaces, and how they are used?
    Namespaces are used to organize classes within the .NET Framework. They dictate the logical structure of the code. The .NET Framework has namespaces defined for its many classes, such as System.Xml–these are utilized via the using statement. Namespaces are assigned to classes via the namespace keyword.
  44. What is a constructor?
    A constructor is a class member executed when an instance of the class is created. The constructor has the same name as the class, and it can be overloaded via different signatures. Constructors are used for initialization tasks.
  45. Why are strings in C# immutable?
    Immutable means string values cannot be changed once they have been created. Any modification to a string value results in a completely new string instance, thus an inefficient use of memory and extraneous garbage collection. The mutable System.Text.StringBuilder class should be used when string values will change. Immutable types are inherently thread-safe, since no thread can modify it, the risk of a thread modifying it in a way that interferes with another is removed.
  46. What is the execution entry point for a C# console application
    The Main method.
  47. How do you initialise a string without escaping each backslash
    You put an @ sign in front of the double-quoted string
  48. What is boxing
    Boxing is the process of explicitly converting a value type into a corresponding reference type. Basically,this involves creating a new object on the heap and placing the value there. Reversing the process is just as easy with unboxing, which converts the value in an object reference on the heap into a corresponding value type on the stack. The unboxing process begins by verifying that the recipient value type is equivalent to the boxed type. If the operation is permitted, the value is copied to the stack.
  49. What is the .NET datatype that allows the retrieval of data by a unique key
    HashTable
  50. Explain ACID rule of thumb for transactions.
    The transaction must be:

    Atomic (it is one unit of work and does not
    depend on previous and following transactions),

    Consistent (the data is either committed or roll
    back, no “in-between” case where something has been updated and something
    hasn’t),

    Isolated (no transaction sees the intermediate
    results of the current transaction),

    Durable (the values persist if the data had been
    committed even if the system crashes right after).

  51. When would you use a StringBuilder as opposed to concatenating separate strings
    When the concatenation occurs in a loop and you don’t know in advance how many times the loop will execute. Or when you know the concatenation will occur more than 5 or 6 times. Below this, the additional overhead of creating a StringBuilder class outweight the gains used through using immutable strings.

Please note, this entry will be regularly updated and added so pleale chack back for latest changes.

Another book: ASP.NET jQuery Cookbook

ASP.NET jQuery Cookbook
I’ve been editing another book!

This one covers many aspects of using jQuery within ASP.NET in a WebForms based environment. If you are new to the combination of jQuery and WebForms (aspx) then I thoroughly recommend this as a great introduction.

It includes the following:

  • Tips and tricks for interfacing the jQuery library with ASP.NET controls
  • Boost ASP.NET applications with the power of jQuery
  • Use a problem-solution based approach with hands-on examples for ASP.NET developers
  • Step-by-step guide with plenty of code snippets and screen images
  • Simple, effective, and easy-to-follow recipes
  • eBook available as PDF and ePub downloads

For more details, see the publisher’s page here.

ASP.NET MVC 2 Cookbook

ASP.NET MVC 2 Cookbook

Over the past year or so, I have had the pleasure to technically review this book, chapter by chapter and revision by revision.  The final result is an extremely useful collection of ‘recipes’ that will add extra functionality in most MVC applications and help you to understand some of the key concepts.

For more details, see the Packt website here

Populating common view model attributes

In many ASP.Net MVC based applications, we often find ourselves needing to include the same information in every page.  Such information typically includes details of the current user, maybe environmental values and running totals like the number of items in a shopping basket.

In order to ensure these values are always available in views, base your view models on a common base class, and populate these base values using an action filter.

public class ViewModelBase
{
   public string UserName { get; set; }
   public List<UserFavorite> UserFavorites { get; set; }
   public ShoppingBasket ShoppingBasket { get; set; }
}

Then, create an action filter to populate this, if it has not already been populated by the action method on which it has been applied.

// Populates View Model base properties, if they are not already populated by the controller
class ViewModelAttribute : ActionFilterAttribute
{
   public override void OnActionExecuted(ActionExecutedContext filterContext)
   {
   ViewModelBase viewModel;

   if (filterContext.Controller.ViewData.Model == null)
   {
      viewModel = new ViewModelBase();
      filterContext.Controller.ViewData.Model = viewModel;
   }
   else
   {
      viewModel = filterContext.Controller.ViewData.Model as ViewModelBase;
   }

   if (viewModel != null)
   {
      viewModel.UserName = lookupUserName();
      viewModel.UserFavorites = GetUserFavorites();
      viewModel.ShoppingBasket = GetShoppingBasket();
   }

   base.OnActionExecuted(filterContext);
   }
}

The code first checks for a null model and assigns a base view model if none exists.  It then checks that if a model does already exist, that it is of type ViewModelBase.  If so, the appropriate values are initialized.

Then, on any action method that required this – or (in my case) at the controller level of a base controller class, add the attribute:

[ViewModel]
public abstract class ControllerBase : Controller
{
 /// Controller base

}

Rendering views to strings

Rendering a view or a partial to a string is a common problem, especially when you want to re-use your code and markup in a PDF or Email.  There are a number of semi-successful methods for achieving this across the internet.  The techniques outlined below are built on the excellent post from Kevin Craft at http://craftycodeblog.com/2010/05/15/asp-net-mvc-render-partial-view-to-string/ this has the advantage of being simple, straight forward and fully support embedded Html helpers.

Render Partial To String & Render Form To String

Define the following within a Controller base class:

public class BaseController : Controller
{
   protected string RenderPartialToString(string viewName, object model)
   {
      if (string.IsNullOrEmpty(viewName))
         viewName = ControllerContext.RouteData.GetRequiredString("action");

      ViewData.Model = model;
      using (StringWriter sw = new StringWriter())
      {
         ViewEngineResult viewResult = ViewEngines.Engines.FindPartialView(ControllerContext, viewName);
         validateViewResult(viewResult, viewName);
         ViewContext viewContext = new ViewContext(ControllerContext, viewResult.View, ViewData, TempData, sw);
         viewResult.View.Render(viewContext, sw);
         return sw.GetStringBuilder().ToString();
      }
   }

   protected string RenderViewToString(string viewName, object model, string masterName)
   {
      if (string.IsNullOrEmpty(viewName))
      viewName = ControllerContext.RouteData.GetRequiredString("action");
      ViewData.Model = model;
      using (StringWriter sw = new StringWriter())
      {
         ViewEngineResult viewResult = ViewEngines.Engines.FindView(ControllerContext, viewName, masterName);
         validateViewResult(viewResult, viewName);
         ViewContext viewContext = new ViewContext(ControllerContext, viewResult.View, ViewData, TempData, sw);
         viewResult.View.Render(viewContext, sw);
         return sw.GetStringBuilder().ToString();
      }
   }

   private static void validateViewResult(ViewEngineResult viewResult, string viewName)
   {
      if (viewResult.View != null)
      return;
      // wasn't found - construct error message
      StringBuilder locationsText = new StringBuilder();
      foreach (string location in viewResult.SearchedLocations)
      {
         locationsText.AppendLine();
         locationsText.Append(location);
      }
      throw new InvalidOperationException(String.Format("View {0} not found. Locations Searched: {1}", viewName, locationsText));
   }
}

Then, within your controller action methods you can use something similar to this:

string partial = RenderPartialToString("TestPartial", "This is my test partial");
string viewString = this. RenderViewToString("", null, "");

Using MVC RenderAction within a Webform

As pointed out in the previous post (<here>) it is possible to call the MVC RenderPartial from within a webform.  This assumes that your webform has all the information it needs to populate the required model.  Where this information is not available, a good alternative is to use RenderAction from within the webform:

Add the following to the MvcUtility class described in the previous post:

public static void RenderAction(string controllerName, string actionName, object routeValues)
{
   RenderPartial("RenderAction", new RenderActionViewModel() { ControllerName = controllerName, ActionName = actionName, RouteValues = routeValues });
}

Create the viewModel to support the data we want to pass:

public class RenderActionViewModel
{
   public string ControllerName { get; set; }
   public string ActionName { get; set; }
   public object RouteValues { get; set; }
}

And, create a partial view to make the RenderAction request (I put mine in the Shared directory)

<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl<RenderActionViewModel>" %>
<%Html.RenderAction(Model.ActionName, Model.ControllerName, Model.RouteValues); %>

Then, all that is needed is to call the MvcUtility.RenderAction from within a webform, passing it the name of the controller, action and and additional parameters that your action method requires.  Examples:

<% PartialViewHelper.RenderAction("myController", "myAction", new { param = Value }); %>
...
<% PartialViewHelper.RenderAction("Blogs", "List", new { page = 1, order = "date", comments = "off" }); %>

This is a great way of adding MVC functionality to a Webforms environment.

Using MVC RenderPartial within a webform

I you are lucky, like me, you get to work on both MVC and Webforms projects, often simultaneously, in mixed environment projects.

One question that commonly arises – how to render an MVC partial view within a webform.  A little study of the MVC source code, and it reveals that its relatively easy, as long as you are able to fake the necessary context elements.

Step 1. Create a dummy controller from which we can create the controller context.  This is simply an empty class that inherits from Controller.

// create a dummy controller
public class DummyController : Controller
{
}

Step 2. Create a static class MvcUtility that constructs the context and call the render method.

public static class MvcUtility
{
   public static void RenderPartial(string partialViewName, object model)
   {
      // Get the HttpContext
      HttpContextBase httpContextBase = new HttpContextWrapper(HttpContext.Current);
      // Build the route data, pointing to the dummy controller
      RouteData routeData = new RouteData();
      routeData.Values.Add(&quot;controller&quot;, typeof(DummyController).Name);
      // Create the controller context
      ControllerContext controllerContext = new ControllerContext(new RequestContext(httpContextBase, routeData), new DummyController());
      // Find the partial view
      IView view = FindPartialView(controllerContext, partialViewName);
      // create the view context and pass in the model
      ViewContext viewContext = new ViewContext(controllerContext, view, new ViewDataDictionary { Model = model }, new TempDataDictionary(), httpContextBase.Response.Output);
      // finally, render the view
      view.Render(viewContext, httpContextBase.Response.Output);
   }

   private static IView FindPartialView(ControllerContext controllerContext, string partialViewName)
   {
      // try to find the partial view
      ViewEngineResult result = ViewEngines.Engines.FindPartialView(controllerContext, partialViewName);
      if (result.View != null)
      {
         return result.View;
      }
      // wasn't found - construct error message
      StringBuilder locationsText = new StringBuilder();
      foreach (string location in result.SearchedLocations)
      {
         locationsText.AppendLine();
         locationsText.Append(location);
      }
      throw new InvalidOperationException(String.Format(&quot;Partial view {0} not found. Locations Searched: {1},  partialViewName, locationsText));
   }
}

This creates the necessary environment – creating the HttpContext, route data, controller context, finds the view and renders it.  The second routine, FindPartialView uses the ViewEngines to find the partial view and throws an appropriate exception if it can’t find the requested partial.

Finally, within my webform, I create a public property called Model in the code behind and include the following:

<% MvcUtility.RenderPartial("TestPartial", Model); %>

Thats all there is to it…

There is only on drawback to this approach, your code behind needs to populate the model and therefore needs all the model creation information in order to call this.  The next post Using MVC RenderAction within a Webform addresses this… Continue reading