Is everything an object in .NET and C#?

In .NET and C# all is object.

Simply said.

Even a value type, a struct, an interface and an enum.

One can not approve, but the point is that everything is object, except pointers/references, and literals from binary files, even CPU optimized primitive types, since it is the OOP Theory as well as the. NET specifications and therefore the facts.

Continue reading »


What are classes and interfaces in C#?

Interfaces are to make an abstraction, an archetype, of the abstraction, the classes, of the reality, the objects.

Interfaces are to specify contract terms without providing implementation provided by classes.

Continue reading »


What is polymorphism in OOP?

Polymorphism in OOP Theory is the ability to:

  • Invoke an operation on an instance of a specialized type by only knowing its generalized type while calling the method of the specialized type and not that of the generalized type: this is dynamic polymorphism.
  • Define several methods having the save name but having differents parameters: this is static polymorphism.

The first if the historical definition and the most important.

Continue reading »


What is encapsulation in OOP?

Encapsulation in OOP Theory is the process to mask some properties and operations in the class that will become inaccessible from the exterior: these are only internal things and behaviours like a digestive system.

It's a compartmentalization.

Continue reading »


What is abstraction in OOP?

Abstraction in OOP Theory consists in retaining only the relevant aspects of a real world object for a specific problem.

Thus we talk about abstraction of the reality.

It's a reduction.

Continue reading »


How to improve your knowledge of C#

Study the code of software you like that you can found for example on CodeProject, GitHub, GitLab, SourceForge, etc.

Try to make similar software and adapt them, without plagiarizing outside of personal learning, like a notepad, a calculator, a file explorer, a bank manager... or a game.

Write code, don't stop to write.

And above all, read and re-read books.

Personally, I like Wrox (Wiley) books, they are very good: do not hesitate to read even old books if newer version not available.

Online course are great too, but they don't replace books and source code or professional training.

To be able to understand advanced and in depth subjects related to programming and the nature of computers, we must go to Assembly, not only IL, but native Assembly and machine code.

Continue reading »


Are interfaces evil or misused?

There are several considerations and practices concerning interfaces

Some developers say that interfaces can be used as a replacement of multiple inheritance mechanisms, which cause complexity and ambiguity. But each feature must be implemented each time it is declared: this is not an inheritance, this is a wrapper to the description of a part of a group of classes, like IDisposable. It is the same as a multiple inheritance with one implemented class and some abstract classes: it is a particular case which allows only one way hierarchy with interfaces as abstract connectors that describes services.

Some developers say that interfaces can be used to separate the access to an object of this instance. Historically, interfaces are a COM & DCOM heritage: they are used to manipulate components services, whatever objects are, where they are, and how they are implemented. Interfaces are not a replacement to multiple inheritance, they are something else.

Recommended articles:
A plea for full multiple inheritance support in .NET
A Typed Intermediate Language for Compiling Multiple Inheritance

Continue reading »


Design flaws of the singleton pattern

The paradigm

Consider this common singleton pattern implementation:

public class Singleton
{
  static private readonly object locker = new object();

  static public Singleton Instance
  {
    get
    {
      lock ( locker )
      {
        if ( _Instance == null ) _Instance = new Singleton();
        return _Instance;
      }
    }
  }
  static private volatile Singleton _Instance;

  private Singleton() { }
}

The problem is that you can inherit this class and create a public constructor if there is no private constructor. Furthermore, static members are allowed. This is no longer a singleton at all. Setting the class as sealed can be an acceptable solution, but you must implement singleton by singleton, i.e., more than ten lines. Thus, coding a such singleton can be the source of many errors and difficulties. Thinking with factoring is not only an agile principle, it is a mathematical theorem.

Defining a generic singleton

A generic solution is to check the absence of static members and that there is only one parameterless private constructor, or an exception is thrown. Singletons that inherit this class can't be inherited and must be sealed. Moreover, the implementation of singleton types are checked at program startup. Therefore, it is not the best solution, but the only thing to do is to create one parameterless private constructor, no static members, and seal the class.

  Generic Persistent Singleton Sample

Size: 53.4 KiB
Upload: 28 July 2009
Update: 8 September 2015
Last download: 19 April 2024
Total downloads: 571

Continue reading »