Question: Which software engineering principles are
supported by C#? How does this language help in the development
of large software systems?

Answer:

• Type-safety. C# is a type-safe language, which means
  that the compiler checks the correct usage of types in expressions,
  assigments and method calls (also across class and component
  boundaries). In the development of large software systems
  this helps to detect errors early (i.e. at compilation time)
  instead of at run time during testing. This significally
  reduces the software development and maintenance costs.
• Data abstraction. C# allows programmers to combine data
  and operations to objects. The interfaces of these objects
  can be kept simple; any complexities can be hidden behind
  the interface inside the implementation of the objects
  (information hiding). This helps in the development of large
  software systems because it allows developers to structure
  their data and operations and to keep the interfaces between
  objects small. Modifications to the software are therefore
  kept local most of the time. This helps to reduce maintenance
  costs.
• Object-orientation. This is the next step beyond data
  abstraction. Objects (consisting of data and methods) are
  instances of classes that can be organized in type hierarchies.
  A class can inherit code from another class. This speeds up
  software development: only those parts of a subclass have to
  be implemented that cannot be inherited from its base class.
  Interface types can be used to define the method protocol
  that a certain type should support. All classes that implement
  this interface are guaranteed to support these methods.
  Dynamic binding makes it possible to work with variables
  without knowing the run-time type of the object that is
  stored in this variable. As long as the static type of the
  variable supports a certain method, the method can be invoked
  on this variable, and the object that is stored in this
  variable will respond. Object-orientation is important for
  making large software systems extensible.
• Component-based programming. .NET assemblies are
  components that are used via their interfaces. They are stored
  in binary form as DLL or EXE files and can be dynamically
  loaded. Assemblies can be separately deployed and replaced
  with new versions on demand. Since assemblies also contain
  metadata (i.e. type information) they can by inspected and
  manipulated at run time using reflection. This makes it
  possible to configure a system of components at run time
  using a builder tool.
• Exception handling. This is a feature that is available
  in most modern programming languages. It allows programmers
  to keep the normal (error-free) program logic separate from
  error-handling code. Exceptions can be thrown in one method
  and caught (i.e. handled) in one of the callers. The CLR
  makes sure that an exception that is not handled causes the
  program to terminate so that errors cannot go undetected.
  Large programs rely on this technique to handle all possible
  errors in a systematic way.
• Threading. C# supports light-weight parallel processes.
  Several activities in a program can be executed concurrently
  without blocking each other. The access to common data can be
  guarded with lock statements which are an implementation of
  the well-known monitor concept. Threading is especially useful
  for the implementation of user interfaces and servers.