Explain the elements of the .NET Framework.
- CLR (Common Language Runtime): It is a common managed environment where all the .net programs run. Supports multiple languages and has the garbage collector.
- .Net Framework Class Libraries: For each source code compiler (VB.NET, C#.NET, etc.), there is a minimum set of coding standards that must be met. The minimum set of coding standards that must be met to compile .NET code into MSIL code is known as CLS - Common Language Specification. The role of the Common Language Specification is to ensure that all generated code (MSIL) that meets the minimum set of coding standards can operate successfully within the .NET framework. THE CTS (Common Type System) handles conversion of programming-language data types into .NET compatible (MSIL) data types. The implicit benefit of the CTS is the reduction of development time when attempting to coordinate data types between two sets of different programming-language code.
- Data and XML: Support for disconnected programming model and XML.
- XML web services: creating web services for distributed architecture.
- Web forms: Provides support and functionality for Web based UI.
- Windows forms: Provides support and functionality for Windows based UI.
What is assembly manifest ? What is the information it provides.
- Assembly Manifest is a file that contains data that describes how the elements present inside an assembly are connected to each other. The assembly manifest contains assembly metadata to define the scope of the assembly and resolve references to resources and classes.
- Information provided by Assembly Manifest:
- Assembly Name
- Version Number
- Culture
- Strong name
- List of files inside the assembly
- Reference information
Any code written in any .NET complaint languages when compiled, converts into MSIL (Microsoft Intermediate Language) code in form of an assembly through CLS, CTS. IL is the language that CLR can understand. On execution, this IL is converted into binary code by CLR's just in time compiler (JIT) and these assemblies or DLL are loaded into the memory.
.NET's Base class library exists in order to encapsulate huge number of common functions and makes them easily accessible to the developer. .NET base class library provides the functionality like ADO.NET, XML, Threading, IO, Security, Diagnostics, Resources, Globalization, collections etc. It serves as the main point of interaction between developer and runtime.
- Value Type:
- Stores the data.
- The value of value types is stored on the managed stack.
- One variable can have just one value.
- They are lighter objects.
- Reference Type:
- Stores the reference to the data.
- A reference type is allocated on the heap.
- several variables can reference the same data
- They are heavier objects.
- Import statement: creates a property on the global object with the name supplied as namespace and initializes it to contain the object that corresponds to the namespace being imported. Any properties created using the import statement cannot be assigned to, deleted, or enumerated. All import statements are executed when a script starts.
- Using statements: mainly defines the namespaces whose objects will be used in the form. This clearly solves 2 purposes: Defines all the namespaces that will be used in a form. Secondly, reduces the hassle for the programmer to type the name of namespace again and again while using classes/objects that belong to the namespace.
- Class:
- It is reference type.
- Null value can be assigned to a variable in a class
- It can have destructor.
- All variables in classes are by default private.
- Good to be used from architecture view as it provides high flexibility.
- Structure:
- It is value type.
- Null value assignment is not feasible here.
- Cannot have destructor.
- All variables in structures are public.
- Good to be used for simple data structures.
- The garbage collector assumes that all objects in the managed heap are garbage. It starts walking the roots and builds a graph of all objects reachable from the roots recursively. It stops when it attempts to add an object to the graph that it previously added.
- The graph contains the set of all objects that are reachable from the application's roots. Any object/s that is not in the graph is not accessible by the application, and is considered garbage. Collection only occurs when the heap is full. In such a case, each and every garbage object calls the Finalize method and reclaims the unused memory.
The .Net runtime knows about all the references between the objects. It can identify all the circular references that are reachable from the root and hence finalize them to free them all at once if and when needed.
- Main Menu component is a component that allows the display of Menus at runtime on a form.
- Process of creating Menu using Main Menu Component:
- Add Main Menu component on Windows Form.
- Menu designer allows deciding the structure of the main menu by selecting the Type
- Here area and adding the Menu Items to be displayed on the menu.
- Add functionality to Menu Items as required.
- Context Menu component provides the users with the ability to access some very frequently used commands. Context menu works by right click of mouse. They mainly provide access to commands particular to the control that has been clicked upon.
- Process for creating context menus:
- Open the windows form application.
- Select Context Menu component from toolbox.
- A menu is added. Click on Type here and type in new Menu Items to be placed on the Menu.
- Provide the functionality.
- Associate the context menu with the form or the control it is supposed to be related to.
- Break mode is the state of an application when the execution gets paused and allows the developer to edit the value in the current state. To attain a break mode we can do any of the following steps:
- Selecting Break from the Run menu (Ctrl+Break) or pressing the pause button.
- Reaching to break point.
- Setting up the break points:
- Go to the line where you need to mark the break point.
- Click with mouse on left corner margin of that line.
- Another way is to press F9
- Steps to step through the code in .NET:
- Start the program in debug mode.
- When the first break point is reached then step through can be done in one of the two ways:
- Press F10 to move to next line.
- Select debug menu and click on step over. This would step over the break point to next level.
- Other options are: "Step Into" and "Step Out".
- User authored controls are which not part of the .net framework library. It includes both custom controls and user controls.
- Custom Controls: They look similar to ASP.NET controls. They can be created in one of the 3 ways:-
- Deriving a custom control from existing custom control.
- Making a composite custom control by combining 2 or more existing controls
- By creating a new control from scratch by deriving the control from its base class.
- User Controls: enables a part of ASP.NET page to be reused. The reusable part is in form of a control with the extension .ascx. They look like to be a group of ASP.NET controls which can be used over and over again.
- Steps to create inherited Control:-
- Create a new project.
- Add a custom control to the project.
- Change the name of the class you need to inherit the control from the base class. E.g. inherit the class from System.Windows.Forms.Button if the control s to be inherited from a button class.
- Implement the control with custom properties and featured needed by the control.
- Override the On Paint method if the control's appearance needs to be changed.
- Save the build the control
- Reference you control into another or the same project and use the control.
- Steps to create a User control:
- Select a project
- Right click and add a new item (User Control - .ascx) to the selected project.
- Add @Control Directive
- Add all the controls that you want to be displayed on the User control as a part of one or more web pages.
- Write the code for all the tasks to be performed by the user control.
- Create accessor methods for the outside world accessing this user control.
- Using the User control:
- Register the control on the webpage it needs to be used by putting @Register directive.
- Specify the following attributes to the register directive:
- Tag Prefix: defines the namespace in which the control would reside
- Tag Name: defines the name with which control is referred
- Src: Path of where the control is kept.
- Control is then used on the page using the following code:
- Steps to create a custom control:
- Create a new project.
- Add a custom control to the project.
- Change the name of the class you need to inherit the control from the base class.
- E.g. inherit the class from System.Windows.Forms.Button if the control s to be inherited from a button class.
- Implement the control with custom properties and featured needed by the control.
- Override the On Paint method if the control's appearance needs to be changed.
- Save the build the control
- Reference you control into another or the same project and use the control.
- .Net framework has two components:
- .Net framework class library
- Common language runtime.
- FCL facilitates the types through CTS which are common to all the supported languages.
- The CLS ensures that all languages are interoperable. This ensures that all code is managed .i.e. code which is converted to MSIL.
- The CLR has the class loader that load the MSIL code of an application into runtime, which is then converted into native code by the JIT compiler. The CLR manages code and provide services such as memory management, threading, remoting, type safety, security, Exception handling etc.
- Managed execution process is a process where CLR executes the managed code. The steps involved in this process are:
- Choosing the right compiler
- Compiling the code to MSIL. This also generates the required metadata.
- Compile the MSIL ode to native machine code.
- Executing the code with the variety of services available.
- Assembly is a compiled output of program which are used for easy deployment of an application. They are executables in the form of exe or dll. It also is a collection of resources that were used while building the application and is responsible for all the logical functioning.
- Types of assemblies:
- Private Assemblies: are accessible by a single application. They reside within the application folder and are unique by name. They can be directly used by copying and pasting them to the bin folder.
- Shared Assemblies: are shared between multiple applications to ensure reusability. They are placed in GAC.
- Satellite Assemblies: are the assemblies to provide the support for multiple languages based on different cultures. These are kept in different modules based on the different categories available.
- Assemblies are main building blocks. An assembly maybe defined as a unit of deployment. A single assembly is a collection of types, and resources. The CLR does not understand any types that are outside assemblies. The CLR executes the code in assemblies as they contain MSIL code. They define type, version and security boundaries.
- Assemblies in .Net are a solution to the Dll hell problem as one can use different versions of same assembly in different applications at the same time. To make a shared assembly, we need to register it with GAC where as private assemblies reside in applications directory.
- Windows services are a way to create continuously running applications in the background. They don't interfere with other applications and can be run whenever a machine starts. They can be paused if and when needed and quietly run in the background without the need of any user intervention. Windows services can be configured to run under specific user accounts. They run under their own windows sessions and are ideal for tasks that need to be performed periodically or for monitoring requirements.
- Main difference between windows services and other .Net applications lies in the fact that they run in their own windows session without any user intervention in the background.
