In Part 1,  we talked about creating LINQ objects  and getting data.  This time, we are going to show how to use XML with LINQ to test a SQL database.  This part is really not difficult, we are just going to cover the basics of getting started. I have made the conscious decision that I am going to use a SQL database during my development process.  You may decide that you want to do use a different methodology.  These are some of your options:

• Repository Pattern
• In-Memory Database
• Development Database
• Live Database 

Step 1: Generate Data
First, you want to create some test data.  Since, I did not really wanted to do this by hand I found a site www.generatedata.com, that has an online utility for generating data.  The best part was the different formats that it supports.

Step 2: Create Unit Test Project
Now that I have data, I created a Unit Test project and now I am ready to really get some  work done.  In this project, I created a "Data" directory and put my generated XML from Step 1.  To the right is an example of what my Unit Testing file structure currently looks like.

Step 3: Create Helper
The next thing we want to do is create a helper that will be used to populate XML data to SQL. Next, lets create a class, and name it CustomerHelper.  In my class, I made the following adjustments.

• References
  • Business Library where my model LINQ objects are held.
  • System.Linq
  •  System.Xml.Linq
• Make the class static. (See below sample)

Next, we need to add some constants to hold the XML and resulting collections that will get loaded.  Mine looks like the following:

    public static class CustomerHelper

    {

        static XDocument xmlCustomers;

        static List<Customer> customers;

        public static List<Customer> Customers

        {

            get { return customers; }

        }

     }

Next we need to automatically load the data in the constructor.

            xmlCustomers = XDocument.Load("Customers.xml");

            customers = (from c in xmlCustomers.Descendants("Customer")

                         select new Customer

                         {

                             FirstName = (string)c.Element("FirstName"),

                             LastName = (string)c.Element("LastName"),

                             MiddleName = string.Empty,

                             Apartment = string.Empty,

                             Address = (string)c.Element("Address"),

                             City = (string)c.Element("City"),

                             Country = "USA",

                             Email = (string)c.Element("Email"),

                             PostalCode = (string)c.Element("PostalCode"),

                             State = (string)c.Element("State"),

                             Telephone = (string)c.Element("Telephone"),

                         }

                     ).ToList();

So some explaining, need to be done about what is happening here.  First we are loading the XML file into an XDocument.  That XDocument will then act just like SQL where we can query against it like any other data.  LINQ looks at the object just like it would for SQL except there are some additional properties and methods.  An example of the data is below. We query the data and turn it into LINQ SQL objects.  The query is doing the following:

1. Query the xmlCustomer object looking for the "Customer" nodes.
2. In each customer node, we want to take the selected elements and populate them into our Customer object.
3. After building the query, execute the code now and return a list of Customers.

 <Customers>
   <Customer>
     <FirstName>Bevis</FirstName> 
     <LastName>Dalton</LastName> 
     <Address>5394 Dis Ave</Address> 
     <City>Tamuning</City> 
     <State>Wisconsin</State> 
     <PostalCode>04338</PostalCode> 
     <Telephone>(772) 462-2385</Telephone> 
     <Email>lorem.luctus.ut@elitEtiam.ca</Email> 
   </Customer>
 </Customers>

If we try and run this now, it will not work because we need to do a little bit of plumbing first.

Step 4: Start Testing

After creating my unit test file, I add a reference to my LINQ Database Context, which in my case is called InventoryDBDataContext.

        InventoryDBDataContext db;
In my Test Initialize I create an instance of my database context, 
so each test will have a new one.

        [TestInitialize()]
        public void MyTestInitialize()
        {
            db = InventoryDBDataContext.Create();
        }

Now I just want to do a simple test to make sure that I can get 
data from XML and into SQL.

        [TestMethod]
        [DeploymentItem(@"\Data\")]
        public void ShouldCreateAGroupOfCustomers()
        {
            ShouldDeleteAllCustomers();
            foreach (Customer cust in CustomerHelper.Customers)
            {
                db.Customers.InsertOnSubmit(cust);
                db.SubmitChanges();
            }
            Assert.IsTrue(db.Customers.Count() >= 5);
        }

        public void ShouldDeleteAllCustomers()
        {
            foreach (Customer c in db.Customers)
            {
                db.Customers.DeleteOnSubmit(c);
            }
            db.SubmitChanges();
            Assert.IsTrue(db.Customers.Count() == 0);
            db.ExecuteCommand("DBCC CHECKIDENT ('Customer', RESEED, 0)");
        }

The key to this whole process is the [DeploymentItem(@"\Data\"] 
attribute.  This takes the XML files and makes sure that they
are deployed with the rest of the files.  The other key is 
that I want to clean up my SQL database after each test, so 
I clear out my data and make sure that the Identity field 
gets reset so it matches the other XML data which will 
be used later.  

So, now we are done.  You should have working test, that can

take XML data and put it into SQL for Data Populate, but
you also have a set of data that you can then run test against
and test that you got correct results.

In the next installment, we will examine the full completed LINQ 
middle tier of our application.

Have fun.

Enjoy

/// <summary>
/// Generic Container for holding results
/// </summary>
/// <typeparam name="T"></typeparam>
[DataContract(Name="{0}sContainer")]
public class Container<T>
{
    /// <summary>
    /// TotalResults that can be returned.
    /// </summary>
    [DataMember]
    public int TotalResults
    {
        get;
        set;
    }

    /// <summary>
    /// Container results.
    /// </summary>
    [DataMember]
    public IEnumerable<T> Results
    {
        get;
        set;
    }
}

References:

• Data Contract Names

So the first thing that we need is some data to define. The sample application that we are going to build is a simple home inventory system.  The image to the right defines a Customer. 

There is three ways that we can generate this data definition.

1. Command Line Tool (SqlMetal.exe)
2. Designer Wizard (.dbml)
3. Manually (.cs)

The second option is the simplest but you don't have very much control of what gets generated. So, I favor creating my files manually, because I have total control and I only define what I need (Option 3).

Step 1: Define data class.

Make sure that you have a reference to System.Data.Linq.

    [Table(Name="Customer")]
    public class Customer
    {
        [Column(Name="Id",
         IsDbGenerated=true,
         DbType="int",
         IsPrimaryKey=true)]
        public int Id
        {
            get;
            set;
        }
        
        [Column(Name="FirstName")]
        public string FirstName
        {
            get;
            set;
        }
    }

Step 2: Create Data Context

In this step we are going to create a data context to handle our database interactions.  First, we need to create a class that derives from System.Data.Linq.DataContext.   Second, we create a static Create method to handle the initialization of the class for ease of use.  Third, define tables, procedures and queries.  Below show a simple class for our use.

    public class InventoryDBDataContext : DataContext
    {
        public InventoryDBDataContext(string connection)
            : base(connection)
        {
        }

        public static InventoryDBDataContext Create()
        {
            string connection = ConfigurationManager.ConnectionStrings["InventoryDB"].ConnectionString;
            return new InventoryDBDataContext(connection);
        }

        public Table<Customer> Customers;
    }

You will notice that the static Create method allows for the hiding of implementation.  In the next part you will see how this is helpful.

Step 3: Get Data

Well, we finally are ready to get data.  To get a list of customer, all that we have to do is the following:

using (InventoryDBDataContext context = InventoryDBDataContext.Create())
{
         var customers = (from c in context.Customers
                                 select c).ToList();
         Assert.IsTrue(customers.Count > 0);
}

Now you see that we are now containing the calls with a "using" statement. This allows for better garbage collection.  With the 3.0 framework, you can allow a runtime definition of variables by just using the "var" keyword.  The selection of the data looks very familiar with TSQL statements.  The selection pieces defined:

We have now completed the basics with getting started with LINQ.  Next time we will take a deeper look into LINQ queries and other customization  of our classes.

Let me know what you think.  Next time we will cover how to use XML LINQ in unit testing our code.

David Waddleton

Links:

• Attribute Mappings
• Data Types and Functions

• 3.0 Framework
• WCF Activation installed
  • This can be found under  the 3.0 framework options. Depending on your operating system this could be under different locations. 
    • Vista  : Control Panel -> Program and Features -> Turn on/ off Windows Features -> Microsoft.NET Framework 3.0
    • Server 2008 : Server Manager -> Add Features-> .Net Framework 3.0 Features -> WCF Activation

I kept getting 404.3 errors, so I started examining IIS to make sure that the right stuff is registered.  After not finding anything wrong, I started looking at the WCF installation. I found that my WCF services where not installed.  You can do the installation manually by running "ServiceModelReg.exe", which was found at %Windows%\Microsoft.Net\Framework\v3.0\Windows Communication Foundation\.

To check status run:
Command: ServiceModelReg -vi
Result: The expected result if "Default Installation" next to the features shown, otherwise the services are not active. 

To turn on Services:
Command: ServiceModelReg -i
Result: Installation of WCF services in IIS 7(6)

I was then able to immediately test my service and see that I could get to the WSDL.

Hopefully this fixes your 404.3 issue.

David Waddleton

First, you will need to use System.Reflection.Assembly.  There are two important methods that are useful for what we need.  GetManifestResourceNames and GetManifestResourceStream.  The first method allow you to see what the names of the resources are that are part of your class.

 Example: To get a list of assemblies in a current class library.

string[] resources = Assembly.GetCallingAssembly().GetManifestResourceNames();

After you know the name of the embedded resource, you can get a Stream for reading the resource using the GetManifestResourceStream method. 

Second, to read resource files, you can use the  System.Resources.ResourceReader class. The embedded resource file is a .resx resource file.  The end result when the class is compiled, you will have the following reference as <Class Name>.<Name of Resource File>.resources.  The compiled version automatically turns the resource in to a compiled version with a .resource extension.  This can be done manually using the ResGen tool.

Sample Code:

/// <summary>
/// Internal member representation of Country List
/// </summary>
private static List<KeyValueStruct> countryList;

/// <summary>
/// Static Constructor, which will load the resource files
/// </summary>
static LanguagesCountries()
{
         countryList = new List<KeyValueStruct>();

         Stream stream = Assembly.GetCallingAssembly().GetManifestResourceStream("ResourceClass.Countries.resources");
         ResourceReader rmCountries = new ResourceReader(stream);
         PopulateCountries(rmCountries);
}

private static void PopulateCountries(ResourceReader reader)
{
         foreach (DictionaryEntry entry in reader)
         {
              countryList.Add(new KeyValueStruct(entry.Key.ToString(), entry.Value.ToString()));
         }
}

KeyValueStruct Structure for holding the values

/// <summary>
/// Structure to hold the Language Information
/// </summary>
public struct KeyValueStruct
{
        private string key;
        private string value;

/// <summary>
/// Constructor to load the Language / Value Pairs
/// </summary>
/// <param name="key">Language</param>
/// <param name="value">language code</param>
public KeyValueStruct(string key, string value)
{
        this.key = key;
        this.value = value;
}

/// <summary>
/// Language property
/// </summary>
public string Key
{ get { return this.key; } }

/// <summary>
/// Value Property
/// </summary>
public string Value
{ get { return this.value; } }

}

Have fun, let me know if this was helpful.

David Waddleton

Links:

https://weblogs.asp.net/scottgu/archive/2007/01/23/asp-net-ajax-1-0-released.aspx
https://weblogs.asp.net/scottgu/archive/2007/01/25/links-to-asp-net-ajax-1-0-resources-and-answers-to-some-common-questions.aspx

Download the Bits:

https://ajax.asp.net/downloads/default.aspx?tabid=47

Remember, have lots of fun with this. I think you will enjoy it.

David

Link to Get Fuzzy 

1) An update to https://www.asp.net/ and https://Ajax.asp.net/ to support the release

2) A comprehensive whitepaper detailing changes between the CTP’s and Beta

3) A simple to follow migration guide to help developers

4) Updated documentation

5) A revised ASP.NET AJAX Control Toolkit

6) And much, much more

This release is composed of three parts:

1) The Beta of the soon to be fully-supported ‘core’ ASP.NET AJAX functionality

2) A new CTP of additional functionality that runs on top of the Beta ‘core’

3) A new ASP.NET AJAX Control Toolkit that runs on top of the Beta ‘core’ and new CTP

Link to ASP.NET AJAX : The Official Microsoft ASP.NET AJAX Site

More Context: Collection 5134: Developing Rich Experiences with Microsoft® .NET Framework 3.0 and Visual Studio® 2005

This collection of 3 2-hour premium clinics teaches about the new capabilities provided by the .NET Framework 3.0. These clinics are for experienced Developers and Software Architects who are looking to adopt Microsoft's next generation technology within their solutions.
Topics covered within the collection include:

• Windows Presentation Foundation
• Windows Workflow Foundation
• Windows Communication Foundation

Link: https://www.microsoftelearning.com/eLearning/offerDetail.aspx?offerPriceId=109340