Essential language features
Download as PPTX, PDF0 likes234 views
The document discusses several key C# language features including auto-implemented properties, object and collection initializers, extension methods, anonymous methods, and lambda expressions. Auto-implemented properties reduce code by automatically generating backing fields and accessors when no additional logic is needed. Object and collection initializers allow initializing objects without separate constructor calls. Extension methods allow adding methods to existing types without modifying the original code. Anonymous methods and lambda expressions allow passing code blocks as delegates, with lambda expressions using less code.
Essential language features
- 2. Essential Language Features Anoop K. C. anoop@baabte.com www.facebook.com/anoopb aabte twitter.com/anoop_baabte in.linkedin.com/in/anoopbaa bte/ +91 9746854752
- 4. Consider a class “baabtraStudent” with the 3 properties name, marks and isPromotable . Consider the following code to implement the class.
- 5. If we have a closer look at the implementation of properties, properties name and marks have get and set methods implemented in the usual way whereas the boolean property isPromotable is implemented as a read-only property and the get accessor of isPromotable is implemented with some logic. The logic is “the student is promotable (isPromotable returns true) only when his marks are greater than 60” Leaving the isPromotable property and if we look at the other two, there is no logic in the get and set accessors. So if we have 10 or 20 or more such properties we will have to write a lot of code to implement all these which will actually take away a lot from the developers’ time. The concept of auto-implemented properties removes this hassle by making the property declaration in a single line of code which will look like Public string name { get; set; }
- 6. With such a declaration the compiler will automatically implement the get and set accessors of the property. So that our earlier implementation of the baabtraStudent class can be re-written as This enhances the code maintainability by a greater degree and removes the need of writing a lot of code to implement the properties.
- 7. Summary auto implemented properties can only be used when the implementation of property (get and set accessors) need no additional logic Auto implemented properties reduce the amount of code that needs to be written We don’t have to explicitly declare a field for an auto implemented property. when we use auto-implemented properties, the compiler creates a private, anonymous field that can only be only be accessed through the property’s get and set accessors.
- 8. Object and Collection Initializers
- 9. Object initializers let us assign values to any accessible fields or properties of an object at creation time without having to invoke a constructor followed by lines of assignment statements. Consider the class “baabtraStudent” again
- 10. Suppose if we want to create 3 object instances of this class, we will have to write the following code, This needs a lot of code to be written to initialize objects.
- 11. C# offers another method of object initializing as shown in the following code Which saves a lot of coding and time for the developers. A collection object of the “baabtrStudent” class (List<baabtraStudent>) can also be initialized in the same way as in the following code. This eliminates creating and adding new objects to the collection one by one.
- 13. Extension methods help us to add new methods to existing types without modifying the original code, inheriting or aggregating . Consider a simple class called “mathOperations” which is having only an addition method, which takes two numbers as arguments and returns the added value as result. Suppose this class is added as a compiled dll to our application and the source code is no longer available to edit and add other methods.
- 14. We can create an instance of this class in our application and perform an add function and display the result as in the following code When we put a dot to the right of the mathOperations variable the “add” method is populated in the intelliscence And the program runs smoothly
- 15. Now if we want to find the difference between two numbers, there is no subtract method available in the “mathOperations” class. So to add a subtract method we can go for 3 options add a subtract method in the “mathOperations” class – this is not possible as mathOperations is a third party dll and we don’t have the source code for it. Through aggregation - Create a wrapper class around the math operations class and add the subtract method as shown in the following example
- 16. And access the method as shown in the following code But now as you can see the add method can only be accessed through a mathOperations field of wrapperMathOperations class and is not directly accessible from the wrapperMathOperationsClass. The third method is to inherit the mathOperations class and add the subtract method In any of the three methods the complexity of the class structure is increased.
- 17. The correct solution to such a scenario is an extnesion method “subtract” for the mathOperations type which can be created in the following way, Now the method “add” and “subtract” (as an extention method, see the blue arrow right to the pink block) appears in the intelliscense block for an object instance of the mathOperations class as shown in the following fig.
- 18. Summary extension methods enable us to add methods to a datatype without changing the code for the datatype or creating a derived type. An extension method must be a static method inside a static class they can be called on the object instance in the same way as we call any other defined methods in the object class
- 19. Anonymous Methods & Lambda Expressions
- 20. Anonymous methods provide a technique to pass a code block as a delegate parameter. Anonymous methods are basically methods without a name, just the body. We need not specify the return type in an anonymous method; it is inferred from the return statement inside the method body. Anonymous methods are declared with the creation of the delegate instance, with a delegate keyword. For example The code block Console.WriteLine("Anonymous Method: {0}", x); is the body of the anonymous method.
- 21. The delegate could be called both with anonymous methods as well as named methods in the same way, i.e., by passing the method parameters to the delegate object. By using anonymous methods, we reduce the coding overhead in instantiating delegates because you do not have to create a separate named method. The scope of the parameters of an anonymous method is the anonymous- method-block. It is an error to have a jump statement, such as goto, break, or continue, inside the anonymous method block if the target is outside the block. It is also an error to have a jump statement, such as goto, break, or continue, outside the anonymous method block if the target is inside the block.
- 22. Lambda expressions Lambda expressions are similar to anonymous methods with the difference that in lambda expressions we don’t have to use the “delegate” keyword and the input parameter type explicitly. Lamda expressions are more easy to write than anonymous methods because they need much lesser amount of coding and they are syntactically simpler. Lambda expressions are particularly helpful in writing LINQ query expressions. In an anonymous method the inout parameters canbe completely omitted if they are not used inside the method block but in case of a lambda expression this is not possible. Most of the time lambda expressions supersede anonymous methods unless the input parameters to the method has to be omitted which is not possible in lambda expressions
- 23. Examples The examples below demonstrates the same functionality implemented with anonymous method and lambda expression Anonymous method
- 26. The var keyword in C# allows the compiler to infer the type of a variable implicitly. A var can be set to any type like, string, int, double etc. The var can be used to access a variable based on an anonymous class. var is only allowed for local variables var is also strongly typed, but by the compiler. For example, The following two declarations of i are functionally equivalent: A variable of type var cannot be initialized to null After the initial assignment the type of the variable is fixed
- 27. Follow us @ twitter.com/baabtra Like us @ facebook.com/baabtra Subscribe to us @ youtube.com/baabtra Become a follower @ slideshare.net/BaabtraMentoringPartner Connect to us @ in.linkedin.com/in/baabtra Thanks in advance. www.baabtra.com | www.massbaab.com |www.baabte.com
- 28. Contact Us Emarald Mall (Big Bazar Building) Mavoor Road, Kozhikode, Kerala, India. Ph: + 91 – 495 40 25 550 NC Complex, Near Bus Stand Mukkam, Kozhikode, Kerala, India. Ph: + 91 – 495 40 25 550 Cafit Square, Hilite Business Park, Near Pantheerankavu, Kozhikode Start up Village Eranakulam, Kerala, India. Email: info@baabtra.com