One day when he was sitting next to the owner as usual, with the owner doing all the maths on the calculator, the owner wanted to know the price of a product. The old man of course had this information handy through years of working in the shop. In fact he also knew how much quantity of that product was in the shop. From that day his role changed, he would advice the owner on inventory management, cost price and selling price of each product.

A few days later on being asked by someone what was he still doing in the shop, when the owner now had the calculator, the old man said that he had been promoted to be a manager!

The morale of the story is simple. To grow in an organization, make yourself replaceable. Grow your fellow employees to take your place. Growing your team should be the higher objective, and you’ll see that your own growth was a natural consequence.

Each organization has its own unique set of processes and tools. At CircleSource we have created our own Software Development Methodology customized to suit the kind of product development we undertake in our organization. This is a simple one page document, figuratively explaining the various phases and associated deliverables. We use two main tools – SVN for version control and Trac for project management. We have customized both these tools to our needs. Besides, we have many other documented processes e.g. Release Management, Roll out of the application on the production server,  Pre Release Checks.
The key is the dissemination of this information to the employees on a continual basis. It takes extreme importance for new joinees who have to be quickly taken under the wings of CircleSource’ QMS. We provide training to all new employees on our tools and processes, and strive to do this within a week of their inception. No employee can be part of a live project unless he/she has undergone these trainings. This initiative, which is a combined effort of the HR/Quality Team/Engineering Team of CircleSource, ensures that our team adheres to processes and  delivers value  from day one of the project!

As we know we can bind the controls to our page (aspx) in 2 ways
1. Statically :- Binding the controls while Designing
2. Dynamically :- Binding the controls at runtime

Everyone know how to bind statically but there may be some cases where we need to bind the control dynamically .One of those cases is when our controls are keep on changing like I have a registration site in which the control type may keep on changing then I may need to go for binding the controls dynamically .

Approach:

For binding the controls I need the data what are the controls I want to bind and what is the id to be given and what are the properties to be provided etc.,

This can be provided by 2 ways

1. Using database (This is my approach)
2. Using Xml file

I am creating one example (registration Page) where I am getting the data from the database as a table and based on this table I will be binding my controls to the page as we can see below

My Controls Data from database

ControlText : - Text to be Displayed

ControlType :-

1 – TextBox Control
2 – DropDown Control
3 – DateTime Control
4 – Buttom Control

MaxLength:- Defining the maximum length for textbox

Manditory :- Based On this we will be binding the required field validation

HelpText :- This is used to bind as ToolTip for the control

Source :- Use for binding data source for dropdown controls

Page in which all the controls are generated dynamically

Implementation:

As we know all the server control are under System.Web.UI.WebControls namespace

I will be getting the tabel into a dataset for suppose the name is controlsDataSet

///
/// Method usd to bind the controls
///
///
private void BuldControls(DataSet controlsDataSet)
{
Table table = new Table();
table.Style.Add("align", "center");

// Looping the dataset and get the values
foreach (DataRow datarow in controlsDataSet.Tables[0].Rows)
{
int controlType =
Convert.ToInt32(datarow["ControlType"].ToString());
string controlText = datarow ["ControlText"].ToString();

TableRow newRow = new TableRow();
TableCell textCell = new TableCell();

// Binding the text
textCell.Text = controlText;
newRow.Cells.Add(textCell);

TableCell valueCell = new TableCell();
Control[] cntrlCollection=new Control[4];

// Checking the control Type
switch(controlType)
{
// If TextBox
case 1:
cntrlCollection = this.BindTextBox(control);
break;

// If DropDown
case 2:
cntrlCollection = this.BindDropDown(control);
break;

// If DateTime
case 3:
cntrlCollection = this.BindDateTime(control);
break;

// If Button
case 4:
cntrlCollection = this.BindButton(control);
break;

}

// Adding th controls to the table cell
foreach (Control cntrl in cntrlCollection)
{
if (cntrl != null)
{
valueCell.Controls.Add(cntrl);
}
}

newRow.Cells.Add(valueCell);
table.Rows.Add(newRow);
}

// Adding the table to the main panel
this.pnlControls.Controls.Add(table);
}

Creating controls dynamically is not a big matter but we have bind in such a way that when we are retriving it should not be a problem so we need to give the ids of the controls as below

///
/// Method to bind the DropDown
///
///
///
private Control[] BindTextBox(DataRow datarow)
{
// Retriving the values from the datarow
int controlId = Convert.ToInt32(datarow["Id"].ToString());
int length = Convert.ToInt32(datarow["MaxLengh"].ToString());
bool required =
Convert.ToBoolean(datarow["Manditory"].ToString());
string helpText = datarow["HelpText"].ToString();
string controlText = datarow["ControlText"].ToString();

// Creating the controls array
Control[] controls = new Control[4];

// creating the textbox
TextBox textbox = new TextBox();
textbox.ID = string.Concat(“txt”, controlId);
textbox.ToolTip = helpText;

// Checking the length
if (length != 0)
{
textbox.MaxLength = length;
}

// Adding the textbox to the control array
controls[0] = textbox;

// Checking id manditory
if (required)
{
controls[1] = this.BindRequiredvalidator(controlId,
textbox.ID, controlText);
}
return controls;
}

Suppose I am bind for the name column the textbox id becomes like this
“txt_1” and while saving also we can save accordingly.

So this is the way how to bind the controls and now coming to validation controls (I and using the controls provided my the VS).I am showing you a example where I am bind a validation control to textbox as shown below

private RequiredFieldValidator BindRequiredvalidator(int Id, string
controlId, string controlText)
{
RequiredFieldValidator requiredFieldValidator = new
RequiredFieldValidator();
requiredFieldValidator.ID = string.Concat(“rfv”, Id);
requiredFieldValidator.ControlToValidate = controlId;
requiredFieldValidator.SetFocusOnError = true;
requiredFieldValidator.ErrorMessage = string.Concat(“Enter “,
controlText);
return requiredFieldValidator;

}

For this method I will be passing the Id , ControlId (Like textbox control id) which need to be validated ,controlText used for error messaeges

And after doing all these we can see the paeg with validation controls like this

With Validation controls

Advantages over binding controls statically:

1. Suppose we need to add 10 controls and we are using those statically but now I need to change my control type like a textbox to be changed to dropdown then I need to change all my code once again but this easier while binding controls dynamically.
2. Can bind any validation to any control dynamically.

The use cases and class diagrams are very useful in order to plan and designing any project. Before understanding use cases and diagrams we need to know regarding UML.

UML can be abbreviated as Unified Modeling Language, which is used in order to provide a common modeling for various
problems/projects which are platform independent, technology independent and support purely object oriented programming languages.

The use cases can be defined in simple word as scenario in which the given problem solution will be used and what are all the cases that may arise while using the project/solution.

The use cases helps the system design and development easier by providing the necessary and mandatory cases that are the users of any project.  The use cases can be represented by using standard notations.  The following are the notations which are used in order derive the use cases most commonly.

In order to understand the use cases in better way, let me explain an example, consider the video conference system as a problem/project, in order to implement this project first I need to gather the information from user/client properly once the required information is gathered by using any of the information gathering techniques, I can start on writing the use cases for video conference system.

The use cases are formed or designed by considering the main functional requirements of the system not mapped one-to-one and it shows what behavior the actor can expect and not how the system will work to provide the service.

In order to write the use cases we need to know two things properly in use cases

1.  Actor,the external agent who will make use of the system

2. Service provided by the System

In the video conference system the actors are the persons who will make use of the system by connecting to the system, and the services provided by the system are login authentication, video conferencing, video recording, text messaging.  These are all the main functional requirements which are identified in order to develop the video conferencing system.  The following are the different use cases those can be derived or drawn by considering the video conferencing system and the services provided by the system.

The following are the example/illustrative use case diagrams with respect to web based video conferencing system, which is used for video conferencing over the internet.

The use case diagrams does have extension, aggregation and interface concept those can be represented pictorially as above.

Class Diagrams

                The class diagrams are diagrams which are used in order to represent the classes used or to be used in any solution
implementation using notations.  The class diagrams makes the understandability of the project flow and the pictorially represents the different classes used and how they were connected to each other  and which are all the classes that depends on the other classes can be represented.

The class diagram can be represented by following notation and it does mainly have 3 parts first part is the name of the class, the second box or part is declaration of members or variables which are used in the class, the third part/box will be list of all the methods which are implemented in the class in order to perform the operations on class data members.

The following notations are used in drawing class diagrams.

The Class diagrams can be used to represent all the available variants of classes in Object oriented languages.

The example class diagram used in web based video conferencing system.

In this diagram, as we can see the class is of type public and class name is enter_002dconf2_jsp used in web based video conferencing system, the member of the class is _dependants of  type Vector and access mode is private.

The two methods are defined of type public in order to perform the required operation, the getDependants() ,
method will get all the necessary dependents needed to start the video conferencing service, and the second method will _jspService() will start the service and write the required information on to the browser, if the required dependents are present then the client application will run through which the user can able to perform video conferencing, if not then the
necessary information will be written on to the browser.

Advantage for developing against a reporting framework:

Development Efficiency
Most of the tedious reporting logic is written once and encapsulated in a reusable reporting component. Instead of copying the code from page to page or starting from scratch, we can leverage the reusable component whenever needed. This speeds up the report generation significantly which will help in meeting the project deadlines and keep the project on time and on budget.

Accuracy
As speed increases, accuracy normally decreases. Coding against a framework allows us to create reports faster without adverse effects on accuracy. Because most of the complex reporting logic is encapsulated in reusable component, the errors will be less as we are touching less code.
Consistency
Using a reporting framework also ensures all the report pages are consistent. In absence of reporting framework, every user may use different method of creating reports there by creating inconsistency in report generation process and also report content. Consistency is imperative for user experience.
In general, reporting framework will give following features

1. Standard way to collect the input (for both data source and report parameters) for the report in the form of report filters (implemented as bean, data models or datasource).
2. All these report filters will implement a standard interface or extend from an abstract class. (In case of web applications, we can have a separate report servlet to handle this input collection and forwarding the request.)
   Input forms are still specific to each report and they initiate the report generation process in report framework.
   User has to give data source implementation for each report based on input filter but this is handled in a consistent way.
3. User has to specify the report design files for each type of report and export allowed and reporting framework has to dynamically find this based on the report type and export type. These things can be externally configured using property files.
4. Reporting framework has to set the data source and report parameters (standard one’s like report creator/timestamp/any standard headers/footers/summary and any user supplied report parameters specific to the report being generated.)
5. The report design files can be compiled each time or cached by the reporting framework.
6. Finally, the reporting framework has to call the report engine’s api to generate the report and show to the user in the export format requested by the user.
7. In addition to this, to handle the complex reports, report framework can also include support for handling sub reports in a consistent way.