Skip to main content

C# : Interview questions (86-90)

 

Questions:

    • Explain the concept of null-conditional operators.
    • What are nullable types in C#?
    • How do you define a nullable type in C#?
    • What is the purpose of the "?? operator" in C#?
    • Explain the use of the "switch" statement in C#.

    Answers:

    1. Concept of Null-Conditional Operators:

    The null-conditional operators (?. and ?[]) in C# allow you to perform member and element access operations only when the operand is not null. They help prevent NullReferenceException and make the code more concise and readable.

    • ?. Operator: Used for accessing members (properties, methods) safely.

      Person person = null;
      string name = person?.Name; // name will be null if person is null
      Console.WriteLine(name); // Output: (null)
      
      Person person2 = new Person { Name = "John" };
      string name2 = person2?.Name; // name2 will be "John" if person2 is not null
      Console.WriteLine(name2); // Output: John
      
      • ?[] Operator: Used for safely accessing elements in arrays or collections.
      int[] numbers = null;
      int? firstNumber = numbers?[0]; // firstNumber will be null if numbers is null
      Console.WriteLine(firstNumber); // Output: (null)
      
      int[] numbers2 = { 1, 2, 3 };
      int? firstNumber2 = numbers2?[0]; // firstNumber2 will be 1 if numbers2 is not null
      Console.WriteLine(firstNumber2); // Output: 1
      

      2. Nullable Types in C#:

      Nullable types allow value types to represent null values. This is useful when working with databases or other scenarios where a value might be missing or undefined.

      3. Defining a Nullable Type in C#:

      To define a nullable type, use the ? suffix with the value type.

      int? nullableInt = null;
      nullableInt = 5;
      Console.WriteLine(nullableInt); // Output: 5
      

      In this example, nullableInt is a nullable integer that can hold both null and integer values.

      4. Purpose of the ?? Operator in C#:

      The ?? operator, known as the null-coalescing operator, is used to provide a default value when the left-hand operand is null.

      string name = null;
      string defaultName = "Default Name";
      
      string result = name ?? defaultName;
      Console.WriteLine(result); // Output: Default Name
      
      name = "John";
      result = name ?? defaultName;
      Console.WriteLine(result); // Output: John
      

      In this example, if name is null, result will be assigned the value of defaultName. Otherwise, it will be assigned the value of name.

      5. Use of the switch Statement in C#:

      The switch statement is used to select one of many code blocks to execute based on the value of an expression. It is a cleaner alternative to multiple if-else statements when you have multiple conditions to check.


      int day = 3;
      string dayName;
      
      switch (day)
      {
          case 1:
              dayName = "Monday";
              break;
          case 2:
              dayName = "Tuesday";
              break;
          case 3:
              dayName = "Wednesday";
              break;
          case 4:
              dayName = "Thursday";
              break;
          case 5:
              dayName = "Friday";
              break;
          case 6:
              dayName = "Saturday";
              break;
          case 7:
              dayName = "Sunday";
              break;
          default:
              dayName = "Invalid day";
              break;
      }
      
      Console.WriteLine(dayName); // Output: Wednesday
      
      In this example, the switch statement checks the value of day and assigns the corresponding day name to dayName. If day does not match any case, the default case is executed.

      Comments

      Popular posts from this blog

      C# : How can we access private method outside class

      Introduction In object-oriented programming, encapsulation is a fundamental principle that restricts direct access to the internal implementation details of a class. Private methods, being part of this internal implementation, are designed to be accessible only within the confines of the class they belong to. However, there might be scenarios where you need to access a private method from outside the class. In this blog post, we'll explore several techniques to achieve this in C#. 1. Reflection: A Powerful Yet Delicate Approach Reflection is a mechanism in C# that allows inspecting and interacting with metadata about types, fields, properties, and methods. While it provides a way to access private methods, it should be used cautiously due to its potential impact on maintainability and performance. using System ; using System . Reflection ; public class MyClass { private void PrivateMethod ( ) { Console . WriteLine ( "This is a private method."

      C# : Understanding Types of Classes

      In C#, classes serve as the building blocks of object-oriented programming, providing a blueprint for creating objects. Understanding the types of classes and their applications is crucial for designing robust and maintainable software. In this blog, we’ll delve into various types of classes in C#, accompanied by real-world scenarios and code snippets for a practical understanding. 1. Regular (Instance) Classes Definition: Regular classes are the most common type and are used to create instances or objects. They can contain fields, properties, methods, and other members. Example Scenario: A Person class representing individual persons with properties like Name and Age. public class Person { public string Name { get ; set ; } public int Age { get ; set ; } } 2. Static Classes Definition: A static class cannot be instantiated and can only contain static members (methods, properties, fields). It’s often used for utility functions. Example Scenario: A MathUtility cla

      C# : 12.0 : Primary constructor

      Introduction In C# 12.0, the introduction of the "Primary Constructor" simplifies the constructor declaration process. Before delving into this concept, let's revisit constructors. A constructor is a special method in a class with the same name as the class itself. It's possible to have multiple constructors through a technique called constructor overloading.  By default, if no constructors are explicitly defined, the C# compiler generates a default constructor for each class. Now, in C# 12.0, the term "Primary Constructor" refers to a more streamlined way of declaring constructors. This feature enhances the clarity and conciseness of constructor declarations in C# code. Lets see an simple example code, which will be known to everyone. public class Version { private int _value ; private string _name ; public Version ( int value , string name ) { _name = name ; _value = value ; } public string Ve