Official Study Materials for Computer Science
Review targeted academic resources with the Application of .NET Technology Unit 09 .NET Architecture and Advanced Tools Notes Set 01. Built according to official standards for the 2026-27 term, these downloadable Computer Science study materials support effective daily practice and deeper conceptual understanding for .NET Technology.
Advanced Resources for Computer Science
Navigate directly to the advanced Computer Science study materials using the digital viewer below. Each resource pack includes detailed conceptual summaries and solved practice questions, allowing students to instantly reinforce their learning.
This page covers object-oriented VB.Net (classes, constructors, destructors, shared members, inheritance) and structured exception handling with Try, Catch, Finally and Throw. It then moves to designing distributed web applications in three layers and the qualities of availability, manageability, performance, reliability, scalability and securability, followed by XML classes, ADO.NET, graphics, printing and report generation.
Object-oriented Programming - Classes and Objects
When you define a class, you define a blueprint for a data type.
This does not actually define any data, but it does define what the class name means, that is, what an object of the class will consist of and what operations can be performed on such an object.
Objects are instances of a class.
The methods and variables that constitute a class are called members of the class.
A class definition starts with the keyword Class followed by the class name; and the class body, ended by the End Class statement.
Following is the general form of a class definition:
[ <attributelist> ] [ accessmodifier ] [ Shadows ] [ MustInherit | NotInheritable ] [ Partial ] _ Class name [ ( Of typelist ) ] [ Inherits classname ] [ Implements interfacenames ] [ statements ] End Class
Attributelist is a list of attributes that apply to the class. Optional.
Accessmodifier defines the access levels of the class, it has values as - Public, Protected, Friend, Protected Friend and Private. Optional.
Shadows indicate that the variable re-declares and hides an identically named element, or set of overloaded elements, in a base class. Optional.
MustInherit specifies that the class can be used only as a base class and that you cannot create an object directly from it, i.e., an abstract class. Optional.
NotInheritable specifies that the class cannot be used as a base class.
Partial indicates a partial definition of the class.
Inherits specifies the base class it is inheriting from.
Implements specifies the interfaces the class is implementing.
Member Functions and Variables
A member function of a class is a function that has its definition or its prototype within the class definition like any other variable.
It operates on any object of the class of which it is a member and has access to all the members of a class for that object.
Member variables are attributes of an object (from design perspective) and they are kept private to implement encapsulation.
These variables can only be accessed using the public member functions.
Constructors
A class constructor is a special member Sub of a class that is executed whenever we create new objects of that class.
A constructor has the name New and it does not have any return type.
Types of constructor
1. Default Constructor
2. Parameterized constructors
A default constructor does not have any parameter, but if you need, a constructor can have parameters.
Such constructors are called parameterized constructors.
This technique helps you to assign initial value to an object at the time of its creation.
Example For Constructor
Class Line
Private length As Double ' Length of a line
Public Sub New() 'constructor
Console.WriteLine("Object is being created")
End Sub
Public Sub setLength(ByVal len As Double)
length = len
End Sub
Public Function getLength() As Double
Return length
End Function
Shared Sub Main()
Dim line As Line = New Line()
'set line length
line.setLength(6.0)
Console.WriteLine("Length of line : {0}", line.getLength())
Console.ReadKey()
End Sub
End ClassOutput
Object is being created Length of line : 6
Destructor
A destructor is a special member Sub of a class that is executed whenever an object of its class goes out of scope.
Protected Overrides Sub Finalize() ' destructor
Console.WriteLine("Object is being deleted")
End SubA destructor has the name Finalize and it can neither return a value nor can it take any parameters.
A destructor can be very useful for releasing resources before coming out of the program like closing files, releasing memories, etc.
Destructors cannot be inherited or overloaded.
Example For Destructor
Class Line
Private length As Double ' Length of a line
Public Sub New() 'constructor
Console.WriteLine("Object is being created")
End Sub
Protected Overrides Sub Finalize() ' destructor
Console.WriteLine("Object is being deleted")
End Sub
Public Sub setLength(ByVal len As Double)
length = len
End Sub
Public Function getLength() As Double
Return length
End Function
Shared Sub Main()
Dim line As Line = New Line()
'set line length
line.setLength(6.0)
Console.WriteLine("Length of line : {0}", line.getLength())
Console.ReadKey()
End Sub
End ClassOutput:
Object is being created Length of line : 6 Object is being deleted
Shared Members of a VB .Net Class
The keyword Shared implies that only one instance of the member exists for a class.
Shared variables are used for defining constants because their values can be retrieved by invoking the class without creating an instance of it.
Public Shared Function getNum() As Integer Return num End Function
We can define class members as static using the Shared keyword.
When we declare a member of a class as Shared, it means no matter how many objects of the class are created, there is only one copy of the member.
Public Shared num As Integer Public Sub count() num = num + 1 End Sub
Shared variables can be initialized outside the member function or class definition.
You can also initialize Shared variables inside the class definition.
Example For Shared Members of a VB .Net Class.
Class StaticVar
Public Shared num As Integer
Public Sub count()
num = num + 1
End Sub
Public Shared Function getNum() As Integer
Return num
End Function
Shared Sub Main()
Dim s As StaticVar = New StaticVar()
s.count()
s.count()
s.count()
Console.WriteLine("Value of variable num: {0}", StaticVar.getNum())
Console.ReadKey()
End Sub
End ClassWhen the code is compiled and executed, it produces the following result:
Value of variable num: 3
You can also declare a member function as Shared.
Such functions can access only Shared variables.
The Shared functions exist even before the object is created.
Inheritance
One of the most important concepts in object-oriented programming is that of inheritance.
Inheritance allows us to define a class in terms of another class which makes it easier to create and maintain an application.
This also provides an opportunity to reuse the code functionality and fast implementation time.
When creating a class, instead of writing completely new data members and member functions, the programmer can designate that the new class should inherit the members of an existing class.
This existing class is called the base class, and the new class is referred to as the derived class.
Base and Derived Classes
A class can be derived from more than one interface, which means that it can inherit data and functions from multiple interfaces (VB.Net allows only one base class).
The derived class inherits the base class member variables and member methods.
Therefore, the super class object should be created before the subclass is created.
The super class or the base class is implicitly known as MyBase in VB.Net.
The syntax used in VB.Net for creating derived classes is as follows:
<access-specifier> Class <base_class> ... End Class Class <derived_class> : Inherits <base_class> ... End Class
Exception Handling
An exception is a problem that arises during the execution of a program.
An exception is a response to an exceptional circumstance that arises while a program is running, such as an attempt to divide by zero.
In general it handles the run time error.
Exceptions provide a way to transfer control from one part of a program to another.
VB.Net exception handling is built upon four keywords: Try, Catch, Finally and Throw.
Syntax
Try [ tryStatements ] [ Exit Try ] [ Catch [ exception [ As type ] ] [ When expression ] [ catchStatements ] [ Exit Try ] ] [ Catch ... ] [ Finally [ finallyStatements ] ] End Try
Try:
A Try block identifies a block of code for which particular exceptions will be activated.
It is followed by one or more Catch blocks.
Catch:
A program catches an exception with an exception handler at the place in a program where you want to handle the problem.
The Catch keyword indicates the catching of an exception.
Finally:
The Finally block is used to execute a given set of statements, whether an exception is thrown or not thrown.
For example, if you open a file, it must be closed whether an exception is raised or not.
Throw:
A program throws an exception when a problem shows up.
This is done using a Throw keyword.
Exception Classes in .Net Framework
In the .Net Framework, exceptions are represented by classes.
The exception classes in .Net Framework are mainly directly or indirectly derived from the System.Exception class.
Some of the exception classes derived from the System.Exception class are the System.ApplicationException and System.SystemException classes.
The System.ApplicationException class supports exceptions generated by application programs.
So the exceptions defined by the programmers should derive from this class.
The System.SystemException class is the base class for all predefined system exceptions.
Some of the Predefined Exception Classes
| Name | Description |
|---|---|
| System.IO.IOException | Handles I/O errors. |
| System.IndexOutOfRangeException | Handles errors generated when a method refers to an array index out of range. |
| System.ArrayTypeMismatchException | Handles errors generated when type is mismatched with the array type. |
| System.NullReferenceException | Handles errors generated from dereferencing a null object. |
| System.DivideByZeroException | Handles errors generated from dividing a dividend with zero. |
| System.InvalidCastException | Handles errors generated during typecasting. |
| System.OutOfMemoryException | Handles errors generated from insufficient free memory. |
| System.StackOverflowException | Handles errors generated from stack overflow. |
Handling Exceptions
VB.Net provides a structured solution to the exception handling problems in the form of Try and Catch blocks.
Using these blocks the core program statements are separated from the error-handling statements.
These error handling blocks are implemented using the Try, Catch and Finally keywords.
Following is an example of throwing an exception when dividing by zero condition occurs:
Module exceptionProg
Sub division(ByVal num1 As Integer, ByVal num2 As Integer)
Dim result As Integer
Try
result = num1 \ num2
Catch e As DivideByZeroException
Console.WriteLine("Exception caught: {0}", e)
Finally
Console.WriteLine("Result: {0}", result)
End Try
End Sub
Sub Main()
division(25, 0)
Console.ReadKey()
End Sub
End ModuleYou can use a Throw statement in the Catch block to throw the present object as:
Throw [ expression ]
Example:
Module exceptionProg
Sub Main()
Try
Throw New ApplicationException("A custom exception _
is being thrown here...")
Catch e As Exception
Console.WriteLine(e.Message)
Finally
Console.WriteLine("Now inside the Finally Block")
End Try
Console.ReadKey()
End Sub
End ModuleYou can throw an object if it is either directly or indirectly derived from the System.Exception class. Output:
A custom exception is being thrown here... Now inside the Finally Block
Creating Distributed Web Applications
Visual Studio .NET provides the tools you need to design, develop, debug, and deploy Web applications, XML Web services, and traditional client applications.
Information on application design decisions, such as system architecture, database design, and international considerations, as well as Enterprise Templates.
Application architects can use the .NET Platform to develop, deploy, and support distributed applications.
Highly integrated but flexible, this platform enables developers to build end-to-end business solutions that can leverage existing architectures and applications.
Windows DNA was an architecture for building tightly-coupled, distributed Web applications.
As distributed applications began to require more loosely-coupled principles, the Microsoft architecture moved to the .NET Platform.
Developers can build highly scalable and flexible applications by partitioning applications along these lines, by using component-based programming techniques, and by fully using the features of the .NET Platform and the Microsoft Windows operating system.
A simple distributed application model consists of a client that communicates with the middle layer, which itself consists of the application server and an application containing the business logic.
The application, in turn, communicates with a database that supplies and stores data.
The key tenet of distributed applications is the logical partitioning of an application into three fundamental layers:
1. Presentation
2. Business Logic
3. Data Access and Storage
Presentation services
The presentation layer includes either a rich- or thin-client interface to an application.
The rich client, either directly by using the Microsoft Win32 API or indirectly through Windows Forms, provides a full programming interface to the operating system's capabilities or uses components extensively.
The thin client (Web browser) is rapidly becoming the interface of choice for many developers.
A developer is able to build business logic that can be executed on any of the three application tiers.
With ASP.NET Web applications and XML Web services, the thin client is able to provide a visually rich, flexible, and interactive user interface to applications.
Thin clients also have the advantage of providing a greater degree of portability across platforms.
Business Logic - Application Services
This layer is divided into application servers and services, which are available to support clients.
Web applications can be written to take advantage of COM+ services, Message Queuing (MSMQ), directory services, and security services using the .NET Framework.
Application services, in turn, can interact with several data services on the data access layer.
Data Access and Storage Services
The data services that support data access and storage consist of:
1. ADO.NET, which provides simplified programmatic access to data by using either scripting or programming languages.
2. OLE DB, which is an established universal data provider developed by Microsoft.
3. XML, which is a mark-up standard for specifying data structures.
Availability
All applications are available at least some of the time, but Web-based applications and mission-critical enterprise applications must typically provide round-the-clock services.
If your enterprise application needs to work 24 hours a day, 7 days a week, you probably need to design for high availability.
Advances in hardware and software have dramatically increased the quality of high-availability applications.
However, availability is not easy to implement and requires a considerably more complex architectural infrastructure than the previous generation of client/server applications.
If your application requires high availability, you will want to understand how design choices help maximize application availability and how testing can validate planned service levels.
Reduce unplanned downtime:
Cluster service with a shared disk avoids most downtime and provides automatic recovery from hardware or software failures.
Reduce planned downtime:
Planned downtime is reduced because you can deploy operating system and application upgrades without interrupting normal service by using a rolling upgrade.
Continuous health monitoring:
The operational status of your application and server is automatically checked. When a problem is identified the failed service is transferred to another server.
Manageability
Managing a modern .NET application requires an efficient way to handle typical local and remote application support processes, including:
1. Initial deployment
2. Configuration tuning
3. Scheduled and unscheduled maintenance
4. Occasional troubleshooting
Management agents:
Each hardware device, operating system service, and application service requires a management agent.
Management agents monitor the local resource and publish data about the resource's current state and performance.
Collection process:
The information collection process collects, filters, correlates, and stores information from all of the management agents.
Management console:
The management console workstation aggregates and reports on application management information.
From this central console an administrator can monitor all devices, analyze operational profiles, automate certain recurring activities, receive notifications from managed elements, and initiate remote configuration changes.
Performance
1. Identifying Constraints
2. Determining Features
3. Specifying the Load
Key application metrics, such as transaction throughput and resource utilization, define application performance.
Metrics related to hardware, such as network throughput and disk access, are common application performance bottlenecks.
From a user's perspective, application response time defines performance.
Of course, performance does not come without a price.
While it is possible to build a high performance application for any given problem space, a key price point is the cost per transaction.
It is sometimes necessary to sacrifice performance to control cost.
Reliability
As distributed applications grow both in size and complexity, there is an increasing need to improve the reliability and operating quality of software.
First, the cost of application failure is often too high.
Users bypass failure-prone Web sites, resulting in lost revenue and reduced future sales, and the expense of repairing corrupted data can further increase the cost of application failure.
Second, failure-prone systems are difficult to maintain or improve because the failure points are typically hidden throughout the system.
Finally, modern software technology makes it easy to create dependable applications.
At its best, good reliability design engineering would:
1. Follow the Windows 2000 application design guidelines.
2. Put reliability requirements in the specification.
3. Use good architectural infrastructure.
4. Build management information into the application.
5. Use redundancy for reliability.
6. Use quality development tools.
7. Use built-in application health checks.
8. Use consistent error handling.
Scalability
Scalability is the capability to increase resources to yield a linear (ideally) increase in service capacity.
The key characteristic of a scalable application is that additional load only requires additional resources rather than extensive modification of the application itself.
Although raw performance makes a difference in determining the number of users that an application can support, scalability and performance are two separate entities.
In fact, performance efforts can sometimes be opposed to scalability efforts.
The Five Commandments of Designing for Scalability
1. Do Not Wait.
2. Do Not Fight for Resources.
3. Design for Commutability.
4. Design for Interchangeability.
5. Partition Resources and Activities.
Securability
The ability to provide security to an application and its data is referred to here as securability.
The securability of an application is impacted by numerous design choices, such as the selection of communication protocols and the method of user authentication.
Most security vulnerabilities are not in security-related code.
Instead, they are found in code that is unrelated to security and that was written without attention to security.
This is why developers must be keenly aware of application securability.
The acronym STRIDE describes the following taxonomy of security threats:
1. Spoofing Identity.
2. Tampering with Data.
3. Repudiability.
4. Information Disclosure.
5. Denial of Service.
6. Elevation of Privilege.
XML
Extensible Markup Language (XML) is the universal format for data on the Web.
XML allows developers to easily describe and deliver rich, structured data from any application in a standard, consistent way.
XML does not replace HTML; rather, it is a complementary format.
The Extensible Markup Language (XML) is a markup language much like HTML or SGML.
This is recommended by the World Wide Web Consortium and available as an open standard.
The System.Xml namespace in the .Net Framework contains classes for processing XML documents.
XML Class
| Name | Description |
|---|---|
| XmlAttribute | Represents an attribute. Valid and default values for the attribute are defined in a document type definition (DTD) or schema. |
| XmlCDataSection | Represents a CDATA section. |
| XmlCharacterData | Provides text manipulation methods that are used by several classes. |
| XmlComment | Represents the content of an XML comment. |
| XmlConvert | Encodes and decodes XML names and provides methods for converting between common language runtime types and XML Schema definition language (XSD) types. When converting data types, the values returned are locale independent. |
| XmlDeclaration | Represents the XML declaration node <?xml version='1.0'...?>. |
| XmlDictionary | Implements a dictionary used to optimize Windows Communication Foundation (WCF)'s XML reader/writer implementations. |
| XmlDictionaryReader | An abstract class that the Windows Communication Foundation (WCF) derives from XmlReader to do serialization and deserialization. |
| XmlDictionaryWriter | Represents an abstract class that Windows Communication Foundation (WCF) derives from XmlWriter to do serialization and deserialization. |
| XmlDocument | Represents an XML document. |
| XmlDocumentFragment | Represents a lightweight object that is useful for tree insert operations. |
| XmlDocumentType | Represents the document type declaration. |
| XmlElement | Represents an element. |
| XmlEntity | Represents an entity declaration, such as <!ENTITY...>. |
| XmlEntityReference | Represents an entity reference node. |
| XmlException | Returns detailed information about the last exception. |
| XmlImplementation | Defines the context for a set of XmlDocument objects. |
| XmlLinkedNode | Gets the node immediately preceding or following this node. |
| XmlNode | Represents a single node in the XML document. |
| XmlNodeList | Represents an ordered collection of nodes. |
| XmlNodeReader | Represents a reader that provides fast, non-cached forward only access to XML data in an XmlNode. |
| XmlNotation | Represents a notation declaration, such as <!NOTATION...>. |
| XmlParserContext | Provides all the context information required by the XmlReader to parse an XML fragment. |
| XmlProcessingInstruction | Represents a processing instruction, which XML defines to keep processor-specific information in the text of the document. |
| XmlQualifiedName | Represents an XML qualified name. |
| XmlReader | Represents a reader that provides fast, noncached, forward-only access to XML data. |
| XmlReaderSettings | Specifies a set of features to support on the XmlReader object created by the Create method. |
| XmlResolver | Resolves external XML resources named by a Uniform Resource Identifier (URI). |
| XmlSecureResolver | Helps to secure another implementation of XmlResolver by wrapping the XmlResolver object and restricting the resources that the underlying XmlResolver has access to. |
| XmlSignificantWhitespace | Represents white space between markup in a mixed content node or white space within an xml:space='preserve' scope. This is also referred to as significant white space. |
| XmlText | Represents the text content of an element or attribute. |
| XmlTextReader | Represents a reader that provides fast, non-cached, forward-only access to XML data. |
| XmlTextWriter | Represents a writer that provides a fast, non-cached, forward-only way of generating streams or files containing XML data that conforms to the W3C Extensible Markup Language (XML) 1.0 and the Namespaces in XML recommendations. |
| XmlWhitespace | Represents white space in element content. |
| XmlUrlResolver | Resolves external XML resources named by a Uniform Resource Identifier (URI). |
| XmlWriter | Represents a writer that provides a fast, non-cached, forward-only means of generating streams or files containing XML data. |
| XmlWriterSettings | Specifies a set of features to support on the XmlWriter object created by the XmlWriter.Create method. |
ADO .NET
ADO.Net provides a bridge between the front end controls and the back end database.
The ADO.Net objects encapsulate all the data access operations and the controls interact with these objects to display data, thus hiding the details of movement of data.
ADO.NET provides consistent access to data sources such as SQL Server and XML, and to data sources exposed through OLE DB and ODBC.
Data-sharing consumer applications can use ADO.NET to connect to these data sources and retrieve, handle, and update the data that they contain.
The ADO.NET classes are found in System.Data.dll, and are integrated with the XML classes found in System.Xml.dll.
Sample code can be written that connects to a database, retrieves data from it, and then displays that data in a console window.
The DataSet Class
The data set represents a subset of the database.
It does not have a continuous connection to the database.
To update the database a reconnection is required.
The DataSet contains DataTable objects and DataRelation objects.
Properties of the DataSet class
| Name | Description |
|---|---|
| CaseSensitive | Indicates whether string comparisons within the data tables are case-sensitive. |
| Container | Gets the container for the component. |
| DataSetName | Gets or sets the name of the current data set. |
| DefaultViewManager | Returns a view of data in the data set. |
| DesignMode | Indicates whether the component is currently in design mode. |
| EnforceConstraints | Indicates whether constraint rules are followed when attempting any update operation. |
| Events | Gets the list of event handlers that are attached to this component. |
| ExtendedProperties | Gets the collection of customized user information associated with the DataSet. |
| HasErrors | Indicates if there are any errors. |
| IsInitialized | Indicates whether the DataSet is initialized. |
| Locale | Gets or sets the locale information used to compare strings within the table. |
| Namespace | Gets or sets the namespace of the DataSet. |
The DataTable Class
The DataTable class represents the tables in the database. It has the following important properties:
| Name | Description |
|---|---|
| ChildRelations | Returns the collection of child relationship. |
| Columns | Returns the Columns collection. |
| Constraints | Returns the Constraints collection. |
| DataSet | Returns the parent DataSet. |
| DefaultView | Returns a view of the table. |
| ParentRelations | Returns the ParentRelations collection. |
| PrimaryKey | Gets or sets an array of columns as the primary key for the table. |
| Rows | Returns the Rows collection. |
The DataRow Class
The DataRow object represents a row in a table. It has the following important properties:
| Name | Description |
|---|---|
| HasErrors | Indicates if there are any errors. |
| Items | Gets or sets the data stored in a specific column. |
| ItemArrays | Gets or sets all the values for the row. |
| Table | Returns the parent table. |
The DataAdapter Object
The DataAdapter object acts as a mediator between the DataSet object and the database. This helps the data set to contain data from more than one database or other data source.
The DataReader Object
The DataReader object is an alternative to the DataSet and DataAdapter combination. This object provides a connection oriented access to the data records in the database.
DbConnection Objects
The DbConnection object represents a connection to the data source. The connection could be shared among different command objects.
DbCommand Objects
The DbCommand object represents the command or a stored procedure sent to the database for retrieving or manipulating data.
Graphics Control
| Name | Description |
|---|---|
| Graphics | It is the top level abstract class for all graphics contexts. |
| Graphics2D | It is a subclass of Graphics class and provides more sophisticated control over geometry, coordinate transformations, color management, and text layout. |
| Arc2D | Arc2D is the abstract superclass for all objects that store a 2D arc defined by a framing rectangle, start angle, angular extent (length of the arc), and a closure type (OPEN, CHORD, or PIE). |
| CubicCurve2D | The CubicCurve2D class is the abstract superclass for all objects which store a 2D cubic curve segment and it defines a cubic parametric curve segment in (x, y) coordinate space. |
| Ellipse2D | The Ellipse2D is the abstract superclass for all objects which store a 2D ellipse and it describes an ellipse that is defined by a framing rectangle. |
| Rectangle2D | The Rectangle2D class is an abstract superclass for all objects that store a 2D rectangle and it describes a rectangle defined by a location (x, y) and dimension (w x h). |
| QuadCurve2D | The QuadCurve2D class is an abstract superclass for all objects that store a 2D quadratic curve segment and it describes a quadratic parametric curve segment in (x, y) coordinate space. |
| Line2D | This Line2D represents a line segment in (x, y) coordinate space. |
| Font | The Font class represents fonts, which are used to render text in a visible way. |
| Color | The Color class is used to encapsulate colors in the default sRGB color space or colors in arbitrary color spaces identified by a ColorSpace. |
| BasicStroke | The BasicStroke class defines a basic set of rendering attributes for the outlines of graphics primitives, which are rendered with a Graphics2D object that has its Stroke attribute set to this BasicStroke. |
Printing
The PrintDialog control lets the user print documents by selecting a printer and choosing which sections of the document to print from a Windows Forms application. There are various other controls related to printing of documents.
| Name | Description |
|---|---|
| The PrintDocument control | It provides support for actual events and operations of printing in Visual Basic and sets the properties for printing. |
| The PrinterSettings control | It is used to configure how a document is printed by specifying the printer. |
| The PageSetUpDialog control | It allows the user to specify page-related print settings including page orientation, paper size and margin size. |
| The PrintPreviewControl control | It represents the raw preview part of print previewing from a Windows Forms application, without any dialog boxes or buttons. |
| The PrintPreviewDialog control | It represents a dialog box form that contains a PrintPreviewControl for printing from a Windows Forms application. |
The following are some of the commonly used properties of the PrintDialog control:
| Name | Description |
|---|---|
| AllowCurrentPage | Gets or sets a value indicating whether the Current Page option button is displayed. |
| AllowPrintToFile | Gets or sets a value indicating whether the Print to file check box is enabled. |
| AllowSelection | Gets or sets a value indicating whether the Selection option button is enabled. |
| AllowSomePages | Gets or sets a value indicating whether the Pages option button is enabled. |
| Document | Gets or sets a value indicating the PrintDocument used to obtain PrinterSettings. |
| PrinterSettings | Gets or sets the printer settings the dialog box modifies. |
| PrintToFile | Gets or sets a value indicating whether the Print to file check box is selected. |
| ShowHelp | Gets or sets a value indicating whether the Help button is displayed. |
| ShowNetwork | Gets or sets a value indicating whether the Network button is displayed. |
Printing Methods
| Name | Description |
|---|---|
| Reset | Resets all options to their default values. |
| RunDialog | When overridden in a derived class, specifies a common dialog box. |
| ShowDialog | Runs a common dialog box with a default owner. |
Reporting
Designing the report
In this step we create the JRXML file, which is an XML document that contains the definition of the report layout. We can use any text editor or iReportDesigner to manually create it. If iReportDesigner is used the layout is designed in a visual way, hence the real structure of the JRXML can be ignored.
Compiling the report
In this step JRXML is compiled in a binary object called a Jasper file (*.jasper). This compilation is done for performance reasons. Jasper files are what you need to ship with your application in order to run the reports.
Executing the report (Filling data into the report)
In this step data from the application is filled in the compiled report. The class net.sf.jasperreports.engine.JasperFillManager provides necessary functions to fill the data in the reports. A Jasper print file (*.jrprint) is created, which can be used to either print or export the report.
Exporting the report to desired format
In this step we can export the Jasper print file created in the previous step to any format using JasperExportManager. As Jasper provides various forms of exports, hence with the same input we can create multiple representations of the data.
Free study material for Computer Science
Free CBSE Study Guides: Computer Science .NET Technology
Essential Notes for Computer Science
Explore essential learning tools for Computer Science .NET Technology. This curated collection features in-depth notes and targeted practice questions built around the active 2026 curriculum to streamline your daily revision.
Verified Solutions for Computer Science
Designed around the official curriculum, these study guides guarantee standard compliance. Reviewing step-by-step solutions clarifies complex sub-topics within .NET Technology and demystifies standard marking schemes for Computer Science evaluations.
Enhance Accuracy with Online Tests
For peak performance in upcoming evaluations, integrate official Computer Science sample papers directly into your study schedule. Follow up your revision by attempting online MCQ tests for .NET Technology to refine calculation speed and precision.
FAQs
The latest 2026-27 advanced study resources for Computer Science are available for free on StudiesToday.com which includes NCERT Exemplars, high-order thinking skills (HOTS) questions, and deep-dive concept summaries.
Our exhaustive Computer Science package includes chapter wise revision notes, solved practice sheets, important formulas and Concept Maps to help in better understanding of all topics.
Yes. For , our resources have been developed to help you get better marks in school exams and also build fundamental strength needed for entrance tests including Competency Based learning.
in , students should use Active Recall method, read the concept summary, then solve the Important Questions section without looking at the answers and then check your answers.
All Computer Science study materials are provided in mobile-friendly PDF. You can download and save them on your device.
Yes, our team has ensured that all Computer Science materials for are strictly aligned with the National Education Policy (NEP) 2020 and the latest 2026-27 syllabus.