This is part five of the series. Before reading this article, I highly recommend reading the previous parts on learning C#:
Abstract
This article is based on learning basic C# concepts in order to create applications using C# language.
Introduction
This is the fifth day of learning a tiny bit of C# in 7 days. In this series we will extend our topics try to cover basic of those topics.
What did we learn last time?
In the last article we covered following topics:
- Delegates
- Enums
- Attributes
- Generics
Agenda for Day 5
- Reflection
- Early Binding/ Late Binding
- Stringbuilder/ System.String
- Var Keyword
- Extension Method
1.1 Reflection
Reflection is the ability to inspect assembly metadata at runtime. It is used to find all types in an assembly.
It can invoke member of the class.
Practical Uses of Reflection
- If you are creating an Editor where we want to show metadata of the object by using intelligence.
- Invoking private methods for testing.
Sometimes we would like to dump properties, methods and assembly reference to a file probably to show it on a screen.
Let’s try and unleash the Basic concept of Reflection. Let’s switch to visual studio and create a new console application.
Figure 1: Creating a new Console Application
While implementing Reflection in your application you need to have two important Namespace:
- System.Reflection
- Sytem.Type
These two work together in order to perform Reflection related operations in .NET. Sytem. Reflection namespace contains all the necessary set of classes, interface, properties.
In this demo I will be creating a class library declare its properties, functions and constructor and try to extract all the members of class using Reflection.
- Add a new Class Library
Figure 2: Creating a new Class Library
We create our StoreMaster class as shown below:
- using System;
- using System.Collections.Generic;
- using System.Linq;
- using System.Text;
- using System.Threading.Tasks;
-
- namespace Store
- {
-
-
- interfaceICreate
- {
- void CreateStore();
-
- }
-
- publicclassStoreMaster: ICreate
- {
-
- publicint storeId
- {
- get;
- set;
- }
- publicstring storeName
- {
- get;
- set;
- }
- publicstring storeAddress
- {
- get;
- set;
- }
-
- publicvoid CreateStore()
- {
-
- Console.WriteLine("Store Created");
- }
-
- publicStoreMaster PrintDetails(int Id)
- {
-
- List < StoreMaster > listStoreMaster = newList < StoreMaster > () {
- newStoreMaster()
-
- {
- storeId = 1,
- storeName = "Kirana",
- storeAddress = "Mumbai"
-
- },
-
- newStoreMaster()
-
- {
- storeId = 2,
- storeName = "Local",
- storeAddress = "Dehradun"
-
- },
- newStoreMaster()
-
- {
- storeId = 3,
- storeName = "Friendz",
- storeAddress = "Bangalore"
-
- },
- };
-
- StoreMaster store = listStoreMaster.Single(str => str.storeId == Id);
- return store;
- }
- }
- }
Build the store class and we will see in the Store class library location and store dll has been created and now we remove the store library class from our project. Now with the help of Reflection we will try to fetch all the information of the class using reflection.
Figure 3: Creation of Store.dll
Figure 4: GetType of the Full Name(Namesace.Class)
You can see that I have removed the Store class library and am trying to access the member and function of class using Reflection.
Type Properties:
- using System;
- using System.Reflection;
-
- namespace Reflection
- {
- classProgram
- {
- staticvoid Main(string[] args)
- {
-
- var assembly = Assembly.LoadFile(@ "C:\Users\Developer\Documents\visual studio 2015\Reflection\Reflection\Store\bin\Debug\Store.dll");
-
-
-
- var type = assembly.GetType("Store.StoreMaster");
-
- bool classStatus = type.IsClass;
- Console.WriteLine($ "Is this Type is a Class= {classStatus} ");
-
- bool interfaceStatus = type.IsInterface;
- Console.WriteLine($ "Is this Type is an Interface= {interfaceStatus} ");
-
- bool abstractClass = type.IsAbstract;
- Console.WriteLine($ "Is this Type is an Abstract Class= {abstractClass} ");
- Console.ReadLine();
- }
- }
- }
Output
Figure 5: Displaying Type Is
You can checkout a whole list of properties of Type class in below url: https://msdn.microsoft.com/en-us/library/system.type(v=vs.110).aspx
Var Keyword in C#
Methods: methods in Sytem.Type is used to retrieve the list of methods of the Type. Let’s cover few of them.
GetProperties: Returns an array of PropertyInfo array.
Figure 6: PropertyInfo Return Type
This method returns an array of PropertyInfo as shown in the above diagram. Now once will get all lists of Properties we will loop through all of them and check whether all of them exist in the Class or not.
- using System;
- using System.Reflection;
-
- namespace Reflection
- {
-
- classProgram
- {
- staticvoid Main(string[] args)
- {
-
- var assembly = Assembly.LoadFile(@ "C:\Users\Developer\Documents\visual studio 2015\Reflection\Reflection\Store\bin\Debug\Store.dll");
-
-
-
- var type = assembly.GetType("Store.StoreMaster");
-
-
-
- PropertyInfo[] properties = type.GetProperties();
- foreach(PropertyInfo property in properties)
- {
- Console.WriteLine(property.Name + " " + property.PropertyType.Name);
- }
-
- Console.ReadLine();
- }
- }
- }
Output:
Figure 7: Displaying Property Name and PropertyType Name
We can also retrieve a single property by just using type.getProperty(“specify the property name”).
Retrieving all Methods using MethodInfo:
- using System;
- using System.Reflection;
- usingstatic System.Console;
- namespace Reflection
- {
- classProgram
- {
- staticvoid Main(string[] args)
- {
-
- var assembly = Assembly.LoadFile(@ "C:\Users\Developer\Documents\visual studio 2015\Reflection\Reflection\Store\bin\Debug\Store.dll");
-
-
-
- var type = assembly.GetType("Store.StoreMaster");
- WriteLine("retrieving single method by name");
- MethodInfo method = type.GetMethod("PrintDetails");
- Console.WriteLine($ "Method name is {method.Name}");
-
- MethodInfo[] methods = type.GetMethods();
- Console.WriteLine($ "All method present in {type.Name}");
- foreach(MethodInfo methodInfo in methods)
- {
- Console.WriteLine($ "method Name= {methodInfo.Name}");
- }
- Console.ReadLine();
- }
- }
- }
Figure 8: Displaying list of method Name present in Type
You will be getting confused why there are so many methods as we have only declared two methods; PrintDetails and CreateStore.
Get_storeid and set_Storeid are internal methods of property and same as other properties whereas toString(), equals(), getHashCode(), getType(). As we know that .net has base class called object and all are type directly or indirectly inherit from system.object class.
Let execute printDetails function using reflection.
- using System;
- using System.Reflection;
- usingstatic System.Console;
- namespace Reflection
- {
- classProgram
- {
- staticvoid Main(string[] args)
- {
-
- var assembly = Assembly.LoadFile(@ "C:\Users\Developer\Documents\visual studio 2015\Reflection\Reflection\Store\bin\Debug\Store.dll");
-
-
-
- var type = assembly.GetType("Store.StoreMaster");
-
-
- var instance = Activator.CreateInstance(type);
-
- object[] parameter = newobject[1];
- parameter[0] = 1;
-
- MethodInfo method = type.GetMethod("PrintDetails");
- WriteLine("Calling PrintDetails method");
-
- dynamic typeClass = (object) method.Invoke(instance, parameter);
- Console.WriteLine(typeClass.storeId);
- Console.WriteLine(typeClass.storeName);
- Console.WriteLine(typeClass.storeAddress);
- Console.ReadLine();
- }
- }
- }
Figure 9: Calling PrintDetails method of storeMaster class
Now if we want to retrieve constructor we can do the same by following.
- WriteLine("retrieving constructor ");
- ConstructorInfo[] constructors = type.GetConstructors();
- foreach(ConstructorInfo constructor in constructors)
- {
- Console.WriteLine(constructor.ToString());
- }
- Console.ReadLine();
Figure 10: Retrieving constructors
We only default constructor which is automatically created by compiler if we don’t have any parameterized constructor. If we don't provide an overloaded constructor, the compiler will generate a default constructor for us.
Let’s go in depth and create a Constructor in our class. So for that we need to open our class project and create parameterized constructor as shown below.
- public StoreMaster(int id, string name, string address)
- {
- this.storeId = id;
- this.storeName = name;
- this.storeAddress = address;
- }
And add a function to display the assigned value of properties while creating an instance of this class.
- publicvoid PrintStoreValues()
- {
- Console.WriteLine("The value of StoreId is={0} ,StoreName= {1} ,StoreAddress={2}", storeId, storeName, storeAddress);
-
- }
So if we want to how many constructor are there and their type we will first retrieve all the constructorsand then move ahead creating instances of the Type.
- using System;
- using System.Reflection;
- namespace Reflection
- {
- classProgram
- {
- staticvoid Main(string[] args)
- {
-
- var assembly = Assembly.LoadFile(@ "C:\Users\Developer\Documents\visual studio 2015\Reflection\Reflection\Store\bin\Debug\Store.dll");
-
-
-
- var type = assembly.GetType("Store.StoreMaster");
-
- ConstructorInfo[] constructors = type.GetConstructors();
- foreach(ConstructorInfo constructor in constructors)
- {
- Console.WriteLine(constructor.ToString());
- }
- Console.ReadLine();
- }
- }
- }
Figure 11: Retrieving parameterized constructors
We can see there is one parameterized constructor which has three parameters. Now once we know the parameters type of constructor let’s try to invoke the class instance and call PrintStoreValuesmethod.
- using System;
- using System.Reflection;
- namespace Reflection
- {
- classProgram
- {
- staticvoid Main(string[] args)
- {
-
- var assembly = Assembly.LoadFile(@ "C:\Users\Developer\Documents\visual studio 2015\Reflection\Reflection\Store\bin\Debug\Store.dll");
-
-
-
- var type = assembly.GetType("Store.StoreMaster");
-
- object[] consParameter = newobject[3];
- consParameter[0] = 1;
- consParameter[1] = "BigBazaar";
- consParameter[2] = "Dehradun";
-
- var objType = Activator.CreateInstance(type, consParameter);
-
- MethodInfo methodToBeCalled = type.GetMethod("PrintStoreValues");
-
-
- methodToBeCalled.Invoke(objType, null);
- Console.ReadLine();
- }
- }
- }
Note:
If you want to see a real life project we can take any IDE eg visual studio.
I have come across one of my favorite tools called .NET Reflector, IL tool etc. Have a look at any one of these to see how great these tools are when we want check the class structure, methods, properties of classed we just use in our project. Here is a snapshot of System.web.Mvc dll
Figure 12: Snapshot of demonstration of ActionResult derived type using IL Spy tool.
Figure 13: Debugging Snapshots
- LateBinding
Before moving ahead let's first learn about early Binding.
Early Binding means methods, properties, constructor etc are checked during the compile time, whereas in a Late Binding method, properties and constructors are checked during the runtime with the help of Reflection or Dynamic keyword in c#.
In late Binding it never checks whether that function or Properties are present or not.
Let try them practically:
2.1 Early Binding:
Figure 14: Compile time check.
Intellisense clearly shows us the return type of the method as well as input parameter type for the method as shown below.
Figure 15: Intelisense for method parameter
- using System;
- namespace EarlyBinding
- {
- classProgram
- {
- staticvoid Main(string[] args)
- {
-
-
- Store store = newStore();
- string result = store.PrintDetails(1, "RM", "Koparkhairne, Mumbai", "500701");
- Console.WriteLine(result);
- Console.ReadLine();
- }
- }
- publicclassStore
- {
- publicstring PrintDetails(int storeId, string storeFullName, string storeFullAddress, string pinCode) {
- return ("The store id of store Name " + storeFullName + " is " + storeId + " located in " + storeFullAddress + " " + pinCode);
- }
- }
- }
In early binding hence all the properties, methods, errors, type Mismatches, return values are calculated at compile time itself.
2.2 LateBinding
Late Binding is basically performed when we don’t have knowledge of the class which we are consuming or creating instance at compile time. So let’s implement the same.
Let’s cut the Store class and add a new class library and paste the same in that class build your class and once it’s successfully buildthan remove the class library.
Figure 16: Remove Class Library Project from Solution
- using System;
- using System.Reflection;
-
- namespace EarlyBinding
- {
- classProgram
- {
- staticvoid Main(string[] args)
- {
-
- var assmbly = Assembly.LoadFile(@ "C:\Users\Developer\Documents\visual studio 2015\Reflection\EarlyBinding\Store\bin\Debug\Store.dll");
- Type type = assmbly.GetType("Store.Store");
-
- object storeInstance = Activator.CreateInstance(type);
-
- MethodInfo method = type.GetMethod("PrintDetails");
- object[] parameter = newobject[4];
- parameter[0] = 1;
- parameter[1] = "Friendz";
- parameter[2] = "Mumbai";
- parameter[3] = "348001";
-
- string result = (String) method.Invoke(storeInstance, parameter);
- Console.WriteLine(result);
- }
- }
-
- }
Figure 17: Retrieving Type from the Assembly
Getting the type of the Class Store.
Figure 18: Retrieved method info with its parameters
Retrieving methodinfo of PrintDetails
Figure 19:Method parameters
Figure 20:Printing the output from Method invoke.
The output after execution for function. So we can see how to do Late Binding. We can figure out the late binding drawbacks:
• No compile time checking
• Complex structure and lengthy code.
• It also have performance issue because of loading the external assembly.
• We should use late binding when we are not aware of the class type.
- Stringbuilder/ System.String
Strings are immutable:
Let’s walk through the Immutable what actually it means using a simple demo:
- using System;
-
- namespace StringBuilder
- {
- classProgram
- {
- staticvoid Main(string[] args)
- {
- Console.WriteLine("Sample System.String");
- string userString = "Learn";
- userString += "tiny";
- userString += "bit of";
- userString += "bit of c#";
- userString += "bit of c# in 7 days";
-
- }
- }
- }
Here we are manipulating the string and adding some text to it. When we try to manipulate the string internally what really happens is that in memory each time we manipulate the string a new copy of userString object is created within heap memory. When string is created for the first time in heap memory the reference variable points towards that allocated memory location once we manipulate the string the reference variable now points towards new manipulated string as shown in the below diagram:
Figure 21: System.String
Once we create a new copy of the string the old string still remains in the memory unless and until garbage collector comes and destroy the same from the memory
So here we learned string is an immutable object which means that once it is created it cannot be changed. Let’s try to unleash this checking whether new objects are getting created or not.
- classProgram
- {
- staticvoid Main(string[] args)
- {
- Console.WriteLine("Sample System.String");
- string userString = string.Empty;
- for (int i = 0; i <= 10000; i++)
- {
- userString += "s";
- }
- }
Here I have created a simple string and manipulated it till the I count is <= 10000. Microsoft has provided us a great tool called CLRProfiler.
“CLRProfiler is a free tool from Microsoft to help you diagnose memory issues with your managed app.”
Source: https://clrprofiler.codeplex.com/
You can download CLRProfiler from https://clrprofiler.codeplex.com/
Let start debugging our application.
• Run CLRProfiler
Figure 22: Figures Demonstrating CLR Profiler Tool. Step By Step process to evaluate the new creation of string objects
• Check allocation and call Profile checkbox,
• Click on File => Profile Application,
• Now give the path of your application.
Figure 23: Step By Step process to evaluate the new creation of string objects (Continued).
• Select the file
• CLR Profiler will automatically create the Summary as shown below:
• Click on Object by Address to check the memory consumption,
Figure 24: Demonstrating the Bytes of memory consumed by System.String.
• We can see 97 percent of the memory is consumed by system.string objects. Once we click on Time Line,
We would be able to see the below graph,
Figure 25: Creation and destruction of Object by Garbage Collector
Here when you will see it live you will find new objects are created and destroyed. So the alternate of this problem is StringBuilder.
StringBuilder string are mutable means no matter how many times you manipulate the string there will be one object created for all of them i.e. same object will be changed all the time when we manipulate the stringBuilder. Unlike string stringBuilder is faster as compared to string. We call append method to add string to our stringBuilder. stringBuilder exists inside System.Text namespace.
Figure 26: String Builder
So let’s try the same example using stringbuilder as shown below:
- classProgram
- {
- staticvoid Main(string[] args)
- {
- Console.WriteLine("Sample System.String");
- StringBuilder userString = newStringBuilder();
- for (int i = 0; i <= 10000; i++)
- {
- userString.Append("s");
- }
- }
- }
Figure 26: String Builder CLR Profiler Performance
Let’s check the performance with CLRProfiler. Perform the same steps as done above in System.String.
Now we can see the memory consumption of StringBuilder.
So we can conclude with the outcome i.e. we are going to use StringBuilder when our output is going to change again and again where we will use string when we using constant string. You can do.
- Var Keyword
In this article we will try to focus and unleash the use of Var keyword.
We have often heard of Var keyword in C#, with emergence of C# 3. New Implicitly typed local variable was introduced. In C# we can declare a variable with var keyword and let the compiler define the datatype from the expression used while initialization.
Eg. Var name=”saillesh”; //Implicit Declaration indirect
The C# compiler can conclude or decide that the type of my variable name is “String”.
i.e the above statement generates the same result as the following statements.
String name=”saillesh”; //Explicit Declaration direct declaration
This means what type of data type we want to assign to name variable.
In the Var keyword datatype the compiler at the compile time looks at the right hand side data type and creates the desired data type to the variable. As in example of Var keyword the compiler will assign the string data type to the name variable.
In single one word terminology we can say that:
“Var keyword is an Implicit or Indirect way of defining data type”.
By looking at the right hand side data the datatype is assigned to the var variable during the generation of IL code.
i.e. var keyword defines data type statically not dynamically.Let’s take a practical example of the same,
- namespace Var
- {
- classProgram
- {
- staticvoid Main(string[] args)
- {
-
- var value = 1;
- value = "saillesh";
- }
- }
- }
If try to build it we face an error as shown below:
Figure 27: Error specifying strongly typed Explicit Declaration
Figure 28: Error specifying strongly typed Explicit Declaration
So we can see that the error is shown during the compile time not during the runtime.Now once I try to check the data type of the value, it displays the data type as shown below,
Figure 29: strongly typed variable of type Int
We can do the same using Type keyword in C# as shown below:
- namespace Var
- {
- classProgram
- {
- staticvoid Main(string[] args)
- {
-
- var value = 1;
-
- Type valueType = value.GetType();
- Console.WriteLine("value if of datatype " + valueType.ToString());
- Console.WriteLine();
-
-
- }
-
- }
- }
Figure 30: Displaying the data typeof Type
So just to confirm the same, let’s open this application in ILDASM, I declare some more var variable and assign other datatypes to the variable and then see how var keyword is statically defined during run time.
- namespace Var
- {
- classProgram
- {
- staticvoid Main(string[] args)
- {
-
- var value = 1;
- var name = "Nishant Negi";
- var isMale = true;
- Console.ReadLine();
-
-
-
-
- }
-
- }
- }
Open ILDASM
Step 1:
Go to start got to Visual Studio and search for Developer Command Prompt .
Run the Developer Command Prompt and type ILDASM as shown below:
ILDASM will open as shown below:
Step 2: Go to your project root directory copy the path of .exe file as shown below:
Copy the address bar and click on File option in ILDASM.
Click on Open and paste the desired location of your Application.
And open the same in ILDASM.
Double click on Main Intermediate Language code will appear.
Now we can see very clearly that these variables are local variables and are of type:
• value => int32
• name => string
• isMAle =>bool
So we can say that the var type keyword is statically defined.
There are few restrictions of Var keyword implicit typed local variables:
• We must initialize the variable
If we try to declare Implicit type variable without initialization it give us the compile time error.
- classProgram
- {
- staticvoid Main(string[] args)
- {
- var name;
- }
-
- }
Figure 31: Implicit type variable without initialization
• Var keyword cannot be null,
- classProgram
- {
- staticvoid Main(string[] args)
- {
- var name = null;
- }
-
- }
Figure 32: Var keyword cannot
• You cannot use object or collection initializers:
- classProgram
- {
- staticvoid Main(string[] args)
- {
- var array =
- { 1, 3, 4, 5 };
- }
- }
Figure 33: Error demonstrating we cannot use object or collection initializers
- namespace Var
- {
- classProgram
- {
- staticvoid Main(string[] args)
- {
- var value = 1;
- var name = "Saillesh";
- var array = newint[]
- {
- 1,
- 3,
- 4,
- 5,
- 6
- };
- Console.WriteLine(value);
- Console.WriteLine(name);
- foreach(int i in array)
- {
- Console.WriteLine(i);
- }
- Console.ReadLine();
- }
-
- }
- }
Output:
Figure 33: defining Collection of type int and other var declaration
So now what is benefit of Var keyword and what scenarios it‘s useful.
4.1 Object Initializers
As we follow OOPs principle likes Class, Object etc. We have to do a lot of Object Initialization as shown below:
- publicclassCustomer
- {
- privatestring _customerName;
-
- publicstring customerName
- {
- get;
- set;
- }
-
- privatestring _customerAddress;
- publicstring customerAddress
- {
- get;
- set;
- }
-
- }
When we instantiate this class we normally write code,
- staticvoid Main(string[] args)
- {
- Customer objCustomer = newCustomer();
- objCustomer.customerName = "Saillesh Pawar";
- objCustomer.customerAddress = "Mumbai";
- }
- Or
- staticvoid Main(string[] args)
- {
- Customer objCustomer = newCustomer()
- {
- customerName = "Saillesh Pawar",
- customerAddress = "Mumbai"
- };
- }
- Or we can do the same using Var keyword
-
- var objCustomer = newCustomer()
- {
- customerName = "Saillesh Pawar",
- customerAddress = "Mumbai"
- };
4.2 Initializing Collections
Let’s take an example of a generic list as shown below,
- List < string > objstringList = newList < string > ();
- using System;
- using System.Collections.Generic;
- using System.Linq;
- using System.Text;
- using System.Threading.Tasks;
-
- namespace Var
- {
- publicclassAuthor
- {
- string _author;
- List < string > _articles = newList < string > ();
- publicstring author
- {
- get
- {
- return _author;
- }
- set
- {
- _author = value;
- }
- }
-
- publicList < string > articles
- {
- get
- {
- return _articles;
- }
- set
- {
- _articles = value;
- }
- }
-
- }
-
-
- classProgram
- {
- staticvoid Main(string[] args)
- {
- List < Author > authorList = newList < Author > ();
- Author objAuthor = newAuthor();
- objAuthor.author = "Saillesh Pawar";
- objAuthor.articles.Add("Learn C# day 1");
- objAuthor.articles.Add("Learn C# day 2");
- objAuthor.articles.Add("Learn C# day 3");
- objAuthor.articles.Add("Var keyword");
- authorList.Add(objAuthor);
-
- Author objAuthor2 = newAuthor();
- objAuthor2.author = "Nishant Negi";
- objAuthor2.articles.Add("Essence of Life");
- objAuthor2.articles.Add("Serve your Nation");
- objAuthor2.articles.Add("My life");
- objAuthor2.articles.Add("Enroute to Ladakh");
- authorList.Add(objAuthor2);
-
- Console.WriteLine(objAuthor.author + " Articles Published \n" + objAuthor.articles[0] + "\n" + objAuthor.articles[1]);
- Console.WriteLine(objAuthor2.author + " Articles Published \n" + objAuthor2.articles[0] + "\n" + objAuthor2.articles[1]);
- Console.ReadLine();
- }
-
-
- }
- }
Now same can be done with less amount of code using Var.
- using System;
- using System.Collections.Generic;
-
- namespace Var
- {
- publicclassAuthor
- {
- string _author;
- List < string > _articles = newList < string > ();
- publicstring author
- {
- get
- {
- return _author;
- }
- set
- {
- _author = value;
- }
- }
-
- publicList < string > articles
- {
- get
- {
- return _articles;
- }
- set
- {
- _articles = value;
- }
- }
- }
- classProgram
- {
- staticvoid Main(string[] args)
- {
- var autorList = newList < Author > ()
- {
- newAuthor
- {
- author = "Saillesh Pawar",
- articles =
- {
- "Learn Tiny bit of c# day1",
- "Learn tiny bit of C# day2"
- }
- },
- newAuthor
- {
- author = "Nishant Negi",
- articles =
- {
- "Enjoy the life",
- "Enroute to Ladakh"
- }
- }
- };
-
- Console.WriteLine("Author name " + autorList[0].author + "Articles Published in 2015 \n 1." + autorList[0].articles[0] + " \n 2." + autorList[0].articles[1]);
-
-
- Console.WriteLine("Author name " + autorList[1].author + "Articles Published in 2015 \n 1." + autorList[0].articles[1] + " \n 2." + autorList[0].articles[1]);
- Console.ReadLine();
- }
-
-
- }
- }
4.3 Linq with Anonymous Types
I will be covering linq in depth in upcoming articles. Anonymous Types: The C# can create an Anonymous type by using the properties in an object initializer.
Eg:
- var obj = new
- {
- Name = "saillesh",
- Address = "Mumbai"
-
-
- };
- Console.WriteLine("Name= {0} , Address={1}", obj.Name, obj.Address);
By this the compiler creates an Anonymous type and declares the properties as specified in the object initializer.
Sometimes we need Anonymous type when we are working with linq, example there are two classes and you are joining them with linq to sql. In order to fetch the value to strongly typed propertiesyou need a class that can hold the records retrieved by the Linq. Well that’s a whole lot of work, you can do the same without creating a class with the help of Var keyword as shown below:
- using System;
- using System.Collections.Generic;
- using System.Linq;
- using System.Text;
- using System.Threading.Tasks;
- using System.Xml.Linq;
-
- namespace Anonymous
- {
- publicclassMeetingMaster
- {
- publicint MOMId
- {
- get;
- set;
- }
- publicint SegmentId
- {
- get;
- set;
- }
- publicint MeetingNameId
- {
- get;
- set;
- }
- publicstring Description
- {
- get;
- set;
- }
-
- }
- publicclassMeetingNameMaster
- {
- publicint Id
- {
- get;
- set;
- }
- publicstring MeetingName
- {
- get;
- set;
- }
- }
-
-
- classProgram
- {
- staticvoid Main(string[] args)
- {
- var meetingList = newList < MeetingNameMaster >
- {
- newMeetingNameMaster
- {
- Id = 1,
- MeetingName = "RMS"
- },
- newMeetingNameMaster
- {
- Id = 2,
- MeetingName = "Functional"
- },
- newMeetingNameMaster
- {
- Id = 3,
- MeetingName = "Hr"
- }
-
- };
-
- var meetingMaster = newList < MeetingMaster >
- {
- newMeetingMaster
- {
- MOMId = 1,
- MeetingNameId = 1,
- Description = "RMS Funtional covered",
- SegmentId = 1
- },
- newMeetingMaster
- {
- MOMId = 2,
- MeetingNameId = 1,
- Description = "Functional Agenda Covered"
-
- },
- newMeetingMaster
- {
-
- MOMId = 3,
- MeetingNameId = 1,
- Description = "Rms functional covered responsibility taken by saillesh pawar",
- SegmentId = 1
-
- }
- };
-
- var rmsMeetingCommenced = (from mtnMaster in meetingMaster join meetings in meetingList on mtnMaster.MeetingNameId equals meetings.Id selectnew {
-
- MOMId = mtnMaster.MOMId,
- Desciption = mtnMaster.Description,
- MeetingName = meetings.MeetingName
- }).ToList();
-
-
-
-
- foreach(var i in rmsMeetingCommenced)
- {
- Console.WriteLine("The MOM id is {0} \n MeetingId is {1} \n Meeting Description is={2} \n MeetingName is ={3}", i.MOMId, i.MeetingName, i.Desciption, i.MeetingName);
-
- }
-
- Console.ReadLine();
-
-
-
-
- }
- }
- }
- Extension Method
We can create an Extension method within a Static class within a static method. The first parameter of an extension class must be keyword this.
Eg:
- using System;
-
- namespace ConsoleApplication3
- {
- publicstaticclassMyClass
- {
-
- publicstaticint Square(thisint Number)
- {
- return (Number * Number);
- }
-
- }
-
-
- classProgram
- {
- staticvoid Main(string[] args)
- {
-
- Console.WriteLine("Enter the Number");
- int Number = Convert.ToInt32(Console.ReadLine());
- int squareResult = Number.Square();
-
- Console.WriteLine("The square of the number is " + squareResult);
- Console.ReadLine();
-
- }
- }
- }
Output:
Figure 34: Calling Extension Method
We can do the same without extension method:
- int squareResult = MyClass.Square(Number);
Read more articles on C#: