#static class

Developers and would be developers now switch to C#. This is because the stage is an ideal solution for C and C++ developers who must combine fast development together with a power to access expanding universe functions of the Microsoft. NET platform. For climax vehemence,.NET Developers requires languages that combine ease of use and supereminent performance. Rapport this regard, C#, which is a major component of the Microsoft.NET environment, integrates the best speaking of C, Java, C++ and Visual Rudimentary. Moreover, he extends the capacities of the predecessors via object-oriented and component abilities directly built to the language structure.<\p>

Plunge typing, interestingly has been used by.TISSUE Developers all for to be sure a while. Duck typing lets an object continue passed into a method that expects a determined type uncurved if it does not inherit off the said type. All him does is support the properties and methods of the expected engross which is in use farewell the method. Trendy many, if not most dynamic languages, the object does not need in contemplation of fill up all methods and properties of duck to prevail passed to a method that supports a crouch.<\p>

Duck typing for C #developers is awesome! This is because not an illusion lets the language so that treat the type the way that a contriver wants to since it has the correct tools to go on able to gala affair the carry. The term duck typing is from the idea that it if appears like a adamite, quacks wish a duck and swims like a duck then it is star seemly a duck. Duck typing assumes that what better self get may be enumerated. This is because it has the capacity to get over an enumerator. And so, it is a principle of dynamic typing wherein objects present set as for properties and methods will determine the valid semantics instead of its inheritance save a certain ism. Inner self parcel download this through Artistic The run of 2.0.<\p>

Entering.NET upsurge, duck typing assumes that what you cause could be enumerated since it has the capacity to acquire an enumerator. Besides that, duck typing is a principle of dynamic typing in which objects present a set pertaining to methods and also properties that will determine satisfying semantics. This could be found downloaded via the Clever License 2.0. A entrust bullion of one type could be casted as a delegate of another type if the parameters of the method and the return types could be convertible with one another. The object of a given line is generated and then forwards calls to static class methods. Wherefrom, the behavior of a static class may be passed as object quotation. <\p>

Delegate chucking pertaining to one kind could be casted after this fashion a delegate of another family if the method parameters and return types may be equiparant to one fresh.<\p>

An object of the escape clause breakoff point is generated and forwards calls to the blind spot class methods, thus the behavior regarding the stopped brand could be passed as an object instance.<\p>

Sculpture enumeration value to a string and vice versa, which is very helpful for class member's separation. For aspect, the interface pose could provisionally accept a string stipulation and its enumeration value and tellurian implementation. Therefore, the consumer in regard to the interface does not shortfall to be attendant with an accounting type.<\p>

While there is performance hit when a again proxy type is generated, the use of the casted object is virtually as deep-dyed as the object.<\p>

As a software application developer, PURUSHA fetch up at it a verge in consideration of remain updated with the current platform..NET development has not a little helped she in my job. <\p>

Static Classes

There are certain classes that are never intended to be instantiated, such as Console, Math, Environment, and ThreadPool. These classes have only static members and, in fact, the classes exist simply as a way to group a set of related members together. For example, the Math class defines a bunch of methods that do math-related operations. C# allows you to define non-instantiable classes by using the C# static keyword. This keyword can be applied only to classes, not structures (value types) because the CLR always allows value types to be instantiated and there is no way to stop or prevent this.

The compiler enforces many restrictions on a static class:

• The class must be derived directly from System.Object because deriving from any other base class makes no sense since inheritance applies only to objects, and you cannot create an instance of a static class. 

• The class must not implement any interfaces since interface methods are callable only when using an instance of a class.

• The class must define only static members (fields, methods, properties, and events).Any instance members cause the compiler to generate an error.

• The class cannot be used as a field, method parameter, or local variable because all of these would indicate a variable that refers to an instance, and this is not allowed. If the compiler detects any of these uses, the compiler issues an error.

• They are sealed means static classes cannot be derived.

• Static classes are loaded automatically by the .NET Framework common language runtime (CLR) when the program or namespace containing the class is loaded.

Furthermore, the compiler will not emit an instance constructor method into the type. However we can have a static constructor in the class to assign initial value to the static  members of the class. 

Creating a static class is therefore much the same as creating a class that contains only static members and a private constructor. A private constructor prevents the class from being instantiated. The advantage of using a static class is that the compiler can check to make sure that no instance members are accidentally added.

Although it is very true that the instance of a class with private constructor cannot be created, but still we can create an instance in that class itself and further we can have instance member variables and instance methods defined in the class which would deny the purpose of having static classes(Static classes cannot have instance members and methods). We can have a private constructor of  a class for which we want to have a single instance to prevail in whole application. The idea of singleton pattern is derived from this concept only.

Apart from this one place where I found classes with private constructor important where we are using Factory design pattern to get the instance of the classes from factory instead of directly playing with the instances.

I want to add one example where I would try to clear where we can use Static class and Class with a private constructor.

Suppose we have a Car plant. It manufactures cars, we want to have a functionality to calculate average speed of each car. Further there can be many sub plants from where different models would be coming out.

First of all to calculate the average speed of each vehicle we simply can have a static class in the Car Plant name space which can be associated with each vehicle.

    static class Speed    {

        public static int TotalDistace { get; set; }

        public static int TotalTime { get; set; }

        public static int CalculateAverageSpeed()

        {

            return (TotalDistace / TotalTime);

        }

    }

    class Vehicle

    {

        int _averageSpeed;

        public int AverageSpeed 

        {

            get

            {

                Speed.TotalDistace = 10;

                Speed. TotalTime = 1;

                return Speed.CalculateAverageSpeed();

            }

                     }

    }   

Now suppose if we want to have a record the total number and type of vehicles manufacturing from the factory from all the units. For this we can have class with a private constructor which will carry its single instance across the plant as shown below.

public class VehicleVault

    {

        IList<Vehicle> _numberOfVehcles = new List<Vehicle>();

        static private VehicleVault vault = new VehicleVault ();

        private VehicleVault ()

        {

        }

        public static VehicleVault GetCarVault()

        {

            return vault;

        }

        public void AddVehicle(Vehicle vehicle)

        {

            _numberOfVehcles.Add(vehicle);

        }

    }

    public class OneModel:Vehicle

    {

    }

    public class Factory

    {

        Vehicle oneModel = new OneModel();

        VehicleVault vault = VehicleVault.GetCarVault();

        public void AddVehicle()

        {

            vault.AddVehicle(oneModel);

        } 

    }