In my time with Oracle, the company shifted it’s course from OCI-Classic to onboarding all new customers, and migrating current customers to OCI. This would provide some challenges for current customers as they would require an exercise in taking inventory of their current cloud resources. This would help in capacity planning for their future in Oracle’s cloud. Some customers kept up to date spreadsheets of all their current services in OCI-C, while others were seeking help with a more automated approach at mapping their current OCI-C resources.

The Situation

I was assigned to help a customer with their capacity planning for migration. They were in need of some information that Oracle couldn’t provide (as it was beyond a security boundary) and other information that could be provided programmatically using the OPC API. I was determined to give this customer the most information that could be provided in an automated fashion. They were specifically interested in their IaaS compute instances and collecting metadata information about them. I figured a simple CLI application could do the trick.

The Solution

I was able to cobble together a NodeJS application that could be configured with endpoint information, check the user’s credentials and pull all the necessary information down from the API. Once that was done, we could introspect it for the specific information we were looking for and write it to a simple CSV file.

If you’re on OCI-C and need to collect your own IaaS instance information, hopefully this tool can help you too!

Click to check the Repo out on GitHub

I bought a new computer a while back. I do a lot of file moving/manipulation/cleanup on my home PC because I’m an avid Plex user. For these tasks I simply use .bat or .cmd files and the Windows task scheduler. It’s quite a simple solution and generally runs like clock work. Until it doesn’t and you can’t understand why.

First Attempt

After some internet searches I stumbled across the Tweaking.com windows repair program that offered fixes and had quite a few recommendations. With my fingers crossed I installed the app and tried it out. It did not fix my Windows task scheduler problem. But I did end up buying a license for it because it’s an amazing piece of software that does a lot of optimizations.

Coding Your Own

Time to think about rolling my own. What do I need this thing to do?

1. Always be running
2. Run .bat or .cmd files on an interval

So for #1 something always running, I immediately think Windows service. I’ve long used TopShelf for this sort of thing. It’s highly configurable and easy to use. For #2 I considered using Quartz.NET, but I thought it would be overkill. I just rolled my own interval and tracking code. I specifically needed to run .bat and .cmd files, for this I found a project called MedallionShell. It runs commands in threads within your application. You could use it for parallelism, but I decided not to introduce that complexity into my simple use case.

Learning

This project brought some fun learning aspects. I was able to implement builds using Cake builds for C# and also automate my builds using AppVeyor. With all of this in place it will build my code and put a release on GitHub for me. Pretty nifty! Even got some badges working on the project home page.

Conclusion

I learned a lot doing this simple little project and had a lot of fun doing it. I wish I knew why the Windows task scheduler doesn’t run my tasks. I guess as long as it runs all of the other important ones, I can be good with that.

Click to check the Repo out on GitHub

Editor(s)

So many to choose from in this department. Personally I chose WebStorm because it afforded me that debugging experience I was looking for in the IDE. SublimeText and VS Code are excellent options as well, but like I said… Debugging.

Getting Lessons

My first round of searches brought me to an excellent video tutorial by Brad Traversy on MEAN Stack Front To Back. It’s a series in which you’ll use ES6 to create a MEAN stack application that does some simple authentication. It’s a great series, I highly suggest watching it and checking out the code here. It uses ES6 and like I said, I’m looking for TypeScript.

My next round of searching brought me to Brian Love’s blog where he has an article TypeScript2 + Express + Mongoose + Mocha + Chai. Whew! That’s a mouth full, and a lot of tech to learn. It’s a fantastic article about combining all those technologies to get a running MEAN stack application with testing. Check out his article here and certainly check out the code here.

Combo

My mission was to combine the two projects to make one MEAN application with a TypeScript and test driven backend and an Angular2 front end. I was able to take the lessons learned about TypeScript, Grunt, Mocha and Chai and apply it to the meanauthapp created in Brad’s videos. It makes for very easy and type-safe development with NodeJS. Big thanks to both Brian and Brad for their work!

Click to check the Repo out on GitHub

Isn’t the whole point of durable, reliable messaging that we can re-queue a message for processing?
– Me

The Background

I recently got involved in a project using Azure Service Bus. The premise was simple, run service bus queue messages through a WebJob durably and reliably. For this project I ended up using the Topics feature for a publish/subscribe model. I got the project up and running fairly quickly thanks to the WebJobs SDK. By default the message will be attempted 10 times and then automatically sent to the DeadLetter queue. So to test this, I throw an exception during message processing and sure enough it goes as expected. I now have a message in the DeadLetter queue. In the Azure Management Portal I can see the message exists where it’s supposed to. As of the writing of this article the Azure Management Portal only supports changing the properties of Topics and not managing the messages in them.

Supplemental Software

What I need is a piece of software that will let me manage the messages in the queue. I could write it myself, but this seems like a task there would be a tool for.

My first round of searches dug up Service Bus Explorer. It’s a free Service Bus management tool. It looks like a great piece of well thought out management software, but I was unable to get the DeadLetter Repair and Resubmit Message to work properly for me.

Update: After a bit of digging about BrokeredMessage serialization I was able to find this article on StackOverflow explaining how to dictate how Azure Service Bus handles my message content. After implementing that Service Bus Explorer is working like a charm.

My next round of digging brought me to Azure Management Studio. This is a paid piece of management software that helps manage more than just your Service Bus. This tool was able to properly copy and re-submit the queue message back to it’s Topic of origin. Success!

Side Note

If Domain Driven Design and Message Queues are highly important to your system, you may want to check out NServiceBus. I just needed some bolt-on queues for middleware which is why I decided to just tackle queueing on my own.

Happy coding!

So I decided to just use my favorite REST client RestSharp to contact a fairly simple REST API for WooCommerce. But I was running into a strange authentication issue and being denied authentication with a 401 status code.

Now, first a disclaimer… DO NOT USE HTTP FOR WooCommerce IN A PRODUCTION ENVIRONMENT!

Ok, but I need to do some testing in a local environmnet so I can see that my code is working properly. Reading the WooCommerce documentation for authentication, which can be found here, it clearly states:

The OAuth parameters must be added as query string parameters and not included in the Authorization header. This is because there is no reliable cross-platform way to get the raw request headers in WordPress.

So I do a bit of digging about RestSharp and OAuth1.0 and come up with this suite of tests. Here’s the important bit that I needed:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

[Test]
public void Can_Authenticate_OAuth1_With_Querystring_Parameters()
{
    const string consumerKey = "enterConsumerKeyHere";
    const string consumerSecret = "enterConsumerSecretHere";
    const string baseUrl = "http://restsharp.org";
    var expected = new List<string>
    {
        "oauth_consumer_key",
        "oauth_nonce",
        "oauth_signature_method",
        "oauth_timestamp",
        "oauth_version",
        "oauth_signature"
    };

    RestClient client = new RestClient(baseUrl);
    RestRequest request = new RestRequest(Method.GET);
    var authenticator = OAuth1Authenticator.ForRequestToken(consumerKey, consumerSecret);
    authenticator.ParameterHandling = OAuthParameterHandling.UrlOrPostParameters;
    authenticator.Authenticate(client, request);

    var requestUri = client.BuildUri(request);
    var actual = HttpUtility.ParseQueryString(requestUri.Query).AllKeys.ToList();

    Assert.IsTrue(actual.SequenceEqual(expected));
}

The above Authenticate method will do all the work and add all the parameters I need.

But wait… Something’s not right here. In the debugger it shows me that the parameters on the request are being added as cookes:

Strange, but ok. So I decided to make an extension method that does all the authentication, gets all the parameters added to the request, and then converts them to QueryString parameters.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public static class RestRequestExtensions
{
    public static RestRequest BuildOAuth1QueryString(this RestRequest request, RestClient client, string consumerKey, string consumerSecret)
    {
        var auth = OAuth1Authenticator.ForRequestToken(consumerKey, consumerSecret);
        auth.ParameterHandling = OAuthParameterHandling.UrlOrPostParameters;
        auth.Authenticate(client, request);

        //convert all these oauth params from cookie to querystring
        request.Parameters.ForEach(x =>
        {
            if (x.Name.StartsWith("oauth_"))
                x.Type = ParameterType.QueryString;
        });

        return request;
    }
}

So the code to build a request now looks something like this.

1
2
3
4

var client = new RestClient("http://example.com/api/v1");
var request = new RestRequest("/path/to/resource");
request.BuildOAuth1QueryString(client, "{consumer_key}", "{consumer_secret}");
var response = client.Execute(request);

And there we have it. Talking to WooCommerce with RestSharp.

For Production

I can not stress enough to not communicate over HTTP in production. In production, you should be using HTTPS. In that case you can use HTTP Basic Authentication. Then you will no longer need the BuildOAuth1QueryString extension method, you would simply add the Basic Authentication to the client like so:

1
2

//Basic over Https
client.Authenticator = new HttpBasicAuthenticator("{consumer_key}", "{consumer_secret}");

Hope this helps!

I’ve been curating this list of blog feeds since I became a developer a long time ago, so many of them may be out-dated. Still, there are always great articles popping up for me to read and dabble in the tech if I have the time. Personally I use Feedly for my RSS reader, but the file should easily import into your favorite RSS reader.

Developer Feed File - You may need to Right Click -> Save As

Anyhow, hope you enjoy!

Let’s just start basic. The first thing you should know about developing for whatever it is you want to write code for is the syntax of the language you’ll be using. Start simple, think “Hello World”.

If you’re learning an Object Oriented language (like C#), your next stop should be The four pillars of Object Oriented Design

• Abstraction
• Polymorphism
• Inheritance
• Encapsulation

Once you have an understanding of the 4 pillars in my opinion your next stop should be learning the SOLID principles

• Single responsibility principle
• Open/closed principle
• Liskov substitution principle
• Interface substitution principle

Once you’ve gotten to principles you can start to make more maintainable code in larger projects.

Finally, once you’ve gotten those down it’d be best to look into the Gang of Four Design Patterns. These are proven patterns for enterprise scale production systems. If you have a good understanding of the problem you’re trying to solve, there’s a good chance a combination of these patterns will help you solve it.

All of this being said, there are problems you come across time and again as a developer. One of the biggest ones I face often is that of cross cutting concerns. I have this thing that does one thing, but now needs to do another. For example, you have data going into a database and you’d like to audit who put the record in with some sort of logging. In this case there are many solutions, and you could even write your own using all those spiffy patterns. Or in my case I found a great library called MediatR that implements a nice architecture solving that problem for me. Sometimes with the right amount of digging you’ll find a good library that solves the recurring problems.

Update

It is almost imperative now to know about cloud architecture for hightly available and scalable applications. I had the pleasure of reconnecting with a former colleague of mine who so happens to be a cloud architect at Microsoft. He pointed me toward his GitHub for some guidance on Microsoft Azure cloud architecture. You can see the repository on his GitHub here.

Happy coding!

You can find more about hexo at http://hexo.io

Update

I was able to get some, but not all of my old posts back. It took a lot of digging and code re-formatting but it was worth it. Took some time learning EJS and Hexo template stuff, but the site is looking nice.

Much like everyone else, I started my career as a coder. Rob Conery from Tekpub has a great series on going from coder to developer here. Being the coder has it’s up sides, low responsibilities being one of them. If you just like to do what you do and go home, then there is no need to move up for you here. This usually consists of taking strict written or verbal requirements and turning them into a bit of code. This person is usually in charge of testing too. You usually are under at least one person who guides you a lot. But if you aspire to do more, you will most likely want to become a developer.

The Developer

The developer has a lot more decision making power when it comes to both requirements and system architecture. In most scenarios, a discovery phase of a project is done and then all of that is in turn made into functional requirements. The developer can be called upon to both try to make requirements from the discovery documents or review functional requirements for refinement. The developer also has a bit more reign when it comes to speaking to clients and making bigger decisions in system architecture and implementation.

The Architect

The architect has the ultimate power when it comes to the system architecture. This is the person called upon to solve the really complex problems. Usually the most talented person that codes for the hardest problems, but overall probably writes the least amount of code on the project. This sometimes isn’t by choice. A lot of the time it is due to the fact that this person is usually in charge of peer code reviews and other administrative duties. Especially duties of discovery and helping find all of the functional requirements. The architect also weighs the risks of implementing new technologies into the system. This person usually has the last call on what technologies go into the system, and what is left out.

The Project Manager

The PM is the person usually in charge of documentation and collaboration. Documenting the current processes through the discovery phase and then working with whom ever they need to to make a functional requirements document out of it. The PM does a lot of system testing to make sure everything passes to spec. The keep a constant watch over the project and budget to make sure that the client stays happy and the project comes in on budget.

The Decision

Starting out as a coder, you usually climb up the latter to a PM or an Architect. If you are in an unfortunate situation then sometimes you have to do it all. Depending on the type of person you are and your desires as a professional, you will choose different paths out of the coder role. I myself am finding that I’m having a hard time with the PM duties because I like to stay more on the technical side of things. I’m not sure if that may change in the future, but for now my next move up is most likely looking to be an Architect.

Conclusion

There comes a point in time as a coder where you will need to make a decision on which way is up. This decision will be made not only for career advancement, but also for some extra padding in the salary department. When that time comes you may be asked to try some things out that you may or may not love. I suggest you give it a good shot because you never know, some things might grow on you.

BlogEngine.NET

I was using BlogEngine.NET as my blog software. It actually worked really well, I had no real complaints. The only thing for me was that it wasn’t easily customized. By easy I mean pure and simple customizations. I was on a previous version of it because I hadn’t touched the site in a while, so I’m not sure if this has change or how much in later releases.

Orchard

I chose to go with the Orchard software for my new site. It is full featured and is very easily customized with modules and theme. It’s taken some getting use to, but everything I need to learn is pretty much in the Dashboard of Orchard. There are quite a few articles out there on getting started with Orchard, but a series I found particularly helpful was written by John Papa. You can find it here: http://johnpapa.net/orchardpart1

I’m thinking it will be a bit of an adventure still getting into this. The export and import of my blog worked out nicely. So from here on in, it’s Orchard or bust!

Update

Moved it again to Hexo, see this post for more details.

Enter xSql

xSQLSoftware This is where a tool such as xSQL Object can be extremely helpful. All that need be done is set up the connections, run the comparison, and then you can visually see what has changed between your development and live databases! No need to remember what you changed or any of that, just run the comparison and execute the change script. It will even allow you to save database snapshots before running your change scripts. You can see an excellent walkthrough here. xSQL Object also comes in a bundle with another one of their products, xSQL Data or by it’s self. xSQL Data allows you to compare data differences between two databases.

The Best Part

All the goodness of the xSQL Bundle (xSQL Object and xSQL Data) Lite Edition comes at a very affordable price FREE! If you only use SQL express edition then you can get the full bundle lite edition and it will work without any restrictions at all! However, if you need to use it against other versions of SQL Server it does have the following limitations:

• up to 25 tables
• up to 40 views
• up to 40 stored procedures
• up to 40 functions

If you are using it against a small database then you shouldn’t have any problems. Now if you have databases larger than this and are using SQL Server editions other than express, the product costs $399.00 for a single user license. BUT, after downloading it I was sent an email offering 30% off if I purchased the product within 7 days of the download. That brings the cost down to $280! Not too bad when you compare it with the prices of other comparable tools. So I ask you to go to the website and check it out if you haven’t already! http://www.xsqlsoftware.com

Update

After contacting the company about licensing, I was shown another one of their great tools. A little while back I wrote a post titled Finding Text in SQL Server Stored Procedures. They have a tool called xSQL Object Search that allows you to search for all object types, through the names and definitions, for strings. It will also do a search using regular expressions! Pretty powerful stuff for a **FREE **tool! Check it out here: xSQL Object Search

Happy Deployments!

To start with, you should have some kind of certificate. Most likely a *.pfx or *.p12 file. This can also come with a private key or password for the certificate’s encryption. This is what a standard WebRequest over SSL might look like:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public string GetData(string inputData)
{
    //will hold the result
    string result = string.Empty;
    //build the request object
    HttpWebRequest request = (HttpWebRequest)WebRequest.Create("https://someapi.com/");
    //write the input data (aka post) to a byte array
    byte[] requestBytes = new ASCIIEncoding().GetBytes(inputData);
    //get the request stream to write the post to
    Stream requestStream = request.GetRequestStream();
    //write the post to the request stream
    requestStream.Write(requestBytes, 0, requestBytes.Length);
    //build a response object to hold the response
    //submit the request by calling get response
    HttpWebResponse response = (HttpWebResponse)request.GetResponse();
    //get the response stream to read the response from
    Stream responseStream = response.GetResponseStream();
    //now read it out to our result
    using (StreamReader rdr = new StreamReader(responseStream))
    {
        //set the result to the contents of the stream
        result = rdr.ReadToEnd();
    }
    //return
    return result;
}

The example above is missing the portion where you add the certificate to the request. You may receive a 403 Forbidden error from the server if a certificate is required to make the request to the API server. A simple way of adding a certificate to the request would be like so:

1
2

//add certificate to the request
request.ClientCertificates.Add(new X509Certificate(@"C:\certs\Some Cert.p12", @"SecretP@$$w0rd"));

The X509Certificate class is found in the System.Security.Cryptography.X509Certificates namespace. Simply add a new certificate to the client certificates before calling for the response, and it should be sent with the request. However, you may encounter an exception with the message “The system cannot find the file specified”. I encountered this error after I got the application off my local machine and onto the development server. After doing some research I stumbled upon this kb article. This article opened my eyes to how using certificates is a little more complicated than I initially thought. Turns out the problem was that the user trying to access the certificate does not have a profile loaded.

After stepping through the article, installing the certificate to the local machine’s personal certificate store, and then granting rights to the certificate using the WinHttpCertCfg.exe tool, and putting in a little more code found in the kb article, I was well on my way. The article describes how to use C# to open a certificate store and use the certificate directly out of the store. This presents a bit more elegant, and in my opinion more secure, way of getting to and using the certificate.

1
2
3
4
5
6

//add it in a better way
X509Store certStore = new X509Store("My", StoreLocation.LocalMachine);
certStore.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
X509Certificate2 cert = certStore.Certificates.Find(X509FindType.FindBySubjectName, "My cert subject", false)[0];
certStore.Close();
request.ClientCertificates.Add(cert);

This method will not only give access to the certificate regardless of having a loaded profile, but it also takes the certificate’s private key password out of the code and/or configuration. This snippet above took me out of the certificate hell that was crushing my life for a couple days!

Putting it all together:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public string GetData(string inputData)
{
    //will hold the result
    string result = string.Empty;
    //build the request object
    HttpWebRequest request = (HttpWebRequest)WebRequest.Create("https://someapi.com/");
    //add certificate to the request
    //request.ClientCertificates.Add(new X509Certificate(@"C:\certs\Some Cert.p12", @"SecretP@$$w0rd"));
    //add it in a better way
    X509Store certStore = new X509Store("My", StoreLocation.LocalMachine);
    certStore.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
    X509Certificate2 cert = certStore.Certificates.Find(X509FindType.FindBySubjectName, "My cert subject", false)[0];
    certStore.Close();
    request.ClientCertificates.Add(cert);
    //write the input data (aka post) to a byte array
    byte[] requestBytes = new ASCIIEncoding().GetBytes(inputData);
    //get the request stream to write the post to
    Stream requestStream = request.GetRequestStream();
    //write the post to the request stream
    requestStream.Write(requestBytes, 0, requestBytes.Length);
    //build a response object to hold the response
    //submit the request by calling get response
    HttpWebResponse response = (HttpWebResponse)request.GetResponse();
    //get the response stream to read the response from
    Stream responseStream = response.GetResponseStream();
    //now read it out to our result
    using (StreamReader rdr = new StreamReader(responseStream))
    {
        //set the result to the contents of the stream
        result = rdr.ReadToEnd();
    }
    //return
    return result;
}

Hope this helps!

The query:

1
2
3
4
5
6
7
8
9
10
11

USE Northwind
GO 
DECLARE @SearchText AS VARCHAR(50)
SET @SearchText = 'CustomerID'

SELECT
ROUTINE_NAME,
ROUTINE_DEFINITION
FROM INFORMATION_SCHEMA.ROUTINES
WHERE ROUTINE_NAME LIKE '%' + @SearchText + '%'
OR ROUTINE_DEFINITION LIKE '%' + @SearchText + '%'

This query will return all the names and routine definitions of stored procedures that contain certain text. It is not really bound by column names but I needed a true development scenario. Run the query with what you are looking for and presto! All the stored procedures you will need to modify.

Hope this helps!

This task is easier to accomplish in SQL 2005 and 2008 using the ROW_NUMBER() function. The part that gets flaky is having a dynamic order by clause in your SQL statement. Unfortunately, the only way to accomplish this is to write some dynamic SQL. In doing so, It can be hard to tell if the order by parameter received by the stored procedure is a valid one for the table you are selecting from.

Solution

Enter the "IsValidOrderBy" user-defined function. This is a little function that will tell you if the column and order in the dynamic order by parameter is a valid one for the select statement you are running.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

CREATE FUNCTION [dbo].[udf_OrderByExists] 
(
    @TableName NVARCHAR(50),
    @OrderBy NVARCHAR(50)
)
RETURNS BIT
AS
BEGIN
 
    DECLARE @Result BIT
    SET @Result = 0
 
    DECLARE @TableColumns TABLE
    (
        [ColumnNameAndSort] NVARCHAR(100) NOT NULL
    )
 
    INSERT INTO @TableColumns
    SELECT [Name] 
    FROM syscolumns 
    WHERE ID = OBJECT_ID(@TableName)
 
    INSERT INTO @TableColumns
    SELECT [Name] + ' ASC' 
    FROM syscolumns 
    WHERE ID = OBJECT_ID(@TableName)
 
    INSERT INTO @TableColumns
    SELECT [Name] + ' DESC' 
    FROM syscolumns 
    WHERE ID = OBJECT_ID(@TableName)
 
    IF EXISTS(SELECT [ColumnNameAndSort] FROM 
        @TableColumns WHERE [ColumnNameAndSort] = @OrderBy)
        SET @Result = 1
 
    RETURN @Result    
 
END

Here you can see that we are taking 2 inputs. The first one being the table name you are selecting from, and the second being the order by clause received by the stored procedure. The function will then return a bit telling you if the column and order was found for the table you are selecting from.

Example

A simple example of using this user defined function would be selecting from a table of products. In that case, your stored procedure could look like so

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

CREATE PROCEDURE [dbo].[usp_GetProductsPaged]
    @SortExpression NVARCHAR(50),
    @PageIndex INT,
    @PageSize INT
AS
 
-- SET NOCOUNT ON added to prevent extra result sets from
-- interfering with SELECT statements.
SET NOCOUNT ON;
 
IF ((SELECT [dbo].[udf_OrderByExists]('dbo.Products', @SortExpression)) = 0)
    SET @SortExpression = 'Name'
 
DECLARE @sql AS NVARCHAR(MAX),
    @ParamDefinition AS NVARCHAR(MAX),
    @StartRowIndex INT,
    @RecordCount INT
 
SELECT @RecordCount = COUNT([ProductID]) FROM [Products]
 
IF @PageIndex = 0
    SET @PageIndex = 1
IF @PageSize = 0
    SET @PageSize = @RecordCount
SET @StartRowIndex = ((@PageIndex * @PageSize) - @PageSize) + 1
SET @ParamDefinition = N'@paramStartRowIndex INT, 
    @paramPageSize INT'
 
SET @sql = N'SELECT
    [ProductID],
    [Name],
    [Description],
    [Price]
FROM (SELECT
    [ProductID],
    [Name],
    [Description],
    [Price],
    ROW_NUMBER() OVER(ORDER BY ' + @SortExpression + ') AS [RowNumber]
FROM [Products]) AS [Prods]
WHERE [RowNumber] BETWEEN @paramStartRowIndex
        AND (@paramStartRowIndex + @paramPageSize) - 1'
 
-- For testing
--PRINT @sql
--PRINT @StartRowIndex
 
EXEC sp_executesql @sql, 
@ParamDefinition, 
@paramStartRowIndex = @StartRowIndex, 
@paramPageSize = @PageSize
 
SELECT @RecordCount AS [RecordCount]

As you can see, by calling **udf_OrderByExists **and passing in the parameters, if the order by does not fit the table, we then change it to be something known and valid.

Conclusion

With a simple and portable user defined function, we can ensure that the order by clauses going into our paging stored procedures are validated thus keeping integrity. It isn’t fun having to write and maintain dynamic SQL in stored procedures, but it can be done and also made a little bit safer. One last tip: Always use the sp_executesql, as this will tell the SQL server that the execution plan should be cached for re-use.

Hope this helps!

So we start off by making our data object, putting in the ability to mark it read only and giving it the ability to clone itself.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

public class Lion : ICloneable
{
    public Lion()
    {

    }

    public Lion(string name)
    {
        this.Name = name;
    }

    private bool _isReadOnly;

    public bool IsReadOnly
    {
        get { return _isReadOnly; }
    }

    private string _name;

    public string Name
    {
        get { return _name; }
        set 
        {
            if (_isReadOnly)
                throw new ReadOnlyException("This object is read only");
            _name = value; 
        }
    }

    public void MakeReadOnly()
    {
        _isReadOnly = true;
    }

    #region ICloneable Members

    public Lion Clone()
    {
        Lion result = (Lion)((ICloneable)this).Clone();
        result._isReadOnly = false;
        return result;
    }

    object ICloneable.Clone()
    {
        return this.MemberwiseClone();
    }

    #endregion
}

Take a look at line #43 above. During the cloning process, you can set the private variable _isReadOnly on the newly cloned object!

For some reason, I was under the impression that any and all private fields and methods were private to that instance of the object. This would mean that all private members of the cloned object would have to be called in the cloned object. To my surprise, this is not the case at all. After changing the _isReadOnly field of the cloned object, the object that was cloned will still remain read only. The cloned object will remain editable until the MakeReadOnly() method is called on it.

Conclusion

All fields and methods with the private access modifier are exposed at any time as long as you are in the containing type. The implications of this are that if you clone an object you will have access to the private members of the newly created object. This can be extremely useful, especially if you want a specific action to be performed on a cloned object but you don’t want to explicitly call that action publicly.

Hope this helps!

One part I really enjoyed about this sample is that your objects on the server are translated into client side objects. So Order.OrderID or Order.ShippingAddress.ShipName would work the same on the client and server side of the programming. The jtemplates add-in allows you to name your active object of the collection you are looping through a lot like .NET like so:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<tbody>
    {#foreach $T.d as order}
    <tr>
        <td>
            {$T.order.OrderID}
        </td>
        <td>
            {$T.order.ShippingAddress.ShipName}
        </td>
        <td>
            {DateDeserialize($T.order.OrderDate).format('MM/dd/yyyy')}
        </td>
        <td>
            {DateDeserialize($T.order.RequiredDate).format('MM/dd/yyyy')}
        </td>
        <td>
            {$T.order.ShippingAddress.ShipCountry}
        </td>
    </tr>
    {#/for}
</tbody>

As you can see the order object is used in the jtemplates code just like in .NET code.

You may have noticed the DateDeserialize() function followed by the extension method .format() in the snipped above. This is due to some date deserialization issues I ran into. The signature for the DateDeserialize method is as so:

1
2
3

function DateDeserialize(dateStr) {
  return eval('new' + dateStr.replace(/\//g, ' '));
}

This method is basically returning the evaluation of the date returned by the .NET framework (ex: /Date(894427200000)/), replacing the / with a space with the keyword "new" in front of it. This will return us a JavaScript Date object. Then I'm using the .format() extension method from the included MSAjax framework. It took me a little while to figure out, but once I did I fell in love. You can't put a price on full on object-oriented programming!

Special thanks to Dave Ward for opening my eyes to the power of JQuery!

Hope this helps!

The solution here is simple. Write a custom DataRow comparer that compares the DataRow against the column you are trying to put the distinct on. Here is an example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class PersonDataRowComparer : IEqualityComparer<DataRow>
{
    #region IEqualityComparer<DataRow> Members
    
    public bool Equals(DataRow x, DataRow y)
    {
        return (x.Field<int>("PersonID") == y.Field<int>("PersonID"));
    }
 
    public int GetHashCode(DataRow obj)
    {
        return obj.ToString().GetHashCode();
    }
 
    #endregion
}

Once we inherit IEqualityComparer<T> (T being the type we want to do the comparison on) all we do is fill in the Equals() and the GetHashCode() methods. In the Equals() method, we just tell the DataRows to compare the fields "PersonID" and return if they are equal. This will tell LINQ if the DataRow is distinct or not.

Hope this helps!

That was when I had a small epiphany. Why can’t I just make an abstract base class? Well the answer is you can! Sometimes I am prone to forget how .NET allows me to customize pre-defined classes. What we can do is create an abstract base class that inherits the UserControl class, then have our UserControls inherit from our base class.

First we will create our abstract base class.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

using System;
using System.Data;
using System.Configuration;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;

/// <summary>
/// Base class to be inherited by a UserControl that displays the date
/// </summary>
public abstract class DateTimeDisplayControl : UserControl
{
    /// <summary>
    /// Updates the date time inside the user control.
    /// </summary>
    public abstract void UpdateDateTime();
}

So in the snippet above, we have created a class called DateTimeDisplayControl. This inherits from UserControl and will have to override the abstract method UpdateDateTime().

Now we can create a couple of UserControls that inherit from our DisplayDateTimeControl class. The first control will be called "ControlOne".

Here is the *.ascx code:

1
2
3
4
5
6
7

<%@ Control Language="C#" AutoEventWireup="true" CodeFile="ControlOne.ascx.cs" Inherits="UserControls_ControlOne" %>
<p>User control one</p>
<asp:UpdatePanel ID="udp1"  runat="server" UpdateMode="Conditional">
    <ContentTemplate>
        <asp:Label ID="lblDateTime" runat="server" />
    </ContentTemplate>
</asp:UpdatePanel>

Here is the code behind:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

using System;
using System.Collections;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;

public partial class UserControls_ControlOne : DateTimeDisplayControl
{
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!Page.IsPostBack)
            UpdateDateTime();
    }

    public override void UpdateDateTime()
    {
        lblDateTime.Text = DateTime.Now.ToString();
        udp1.Update();
    }
}

As you can see, ControlOne contains an UpdatePanel with a Label inside of it. The Label will display the date and time. We will call our second control "ControlTwo" and it will look exactly like ControlOne, only it will say "User control two" inside of it.

Now we will create the actual *.aspx page to display the controls.

Here is the *.aspx code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

<%@ Page Language="C#" AutoEventWireup="true"  CodeFile="Default.aspx.cs" Inherits="_Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml&quot;>
<head runat="server">
    <title>Strongly Typed Dynamic User Controls</title>
</head>
<body>
    <form id="form1" runat="server">
        <asp:ScriptManager ID="sm1" runat="server" />
        <asp:UpdatePanel ID="udp" runat="server" UpdateMode="Conditional">
            <ContentTemplate>
                <asp:Panel ID="pnlContent" runat="server" />
            </ContentTemplate>
            <Triggers>
                <asp:AsyncPostBackTrigger ControlID="btnUseControlOne" EventName="Click" />
                <asp:AsyncPostBackTrigger ControlID="btnUseControlTwo" EventName="Click" />
                <asp:AsyncPostBackTrigger ControlID="btnUpdateDateTime" EventName="Click" />
            </Triggers>
        </asp:UpdatePanel>
        <p>
            <asp:Button ID="btnUseControlOne" runat="server" Text="Use Control One"
                onclick="btnUseControlOne_Click" />&nbsp;
            <asp:Button ID="btnUseControlTwo" runat="server" Text="Use Control Two"
                onclick="btnUseControlTwo_Click" />&nbsp;
            <asp:Button ID="btnUpdateDateTime" runat="server" Text="Update Content"
                onclick="btnUpdateDateTime_Click" />
        </p>
    </form>
</body>
</html>

Here is the code behind:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

using System;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;

public partial class _Default : System.Web.UI.Page
{
    private string _controlVirtualPath = string.Empty;
    private DateTimeDisplayControl _DateTimeDisplayControl = null;

    private string ControlVirtualPath
    {
        get
        {
            if (string.IsNullOrEmpty(_controlVirtualPath))
                _controlVirtualPath = ViewState["ControlVirtualPath"].ToString();
            ViewState["ControlVirtualPath"] = _controlVirtualPath;
            if (string.IsNullOrEmpty(_controlVirtualPath))
                throw new ApplicationException("The control virtual path was not found");
            return _controlVirtualPath;
        }
    }

    private DateTimeDisplayControl LoadedAjaxControl
    {
        get
        {
            if (_DateTimeDisplayControl == null)
            {
                _DateTimeDisplayControl = (DateTimeDisplayControl)Page.LoadControl(ControlVirtualPath);
            }
            return _DateTimeDisplayControl;
        }
    }

    private void LoadAndDisplayUserControl()
    {
        pnlContent.Controls.Add(LoadedAjaxControl);
    }

    private void LoadAndDisplayUserControl(string controlVirtualPath)
    {
        _controlVirtualPath = controlVirtualPath;
        pnlContent.Controls.Add(LoadedAjaxControl);
    }

    protected void Page_Load(object sender, EventArgs e)
    {
        if (!Page.IsPostBack)
            LoadAndDisplayUserControl("~/UserControls/ControlOne.ascx");
    }

    protected void btnUseControlOne_Click(object sender, EventArgs e)
    {
        LoadAndDisplayUserControl("~/UserControls/ControlOne.ascx");
    }

    protected void btnUseControlTwo_Click(object sender, EventArgs e)
    {
        LoadAndDisplayUserControl("~/UserControls/ControlTwo.ascx");
    }

    protected void btnUpdateDateTime_Click(object sender, EventArgs e)
    {
        LoadAndDisplayUserControl();
        LoadedAjaxControl.UpdateDateTime();
    }
}

As you may see, the *.aspx page will load up ControlOne by default. There are 3 buttons on the page that will allow you to swap out ControlOne and ControlTwo as well as call the UpdateDateTime() method of the controls.

That is all there is to it! One important note is that I am using a private property to get the loaded control, this is important to note because you will need to call that UpdateDateTime() method on the instance of the control that you rendered to the page. I don’t know why I didn’t think of this long ago, but I hope you will find it as useful as I did!

Happy coding!

An important note is that all event handlers that have been moved to the call stack will be fired. So when you call out to your custom event, all objects that are in the call stack with an event handler for that event will be fired. Another thing to keep in mind is that there is no guaranteed order in which the events will be fired. If you are in need of doing something that requires a specific order, you should use more events or take another approach entirely.

In this project, we will create some events and handle them in a logging system. The first thing we will need to do is set up an event delegate to strongly type our event. Along with doing that, I like to setup some custom event arguments that will take in the object(s) that I will be dealing with during the event.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

using System; using System.Collections.Generic; 
 
//Delegate for a PersonEvent 
public delegate void PersonEvent(PersonEventArgs e); 
 
public class PersonEventArgs : EventArgs 
{     
    public PersonEventArgs()     
    {              
    
    }     
    
    public PersonEventArgs(Person person)     
    {         
        this.Person = person;     
    }     
    
    public PersonEventArgs(List<Person> personList)     
    {         
        this.PersonList = personList;     
    }     
    
    //Person the action will be on     
    public Person Person { get; private set; }     
    
    //List of person the action will be on     
    public List<Person> PersonList { get; private set; }     
    
    //For canceling action     
    public bool Cancel { get; set; } 
}

Ok, Now all we have to do is declare and throw our events. When declaring our events, they will be of the type PersonEvent.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

using System.Collections.Generic; 
using System.ComponentModel; 
 
[DataObject(true)] 
public class PersonBLL 
{     
    //Declare events     
    public static event PersonEvent Pre_Get;     
    public static event PersonEvent Post_Get;     
    public static event PersonEvent Pre_Insert;     
    public static event PersonEvent Post_Insert;     
    public static event PersonEvent Pre_Update;     
    public static event PersonEvent Post_Update;     
    public static event PersonEvent Pre_Delete;     
    public static event PersonEvent Post_Delete;     
    
    [DataObjectMethod(DataObjectMethodType.Select)]     
    public List<PersonPresentationShell> GetPeople()     
    {         
        //Call out to event handler         
        if (Pre_Get != null)         
        {             
            PersonEventArgs args = new PersonEventArgs();             
            Pre_Get(args);             
            if (args.Cancel) return null;         
        }         
        
        List<PersonPresentationShell> result = new List<PersonPresentationShell>();         
        List<Person> personList = DataAccessFactory.GetPeople();         
        foreach (Person item in personList)         
        {             
            result.Add(new PersonPresentationShell(item));         
        }         
        
        //Call out to event handler         
        if (Post_Get != null)         
        {           
            PersonEventArgs args = new PersonEventArgs(personList);             
            Post_Get(args);             
            if (args.Cancel) return null;         
        }         
        
        return result;     
    }     
    
    [DataObjectMethod(DataObjectMethodType.Update)]     
    public void UpdatePerson(PersonPresentationShell p)     
    {         
        //Call out to event handler         
        if (Pre_Update != null)         
        {             
            PersonEventArgs args = new PersonEventArgs(p.Person);             
            Pre_Update(args);             
            if (args.Cancel) return;         
        }         
        
        DataAccessFactory.UpdatePerson(p.Person);         
        
        //Call out to event handler         
        if (Post_Update != null)         
        {             
            PersonEventArgs args = new PersonEventArgs(p.Person);             
            Post_Update(args);         
        }     
    }     
    
    [DataObjectMethod(DataObjectMethodType.Delete)]     
    public void DeletePerson(PersonPresentationShell p)     
    {         
        //Call out to event handler         
        if (Pre_Delete != null)         
        {             
            PersonEventArgs args = new PersonEventArgs(p.Person);             
            Pre_Delete(args);             
            if (args.Cancel) return;         
        }         
        
        DataAccessFactory.DeletePerson(p.Person);         
        
        //Call out to event handler         
        if (Post_Delete != null)         
        {             
            PersonEventArgs args = new PersonEventArgs(p.Person);             
            Post_Delete(args);         
        }     
    }     
    
    [DataObjectMethod(DataObjectMethodType.Insert)]     
    public void InsertPerson(PersonPresentationShell p)     
    {         
        //Call out to event handler         
        if (Pre_Insert != null)         
        {             
            PersonEventArgs args = new PersonEventArgs(p.Person);             
            Pre_Insert(args);             
            if (args.Cancel) return;         
        }         
        
        DataAccessFactory.InsertPerson(p.Person);         
        
        //Call out to event handler         
        if (Post_Insert != null)         
        {             
            PersonEventArgs args = new PersonEventArgs(p.Person);             
            Post_Insert(args);         
        }     
    } 
}

There we have it! An event will now be thrown before and after every get, insert, update and delete. Now we have to set up some event handlers in our logging object.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

using System; 
using System.IO; 
using System.Web; 
 
public class Logger 
{     
    //Set the log file location     
    private static string _logFileLocation = HttpContext.Current.Server.MapPath("~/App_Data/logfile.log");     
    
    static Logger()     
    {         
        //Attach event handlers         
        PersonBLL.Pre_Delete += new PersonEvent(PersonBLL_Pre_Delete);         
        PersonBLL.Post_Delete += new PersonEvent(PersonBLL_Post_Delete);         
        PersonBLL.Pre_Get += new PersonEvent(PersonBLL_Pre_Get);         
        PersonBLL.Post_Get += new PersonEvent(PersonBLL_Post_Get);         
        PersonBLL.Pre_Insert += new PersonEvent(PersonBLL_Pre_Insert);         
        PersonBLL.Post_Insert += new PersonEvent(PersonBLL_Post_Insert);         
        PersonBLL.Pre_Update += new PersonEvent(PersonBLL_Pre_Update);         
        PersonBLL.Post_Update += new PersonEvent(PersonBLL_Post_Update);     
    }     
    
    static void PersonBLL_Post_Update(PersonEventArgs e)     
    {         
        WriteToLogFile("PersonId: " + e.Person.PersonId.ToString() + " - " + e.Person.FirstName + " " + e.Person.LastName 
            + " was updated”);     
    }     
    
    static void PersonBLL_Pre_Update(PersonEventArgs e)     
    {         
        WriteToLogFile("PersonId: " + e.Person.PersonId.ToString() + " - " + e.Person.FirstName + " " + e.Person.LastName 
            + " is about to be updated”);     
    }     
    
    static void PersonBLL_Post_Insert(PersonEventArgs e)     
    {         
        WriteToLogFile("PersonId: " + e.Person.PersonId.ToString() + " - " + e.Person.FirstName + " " + e.Person.LastName 
            + " was inserted”);     
    }     
    
    static void PersonBLL_Pre_Insert(PersonEventArgs e)     
    {         
        WriteToLogFile("PersonId: " + e.Person.PersonId.ToString() + " - " + e.Person.FirstName + " " + e.Person.LastName 
            + " is about to be inserted”);     
    }     
    
    static void PersonBLL_Post_Get(PersonEventArgs e)     
    {         
        WriteToLogFile("The people were gotten”);     
    }     
    
    static void PersonBLL_Pre_Get(PersonEventArgs e)     
    {         
        WriteToLogFile("The people are about to be gotten”);     
    }     
    
    static void PersonBLL_Post_Delete(PersonEventArgs e)     
    {         
        WriteToLogFile("PersonId: " + e.Person.PersonId.ToString() + " - " + e.Person.FirstName + " " + e.Person.LastName 
            + " was deleted”);     
    }     
    
    static void PersonBLL_Pre_Delete(PersonEventArgs e)     
    {         
        WriteToLogFile("PersonId: " + e.Person.PersonId.ToString() + " - " + e.Person.FirstName + " " + e.Person.LastName 
            + " is about to be deleted”);     
    }     
    
    public static void WriteToLogFile(string message)     
    {         
        DateTime now = DateTime.Now;         
        using(StreamWriter sw = File.AppendText(_logFileLocation))         
        {             
            sw.WriteLine(now.ToString() + " - " + message);         
        }     
    } 
}

Finally, we have to create an instance of our logger class in the Global.asax file to attach our event handlers to our events when the application starts.

1
2
3
4
5
6

void Application_Start(object sender, EventArgs e)  
{     
    //Create an instance of the logger     
    //To attach event handlers     
    Logger logger = new Logger(); 
}

There we have it. Now on every CRUD operation in our application, a log entry will be written with some data about that action. Once you get the hang of it events become extremely useful. One big instance I like to use it for is authorization of performing an action in a membership and roles scenario.

Hope this helps!

A couple of good things to note is the placement of some key pieces for control adapters in the .NET framework. The ControlAdapter class should be inherited for every control adapter you create, it can be found in the System.Web.UI.Adapters namespace. All of the tags we will be overriding belong to the System.Web.UI.HtmlControls namespace.

The first tag we will override is the head tag itself.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

using System.Web.UI; 
using System.Web.UI.Adapters; 
using System.Web.UI.HtmlControls; 
namespace Rollem.ControlAdapters 
{     
    public class HtmlHeadAdapter : ControlAdapter     
    {         
        protected override void Render(HtmlTextWriter writer)         
        {             
            HtmlHead headTag = (HtmlHead)this.Control;             
            writer.WriteBeginTag("head");             
            if (!string.IsNullOrEmpty(headTag.ID))                 
                writer.WriteAttribute("id", headTag.ClientID);             
            writer.Write(HtmlTextWriter.TagRightChar);             
            foreach (Control item in headTag.Controls)                 
                item.RenderControl(writer);             
            writer.WriteLine("");         
        }     
    }  
}

Next we are on to the title tag.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

using System.Web.UI; 
using System.Web.UI.Adapters; 
namespace Rollem.ControlAdapters 
{     
    public class HtmlTitleAdapter : ControlAdapter     
    {         
        protected override void Render(HtmlTextWriter writer)         
        {             
            writer.WriteLine();             
            writer.WriteFullBeginTag("title");             
            writer.Write(Page.Title);             
            writer.WriteEndTag("title");             
            writer.WriteLine();         
        }     
    }  
}

Now the link tags.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

using System.Collections; 
using System.Web.UI; 
using System.Web.UI.Adapters; 
using System.Web.UI.HtmlControls; 
namespace Rollem.ControlAdapters 
{     
    public class HtmlLinkAdapter : ControlAdapter     
    {         
        protected override void Render(HtmlTextWriter writer)         
        {             
            HtmlLink linkTag = (HtmlLink)this.Control;             
            writer.Write("<link");             
            AttributeCollection attributes = linkTag.Attributes;             
            IEnumerator keys = linkTag.Attributes.Keys.GetEnumerator();             
            while (keys.MoveNext())             
            {                 
                string key = (string)keys.Current;                 
                if (key.ToLower() == "href" && attributes[key].Contains("~"))                     
                    writer.WriteAttribute(key, linkTag.ResolveClientUrl(attributes[key]));                 
                else                     
                    writer.WriteAttribute(key, attributes[key]);             
                writer.WriteLine(" />");         
            }     
        } 
    }
}

Last but not least, the meta tags.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

using System.Web.UI; 
using System.Web.UI.Adapters; 
using System.Web.UI.HtmlControls; 
namespace Rollem.ControlAdapters 
{     
    public class HtmlMetaAdapter : ControlAdapter     
    {         
        protected override void Render(HtmlTextWriter writer)         
        {             
            HtmlMeta metaTag = (HtmlMeta)this.Control;             
            writer.WriteBeginTag("meta");             
            if (!string.IsNullOrEmpty(metaTag.HttpEquiv))                 
                writer.WriteAttribute("http-equiv", metaTag.HttpEquiv);             
            if (!string.IsNullOrEmpty(metaTag.Name))                 
                writer.WriteAttribute("name", metaTag.Name);             
            writer.WriteAttribute("content", metaTag.Content);             
            writer.WriteLine(HtmlTextWriter.SelfClosingTagEnd);         
        }     
    }  
}

Now all we have to do is setup a *.browser file in the App_Browsers folder to map the control adapter overrides.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<browsers>     
    <browser refID="Default">         
        <controlAdapters>             
            <adapter controlType="System.Web.UI.HtmlControls.HtmlHead"                 
                    adapterType="Rollem.ControlAdapters.HtmlHeadAdapter" />             
            <adapter controlType="System.Web.UI.HtmlControls.HtmlTitle"                 
                    adapterType="Rollem.ControlAdapters.HtmlTitleAdapter" />             
            <adapter controlType="System.Web.UI.HtmlControls.HtmlMeta"                 
                    adapterType="Rollem.ControlAdapters.HtmlMetaAdapter" />             
            <adapter controlType="System.Web.UI.HtmlControls.HtmlLink"                 
                    adapterType="Rollem.ControlAdapters.HtmlLinkAdapter" />         
        </controlAdapters>     
    </browser> 
</browsers>

Now if we right click and view source we will see a nice clean head tag.

Don’t live a moment longer with that ugly ASP.NET rendered head tag! 

Hope this helps!