Developers House

Test Driven Development Tutorial in C# 4.0

2010-05-26T01:27:00.001-07:00

Introduction - Defining the Battlefield
This tutorial is an short introduction to using Test Driven Development (TDD) in Visual Studio 2010 (VS2010) with C#. Like most of my examples it's based on a game.
By completing this tutorial you will:

Get a taste of TDD through a series of small iterations;
Learn how VS2010 provides TDD support through a number of new features; and
Learn a number of C# 4.0 features.

CannonAttack is a simple text based game in which a player enters an angle and velocity of a cannonball to hit a target at a given distance. The game uses a basic formula for calculating the trajectory of the cannonball and the player keeps taking turns at shooting at the target until it has been hit. I won't go into TDD theory in any great detail now, but you should check out the number of great references to TDD including:
http://en.wikipedia.org/wiki/Test_driven_development
http://www.codeproject.com/KB/dotnet/tdd_in_dotnet.aspx
C# .NET 2.0 Test Driven Development by Matthew Cochran
http://msdn.microsoft.com/en-us/library/dd998313(VS.100).aspx
The following are the fundamental steps of a TDD iteration:

RED - take a piece of functionality and build a test for it and make it fail the test by writing a minimum amount of code(basically just get it to compile and run the test);
GREEN - write minimal code for the test to make it succeed; and
REFACTOR - clean up and reorganize the code and ensure it passes the test and any previous tests.

In this tutorial we will be progressing through a number of iterations of the TDD cycle to produce a fully functional simple application. Each iteration will pick up one or more of the requirements/specs from our list (see The CannonAttack Requirements/Specs below). We won't test for absolutely everything and some of the tests are fairly basic and simplistic, but I am just trying to keep things reasonably simple at this stage
VS2010 and C# 4.0:
This tutorial covers the use of VS2010 and targets a number of features of C# 4.0,

Generating stubbs for TDD in VS2010;
Test Impact View in VS2010;
Tuples; and
String.IsNullOrWhiteSpace method.

There are many more features of C#4.0 and we will be covering them in future tutorials.
What you need:

This is a C# tutorial so a background in C# would be very useful; and
VS 2010 professional or above (This tutorial has been tested against VS2010 rtm and beta2).

The CannonAttack Requirements/Specs:
The following is a combination of Requirements and Specifications that will give us some guide in terms of the application we are trying to build:

Windows Console Application;
Player identified by an id, default is set to a constant "Human";
Single player only, no multi-play yet;
Allow player to set Angle and Speed of the Cannon Ball to Shoot at a Target;
Target Distance is simply the distance of the Cannon to Target, and is created randomly by default but can be overridden;
Angle and Speed needs to be validated (specifically not greater than 90 degrees and Speed not greater than speed of light);
Max distance for target is 20000 meters;
Base the algorithm for the calculation of the cannons trajectory upon the following C# code (distance and height is meters and velocity is meters per second):
distance = velocity * Math.Cos(angleInRadians) * time;
height = (velocity * Math.Sin(angleInRadians) * time) - (GRAVITY * Math.Pow(time, 2)) / 2;
A hit occurs if the cannon is within 50m of the target;
Display number of shots for a hit
Game text will be similar to following:

Welcome to Cannon Attack
Target Distance:12621m
Please Enter Angle:40
Please Enter Speed:350
Missed cannonball landed at 12333m
Please Enter Angle:45
Please Enter Speed:350
Hit - 2 Shots
Would you like to play again (Y/N)
Y
Target Distance:2078m
Please Enter Angle:45
Please Enter Speed:100
Missed cannonball landed at 1060m
Please Enter Angle:45
Please Enter Speed:170
Missed cannonball landed at 3005m
Please Enter Angle:45
Please Enter Speed:140
Hit - 3 shots
Would you like to play again (Y/N)
N
Thanks for playing CannonAttack

OK so now we are ready to code, let's go...
Iteration 1 - Creating the Cannon
Steps

Start Visual Studio
Click New Project...
From the Windows submenu select Console Application as below
Call the application CannonAttack and click OK
Right click on Program.cs and select Rename and call the file CannonAttack.cs.
If you see the following select YES.
When the solution has loaded right click on the solution in Solution Explorer and select ADD->NEW PROJECT. If you can't see the Solution Explorer select from Tools->Options->Projects and Solutions and tick always show solution
Select Test Project and call it CannonAttackTest as below:
Click OK
Right click on the CannonAttackTest project and make it the startup project by selecting Set as Startup Project.
Rename the UnitTest1.cs to CannonAttackTest.cs
If you see the following select YES
You should see the Solution explorer appear as:
Open the code window for the CannonAttackTest.cs file and you should see the default test method. The [TestMethod] attribute above a method in this file indicates VS2010 will add this method as a unit test.
Replace the default test method:
[TestMethod]
public void TestMethod1()
{
}
with the following:
[TestMethod]
public void TestCannonIDValid()
{
Cannon cannon = new Cannon();
}
This won't compile but right click on Cannon and select Generate->New Type
When the following screen appears change the Project to CannonAttack and accept the other defaults as below:
Now change the TestCannonIDValid method to:
[TestMethod]
public void TestCannonIDValid()
{
Cannon cannon = new Cannon();
Assert.IsNotNull(cannon.ID);
}
Now the solution won't compile as the ID property does not exist
Right click on the ID and select Generate->Property (ID has now been added to the Cannon class). This creates an auto property which for the moment will hopefully compile.
Save all projects and hit CTRL-F5. This will start the Tests running (not F5 in debug mode because debug mode will by default stop if an Assert fails).
You should see in the tests window:
The test failed. This is correct and as expected the first phase of the TDD iteration has occurred RED - failed!!!
So now that we have a red lets get this test to pass.
Select cannon.cs in the CannonAttack project and make the following change to the ID property:
public string ID
{
get
{
return "Human";
}
}
Now run the test CTRL-F5 and we should see:
We have just completed the second stage of a TDD cycle GREEN - Pass!!!!
So the next stage is to refractor, and it would be nice to make a couple of changes to the class to clean it up, so that the class now looks like:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CannonAttack
{
public sealed class Cannon
    {
private readonly string CANNONID = "Human";
private string CannonID;
public string ID
        {
get
            {
return (String.IsNullOrWhiteSpace(CannonID)) ? CANNONID : CannonID;
            }
set
            {
                CannonID = value;
            }
        }
    }
}

We have made this class sealed so that it is not inherited by anything. Also, we have added a readonly string to store a default ID if not set by the user. I am going to use runtime constants (readonly) because they are more flexible than compile time constants (const) and if you are interested check out Bill Wagner's book (effective C# - 50 Ways to Improve your C#) for further details.
Let's run the test again. Again it should compile and pass tests because although we have made some changes to the code, we should not have impacted the tests and this is an important part of the Refactor phase. We should make the changes we need to make the code more efficient and reusable, but it is critical that the same test that we made pass in the Green phase still passes in the Refactor phase.
The refactoring is complete. Now for ITERATION 2 of the CannonAttack project.
Iteration 2 - One Canon, and only one Cannon - Using the Singleton Pattern.
Like the previous iteration we will pick an element of functionality and work through the same sequence again RED->GREEN->REFACTOR. Our next requirement is to allow only a single player. Given that we can allow 1 player we really should only use one instance, let's create a test for only one instance of the cannon object. We can compare two objects to ensure they are pointing at the same instance like (obj == obj2).

Add a new test beneath the first test in cannonattacktest.cs and our method looks like:
[TestMethod]
public void TestCannonMultipleInstances()
{
Cannon cannon = new Cannon();
Cannon cannon2 = new Cannon();
Assert.IsTrue(cannon == cannon2);
}
Run the tests by hitting CTRL-F5. We 1 Pass and 1 fail (our new test) so we are at RED again.
The reason that this failed is we have created two different instances. What we need is the singleton pattern to solve our problem. I have a great book on patterns called HEAD FIRST DESIGN PATTERNS if you want to know more about design patterns it's a great start - sure its Java but the code is so close to C# you should not have any real problems.
We are going to use the singleton pattern to meet the requirement of a single player. Really we don't want multiple instances of cannons hanging around - 1 and only 1 instance is needed. Insert the following Singleton code below the property for the ID.
private static Cannon cannonSingletonInstance;
private Cannon()
{
}
public static Cannon GetInstance()
{
if (cannonSingletonInstance == null)
    {
        cannonSingletonInstance = new Cannon();
    }
return cannonSingletonInstance;
}
If we try to run the tests we won't compile because the cannon object can't be created with Cannon cannon = new Cannon(); So make sure that we use Cannon.GetInstance() instead of new Cannon(). The two test methods should now look like:
[TestMethod]
public void TestCannonIDValid()
{
Cannon cannon = Cannon.GetInstance();
Assert.IsNotNull(cannon.ID);
}
[TestMethod]
public void TestCannonMultipleInstances()
{
Cannon cannon = Cannon.GetInstance();
Cannon cannon2 = Cannon.GetInstance();
Assert.IsTrue(cannon == cannon2);
}
Run the Tests again CTRL-F5

This time they pass GREEN so time to refactor. We are going to change our Singleton code because although the code works (and is pretty much 100% the same as the singleton code in the HEAD FIRST DESIGN PATTERNS Book) it is not thread safe in C# (see http://msdn.microsoft.com/en-us/library/ff650316.aspx) So we replace the original singleton code with:

private static Cannon cannonSingletonInstance;
static readonly object padlock = new object();
private Cannon()
{
}
public static Cannon GetInstance()
{
lock (padlock)
    {
if (cannonSingletonInstance == null)
        {
            cannonSingletonInstance = new Cannon();
        }
return cannonSingletonInstance;
    }
}
The block inside the lock ensures that only one thread enters this block at any given time. Given the importance of determining if there is an instance or not, we should definitely use the lock.

Run the all the tests again CTRL-F5 and they should all pass

That's the end of the second iteration and I think you should be getting the hang of it by now, so lets get onto the 3rd iteration.
Iteration 3 - Angling for something...
We will add another test method. This time we want to ensure that an incorrect angle (say 95 degrees) will not hit. So we need a Shoot method and a return type (lets keep it simple and make it a Boolean for now).

Add the following test below the last test:

[TestMethod]
public void TestCannonShootIncorrectAngle()
{
Cannon cannon = Cannon.GetInstance();
Assert.IsFalse(cannon.Shoot(95, 100));
}

Of course the compiler will complain and we get it to compile by right clicking on the Shoot method and select Generate->Method Stub.
Change the return type of the stub (in Cannon.cs) to a bool so that it will compile.

public bool Shoot(int p, int p_2)
{
throw new NotImplementedException();
}

Now hit CTRL-F5 and we see that the first two tests should still pass but our new test fails as this is the RED phase again.
So open Cannon.cs in the CannonAttack project, and replace the generated Shoot method with:

public bool Shoot(int angle, int velocity)
{
if (angle > 90 || angle < 0) //Angle must be between 0 //and 90 degrees
{
return false;
}
return true; //Not going to do the calculation just yet
}

Run the tests again and all three tests now pass so again :GREEN, so now back to refactor.
We need to add two extra readonly integers to the class. Insert them at the top of the class. We will add them as public so that they are exposed to the console application eventually.
public static readonly int MAXANGLE = 90;
public static readonly int MINANGLE = 1;
We want to refactor the Shoot method, so this now looks like:
public Tuple<bool, string> Shoot(int angle, int velocity)
{
if (angle > MAXANGLE || angle < MINANGLE) //Angle must be //between 0 and 90 degrees
{
return Tuple.Create(false, "Angle Incorrect");
}
return Tuple.Create(true, "Angle OK"); //Not //going to do the calculation just yet
}
We have changed the interface of the method so it returns a Tuple indicating if its a hit (BOOL) and also a message (STRING) containing the display text. The Tuple is a feature of C# 4.0. used to group a number of types together and we have used it in conjunction with the type inference of the var to give a neat and quick way to handle the messages from our shoot method. See the following article for further information:http://www.davidhayden.me/2009/12/tuple-in-c-4-c-4-examples.html
To handle the change to the shoot method we change our test to:

[TestMethod]
public void TestCannonShootAngleIncorrect()
{
var shot = cannon.Shoot(95, 100);
Assert.IsFalse(shot.Item1);
}
You will also notice now we have removed the object initialization of the cannon in our test method. The reason we have done this is we have moved that to the Class Initialize method of CannonAttackTest.cs. To do this simply uncomment out the two lines below:

[ClassInitialize()]
public static void CannonTestsInitialize(TestContext testContext)
{
}

Rename MyClassInitialize to CannonTestsInitialize.

Now just declare a cannon object for the class and add the object initialize code as this method is called every time we run our test. It means every test can remove that one line of code and now looks like the following (note we have removed a number of commented test methods that visual studio creates by default):

using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using CannonAttack;
namespace CannonAttackTest
{
    [TestClass]
public class CannonAttackTest
    {
private static Cannon cannon;
        [ClassInitialize()]
public static void CannonTestsInitialize(TestContext testContext)
        {
            cannon = Cannon.GetInstance();
        }
        [TestMethod]
public void TestCannonIDValid()
        {
Assert.IsNotNull(cannon.ID);
        }
        [TestMethod]
public void TestCannonMultipleInstances()
        {
Cannon cannon2 = Cannon.GetInstance();
Assert.IsTrue(cannon == cannon2);
        }
        [TestMethod]
public void TestCannonShootAngleIncorrect()
        {
var shot = cannon.Shoot(95, 100);
Assert.IsFalse(shot.Item1);
        }
    }
}

Now let's compile and run the tests CTRL-F5 and we'll find that they should all pass so we are finished the 3rd iteration.

Iteration 4 - That's a pretty fast cannonball
The next area of functionality, looking at the requirements, is to validate the incorrect speed. Just incase you are worrying about this validation...
"Nothing in the universe can travel at the speed of light, they say, forgetful of the shadow's speed." ~Howard Nemerov
Now that we are informed, let's write the test...

Add the following below the TestCannonShootAngleIncorrect method

[TestMethod]
public void TestCannonShootVelocityGreaterThanSpeedOfLight()
{
var shot = cannon.Shoot(45, 300000001);
Assert.IsFalse(shot.Item1);
}

So we run the tests and it will fail RED because the validation isn't complete in the Shoot method . We add the code needed into shoot method just under the validation code for the incorrect angle:

if (velocity > 300000000)
{
return Tuple.Create(false, "Velocity of the cannon cannot travel faster than the speed of light");
}

Run the tests again and this time they all pass - GREEN
Time to refactor, but this time lets use a new feature in VS2010 that allows us to determine the impact of a code change on the Test project.
Select from the menu TEST->Windows->Test Impact View :
The Test Impact View will appear on the right of your IDE and if you haven't used Test Impact View yet you will see:
Click the Enable test impact data collection in the active test settings link and then select OK on the next dialog. You must do this for each solution you use test impact view.
Build and Run CTRL-F5 all the tests and again they should all pass. Time to refactor.
Now add a constant (readonly int) for the speed of light and then ensure the code in the shoot method refers to the constant ie:
private readonly int MAXVELOCITY = 300000000;
And
if (velocity > MAXVELOCITY)
{
return Tuple.Create(false, "Velocity of the cannon cannot travel faster than the speed of light");
}
Now build the project and have a look at the Test Impact View:

This is very useful as we can see the impact of that change (even though its not a serious change) on the tests. If you want to run just the tests impacted by the change click on the Run Tests link in the Test Impact View window. While I won't talk further about the test impact view, it's worth using in your TDD activities. OK so this iteration is complete now for the calculation of the cannonball trajectory.

Iteration 5 - Shoot, the Messenger:Shot!!!
Time for the real fun of the shoot method. As the next four requirements are very close, I am going to include them in this iteration. Normally we would break these up but to keep this tutorial as brief as possible we'll group them together. They are:

Target Distance is simply the distance of the Cannon to Target, and is created randomly by default but can be overridden;
Max distance for target is 20000 meters;
Base the algorithm for the calculation of the cannons trajectory upon the following C# code (distance and height is meters and velocity is meters per second):
- distance = velocity * Math.Cos(angleInRadians) * time;
- height = (velocity * Math.Sin(angleInRadians) * time) - (GRAVITY * Math.Pow(time, 2)) / 2;
A hit occurs if the cannon is within 50m of the target;

First, we need a test to set a distance for the target and the correct angle and velocity for a miss (yes we are going to test for a miss first). Actually, for this functionality we are going to add two tests: one to test a miss and one for a hit.

So lets add the tests:

[TestMethod]
public void TestCannonShootMiss()
{
cannon.SetTarget(4000);
var shot = cannon.Shoot(45, 350);
Assert.IsTrue(shot.Item2 == "Missed cannonball landed at 12621 meters");
}
[TestMethod]
public void TestCannonShootHit()
{
cannon.SetTarget(12621);
var shot = cannon.Shoot(45, 350);
Assert.IsTrue(shot.Item2 == "Hit");
}

This will not compile so we can right click SetTarget and select Generate Method Stub.
Run the tests and of course the last two tests fail
We need to some changes to make it succeed, add this private variable and readonly int to the class:

private int distanceOfTarget;
private readonly double GRAVITY = 9.8;

below the validation code replace
return Tuple.Create(true, "Angle OK"); //Not going to do //the calculation just yet
with:
string message;
bool hit;
int distanceOfShot = CalculateDistanceOfCannonShot(angle, velocity);
if (distanceOfShot == distanceOfTarget)
{
    message = "Hit";
    hit = true;
}
else
{
    message = String.Format("Missed cannonball landed at {0} meters", distanceOfShot);
    hit = false;
}
return Tuple.Create(hit, message);
and then we create another method

public int CalculateDistanceOfCannonShot(int angle, int velocity)
{
    int time = 0;
double height = 0;
double distance = 0;
double angleInRadians = (3.1415926536 / 180) * angle;
while (height >= 0)
    {
        time++;
        distance = velocity * Math.Cos(angleInRadians) * time;
        height = (velocity * Math.Sin(angleInRadians) * time) - (GRAVITY * Math.Pow(time, 2)) / 2;
    }
return (int)distance;
}

Now Compile and run the tests and they will fail - because we are throwing an exception in SetTarget so lets change SetTarget to :

public void SetTarget(int distanceOfTarget)
{
this.distanceOfTarget = distanceOfTarget;
}

Run the tests again and now they all pass GREEN. Time to refactor.
Lets add some code to the constructor of the cannon class to randomly set it

private Cannon()
{
//by default we setup a random target
Random r = new Random();
SetTarget(r.Next(MAXDISTANCEOFTARGET));
}

and a constant for MAXDISTANCEOFTARGET

private readonly int MAXDISTANCEOFTARGET = 20000;

Make sure DistanceOfTarget is now a property:

public int DistanceOfTarget
{
get { return distanceOfTarget; }
set { distanceOfTarget = value; }
}

And now SetTarget can change to:

public void SetTarget(int distanceOfTarget)
{
    if (!distanceOfTarget.Between(0, MAXDISTANCEOFTARGET))
    {
throw new ApplicationException(String.Format("Target distance must be between 1 and {0} meters", MAXDISTANCEOFTARGET));
    }
this.distanceOfTarget = distanceOfTarget;
}

And we need to include the burst radius code in the Shoot method which will replace:

if (distanceOfShot == distanceOfTarget)

With

if (distanceOfShot.WithinRange(this.distanceOfTarget, BURSTRADIUS))

and a couple of important changes here
- We are using an extension method to provide a number of additional functions to ints.
- To add an extension method we follow the following steps:
  - Add a class to the console project
  - Call it ExtensionMethods.cs
  - Enter the following code:

using System;
namespace System
{
public static class ExtensionMethods
    {
public static bool Between(this int source, int min, int max)
        {
return (source >= min && source <= max);
        }
public static bool WithinRange(this int source, int target, int offset)
        {
return (target.Between(source - offset, source + offset));
        }
    }
}

We also need a BURSTRADIUS constant added to the class:

private readonly int BURSTRADIUS = 50;

The reason we use an extension method is because the Between and Within Range will be used often within the app. As we used the System namespace for these extension methods they will be provided always.
OK, So run the tests again and we find that they pass so time to move onto the next iteration
Iteration 6 - Counting Shots not Crows.
So the last piece of functionality to test is the Number of Shots so lets start with a simple test.

insert this after the last test.

[TestMethod]
public void TestCannonCountShots()
{
cannon.SetTarget(12621);
var shot = cannon.Shoot(45, 350);
Assert.IsTrue(shot.Item2 == "Hit - 1 Shot(s)", "Number of shots:" + cannon.Shots);
}
This will not compile because Shots doesn't exist yet.

Right click on the Shots property and select Generate->Property
Run the tests again and you will see this fail so lets make some changes to Cannon including:
- Change the property for Shots to:

public int Shots
{
get
{
return shots;
}
}

Add a field to the class

private int shots;

Initialise the variable in the constructor. It should now look like:

private Cannon()
{
//by default we setup a random target
Random r = new Random();
SetTarget(r.Next((int)MAXDISTANCEOFTARGET));
}

Increment the shot count in the shoot method - insert this after the validation for the speed of light:
shots ++;
Change the message of the hit to:
message = String.Format("Hit - {0} Shot(s)", shots);

Run the tests again we see the following:

This tells us the shot count is 3 not 1 (it also shows that the original test for a hit has to change to handle the new text) and the reason for this is the singleton pattern we are using. As we are only maintaining one instance of the object, that instance is actually being used for every Shoot that occurs during the run of tests. So we need to ensure every time we start a new game (ie. a new test) we reset the shot count. The easiest way is to introduce a Reset method where we can reset the shot count but also later on we can use this method for other things that need to be cleaned up/reset.

Add the following to Cannon.cs:

public void Reset()
{
shots = 0;
}

The way we can use this in our tests is by using a method that is being called before every test. Add the following method to CannonAttackTest

[TestInitialize]
public void ResetCannonObject()
{
cannon.Reset();
}

Let's change the original for test for the hit to:

[TestMethod]
public void TestCannonShootHit()
{
cannon.SetTarget(12621);
var shot = cannon.Shoot(45, 350);
Assert.IsTrue(shot.Item2 == "Hit - 1 Shot(s)");
}

Run the tests CTRL-F5. They will all pass:

and the cannon class is pretty much done. This is the end of the 6th Iteration and the Classes are complete. We are now going to write the code for CannonAttack that will call the classes from the UI.
Completing the Project
We can writethe Code in the Console UI to get the values from the user for the angle. This is important part because we haven't thought about UI till now, All the UI should be handled by the console. To do this:

Set the CannonAttack console project as the startup project
Add the following code to the CannonAttack.cs file

using System;
namespace CannonAttack
{
class CannonAttack
    {
private static readonly int MaxNumberOfShots = 50;
static void Main(string[] args)
        {
Console.WriteLine("Welcome to CannonAttack");
bool isStillPlaying = true;
while (isStillPlaying)
            {
bool isAHit = false;
Cannon cannon = Cannon.GetInstance();
while (!isAHit && cannon.Shots < MaxNumberOfShots)
                {
int angle;
int velocity;
Console.WriteLine(String.Format("Target is at {0} meters", cannon.DistanceOfTarget));
                    GetInputVariable(out angle, out velocity);
var shot = cannon.Shoot(angle, velocity);
                    isAHit = shot.Item1;
Console.WriteLine(shot.Item2);
                }
                isStillPlaying = GetIsPlayingAgain();
                cannon.Reset();
            }
Console.WriteLine("Thanks for playing Cannon Attack");
        }
    }
}
This is the core of the application and it should provide the main basis for the cannon attack application.
Below are the additional helper methods that are needed, so add them in underneath the main method:

private static bool GetIsPlayingAgain()
{
    bool isPlayingAgain = false;
bool validAnswer = false;
while (!validAnswer)
    {
Console.Write("Do you want to play again (y/n)?");
string playAgain = Console.ReadLine();
if (playAgain == "y" || playAgain == "Y")
        {
            isPlayingAgain = true;
            validAnswer = true;
        }
if (playAgain == "n" || playAgain == "N")
        {
            isPlayingAgain = false;
            validAnswer = true;
        }
    }
return isPlayingAgain;
}
private static void GetInputVariable(out int angle, out int velocity)
{
    string angleBuffer;
string velocityBuffer;
Console.Write(String.Format("Enter Angle ({0}-{1}):", Cannon.MINANGLE, Cannon.MAXANGLE));
    angleBuffer = Console.ReadLine();
if (!int.TryParse(angleBuffer, out angle))
    {
Console.WriteLine("Not a number, defaulting to 45");
        angle = 45;
    }
Console.Write("Enter Velocity (meters per second):");
    velocityBuffer = Console.ReadLine();
if (!int.TryParse(velocityBuffer, out velocity))
    {
Console.WriteLine("Not a number, defaulting to 100 meters per second");
        velocity = 100;
    }
}
Now you should be able to run the application and it should work displaying the output similar to what we defined on page 2 and should look like:

This is the End
That's it - your first TDD project is complete!!!. The next tutorial will introduce a number of new areas of functionality including:

Multiplayer; and
Mountains.

Any feedback you have would be appreciated as I'll update this tutorial as needed.
Additional Resources

Head First Design Patterns, Freeman and Freeman, O'Reilly, 2004.
Effective C# 50 Specific Ways to improve your C#, Bill Wagner, Addison -Wesley,2005.
Trajectory Calculation Code: http://forums.macrumors.com/showthread.php?t=180810
www.mdsn.microsoft.com

Image Processing Lab in C#

2010-05-18T01:49:00.001-07:00

· Download demo - 1025.2 KB

· Download source - 548.0 KB

Introduction

Image Processing Lab is a simple tool for image processing, which includes different filters and tools to analyze images available in the AForge.NET framework. It's easy to develop your own filters and to integrate them with the code or use the tools in your own application. The following filters are implemented in the AForge.NET framework and demonstrated in the application:

Color filters (grayscale, sepia, invert, rotate, channel extraction, channel replacing, channel filtering, color filtering, Euclidean color filtering);
HSL filters (linear correction, brightness, contrast, saturation, hue modifier, HSL filtering);
YCbCr filters (linear correction, YCbCr filtering, channel extraction/replacement);
Binarization filters (threshold, threshold with carry, ordered dithering, Bayer dithering, Floyd-Steinberg, Burkes, Jarvis-Judice-Ninke, Sierra, Stevenson-Arce, Stucki dithering methods);
Automatic binarization (simple image statistics);
Mathematical morphology filters (erosion, dilatation, opening, closing, hit & miss, thinning, thickening);
Convolution filters (mean, blur, sharpen, edges, Gaussian);
2 Source filters (merge, intersect, add, subtract, difference, move towards, morph);
Edge detectors (homogeneity, difference, sobel, canny);
Blob counter, Connected components labeling;
Pixellate, Simple skeletonization, Jitter, Shrink, Oil painting;
Levels linear filter, gamma correction;
Median filter, Adaptive smoothing, Conservative smoothing;
Resize and Rotate;
Texture generators based on Perlin noise;
Texture filters (texturer, textured filtering, textured merging);
Fourier transformation (lowpass and hipass filters).

You can create (save and load) your own convolution filters or filters based on standard mathematical morphology operators. Colorized grid makes it very convenient to work with custom convolution filters.

A preview window allows you to view the results of changing filter parameters on the fly. You can scroll an image using the mouse in the preview area. All filters are applied only to the portion of the image currently viewed to speed up preview.

A PhotoShop-like histogram allows you to get information about mean, standard deviation, median, minimum and maximum values.

The program allows you to copy to or paste from clipboard, save and print images.

Using the Code

Most filters are designed to work with 24bpp RGB images or with grayscale images. In the case of grayscale images, we use PixelFormat.Format8bppIndexed with color palette of 256 entries. To guarantee that your image is in one of the formats, you can use the following code:

// load an image

System.Drawing.Bitmap image = (Bitmap) Bitmap.FromFile( fileName );

// format image

AForge.Imaging.Image.FormatImage( ref image );

It is easy to apply any filter to your image:

// load an image

System.Drawing.Bitmap image = (Bitmap) Bitmap.FromFile( fileName );

// create filter

AForge.Imaging.Filters.Median filter = new AForge.Imaging.Filters.Median( );

// apply filter

System.Drawing.Bitmap newImage = filter.Apply( image );

Suppose, you want to apply a series of filters to an image. The straight way to do it is to apply filters one after another, but it's not very likely in the case of 3 or more filters. All filters implement the IFilter interface, so it allows us to create a collection of filters and apply it at once to an image (besides, the collection will also save us from disposing routines on intermediate images):

// create filters sequence AForge.Imaging.Filters.FiltersSequence

filter = new AForge.Imaging.Filters.FiltersSequence( );

// add filters to the sequence

filter.Add( new AForge.Imaging.Filters.Sepia( ) );

filter.Add( new AForge.Imaging.Filters.RotateBilinear( 45) );

filter.Add( new AForge.Imaging.Filters.ResizeBilinear( 320, 240 ) );

filter.Add( new AForge.Imaging.Filters.Pixellate( 8 ) );

filter.Add( new AForge.Imaging.Filters.Jitter( 2 ) );

filter.Add( new AForge.Imaging.Filters.Blur( ) );

// apply the sequence to an image

System.Drawing.Bitmap newImage = filter.Apply( image );

It's easy to get such image statistics as mean, standard deviation, median, minimum and maximum values. It can be useful for image brightness/contrast regulation.

// get image statistics

AForge.Imaging.ImageStatistics statistics =

new AForge.Imaging.ImageStatistics( image );

// get the red histogram

AForge.Math.Histogram histogram = statistics.Red;

// get the values

double mean = histogram.Mean; // mean red value

double stddev = histogram.StdDev; // standard deviation of red values

int median = histogram.Median; // median red value

int min = histogram.Min; // min red value

int max = histogram.Max; // max value

// get 90% range around the median

AForge.IntRange range = histogram.GetRange( 0.9 );

Image statistics can be easily combined with filters. Suppose that the minimum value of red is 50 on the image and the maximum value is 200. So, we can normalize the contrast of the red channel:

// create levels filter

AForge.Imaging.Filters.LevelsLinear filter =

new AForge.Imaging.Filters.LevelsLinear( );

filter.InRed = new IntRange( histogram.Min, histogram.Max );

// apply the filter

System.Drawing.Bitmap newImage = filter.Apply( image );

Or we can normalize the contrast of each channel, getting only the 90% ranges from each channel:

// create levels filter

AForge.Imaging.Filters.LevelsLinear filter =

new AForge.Imaging.Filters.LevelsLinear( );

filter.InRed = statistics.Red.GetRange( 0.9 );

filter.InGreen = statistics.Green.GetRange( 0.9 );

filter.InBlue = statistics.Blue.GetRange( 0.9 );

// apply the filter

System.Drawing.Bitmap newImage = filter.Apply( image );

HSL Filters

Using HSL color space is more obvious for some sorts of filters. For example, it's not very clean, how to adjust saturation levels of an image using RGB color space. But it can be done easily, using HSL color space:

// create filter

AForge.Imaging.Filters.SaturationCorrection filter =

new AForge.Imaging.Filters.SaturationCorrection( 0.1 );

// apply the filter

System.Drawing.Bitmap newImage = filter.Apply( image );

Initial image

Saturation adjusted

Using HSL color space, we can modify the hue value of pixels. Setting all hue values to the same value will lead to an image in gradations of one color:

// create filter

AForge.Imaging.Filters.HueModifier filter =

new AForge.Imaging.Filters.HueModifier( 142 );

// apply the filter

System.Drawing.Bitmap newImage = filter.Apply( image );

It's possible to get much more interesting results using HSL filtering. For example, we can preserve only the specified range of hue values and desaturate all others out of the range. So, it will lead to a black and white image with only some regions colored.

// create filter

AForge.Imaging.Filters.HSLFiltering filter =

new AForge.Imaging.Filters.HSLFiltering( );

filter.Hue = new IntRange( 340, 20 );

filter.UpdateHue = false;

filter.UpdateLuminance = false;

// apply the filter

System.Drawing.Bitmap newImage = filter.Apply( image );

Hue modified

HSL filtering

Mathematical Morphology Filters

There are many tasks that can be accomplished using mathematical morphology filters. For example, we can reduce noise on binary images using erosion, or we can separate some objects with the filter. Using dilatation, we can grow some parts of our interest on the image. One of the most interesting morphological operators is known as Hit & Miss. All other morphological operators can be expressed from the Hit & Miss operator. For example, we can use it to search for particular structures on the image:

// searching for vertical lines

short[,] vse = new short[3, 3] {

{ 0, 1, 0 },

{ 0, 1, 0 }

};

AForge.Imaging.Filters.HitAndMiss vFilter =

new AForge.Imaging.Filters.HitAndMiss( vse );

System.Drawing.Bitmap vImage = vFilter.Apply( image );

// searching for horizontal lines

short[,] hse = new short[3, 3] {

{ 0, 0, 0 },

{ 1, 1, 1 },

{ 0, 0, 0 }

};

AForge.Imaging.Filters.HitAndMiss hFilter =

new AForge.Imaging.Filters.HitAndMiss( hse );

System.Drawing.Bitmap hImage = hFilter.Apply( image );

Original image

Searching for vertical lines

Searching for horizontal lines

Using a thickening operator, we can grow some parts of the image in the places we need. For example, the next sample will lead to thickening horizontal lines in the bottom direction:

// create filter

AForge.Imaging.Filters.FilterIterator filter =

new AForge.Imaging.Filters.FilterIterator(

new AForge.Imaging.Filters.HitAndMiss(

new short [,] { { 1, 1, 1 }, { -1, 0, -1 }, { -1, -1, -1 } },

HitAndMiss.Modes.Thinning ), 5 );

// apply the filter

System.Drawing.Bitmap newImage = filter.Apply( image );

Original image

Thickened image

Using a thinning operator, you can remove some unnecessary parts of the image. For example, you can develop a skeletonization filter with appropriate structuring elements:

// create filter sequence

AForge.Imaging.Filters.FiltersSequence filterSequence =

new AForge.Imaging.Filters.FiltersSequence( );

// add 8 thinning filters with different structuring elements

filterSequence.Add( new AForge.Imaging.Filters.HitAndMiss(

new short [,] { { 0, 0, 0 }, { -1, 1, -1 }, { 1, 1, 1 } },

HitAndMiss.Modes.Thinning ) );

filterSequence.Add( new AForge.Imaging.Filters.HitAndMiss(

new short [,] { { -1, 0, 0 }, { 1, 1, 0 }, { -1, 1, -1 } },

HitAndMiss.Modes.Thinning ) );

filterSequence.Add( new AForge.Imaging.Filters.HitAndMiss(

new short [,] { { 1, -1, 0 }, { 1, 1, 0 }, { 1, -1, 0 } },

HitAndMiss.Modes.Thinning ) );

filterSequence.Add( new AForge.Imaging.Filters.HitAndMiss(

new short [,] { { -1, 1, -1 }, { 1, 1, 0 }, { -1, 0, 0 } },

HitAndMiss.Modes.Thinning ) );

filterSequence.Add( new AForge.Imaging.Filters.HitAndMiss(

new short [,] { { 1, 1, 1 }, { -1, 1, -1 }, { 0, 0, 0 } },

HitAndMiss.Modes.Thinning ) );

filterSequence.Add( new AForge.Imaging.Filters.HitAndMiss(

new short [,] { { -1, 1, -1 }, { 0, 1, 1 }, { 0, 0, -1 } },

HitAndMiss.Modes.Thinning ) );

filterSequence.Add(new AForge.Imaging.Filters.HitAndMiss(

new short [,] { { 0, -1, 1 }, { 0, 1, 1 }, { 0, -1, 1 } },

HitAndMiss.Modes.Thinning ) );

filterSequence.Add( new AForge.Imaging.Filters.HitAndMiss(

new short [,] { { 0, 0, -1 }, { 0, 1, 1 }, { -1, 1, -1 } },

HitAndMiss.Modes.Thinning ) );

// create filter iterator for 10 iterations

AForge.Imaging.Filters.FilterIterator filter =

new AForge.Imaging.Filters.FilterIterator( filterSequence, 10 );

// apply the filter

System.Drawing.Bitmap newImage = filter.Apply( image );

Original image

Thinned image

Fourier Transformation

It is easy to perform a Fourier transformation, which is useful for image analysis and filtering with the library:

// create complex image from bitmap

AForge.Imaging.ComplexImage cimage =

AForge.Imaging.ComplexImage.FromBitmap( bitmap );

// perform forward Fourier transformation

cimage.ForwardFourierTransform( );

// get frequency view

System.Drawing.Bitmap img = cimage.ToBitmap( );

Lowpass and hipass filtering can be performed using the FrequencyFilter method of the ComplexImage class:

// lowpass filtering

cimage.FrequencyFilter( new Range( 0, 100 ) );

// perform backward Fourier transformation

cimage.BackwardFourierTransform( );

// get filtered image

System.Drawing.Bitmap img = cimage.ToBitmap( );

Blob Counter

Blob counter is a very useful feature and can be applied in many different applications. What does it do? It can count objects on a binary image and extract them. The idea comes from "Connected components labeling," a filter that colors each separate object with a different color. Let's look into a small sample:

// create filter

AForge.Imaging.Filters.ConnectedComponentsLabeling filter =

new AForge.Imaging.Filters.ConnectedComponentsLabeling( );

// apply filter

System.Drawing.Bitmap newImage = filter.Apply( image );

// objects count

System.Diagnostics.Debug.WriteLine( "Objects count: " +

filter.ObjectCount );

Here are two images: initial image and colored image. So, it looks like the filter is really able to count objects.

Here is another example of objects counting and retrieving their position and size:

// process an image

AForge.Imaging.BlobCounter blobCounter = new BlobCounter( image );

Rectangle[] rects = blobCounter.GetObjectRectangles( );

// objects count

System.Diagnostics.Debug.WriteLine( "Objects count: " + rects.Length );

// objects dimension

foreach ( Rectangle rc in rects )

{

System.Diagnostics.Debug.WriteLine(

string.Format("Position: ({0}, {1}), Size: {2} x {3}",

rc.Left, rc.Top, rc.Width, rc.Height ) );

}

It's possible to extract each object with the GetObjects method of BlobCounter:

// process an image

AForge.Imaging.BlobCounter blobCounter = new BlobCounter( image );

Blob[] blobs = blobCounter.GetObjects( image );

// process blobs

foreach ( Blob blob in blobs )

{

// ...

// blob.Location - location of the blob

// blob.Image - blob`s image

}

YCbCr Filtering

YCbCr filters are provided with similar functionality to RGB and HSL filters. The YCbCr linear correction filter performs as its analogues from other color spaces, but operates with the Y, Cb and Cr components respectively, providing us with additional convenient ways of color correction. The next small sample demonstrates the use of the YCbCr linear filter and the use of in-place filtering: the feature, which allows you to filter a source image instead of creating a new result image, is as follows:

// create filter

YCbCrLinear filter = new YCbCrLinear( );

filter.InCb = new DoubleRange( -0.276, 0.163 );

filter.InCr = new DoubleRange( -0.202, 0.500 );

// apply filter

filter.ApplyInPlace( image );

Perlin Noise Filters

Perlin noise has many applications and one of the most interesting of them is the creation of different effects, like marble, wood, clouds, etc. Application of such effects to images can be done in two steps. The first step is to generate effect textures and the second step is to apply the textures to the particular image. Texture generators are placed into the Texturesnamespace of the library, which contains generators for such effects as clouds, wood, marble, labyrinth and textile. All these texture generators implement the ITextureGeneratorinterface. For applying textures to images, there are three filters. The fist one, Texturer, is for texturing images. The second, TexturedFilter, allows application of any other filter to an image using the texture as a mask. The third, TexturedMerge, allows merging of two images using the texture as a mask.

// 1 - Marble effect

// create texture

ITextureGenerator generator = new MarbleTexture( );

float[,] texture = generator.Generate( image.Width, image.Height );

// create filter

IFilter filter1 = new Texturer( texture );

// apply filter

Bitmap newImage1 = filter1.Apply( image );

// 2 - Wood effect

// create filter

IFilter filter2 = new Texturer( new WoodTexture( ) );

// apply filter

Bitmap newImage2 = filter2.Apply( image );

// 3 - Textile effect

// create filter

IFilter filter3 = new Texturer( new TextileTexture( ) );

// apply filter

Bitmap newImage3 = filter3.Apply( image );

// 4 - Rusty effect

IFilter filter4 = new TexturedFilter( new CloudsTexture( ),

new Sepia( ) , new GrayscaleBT709( ) );

// apply filter

Bitmap newImage4 = filter4.Apply( image );

AForge.NET Framework

The Image Processing Lab application is based on the AForge.NET framework, which provides all the filters and image processing routines available in the application. To get more information about the framework, you may read the dedicated article on The Code Project or visit the project's home page, where you can get all the latest information about it, participate in a discussion group or submit issues or requests for enhancements.

Conclusion

I suppose the code may be interesting for someone who would like to start studying image processing or for filters/effects developers. As for me, I'll use the tool for my further research in computer vision. Besides, the library helped me very much in successfully finishing my bachelor work.

History

[08.03.2007] - Version 2.4.0
- Application converted to .NET 2.0;
- Integrated with AForge.NET framework.
[13.06.2006] - Version 2.3.0
- In place filter interface introduced, which allows filter application on the source image;
- Perlin noise texture generators (marble, wood, textile, labyrinth, clouds);
- Texture filters (texturer, textured filtering, textured merging);
- RGB to YCbCr and YCbCr to TGB converters;
- YCbCr filters;
- Image statistics for YCbCr;
- Other minor changes (fix of Canny edge detector, Pixellate filter updated, morph filter).
[20.09.2005] - Version 2.2.0
- Canny edge detector;
- Oil painting, Conservative smoothing;
- Simple image statistics threshold.
[20.08.2005] - Version 2.1.0
- Blob counter, Connected components labeling;
- Sobel edge detector;
- Adaptive smoothing, Gaussian blur, Image cropping.
[12.07.2005] - Version 2.0.0
- Homogeneity and Difference edge detectors;
- Fourier transformation (lowpass and hipass filters);
- AForge namespace;
- Copy and Paste to clipboard;
- Image saving and printing.
[20.06.2005] - Version 1.4.0
- More morphological methods (hit & miss, thinning, thickening);
- HSL filters;
- Gamma correction, filter iterator, etc.
[29.03.2005] - Version 1.3.0
- Resize and rotate;
- Jitter, Shrink, more dithering methods;
- MaskedFilter.
[20.03.2005] - Version 1.2.0
- More filters;
- Preview window;
- Grid colorization for morphology and convolution custom filters;
- Support for two source filters;
- Toolbar.
[03.03.2005] - Version 1.0.0

URL": http://www.codeproject.com/KB/GDI-plus/Image_Processing_Lab.aspx?display=Print

Dynamic Type in C# 4.0

2010-05-18T01:29:00.000-07:00

Dynamic is a new type introduced in c# 4.0.Dynamic types are declared with the dynamic keyword. The objects of type Dynamic are not type checked at compile time. It behaves like type Object in most cases .Object of any type can be assigned to a variable of Dynamic type .Variable of Dynamic type can get its value even from HTML Document Object Model (DOM) or COM API. If the code is not valid, errors are caught at run time not at compile time.

C# was until now a statically bound language. This means that if the compiler couldn't find the method for an object to bind to then it will throw compilation error.

We declare at compile-time the type to be dynamic, but at run-time we get a strongly typed object.

Dynamic objects expose members such as properties and methods at run time, instead of compile time. If you try to access members of a Dynamic type in visual studio IDE you will get the message "The operation will be resolved at runtime".

Difference between Object, Var and Dynamic type

If we execute the following code

dynamic dyn = 0;

object obj = 0;

var var = 0;

System.Console.WriteLine(dyn.GetType());

System.Console.WriteLine(obj.GetType());

System.Console.WriteLine(var.GetType());

We will get the runtime types of all the Object ,Dynamic and var variables as Sytem.Int32 .But the type of var variable is available at compile time as well.

But now if we add the following two statements the second statement will give compile time error because the expression is type checked at compile time while the first statement compiles successfully because expressions of dynamic type are not type checked at compile time and the var type variable is assigned the appropriate datatype at compile time itself.

dyn = dyn + 1;

obj = obj + 1;

var = var + 1;

If we execute the below program

class Dynamic

{

static void Main(string[] args)

{

dynamic dyn;

string str = "Dynamic type test.String";

StringBuilder sb = new StringBuilder();

sb.Append("Dynamic type test.StringBuilder");

dyn = str;

DynamicFunction(dyn);//This will call the first function because at run time the dynamic type is of string type

dyn = sb;

DynamicFunction(dyn);////This will call the first function because at run time the dynamic type is of string builder type

Console.Read();

}

public static void DynamicFunction(string s)

{

Console.WriteLine(s);

}

public static void DynamicFunction(StringBuilder sb)

{

Console.WriteLine(sb.ToString());

}

We will get the output as shown below:

To conclude Dynamic Type is a nice feature when it comes to interoperatibility and .NET usage with other Dynamic languages. However Dynamic type also makes it the responsibility of the developer for the correct usage of the calls.

URL: http://www.c-sharpcorner.com/UploadFile/ashish_2008/1157/

Developing and Deploying Custom Web Parts for SharePoint Portal 2007

2009-10-25T05:09:00.001-07:00

Overview and difference with SPS 2003:

Developing Web Part for SharePoint Portal 2007 is different as compared to developing for SPS 2003. Web Parts Developed in .Net 1.1 for SPS 2003 used the SharePoint.WebPartPages namespace, however the Web Part in ASP.Net 2.0 is found under theSystem.Web.UI.WebControls.WebParts.

Development of Web Part in VS 2005

To Get Started with creating Custom Web Part for MOSS 2007 in Microsoft Visual Studio 2005, Open the IDE and create a new C# project, Select Class Library as Project Type. Name It as NewWebPart.

Add a reference to the System.Web from .Net components into the project. The System.Web dll contains the required namespace ofSystem.Web.UI.WebControls.WebParts .

In The Project explorer view rename the Class1.cs with NewWbPart.cs to be consistent with this example; this will result in renaming the Class name as well. With the help of “using” keyword include the namespaces as shown in the code example below. Derive / Extend the NewWebPart Class from the WebPart Class ( System.Web.UI.WebControls.WebParts.WebPart), and add the code as shown below. The CreateChildren Control is same as in .Net 1.1, that it would create and add controls to this Web Part Class,. In this case I have only added a WebControl.Calender Object. The RenderControl Method is an override for the WebPart Base Class and calls the RenderChildren Method, this causes the Children Controls to be rendered on the Particular HtmlTextWriter passed as a parameter to the method.

using System;

using System.Collections.Generic;

using System.Text;

using System.Web;

using System.Web.UI;

using System.Web.UI.WebControls;

using System.Web.UI.WebControls.WebParts;

namespace NewWepPart

{

public class NewWebPart : WebPart

{

protected override void CreateChildControls()

{

Calendar cldr = new Calendar();

cldr.Enabled = true;

cldr.ShowGridLines = true;

cldr.ShowTitle = true;

cldr.EnableViewState = true;

cldr.SelectedDate = DateTime.Now;

Controls.Add(cldr); �

�

}

public override void RenderControl(HtmlTextWriter writer)

{

RenderChildren(writer);

}

Build the project and on successful built you are ready to Deploy the Web Part to the Portal Site.

Deployment of Web Part:

In order to deploy a web part to a SharePoint portal 2007 site, we must have the URL of the site to which we want our web part needs to be deployed (displayed in fact). As it is mentioned earlier that the Web Parts developed in .Net 2.0 environment does have a .CAB project , instead an assembly is created on build of project. Now there are two choices to deploy the assembly to the SharePoint portal directory.

Deploy the assembly to the Assembly Folder (GAC) (requires the assembly to be stron named).
Put the assembly to the bin folder of the portal directory.

For the sake of simplicity, the later choice is being demonstrated in this example.

Putting Assembly in Bin Folder:

The MOSS 2007 creates every portal in the inetpub\wwwroot\wss folder. The easiest way to find the bin folder from these folder hierarchies is to go from inetmgr console. Locate the appropriate portal (for which u want to deploy the web part), identified with the port number. Right click and have Properties. Under the Home Directory Tab, note the path in Local path text box. Verify if the bin folder exists in the specified path by opening it in browser. If the folder doesn’t exist then create one. Now copy the assembly form the project output folder and paste it in bin folder of portal.

However there is another work around for putting the assembly in to the portal’s bin folder again ad again each time the Web Part Project is built with changes.

Right click on the project name (NewWebPart) in the VS.Net 2005 IDE and click properties. Under the Build page paste the same path copied from inetmgr console into the Output Path. As shown in figure below. This will result in the latest assembly automatically deployed to the bin folder every time the project is built.

Adding the Safe Control Entry:

Even though the assembly is present in the Portal’s Bin folder, there is another step required to make the Control (Web Part) assembly usable on the Portal Pages. Since the control will need to render on multiple machines in different browsers with as many user accounts as the organizations have. There is a need to declare the control as “safe”. To do so open the web.config file placed under the portal’s directory in the VS.Net 2005 IDE.

Then edit the file in the section of SafeControls, create a new SafeControl entry for our assembly as shown below. Save the file and close it.

SafeControls>

Configuring Portal to use NewWebPart

Since now the web part have been written and deployed to the desired portal’s directory. The next task is to use the web part on the Portal’s Site. The Web Part Deployed to the portal can be placed on any site within that Portal. For convenience this NewWebPart is demonstrated to be placed on the home page of default Portal.

Open the portal site in the internet explorer; in this case http://oss1 is the URL for the default portal, ensuring that the current logged in user has the administrative rights on the portal site.

To begin with, the first step is to add the newly deployed web to the Portal’s web part gallery, since the portal is using the configuration databases to keep record of the contents of the portal, our newly created web part’s information doesn’t exist in the database. We need to add the web part to the Web Part Gallery before we can use it.

To do so, the following steps should be followed.

1. Click on the Site Actions button and then select Site Settings.

2. On the site settings page under Galleries column click on the Web Parts.

3. On the Web Part Gallery Page click on the New button, to add the new web part assembly to the gallery.

4. On the New Web Parts page locate the NewWebPart in the list, check the check box on the left and click on the Populate Gallerybutton the top of the page. This will result in the Web Part entry creation in the Web Part Gallery list, and hence it can be used from now on from the gallery. It can be notices easily that the Web Parts developed form the new Frame work of 2.0 have an extension of .webpartafter their names. Whereas in earlier versions, it was a .dwp file. Both the .webpart and .dwp files are the XML definition of the Web Part.

5. Until this step the web part is ready to be used on the site by selecting it from Web Part Gallery. Click on the Site Actions button on the page and then select Edit Page, this will modify the appearance of the page to enable the edit view. In this view Web Part Zones are highlighted so that a user can add a web part to the zone, Click on the Add a Web Part button in the left zone to add the Web Part.

6. Select the NewWebPart from the web part list . it is found under the Misc section and then click on�Advanced Web Part gallery and options.

7. In the�Add Web Part Pane at right , select Home Gallery and then drag the NewWebPart from the pane into the Web Part Zone.

8. Click on the Exit Edit Mode link on the page and the site will return to the view mode.

Map IP Address to a Geographical Location

2009-10-24T02:38:00.001-07:00

Introduction

On the Internet there is the concept of web site analytics that helps track all the visitors' activities and usage patterns. One of the dimensions to track is the geographical information of the visitors, which can be obtained by using the IP address information that is collected when a user lands on a Website. In this article, I will describe a simple process that enables your reporting system to display the geographical information of the visitors.

Scope

This article does not describe the process needed to capture the IP information from the user. This process is an application level solution that can be implemented on the front end with software like ASP.Net, PHP etc. The scope of this article is limited to the usage of the IP address to discover the geographical data. This data is composed of the Country, Region, City, Postal code and Area code where applicable. Some countries may not have the concept of postal code.

What is an IP Address?

When a user lands on a web page, the web application has the ability to collect information from this user. One of these data elements is the IP address. The IP address has a format of 192.15.10.125, and it is a logical address assigned to a device. This is what identifies your Internet address, and it is composed of segments that identify your geographical location.

What Do I need to Map an IP Address to a Geo Location?

In order to map the IP address to a geographical representation, the system needs the geographical data mapping. This data is provided by several companies. In this case, we are using the GEOLiteCity data, which is free. To obtain this data, visithttp://www.maxmind.com/app/geolitecity and download the ZIP file which contains two files, Blocks and Location CSV. The block file maps an IP number range to a location. The location file has the geographical information. Please note that there are frequent updates to these files, so make sure you read the description of their services.

In order to import this data to your database, one first needs to create the table definitions. We need to create the Geo Location and Block tables. This are the table definitions: (you can also download the scripts)

Import the data using your preferred method. The first line on the CSV file is a copyright statement. The second line has the column headers, so make sure to skip the first line during the import process. I have also included a visitor log table which can be used to track the user's data. This table is very simple, and it does not include all the possible data elements that can be collected.

Solution

Once the data has been imported, you will notice that the IP address in the data does not look anything like 192.15.10.125. The information is actually stored as an IP number. This numeric value is what allows us to do a range comparison. An IP number range is mapped to a particular location. This is what allows us to do the association, but the first step is to figure out how to convert an IP address to an IP number. This is where a user defined function can help us. We first need to convert the IP address to an IP number by using the ConvertIP2Num function below:

This function first splits the IP address into its four segments (delimited by a dot). This is where XML becomes really handy. We just create an XML string and use the parser to do the split for us by selecting the XML nodes. We use the Row_Number() function to create a factor which will help us arrive to the segment weight (i.e. segment: 192 has rownumber:1 and weigh: 4-1 = 3) . We now apply the conversion formula which consists of assigning a zero based weight to each segment (zero starting from the right segment) and multiplying this segment by (256 ^ n) OR POWER (256,n) where n = weight. The final step is to add all the segment results. For example, IP 192.15.10.125 is converted as follows:

The result is the number that can be used to query the geo tables. To do this, you can create a query similar to the one below which returns the geographical information.

One item to notice here is that the conversion from IP address to number would not perform as well when you are trying to query thousand of rows and using the function to do the conversion at run time. A better approach would be to have an additional column on the table the holds the IP address information. This column can store the IP number as well. (See IPNum column on the Visitor_log Table) This way the import job can populate this field, so there is no performance hit during the query or creation of the report. In addition, by storing both fields (IP Address and Num), you will not have a need to reverse the IP Num to IP Address.

If you do need to reverse an IP Num to IP Address (to validate the process, etc), you can use the ConvertNum2IP function below:

This function just reverses the process by dividing the IP Num by Power(256,n) and subtracting the result from the IP Num. Each segment result is then appended into a string with the corresponding IP Address format.

Conclusion:

With this article, I was able to show a simple process to create your own GEO lookup database and provide a solution to map the IP address to its location information. There are still other items to consider like automating the import process to download the new files, convert the IP address to the IP Num value, integrate this information in a data warehouse, and create reports that will show your marketing team in what regions the customers are located.

Facebook forget password Error :)

2009-10-20T06:20:00.001-07:00

Hi,

Just i forget my facebook account password and want to reset it. So i go to facebook website and then forget password and then trying to enter the Security Check words like the below screen shot

Because I am a developer, I can guess the technical problem as the function which compare the user input and security check words is wrong .

After you click Reset password, FB will send you an email with code to change your password despite of wrong input words as shown on the above image.

May be The below is the technical problem expectation
The below function of validating word will ignore the last character.

I like catching the problems from big companies’ products :)

Hope it being nice post for you.!

Part IV: Step by step procedure of how to install an assembly

2009-08-02T07:34:00.001-07:00

Introduction

Now, we will see how to install an assembly using the merge module witch is a tool provided by the MS Visual Studio 2005. The merge module tool is used to wrap components designed especially in order to be shared later. Components can be dll files or user controls objects that are consumed, in general, by the developer who wants to use or reuse already existing components, for example, he can develop anapplication against given dll files. So, using this method can provide him possibility to enjoy with those dll's or component's services.
Assuming that we want deploy an assembly witch called ClassLibrary1 with this feature:

using System;

using System.Collections.Generic;

using System.Text;

using System.Windows.Forms;

namespace ClassLibrary1

{

public class Class1

{

public Class1()
{

MessageBox.Show("You are using ClassLibrary1");

}

}
}
After building it, we save the project and we add a new one by clicking File, New and Project

Figure 1

After the merge module project is opened, select Module Retarget able Folder just at right under the File system target machine node, then, right click and select add, then select project output as the figure shows bellow:

Figure 2

Select the primary output element list representing the assembly that we want to deploy. If you want to deploy other elements such as documentation files to get support to the developers or XML serialization assemblies, you can add them with the primary output.

Figure 3

Now, expand the Merge module properties grid and set the author name, for example, "Me" as the figure shows bellow:

Figure 4
There is a property witch I find very useful by the way, I mean, the "Search Path" property used to determine the path used to localize assemblies, files or even merge modules on the development computer.
Now, build the solution and browse to the application directory, the merge module project with name "MergeModule1" is there. Browse to the debug file an open it. A file with *.msm extension is created; this file represents the merge module project output. The mission is not completely accomplished because the merge module can not be installed directly. To install it, we must add an Installer project in order to consume the merge module; in fact, this one can't be installed by its self.
So, add a new setup project by selecting File then Add then New Project, and select Setup Project

Figure 5

Now, select Application Folder then Add then Project output menu item and click on it.

Figure 6

Select the Merge Module 1 project in the combo box list as shown bellow:

Figure 7

Expand the setup properties grid and change the author property "." By "Me" and the Manufacturer property value "." By "Me" before build the project, otherwise, it can not be installed later. Build the setup project. After that, select it, right click and choose install in the context menu and click on it.

Figure 8
The install process will be launched.

Figure 9

After the project deployment, swap to the configuration panel and open add and remove program. You can find the setup 1 among the installed programs.

Figure 10
The developer, or let us say the intermediate user, can browse to %root%\ProgramFiles\Me, there, he can find the new installed dll file.

Part III: Step by step procedure of how to install an assembly

2009-08-02T07:31:00.001-07:00

Introduction

We have seen in previous articles how to install an assembly using both, the .NET Framework management console and the Global assembly cache tool provided by the NET Framework. Now we will se how to install a strong named assembly with the simplest manner.
We have seen in a previous article how one can install a given assembly using the .Net Framework management console the Mscorcfg.msc. Now, we proceed to achieve the same goal but using another tool witch is the Global assembly cache tool cagutil.exe provided by the .Net framework.
To do that, follow those steps:
First of all, let us develop a simple assembly. To do that, follow those steps

Create a new class library project and name it myAssembly

Figure 1

Add this code to the editor

using System;

using System.Collections.Generic;

using System.Text;

using System.Windows.Forms;

namespace myAssembly

{

public class Class1

{

public Class1()

{

MessageBox.Show("You are using myAssembly");

}

}
}

Save the project.
The GAC accepts only assemblies with strong names; there fore it is imperatively recommended to sign the assembly before adding it into GAC, otherwise when adding a none strongly assembly, a message indicates that the new assembly can not be added to the GAC appears and finally the action is failed. So, to sign myAssembly, go to myAssembly properties as shown bellow.

Figure 2

Select the signing tab and then check sign the assembly checkbox

Figure 3

Select New in the combo box as shown above. This dialog box appears

Figure 4

Enter the key file name with twelve characters, then enter a password with more than six characters and confirm it, then click Ok.
A file looks like this is added to the application directory with *.snk as an extension witch is a Strong Name Key abbreviation. This file contains a random pair keys and it is provided to sign the assembly. This file can be generated also using the Strong name tool sn.exe provided by .NET framework.
Browse to "C:\Windows\assembly" directory witch looks like bellow:

Figure 5

Drag the assembly and drop it in this directory, that's all.

Installing an Assembly: Part II Using the Global Cache

2009-08-02T07:28:00.001-07:00

Introduction

We have seen in a previous article how one can install a given assembly using the .Net Framework management console the Mscorcfg.msc. Now, we proceed to achieve the same goal but using another tool witch is the Global assembly cache tool cagutil.exe provided by the .Net framework.
To do that, follow those steps:
First of all, let us develop a simple assembly. To do that, follow those steps

1. Create a new class library project and name it myAssembly

Figure 1

Add this code to the editor

using System;

using System.Collections.Generic;

using System.Text;

using System.Windows.Forms;

namespace myAssembly

{

public class Class1

{

public Class1()

{

MessageBox.Show("You are using myAssembly!!!");

}

}
}

Save the project.
The GAC accepts only assemblies with strong names ; there fore it is imperatively recommended to sign the assembly before adding it into GAC, otherwise when adding a none strongly assembly, a message indicates that the new assembly can not be added to the GAC appears and finally the action is failed. So, to sign myAssembly, go to myAssembly properties as shown bellow.

Figure 2

Select the signing tab and then check sign the assembly checkbox

Figure 3

Select New in the combo box as shown above. This dialog box appears

Figure 4

Enter the key file name with twelve characters, then enter a password with more than six characters and confirm it, then click Ok.
A file looks like this is added to the application directory with *.snk as an extension witch is a Strong Name Key abbreviation. This file contains a random pair keys and it is provided to sign the assembly. This file can be generated also using the Strong name tool sn.exe provided by .NET framework.
Build the solution, save the project and close it.
Open the console, Start--> Accessories--> Console
Browse to your .Net framework directory using the change directory cd command.
Tape cagutil -I myAssembly and the press enter and the windows shell will tell you that the assembly is installed in the assembly cache.

Step by step procedure of how to install an assembly: Part I

2009-08-02T07:27:00.001-07:00

Introduction

It is an assembly container provided by the .NET Framework especially to store assemblies shared and used by different .Net applications installed on a given computer or on a given network. It is located in a subdirectory of the root system but it can not be directly accessed except that administrator permission is given before. The GAC is accessed via the .NET configuration management console witch is represented bellow:

Figure 1
Assume that an assembly is simultaneously used and/or reused by more than one developer or shared by more than one application. So, it should be shared by them all. Therefore using GAC is a good alternative. It is possible to install the assembly in the GAC and give developers privileges access to the system root rather than to copy it into each development station. It is possible that the assembly cache contains more than one version of the same assembly but it is important to mention in this context that assemblies' names don't have an extension like *.dll or *.exe when are displayed within the GAC list. Only the assembly name appears without any extensions, because when the common language runtime CLR looks for a targeted assembly, it can precise the corresponding assembly according to the application needs.
When an application is developed against an assembly, it depends on it, therefore it needs to locate it and exploit its services when running. First of all the common language runtime CLR, witch is responsible for executing the application program, verifies if the assembly is already referenced and used, if this is not the case, it search it, at second plan, in the application bin directory, after that, it is checked in the global assembly cache GAC, in a final step, the CLR checks information about the targeted assembly in the configuration file, in this step the code base located in the configuration file gives information about the targeted assembly. When the assembly is not or can not be found, an error occurs. And a message like this can be found in the error list:

Figure 2

Where can one find the Global Assembly Cache:

To obtain the assemblies' list in Global assembly cache, follow this path:
Click Start --> Configuration Panel --> Administration tools --> .Net Framework Configuration
The .NET Framework 2.0 Configuration management console is opened as bellow:

Figure 3

Expand the My Computer node within the tree just at right and then select the assembly cache node then click view List of assemblies in the assembly cache hyper link.

Figure 4

The assembly list is displayed as bellow:

Figure 5

How can one install an assembly in the GAC:

First of all, let us develop a simple assembly. To do that, follow those steps

Create a new class library project and name it myAssembly for example.

Figure 6

Add this code to the editor.

using System;

using System.Collections.Generic;

using System.Text;

using System.Windows.Forms;

namespace myAssembly

{

public class Class1

{

public Class1()

{

MessageBox.Show("You are using myAssembly");

}

Save the project.
The GAC accepts only assemblies with strong names ; there fore it is imperatively recommended to sign the assembly before adding it into GAC, otherwise when adding a none strongly assembly, a message indicates that the new assembly can not be added to the GAC appears and finally the action is failed. So, to sign myAssembly, go to myAssembly properties as shown bellow.

Figure 7

Select the signing tab and then check Sign the assembly checkbox.

Figure 8

Select New in the combo box as shown above. This dialog box appears

Figure 9

Enter the key file name with twelve characters, then enter a password with more than six characters and confirm it, then click Ok.
A file looks like this is added to the application directory with *.snk as an extension witch is a Strong Name Key abbreviation. This file contains a random pair keys and it is provided to sign the assembly. This file can be generated also using the Strong name tool sn.exe provided by .NET framework.
Build the solution, save the project and close it.
Switch to the .Net Framework management console and right click on the Assembly cache node, a context menu appears.
Click add menu item, the open dialog box appears.

Figure 10

Browse to the assembly location and then click open. The assembly will be added to the global assembly cache without any problems.

Google's Static Map API WebControl

2009-08-02T00:32:00.001-07:00

· Download source - 5.56 KB

· Download demo - 19.24 KB

Introduction

GStaticMap is an ASP.NET WebControl allowing you to build and show a static map image with optionally some markers, a path, etc. using Google’s Static Maps API.

Here is a quick sample, showing you what you can quickly and easily produce with it:

This sample can be achieved with some lines of code in the code-behind, or directly in your ASPX page:

Collapse

<asp:GStaticMap ID="gsmTestMap" AutomaticZoomLevel="true"

AutomaticCenter="true" Width="320" Height="200" Type="RoadMap"

ZoomLevel="12" Key="put_yours_here" runat="server">

<asp:GMarker Latitude="45.859723" Longitude="4.842223" Letter="a"

Color="Red"></asp:GMarker>

<asp:GMarker Latitude="45.759723" Longitude="5.042223" Letter="b"

Color="Green"></asp:GMarker>

<asp:GMarker Latitude="45.659723" Longitude="4.842223" Letter="c"

Color="Blue"></asp:GMarker>

<asp:GMarker Latitude="45.759723" Longitude="4.642223" Color="Green">

</asp:GMarker>

</Markers>

<Paths>

<asp:GPath Color="blue" Opacity="255" Weight="5">

<asp:GCoordinate Latitude="45.859723" Longitude="4.842223">

</asp:GCoordinate>

<asp:GCoordinate Latitude="45.759723" Longitude="5.042223">

</asp:GCoordinate>

<asp:GCoordinate Latitude="45.659723" Longitude="4.842223">

</asp:GCoordinate>

</Points>

</asp:GPath>

<asp:GPath Color="red" Opacity="128" Weight="5">

<asp:GCoordinate Latitude="45.659723" Longitude="4.842223">

</asp:GCoordinate>

<asp:GCoordinate Latitude="45.759723" Longitude="4.642223">

</asp:GCoordinate>

<asp:GCoordinate Latitude="45.859723" Longitude="4.842223">

</asp:GCoordinate>

</Points>

</asp:GPath>

</Paths>

</asp:GStaticMap>

The generated URL is the following (I've added some spaces to wrap the URL and removed my API key):

Collapse

http://maps.google.com/staticmap?size = 320x200 & maptype = roadmap

& markers = 45.859723,4.842223,reda | 45.759723,5.042223,greenb |

45.659723,4.842223,bluec | 45.759723,4.642223,green & path = rgba:0x0000ffff,weight:5

| 45.859723,4.842223 | 45.759723,5.042223 | 45.659723,4.842223 &

path = rgba:0xff000080,weight:5 | 45.659723,4.842223 | 45.759723,4.642223

| 45.859723,4.842223 & key = put_yours_here.

Note that this WebControl is a sequel of my previous MapData WebControl, replacing it.

Background

First, you'll need to sign up for a free Google Maps API key if you don't have one. Connect with your Google account and put your domain name root (including the TCP/IP port).

Please note that I didn't provide my API key in the sample project, you'll have to put yours if you want to run the tests (just replace all "put_yours_here" occurrences with your key)

Classes Overview / Code Design

Our goal is to display a map with, optionally, some markers and a path. Since the map will be rendered as an image (img tag), there is no need to reinvent the wheel: we'll derive our GStaticMap WebControl from System.Web.UI.Image.

It’s now time to think about the classes that will be the foundations of our WebControl. First, we have a static map (GStaticMap class); this map will use:

A center based on a coordinate (GCoordinate class)
A collection of markers (GMarker class) themselves based on coordinates (GCoordinate class)
A collection of paths (GPath class), themselves based on a collection of coordinates (GCoordinate class)

Here is the class diagram (included in the sample project):

The next step is to more deeply describe our classes. So:

A static map is defined by the following properties:

A width (integer, inherited from Image)
A height (integer, inherited from Image)
A center (using our GCoordinate class, optional when there is at least one marker)
A zoom level (integer, optional when there is at least one marker, from 1 to 19)
A rendering type (enumerator, optional: roadmap by default, or designed for mobile devices)
An image format (enumerator, optional: GIF, JPEG or PNG)

A marker is defined by the following properties:

A color (enumerator, optional: the Static Map API restricts them to red, by default, blue, or green)
An optional letter (character, optional, from A to Z)

A path is defined by the following properties:

A color (you can define it either with a known color from RGB values)
An optional opacity (integer, optional: from 0 to 255)

A coordinate is defined by the following properties:

A latitude (double)
A longitude (double)

Making the Code – Coordinate Class (GCoordinate)

It’s now time for some code.

We'll start our control with the coordinate class (GCoordinate). It’s a "small" class based on two doubles, constructors, and a query string serialization. Here is the class (tips and tricks are explained after):

Collapse

/// <summary>

/// Represents a Google Coordinate

/// </summary>

[Serializable]

[ToolboxData("<{0}:GCoordinate Latitude=''

Longitude='' runat="server"></{0}:GCoordinate>")]

public class GCoordinate

{

#region Instance members

/// <summary>

/// Latitude

/// </summary>

private double _latitude;

/// <summary>

/// Longitude

/// </summary>

private double _longitude;

#endregion

#region Accessors

/// <summary>

/// Latitude

/// </summary>

[Bindable(true)]

[Category("Coordinate")]

[DefaultValue("")]

[Localizable(false)]

public double Latitude

{

get { return _latitude; }

set { _latitude = value; }

}

/// <summary>

/// Longitude

/// </summary>

[Bindable(true)]

[Category("Coordinate")]

[DefaultValue("")]

[Localizable(false)]

public double Longitude

{

get { return _longitude; }

set { _longitude = value; }

}

#endregion

#region Constructors

/// <summary>

/// Constructor

/// </summary>

/// <param name="latitude"></param>

/// <param name="longitude"></param>

public GCoordinate()

{

}

/// <summary>

/// Constructor

/// </summary>

public GCoordinate(double latitude, double longitude)

{

SetCoordinate(latitude, longitude);

}

#endregion

#region Utilities

/// <summary>

/// Serialize data as a query string part

/// Format : {latitude,longitude}

/// </summary>

/// <returns></returns>

internal virtual string SerializeAsQueryString()

{

return string.Format("{0},{1}", AngularValueToString(Latitude, 6),

AngularValueToString(Longitude, 6));

}

/// <summary>

/// Format an angular value to be used by GStaticMap

/// </summary>

/// <param name="angularValue"></param>

/// <param name="fixedLength"></param>

/// <returns></returns>

private string AngularValueToString(double angularValue, int precision)

{

return angularValue.ToString("F" + precision,

CultureInfo.CreateSpecificCulture("en-US"));

}

internal void SetCoordinate(double latitude, double longitude)

{

_latitude = latitude;

_longitude = longitude;

}

#endregion

}

First, I've added the [Serializable] attribute before the class declaration, this is needed in order to store the class in the ViewState (as a serializedstring).

Secondly, let's have a look at the serialization methods: the AngularValueToString method converts a double value to a formatted string (localized to en-US culture for the decimal point), and SerializeAsQueryString is an internal (to be accessed by other classes of the same assembly) method making use of AngularValueToString to output the coordinate as query string parameters (braces are not relevant).

Output: {latitude},{longitude}

Finally, we have a SetCoordinate method that will allow us to modify the latitude and longitude in a single call.

Making the Code – Marker Class (GMarker)

A marker will be outputted like this on the map: (color and letter are customizable)

First, we have an enumerator with available colors:

Collapse

#region Enumerators

/// <summary>

/// Available Google Static Marker colors

/// </summary>

public enum GMarkerColor

{

Red,

Blue,

Green

}

#endregion

Then, the marker class (GMarker) inherits from GCoordinate and extends it with marker’s color and letter (tips and tricks are explained after):

Collapse

/// <summary>

/// Represent a Google Marker

/// {latitude} (required) specifies a latitudinal value with precision to

/// 6 decimal places.

/// {longitude} (required) specifies a longitudinal value with precision to

/// 6 decimal places.

/// {color} (optional) specifies a color from the set {red,blue,green}.

/// {alpha-character} (optional) specifies a single lowercase alphabetic character

/// from the set {a-z}.

/// </summary>

[Serializable]

[ToolboxData("<{0}:GMarker Latitude='' Longitude=''

Letter='a' Color='Red' runat="server">

</{0}:GMarker>")]

public class GMarker : GCoordinate

{

#region Instance members

/// <summary>

/// Marker color

/// </summary>

private MarkerColor _color;

/// <summary>

/// Marker letter (optional)

/// </summary>

private char? _letter;

#endregion

#region Accessors

/// <summary>

/// Marker color

/// </summary>

[Bindable(true)]

[Category("Appearance")]

[DefaultValue("Red")]

[Localizable(false)]

public MarkerColor Color

{

get { return _color; }

set { _color = value; }

}

/// <summary>

/// Marker letter (optional)

/// </summary>

[Bindable(true)]

[Category("Appearance")]

[DefaultValue("a")]

[Localizable(false)]

public char? Letter

{

get { return _letter; }

set { _letter = value; }

}

#endregion

#region Constructors

public GMarker()

{

}

public GMarker(double latitude, double longitude, MarkerColor color)

: base(latitude, longitude)

{

_color = color;

}

public GMarker(double latitude, double longitude, MarkerColor color, char letter)

: this(latitude, longitude, color)

{

_letter = letter;

}

#endregion

#region Utilities

/// <summary>

/// Serialize data as a query string part

/// Format : {latitude},{longitude},{color}{alpha-character}

/// </summary>

/// <returns></returns>

internal override string SerializeAsQueryString()

{

return string.Format

(

"{0},{1}{2}",

base.SerializeAsQueryString(),

Enum.GetName(typeof(MarkerColor), Color).ToLower(),

(Letter == null ? "" : Letter.ToString())

);

}

#endregion

}

Once again, I added the [Serializable] attribute (always for the ViewState).

The most interesting code is the serialization part: SerializeAsQueryString is again with internal visibility (to be accessed by other classes of the same assembly) and outputs the marker as query string parameters with the help of its base class (for the coordinate part). It also shows how to retrieve the name of an enumerator value (yes, it’s verbose…) transformed to lower characters in order to respect the Google Static Map API (braces are not relevant).

Serialization output: {coordinate},{color}{letter}

Note that the letter is optional, so we only output it if it’s not null (thanks to the ternary operator, gracefully used here).

Making the Code – Path Class (GPath)

The last step before building the static map class is the path class (GPath).

First, we have an enumerator with available color types (simple RBG, or RGB with Alpha channel):

Collapse

#region Enumerators

/// <summary>

/// Available Google Static Marker colors

/// </summary>

public enum GPathColorType

{

RGB,

RGBA

}

#endregion

This class doesn't inherit from any class but makes use of the coordinate one (GCoordinate) to store the points (tips and tricks are explained after):

Collapse

/// <summary>

/// Represent a Google Path

/// </summary>

[Serializable]

[ToolboxData("<{0}:GPath runat="server"></{0}:GPath>")]

public class GPath

{

#region Enumerators

/// <summary>

/// Available Google Static Marker colors

/// </summary>

protected enum PathColorType

{

RGB,

RGBA

}

#endregion

#region Instance members

/// <summary>

/// Path color (default blue)

/// </summary>

private System.Drawing.Color _color = System.Drawing.Color.Blue;

/// <summary>

/// Path thickness, in pixels

/// </summary>

private int _weight = 1;

/// <summary>

/// Path opacity from 0% to 100% (optional)

/// </summary>

private int? _opacity;

/// <summary>

/// List of points

/// </summary>

private List<GCoordinate> _points = new List<GCoordinate>();

#endregion

#region Accessors

/// <summary>

/// Path color

/// </summary>

[Bindable(true)]

[Category("Appearance")]

[DefaultValue("Red")]

[Localizable(false)]

public System.Drawing.Color Color

{

get { return _color; }

set { _color = value; }

}

/// <summary>

/// Path thickness, in pixels

/// </summary>

[Bindable(true)]

[Category("Appearance")]

[DefaultValue("1")]

[Localizable(false)]

public int Weight

{

get { return _weight; }

set { _weight = value; }

}

/// <summary>

/// Path opacity from 0 to 255 (optional)

/// </summary>

[Bindable(true)]

[Category("Appearance")]

[DefaultValue("1")]

[Localizable(false)]

public int? Opacity

{

get { return _opacity; }

set { _opacity = value; }

}

/// <summary>

/// Paths (optional)

/// </summary>

[

DesignerSerializationVisibility(DesignerSerializationVisibility.Content),

PersistenceMode(PersistenceMode.InnerDefaultProperty),

Editor(typeof(List<GCoordinate>), typeof(System.Drawing.Design.UITypeEditor)),

]

public List<GCoordinate> Points

{

get { return _points; }

}

#endregion

#region Constructors

public GPath()

{

}

public GPath(System.Drawing.Color color, int weight)

{

Color = color;

Weight = weight;

}

public GPath(System.Drawing.Color color, int weight, int opacity)

: this(color, weight)

{

Opacity = opacity;

}

#endregion

#region Utilities

/// <summary>

/// Serialize data as a query string part

/// Format : path=pathColorType:pathColorValue,weight:pathWeight

/// |pathPoint1|pathPoint2|pathPoint3|...

/// </summary>

/// <returns></returns>

internal string SerializeAsQueryString()

{

// Checks

// Get color type

PathColorType pathColorType = (Opacity == null) ? PathColorType.RGB :

PathColorType.RGBA;

// Get color value

string colorValue = string.Format("{0:x8}", Color.ToArgb()).Substring(2, 6);

if (Opacity != null)

{

colorValue += string.Format("{0:x2}", Opacity);

}

// Serialize path's header

string serializedPath = string.Format

(

"path={0}:0x{1},weight:{2}|",

(pathColorType == PathColorType.RGB) ? "rgb" : "rgba",

colorValue,

_weight

);

//Serialize path's points

List<string> serializedPoints = new List<string>();

foreach(GCoordinate coordinate in Points)

{

serializedPoints.Add(coordinate.SerializeAsQueryString());

}

// Returns serialized path

return serializedPath + string.Join("|", serializedPoints.ToArray());

}

#endregion

}

As usual, this class is serializable ([Serializable] attribute) in order to be stored in the ViewState.

The serialization part (SerializeAsQueryString method) is again with internal visibility (to be accessed by other classes of the same assembly) and outputs the path as query string parameters with the help of the coordinate class (braces and brackets are not relevant).

Serialization output: path={rgb|rgba}:0x{ color}[{alpha}],weight:{weight}|{ coordinate}|{coordinate}...

Note that the opacity is optional and the color type will be output as "rgb" or "rgba" according to its value (note the use of the ternary operator).

Making the Code – Static Map Class (GStaticMap)

Here is the final part of our WebControl: the WebControl itself. I've sliced out the interesting parts in order to comment them step by step (you may open the whole code in your Visual Studio).

First, we have useful enumerators for the map type, the map’s image format and for the zoom levels bounds:

Collapse

#region Enumerators

/// <summary>

/// Available map types

/// </summary>

public enum GStaticMapType

{

Mobile,

RoadMap

}

/// <summary>

/// Available image formats

/// </summary>

public enum GStaticMapImageFormat

{

GIF,

JPG,

PNG32

}

/// <summary>

/// Available zoom levels

/// </summary>

public enum GStaticMapZoomLevel : uint

{

Mini = 1,

Maxi = 19

}

#endregion

Here is the declaration of the static map class (GStaticMap), inheriting from System.Web.UI.WebControls.Image:

Collapse

[ToolboxData("<{0}:GStaticMap runat="server"></{0}:GStaticMap>")]

public class GStaticMap : System.Web.UI.WebControls.Image

{

..........

}

We declare private instance members of our class.

You'll notice that we have members relating to the automatic centering and automatic zooming features, which we will talk about in few minutes.

I also make use of generics for the markers and paths lists. The last member is the Google API Key, don't forget to get yours!

Collapse

#region Instance members

/// <summary>

/// Indicates if automatic center is enabled

/// (available if at least one marker present)

/// </summary>

private bool _automaticCenter;

/// <summary>

/// Indicates if automatic zoom level is enabled

/// (available if at least one marker present)

/// </summary>

private bool _automaticZoomLevel;

/// <summary>

///Center (required if markers or paths not present)

/// </summary>

private GCoordinate _center;

/// <summary>

/// ZoomLevel (required if markers or paths not present)

/// </summary>

private uint? _zoomLevel = null;

/// <summary>

/// Image format (optional)

/// </summary>

private MapImageFormat? _imageFormat = null;

/// <summary>

/// Map type (optional)

/// </summary>

private MapType? _type = null;

/// <summary>

/// List of markers

/// </summary>

private List<GMarker> _markers = new List<GMarker>();

/// <summary>

/// List of paths

/// </summary>

private List<GPath> _paths = new List<GPath>();

/// <summary>

/// Google Base API Key (required)

/// Go to http://code.google.com/apis/base/signup.html to get yours

/// (it's free and doesn't require any subscription)

/// </summary>

private string _key;

#endregion

It’s now time to declare our public accessors.

Since we are making a WebControl, you'll notice that most of them have a Bindable attribute in order to become ASP.NET attributes (i.e. you can define them directly in the tag that you may declare in the ASPX page) and to be available in the design mode.

Don't worry if you don't see the Center, Markers and Paths here, a specific region will covers them since they are now accessible as children in the ASPX page.

Accessors are very interesting because they encapsulate the way they manage the value you pass or retrieve to them: have a look at the zoom level (ZoomLevel), and the setter (which becomes a method during the compilation) checks bounds with the help of the enumerator. By contrast, automatic center and automatic zoom accessors alter the return value through the getter (also transformed to a method by the compiler).

The last interesting thing in this part is about the ImageUrl accessor. I make use of the new keyword as a modifier in order to redefine the base class’ImageUrl accessor. Here, I wanted ImageUrl to be readable but not settable (because it’s built by our class before rendering), so I only defined a getter returning the value of the base class accessor (base keyword):

Collapse

#region Accessors

/// <summary>

/// ZoomLevel (required if markers or paths not present)

/// </summary>

[Bindable(true)]

[Category("Appearance")]

[DefaultValue("MapZoomLevel.Mini")]

[Localizable(false)]

public uint? ZoomLevel

{

get { return _zoomLevel; }

set

{

// Check zoom bounds

if (value < (uint)MapZoomLevel.Mini) { value = (uint)MapZoomLevel.Mini; }

else if (value > (uint)MapZoomLevel.Maxi) { value = (uint)MapZoomLevel.Maxi; }

// Apply new zoom

_zoomLevel = value;

}

/// <summary>

/// Image format (optional)

/// </summary>

[Bindable(true)]

[Category("Appearance")]

[DefaultValue("PNG")]

[Localizable(false)]

public MapImageFormat? ImageFormat

{

get { return _imageFormat; }

set { _imageFormat = value; }

}

/// <summary>

/// Map type (optional)

/// </summary>

[Bindable(true)]

[Category("Appearance")]

[DefaultValue("RoadMap")]

[Localizable(false)]

public MapType? Type

{

get { return _type; }

set { _type = value; }

}

/// <summary>

/// Google Base API Key (required)

/// Go to http://code.google.com/apis/base/signup.html to get yours

/// (it's free and doesn't require any subscription)

/// </summary>

[Bindable(true)]

[Category("Google")]

[DefaultValue("")]

[Localizable(false)]

public string Key

{

get { return _key; }

set { _key = value; }

}

/// <summary>

/// Indicates if automatic center is enabled (available if at least one marker present)

/// </summary>

[Bindable(true)]

[Category("Appearance")]

[DefaultValue("")]

[Localizable(false)]

public bool AutomaticCenter

{

get { return _automaticCenter && IsAutomaticAvailable; }

set { _automaticCenter = value; }

}

/// <summary>

/// Indicates if automatic zoom level is enabled

/// (available if at least one marker present)

/// </summary>

[Bindable(true)]

[Category("Appearance")]

[DefaultValue("")]

[Localizable(false)]

public bool AutomaticZoomLevel

{

get { return _automaticZoomLevel && IsAutomaticAvailable; }

set { _automaticZoomLevel = value; }

}

/// <summary>

/// Redefine picture's ImageUrl to avoid any modification

/// (since ImageUrl is built by the webcontrol)

/// </summary>

public new string ImageUrl

{

get { return base.ImageUrl; }

}

/// <summary>

/// Indicates whether automatic center and levels are available

/// </summary>

public bool IsAutomaticAvailable

{

get { return (Markers.Count > 0 || Paths.Count > 0); }

}

#endregion

Here are the accessors that you can use directly in the ASPX page, the DesignerSerializationVisibility attribute for each of them make (according to MSDN) the code generator produce code for the contents of the object, rather than for the object itself (so you can access them in the ASPX page):

Collapse

#region Childs

/// <summary>

/// Center (required if markers or paths not present)

/// </summary>

[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]

public GCoordinate Center

{

get

{

if (_center == null)

{

_center = new GCoordinate();

}

return _center;

}

/// <summary>

/// Markers (optional)

/// </summary>

[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]

public List<GMarker> Markers

{

get { return _markers; }

}

/// <summary>

/// Paths (optional)

/// </summary>

[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]

public List<GPath> Paths

{

get { return _paths; }

}

#endregion

Now, since we have all the needed members and attributes to complete our aim, it’s time to write the BuildUrl method that will produce the final URL, according to the Google Static Map API.

Serialization output: http://maps.google.com/staticmap?parameters.

Collapse

#region Utilities

/// <summary>

/// Build up the URL used to request the generated picture

/// Format : http://maps.google.com/staticmap?parameters

/// </summary>

/// <returns></returns>

private string BuildUrl()

{

// Base URL (change if needed)

string url = "http://maps.google.com/staticmap?";

List<string> parameters = new List<string>();

// Center (required if markers or paths not present)

if (!AutomaticCenter)

{

parameters.Add("center=" + Center.SerializeAsQueryString());

}

// ZoomLevel (required if markers or paths not present)

if (!AutomaticZoomLevel)

{

parameters.Add("zoom=" + ZoomLevel);

}

// Image size

parameters.Add(string.Format("size={0}x{1}",

(int)Width.Value, (int)Height.Value));

// Image format (optional)

if (ImageFormat != null)

{

parameters.Add("format=" + Enum.GetName(typeof(MapImageFormat),

ImageFormat).ToLower());

}

// Map type (optional)

if (Type != null)

{

parameters.Add("maptype=" + Enum.GetName(typeof(MapType), Type).ToLower());

}

// Markers (optional)

if (Markers.Count > 0)

{

// Gather markers in a string list

List<string> markers = new List<string>();

foreach (GMarker poi in Markers)

{

markers.Add(poi.SerializeAsQueryString());

}

// Add them as a parameter

parameters.Add(string.Format

("markers={0}", string.Join("|", markers.ToArray())));

}

// Paths (optional)

if (Paths.Count > 0)

{

foreach (GPath path in Paths)

{

// Add them as a parameter

parameters.Add(path.SerializeAsQueryString());

}

// ZoomLevel (required if markers or paths not present)

if (Key != string.Empty)

{

parameters.Add("key=" + Key);

}

// Build up and returns final URL

return url + string.Join("&", parameters.ToArray());

}

#endregion

The next logical step is to set the ImageUrl accessor. The best moment to do this is just before the rendering, so we just have to overload the OnPreRendervirtual method to achieve this:

Collapse

#region Methods

/// <summary>

/// Build the image url according to parameters and added points

/// </summary>

/// <param name="e"></param>

protected override void OnPreRender(EventArgs e)

{

base.OnPreRender(e);

// Set Image Url before rendering

base.ImageUrl = BuildUrl();

}

#endregion

OK, our work is looking good now, but we have missed something… How will the state of our control be maintained after a postback? Obviously with theViewState, so here is the way to do this: we must overload the LoadViewState and SaveViewState virtual methods to, respectively load ViewStatevalues in the control and save the control values in the ViewState (you can also directly save or load some values on demand, by using accessors):

Collapse

/// <summary>

/// Load viewstate values

/// </summary>

/// <param name="savedState"></param>

protected override void LoadViewState(object savedState)

{

base.LoadViewState(savedState);

_center = (GCoordinate)ViewState["Center"];

ZoomLevel = (uint)ViewState["ZoomLevel"];

Type = (MapType)ViewState["MapType"];

Markers.AddRange(new List<GMarker>((GMarker[])ViewState["Markers"]));

Paths.AddRange(new List<GPath>((GPath[])ViewState["Paths"]));

Key = (string)ViewState["Key"];

AutomaticCenter = (bool)ViewState["AutomaticCenter"];

AutomaticZoomLevel = (bool)ViewState["AutomaticZoomLevel"];

}

/// <summary>

/// Save viewstate values

/// </summary>

/// <returns></returns>

protected override object SaveViewState()

{

ViewState["Center"] = _center;

ViewState["ZoomLevel"] = ZoomLevel;

ViewState["MapType"] = Type;

ViewState["Markers"] = Markers.ToArray();

ViewState["Paths"] = Paths.ToArray();

ViewState["Key"] = Key;

ViewState["AutomaticCenter"] = AutomaticCenter;

ViewState["AutomaticZoomLevel"] = AutomaticZoomLevel;

return base.SaveViewState();

}

The only tricky thing was to save and load the markers and paths list based on a generic class. It may be a better way to do this, but I convert the list into an array and get it back to a list during the ViewState loading phase.

Using the WebControl in an ASPX Page

If you're a Web Designer or not so close to ASP.NET programming, you can now widely use the WebControl directly in an ASPX page.

First, you need to register the WebControl in your page:

Collapse

<%@ Register TagPrefix="asp" Assembly="GStaticMapTest"

Namespace="Initia.Google.GStaticMap" %>

Then, you can show a simple map like this (don't forget runat="server" and the center coordinate, since there are no markers and paths):

Collapse

<asp:GStaticMap ID="gsmTestMap" AutomaticZoomLevel="true" AutomaticCenter="true"

Width="320" Height="200" Type="RoadMap" ZoomLevel="12" Key="put_yours_here"

runat="server">

</asp:GStaticMap>

As needed, you may add one or several markers (the center is optional if you use automatic center):

Collapse

<asp:GStaticMap ID="gsmTestMap" AutomaticZoomLevel="true" AutomaticCenter="true"

Width="320" Height="200" Type="RoadMap" ZoomLevel="12"

Key="put_yours_here" runat="server">

<asp:GMarker Latitude="45.859723" Longitude="4.842223"

Letter="a" Color="Red">

</asp:GMarker>

<asp:GMarker Latitude="45.759723" Longitude="5.042223"

Letter="b" Color="Green">

</asp:GMarker>

<asp:GMarker Latitude="45.659723" Longitude="4.842223"

Letter="c" Color="Blue">

</asp:GMarker>

<asp:GMarker Latitude="45.759723" Longitude="4.642223"

Color="Green">

</asp:GMarker>

</Markers>

</asp:GStaticMap>

Finally, you may add one or several paths on your map:

Collapse

<asp:GStaticMap ID="gsmTestMap" AutomaticZoomLevel="true" AutomaticCenter="true"

Width="320" Height="200" Type="RoadMap" ZoomLevel="12"

Key="put_yours_here" runat="server">

<asp:GMarker Latitude="45.859723"

Longitude="4.842223" Letter="a" Color="Red">

</asp:GMarker>

<asp:GMarker Latitude="45.759723"

Longitude="5.042223" Letter="b" Color="Green">

</asp:GMarker>

<asp:GMarker Latitude="45.659723"

Longitude="4.842223" Letter="c" Color="Blue">

</asp:GMarker>

<asp:GMarker Latitude="45.759723"

Longitude="4.642223" Color="Green">

</asp:GMarker>

</Markers>

<Paths>

<asp:GPath Color="blue" Opacity="255" Weight="5">

<asp:GCoordinate Latitude="45.859723" Longitude="4.842223">

</asp:GCoordinate>

<asp:GCoordinate Latitude="45.759723" Longitude="5.042223">

</asp:GCoordinate>

<asp:GCoordinate Latitude="45.659723" Longitude="4.842223">

</asp:GCoordinate>

</Points>

</asp:GPath>

<asp:GPath Color="red" Opacity="128" Weight="5">

<asp:GCoordinate Latitude="45.659723" Longitude="4.842223">

</asp:GCoordinate>

<asp:GCoordinate Latitude="45.759723" Longitude="4.642223">

</asp:GCoordinate>

<asp:GCoordinate Latitude="45.859723" Longitude="4.842223">

</asp:GCoordinate>

</Points>

</asp:GPath>

</Paths>

</asp:GStaticMap>

Using the WebControl in the Code-behind

If you love coding or have to programmatically manage static maps, you can use code-behind to fit your needs.

The sample project included with this article shows you how to do this, here is some explanation about the basics.

First, create an ASPX page and register the newly created WebControl:

Collapse

<%@ Register TagPrefix="asp" Assembly="GStaticMapTest"

Namespace="Initia.Google.GStaticMap" %>

Now, "instantiate" the WebControl (this reference is automatically added in the designer if the ASPX page is right) where you want the static map to render:

Collapse

<asp:GStaticMap ID="gsmTestMap" runat="server"></asp:GStaticMap>

At this point, you can set some attributes like automatic center, map type, width, height… and you must set the Google API Key (beware: Google will serve you 1000 times the same static map per day and per IP address, you should use cache to avoid problems if you have some traffic !)

To avoid prefixing GStaticMap components in the code-behind, use the following namespace:

Collapse

using Initia.Google.GStaticMap;

Then, you can show a simple map like this (don't forget the center coordinate, since there are no markers and paths):

Collapse

// Initialize map size

gsmTestMap.Width = int.Parse(tbMapWidth.Text);

gsmTestMap.Height = int.Parse(tbMapHeight.Text);

// Set map type to Mobile

gsmTestMap.Type = GStaticMapType.Mobile;

// Center the static map to my town: Lyon, FRANCE

gsmTestMap.Center.SetCoordinate(45.759722, 4.842222);

gsmTestMap.Key = "put_yours_here";

// Set the zoom level

gsmTestMap.ZoomLevel = 8;

As needed, you may add one or several markers (the center becomes optional if you use automatic center):

Collapse

gsmTestMap.Markers.Add(new GMarker(45.759722, 4.842222, GMarkerColor.Blue, 'd');

Finally, you may add one or several paths on your map like this:

Collapse

// Trace a path from Lyon, FRANCE (45° 45' 35? N, 4° 50' 32? E) to Paris,

FRANCE (48° 51' 23.68? N,

// 2° 21' 6.58? E)

GPath fromLyonToParis = new GPath(KnownColor.Red, 5, 255);

fromLyonToParis.Points.Add(new GCoordinate(45.759723, 4.842223));

fromLyonToParis.Points.Add(new GCoordinate(48.856578, 2.351828));

gsmTestMap.Paths.Add(fromLyonToParis);

Points of Interest

This WebControl now covers all features of discontinued MapData WebControl, using the official static maps API from Google.

With this article, you learned how to:

build a useful custom WebControl with attributes and children
manage the ViewState
use the Google Static Maps API

Known Limitations

Missing visual designer
Missing icon for the toolbox

How to develop a Simple Vertical Text Scroller custom server control in ASP.NET

2009-08-02T00:24:00.001-07:00

Introduction

Couple years ago, I was looking for a simple text scroller application to replace our text scoller that was based on Java and I found the application Cross Browser marquee II on dynamicdrive.com. I have modified it to tailor my requirement. The main modification I made to the scroller was the addition of two buttons that controlled the flow of the vertical scroll content. Recently, I did a quick search on Google and found out that handful (50+) of websites were still using this application. Below are the few of them.

Check it out.

http://cherryle.win.aplus.net/index.asp
http://www.hydroqual.com
http://www.sabugacenter.com
http://www.ehub.si
http://www.globalnews-indonesia.com
http://www.mmtv.co.za/index.htm
http://www.opcfoundation.org

Moving forward, I have converted this application to ASP.NET custom server control. Now, the ASP.NET developers can drag and drop the control to the page without copy and paste between the web applications. Below is a step by step tutorial on how I have accomplished this. Hope this tutorial will give someone an idea on how to create a custom server control.

Download the original application/ script

cmarquee2.htm

Note

I have broken the cmarquee2.htm page into three different sections, namely Style Sheet, JavaScript and static HTML elements/ tags.

Create Class Library

Open VS 2005/2008. Go to File, New, Project, Visual C# and select Class Library template and fill up the required field.
Rename the class1.cs to TextScroller.cs

Adding Style Sheet

Right click the project, Add, New Item, Visual C# Project Items, Select Style Sheet from the available templates. I named it TextScroller.css. Extract all the Style Sheet from cmarquee2.htm into TextScroller.css

Adding JavaScript

Right click the project, Add, New Item, Visual C# Project Items, Select Jscript from the available templates. I named it TextScroller.js. Extract all the JavaScript from cmarquee2.htm into TextScroller.js

Adding New Folder

Right click the MyTextScroller project, Add, New Folder, rename the folder to images. Place all the images in this folder.

Adding System.Web References

Right click on the MyTextScroller project, Add Reference. In the .NET tab locate the System.Web component name, select it and click Ok.

Check Point

The structure of the project should look like the picture from below if you follow all the above step correctly.

Embedding the Resources

Right click one of the images, select Properties, and change the Build Action value from Content to Embedded Resource. Repeat the same step for all the other images.

Repeat the above step for the JavaScript and Style Sheet.

Double click the AssemblyInfo.cs. Add the following to the bottom of the file.

Collapse

[assembly: System.Web.UI.WebResource("MyTextScroller.TextScroller.css", "text/css")]
[assembly: System.Web.UI.WebResource("MyTextScroller.TextScroller.js", "text/javascript")]
[assembly: System.Web.UI.WebResource("MyTextScroller.images.nav-arrow-down-hover.gif", "image/gif")]
[assembly: System.Web.UI.WebResource("MyTextScroller.images.nav-arrow-down.gif", "image/gif")]
[assembly: System.Web.UI.WebResource("MyTextScroller.images.nav-arrow-up-hover.gif", "image/gif")]
[assembly: System.Web.UI.WebResource("MyTextScroller.images.nav-arrow-up.gif", "image/gif")]

Note

The syntax - [assembly: System.Web.UI.WebResource("Default Namespace.File Location.File Name", "Type")]

Example 1

My Default Name Space is MyTextScroller

My JavaScript File name is TextScroller.js

And I'll end up having this line in my AssemblyInfo.cs

Collapse

[assembly: System.Web.UI.WebResource("MyTextScroller.TextScroller.js", "text/javascript")]>

Example 2

My Default Name Space is MyTextScroller

All my images are in images folder

My image name is nav-arrow-down-hover.gif

And I’ll end up having this line in my AssemblyInfo.cs

Collapse

[assembly: System.Web.UI.WebResource("MyTextScroller.images.nav-arrow-down.gif", "image/gif")]

TextScroller.cs

The TextScroller.cs will hold all the static HTML elements in the cmarquee2.htm. Please look at the code, is pretty straight forward. Here is a brief explanation.

Add design-time attributes to provide custom metadata that will be used to display the control in the visual designer at design time

Collapse

namespace MyTextScroller
{
    [   AspNetHostingPermission(SecurityAction.Demand, Level = AspNetHostingPermissionLevel.Minimal),
        AspNetHostingPermission(SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal),
        ParseChildren(true, "innerHTML"),
        DefaultProperty("innerHTML"),
        ToolboxData("<{0}:TextScroller runat="\""server\"> ") ]
    public class TextScroller : WebControl, INamingContainer
	{

Additional Reading/ Information

The ToolboxData attribute specifies the default tag generated for the TextScroller control when it is dragged from the Toolbox into a page at design time.

ParseChildren

AspNetHostingPermission

//Properties to adjust the width and height of the div and set the innerHTML od the div

Collapse

     #region Public Properties

        private Unit width = Unit.Pixel(260);
        public override Unit Width
        {
            get { return width; }
            set { EnsureChildControls(); width = value; }
        }

        private Unit height = Unit.Pixel(160);
        public override Unit Height
        {
            get { return height; }
            set { EnsureChildControls(); height = value; }
        }

//property to set the content of the Text Scroller
private string _innerHTML = "Your Content here";

        [   Browsable(true), //display this property in designer
            Category("Appearance"),
            DefaultValue("Your Content Here"),
            Description("The Content to Display."),
            Localizable(true),
            PersistenceMode(PersistenceMode.InnerDefaultProperty) ]
        public virtual string innerHTML
        {
            get
            {
                return _innerHTML;
            }
            set
            {
                EnsureChildControls(); _innerHTML = value; 
            }
        }	
        #endregion

Working with Web Resources in ASP.NET 2.0

Example - Images

Collapse

Image myImage = new Image();
ClientScriptManager cs = Page.ClientScript;
Type rsType = this.GetType();
myImage.ImageUrl = cs.GetWebResourceUrl(rsType, "MyTextScroller.images.nav-arrow-up.gif")

Example - JavaScript

Collapse

Type rsType = this.GetType();
this.Page.ClientScript.RegisterClientScriptInclude(
rsType, "TextScroller_Script_Name",
Page.ClientScript.GetWebResourceUrl(rsType, " MyTextScroller.TextScroller.js"));

Example - Style Sheets

Collapse

   
Type rsType = this.GetType();     
string csslink = "<link rel='stylesheet' type='text/css' href='" + 
	Page.ClientScript.GetWebResourceUrl(rsType, "MyTextScroller.TextScroller.css") + "' />";
LiteralControl include = new LiteralControl(csslink);
this.Page.Header.Controls.Add(include);

//using the embeded JavaScript and Style Sheet

Collapse

  
        protected override void OnInit(EventArgs e)
        {
            //Get the name of the Web Resource.
            base.OnInit(e);

            this.Page.ClientScript.RegisterClientScriptInclude(
                        this.GetType(), "TextScroller",
                        Page.ClientScript.GetWebResourceUrl(this.GetType(),
                        "Scroller.TextScroller.js"));

            // create the style sheet control and put it in the document header
            string csslink = @"<link rel='stylesheet' type='text/css' href='" + 
				Page.ClientScript.GetWebResourceUrl(this.GetType(), "Scroller.TextScroller.css") + "' />";
            LiteralControl include = new LiteralControl(csslink);

            this.Page.Header.Controls.Add(include);
        }

//write the output to the page that are in the cmarquee2.htm page

Collapse

		protected override void OnPreRender(EventArgs e)
        {
            base.OnPreRender(e);
        }

        protected override void Render(HtmlTextWriter output)
        {
            EnsureChildControls(); 
            output.Write(GenerateDiv());
        }

//create all the HTML Tag elemets
        private string GenerateDiv()
        {
			StringBuilder b = new StringBuilder();
            ClientScriptManager cs = Page.ClientScript;
            Type rsType = this.GetType();
			
			b.Append("<div style=\"width:");
            b.Append(width.Value);
			
            //see attached code ...
			....
         	return b.ToString();
        }
		
		protected override void CreateChildControls()
        {
            Controls.Clear();
        }

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e); 
        }    
    }
}

Individualizing the Control: Add a custom toolbox icon for the control

Create an icon from any of the links below. This is free.

dynamicdrive

genfavicon

What is the name of your class? For instance my class name is TextScroller

Collapse
```
public class TextScroller : WebControl, INamingContainer
```
Then I named the icon TextScroller.ico. Place it in the project root directory and change the Build Action to Embeded Resource

Adding the Control to the Toolbox

Go to View, Toolbox, Right click any place in the Toolbox, Add Tab, I name it MyTextScroller.

Right click MyTextScroller, Choose Items, .NET Framework Components Tab, Browse, find the MyTextScroller.dll, click Ok.

You should see something like this on the Toolbox.

How to test it? / Using the code

Add Refenence

Right click on the solution, Add, New Web Site, ASP.NET Web Site/ ASP.NET AJAX-Enabled Web Site

Right click the TestMyTextScroller, Add References, Project Tab, MyTextScroller project, Ok.

Drag the TextScroller from the Toolbox to the Default.aspx. Try one of the following

Collapse

<cc1:TextScroller ID="TextScroller1" runat="server" Height="100px">
		My test content here. 

		"http://blog.ysatech.com/" target="_blank">My Blog 

		More text here….
      </cc1:TextScroller>

Collapse

protected void Page_Load(object sender, EventArgs e)
    {
         TextScrollerContent();
    }

    internal void TextScrollerContent()
    {
        StringBuilder sbContent = new StringBuilder(string.Empty);
        
        sbContent.Append("My test content here. <br />");
        sbContent.Append("<a href=\"http://blog.ysatech.com\">My Blog <br />");
        sbContent.Append("More text here…");    
      
        TextScroller1.innerHTML = sbContent.ToString();
    }

You should see something like below:

Points of Interest

Do not use any custom server control from any unknown sources that have JavaScript embedded to it. Go through all the JavaScript and make sure that no potential malicious scripts embedded in it.

Next improvement:

Support multiple instances, currently this version work only with one instance of the TextScroller on the same page

Allow user to change the image button during design time

Conclusion

Here are the lists of items we have covered in this article:

How to create a Custom Server Control

How to embed resources

How to access embedded Resource

How to include custom toolbox icon

How to test the new control

References

http://aspalliance.com/726

http://www.dynamicdrive.com/dynamicindex2/cmarquee2.htm

http://www.codeproject.com/

http://msdn.microsoft.com/en-us/library/system.web.ui.control.ensurechildcontrols.aspx

http://msdn.microsoft.com/en-us/library/system.web.aspnethostingpermission.aspx

http://ondotnet.com/pub/a/dotnet/excerpt/progaspdotnet_14/index2.html

http://msdn.microsoft.com/en-us/library/system.web.ui.parsechildrenattribute.aspx

Split Strings Using XML

2009-08-01T07:14:00.001-07:00

This article would help developers looking to split strings in a single query using XML. We generally use a user defined function, which you all may have found at many places that splits the string based on the delimiter passed. But, when it comes to separate the string in a single query without any help of user defined function we often get panic. I have found a much optimized and shorter way of splitting any string based on the delimiter passed. I will be using the power of XML to do the same.

Let's say for example there is a string 'A,B,C,D,E' and I want to split it based on the delimiter ','. The first step would be to convert that string into XML, replacing the delimiter with some start and end XML tag.

Declare @xml as xml,@str as varchar(100),@delimiter as varchar(10)
SET @str='A,B,C,D,E'
SET @delimiter =','
SET @xml = cast(('<X>'+replace(@str,@delimiter ,'</X><X>')+'</X>') as xml)

Here as shown above, the delimiter ',' is replaced by </X><X> tags.
When you will see the output after converting the string into XML, you will be able to see the string as shown in the image below:

Once the string is converted into XML you can easily query that using XQuery.
SELECT N.value('.', 'varchar(10)') as value FROM @xml.nodes('X') as T(N)

This will give the output as a separated string as:

Now, say if I have a table as having an ID column and comma separated string as data column.

DECLARE @t TABLE( ID INT IDENTITY, data VARCHAR(50))

INSERT INTO @t(data) SELECT 'AA,AB,AC,AD'
INSERT INTO @t(data) SELECT 'BA,BB,BC'

I can use the method shown above to split the string.

select F1.id,

F1.data,
O.splitdata
from
(
select *,
cast('<X>'+replace(F.data,',','</X><X>')+'</X>' as XML) as xmlfilter
from @t F
)F1
cross apply
(
select fdata.D.value('.','varchar(50)') as splitdata
from f1.xmlfilter.nodes('X') as fdata(D)) O

First of all, cast the 'data' column of table @t into XML data type by replacing the delimiter by starting and ending tags
'<X></X>'.

I have used 'CROSS APPLY' for splitting the data. APPLY clause let's you join a table to a table-valued-function. The APPLY clause acts like a JOIN without the ON clause comes in two flavors:

CROSS and OUTER

The OUTER APPLY clause returns all the rows on the left side (@t) whether they return any rows in the table-valued-function or not. The columns that the table-valued-function returns are null if no rows are returned.

The CROSS APPLY only returns rows from the left side (@t) if the table-valued-function returns rows.

Executing the select statement mentioned above would display the following output:

This article might have made you clear of the power of XML and a very good use of 'CROSS APPLY'. There are other options to split strings in a single query using recursive CTEs.

Now whenever splitting of string is required you can easily cast the string into XML, by replacing the delimiter by XML start and end tags and then use the method shown above to split the string.

Provider Design Patterns in NET 2.0

2009-07-31T05:39:00.001-07:00

Download ProviderDesignPattern.zip - 4.01 MB

Source Article

Introduction
What are the benefits of the article ?
Application Architecture
Application Configuration
Provider Implementation
Restoring Database
Debugging code
Conclusion
References

Introduction

Provider Design Pattern is a new pattern that Microsoft formalized in ASP.NET Whidbey. The pattern was officially named in the summer of 2002 when Microsoft was designing Whidbey's new Personalization feature.
Benefits of Provider

No need to explicitly instantiate classes. The .NET framework will automatically manage class instantiation, including re-using classes that have already been instantiated. This will greatly improve the memory management of your application.
Switching data sources is much easier. Changing the source of data for your application from the current database to any database, whether SQL Server, Oracle, XML, or other, is a simple as replacing your existing concrete (implementer) class with a new concrete (implementer) class and inheriting from your provider class. That is all. Your presentation and business logic layers remain unchanged, thereby reducing effort required to switch data sources and the amount of regression testing required thereafter.
Learning the Provider Design concept will make it very easy to customize built-in .NET framework providers.

A provider implementation must derive from an abstract base class, which is used to define a contract for a particular feature.
For example, to create a Person provider for SQL, you create a new class SqlPersonProvider, which derives from PersonProvider. The base class of PersonProvider is ProviderBase . The ProviderBase class is used to mark implementers as a provider and forces the implementation of a required method and property common to all providers.

What are the benefits of the article ?

- Understanding the implementation of Provider Design Pattern
- Understanding the implementation of 3-tier architecture application
- Understanding the application architecture
- Naming Conventions

Note: I strongly suggest that you use the exact names that I use in this document to develop your solution for the purpose of learning this concept. Once you have tested and understand how it works, then you can integrate your own naming conventions.

Application Implementation

I developed an application, Phone Book, as desktop application to describe the provider idea.
The phone book application was developed with the use of 3 tier architecture as shown on application architecture.
Database objects like tables, fields and stored procedures are represented by object oriented classes, properties and methods on the provider infos of CompanyName library

The presentation layer calls the result from business logic layer and then data retrieved from database by the use of providers implemented at data access layer library.
Solution Projects [ 4 Projects]:

BusinessLogicLayer : The business logic layer of the application
CompanyName: it includes the global classes to all solution's projects
DataAccessLayer: The data access layer of the application
PhoneBookApplication: The presentation layer

Application Architecture

The following figure depicts the common tiers of a distributed application. This document distinguishes between business data and the business processes that use the data; the business process tier is discussed only where needed for clarification. Likewise, the presentation tier is discussed only where there are direct implications for the way data is represented, such as the way Microsoft® ASP.NET Web pages expose business data. Read More

the following diagram describes the architecture of all solution's projects:

The following diagram, ERD, is the database design of phonebook

The following diagram, Use-Case diagram, describe the main functionality of the application:

Now, we can discuss the implementation of each project:
(1) Open Visual Studio 2005
1- Create Windows Application and name it PhoneBookApplication
2- Choose File Menu --> Add --> New Project and name it BusinessLogicLayer
3- Choose File Menu --> Add --> New Project and name it DataAccessLayer
4- Choose File Menu --> Add --> New Project and name it CompanyName CompanyName :
this project will include common libraries that are globally used in the development and shared objects among projects
so you will add reference for CompanyName library to all other applications.
ex. i created the provider info classes to be shared among the "BussinessLogicLayer" and "DataAccessLayer" projects

(2) Add Reference to the below DLLs for the BusinessLogicLayer and DataAccessLayer

System.Web
System.Configuration
CompanyName

(3) Add references of "CompanyName" and "BusinessLogicLayer" to the desktop application

(4) Configuaring the App.config of the "PhoneBookApplication"
if you look to the xml elments in app.config, we define seciongroup named "PhoneBook" and added 2 sections to it which are "Person" and "Group"

Collapse

</sectionGroup>

then define that section group as:

Collapse

<add name="SqlPerson" type="CompanyName.PhoneBook.DataAccessLayer.SqlPersonProvider, DataAccessLayer"

connectionStringName="strcon" />

<add name="OraclePerson" type="CompanyName.PhoneBook.DataAccessLayer.OraclePersonProvider, DataAccessLayer"

connectionStringName="OracleConnection" />

<add name="AccessPerson" type="CompanyName.PhoneBook.DataAccessLayer.AccessPersonProvider, DataAccessLayer"

connectionStringName="AccessConnection" />

</providers>

</Person>

<Group>

<add name="SqlGroup" type="CompanyName.PhoneBook.DataAccessLayer.SqlGroupProvider, DataAccessLayer"

connectionStringName="strcon" />

</providers>

</Group>

</PhoneBook>

then define the connection strings for data stores of "SQL, Oracle and Access"

Collapse

</connectionStrings>

person provider could retrieve data from SQL,Oracle or Access database.
Group provider could retrieve data from SQL only (5) Implementing DataAccessLayer Suppose PhoneBook is a midsize business and the PhoneBookApplicaion contains 2 major sections: - Person : profile management
- Groups : categorization of persons The following code reads all providers defined in your web.config. That is all you have to do to make providers information available to other classes.

Collapse

using System;

using System.Configuration;

namespace CompanyName.PhoneBook.DataAccessLayer

{

public class SectionConfig : ConfigurationSection

{

[ConfigurationProperty("providers")]

public ProviderSettingsCollection Providers

{

get

{

return (ProviderSettingsCollection)base["providers"];

}

We need to create another class to have access to the Framework provider collection and to add our new provider(s) to the provider collection.

Collapse

using System;

using System.Configuration.Provider;

namespace CompanyName.PhoneBook.DataAccessLayer

{

public class ProviderList : ProviderCollection

{

public override void Add(ProviderBase provider)

{

if (provider == null) throw new ArgumentNullException("The provider parameter cannot be null.");

base.Add(provider);

}

Create another class that will initialize the provider by the provider name.
example: initialize the Group provider for SQLGroupProvider class using provider name of "SQLGroup"

Collapse

using System;

using System.Collections.Generic;

using System.Text;

using System.Web.Configuration;

using System.Configuration;

using CompanyName.PhoneBook.DataAccessLayer;

namespace CompanyName.PhoneBook.DataAccessLayer

{

public abstract class InitMember<T>

{

public static ProviderList Providers(string _providerSectionName)

{

SectionConfig qc = (SectionConfig)ConfigurationManager.GetSection(_providerSectionName);

providerCollection = new ProviderList();

// this wl instatiate PersonProvider with the class "personimpl" which inherit it

ProvidersHelper.InstantiateProviders(qc.Providers, providerCollection, typeof(T));

providerCollection.SetReadOnly();

return providerCollection;

}

private static ProviderList providerCollection;

}

The class takes the provider you want to initialize, i.e PersonProvider, its class and the provider name
This enum founded on CompanyName.Globals class

using that class from the Instance method of PersonProvider Class:

Collapse

/// <summary>

/// This will initialize the provider and add instanse to the providers list

/// </summary>

/// <param name="_Provider"></param>

/// <returns></returns>

public static PersonProvider Instance(Globals.Providers _Provider)

{

return (DataAccessLayer.PersonProvider)DataAccessLayer.InitMember

<DataAccessLayer.PersonProvider>.Providers("PhoneBook/Person")[_Provider.ToString()];

}

This method will initialize the provider and add instance to the providers list
Now our "DataAccessLayer" project has the necessary classes for all providers to be later developed.
so we are going to develop two providers:
- PersonProvider
- GroupProvider

· Now, we create our provider model:
BaseProvider --> xxxProvider --> SQLxxxProvider xxx is the name of entity like Person, Group, ....etc Person Provider Classes:

Group Provider Classes:

Let me explain the implementation of the PersonProvider and you can create GroupProvider by yourself: first we create a class named "PersonProvider.cs"

Collapse

using System;

using CompanyName.PhoneBook.Providers;

using System.Configuration.Provider;

using System.Configuration;

using System.Web.Configuration;

namespace CompanyName.PhoneBook.DataAccessLayer

{

public abstract class PersonProvider : ProviderBase

{

/// <summary>

/// This will initialize the provider and add instanse to the providers list

/// </summary>

/// <param name="_Provider"></param>

/// <returns></returns>

public static PersonProvider Instance(Globals.Providers _Provider)

{

return (DataAccessLayer.PersonProvider)DataAccessLayer.InitMember

<DataAccessLayer.PersonProvider>.Providers("PhoneBook/Person")[_Provider.ToString()];

}

/// <summary>

/// Add new person

/// </summary>

/// <param name="_info"></param>

/// <returns></returns>

public abstract bool Add(PersonInfo _info);

/// <summary>

/// Modify selected person

/// </summary>

/// <param name="_info"></param>

/// <returns></returns>

public abstract bool Modify(PersonInfo _info);

/// <summary>

/// Delete selected person

/// </summary>

/// <param name="_PersonId"></param>

/// <returns></returns>

public abstract bool Delete(int _PersonId);

/// <summary>

/// Get all personns

/// </summary>

/// <returns></returns>

public abstract PersonInfo[] Find();

/// <summary>

/// Get info of person

/// </summary>

/// <param name="_PersonId"></param>

/// <returns></returns>

public abstract PersonInfo GetInfo(int _PersonId);

/// <summary>

/// Get personns that match a given criteria

/// </summary>

/// <param name="_Searchinfo"></param>

/// <returns></returns>

public abstract PersonInfo[] Find(SearchCriteriaInfo _Searchinfo);

}

Instance() method : is responsible for instantiating our concrete (implementer) class (SqlGeneralProvider.cs), which has been defined within Web.config. and "PersonProvider" abstract class, which it inherits from ProviderBase and include person abstracted functions. (6)
BusinessLogicLayer

Note: It is a good idea to add a Helper class into your BusinessLogicLayer project. This way, you can expose some common functionality to all of your BusinessLogicLayer classes just by inheriting from this helper class.

Collapse

using System;

using System.Collections.Generic;

using System.Text;

using System.Web;

namespace CompanyName.PhoneBook.BusinessLogicLayer

{

/// <summary>

/// You can use helper to provide common info./data needed OR to massage or add more info.

/// to your data before sending it to presentation.

/// </summary>

public abstract class Helper

{

protected static string MachineName

{

get

{

return Environment.MachineName;

}

// Add more methods/properties below

}

then define the business classes for the Person and Group providers.
Person.cs

Collapse

using System;

using System.Collections.Generic;

using System.Text;

using CompanyName.PhoneBook.Providers;

using CompanyName.PhoneBook.DataAccessLayer;

namespace CompanyName.PhoneBook.BusinessLogicLayer

{

public abstract class Person : Helper

{

static PersonProvider objPersonProvider;

/// <summary>

/// Person Cnstructor

/// </summary>

//Class Constructor: will be invoked 1 time only / Appdomain

static Person()

{

objPersonProvider = PersonProvider.Instance(Globals.Providers.SqlPerson);

}

// staticed methods for person

/// <summary>

/// Add new person

/// </summary>

/// <param name="_info"></param>

/// <returns></returns>

public static bool Add(PersonInfo _info)

{

// You can use helper to provide common info./data needed OR to

// massage or add more info. to your data before sending it to

// presentation.

// Here we use helper class to get MachineName and pass it along

// with data to presentation.

return objPersonProvider.Add(_info);

}

/// <summary>

/// Modify selected person

/// </summary>

/// <param name="_info"></param>

/// <returns></returns>

public static bool Modify(PersonInfo _info)

{

return objPersonProvider.Modify(_info);

}

/// <summary>

/// Delete selected person

/// </summary>

/// <param name="_PersonId"></param>

/// <returns></returns>

public static bool Delete(int _PersonId) { return objPersonProvider.Delete(_PersonId); }

/// <summary>

/// Get all personns

/// </summary>

/// <returns></returns>

public static PersonInfo[] Find() { return objPersonProvider.Find(); }

/// <summary>

/// Get info of person

/// </summary>

/// <param name="_PersonId"></param>

/// <returns></returns>

public static PersonInfo GetInfo(int _PersonId) { return objPersonProvider.GetInfo(_PersonId); }

/// <summary>

/// Get personns that match a given criteria

/// </summary>

/// <param name="_Searchinfo"></param>

/// <returns></returns>

public static PersonInfo[] Find(SearchCriteriaInfo _Searchinfo) { return objPersonProvider.Find(_Searchinfo); }

}

define objPersonProvider as PersonProvider to be shared among the instances of Person class. Then initialize it on the class constructor which will be invoked for one time/ Appdomain

Collapse

Person objPerson_1 = new Person(); // on class A

Person objPerson_2 = new Person(); // on class B

Person objPerson_3 = new Person(); // on class C

//Class Constructor: will be invoked 1 time only / Appdomain

static Person()

{

objPersonProvider = PersonProvider.Instance(Globals.Providers.SqlPerson);

}

The objPersonProvider will be initialized with the objPerson_1 constructor only on the class A, then other instances like objPerson_2 or objPerson_3 will use the static object objPersonProvider. you can add you business logic to every method before calling the data access provider as

Collapse

public static bool Add(PersonInfo _info)

{

// Here: you can add you business logic to every method before calling the data access provider

return objPersonProvider.Add(_info);

}

PhoneBook Application

The presentation layer as desktop application for implementing the business logic to the client. <image31>
How to use the BL layer from the presentation layer ? sample code

Collapse

// build the search criteria

SearchCriteriaInfo objSearchInfo = new SearchCriteriaInfo();

objSearchInfo.FilterNameBy = (Globals.FilterNameBy)this.cboName.SelectedValue;

objSearchInfo.GroupId = (int)cboGroup.SelectedValue;

objSearchInfo.Name = txtName.Text.Trim();

if(chkFrom.Checked)

objSearchInfo.FromDate = datefrom.Value;

if(chkTo.Checked)

objSearchInfo.ToDate = dateto.Value;

objSearchInfo.SortBy = (rdoasc.Checked) ? Globals.SortBy.Asc : Globals.SortBy.Desc;

objSearchInfo.SortByBirthDate = chkbirthdate.Checked; ;

objSearchInfo.SortByGroup = chkGroup.Checked;

objSearchInfo.SortByName = chkName.Checked;

objSearchInfo.SortByTele = chkTele.Checked;

objSearchInfo.TeleNumber = txtTeleNumber.Text.Trim();

objSearchInfo.TelephoneType = (Globals.TelephoneTypes)this.cboTeleTypes.SelectedValue;

// get result from bus logic layer

PersonInfo[] objresult = Person.Find(objSearchInfo);

How to save and retrieve image from database ?Save to database:
save the image from the picturebox to MemoryStream and then save it on database as Byte[]

Collapse

// prapare the image

if (null != imgperson.Image) // picturebox control

{

MemoryStream stream = new MemoryStream();

imgperson.Image.Save(stream, System.Drawing.Imaging.ImageFormat.Jpeg);

info.Image = stream.ToArray();

}

Retrieve from database:

Collapse

// display the image

byte[] PImage = info.Image;

if (null != PImage)

{

MemoryStream stream = new MemoryStream(PImage);

imgperson.Image = Image.FromStream(stream);

}

Restoring Database on SQL Server 2005

Attach the database AhmedEid_PhoneBook.mdf from the directory DataBase on the root directory to the SQL Server Engine.

Debugging Scenario

Let us debug the advanced search button code to retrieve results with criteria from the client
the following scenario will lead you to understand the Provider implementation

make breakpoints as the following
1- AdvancedSearch form class ( presentation layer )

2- Person class of BusinessLogicLayer ( BLL layer )

3- PersonProvider Class of DataAccessLayer ( DAL layer )

4- InittMember<T> class of DataAccessLayer ( DAL layer )

the above code will provide and add the SqlPersonProvider class to the providers list to be available for any usage.

5- SqlGroupProvider class of DataAccesslayer ( DAL layer )

Note: After debugging the code for 1st time , the providers (PersonProvider and groupProvider) will be added to the System.Configuration.Provider.ProviderCollection and for 2nd time the results will be retrieved without instantiating the classes again.

References
- http://msdn.microsoft.com/en-us/library/ms972319.aspx
- http://msdn.microsoft.com/en-us/library/ms972370.aspx
- http://msdn.microsoft.com/en-us/library/ms978496.aspx
- http://en.wikipedia.org/wiki/Design_Patterns
- http://www.c-sharpcorner.com/UploadFile/webmaster3/ProviderPattern12242007184126PM/ProviderPattern.aspx

Top of Form

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

About the Author

Ahmad Eid Salim

Member

Bottom of Form

SQL Server 2005 - Merge Replication Step by Step Procedure

2009-07-31T05:29:00.001-07:00

Introduction

Replication is a set of technologies for copying and distributing data and database objects from one database to another and then synchronizing between databases to maintain consistency. Using replication, you can distribute data to different locations and to remote or mobile users over local and wide area networks, dial-up connections, wireless connections, and the Internet.

Replication is the process of sharing data between databases in different locations. Using replication, we can create copies of the database and share the copy with different users so that they can make changes to their local copy of database and later synchronize the changes to the source database.

Terminologies before getting started:

Microsoft SQL Server 2000 supports the following types of replication

Publisher is a server that makes the data available for subscription to other servers. In addition to that, publisher also identifies what data has changed at the subscriber during the synchronizing process. Publisher contains publication(s).

Subscriber is a server that receives and maintains the published data. Modifications to the data at subscriber can be propagated back to the publisher.

Distributor is the server that manages the flow of data through the replication system. Two types of distributors are present, one is remote distributor and the other one local distributor. Remote distributor is separate from publisher and is configured as distributor for replication. Local distributor is a server that is configured as publisher and distributor.

Agents are the processes that are responsible for copying and distributing data between publisher and subscriber. There are different types of agents supporting different types of replication.

Snapshot Agent is an executable file that prepares snapshot files containing schema and data of published tables and database objects, stores the files in the snapshot folder, and records synchronization jobs in the distribution database.

An article can be any database object, like Tables (Column filtered or Row filtered), Views, Indexed views, Stored Procedures, and User defined functions.

Publication is a collection of articles.

Subscription is a request for copy of data or database objects to be replicated.

Replication Types

Microsoft SQL Server 2005 supports the following types of replication:

Snapshot Replication
Transactional Replication
Merge Replication

Snapshot Replication

Snapshot replication is also known as static replication. Snapshot replication copies and distributes data and database objects exactly as they appear at the current moment in time.
Subscribers are updated with complete modified data and not by individual transactions, and are not continuous in nature.
This type is mostly used when the amount of data to be replicated is small and data/DB objects are static or does not change frequently.

Transactional Replication

Transactional replication is also known as dynamic replication. In transactional replication, modifications to the publication at the publisher are propagated to the subscriber incrementally.
Publisher and the subscriber are always in synchronization and should always be connected.
This type is mostly used when subscribers always need the latest data for processing.

Merge replication

It allows making autonomous changes to replicated data on the Publisher and on the Subscriber. With merge replication, SQL Server captures all incremental data changes in the source and in the target databases, and reconciles conflicts according to rules you configure or using a custom resolver you create. Merge replication is best used when you want to support autonomous changes on the replicated data on the Publisher and on the Subscriber.

Replication agents involved in merge replication are snapshot agent and merge agent.

Implement merge replication if, changes are made constantly at the publisher and subscribing servers, and must be merged in the end.

By default, the publisher wins all conflicts that it has with subscribers because it has the highest priority. Conflict resolver can be customized

Before starting the replication process:

assume that we have 2 server:

EGYPT-AEID: is the publisher server ( contains HRatPublisher )
SPS: is the subscriber server ( contains HRatSubscriber ) use SQL server Authentication mode for login

on the publisher database i created table: Employees with fields of (ID, Name, Salary) to replicate its data to the subscriber server.

i will use publisher as subscriber also

Note: Check that SQL Server Agent is running on the publisher and the subscriber

Steps:

Open SQL Server Management Studio and login with SQL Server Authentication to configure Publishing, Subscribers, and Distribution

a- Configure the appropriate server as publisher or distributor.

b- Enable the appropriate database for merge replication

2- Create new local publication from DB-Server --> Replication --> Local Publications --> Right Click --> New Pub

then choose the database that contains the data or objects you want to replicate

then choose the replication type and then specify the SQL server versions that will be used by subscribers to that publication like SQL Server 2005, SQL mobile Edition, SQL for Win CE ....etc

after that manage the replication articles, data and db objects, by choosing objects to be replicated

Note: you can manage the replication properties for selected objects

Then add filters to published tables to optimize performance and then configure the snapshot agent

and configure the security for snapshot agent

finally rename the publication and click finish

3- create a new subscription for the created "MyPublication01" Publication by right click on MyPublication01 --> New Subscription

that to configure the "Merge Agent" for replication on the subscriber database

then choose one or more subscriber databases. you can add new SQL Server subscribers

then specify the Merge Agent security as mentioned above on "Agent Snapshot"

and so specify the synchronization schedule for each agent.

Schedules:

Run Continuously: add schedule times to be auto run continuously
Run on demand only: manually run the synchronization

and then next up to final step, then click finish

you can check the errors from "Replication Monitor" by right click on Local Replication --> Launch Replication Monitor

Advantages in Replication:

Users can avail the following advantages by using replication process:

Users working in different geographic locations can work with their local copy of data thus allowing greater autonomy.
Database replication can also supplement your disaster-recovery plans by duplicating the data from a local database server to a remote database server. If the primary server fails, your applications can switch to the replicated copy of the data and continue operations.
You can automatically back up a database by keeping a replica on a different computer. Unlike traditional backup methods that prevent users from getting access to a database during backup, replication allows you to continue making changes online.
You can replicate a database on additional network servers and reassign users to balance the loads across those servers. You can also give users who need constant access to a database their own replica, thereby reducing the total network traffic.
Database-replication logs the selected database transactions to a set of internal replication-management tables, which can then be synchronized to the source database. Database replication is different from file replication, which essentially copies files.

Replication Performance Tuning Tips:

By distributing partitions of data to different Subscribers.
When running SQL Server replication on a dedicated server, consider setting the minimum memory amount for SQL Server to use from the default value of 0 to a value closer to what SQL Server normally uses.
Don’t publish more data than you need. Try to use Row filter and Column filter options wherever possible as explained above.
Avoid creating triggers on tables that contain subscribed data.
Applications that are updated frequently are not good candidates for database replication.
For best performance, avoid replicating columns in your publications that include TEXT, NTEXT or IMAGE data types.

Source

Model View Presenter (MVP) design pattern and data binding

2009-07-30T15:11:00.001-07:00

Sourse Here

Introduction
Model View Presenter (MVP) design pattern is the evolution of the MVC design pattern and it's aimed at providing a cleaner separation of concerns between the view, the model, and the controller improving the architecture (you can use several UI technologies without recompiling the business logic components) and testability of the enterprise solution. The pattern was originally developed at Taligent in the 1990s.
In this article, I will explain the principles and how to use the MVP design pattern along with data binding with an example using C# language in Microsoft.NET.
The Model View Presenter (MVP) design pattern
Starting from the Model View Controller (MVC) design pattern, creators of MVP neatly separated the model from the view/controller pair. The core of MVP is the strictly regulated interaction taking place between the view and the controller. In MVP, this controller is renamed to presenter.
In the Figure 1, you can see an overview of the MVP design pattern.

Figure 1
As you can see in the Figure 1, the view and model are neatly separated (they don't know each other) and the view exposes an interface for the communication of the presenter with the view and in this way the presenter doesn't know the underlying UI technology and the view is mockable for testing purposes. As well as the presenter knows the model and can invoke its operations.
Note that each Presenter object has exactly one reference to a View object, and each View object has exactly one reference to a Presenter object. There is one Model object for the whole application. As you can see it's required to define an interface and a presenter for every View object of your application (each Web form in ASP.NET and form in Windows).
Let's explain the MVP triad at a glance.
The Model represents the business objects of the domain problem. That is business entities encapsulating the data, business services implementing the business logic and rules of your solution. It's a domain object and should have no knowledge of the user interface, unlike previous design patterns such as MVC (Model-View-Controller) where the model implements the user interface to manipulate it which is a big design error if you try to separate the concerns of the domain.
The View is responsible to display the content of the model and interact with the user's events regarding the UI technology of the solution.
The Presenter is responsible to interpret the user's events and the communication with the model objects. It implements the main workflow of the application. This is where the heart of the application lies.
It's remarkable to say that Martin Fowler has extended the original MVP design pattern with Passive View and Supervising Controller/Presenter.
In the case of the Passive View pattern, the main idea is to have no dependencies between the View and the Model concerns and the view is dumb. The Supervising Controller is a flexible interpretation of the original MVP design pattern and the view is not completely dumb and has some responsibilities.
Now well, my approach, to architect an enterprise-class application for being implemented using Microsoft technologies, is to separate concerns in multiple layers and follow the MVP design patter along with data binding (data binding using BindingSource support in Windows applications and data binding with ObjectDataSource support in ASP.NET applications). The View has some responsibilities such as displaying, formatting and gathering data as well as handling user interaction's events. The Presenter has the responsibility to interpret the messages sent and received from the View as well as to invoke the underlying business objects in the business logic layer in the Model. Now, the communication between the layers of the application is through Data Transfer Objects (DTO). The use of DTO is trade-off because we create new DTO, we're increasing the cost of the complexity of the solution and this cost is justified in large enterprise applications. For small and medium application, it makes sense to reference the business objects directly from the View concern (and bind the data represented by the business object in the controls) in order to avoid the definition of new DTO. The idea is to use the data model represented by the business object as the DTO. But it's not correct to invoke operations and business logic directly from the View (data access methods, calculation, invocation of external services, etc).
The solution, which I will explain in this article, will be based on the MVP design pattern along with data binding for small enterprise application.
Implementing the Model View Presenter (MVP) design pattern
Now let's go and implement the principles and concepts of the Model View Presenter (MVP) design pattern along with data binding in a multi-layer enterprise application using C# in Microsoft.NET.
Let's open the Visual Studio.NET 2008 IDE and create an example solution (see Figure 2).

Figure 2
For this example, we're going to create an application which enables managing the contacts of one enterprise. The data source is the Person.Contact table in the AdventureWorks database shipped with SQL Server 2005.
Let's add the business logic layer using a Class Library project (see Figure 3).

Figure 3
Next step is to add the business entities and objects which model your problem domain (see Listing 1). For the definition of the business entities we're going to use strongly typed Data Set and for the data access code we're going to rely on the underlying table adapters.
Let's add a DataSet to the project named DSContactManager as shown in the Figure 4.

Figure 4
Let's add a Contact data table and its underlying table adapter (see Figure 5).

Figure 5
Now let's add the business service objects to implement the business logic concerning the Contact business entity (see Figure 6).

Figure 6
The code definition for the business services regarding the contact entity is the Listing 1.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BusinessLogicPkg
{
public class ContactBizServices
{
private DSContactManager m_dsContact;

public ContactBizServices(DSContactManager dsContact)
{
this.m_dsContact = dsContact;
}

public void Load()
        {
            DSContactManagerTableAdapters.ContactTableAdapter taContact = new BusinessLogicPkg.DSContactManagerTableAdapters.ContactTableAdapter();
            taContact.Fill(this.m_dsContact.Contact);
        }

public void Save()
        {
            DSContactManagerTableAdapters.ContactTableAdapter taContact = new BusinessLogicPkg.DSContactManagerTableAdapters.ContactTableAdapter();
            taContact.Update(this.m_dsContact.Contact);
        }
    }
}
Listing 1
Now let's add the Presentation layer where the presenter objects lies using a Class Library project (see Figure 7).

Figure 7
We need to add a reference to the business logic layer in the PresentationLayer as in the Figure 8.

Figure 8
Next step is to add the ContactManagerPresenter class to handle the workflow for the communication between the UI controls and the model objects as well as to add the IContactManagerView interface to define the interface to be implemented by the underlying UI artifacts which need to communicate with the Presenter artifact.
In order to define the IContactManagerView interface, we deal with the user stories and requirements and in this case, we want to load contact data, to be changed and then save the changes. We need to access to the data model (the strongly typed Data Set DSContactManager) as the DTO and send a message to the user notifying the status of the performed operation (see Listing 2).
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using BusinessLogicPkg;

namespace PresentationLayerPkg
{
public interface IContactManagerView
{
DSContactManager ContactManager { get; }
void SendMessageInfo(string strMessage);
}
}
Listing 2
Now let's define the workflow of the presenter object as shown in Listing 3.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using BusinessLogicPkg;

namespace PresentationLayerPkg
{
public class ContactManagerPresenter
{
private IContactManagerView m_objContactManagerView = null;

public ContactManagerPresenter(IContactManagerView objContactManagerView)
{
this.m_objContactManagerView = objContactManagerView;
}

public void LoadContact()
        {
ContactBizServices objContactBizServices = new ContactBizServices(this.m_objContactManagerView.ContactManager);
            objContactBizServices.Load();
this.m_objContactManagerView.SendMessageInfo("Operation has successfully ended");
        }

public void SaveContact()
        {
ContactBizServices objContactBizServices = new ContactBizServices(this.m_objContactManagerView.ContactManager);
            objContactBizServices.Save();
this.m_objContactManagerView.SendMessageInfo("Operation has successfully ended");
        }

}
}
Listing 3
Now let's go to the Windows Forms project to define the user interface and communication with the Presenter artifact.
Fist step is to add a reference to the PresentationLayerPkg library as shown in Figure 9.

Figure 9
We need to a reference to the BusinessLogicPkg library as well because we're going to use the data model as our Data Transfer Object (DTO) (see Figure 10).

Figure 10
Now let's add a data source object. Open the Data Sources window and click on the Add New Data Source link to open the Data Source Configuration Wizard. Then select the DSContactManager object in the BusinessLogicPkg library (see Figure 11).

Figure 11
Then drag and drop the defined data source onto the form as a grid control. This action adds a DataGrid control and a binding navigator control in the form. Delete the save icon on the binding navigator to do the load and save actions manually.
Next step is to drag and drop two buttons on the form (one to load the data and the other to save the date after changes) and the underlying event handlers.
Next step is to implement the view interface defined in the presenter library. We need to return an instance of the DSContactManager and show an information message (see Listing 4).
#region IContactManagerView Members

public BusinessLogicPkg.DSContactManager ContactManager
        {
get
            {
return this.dSContactManager;
            }
        }

public void SendMessageInfo(string strMessage)
        {
            System.Windows.Forms.MessageBox.Show(strMessage, "Information Message", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
        #endregion
Listing 4
And the implementation of the event handlers is done by invoking the underlying methods in the presenter artifact (see Listing 5).
private void btnLoad_Click(object sender, EventArgs e)
        {
ContactManagerPresenter objContactManagerPresenter = new ContactManagerPresenter(this);
            objContactManagerPresenter.LoadContact();
        }

private void btnSave_Click(object sender, EventArgs e)
        {
ContactManagerPresenter objContactManagerPresenter = new ContactManagerPresenter(this);
            objContactManagerPresenter.SaveContact();
        }
Listing 5
The complete code for the Windows forms is shown in the Listing 6.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using PresentationLayerPkg;

namespace WinMVPDatabinding
{
public partial class Form1 : Form, IContactManagerView
    {
public Form1()
        {
            InitializeComponent();
        }

private void btnLoad_Click(object sender, EventArgs e)
        {
ContactManagerPresenter objContactManagerPresenter = new ContactManagerPresenter(this);
            objContactManagerPresenter.LoadContact();
        }

#region IContactManagerView Members

public BusinessLogicPkg.DSContactManager ContactManager
        {
get
            {
return this.dSContactManager;
            }
        }

#endregion
}
}
Listing 6
The Figure 12 shows when you run the application.

Figure 12
Conclusion
In this article, I've explained the concepts of the Model View Presenter (MVP) design pattern along with data binding through an example.

One way, two way and one time bindings using Silverlight

2009-07-30T15:07:00.001-07:00

Introduction

Source Here

This article will talk about three ways of binding object properties with SilverLight user interfaces. We will first go through the fundamentals of the 3 bindings and then take up a small sample which will demonstrate how the binding works. We have also attached the source for the same.

Other Silverlight FAQ

In case you are a complete fresher to silverlight then below are some silverlight FAQ's which can give you a quick start in this topic.

Silverlight FAQ Part 1:- For article click here This tutorial has 21 basic FAQ's which will help you understand WPF, XAML, help your build your first silverlight application and also explains the overall silverlight architecture.

SilverLight FAQ Part 2 (Animations and Transformations):- For article click here This tutorial has 10 FAQ questions which starts with silverlight animation fundamentals and then shows a simple animated rectangle. The article then moves ahead and talks about 4 different ways of transforming the objects.

One way bindings

As the name so the behavior. In one way bindings data flows only from object to UI and not vice-versa. For instance you can have a textbox called as 'TxtYear' which is binded with an object having property 'Year'. So when the object value changes it will be reflected on the silverlight UI, but the UI cannot update the year property in the object.

It is a three step procedure to implement one way binding. First create your class which you want to bind with the silverlight UI. For instance below is a simple class called as 'ClsDate' with a 'Year' property.

public class clsDate
{
private int _intYear;
public int Year
    {
set
        {
            _intYear = value;
        }
get
        {
return _intYear;
        }
    }
}

In the second step you need to tie up the 'Year' property with a silver light UI text box. To bind the property you need to specify 'Binding Path=Year' in the text property of the text box UI object. 'Year' is the property which we are binding with the text box UI object.

The final step is to bind the text box data context with the date object just created.

public partial class Page : UserControl
{
public Page()
    {
        InitializeComponent();
clsDate objDate = new clsDate();
        objDate.Year = DateTime.Now.Year;
        txtCurrentYear.DataContext = objDate;
    }
}

Two way binding

Two way binding ensure data synchronization of data between UI and Objects. So any change in object is reflected to the UI and any change in UI is reflected in the object.

To implement two way binding there are two extra steps with addition to the steps provided for 'OneWay'. The first change is we need to specify the mode as 'TwoWay' as shown in the below XAML code snippet.

Second change is we need to implement 'INotifyPropertyChanged' interface. Below is the class which shows how to implement the 'INotifyPropertyChanged' interface. Please note you need to import 'System.ComponentModel' namespace.

public class clsDate : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
private int _intYear;
public int Year
    {
set
        {
            _intYear = value;
            OnPropertyChanged("Year");
        }
get
        {
return _intYear;
        }
    }
private void OnPropertyChanged(string property)
    {
if (PropertyChanged != null)
        {
            PropertyChanged(this,new PropertyChangedEventArgs(property));
        }
    }
}

The binding of data with data context is a compulsory step which needs to be performed.

One time binding

In one time binding data flows from object to the UI only once. There is no tracking mechanism to update data on either side. One time binding has marked performance improvement as compared to the previous two bindings discussed. This binding is a good choice for reports where the data is loaded only once and viewed.

Simple demonstration of OneWay and TwoWay

Below is a simple sample code where in we have two text boxes one takes in the age and the other text box calculates the approximate birth date.

Below is a simple class which has both the properties. We have implemented 'INotifyPropertyChanged' interface so that we can have two way communication for the year property.

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.ComponentModel;
namespace SilverLightBinding
{
public class clsDate : INotifyPropertyChanged
    {
public event PropertyChangedEventHandler PropertyChanged;
private int _intYear;
private int _intAge;
public int Year
        {
set
            {
                _intYear = value;
                OnPropertyChanged("Year");
            }
get
            {
return _intYear;
            }
        }
public int Age
        {
set
            {
                _intAge = value;
                Year = DateTime.Now.Year - _intAge;
            }
get
            {
return _intAge;
            }
        }
private void OnPropertyChanged(string property)
        {
if (PropertyChanged != null)
            {
                PropertyChanged(this,
new PropertyChangedEventArgs(property));
            }
        }
    }
}

Finally we have also binded the SilverLight UI objects with the class properties. Below is the XAML snippet for the same. One point to be noted is that 'Age' is bounded using two way mode as we need to modify the same from the user interface.

<TextBlock VerticalAlignment="Center" HorizontalAlignment="Center"> Enter your age in the below text box</TextBlock>
<TextBox x:Name="txtEnterAge" Text="{Binding Path=Age, Mode=TwoWay}" Height="30" Width="150" VerticalAlignment="Center" HorizontalAlignment="Center"></TextBox>
<TextBlock VerticalAlignment="Center" HorizontalAlignment="Center">Your approximate birth date</TextBlock>
<TextBox x:Name="txtCurrentYear" Text="{Binding Path=Year}" Height="30" Width="150" VerticalAlignment="Center" HorizontalAlignment="Center"></TextBox>

At the top of this article you can get the Source Code.

Blocking IP Addresses Using MMC

2009-07-30T15:02:00.001-07:00

I was searching for a solution to block any communication with specific IP addresses. I have come to this solution using MMC (Microsoft Management Console). The following steps will allow you to block any communication - whatever the protocol is - with specific IP addresses or subnet:
1. Open Start Manu > Run > Write "MMC". Then press Enter.
2. In the Management Console > File > Add/Remove Snap-in...
3. In the opened dialog, leave "Local Computer" as it's and click "Finish".

4. You will have a new node in the left tree called: "IP Secuirty Policies in Local Computer".
5. Right click on this node and select "Create IP Security Policy".
6. In the opened dialog, write "Block IP".
7. Click Next till the end of the wizard and then "Finish".
8. You will have an item in the left pane called: "Block IP". Right click on it and select "Properties".

9. In the opened dialog, click "Add".
10. Go through the wizard, till you reach a step called: "IP Filter List".
11. Click "Add". IP Filter Dialog will open.

12. Modify the name of your IP Filter and click "Add" to add an IP filter policy.
13. Click "Next. Leave "Source Address" as "My IP Address".
14. In the destination address, you can select "A specific IP Address". You can also filter by DNS or subnet. Enter the IP address to block. Then click Next.

15. Leave the protocol to be "Any" and click "Next".
16. Then click "Finish".
17. Apply all changes, and close all the opened windows. You may have to add "Block" action if it doesn't exist.
18. After you finish, don't forget to write click on "Block IP" policy and select "Assign".

Use Gmail IMAP in Microsoft Outlook 2007

2009-07-29T00:43:00.001-07:00

We’ve all been hearing about the new IMAP support in Gmail, but how do we access that from Outlook? Those of you that have been waiting patiently will be happy to know all the instructions are on this page.

Using IMAP we can synchronize email across multiple devices, since the mail stays on the server. You already stopped reading this part and skipped down to the instructions, didn’t you?

Enable IMAP in Gmail Settings

Open your Settings panel in Gmail, and then click on the “Forwarding and POP/IMAP” tab.

Now click the Enable IMAP radio button, and click Save Changes.

Add Account to Outlook

Use the Tools menu you to open the Account Settings panel.

If this is your first account you’ll be prompted for the wizard, otherwise you’ll need to click the New button under the E-mail tab.

Now select the “Microsoft Exchange, POP3, IMAP or HTTP” option and hit next.

Select the checkbox for “Manually configure server settings” and everything on that page will gray out. Hit the next button again.

Now select “Internet E-mail” (Didn’t we just do this? This wizard is taking too long…)

Finally we can enter some settings! Add in all your personal information here.

Note: If you are outside of the US you may need to use imap.googlemail.com and smtp.googlemail.com instead of imap.gmail.com and smtp.gmail.com.

Note: for Gmail Apps accounts, you’ll need to put in your full email address wherever you see an @gmail.com above. For instance, if your account was geek@howtogeek.com you would put that in the E-mail address field as well as the User Name field.

Click on the “More Settings” button and find the Outgoing Server tab, where you’ll need to check the box for “My outgoing server requires authentication”

Now choose the Advanced tab, and enter the following values (Very important)

· Incoming Server: 993

· Incoming Server encrypted connection: SSL

· Outgoing Server: 587

· Outgoing Server encrypted connection: TLS

Note: If you are having an issue with your sent email not showing up in Gmail, you can use the Folders tab, and then select the [Gmail] \ Sent Mail folder.

Note: Only do this step if your mail is not showing up, otherwise it will duplicate the sent mail.

Now that you’ve closed out that dialog, you can click the Test Account Settings button to make sure everything is going to work.

If all goes well, you should see a success message.

Note: Some ISPs restrict outgoing mail, so if you have a problem sending a test message you’ll need to consult with their documentation.

Accessing Your Mail

Now that everything is working you’ll notice a new set of folders for your Gmail account. (I’m using Gmail apps, which is why you don’t see an @gmail.com email address)

All of your labels will show up as separate folders, and the built-in “folders” in Gmail will be under the new [Gmail] folder.

Outlook Flags = Gmail Stars

If you want to star a message in Gmail, you just need to flag it in Outlook. When I flagged this message from Mysticgeek…

It shows up in Gmail as a starred message. (And it works the other way too)

Sending Email from Outlook

To send a new email from your Gmail account, just change the “Account” drop-down to your Gmail address before you send a message.

Note that if you only use Gmail, you won’t have this drop-down and it will default to your Gmail.

Final Thoughts

Here’s a few things to keep in mind:

· Gmail Labels = Outlook Folders. To label a message, add it to a folder.

· Gmail Stars = Outlook Flags.

· Do Not move spam messages to the “Junk E-mail” folder in Outlook, move them to the [Gmail] \ Spam folder.

· Outlook has a built-in Search Folder for “Large Mail”, which will let you easily find messages with large attachments.

Now that you can access your starred and labeled messages, you can start using Outlook’s excellent Search Folders to find messages more easily.

Chapter 8 Continued: Caching Client/Server Applications

2009-07-12T19:54:00.000-07:00

Caching is one of the first techniques used to improve the performance of web browsers and web servers. The browser cache makes network lookup operations unnecessary because a recent copy of the file is kept in the local cache, and the web server cache reduces the cost of loading the file from disk for each request. This section explains how you can use caching in a similar way to improve performance in many client/server applications written in the Java programming language.

The java.util.Collections API available in the Java® 2 Software Development Kit (SDK) software makes implementing a cache simple. This API provides the HashMap class, which works well for caching one object, and the LinkedList class, which works well in combination with the HashMap class for caching many objects.

Caching One Object
Caching Many Objects

Caching One Object

A HashMap object stores data in key and value pairs. When you put a data value in the HashMap, you assign it a key and later use that key to retrieve the data.

A HashMap object is very similar to a Hashtable and can be used to keep a temporary copy of previously generated results. Objects kept in the HashMap cache could, for example, be a list of completed auction results.

In this case, the results of a JDBC query might be requested hundreds of times a second by persons wanting to know who was the highest bidder, but the completed results lists only actually changes once a minute as each auction completes. You can write your program to retrieve unchanged objects from the results cache instead of querying the database every time and gain a significant performance improvement.

This code example runs a database query once a minute, and returns cached copies for requests that come between the queries.

 
import java.util.*;
import java.io.*;
 
class DBCacheRecord {
  Object data;
  long time;
 
  public DBCacheRecord(Object results, long when) {
    time=when;
    data=results;
  }
  public Object getResults() {
	return data;
  }
  public long getLastModified() {
	return time;
  }
}
 
public class DBCache {
  Map cache;
 
  public DBCache() {
    cache = new HashMap();
  }
 
  public Object getDBData(String dbcommand) {
    if(!cache.containsKey(dbcommand)) {
	synchronized(cache) {	
	  cache.put(dbcommand, readDBData(dbcommand)); 
        }
     } else {
       if((new Date().getTime() ) -
         ((DBCacheRecord)cache.get(
		dbcommand)).getLastModified()>=1000) {
	 synchronized(cache) {	
	   cache.put(dbcommand, readDBData(dbcommand)); 
         }
       }	
     }
     return ((DBCacheRecord)cache.get(
	dbcommand)).getResults();
  }
 
  public Object readDBData(String dbcommand) {
 
/*Insert your JDBC code here For Example:
  ResultSet results=stmt.executeQuery(dbcommand);
*/
    String results="example results";
    return(new DBCacheRecord(results,new 
			     Date().getTime()));
	
  }
 
  public static void main(String args[]) {
    DBCache d1=new DBCache();
    for(int i=1;i<=20;i++) {
	d1.getDBData(
	  "select count(*) from results where 
	  TO_DATE(results.completed) <=SYSDATE");
    }
  }
}

Caching Many Objects

Sometimes you will want to cache more than one object. For example, you might want to keep the most recently accessed files on a web server in a cache. If you use a HashMap object for a purpose like this, it will continue to grow and use a lot of memory.

If your machine has large amounts of memory and only a small number of objects to cache then a growing HashMap may not be a problem. However, if you are intending to cache alot of objects then you may find that keeping only the most recent objects in the cache provides the best use of the machines memory. You can combine a HashMap object with a LinkedList to create what is called a Most Recently Used (MRU) cache.

Note: There are other techniques used to constrain cache size besides MRU. MRU is one of the simpler algorithms.

With an MRU cache, you can place a constraint on which objects remain in cache, and thereby, control the size of the cache. There are three main operations that the MRU cache has to perform:

If the cache is not full, new objects not already in the cache are inserted at the head of the list.

If the cache is not full and the object to be inserted already exists in the cache, it is moved to the head of the list.

If the cache is full and a new object is to be inserted, the last object in the cache is removed and the new object is inserted at the head of the list.

This diagram shows how the LinkedList and HashMap work together to implement the operations described above. A discussion of the diagram follows.

MRU Cache with LinkedList and HashMap

The LinkedList provides the queue mechanism, and the entries in the LinkedList contain the key to the data in the HashMap. To add a new entry to the front of the list, the addFirst method is called.

If the list is already full, the removeLast method is called and the data entry is also removed from the HashMap.

If an entry was already in the list, it is removed with a call to the remove method and inserted at the front of the list with a call to the addFirst method.

The Collections API does not implement locking, so if you remove entries from or add entries to LinkedList or HashMap objects, you need to lock access to these objects. You can also use a Vector or ArrayList to get the same results as shown in the code below with the LinkedList.

This code example uses an MRU cache to keep a cache of files loaded from disk. When a file is requested, the program checks to see if the file is in the cache. If the file is not in the cache, the program reads the file from disk and places the cache copy at the beginning of the list.

If the file is in cache, the program compares the modification times of the file and cache entry.

If the cache entry time is older, the program reads the file from disk, removes the cache copy, and places a new copy in the cache at the front of the LinkedList.

If the file time is older, the program gets the file from the cache and moves the cache copy to the front of the list.

 
import java.util.*;
import java.io.*;
 
class myFile {
  long lastmodified;
  String contents;
 
  public myFile(long last, String data) {
    lastmodified=last;
    contents=data;		
  }
  public long getLastModified() {
    return lastmodified;
  }
  public String getContents() {
    return contents;
  }
}
 
public class MRUCache {
 
  Map cache;
  LinkedList mrulist;
  int cachesize;
 
  public MRUCache(int max) {
    cache = new HashMap();
    mrulist= new LinkedList();
    cachesize=max;
  }
 
  public String getFile(String fname) {
    if(!cache.containsKey(fname)) {
      synchronized(cache) {	
        if(mrulist.size() >=cachesize) {
	  cache.remove(mrulist.getLast());
	  mrulist.removeLast();
        }
        cache.put(fname, readFile(fname)); 
        mrulist.addFirst(fname);
      }
    } else {
      if((new File(fname).lastModified())> 
	((myFile)cache.get(fname)).getLastModified()) {
	  synchronized(cache) {	
	    cache.put(fname, readFile(fname)); 
          }
       }	
       synchronized(cache) {
	 mrulist.remove(fname);
	 mrulist.addFirst(fname);
       }
    }
       return ((myFile)cache.get(fname)).getContents();
  }
	
  public myFile readFile(String name) {
    File f = new File(name);
    StringBuffer filecontents= new StringBuffer();
 
    try {
      BufferedReader br=new BufferedReader(
                              new FileReader(f));
      String line;
 
      while((line =br.readLine()) != null) {
	filecontents.append(line);
      }	
    } catch (FileNotFoundException fnfe){
      return (null);
    } catch ( IOException ioe) {
		return (null);
    }
      return (new myFile(f.lastModified(), 
		filecontents.toString()));
  }
 
  public void printList() {
    for(int i=0;i<mrulist.size();i++) {
      System.out.println("item "+i+"="+mrulist.get(i));
    }
  }
 
  public static void main(String args[]) {
 
    // Number of entries in MRU cache is set to 10 
    MRUCache h1=new MRUCache(10);
    for(int i=1;i<=20;i++) {
      // files are stored in a subdirectory called data
      h1.getFile("data"+File.separatorChar+i);
    }
      h1.printList();
  }
}


Source: http://java.sun.com/developer/onlineTraining/Programming/JDCBook/perf4.html

Comparing Web Site Projects and Web Application Projects

2009-07-02T02:58:00.001-07:00

Introduction to Web Application Projects

Microsoft Corporation

April 2006

Applies to:
Visual Studio 2005
Visual Studio .NET 2003

Summary: Find out how to use the new project type, the Web application project, as an alternative to the Web site project model already available in Visual Studio 2005. (27 printed pages)

Introduction

The Web Application Projects add-in provides a Visual Studio 2005 Web project model option that works like the Visual Studio .NET 2003 Web project model. In this paper, the new project type is referred to as a Web application project. You can use Web application projects as an alternative to the Web site project model already available in Visual Studio 2005, which we refer to in this paper as Web site projects.

Purpose of Web Application Projects

The goal of Web application projects is to address some of the feedback we have heard from customers. Some developers find migrating Visual Studio .NET 2003 applications to the new Web site model in Visual Studio 2005 impractical, especially because precompiling (publishing) a Visual Studio 2005 Web site creates multiple assemblies.

The new Web application project type also enables some scenarios where Visual Studio 2005 Web projects are different than in the previous version of Visual Studio. For example, the new model has different semantics for Web subprojects where the subproject is not an ASP.NET or IIS application, but instead feeds its generated assembly to a parent application's Bin folder.

The new project type also provides a model that will feel familiar to developers who do not want to change how they structure their Web projects from how they use Visual Studio .NET 2003 today—for example, they want to continue to use a project file.

The new Web application project type does not replace the Web site project type introduced in Visual Studio 2005, which provides many new features and additional flexibility in how you manage Web applications. Instead, it is an alternative project type that you might choose depending on your requirements and your preferred development workflow. Some developers will find the default Visual Studio 2005 Web site project model natural and easy to use. Other developers will prefer a model in which project resources are defined explicitly (rather than implicitly by simply being in a folder) and in which they have tighter control over their project, and will therefore choose the new Web application project model. Rather than forcing developers to use just one project model, we will support both project models and allow developers to choose whichever Web project model works best for them.

Note Web application projects do not work with Visual Web Developer Express Edition.

In This Paper

This paper describes Web application projects and offers information on when you might choose between a Web application project and a Web site project model in Visual Studio 2005. The paper also walks you through the following common scenarios:

Creating a new Web application project in Visual Studio 2005.
Migrating an existing Visual Studio .NET 2003 project to a Visual Studio 2005 Web application project.

In addition, an appendix lists known issues with Web application projects.

Installing Web Application Projects

Adding Web application projects to Visual Studio 2005 requires you to install both an update and an add-in to Visual Studio 2005. The two installations perform the following tasks:

The update makes changes to Visual Studio 2005 that are required so the Web project conversion wizard and designer will work well with Web application projects. You can download the update from the Microsoft Visual Studio 2005 - Update to Support Web Application Projects [ http://go.microsoft.com/fwlink/?LinkId=63636 ] page on the Microsoft Download Center Web site.
The add-in makes the new Web application projects available in Visual Studio 2005. You can download it from the Visual Studio 2005 Web Application Projects [ http://go.microsoft.com/fwlink/?LinkId=57541 ] page on the ASP.NET Developer Center.

Early versions of Web application projects (V1 and V2 previews) were released in December 2005 and February 2006. The most recent version adds support for generating code to represent server controls and for converting projects directly from Visual Studio .NET 2003 to Web application projects in Visual Studio 2005.

Comparing Web Site Projects and Web Application Projects

The new Web application project model provides the same Web project semantics as Visual Studio .NET 2003 Web projects. This includes a structure based on project files and a build model where all code in the project is compiled into a single assembly. However, the new project type makes available all the new features of Visual Studio 2005 (refactoring, class diagrams, test development, generics, and so on) and of ASP.NET 2.0 (master pages, data controls, membership and login, role management, Web Parts, personalization, site navigation, themes, and so on).

The Web application project model in Visual Studio 2005 also removes two requirements from Visual Studio .NET 2003:

Using FrontPage Server Extensions (FPSE). These are no longer required, but they are supported if your site already uses them.
Using a local copy of IIS. The new project type supports both IIS and the built-in ASP.NET Development Server.

The following two tables describe the differences between Web application projects and Web site projects. The first table highlights various scenarios and tasks and suggests which model is best suited to that task. The second table describes in more detail the behavioral differences between each model. Use the tables to guide you in selecting which model to select.

The following table lists Web project options or tasks and indicates which project model best implements those options.

Option or Task
Web Application Projects
Web Site Projects

Need to migrate large Visual Studio .NET 2003 applications
X

Prefer single-page code model to code-behind model
X

Prefer dynamic compilation and working on pages without building entire site on each page view (that is, save file and then simply refresh the page in the browser).
X

Need to control names of output assemblies
X

Need to generate one assembly for each page
X

Need stand-alone classes to reference page and user control classes
X

Need to build a Web application using multiple Web projects
X

Need to add pre-build and post-build steps during compilation
X

Want to open and edit any directory as a Web project without creating a project file
X

The following table helps you select a project type by describing some of the key differences between Web application projects and Web site projects.

Scenario
Web Application Project
Web Site Project

Project definition
Similar to Visual Studio .NET 2003. Only files that are referenced in the project file are part of the project, are displayed in Solution Explorer, and are compiled during a build. Because there is a project file, some scenarios are more easily enabled:

You can subdivide one ASP.NET application into multiple Visual Studio projects.

You can easily exclude files from the project and from source code-control.

Web site projects use the folder structure to define the contents of the project. There is no project file and all files in the folder are part of the project.

This project type is desirable if you have an existing folder structure representing an ASP.NET application that you want to edit in Visual Studio without having to explicitly create a project file.

Compilation and build outputs
The compilation model for Web application projects is very similar to that in Visual Studio .NET 2003.

All code-behind class files and stand-alone class files in the project are compiled into a single assembly, which is placed in the Bin folder. Because this is a single assembly, you can specify attributes such as assembly name and version, as well as the location of the output assembly.

Certain other applications scenarios are better enabled, such as the Model-View-Controller (MVC) pattern, because they allow stand-alone classes in the project to reference page and user control classes.

The Buildcommand compiles Web site projects only to test them. To run Web site projects, you deploy source files and rely on ASP.NET dynamic compilation to compile pages and classes in the application.

Alternatively, you can precompile the site for performance, which uses the same compilation semantics as ASP.NET dynamic compilation. The ASP.NET dynamic compilation system has two modes—batch mode (the default) and fixed-names mode. In batch mode, many assemblies (typically one per folder) are produced when precompiling the site. In fixed mode, one assembly is produced for each page or user control in the Web site.

Iterative development
To run and debug pages, you must build the entire Web project. Building the entire Web application project is usually fast, because Visual Studio employs an incremental build model that builds only the files that have changed.
You can configure build options Visual Studio 2005 for when you run the site: build the site, an individual page, or nothing at all. In the last case, when you run a Web site, Visual Studio simply launches the browser and passes to it the current or start page. The request then invokes ASP.NET dynamic compilation.

Because pages are compiled dynamically and compiled into different assemblies as needed, it is not required that the entire project compile successfully in order to run and debug a page.

By default, Visual Studio completely compiles Web site projects whenever you run or debug any page. This is done to identify compile-time errors anywhere in the site. However, a complete site build can significantly slow down the iterative development process, so it is generally recommended that you change the build project option to compile only the current page on run or debug.

Deployment
Because all class files are compiled into a single assembly, only that assembly needs to be deployed, along with the .aspx and .ascx files and other static content files.

In this model, .aspx files are not compiled until they are run in the browser. However, when used with Web Deployment Projects (a downloadable add-in to Visual Studio 2005), the .aspx files can also be compiled and included in a single assembly for deployment.

Each time you deploy the single assembly produced in this model, you replace the code for all pages in the project.

Both .aspx files and code-behind files can be compiled into assemblies using thePublish Websitecommand in Visual Studio. (Note that theBuild command does not create a deployable set of assemblies.) The updateable publish option supports compiling only code-behind files while leaving .aspx files unchanged for deployment.

The default mode for precompiling produces several assemblies in the Bin folder, typically one per folder. The fixed-names option produces one assembly per page or user control and can be used to create deployable versions of individual pages. However, the fixed-names option increases the number of assemblies and can result in increased memory usage.

Upgrade from Visual Studio .NET 2003
Because the Web application project model is the same as in the Visual Studio .NET 2003, upgrade is generally simple and will usually not require any restructuring of the application.
The compilation option for Web site projects is significantly different than Visual Studio .NET 2003. A conversion wizard is available to upgrade existing Visual Studio .NET 2003 Web projects to Web site projects. For any reasonably complex Visual Studio .NET 2003 projects, manual fix-up is usually required after the conversion. For most scenarios, it is preferable to upgrade existing Visual Studio .NET 2003 projects to Web application projects in Visual Studio 2005.

Scenario 1: Creating a New Web Application Project

This section walks you through creating a new Web application project. It also examines how page code is handled in a Visual Studio 2005 Web application project.

Note Web application projects do not work with Visual Web Developer Express Edition.

The examples shown here are in C#. The steps for working with Visual Basic are very similar, but file names and code will differ slightly.

Step 1: Create a New Project

To start, create a new Web application project. In Visual Studio, from the File menu, click New Project, displays the New Project dialog box.

Note To create a Web application project, you do not choose the New Web Site command, as you do to create a Web site project. Instead, you choose the New Project command.

Under Project types, open the Visual C# or Visual Basic node, and then under Visual Studio installed templates, click ASP.NET Web Application:

Figure 1. Creating a new Web Application Project

Name the project and specify a location. When you click OK, Visual Studio creates and opens a new Web project with a single page named Default.aspx, an AssemblyInfo.cs file (.vb file), and a Web.config file:

Figure 2. New Web application project

This list of project files, references, compilation information, and other metadata is stored in the project file, which is created in whatever location you specify in the New Project dialog box.

There are two class files (.cs files or .vb files) associated with the Default.aspx page. The Default.cs file (.vb file) contains the page class where you put your code and event handlers. The Default.aspx.designer.cs file (.vb file) is a new file used in Web application projects to contain the code that is generated and maintained by Visual Studio for the page. Both files contain a partial class. During compilation, the files are combined into a single code-behind class.

Step 2: Open and Edit the Page

Open the Default.aspx file and copy the following markup into it, which defines several ASP.NET server controls:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="WebApplication3._Default" %>

<html>
<head runat="server">
    <title>My Visual Studio 2005 Web Application Project Test</title>
</head>
<body>
  <form id="form1" runat="server">
    <div>
    
        <h1>My Visual Studio 2005 Web Application Project Test</h1>
        <h3>Pick a date: </h3>
        <asp:Calendar ID="Calendar1" runat="server" 
             BorderColor="#999999" DayNameFormat="Shortest" 
             Font-Names="Verdana">
          <SelectedDayStyle BackColor="#666666" 
             Font-Bold="True" ForeColor="White" />
          <TodayDayStyle BackColor="#CCCCCC" ForeColor="Black" />
          <SelectorStyle BackColor="#CCCCCC" />
          <WeekendDayStyle BackColor="#FFFFCC" />
          <OtherMonthDayStyle ForeColor="#808080" />
          <NextPrevStyle VerticalAlign="Bottom" />
          <DayHeaderStyle BackColor="#CCCCCC" Font-Bold="True" 
             Font-Size="7pt" />
           <TitleStyle BackColor="#999999" BorderColor="Black" 
             Font-Bold="True" />
        </asp:Calendar>
        <br />
        <div>
          <asp:Label ID="Label1" runat="server" Text="Label"/>
        </div>
    </div>
  </form>
</body>
</html>

In a Web application project, the Default.aspx.designer.cs file is automatically updated when you add or remove controls in the Default.aspx file. The following snippet shows what the Default.aspx.designer.cs file looks like after you add the preceding markup:

namespace WebApplication3 
{
    public partial class _Default 
    {
        protected System.Web.UI.HtmlControls.HtmlForm form1;
        protected System.Web.UI.WebControls.Calendar Calendar1;
        protected System.Web.UI.WebControls.Label Label1;
    }
}

The Default.aspx.designer.cs file contains a control declaration for each server control in the .aspx (or .ascx) file. By default, the controls are declared as protected. You can open the .designer.cs file and change a field's accessor to public if you want to access the variable from outside of its class.

Note It is not recommended that you set the accessibility of control declarations to public, because it is a better to use a property to change the accessibility of a server control variable. However, editing the access modifier for server variables in the designer file is supported for backward compatibility with Visual Studio .NET 2003 Web projects that used this coding technique.

In Web application projects, code generation for server controls is improved over the Visual Studio .NET 2003 experience in two important ways:

You no longer have to switch the page to Design view to update the control declarations. The designer monitors both Design view and Source view and updates declarations appropriately.

Control declarations in the base class of a page are honored and are not duplicated in a page's code-behind class.

Because the .designer.cs file is automatically updated with the control declarations, you can go directly to the Default.aspx.cs code-behind class file and program any of the controls on the page, as in the following example:

using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

namespace WebApplication3 {

    public partial class _Default : System.Web.UI.Page {

        protected void Page_Load(object sender, EventArgs e) {
            Label1.Text = "Current date: " + Calendar1.SelectedDate;
        }
    }
}

Step 3: Build and Run the Project

Run the project in debug mode by pressing F5 or clicking Run in the Debug menu. By default, Web application projects use the built-in ASP.NET Development Server using a random port as the root site (for example, the site's URL might be http://localhost:12345/):

Figure 3. Running a Web application project

When you build Web application projects, all code-behind classes, stand-alone class files, and embedded resources are compiled into a single assembly that is placed in the project's Bin folder.

You can change the output location if you want to—for example, to build the project into a parent application directory. Typically, you set the build location when you have multiple subprojects in subfolders of a single ASP.NET application. Select the properties of the project to set the build location, as shown in the following screenshot:

Figure 4. Setting output build location

After building the project, you can examine the results. In Solution Explorer, click Show All Files:

Figure 5. Results of building a Web application project

This works the same as it does in Visual Studio .NET 2003 ASP.NET Web projects.

Setting Build and Deployment Properties for Web Application Projects

ASP.NET Web application projects use the same configuration settings and behaviors as Visual Studio 2005 class-library projects. You can access these configuration settings by right-clicking the project name in Solution Explorer and selecting Properties. This displays the project properties editor. You can use the editor to change properties such as the name of the generated assembly, the build compilation settings for the project, its references, its resource string values, and code-signing settings:

Figure 6. Changing properties of a Web application project

ASP.NET Web application projects add a tab named Web to the project properties list. You can use this tab to configure how a Web project is run and debugged. By default, ASP.NET Web application projects are configured to launch and run using the built-in ASP.NET Development Server on a random HTTP port on the machine. The following screenshots show using the ASP.NET Development Server: the Taskbar icon, and a page in the browser where you can see the server's URL in the Address box.

Figure 7. Taskbar icon for ASP.NET Development Server

Figure 8. Running a Web application project using the ASP.NET Development Server

You can change the port number if the selected port is already in use or if you want to run the Web project on a specific port:

Figure 9. Changing the port used by the ASP.NET Development Server

Alternatively, Visual Studio can run and debug the Web application using IIS. To use IIS, select Use IIS Web Server and enter the URL of the Web application:

Figure 10. Configuring a Web application project to use IIS

Note ASP.NET Web application projects do not automatically create an IIS virtual root or application for you. To create the virtual directory and application in IIS, click the Create Virtual Directory button next to the Url box.

When you run the application, Visual Studio compiles the project into a single assembly, which follows the build semantics of Visual Studio .NET 2003 Web projects. When the application is running, Visual Studio attaches a debugger to the Web server process.

All project settings are saved in a standard MSBuild project file.

Customizing Deployment Options for Web Application Projects

After creating a Web application project, you can optionally use a Visual Studio 2005 Web Deployment project to set deployment options for the Web application project.

Note Web Deployment Projects is available as a Visual Studio 2005 add-in. You can download the add-in from the Visual Studio 2005 Web Deployment Projects [ http://go.microsoft.com/fwlink/?LinkId=55111 ] page on the ASP.NET Developer Center.

Web application projects compile all code into a single assembly, so you do not need a Visual Studio 2005 Web Deployment project to combine assemblies. However, Web Deployment projects provide additional support for precompiling the .aspx content of a project, as well as for making post-build changes to the published configuration. Using the latest build of the Web Deployment project add-in, you will be able to do add these features for both Visual Studio 2005 Web site projects and Visual Studio 2005 Web application projects.

Scenario 2: Migrating a Visual Studio .NET 2003 Web Project to a Web Application Project

This section walks you through the process of converting an existing Visual Studio .NET 2003 Web project to a Web application project in Visual Studio 2005. The Web application project model uses the same conceptual approach as a Web project in Visual Studio .NET 2003, including a project file to include and exclude files, compilation to a single assembly, and so on. In general, Web application projects do not require any architectural changes after the conversion.

As in the preceding section, this section assumes that you are working in C#. The steps for working with Visual Basic are very similar, but file names and some of the code will differ.

Step 1: Install the Visual Studio 2005 Web Application Project Preview

Be sure you have installed Web Application Projects in Visual Studio 2005 by following the steps in the Installing Web Application Projects section earlier in this paper.

Step 2: Back Up Your Visual Studio .NET 2003 Projects

Make absolutely sure to save a backup of your Visual Studio .NET 2003 Web projects and solutions before attempting any migration. The following steps have been tested using the preview version of Web Application Projects. However, there could still be issues, and you might need to restore the Visual Studio .NET 2003 solution.

Step 3: Open and Verify your Visual Studio .NET 2003 Web Project

Before migrating a project, open your existing Visual Studio .NET 2003 solution, compile it, and then run it. Spending a few minutes to verify that everything works before you migrate can save trouble later, especially if the cause of errors is a last-minute directory change or similar.

Step 4: Migrate the Solution to Visual Studio 2005

Close the solution in Visual Studio .NET 2003, and then start Visual Studio 2005. On the File menu, click Open File, and then browse to the .sln file for the solution you want to migrate. This launches the Visual Studio 2005 Conversion wizard:

Figure 11. Visual Studio 2005 conversion wizard

Click Next to proceed through the wizard, accepting all defaults. Visual Studio 2005 will convert the solution and its contained project files to use the MSBuild format, which is the new project file format in Visual Studio 2005.

As part of the migration, Visual Studio 2005 generates an XML-based log file that provides a summary of the conversion process, flagging any issues encountered during migration. By default, the conversion log file is saved in the same directory as the .sln file. If you have issues later when compiling the project, you might need to refer back to the conversion log file.

Step 5: Verify in Visual Studio 2005

After the solution and project files are upgraded to Visual Studio 2005 format, validate that your application builds without errors and runs as expected. At this point, the most common errors or warnings will be of these types:

Conflicts with names in introduced in the .NET Framework version 2.0.

Warnings about using obsolete members.

To fix naming conflicts, you can either fully qualify existing names with a namespace to remove ambiguity, or rename the members so they do not conflict.

If you see a warning about using obsolete members, the warning message will usually suggest alternative APIs to use. In these cases, you can continue to use the obsolete members in the 2.0 version of the .NET Framework. However, the members will be removed in the next major release of the .NET Framework, so it is a good practice to remove the members and substitute the suggested alternatives.

When running your Web application, you might see an error that says "Directory Listing Denied" that suggests that a virtual directory does not allow its contents to be listed. If you see this error message, do the following:

Close the browser.

In Solution Explorer, right-click the application's start page and then click Set as Start Page to ensure that the correct page is invoked when the application runs.

Run the application again.

Step 6: Covert Code-Behind Classes to Partial Classes

As noted earlier, in Visual Studio 2005, Web application projects use partial classes to store designer-generated code. These classes are stored in a separate file from the code-behind file. By default, the Visual Studio 2005 Web project conversion wizard does not create a *.designer.cs (or *.designer.vb) file for Web pages (.aspx files) or user controls (.ascx files). Instead, the code will look and work just like it did in Visual Studio .NET 2003.

Note The wizard makes the minimum number of changes to the code files during migration to help ensure a smooth conversion to Web application projects in Visual Studio 2005.

You can keep your code in this format. If you do, you must manually update the control field declarations in the code-behind files, but everything else will work fine in Visual Studio 2005.

To take advantage of the editor's ability to maintain field declarations in generated code, you should update your pages and controls to use the partial-class model introduced in ASP.NET 2.0. Partial classes make it easier to organize the generated code and custom code for your code-behind files. For more information on .designer.cs files, see Scenario 1: Creating a New Web Application Project earlier in this paper.

To migrate your code to use partial-class model, first make sure that your code compiles without errors. Then in Solution Explorer, right-click the project name and click Convert to Web Application. This command iterates through each page and user control in the project, moves all control declarations to a .designer.cs file, and adds event handler declarations to the server-control markup in the .aspx and .ascx files.

Note Another option is to use the Convert to Web Application command on individual pages. You might do this first on a few pages if you want to watch closely the changes made for each page before applying the change to the entire application.

Figure 12. Converting a single page to Web application project format

When the process has finished, check the Task List window to see if any conversion errors are reported. If the task list displays errors, right-click the relevant page in Solution Explorer and choose View Codeand View Code Gen File to examine the code and fix problems. Note that errors and warnings that appear in the Task List window persist between Visual Studio sessions. After you have fixed errors listed in the window, you can clear items from the task list.

Note The Convert to Web Application command cannot be undone in Visual Studio. The best method for reverting the changes is to restore from a backup of the Visual Studio .NET 2003 project, and then to re-run the Visual Studio 2005 migration as described in Step 4 above.

Now recompile your project to ensure it compiles without errors. A possible source of errors is if you have modified the control declarations in a code-behind class and the conversion wizard mishandles your changes.

From this point, when you add new pages into your Web project, they will by default use the partial-class template.

Step 7: Examine and Resolve XHTML Compliance Issues

By default, Visual Studio 2005 generates and validates XHTML-compliant markup. This helps you build Web applications that are standards compliant and helps minimize issues with browser-specific rendering. Visual Studio .NET 2003 did not generate XHTML-compliant markup, so you might see validation and rendering issues with pages created in Visual Studio .NET 2003.

Note Validation errors are informational only and are flagged as warnings. Validation errors do not prevent a page from running.

If you do not want to see validation errors, switch the HTML validation setting from XHTML Transitional to Internet Explorer 6.0 (which was the Visual Studio .NET 2003 default setting). In the Tools menu, click Options. In the Options dialog box, open the Text Editor node, then the HTML node, and then the Validation node. In the Target list, select Internet Explorer 6.0, and then unselect the Show Errors check box. Note that this does not fix XHTML validation errors; it simply switches the validation schema to one that is more compatible with the way markup was generated by Visual Studio .NET 2003, and it suppresses validation warnings.

Figure 13. Configuring HTML validation

You can also add the following section to your project's Web.config file, which causes ASP.NET to render legacy (non-XHTML compliant) markup from server controls:

<system.Web>

<xhtmlConformance mode="Legacy" />

</system.Web>

This will avoid the slight rendering differences you might see between pages displayed using ASP.NET 1.1 and using ASP.NET 2.0. For more information, see ASP.NET and XHTML [ http://go.microsoft.com/fwlink/?LinkId=64052 ] in the MSDN Library.

The Future of Web Application Projects

Web application projects provide a compilation and build model very similar to the one used in Visual Studio .NET 2003. Depending on their requirements, some users will find the new Web site project option in Visual Studio 2005 more appropriate for their applications, while other users will prefer the Web application project option. Web application projects provide the best path for upgrading existing Visual Studio .NET 2003 applications to Visual Studio 2005, and are highly recommended for that scenario.

We want to emphasize these important points about the future of Visual Studio 2005 Web application projects:

Going forward, we will fully support both the Visual Studio 2005 Web site project model and Visual Studio 2005 Web application project model. You can choose whichever model works best for you.

In future versions of Visual Studio, the Web application project model will be built in, and both the Web application project model and Web site project model will be supported.

Appendix A: Known Issues

This appendix lists known issues with Web application projects.

Issue 1: Data Scenarios

There are known issues when using data-bound controls and SQL Server 2005 Express with the April 2006 release of Web application projects. For a list of issues and workarounds, see the whitepaper named "Using Data-Bound Controls and SQL Server Express with Web Application Projects," which is available on the Visual Studio 2005 Web Application Projects [ http://go.microsoft.com/fwlink/?LinkId=57541 ] page on the ASP.NET Developer Center.

Issue 2: Visual Basic Inline Code Might Not Be Converted Correctly

When you upgrade a Visual Studio .NET 2003 project to Visual Studio 2005, Visual Basic code in single-file Web pages (.aspx files) or user controls (.ascx files) is not converted to use the new Visual Basic 2005 syntax. This can lead to compile time errors when building your converted Web project. You will need to manually fix these errors and recompile the affected pages. Visual Basic code in code-behind files is converted and should compile correctly.

Issue 3: WSE and Web Application Projects

Web Services Enhancements (WSE) is an add-in to Visual Studio 2005 that provides the latest advanced Web services capabilities. When Web Application Projects is installed, the WSE configuration command on the shortcut menu in Solution Explorer will not work correctly. As a workaround, follow these steps to use the stand-alone WSE 3.0 configuration tool instead:

Start the configuration tool. In the Windows Start menu, click All Programs, click Microsoft WSE 3.0, and then click Configuration Tool.

In the configuration tool, in the File menu, click Open.

Select the Web.config file for the project.

Issue 4: Converting the Club Web Site Starter Kit (Visual Basic)

(This issue applies only when using Visual Basic.) When converting the Visual Basic version of the Club Web Site starter kit to a Web application project, you will see a run-time error similar to the following:

Server Error in '/' Application.
Compiler Error Message: BC30451: Name 'truncate' is not declared.
Source Error: 
Line 129: <asp:Label ID="Label2" runat="server" Text='<%# truncate(CStr(Eval("description"))) %>' />
Source File: C:\vs05\328\test-club1\wap1\Default.aspx    Line: 129

To resolve the error, you must add a namespace. You can do this for individual pages or for the project as a whole. Assuming your project namespace is "wap1", follow these steps.

To add a namespace to an individual page:

Open the page.

Under the last @ Register directive, add an @ Import directive that references the namespace you want to use, as in the following example:
```
<%@ Register TagPrefix="Club" Namespace="wap1.Clubsite" Assembly="wap1">
<%@ Import Namespace="wap1" %>
```

To add a namespace to the project:

Open the Web.config file.

Add or edit the <namespaces> element as a child of the <pages> element, as in the following example:
```
<pages>
  <namespaces>
    <add namespace="wap1"/>
  </namespaces>
</pages>
```

Issue 5: Converting the Personal Web Site Starter Kit (Visual Basic)

(This issue applies only when using Visual Basic.) When converting the Visual Basic version of the Personal Web Site starter kit to a Web application project, you will see a run-time error similar to the following:

Server Error in '/' Application
The type specified in the TypeName property of ObjectDataSource 'ObjectDataSource1' could not be found

To resolve the error, you must add the project namespace to the TypeName property. Assuming your project namespace is "wap1", follow these steps.

Open the Member_List.aspx page.

Change the type name in the ObjectDataSource declaration to be fully qualified, as in the following example:
```
<asp:ObjectDataSource TypeName="wap1.MemberDetails" >
```

Issue 6: Converting a Visual Studio 2005 Web Site project to a Web Application Project

This paper will be updated in the future to show the steps needed to convert a Visual Studio 2005 Web site project to a Web application project. In the meantime, see the entry, Tutorial 8: Migrating from VS 2005 Web Site Projects to be a VS 2005 Web Application Projects [ http://webproject.scottgu.com/CSharp/migration2/migration2.aspx ] on Scott Guthrie's blog.

Fast version of the Activator.CreateInstance method using IL

2009-06-30T19:37:00.001-07:00

FastObjectFactory.zip (50.35 kb)

Source: http://mironabramson.com/blog/post/2008/08/Fast-version-of-the-ActivatorCreateInstance-method-using-IL.aspx

We all know (I guess) the method Activator.CreateInstance(Type) and the generic version: Activator.CreateInstance<T>() that are used to create an instance of a specified Type.

In now days all are talking about 'Entity-relationship model' , 'Object-relational mapping' and that stuff, that basically it means getting a IDataReader, loop over it and fill with the data a List with specfied type of objects and return a List instead of DataSet or DataTable (or similar mechanism). While looping over the IDataReader, every iterate, an instance of the specified type needs to be create. It can be done using one of the methods above, but it can be improved by usind IL and some help using some cache. Here is how can it be done:

public static class FastObjectFactory
{
private static readonly Hashtable creatorCache = Hashtable.Synchronized(new Hashtable());
private readonly static Type coType = typeof(CreateObject);
public delegate object CreateObject();
/// <summary>
/// Create an object that will used as a 'factory' to the specified type T
/// <returns></returns>
public static CreateObject CreateObjectFactory<T>() where T : class
    {
        Type t = typeof(T);
        FastObjectFactory.CreateObject c = creatorCache[t] as FastObjectFactory.CreateObject;
if (c == null)
        {
lock (creatorCache.SyncRoot)
            {
                c = creatorCache[t] as FastObjectFactory.CreateObject;
if (c != null)
                {
return c;
                }
                DynamicMethod dynMethod = new DynamicMethod("DM$OBJ_FACTORY_" + t.Name, typeof(object), null, t);
                ILGenerator ilGen = dynMethod.GetILGenerator();
                ilGen.Emit(OpCodes.Newobj, t.GetConstructor(Type.EmptyTypes));
                ilGen.Emit(OpCodes.Ret);
                c = (CreateObject)dynMethod.CreateDelegate(coType);
                creatorCache.Add(t, c);
            }
        }
return c;
    }
}

Note the static HashTable is been used as a cache. The first time we create a delegate 'CreateObjec' for the given type it is 'slow', so all the point here, is to cache this delegate. The next time we need to create an object from the given type, the 'CreateObjec' delegate will be used from the cache. Without caching it, the whole story worth nothing.

Here are some benchmarks:

1 Object:

100 Objects:

1000 Objects:

Comparing to the generic constraint : new()

Below there is the small project I used for the benchmarks:

FastObjectFactory.zip (50.35 kb)

Source: http://mironabramson.com/blog/post/2008/08/Fast-version-of-the-ActivatorCreateInstance-method-using-IL.aspx