Application of .NET Technology Unit 09 .NET Architecture and Advanced Tools Notes Set 01

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 Class

Output

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 Sub

A 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 Class

Output:

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 Class

When 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

NameDescription
System.IO.IOExceptionHandles I/O errors.
System.IndexOutOfRangeExceptionHandles errors generated when a method refers to an array index out of range.
System.ArrayTypeMismatchExceptionHandles errors generated when type is mismatched with the array type.
System.NullReferenceExceptionHandles errors generated from dereferencing a null object.
System.DivideByZeroExceptionHandles errors generated from dividing a dividend with zero.
System.InvalidCastExceptionHandles errors generated during typecasting.
System.OutOfMemoryExceptionHandles errors generated from insufficient free memory.
System.StackOverflowExceptionHandles 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 Module

You 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 Module

You 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

NameDescription
XmlAttributeRepresents an attribute. Valid and default values for the attribute are defined in a document type definition (DTD) or schema.
XmlCDataSectionRepresents a CDATA section.
XmlCharacterDataProvides text manipulation methods that are used by several classes.
XmlCommentRepresents the content of an XML comment.
XmlConvertEncodes 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.
XmlDeclarationRepresents the XML declaration node <?xml version='1.0'...?>.
XmlDictionaryImplements a dictionary used to optimize Windows Communication Foundation (WCF)'s XML reader/writer implementations.
XmlDictionaryReaderAn abstract class that the Windows Communication Foundation (WCF) derives from XmlReader to do serialization and deserialization.
XmlDictionaryWriterRepresents an abstract class that Windows Communication Foundation (WCF) derives from XmlWriter to do serialization and deserialization.
XmlDocumentRepresents an XML document.
XmlDocumentFragmentRepresents a lightweight object that is useful for tree insert operations.
XmlDocumentTypeRepresents the document type declaration.
XmlElementRepresents an element.
XmlEntityRepresents an entity declaration, such as <!ENTITY...>.
XmlEntityReferenceRepresents an entity reference node.
XmlExceptionReturns detailed information about the last exception.
XmlImplementationDefines the context for a set of XmlDocument objects.
XmlLinkedNodeGets the node immediately preceding or following this node.
XmlNodeRepresents a single node in the XML document.
XmlNodeListRepresents an ordered collection of nodes.
XmlNodeReaderRepresents a reader that provides fast, non-cached forward only access to XML data in an XmlNode.
XmlNotationRepresents a notation declaration, such as <!NOTATION...>.
XmlParserContextProvides all the context information required by the XmlReader to parse an XML fragment.
XmlProcessingInstructionRepresents a processing instruction, which XML defines to keep processor-specific information in the text of the document.
XmlQualifiedNameRepresents an XML qualified name.
XmlReaderRepresents a reader that provides fast, noncached, forward-only access to XML data.
XmlReaderSettingsSpecifies a set of features to support on the XmlReader object created by the Create method.
XmlResolverResolves external XML resources named by a Uniform Resource Identifier (URI).
XmlSecureResolverHelps to secure another implementation of XmlResolver by wrapping the XmlResolver object and restricting the resources that the underlying XmlResolver has access to.
XmlSignificantWhitespaceRepresents 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.
XmlTextRepresents the text content of an element or attribute.
XmlTextReaderRepresents a reader that provides fast, non-cached, forward-only access to XML data.
XmlTextWriterRepresents 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.
XmlWhitespaceRepresents white space in element content.
XmlUrlResolverResolves external XML resources named by a Uniform Resource Identifier (URI).
XmlWriterRepresents a writer that provides a fast, non-cached, forward-only means of generating streams or files containing XML data.
XmlWriterSettingsSpecifies 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

NameDescription
CaseSensitiveIndicates whether string comparisons within the data tables are case-sensitive.
ContainerGets the container for the component.
DataSetNameGets or sets the name of the current data set.
DefaultViewManagerReturns a view of data in the data set.
DesignModeIndicates whether the component is currently in design mode.
EnforceConstraintsIndicates whether constraint rules are followed when attempting any update operation.
EventsGets the list of event handlers that are attached to this component.
ExtendedPropertiesGets the collection of customized user information associated with the DataSet.
HasErrorsIndicates if there are any errors.
IsInitializedIndicates whether the DataSet is initialized.
LocaleGets or sets the locale information used to compare strings within the table.
NamespaceGets 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:

NameDescription
ChildRelationsReturns the collection of child relationship.
ColumnsReturns the Columns collection.
ConstraintsReturns the Constraints collection.
DataSetReturns the parent DataSet.
DefaultViewReturns a view of the table.
ParentRelationsReturns the ParentRelations collection.
PrimaryKeyGets or sets an array of columns as the primary key for the table.
RowsReturns the Rows collection.

The DataRow Class

The DataRow object represents a row in a table. It has the following important properties:

NameDescription
HasErrorsIndicates if there are any errors.
ItemsGets or sets the data stored in a specific column.
ItemArraysGets or sets all the values for the row.
TableReturns 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

NameDescription
GraphicsIt is the top level abstract class for all graphics contexts.
Graphics2DIt is a subclass of Graphics class and provides more sophisticated control over geometry, coordinate transformations, color management, and text layout.
Arc2DArc2D 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).
CubicCurve2DThe 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.
Ellipse2DThe 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.
Rectangle2DThe 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).
QuadCurve2DThe 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.
Line2DThis Line2D represents a line segment in (x, y) coordinate space.
FontThe Font class represents fonts, which are used to render text in a visible way.
ColorThe Color class is used to encapsulate colors in the default sRGB color space or colors in arbitrary color spaces identified by a ColorSpace.
BasicStrokeThe 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.

NameDescription
The PrintDocument controlIt provides support for actual events and operations of printing in Visual Basic and sets the properties for printing.
The PrinterSettings controlIt is used to configure how a document is printed by specifying the printer.
The PageSetUpDialog controlIt allows the user to specify page-related print settings including page orientation, paper size and margin size.
The PrintPreviewControl controlIt represents the raw preview part of print previewing from a Windows Forms application, without any dialog boxes or buttons.
The PrintPreviewDialog controlIt 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:

NameDescription
AllowCurrentPageGets or sets a value indicating whether the Current Page option button is displayed.
AllowPrintToFileGets or sets a value indicating whether the Print to file check box is enabled.
AllowSelectionGets or sets a value indicating whether the Selection option button is enabled.
AllowSomePagesGets or sets a value indicating whether the Pages option button is enabled.
DocumentGets or sets a value indicating the PrintDocument used to obtain PrinterSettings.
PrinterSettingsGets or sets the printer settings the dialog box modifies.
PrintToFileGets or sets a value indicating whether the Print to file check box is selected.
ShowHelpGets or sets a value indicating whether the Help button is displayed.
ShowNetworkGets or sets a value indicating whether the Network button is displayed.

Printing Methods

NameDescription
ResetResets all options to their default values.
RunDialogWhen overridden in a derived class, specifies a common dialog box.
ShowDialogRuns 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 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

Where can I find the most advanced study material for [current-page:node:field_board] [current-page:node:field_class] Computer Science for 2026-27?

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.

What does the 2026-27 Computer Science study package for [current-page:node:field_class] include?

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.

Is this study material enough for both [current-page:node:field_board] exams and competitive tests?

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.

How should [current-page:node:field_class] students use this Computer Science material for maximum marks?

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.

Can I download [current-page:node:field_class] Computer Science study notes in PDF for offline use?

All Computer Science study materials are provided in mobile-friendly PDF. You can download and save them on your device.

Are the [current-page:node:field_class] Computer Science resources updated for the latest NEP guidelines?

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.