I was hoping the DropDown event would take a CancelEventArgs, but nope — and not surprising, since after a little digging, I finally got it to work,  Here’s the code:

Happy Coding

Siri was originally introduced as an iOS application available in the AppStore. Siri was acquired by Apple Inc. on April 28, 2010. Siri had announced that their software would be available for BlackBerry and for Android-powered phones, but all development efforts for non-Apple platforms were cancelled after Apple’s purchase.

Siri is now an integrated part of iOS 5, and available only on the iPhone 4S, launched in October 2011.

Independent developers claim that they ported Siri to iPhone 4.However, some news sites consider that the videos they posted for proof only show the User interface of the application, excluding any voice commands, to conclude that they did not prove anything. However, new sources suggests that the independent developers are able to port Siri to the iPhone 4 and the iPod Touch.

From Wikipedia

If you face error that if database is already in use, you can resolve the same by making database in single user mode – here is the guideline

ALTER DATABASE [YourDbName]
SET SINGLE_USER WITH ROLLBACK IMMEDIATE;

The above query will rollback any transaction which is running on that database and brings SQL Server database in a single user mode.

The usual error due to database in use is as follows:

Msg 3702, Level 16, State 3, Line 1
Cannot drop database “YourDbName” because it is currently in use.

as the ALTER script mentioned on the top of the post will remove that error. Please make sure that if you are on production server, alter database should be used very carefully.

Reference : Pinal Dave

Well, it might not be rocket science (or rocket engineering) but its not exactly well documented, so here are a couple of real world examples of how to handle images in your reports.

Showing/Hiding Images

First of all this is how to show or hide an image in a table, based on the condition of filed in your data set. This could be used to indicate (for instance) if an order is stopped. The first thing to do is add an image holder into your table. When you drag the image holder onto the cell of the table the image wizard will open. Follow the Wizard through and embed the image in your report. When its done you will see the image in the table cell.

Now, on the properties of the cell, drop down the Visible -> Hidden property, and click inExpression in the list, this will open up the expression editor. In here we are going to use an IIF statement to check the condition of one of our fields. We can then set theVisible state to true or false depending on the outcome. The statement will look something like:

=iif(Fields!Stop_Stat.Value = “Stop”, False, True)

With this now in place, when you run the report it should now only show the image when the value of Stop_Stat is true.

Changing the Image

The will be some circumstances where you want to show a different image depending on the value of a variable. This is done in a similar way to hiding the image, but instead youData value of the image source.

The first thing to do is insert the images you need onto the report. Drop an image control onto your table where you want it to apear, and embed the image into the report. Then drop another image control on the report, maybe in the header or somewhere out of the way. Embed the image again and this time set this controlsVisible property to false. Now you have both the images you need in the report.

At this point make a note of the names of both of the images embedded in the report. They tend to be the name of the file you used without the extension.

Now, go into the property’s of the image control in the table, under Data -> Value drop down to Expression to open up the expression editor. Here we are going to use an IIF statement on a filed, and tell it to use one image if the condition is true, or a different one if it was false:

=iif(Fields!Stop_date.Value is nothing, “advert_incomplete_1″, “stop”)

When you save it you wont see the image in the box any more, it should have changed to this

Now, when you run the report, the images should swap round depending on what the value of your filed is, so you will end up with something like

Hopefully, you should now be able to make better use of images in your reports now, making them a bit better to look at and by using visual pointers instead of plain old text.

• How to insert data from one table to another table efficiently?
• How to insert data from one table using where condition to anther table?
• How can I stop using cursor to move data from one table to another table?

There are two different ways to implement inserting data from one table to another table. I strongly suggest to use either of the method over cursor. Performance of following two methods is far superior over cursor. I prefer to use Method 1 always as I works in all the case.

Method 1 : INSERT INTO SELECT
This method is used when table is already created in the database earlier and data is to be inserted into this table from another table. If columns listed in insert clause and select clause are same, they are are not required to list them. I always list them for readability and scalability purpose.

Method 2 : SELECT INTO
This method is used when table is not created earlier and needs to be created when data from one table is to be inserted into newly created table from another table. New table is created with same data types as selected columns.

Both of the above method works with database temporary tables (global, local).

Incorrect T-SQL Script which will give error.
USE AdventureWorks
GO
SELECT TOP 1 SalesOrderDetailID
FROM Sales.SalesOrderDetail
ORDER BY SalesOrderDetailID
UNION ALL
SELECT TOP 1 SalesOrderDetailID
FROM Sales.SalesOrderDetail
ORDER BY SalesOrderDetailID DESC
GO
ResultSet:
Msg 156, Level 15, State 1, Line 4
Incorrect syntax near the keyword ‘UNION’.

As I was in rush, I wrote something very simple with using UNION code, which will give me similar result.

Correct SQL Script which will give correct output.

Correct Script Method 1:
USE AdventureWorks
GO
SELECT *
FROM Sales.SalesOrderDetail
WHERE SalesOrderDetailID IN (
SELECT TOP 1 MIN(SalesOrderDetailID) SalesOrderDetailID
FROM Sales.SalesOrderDetail
UNION ALL
SELECT TOP 1 MAX(SalesOrderDetailID) SalesOrderDetailID
FROM Sales.SalesOrderDetail)
GO


Correct Script Method 2:
USE AdventureWorks
GO
SELECT *
FROM Sales.SalesOrderDetail
WHERE SalesOrderDetailID IN (
SELECT TOP 1 SalesOrderDetailID
FROM Sales.SalesOrderDetail
ORDER BY SalesOrderDetailID)
OR
SalesOrderDetailID IN (
SELECT TOP 1 SalesOrderDetailID
FROM Sales.SalesOrderDetail
ORDER BY SalesOrderDetailID DESC)
GO


Correct Script Method 3:
USE AdventureWorks
GO
SELECT *
FROM (SELECT TOP 1 *
FROM Sales.SalesOrderDetail
ORDER BY SalesOrderDetailID
)X1
UNION ALL
SELECT *
FROM (SELECT TOP 1 *
FROM Sales.SalesOrderDetail
ORDER BY SalesOrderDetailID
DESC)X2
GO

WITH TopBottomRow
AS
(
SELECT TOP 1 *
FROM Sales.SalesOrderDetail
ORDER BY SalesOrderDetailID
UNION ALL
SELECT TOP 1 *
FROM Sales.SalesOrderDetail
ORDER BY SalesOrderDetailID
DESC)
SELECT *
FROM TopBottomRow

Method 1

Method 2

The clause INSERT INTO is repeated multiple times. Many times DBA copy and paste it to save time. There is another alternative to this, which I use frequently. I use UNION ALL and INSERT INTO … SELECT… clauses. Regarding performance there is not much difference. If there is performance difference it does not matter as I use this for one time insert script. I enjoy writing this way, as it keeps me focus on task, instead of copy paste.

Method 3

In SQL Server 2008 we have new feature which will make our life much more easier.

The effective result is same.

Since I was going to all this trouble (which actually turned out to be pretty easy), I decided I should make this thing as configurable as possible. Rather than hard-code it according to my friends specific requirements, I decided to include the following properties: “Text”, “Color”, “Font”, and “Enabled”, so that it would be flexible enough should this friends needs change (and so I could use it in other projects in the future).

To start out with, we need to extend not only the DataGridViewCheckBoxCell class, but the DataGridViewCheckBoxColumn class as well. I called my new classes DataGridViewCheckAndTextColumn and DataGridViewCheckAndTextCell. Here’s how we’ll start:

public class DataGridViewCheckAndTextCell : DataGridViewCheckBoxCell
{
    public DataGridViewCheckAndTextCell()
    {
        this.Enabled = true;
    }

    private bool enabled;
    public bool Enabled
    {
        get
        {
            return enabled;
        }
        set
        {
            enabled = value;
            this.ReadOnly = !enabled;
        }
    }

    private string text;
    public string Text
    {
        get { return text; }
        set { text = value; }
    }

    private System.Drawing.Color color;
    public System.Drawing.Color Color
    {
        get
        {
            return color;
        }
        set { color = value; }
    }

    private System.Drawing.Font font;
    public System.Drawing.Font Font
    {
        get { return font; }
        set { font = value; }
    }
}

Note that the DataGridViewCheckAndTextColumn class contains a constructor which tells it that its cells will be of type DataGridViewCheckAndTextCell. And, the DataGridViewCheckAndTextCell class itself contains the properties I mentioned earlier, in addition to a constructor which sets the Enabled property to True by default.

Next, we’re going to override the DataGridViewCheckBoxCell’s Paint() method. Within our version of the Paint() method, we will first call the base class’s (DataGridViewCheckBoxCell’s) Paint() method, and then do some work of our own. We call the base class’s Paint() method so that it can do whatever other stuff it normally does (we don’t necessarily need to know what that “other stuff” might consist of – isn’t inheritance wonderful?), and then we do what we need to do to make our class work the way we want it to. Here’s the code. Explanations follow:

protected override void Paint(Graphics graphics, Rectangle clipBounds, Rectangle cellBounds,
    int rowIndex, DataGridViewElementStates elementState, object value, object formattedValue,
    string errorText, DataGridViewCellStyle cellStyle, DataGridViewAdvancedBorderStyle advancedBorderStyle,
    DataGridViewPaintParts paintParts)
{
    base.Paint(graphics, clipBounds, cellBounds, rowIndex, elementState, value,
        formattedValue, errorText, cellStyle, advancedBorderStyle, paintParts);

    if (this.Font == null)
        this.Font = cellStyle.Font;

    if (!this.Enabled)
        this.Color = Color.Gray;
    else if (this.Color.IsEmpty)
        this.Color = cellStyle.ForeColor;

    CheckBoxState state;
    bool val = this.Value == null || !Convert.ToBoolean(this.Value) ? false : Convert.ToBoolean(this.Value);
    if (this.enabled && val)
        state = CheckBoxState.CheckedNormal;
    else if (this.enabled && !val)
        state = CheckBoxState.UncheckedNormal;
    else if (!this.enabled && val)
        state = CheckBoxState.CheckedDisabled;
    else
        state = CheckBoxState.UncheckedDisabled;

    Point loc = new Point(cellBounds.X + 2, cellBounds.Y + 2);
    //CheckBoxRenderer.DrawCheckBox(graphics, loc, state);

    Rectangle contentBounds = this.GetContentBounds(rowIndex);
    Point stringLocation = new Point();
    stringLocation.Y = cellBounds.Y + 2;
    stringLocation.X = cellBounds.X + contentBounds.Right + 2;
    graphics.DrawString(this.Text, this.Font, new SolidBrush(this.Color), stringLocation);
}

The first thing you’ll notice (after the call to base.Paint() ) is that we’re checking the values of our properties, and taking appropriate actions. First, we check to see whether the calling code has set a value for this.Font. If that property is null (the property hasn’t been set), we’ll take the default Font (passed in to the Paint() method by the DataGridView control) and use that as our font. Next, we check to see if the Enabled property is set to true or false. If Enabled is false, we’re going to set this.Color to gray, no matter what the Color property says. Otherwise, if the property has not been set, we’ll use the default color passed in to the Paint() method by the DataGridView control. And lastly, if the property was set by the calling code and Enabled is true, we do nothing at this point, and use this.Color as the calling code intended.

Next we set the state of the checkbox. There are four possible values from the CheckBoxState enumerator for our purposes: CheckedNormal, UncheckedNormal, CheckedDisabled, and UncheckedDisabled. We set the state variable based on the underlying value of the data in the cell, combined with the this.Enabled property value.

Now that all of our properties and variables have been set, we’ll put them to work. First, we determine our starting point, based on the cell boundaries. We pass the cellBounds variable passed into the Paint() method to instantiate a Point object (loc), adding 2 pixels top and left to create a little margin. Once we have our starting location, we can use it, along with our state variable and the graphics object passed in to Paint(), to render a checkbox exactly where we want it within the cell (all the way to the left so that there’s room for the text we’re going to add).

Now we’re ready to draw the text. First, we get a Rectangle object, contentBounds, based on the rowIndex which is also passed in to the Paint() method. ( I told you this was easy!) Next, we instaniate a Point object (stringLocation). Its X coordinate will be 2 pixels to the right of the checkbox, and its Y coordinate will be 2 pixels down from the top of the cell. Then we draw a string beginning at that location. We do that by calling the DrawString() method on the graphics object. The method takes four parameters; the string to draw (for which we use the value in this.Text which gets set by the calling code), the font (this.Font), the color (this.Color), and of course, the location (stringLocation).

Believe it or not, that’s all there is to it. You can use your new masterpiece just like you would use any other type of DataGridView column. It’ll even show up in the designer for you:

And the calling code will look something like this:

private void grid1_DataBindingComplete(object sender, DataGridViewBindingCompleteEventArgs e)
{
    DataGridViewCheckAndTextCell ctCell = null;
    foreach (DataGridViewRow row in grid1.Rows)
    {
        if (row != null)
        {
            ctCell = row.Cells["CheckAndText"] as DataGridViewCheckAndTextCell;
            if (ctCell != null)
            {
                ctCell.Enabled = true;
                ctCell.Text = “Hello!”;
                ctCell.Color = Color.Blue;
            }
        }
    }
}

Here’s a screenshot of the final product:

Enjoy ..!

Basically, all we need to do is handle the DataGridView’s Paint() event. Let’s say we want to span columns 3, 4, 5, and 6 with one header that says “My Big Header”. Within the Paint() event handler, we’ll get a handle to the header cell of the first column you wish to span (“Column 3”), and we’ll use that to determine the coordinates of the location on the grid at which we will begin our header text:

DataGridViewCell hc = grid1.Columns[“Column 3”].HeaderCell;
Rectangle hcRct = grid1.GetCellDisplayRectangle(hc.ColumnIndex, -1, true);

The first line of code should be self-explanatory. In the second line, we’re getting a Rectangle object based on the cell in question. Passing the column index and the row index (“-1” means the row header) to the DataGridView’s GetCellDisplayRectangle() method gets us there.

Next, we’ll use that Rectangle object to get another Rectangle that represents the entire area to be covered by our new Multi-Column-Header. We can do that like so:

int multiHeaderWidth = grid1.Columns[hc.ColumnIndex].Width + grid1.Columns[hc.ColumnIndex + 1].Width + grid1.Columns[hc.ColumnIndex + 2].Width + grid1.Columns[hc.ColumnIndex + 3].Width;

Rectangle headRct = new Rectangle(hcRct.Left, hc.ContentBounds.Y + 2, multiHeaderWidth, grid1.ColumnHeadersHeight);

headRct.Height -= 3;

As you can see, the first line above simply gets the total width of all four columns to be spanned. We then pass that variable along with the other three coordinates (left, top, and height) required to instantiate a Rectangle object. (We add 2 to the Y coordinate and subtract 3 from the Rectangle’s height in the next line to create a margin, so that our header cell’s top and bottom borders are still visible.)

Next we need to find the size our string will be based on its length and the font we’ll be using:

SizeF sz = e.Graphics.MeasureString(“My Big Header”, grid1.Font);

Then we figure out where the top will need to be in order to make it vertically centered:

int headerTop = Convert.ToInt32((headRct.Height / 2) – (sz.Height / 2)) + 2;

Then we set the background color to match the grid’s header color:

e.Graphics.FillRectangle(new SolidBrush(SystemColors.Control), headRct);

And finally, we draw the text, starting 2 pixels to the right of the left-most point of our rectangle so it looks nice:

e.Graphics.DrawString(“My Big Header”, grid1.ColumnHeadersDefaultCellStyle.Font, Brushes.Black, hcRct.Left + 2, headerTop);

Putting it all together, here’s our Paint() event handler:

private void grid1_Paint(object sender, PaintEventArgs e)
{
    DataGridViewCell hc = grid1.Columns["Column3"].HeaderCell;
    Rectangle hcRct = grid1.GetCellDisplayRectangle(hc.ColumnIndex, -1, true);

    int multiHeaderWidth = grid1.Columns[hc.ColumnIndex].Width + grid1.Columns[hc.ColumnIndex + 1].Width + grid1.Columns[hc.ColumnIndex + 2].Width + grid1.Columns[hc.ColumnIndex + 3].Width;
    Rectangle headRct = new Rectangle(hcRct.Left, hc.ContentBounds.Y + 2, multiHeaderWidth, grid1.ColumnHeadersHeight);
    headRct.Height -= 3;

    SizeF sz = e.Graphics.MeasureString(“My Big Header”, grid1.Font);
    int headerTop = Convert.ToInt32((headRct.Height / 2) – (sz.Height / 2)) + 2;
    e.Graphics.FillRectangle(new SolidBrush(SystemColors.Control), headRct);
    e.Graphics.DrawString(“My Big Header”, grid1.ColumnHeadersDefaultCellStyle.Font, Brushes.Black, hcRct.Left + 2, headerTop);
}

And here’s a screenshot:

 Hope this helped. Enjoy!

Multi-tier applications exist for a variety of reasons.  This article won’t go into too much depth on when and why to use multi-tier architecture, however a quick overview is in order:

What Is Multi-Tier Architecture, And Why Do We Care?

Multi-tier (or n-tier) architecture refers to the practice of separating an application into layers.  Doing so makes it easier for you and other developers to re-use your code.  Typically, a multi-tier application will be broken into three layers:

• Data Access Layer (DAL):  This layer contains all the code that interacts with the data store used by the application.  For example, if your data store is a typical RDBMS like Sql Server or Oracle, the data access layer will contain the code that calls the stored procedures in your database to perform reads and writes (or if you don’t use stored procedures, the data access layer may contain your SQL code).
• Business Logic Layer (BLL):  This layer contains all the code that implements your application’s business rules.  It makes calls to the DAL, usually on behalf of the Presentation Layer (see below).  The BLL typically contains code that operates on the data received from the DAL prior to passing it back to the Presentation Layer for display to the user.  For example, the BLL may perform calculations based on data retrieved from the DAL to be displayed along with the actual data.
• Presentation Layer:  This layer typically reads and writes to the BLL.  The Presentation Layer is responsible for taking the data it receives from the BLL, formatting it, and displaying it to the user.  It is also responsible for collecting user-entered data and conveying it to the BLL for further processing.  In the .NET world, the Presentation Layer is typically created with either ASP.NET Web Forms, Windows Forms, or more recently WPF (Windows Presentation Foundation).

Dividing an application’s code in this manner allows us to take advantage of distributed deployment. For example, you could deploy your Data Access Layer to a data server, your Business Logic Layer to an application server, and your Presentation Layer to a web server (assuming it was a web-based GUI). Later, should you decide to create a Windows GUI client that consumes the same Business Logic Layer component, you could deploy that client to your users’ desktops and reference the Business component on the application server.  In addition, a distributed, multi-tiered application is much more likely to scale for future growth.

How We’ll Go About It

We will be creating three Visual Studio projects, all within the same solution for simplicity’s sake.  The application we create will read and write to database tables which contain information on car manufacturer’s, makes, and models.  Figure 1 shows the structure and relationships of the three tables involved.  You should create these tables for yourself, and when doing so, don’t forget to specify Primary Keys for each table as indicated in the diagram:

I’ve pre-populated each table as shown in Figure 2, Figure 3, and Figure 4:

Figure 2: Manufacturer table

Figure 3: Make table

Figure 4: Model table

You will need to set these tables up in your database in order to play along with us during the creation of the application.  The data doesn’t have to match exactly, but the structures of each table does.  Also, when entering data, keep in mind the relationships between the tables as shown in Figure 1 above.

As mentioned earlier, our goal is to create a multi-tier application consisting of a Data Access Layer, a Business Logic Layer, and a Presentation Layer.  There will be absolutely no direct communication between the Presentation Layer and the Data Access Layer.  Furthermore, the Data Access Layer will be totally unaware of the Business Logic Layer, and the Business Logic Layer will be totally unaware of the Presentation Layer.  In this way (as it should always be in multi-tier architecture), each of the layers should be able to support any .NET client. For example, although our Presentation Layer will be web-based, once this application is finished, you will be able to create a new Presentation Layer in Windows Forms (or WPF, for that matter) that can consume the Business Logic Layer we will be building (which in turn will consume the Data Access Layer). 

When we are finished building our application, it will allow us to perform maintenance on the three tables above.  It will also contain a reporting function which will enable a user to display a list of all models in the system, including the Manufacturer Name, Make Name, Model Name, and Model Year.

Let’s Do It

OK, so start off by creating a new solution in Visual Studio, and call it “Cars”.  (As I mentioned at the top of the article, I’m assuming you know your way around Visual Studio, so I’m not going to take you through creating solutions and projects within Visual Studio.  If you don’t know how to do that already, please take advantage of the documentation and videos on Microsoft’s web site to familiarize yourself with these procedures.)

Developing the Data Access Layer

Within the Cars solution, create a new Class Library project and call it “CarsDAL”.  This project is where we will develop our Data Access Layer.  Once the project is created, delete the Class1.cs file that gets created by default as we won’t be needing it.  (I told you there wasn’t going to be much coding at the beginning, see?)  Then, create a new folder named App_Code in the project.

Right click on the App_Code folder, add a new DataSet, and name it “CarsDataSet”. Once the DataSet is added, a Table Adapter Design Window will open.  Right click anywhere within the TableAdapter Design Window, the click on Add, then TableAdapter from the popup menu.  This will launch the TableAdapter Configuration Wizard.  We will now create our first TableAdapter, the Manufacturer TableAdapter, by taking the following steps:

• On the first page of the TableAdapter Configuration Wizard, choose your data connection, which should point to the “Cars” database schema you created in preparation earlier, then click Next.
• The next page asks you to choose a Command Type.  For the purposes of this article we will choose the option that says, “Create New Stored Procedures”.  Then click Next. 
• On the next screen, click the Query Builder button, which will load the Query Builder window.  The Add Table dialog box is displayed.  Select Manufacturer, then click the Add button, and then close the Add Table dialog box.  In the Manufacturer table now displayed in the top frame of the Query Builder window, check each of the fields.  Leave the “*(All Columns)” checkbox unchecked.  Then click OK in the Query Builder window, and click Next to advance the TableAdapter Configuration Wizard.
• In the next screen you are asked to name the four stored procedures that will be created for you for the Manufacturer TableAdapter.  (That’s right, you don’t need to create them yourself, Visual Studio does it for you.)  Change the default names so that the four stored procedures are named Manufacturer_s, Manufacturer_i, Manufacturer_u, and Manufacturer_d, for Select, Insert, Update, and Delete respectively.  Click Next.
• The next screen is the Choose Methods screen.  We’re going to uncheck the “Fill A DataTable” checkbox, and leave “Return A DataTable” and “GenerateDBDirectMethods” checkboxes checked.  Also, in the text field under the “Return A DataTable” checkbox, change the method name to GetManufacturerData.  Click Next.
• The Wizard Results screen will list all of the procedures and methods that were generated for you.  Look these over, then click Finish.
• When the TableAdapter Configuration Wizard closes, you should see the Manufacturer TableAdapter represented in the TableAdapter Design Window.  It should contain two sections; the Manufacturer section which lists the fields, and the ManufacturerTableAdapter section which lists the queries available in the TableAdapter.  If you recall, we only created one query for this TableAdapter, called GetManufacturerData(), which returns all of the rows in the Manufacturer table.  It’s a good idea to create one more query which we will call GetManufacturerDataById(), so that we can load a particular Manufacturer record if necessary.  This query is going to accept the MfrId as a parameter.  We’ll create it as follows:
• Right click on the bottom half of the Manufacturer TableAdapter, anywhere in the ManufacturerTableAdapter section.  Choose Add Query from the popup menu, and you will be presented with the TableAdapter Query ConfigurationWizard.  Choose “Create New Stored Procedure”, then click Next.
• On the Query Type screen choose the first option, “SELECT which returns rows”, then click Next.
• In the Generate Stored Procedure screen, you can use the Query Builder, or you can manually type in your query.  It should end up looking like this:SELECT MfrId, MfrName, Created_Date FROM Manufacturer WHERE (MfrId = @MfrId)
• Then click Next.  On the Create Stored Procedure screen, name the stored procedure “Manufacturer_By_Id_s”, then click Next.
• On the Choose Methods screen, uncheck the “Fill A DataTable” checkbox and leave the “Return A DataTable” checkbox checked.  Change the name of the method to “GetManufacturerDataById”, then click Next.
• The Wizard Results screen will list all of the procedures and methods that were generated for you.  Look these over, then click Finish.
• You should now see the Manufacturer TableAdapter represented in the TableAdapter Design Window with the new method included.

Now, repeat each of those steps for the Make table, and then again for the Model table.  Be sure to create “ById” queries and methods for each table, passing the appropriate field (MakeId and ModelId) and naming each query correctly depending on the table you’re dealing with. When you’re done, there is just one more step and we’ll be done with the Data Access Layer.

OK, now we need to create just one more TableAdapter in the DAL.  As before, right click on any empty area within the TableAdapter Design Window, and click Add, and then TableAdapter in the popup menu.  This will load the TableAdapter Configuration Wizard one more time:

• Choose your Cars connection string, then click Next.
• Choose Create New Stored Procedures, then click Next.
• In the Query Builder window, either click the Query Builder button or manually type your SQL query.  Either way, it should look pretty much like this when you’re done:SELECT Manufacturer.MfrName, Make.MakeName, Model.ModelName, Model.ModelYear FROM Model INNER JOIN Make ON Model.MakeId = Make.MakeId INNER JOIN Manufacturer ON Make.MfrId = Manufacturer.MfrId
• Then click Next.  In the Create Stored Procedures screen, change the name of the Select query to “ModelReport_s”.  The rest of the queries won’t matter since you can’t insert, update, or delete when joining tables as we did with this query.  Visual Studio is smart enough to recognize this and doesn’t actually create these queries regardless of what you name them.  (Why it wasn’t smart enough to just disable them is beyond me.)  Anyway, click Next when that’s done.
• Again you will see the Choose Methods screen.  As before, uncheck the “Fill A DataTable” checkbox and leave the “Return A DataTable” checkbox checked.  Change the method name to “GetModelReportData”.  Click Next.
• The Wizard Results screen will list all of the procedures and methods that were generated for you.  Look these over, then click Finish.

The Data Access Layer is now complete.  Next, we’ll take a look at the Business Logic Layer.

Business Logic Layer

Create a new Class Library project in the Cars solution, and call it CarsBLL.  Next, add a reference to the CarsDLL project.  Then rename the Class1.cs file created by default to CarsBLL.cs, add the [System.ComponentModel.DataObject] attribute to the CarsBLL class, and add four fields, one for each adapter created in the DAL. The CarsBLL should look like this at this point:

 using CarsDAL.App_Code.CarsDataSetTableAdapters;
using CarsDAL.App_Code;

namespace CarsBLL
{
    [System.ComponentModel.DataObject]
    public class CarsBLL
    {
        private ManufacturerTableAdapter _manufacturerAdapter = null;
        private MakeTableAdapter _makeAdapter = null;
        private ModelTableAdapter _modelAdapter = null;
        private ModelReport_sTableAdapter _carsReportAdapter = null;
    }
}

The [System.ComponentModel.DataObject] attribute, along with the others we will be adding to the methods we create next in this class, will make the BLL and its methods visible to the controls we will be using later in the Presentation Layer.

Next, we’ll add a property for each adapter, methods to Add, Update, Delete, and Get data for the Manufacturer, Make, and Model tables, and a Get method for the Report adapter.  Note that each of these methods will make calls into the DAL, which as we saw earlier, makes calls to the database.  Once these properties and methods are created, your CarsBLL class should look something like this:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CarsDAL.App_Code.CarsDataSetTableAdapters;
using CarsDAL.App_Code;

namespace CarsBLL
{
    [System.ComponentModel.DataObject]
    public class CarsBLL
    {
        private ManufacturerTableAdapter _manufacturerAdapter = null;
        private MakeTableAdapter _makeAdapter = null;
        private ModelTableAdapter _modelAdapter = null;
        private ModelReport_sTableAdapter _carsReportAdapter = null;

        protected ManufacturerTableAdapter ManufacturerAdapter
        {
            get
            {
                if (_manufacturerAdapter == null)
                {
                    _manufacturerAdapter = new ManufacturerTableAdapter();
                }
                return _manufacturerAdapter;
            }
        }

        [System.ComponentModel.DataObjectMethodAttribute
        (System.ComponentModel.DataObjectMethodType.Select, true)]
        public DataTable GetManufacturerData()  // Returns data for manufacturer table
        {
            return ManufacturerAdapter.GetManufacturerData();
        }

        [System.ComponentModel.DataObjectMethodAttribute
            (System.ComponentModel.DataObjectMethodType.Insert, true)]
        public bool AddManufacturer(string MfrName)
        {
            // Create a new ManufacturerRow instance
            CarsDataSet.ManufacturerDataTable mfrs = new CarsDataSet.ManufacturerDataTable();
            CarsDataSet.ManufacturerRow mfr = mfrs.NewManufacturerRow();

            mfr.MfrName = MfrName;

            // Add the new mfr
            mfrs.AddManufacturerRow(mfr);
            int rowsAffected = ManufacturerAdapter.Update(mfrs);

            // Return true if precisely one row was inserted,
            // otherwise false
            return rowsAffected == 1;
        }

        [System.ComponentModel.DataObjectMethodAttribute
            (System.ComponentModel.DataObjectMethodType.Update, true)]
        public bool UpdateManufacturer(string MfrName, int MfrId)
        {
            CarsDataSet.ManufacturerDataTable mfrs = ManufacturerAdapter.GetManufacturerDataById(MfrId);
            if (mfrs.Count == 0)
            {
                // no matching record found, return false
                return false;
            }

            CarsDataSet.ManufacturerRow mfr = mfrs[0];

            mfr.MfrName = MfrName;

            // Update the mfr record
            int rowsAffected = ManufacturerAdapter.Update(mfr);

            // Return true if precisely one row was updated,
            // otherwise false
            return rowsAffected == 1;
        }

        [System.ComponentModel.DataObjectMethodAttribute
        (System.ComponentModel.DataObjectMethodType.Delete, true)]
        public bool DeleteManufacturer(int MfrId)
        {
            int rowsAffected = ManufacturerAdapter.Delete(MfrId);

            // Return true if precisely one row was deleted,
            // otherwise false
            return rowsAffected == 1;
        }

        protected MakeTableAdapter MakeAdapter
        {
            get
            {
                if (_makeAdapter == null)
                {
                    _makeAdapter = new MakeTableAdapter();
                }
                return _makeAdapter;
            }
        }

        [System.ComponentModel.DataObjectMethodAttribute
        (System.ComponentModel.DataObjectMethodType.Select, true)]
        public DataTable GetMakeData()  // Returns data for make table
        {
            return MakeAdapter.GetMakeData();
        }
        [System.ComponentModel.DataObjectMethodAttribute
            (System.ComponentModel.DataObjectMethodType.Insert, true)]
        public bool AddMake(string MakeName, int MfrId)
        {
            // Create a new MakeRow instance
            CarsDataSet.MakeDataTable makes = new CarsDataSet.MakeDataTable();
            CarsDataSet.MakeRow make = makes.NewMakeRow();

            make.MakeName = MakeName;
            make.MfrId = MfrId;
            // Add the new mfr
            makes.AddMakeRow(make);
            int rowsAffected = MakeAdapter.Update(makes);

            // Return true if precisely one row was inserted,
            // otherwise false
            return rowsAffected == 1;
        }

        [System.ComponentModel.DataObjectMethodAttribute
            (System.ComponentModel.DataObjectMethodType.Update, true)]
        public bool UpdateMake(string MakeName, int MfrId, int MakeId)
        {
            CarsDataSet.MakeDataTable makes = MakeAdapter.GetMakeDataById(MakeId);
            if (makes.Count == 0)
            {
                // no matching record found, return false
                return false;
            }

            CarsDataSet.MakeRow make = makes[0];

            make.MakeName = MakeName;
            make.MfrId = MfrId;

            // Update the make record
            int rowsAffected = MakeAdapter.Update(make);

            // Return true if precisely one row was updated,
            // otherwise false
            return rowsAffected == 1;
        }

        [System.ComponentModel.DataObjectMethodAttribute
        (System.ComponentModel.DataObjectMethodType.Delete, true)]
        public bool DeleteMake(int MakeId)
        {
            int rowsAffected = MakeAdapter.Delete(MakeId);

            // Return true if precisely one row was deleted,
            // otherwise false
            return rowsAffected == 1;
        }

        protected ModelTableAdapter ModelAdapter
        {
            get
            {
                if (_modelAdapter == null)
                {
                    _modelAdapter = new ModelTableAdapter();
                }
                return _modelAdapter;
            }
        }

        [System.ComponentModel.DataObjectMethodAttribute
        (System.ComponentModel.DataObjectMethodType.Select, true)]
        public DataTable GetModelData()  // Returns data for model table
        {
            return ModelAdapter.GetModelData();
        }

        [System.ComponentModel.DataObjectMethodAttribute
            (System.ComponentModel.DataObjectMethodType.Insert, true)]
        public bool AddModel(string ModelName, int ModelYear, int MakeId)
        {
            // Create a new ModelRow instance
            CarsDataSet.ModelDataTable models = new CarsDataSet.ModelDataTable();
            CarsDataSet.ModelRow model = models.NewModelRow();

            model.MakeId = MakeId;
            model.ModelName = ModelName;
            model.ModelYear = ModelYear;
            // Add the new model
            models.AddModelRow(model);
            int rowsAffected = ModelAdapter.Update(models);

            // Return true if precisely one row was inserted,
            // otherwise false
            return rowsAffected == 1;
        }

        [System.ComponentModel.DataObjectMethodAttribute
            (System.ComponentModel.DataObjectMethodType.Update, true)]
        public bool UpdateModel(string ModelName, int ModelYear, int MakeId, int ModelId)
        {
            CarsDataSet.ModelDataTable models = ModelAdapter.GetModelDataById(ModelId);
            if (models.Count == 0)
            {
                // no matching record found, return false
                return false;
            }

            CarsDataSet.ModelRow model = models[0];

            model.MakeId = MakeId;
            model.ModelName = ModelName;
            model.ModelYear = ModelYear;

            // Update the model record
            int rowsAffected = ModelAdapter.Update(model);

            // Return true if precisely one row was updated,
            // otherwise false
            return rowsAffected == 1;
        }

        [System.ComponentModel.DataObjectMethodAttribute
        (System.ComponentModel.DataObjectMethodType.Delete, true)]
        public bool DeleteModel(int ModelId)
        {
            int rowsAffected = ModelAdapter.Delete(ModelId);

            // Return true if precisely one row was deleted,
            // otherwise false
            return rowsAffected == 1;
        }

        protected ModelReport_sTableAdapter CarsReportAdapter
        {
            get
            {
                if (_carsReportAdapter == null)
                {
                    _carsReportAdapter = new ModelReport_sTableAdapter();
                }
                return _carsReportAdapter;
            }
        }

        [System.ComponentModel.DataObjectMethodAttribute
        (System.ComponentModel.DataObjectMethodType.Select, true)]
        public DataTable GetAllModels()  // Returns joined data for reports
        {
            return CarsReportAdapter.GetCarData();
        }

    }
}

Note the attributes added to each method: [System.ComponentModel.DataObjectMethodAttribute (System.ComponentModel.DataObjectMethodType.Select, true)]. Again, this ensures that they are visible to the ObjectDataSource control which will be used in the Presentation Layer.

Now, you may have noticed that the BLL Delete methods all accept one parameter, which represents the primary key for the corresponding table.  We’re going to have to go back to the DAL and adjust the Delete methods there and in the Delete stored procedures that were generated by Visual Studio.  For some reason, Visual Studio’s TableAdapter Configuration Wizard generates these methods and procedures so that it’s necessary to pass a variable for every field into them.  That’s just ridiculous.  Visual Studio should be able to recognize when a table has a primary key, and it should generate the Delete methods and procedures accordingly.  Well, it doesn’t, so we’re going to do that.  (We could leave it the way it is and adjust our BLL to deal with this stupidity, but I have a low tolerance for stupidity.  Besides, it’s almost as easy to do it correctly, and certainly worth the extra effort.)

So, let’s go back to our CarsDAL project and take a look at the CarsDataSet.Designer.cs file that was generated by the TableAdapter Configuration Wizard.  Within that file there should be three different methods called InitAdapter(), one for each table in our schema.  Within each of these methods you can see how each command object is created.  You want to look for where the parameters are being added to the command object.  Look for code that looks something like this:

 this._adapter.DeleteCommand.Parameters.Add(new
 global::System.Data.SqlClient.SqlParameter(“@RETURN_VALUE”,
 global::System.Data.SqlDbType.Variant, 0,
 global::System.Data.ParameterDirection.ReturnValue, 0, 0, null,
 global::System.Data.DataRowVersion.Current, false, null, “”, “”, “”));
 
 this._adapter.DeleteCommand.Parameters.Add(new
 global::System.Data.SqlClient.SqlParameter(“@Original_MfrId”,
 global::System.Data.SqlDbType.Int, 0,
 global::System.Data.ParameterDirection.Input, 0, 0, “MfrId”,
 global::System.Data.DataRowVersion.Original, false, null, “”, “”, “”));
 
 this._adapter.DeleteCommand.Parameters.Add(new
 global::System.Data.SqlClient.SqlParameter(“@Original_MfrName”,
 global::System.Data.SqlDbType.NVarChar, 0,
 global::System.Data.ParameterDirection.Input, 0, 0, “MfrName”,
 global::System.Data.DataRowVersion.Original, false, null, “”, “”, “”));
 
 this._adapter.DeleteCommand.Parameters.Add(new
 global::System.Data.SqlClient.SqlParameter(“@Original_Created_Date”,
 global::System.Data.SqlDbType.DateTime, 0,
 global::System.Data.ParameterDirection.Input, 0, 0, “Created_Date”,
 global::System.Data.DataRowVersion.Original, false, null, “”, “”, “”));

The above code adds four parameters to the DeleteCommand object of the Manufacturer TableAdapter.  We only need the first two; the first parameter represents the return value of the stored procedure, and the second one represents the primary key value of the record to be deleted.  That’s all we really need, so delete the third and fourth parameters.  Once you’ve done that, repeat the process for both the Make TableAdapter and the Model TableAdapter.

Now we need to adjust the three stored procedures that perform the Deletes in the respective tables.  You will need to adjust the parameter list within each stored proc so that it only expects the first “input” parameter as mentioned above.  In addition, you will need to adjust the WHERE clause in each of these stored procs as well, so that they only include the primary key field.  Here’s what the Manufacturer_d stored procedure should look like when you’re done:

CREATE PROCEDURE dbo.Manufacturer_d
        (
            @Original_MfrId int
        ) AS SET NOCOUNT OFF;
        DELETE FROM [Manufacturer]
        WHERE (([MfrId] = @Original_MfrId))

You will need to do this for both the Make_d and Model_d stored procedures as well.

We have now completed both the Data Access Layer and the Business Logic Layer.

Presentation Layer

The Presentation Layer is the final piece to our puzzle.  Keep in mind that although I’ll be using ASP.NET in order to create a web GUI for the purposes of this article, you could just as easily create a Windows Forms or a WPF-based presentation layer for your app, and utilize the exact same Business Logic Layer and Data Access Layer components we created previously.  After all, that is the point of multi-tier architecture.

Within our Cars solution, create a new ASP.NET Web Application project, and name it CarsWeb.  VS will create a Default.aspx page within the project which we will look at soon.  You can leave it alone for now.

Before we start coding, we want to add a reference to the CarsBLL project.  Just right-click on the CarsWeb project, choose Add Reference from the menu, then choose the CarsBLL project from the Project tab. After that’s done, rebuild the solution.  This will ensure that CarsBLL is visible from within CarsWeb.

Our presentation layer is going to consist of a menu of options which will be contained in Default.aspx.  It will also contain a Maintenance page for each of our tables where a user can view, edit, or delete records.  In addition, there will be a Reports page which will list each model, along with the names of its Manufacturer and Make.  VS already created our Default.aspx page, so just add four new pages, naming them mfrmaint.aspx, makemaint.aspx, modelmaint.aspx, and report.aspx.  You should have five aspx files in total, including Default.aspx.  (Our GUI is not going to be pretty or fancy, but it will be functional.  You can add pretty and fancy at your leisure.)

We’ll start by adding an ObjectDataSource to the Manufacturer maintenance page:

• Open up the mfrmaint.aspx page in design mode.
• Add an ObjectDataSource control to the page by dragging it in from the Data section of the VS toolbox. It will be named ObjectDataSource1 by default.
• Right-click on the ObjectDataSource control and choose Configure Data Source from the context menu.
• In the configuration window, choose CarsBLL.CarsBLL from the business objects list, then click Next.
• The next screen contains four tabs; SELECT, UPDATE, INSERT, and DELETE. In each of these tabs, ensure that the appropriate method is selected. The chosen methods should be GetManufacturerData(), UpdateManufacturer(), AddManufacturer(), and DeleteManufacturer() respectively.
• Click Finish
• Switch to Source view, and change the OldValuesParameterFormatString attribute from “original_{0}” to just “{0}” (due to a bug in the ObjectDataSource control)

And now, a GridView control:

• Open up the mfrmaint.aspx page in design mode again
• Add a GridView control to the page by dragging it in from the Data section of the Toolbox
• In the Properties window of the GridView control, assign ObjectDataSource1 to the DataSourceID property
• In the GridView Tasks sheet, check the following options:  Enable Paging, Enable Sorting, Enable Editing, and Enable Deleting
• Set the ReadOnly property to True for the MfrId and Created_Date fields
• Set the DataKeyNames attribute of the GridView control to “MfrId”, so that the control knows which is the Primary Key field

Now, repeat the above steps in both makemaint.aspx and modelmaint.aspx for Make Maintenance and Model Maintenance.  When that’s all done, meet me at the next paragraph.

Ok, now that the table maintenance pages are done, we’ll do the Report page.  The report will consist simply of a call to the GetAllModels() method of our BLL.  It’s just like the table maintenance pages we just completed, only easier.  Open up report.aspx in Design mode and add an ObjectDataSource just like we did on the table maintenance pages.  Right-click on it and choose Configure Data Source from the menu.  In the configuration window, choose CarsBLL.CarsBLL from the business objects list, then click Next.  On the next screen we’ll only be concerned with the SELECT tab this time.  In the SELECT tab, choose the GetAllModels() method and click Finish.  Next, add a GridView control, and assign ObjectDataSource1 as its DataSourceID property.  Then go to the GridView control’s GridView Tasks sheet, check Enable Paging and Enable Sorting.

Lastly, open up Default.aspx and create a simple menu with links to each of the other four pages.  Something like this:

<a href=”report.aspx”>Run Report</a><br /><br />
<a href=”mfrmaint.aspx”>Manufacturer Maintenance</a><br />
<a href=”makemaint.aspx”>Make Maintenance</a><br />
<a href=”modelmaint.aspx”>Model Maintenance</a><br />

And that’s it!  Build your solution, and you should have pages that look as follows:

Default.aspx

mfrmaint.aspx

makemaint.aspx

modelmaint.aspx

report.aspx

You can see that I wasn’t lying when I said the GUI wouldn’t be pretty, but hopefully I’ve shed some light on the subject of building a multi-tier application in C#.