Test interview

you cannot declare 
static members as abstract or virtual
and, therefore, cannot override them. You can 
created new members with the same name, but that doesn't have the same behavior 
as inheritance. 
51.
What is the difference between new () & override? 
The override keyword is used to extend or modify a virtual/abstract method, 
property, indexer, or event of base class into derived class. The new keyword is used 
to hide a method, property, indexer, or event of base class into derived class. 
52.
Can we disallow overriding? (Sealed) 
To prevent being overridden, 
use the sealed in C#
. When you use sealed modifiers in 
C# on a method, then the method loses its capabilities of overriding. The sealed 
method should be part of a derived class and the method must be an overridden 
method.
53.
What is an indexer? 
C# indexers are usually known as smart arrays. A C# indexer is a class property that 
allows you to access a member variable of a class or struct using the features of an 
array. ... Defining an indexer allows you to create a class like that can allows its items 
to be accessed an array. 
54.
What is SOLID? Let's talk about each letter! 
SOLID
principles are the design principles that enable us to manage most of the 
software design problems. Robert C. Martin compiled these principles in the 1990s. 
These principles provide us with ways to move from tightly coupled code and little 
encapsulation to the desired results of loosely coupled and encapsulated real needs 
of a business properly. 
SOLID
is an acronym of the following: 
S
: Single Responsibility Principle 
–
a class should take only one responsibility 
O
: Open Closed Principle 
–
open for extension, closed for modification 
L
: Liskov Substituion Principle 
–
this principle states that a developer should be able 
to use any derived class and have it behave in the same manner without modification 
I
: Interface Segration Principle 
–
this principle states that clients should not be forced 
to implement interfaces they don’t use. Instead of that fat interface, many small are 
preferred based on groups of methods, each one serving one submodule. 

---

D
: Dependency Inversion Principle 
–
this principle states that high-level modules/ 
classes should not depend on low-level modules/classes. Both should depend upon 
abstractions. Secondly, abstractions should not depend upon details. Details should 
depend upon abstractions.
55.
Suppose we sealed the class, we also follow the letter O in SOLID, but then realized 
that we need to add one more method, how can we do this and perhaps without 
changing the class? 
~~ 
56.
What is managed / unmanaged code?