offline, I was working with a pastime application of mine, demonstrating Data Source independence. It is a provider architecture, where the specific data source is easily pluggable.

The base interface (IDataProvider) is used by the application. I already had the SqlDataProvider defined for SQL Databases. I tried switiching the provider to a MySql data source. At the end of it, just wanted to publish a couple of snippets to do data access tasks using C# and MySql.

• You can use the ADO.NET Driver provided by MySql. Download the latest MySql Connector for .NET from: http://dev.mysql.com/downloads/connector/net. This is a free developer version of the component.
• You can download the appropriate connector based on the .NET version.
• You can also use the Odbc Driver, but my snippet is for the MySql connector.
• Add a reference to the MySqlData.DLL to your project. Do not forget to ship this DLL.

Add the following namespace:

using System.Data;
using MySql.Data.MySqlClient;

C# and MySql Data Access without a Transaction.

using (MySqlConnection connection = new MySqlConnection(mySqlConnectionString))
{
    using (MySqlCommand command = new MySqlCommand())
    {
        command.Connection = connection;
        command.CommandType = CommandType.StoredProcedure;
        command.CommandText = "SELNewRecord";
 
        command.Parameters.AddWithValue("Param1", value1);
 
        connection.Open();
 
        using (MySqlDataReader reader = command.ExecuteReader())
        {
            // read the contents.
        }
    }
}

C# and MySql Data Access with a Transaction.

using (MySqlConnection connection = new MySqlConnection(mySqlConnectionString))
{
    using (MySqlCommand command = new MySqlCommand())
    {
        command.Connection = connection;
        command.CommandType = CommandType.StoredProcedure;
        command.CommandText = "INSNewRecord";
 
        connection.Open();
 
        using (command.Transaction = connection.BeginTransaction())
        {
            command.ExecuteNonQuery();
            // Execute additional SQL Queries.
 
            command.Transaction.Commit();
        }
    }
}

after all the latest ORM technologies and ease of code writing, it feels nice to write a good old data access snippet. though only once every 12 months… 

to think of it, one can easily write an RSS reader control, with inline commenting feature for blog posts, searching by category, authors etc. all that, by just using the Syndication API in .NET 3.5.

here are the classes that i am talking about:

• SyndicationFeed: this is the top-level class representing the RSS or ATOM feed
• SyndicationItem: this represents a blog post
• SyndicationCategory: a category defined in a blog, applied to posts
• SyndicationLink: a link associated with a blog post. (self, edit, comments etc)
• SyndicationPerson: author of the blog post (name, email, profile Url etc)

without further ado, here is a quick snippet to get you started on the RSS/Atom APIs..

firstly, a reference needs to be added:

System.ServiceModel.Web

the namespaces required are:

using System.ServiceModel.Syndication;
using System.Xml;

Code Snippet:

string atomOrRssUrl = "http://rajanadar.blogspot.com/atom.xml";
 
SyndicationFeed rssOrAtomFeed = null;
 
using (XmlReader feedXmlReader = XmlReader.Create(atomOrRssUrl))
{
    // Top-level feed in (Atom 1.0) or Rss 2.0
    rssOrAtomFeed = SyndicationFeed.Load(feedXmlReader);
 
    // Read the blog posts in this blog.
    foreach (SyndicationItem blogItem in rssOrAtomFeed.Items)
    {
        // Important Blog Post attributes.
        blogItem.Id;
        blogItem.Title.Text;
        blogItem.PublishDate;
        blogItem.LastUpdatedTime;
        blogItem.Copyright;
 
        // Contents
        if (blogItem.Content is TextSyndicationContent)
        {
            // typically, this will be HTML.
            (blogItem.Content as TextSyndicationContent).Text;
        }
 
        // Categories of this blog post.
        foreach (SyndicationCategory category in blogItem.Categories)
        {
            category.Name;
            category.Scheme;
            category.Label;
        }
 
        // Get the Links associated with this blog post.
        // e.g. Comments (replies), self, alternate, edit links etc
        foreach (SyndicationLink link in blogItem.Links)
        {
            link.Title;
            link.Uri;
            link.RelationshipType;
        }
 
        // Get the Authors associated with the blog post.
        foreach (SyndicationPerson author in blogItem.Authors)
        {
            author.Name;  // Raja Nadar
            author.Email; // noreply@blogger.com
            author.Uri;   // Profile Url for blogger
        }
    }
}

obviously, the code won’t compile :), not because i wrote it, but that i have just highlighted the relevant fields I used. not assigned or used them anywhere..

so explore the Syndication APIs and code happily ever after.

Found multiple X.509 certificates using the following search criteria: StoreName ‘My’, StoreLocation ‘LocalMachine’, FindType ‘FindBySubjectName’, FindValue ”. Provide a more specific find value.

the error message could not have been more concise.. I had a look at the code, and there was nothing programmatic to verify. it was all WCF configuration driven [that I like so much J].

the configuration for binding was as follows:

<bindings>

  <wsHttpBinding>

    <binding name=“wsHttpEndpointBinding“>

      <security mode=“Message“>

        <message clientCredentialType=“Certificate“ />

      </security>

    </binding>

  </wsHttpBinding>

</bindings>

the configuration for service credentials was as follows:

<serviceCredentials>

  <clientCertificate>

    <certificate storeLocation=“LocalMachine“ storeName=“My“

                 x509FindType=“FindBySubjectName“ />

    <authentication revocationMode=“Online“ trustedStoreLocation=“CurrentUser“ />

  </clientCertificate>

  <serviceCertificate findValue=“rajanadar.com“ storeName=“My“

                      storeLocation=“LocalMachine“

    x509FindType=“FindBySubjectName“ />

</serviceCredentials>

I thought, the search ‘rajanadar.com’ may be returning more than one certificate from the store. (may be due to root certificates etc.., I don’t know)

I checked my certificate store, and gave a specific (unique) Subject Name and tried different things.

no luck, still the same issue.

after a little observation, I read the error message a little more carefully.. (why didn’t I do this the first time?)

Found multiple X.509 certificates using the following search criteria: StoreName ‘My’, StoreLocation ‘LocalMachine’, FindType ‘FindBySubjectName’, FindValue ”. Provide a more specific find value.

it complained of a blank ‘FindValue’

then it struck me that we missed the FindValue for the client certificate, not the service certificate.

The corrected configuration was:

<serviceCredentials>

  <clientCertificate>

    <certificate storeLocation=“LocalMachine“ storeName=“My“

        x509FindType=“FindBySubjectName“ findValue=“uniqueclient.rajanadar.com “ />

    <authentication revocationMode=“Online“ trustedStoreLocation=“CurrentUser“ />

  </clientCertificate>

  <serviceCertificate findValue=“server.rajanadar.com“ storeName=“My“

             storeLocation=“LocalMachine“ x509FindType=“FindBySubjectName“ />

</serviceCredentials>

that solved the issue. it was a simple silly mistake. (obviously only after it was caught)

the next error I encountered, sounded something like:

Unhandled Exception: System.Net.WebException: The underlying connection was closed: Could not establish secure channel for SSL/TLS.

Fortunately, my past sleight of hand on WSE and SSL certificates, quickly reminded me that, when dealing with Web Applications, I need to give sufficient access permissions to the aspnet user account, to the PFX files of the certificates.

I modified the access permissions of the PFX file in question, (yeah the \AppData\Microsoft\Crypto\RSA\MachineKeys path) and the application seemed to work without any more issues. silly things, nonetheless there’s a first time..

p.s. the aspnet user account permission issue reminds me of one more classic issue that I encountered most of the times..

[SecurityException: Requested registry access is not allowed.] 

Microsoft.Win32.RegistryKey.OpenSubKey(String name, Boolean writable)

System.Diagnostics.EventLog.FindSourceRegistration(String source, String machineName, Boolean readOnly)

System.Diagnostics.EventLog.SourceExists(String source, String machineName) +79

System.Diagnostics.EventLog.SourceExists(String source)

this is again because, creating a new event log or event source, needs registry write permissions, typically not possessed by the aspnet account.

Solution: initially, I used to grant write permissions to the registry keys

(HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Eventlog\NewLog or HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Eventlog\Application\Source)
 

But then, this is not a good security approach. during the lifetime of the application, it just needs to write to the event logs and never create new ones. Hence I created the new registry keys (effectively new event logs/sources) using my Installers, and granted read permissions to the web application accounts. this sounded good.

there’s a solution to every problem; given enough time and sometimes, well, just time…

every time, a Linq Query is executed (accessed), the expressions tree/Linq query is translated into its equivalent SQL/data source query and the results are fetched. for static data and data, changing on parameter values, the repeated translation is redundant.

Assume we have the following methods:

GetAllProductsAuthorizedToBeSoldInIndia()
{
 // Linq query to join Products and Country table on key for 
 // India and return the expected products.
}

now if we access this method N times, the LINQ query will have N SQL translations, for the same result that it will fetch. clearly this is a performance bottleneck.

also consider a parameterized method:

GetAllProductsAuthorizedToBeSoldInACountry(int countryId)
{
 // Linq query to join Products and Country table on 
 // CountryId and return the expected products.
}

Except for the parameter value, the generated SQL query has to be re-generated every time.

To solve this, we use Linq Compiled Queries. They facilitate one time translation of the Linq query, and re-use of the translated query across multiple calls.

public class MyCompiledQueries
{
  private static 
  Func<MyDatabaseContext, IQueryable<Product>> 
  ProductsAuthorizedToBeSoldInACountry 
  = CompiledQuery.Compile(
  (MyDatabaseContext db, int countryId) => 
  db.Products(p=>p.CountryId=countryId)); 
 
  public static List<Product>  
  GetAllProductsAuthorizedToBeSoldInACountry
  (MyDatabaseContext db, int countryId)
  {
    return MyCompiledQueries. ProductsAuthorizedToBeSoldInACountry(
    db, countryId).ToList<Product>();
  }
}

the queries are translated once, and the parameter values are substituted at runtime.

1. The CompileQuery.Compile method returns us a delegate, which can be invoked repeatedly.
2. The appropriate parameters need to be passed to the delegate during the invocation. (data context + query parameters)
3. Because we need to reuse the delegate to actually have any performance benefit, static variables/method wrappers are preferred.
4. It is a good practice to put all of your Compiled Queries into a separate class, at one place, and possibly have wrapper methods which make more business sense than entity names.
5. on my box, performance increased by 220%, when I changed my queries to Compiled Queries. I was working on a test domain data application using Linq. this was just slightly less than the data reader performance, we get.

the syntax for compiled queries makes it a little tough to maintain, but the benefits are sweet n totally worth the effort.

This is because the call to a Compiled Linq Query involves calling the Compile() method:

public static Func<TArg0, TArg1, TResult> 
 
CompiledQuery.Compile<TArg0, TArg1,  TResult>
 
(Expression<Func<TArg0, TArg1, TResult>> query)
 
 where TArg0 : DataContext;

Now if the above syntax makes total sense to you, then you are probably over the following words. Else, you could read on to make sense of the above syntax.

Assume we have a delegate type defined as follows:

delegate int MyDelegateType(int a, int b)

this delegate can contain (thinking of code container) all methods which return ‘int’ and take 2 integer parameters.
E.g.

public int AddMethod(int a, int b)
 
MyDelegateType myDelegateObject = new MyDelegateType(AddMethod);

As you know, C# 2.0, simplifies this synax. we can now do:

MyDelegateType myDelegateObject = AddMethod;

looks good so far..

Now suppose, we make the delegate deal with generic types.

delegate T MyGenericDelegateType<T> (T a, T b)

this delegate can contain all methods which return ‘T’ type and take 2 T type parameters.

MyGenericDelegateType<int> myGenericDelegateObject = AddMethod;

Now, this is the AddMethod

public int AddMethod(int a, int b)
{
  return a + b;
}

As you know using C# 2.0 anonymous methods, we could write:

MyGenericDelegateType<int> myGenericDelegateObject =
delegate (int a, int b) { return a + b };

C# 3.0, further simplifies this anonymous method syntax, by eliminating even the delegate keyword, and getting the => operator. (Lambda Expressions coming in..)

Hence in C# 3.0, we can write:

MyGenericDelegateType<int> myGenericDelegateObject =
(int a, int b) => return a + b;

A further simplification to the above syntax is removing the types declared. This is because C# 3.0 is equipped with the type inference feature.

MyGenericDelegateType<int> myGenericDelegateObject = (a,b) => a + b;

Notice how we removed even the return keyword. This is perfectly valid, if the method contains only a single return statement.

Now the System.Linq namespace already defines some generic delegates for us. e.g. One of them is:

public delegate TResult Func<A0, A1, TResult> (A0 arg0, A1 arg1);

What this means is we don’t need to define our own delegate types, every time we want to use one with a similar signature.

we could directly say:

Func<int, int, int> myLinqDelegateObject = AddMethod;

Here TResult, A0 and A1 are int types. Replacing by lambda expressions,

Func<int, int, int> myLinqDelegateObject = (a,b) => a+b;

We can use this delegate object as

int sum = myLinqDelegateObject(3, 4);  // sum = 7;

Here myLinqDelegateObject is nothing but a delegate object (instance), of a delegate type already defined by the System.Linq namespace.

An Expression Tree is nothing but an object of type

System.Linq.Expressions.Expression<TDelegateType>

, where TDelegateType is the delegate the tree represents.

e.g.

Expression<Func<int, int, int>> myExpressionTreeObject = (a,b) => a+b;

Expression trees are nothing but an in memory representation of code. sort of a mini code segment, which can be evaluated later on demand, and can be built upon.

Based on all the points above, if we see the syntax now:

public static Func<TArg0, TArg1, TResult> 
 
CompiledQuery.Compile<TArg0, TArg1,  TResult>
 
(Expression<Func<TArg0, TArg1, TResult>> query)
 
 where TArg0 : DataContext;

It should look clear that, the Compile method takes in an Expression Tree object (query), of which the first parameter should be of type DataContext (Generic Contraint), and the return type is a Delegate object. Func

So the use of the Compile method would be as follows:

var queryDelegate =  CompiledQuery.Compile(
 
  (MyDataContext db, string param1, string param2) =>
 
  db.MyEntity
     .Where(v => v.Column1.Trim().ToLower() == param1.Trim().ToLower())
     .Where(v => v.Column2.Trim().ToLower() == param2.Trim().ToLower()));

Here queryDelegate is of type:

Func<MyDataContext, string, string, IQueryable<MyEntity>>

and can be used as follows:

var MyEnitities = queryDelegate(db, param1value, param2value);

As you can see, concise delegate syntax ( => ), generics (T), anonymous methods/types (var), type inference (var), lambda expressions (=>) etc, work under the hood for the Compile method. C# 3.0 is cool.

As for the exact use of Linq compiled queries, their advantages and disadvantages, I’ll be writing about it in part 2 of this post..

I decided to get clear on these terms with the help of my friend, Wiki. So completely based on it, here is the quick summary of the release cycle stages, their order and meaning..

1. Pre-Alpha: Not feature complete, refers to all activities prior to Software Testing. e.g. Milestone versions, Nightly builds etc
2. Alpha: Build delivered to the internal Software Testers for testing.
3. Beta: (also known as Preview, Prototype, Technical Preview or Community Technical Preview Release stage): Build which has passed alpha testing and has been released to external customers/prospective customers (acting as free beta testers) for external feedback/improvements.
4. Release Candidate (RC): (also known as Golden Master, Gamma, Delta, Omega, Zenith etc): A code complete version with potential to be a final product, with no fatal bugs/showstoppers.
5. Gold (also known as General Availability Release GA): Production or Live version of a particular product. ready for distribution.
6. Release To Manufacturing (RTM): Used when the Gold version is sent to a product manufacturer for physical distribution (CDs, DVDs etc) Box Copy is the term used for this physically created version of the product.
7. Release To Web (RTW): If the RTM distribution is online, RTM is called as RTW.

Always good to know the terms once, and be clear forever.

Source: http://en.wikipedia.org/wiki/Software_release_life_cycle

assume we have a class as follows:

public class BusinessObject
{
    private const int MagicFactor = 18;
 
    private int CalculateConfidentialValue(int baseAmount)
    {
        return baseAmount * BusinessObject.MagicFactor;
    }
}

obviously, the method and magic factor are not super-confidential or anything. but let us pretend, they are.

here both the constant and the method are private. needless to say, the following Test Method won’t compile.

[TestMethod()]
public void WontCompileCalculateConfidentialValueTestMethod()
{
    BusinessObject myObject = new BusinessObject();
 
    int magicFactor = BusinessObject.MagicFactor;
 
    Assert.AreEqual(18, magicFactor);
    Assert.AreEqual(magicFactor * 2, myObject.CalculateConfidentialValue(2));
}

this is where private accessors help us. Private Accessors help us to access the Private members and Methods of an object, so that we can unit test them.

1. go to the BusinessObjects class file
2. Right Click >> Create Private Accessor >> Test project..

something similar is created behind the scenes:

[Shadowing("PrivateAccessorDemo.BusinessObject")]
public class BusinessObject_Accessor : BaseShadow
{
    protected static PrivateType m_privateType;
 
    [Shadowing(".ctor@0")]
    public BusinessObject_Accessor();
    public BusinessObject_Accessor(PrivateObject __p1);
 
    [Shadowing("MagicFactor")]
    public static int MagicFactor { get; }
    public static PrivateType ShadowedType { get; }
 
    public static BusinessObject_Accessor AttachShadow(object __p1);
    [Shadowing("CalculateConfidentialValue@1")]
    public int CalculateConfidentialValue(int baseAmount);
}

you don’t need to try and understand that. all you need is how to use the created code, and here it is:

[TestMethod()]
public void CalculateConfidentialValueTestMethod()
{
    BusinessObject_Accessor target = new BusinessObject_Accessor();
 
    int magicFactor = BusinessObject_Accessor.MagicFactor;
 
    Assert.AreEqual(18, magicFactor);
    Assert.AreEqual(magicFactor * 2, target.CalculateConfidentialValue(2));
}

As we can see, we could now test the Private Member and the Private Method using the accessor.

Another good thing about the private accessors now, is the way we can test for exceptions thrown by the method.

Assume we modify our source method to:

public class BusinessObject
{
    private const int MagicFactor = 18;
 
    private int CalculateConfidentialValue(int baseAmount)
    {
        if (baseAmount == 0)
        {
            throw new ArgumentException("argument cannot be zero.", "baseAmount");
        }
 
        return baseAmount * BusinessObject.MagicFactor;
    }
}

To test, if an argument exception is indeed thrown, we could write an unit test case as follows:

[TestMethod()]
[ExpectedException(typeof(System.ArgumentException))]
public void CalculateConfidentialValueWithZeroParameterTestMethod()
{
    BusinessObject_Accessor target = new BusinessObject_Accessor();
    target.CalculateConfidentialValue(0);
}

1. I believe this is possible, because of the Shadowing attribute which is now used for private accessors changing the way exceptions are returned by the target object.
2. Before the Shadow based reflection, the accessor always threw a System.Reflection.TargetInvocationException and the inner exception needed to be evaluated.
3. The concise attribute based exception check for ArgumentException could not be checked.

Private Accessors are very useful, when you are testing the Business Layer or OM.

there’s a solution to every problem; given enough time and money..

– intended for reading/laughing/forgetting purposes only

1. it removes the dependency from any external unit testing libraries like NUnit. (though NUnit was worth all its bits)
2. it is part of the build process and we can use the VSTS test runner (MSTest.exe), if the test cases need to be run separately, rather than from the IDE.
3. Code coverage can be done using the test config file.
4. it also provides support for deploying the required support files for the test cases to run successfully. (xml files, config files etc) explained later.
5. the code can be debugged using the test cases.
6. regression testing is very reliable, when features change in your application.
7. The test cases can be organized using the ‘Test Manager’

 Let us take a small and simple example. I have a sample ‘Add’ method which I want to test:

public int Add(int a, int b)
{
    return a + b;
}

To create a Unit test for this method/project, you could just right click inside the file containing this method >> Create Unit Tests and you can have the whole test project template within seconds.

The Unit Test is as follows:

[TestMethod()]
public void AddTest()
{
    Calculator target = new Calculator();
 
    int a = 8;
 
    int b = 16;
 
    int expected = 24;
    int actual;
 
    actual = target.Add(a, b);
 
    Assert.AreEqual(expected, actual);
}

• The Test class is attributed with the [TestClass()]attribute.
• The Test method is attributed with the [TestMethod()]attribute.
• There are also some other interesting attributes at the Test Method level:
• [ ExpectedException(typeof(Exception))] >> This attribute makes the unit case, expect the type of exception provided, and does not fail the test case when that exception occurs. This is usefule if there are -ve test cases. (E.g FileNotFoundException, Business Exceptions etc)
• [Description("Test Case Id: 2.34 Add two valid numbers.")] >> This attribute makes it easier to name a test case according to your test case list. Whenever the test case fails, you can see the Description and identify the exact test case which failed.
• [WorkItem(9999)] >> This attribute is helpful in associating the test case with a work item in your scrum/tfs/project management tool.
• [Ignore()] >> If there are some test cases, which need not be executed at this point of time, this attribute can be used.

 TestSolution.vsmdi

• This file is basically what the test manager controls. It is used to group all the test cases in the solution.
• As you notice, this file is a solution level item and hence common to all the project unit cases in your application.
• You can create ‘New Test Lists’ and arrange your test cases as per Projects/Business Objects/Layers etc.
• Once arranged, the specific test cases can be executed.

localtestrun.testrunconfig

• This is the common configuration file for all the test cases in your application.
• It controls the naming scheme for the output folder it creates, where the test run results are stored.
• Code Coverage can be enabled for the assemblies.
• The Deployment option provides the support files, which you may want to deploy for the test cases to run successfully.
• It also provides a ‘Startup’ and ‘Cleanup’ script option to be run, before and after the test case run.

there are other cool features of the Unit Testing framework like, reading test data from data sources, private accessors, web tests, load testing, linking it to external test controllers and agents etc..

 there’s a solution to every problem; given enough time and money..

i had written this snippet way back, for a legacy application in which a simple GUID or auto-incrementing big ineteger could not be used as the primary key.

i just rewrote it in the Katmai IDE, and the first feel of native intellisense in SQL studio is refreshing.

here goes the snippet:

Declare @currentKey varchar(32)
Declare @nextUniqueKey varchar(32)
Declare @currentKeyLength int
Declare @counter int
Declare @newKeyHasCarry bit
Declare @singleChar char(1)
 
-- Let us assume, we have a current key and we are looking for
-- the next incremental unique key.
SELECT @currentKey =  'Test129'
 
SET @currentKey = UPPER(@currentKey)
SELECT @currentKey	    
 
-- Logic to build the incremented AlphaNumeric key value, which is unique.
 
SET @counter = 0
SET @nextUniqueKey = ''
SET @newKeyHasCarry = 0
SET @currentKeyLength = Len(@currentKey)
 
-- Iterate through each character in our current key to find the increment.
-- We'll have a carry, if we see '9' as the last character.
While @counter <= @currentKeyLength
Begin
 
SET @singleChar = SubString(@currentKey, @currentKeyLength-@counter, 1)
 
-- We need to increment only if there is a carry, or if it is our first iteration.
IF (@newKeyHasCarry = 1) OR (@counter=0)
Begin
        -- Increment 9 to 'A'
		IF IsNumeric(@singleChar) = 1
		Begin
				IF @singleChar = '9'
					 Begin
					  SET @singleChar = 'A'
					  SET @newKeyHasCarry = 1
					 End
				Else
					 Begin
					  SET @singleChar = @singleChar + 1
					  SET @newKeyHasCarry = 0
					 End
		 End
		Else
		Begin
 
			IF @singleChar='Z'
			 Begin
			  SET @singleChar = '0'
			 End
			Else
			 Begin
			  SET @singleChar = Char(ASCII(@singleChar) + 1)
			 End 
 
			SET @newKeyHasCarry = 0
		End
End
 
-- Append the new character, to construct the key in a reverse direction.
SET @nextUniqueKey = Cast((@nextUniqueKey + @singleChar) AS varchar(255))
SET @counter = @counter + 1
End
 
-- Reverse the key to get the proper unique key.
SET @nextUniqueKey = Reverse(@nextUniqueKey)
 
SELECT UPPER(@nextUniqueKey)
-- End of snippet
-- End of snippet

Notes:

1. After ‘Z’, the next incremental character is assumed to be ‘0′ [zero]
2. The snippet is case insensitive.
3. I like the in-built intellisense of SQL 2008. getting rid of external tools is nice.

there’s a solution to every problem; given enough time and money..