The “new” operator is generally used to create new objects. When you do something like:
Car car1 = new Car("blue", 4, "Volkswagen", "Golf");
A new object of that type is created and a reference is saved into “car1”.
What happens here is that every time you use the new-operator, it checks how many bytes of memory you need for your object. This is the sum of the bytes of all properties, references to other objects and the properties of these objects plus some extra information for you object such as the object pointer, which is used by the garbage collector. After figuring out how many bytes are required on the managed heap, it actually allocates these bytes and sets them all to 0. If it can’t allocate enough space that is required for your new object, an OutOfMemory-exception is thrown. Now, before actually creating the object, the extra-information properties (such as the object pointer) are initialized. You can see this as a set of information that is required so the CLR can manage your object. Now the object’s constructor is called. Now if your object is derived from another object, the constructor emits code to call the constructor of the base class. Of course, every constructor is responsible for setting the class’ parameters to an initial (default) value. You can find the list of initial values on MSDN. Even if your class isn’t inherited from another class, the code for calling the System.Object-constructor is emitted, since System.Object is the base for every object created by the CLR. Object’s constructor is empty, and just returns.
The “new”-keyword can also be interpreted as a modifier. This can be done if you want to explicitly hide a member from an inherited class. For example, if our Car-class would inherit from a Vehicle-class that had a method defined, and you would implement this same method in the Car-class, you would get a warning.
Vehicle class:
1: public class Vehicle
2: {
3: …
4:
5: public void DoSomething()
6: {
7: Console.WriteLine("I'm doing something in the Vehicle class");
8: }
9: …
10: }
Car class:
1: public class Car
2: {
3: …
4:
5: public void DoSomething()
6: {
7: Console.WriteLine("I'm doing something in the Car class");
8: }
9: …
10: }
The warning:
Changing the Car class with the ‘new’ modifier results in resolving the warning:
1: public class Car
2: {
3: …
4:
5: new public void DoSomething()
6: {
7: Console.WriteLine("I'm doing something in the Car class");
8: }
9: …
10: }
Now that we’ve done all that, we can safely say that if you have to use this ‘new’ modifier…you’re doing something wrong somewhere. A better way is to define the method in your base class as virtual (which basically means that if someone is inheriting your class, that person is allowed to implement his own version of that method in his class). If someone wishes to implement his own version of that method in his class, he can use the override method to do so, without any warnings being generated.