This toolkit is intended to improve web apps performance by decreasing total page size. This page size reduction is achieved by decreasing control ClientID size.
It’s been a year since I first made the code available at code.msdn.microsoft.com and now I decided to migrate it to CodePlex.
Try it !!!
In most common samples about faking static types, the type itself is public as the static methods are too.
Usually programmers tend to expose all members that going to be targeted by an Unit test. Well, that’s not how I see Unit tests.
I always try to produce code to keep the cyclomatic complexity lower, and If I succeeded I ended up with types that can be easily tested.
I won’t expose code simply to test it, code should always have the minimum visibility that it indeed requires.
Then I rely on tools to test all my type members, either private, internal or public.
Currently I use the Typemock Isolator and I must say that I’m completely satisfied.
So, here’s how I faked an internal static type and also override it’s GetString method to allow me test the first parameter value:
Type globalizationHelperType = Type.GetType("NG.Helper, NG", true);
Isolate.Fake.StaticMethods(globalizationHelperType);
Isolate.WhenCalled(() => globalizationHelperType.GetMethod("GetString", new Type[] { typeof(String) }).Invoke(null, new object[] { null })).DoInstead((callcontext) => { return callcontext.Parameters[0]; });
I’m not used to use Finalizers in my everyday job but I always thought that if I use it more frequently I could achieve some extra performance.
Well, I’m a natural lazy programmer and that prevents me from digging deeper and doing some tests to clarify this guess.
Thanks to community, there is always someone ready to share knowledge and help those lazy guys like me.
One of those guys were Andrew Hunter that posted an article named “Understanding Garbage Collection in .NET”.
In is article I found that:
- The Finalizer execution is non deterministic – it depends on GC and the way it’s operating: concurrent or synchronous.
- It requires two GC cycles to completely remove the object and memory footprint.
- Two many objects with Finalizers could slow down GC a lot
This don't mean that we shouldn’t use Finalizers, but we must take same care when we create Finalizers. The simplified way to Finalizer usage is:
- Implement System.IDisposable interface
- move Finalizer code to Dispose method
- Finish Dispose method execution with a GC.SupressFinalize() operation, this way the GC will know that this object wont need the Finalizer invocation and can be remove immediately.
- Invoke Dispose method in Finalizer – this way we ensure that external resources were always removed.
A deeper understand on this procedure, also known as the IDisposable Pattern, can be acquired by reading this article (kindly pointed by Luis Abreu).
Conclusion
Using finalizers don't bring any performance improvement but it’s wrong use can be a vector for severe memory management problems.
When we have a class that own external reference not managed automatically by Runtime then the IDisposable Pattern should be used to ensure the correct memory cleanup.
Finding out whether an assembly was compiled in Debug or Release mode is a task we must do from time to time.
I know two ways of accomplish this:
Either attributes are applied to Assemblies and can be found in the Assembly Manifest but there are a major difference between them:
- AssemblyConfigurationAttribute must be added by the programmer but is human readable.
- DebuggableAttribute is added automatically and is always present but is not human readable
You can easily get the Assembly Manifest by using the amazing ILDASM from your Visual Studio Studio Command Prompt:
And if you double click the MANIFEST item you will get all manifest data.
Looking carefully you will find the DebuggableAttribute:
And perhaps the AssemblyConfigurationAttribute:
AssemblyConfigurationAttribute
Locate the AssemblyConfigurationAttribute – this attribute can be easily interpreted: its value can either be Debug or Release
DebuggableAttribute
If AssemblyConfigurationAttribute is not present then we must use the DebuggableAttribute to get our goal.
Since we cannot understood the DebuggableAttribute value we have to open the assembly from another tool and read this attribute content. There’s no such tool available out-of-the-box but we can easily create a Command Line tool and use a method similar to:
private bool IsAssemblyDebugBuild(string filepath)
{
return IsAssemblyDebugBuild(Assembly.LoadFile(Path.GetFullPath(filepath)));
}
private bool IsAssemblyDebugBuild(Assembly assembly)
{
foreach (var attribute in assembly.GetCustomAttributes(false))
{
var debuggableAttribute = attribute as DebuggableAttribute;
if (debuggableAttribute != null)
{
return debuggableAttribute.IsJITTrackingEnabled;
}
}
return false;
}
or (if you prefer LINQ)
private bool IsAssemblyDebugBuild(Assembly assembly)
{
return assembly.GetCustomAttributes(false).Any(x => (x as DebuggableAttribute) != null ? (x as DebuggableAttribute).IsJITTrackingEnabled : false);
}
As you can see … it’s pretty simple.
Note:
Tipically I add a pre-build task to my build server so that the AssemblyConfigurationAttribute is added to the CommonAssemblyInfo file with the appropriated value: either “Debug” or “Release”. This way anyone can easily see, using only the ILDASM, which king of compilation was used to generate my assemblies.
Until 5 June the SmartBear is offering a five seat license of the new CodeReviewer 5.0, with full support and that never expires, for only 5 USD.
You must note that usually each user license is sell for 289 USD.
CodeReviewer is a web-based tool that simplifies and expedites peer code reviews and is specially oriented for small teams.
With such a price it’s a must have … even for our small pet projects.
Most web applications display messages to users. Displaying messages is the most effective way to inform user about errors and warnings or to simply display info or success status.
I also believe that most of those web applications renders user messages using HTML elements such as Div, Span or Label.
The others, mainly because their complex layout or business rules, have to render those messages using a different approach: they render each display message as a Javascript function call where the message itself is a function parameter. Such call could be simply like this:
string.Format("top.addMessage(\"{0}\");", message)
Those of you that already faced this problem won’t learn nothing new but I hope to alert the others and avoid them to face a problem that usually is only detected in advanced develop stage or even production environment.
Problem
The problem turns visible when the display message contains some special characters that prevent the function call to execute and trigger javascript errors.
Typically the characters are “ and ‘ but there are more.
Well, that is not completely correct, only the character “ is problematic, since he is the JSON string delimiter character, but, javascript engines also accept the character ‘ as a delimiter. The best way to avoid problems with ‘ is to ensure that the correct delimiter is used.
By now, you should be thinking that your applications are immune to this problem. Tell me, do you use string Resources? Most of us use, it’s a best practice and a smart choice. Also tell me, do you manage production string Resources? Most of us don’t. In fact, the application owner or sponsor can change it completely outside of your control scope.
String Resources are one of the major vectors of this problem but you can get this problem simply by trying to display an exception message:
string.Format("top.addMessage(\"{0}\");", exception.ToString())
Solution
What we are needing is an JScript.Encode method or similar that encode a C# string in such a way that it becomes a JSON encoded string.
Such method is not available on NetFX but, fortunately, Rick Strahl made a great post about this problem and made available a method that fits perfectly our needs.
Now that you know about it … use it.
This is subject to which I ended up returning from time to time, either for professional purposes, for some pet project or simply to help a friend.
For those of you that already played with Menu control knows that applying CSS styles to the standard ASP.NET Menu control can be a real frustrating task. For all the other I hope that this post avoid or at least reduce this pain.
Problem
The main question regarding styles is how the control renders. The Menu control renders HTML element TABLE, TR and TD and this approach bring us two main problems:
- Turns CSS style configuration more complex
- Increases the overall HTML size
I’m not sure why the control renders like this but I believe is related to multi browser CSS compatibility. We must not forget that even today we face several multi browser CSS problems (with IE8 the differences went minimal but we still have to deal with older browsers for many years) and by the time NetFX 2.0 saw the daylight the gap between browsers were larger and rendering HTML elements TABLE, TR and TD was the one that offered less compatibility issues.
Solution
Fortunately, ASP.NET 2.0 added the concept of ControlAdapter. This is a piece that can be associated to a control type and enable us to change the way that control renders.
As you can imagine, this opened a door to adjust controls without changing the control itself. But, there’s always a but, those kind of associations Adapter/Control are (out of the box) an application setting.
The mapping is made with a Browser Definition File Schema that should look similar to:
<browsers>
<browser refID="Default">
<controlAdapters>
<adapter controlType="System.Web.UI.WebControls.Menu"
adapterType="YourMenuAdapter" />
</controlAdapters>
</browser>
</browsers>
These files should be deployed to the App_Browsers folder.
Now that we know about the ControlAdapters is clear that we need one to the Menu control. Since I’m a lazy programmer, I won’t create from scratch a MenuAdapter. Instead I will use an existing one.
You can find in CodePlex a project that give us a set of Adapters very useful in most common scenarios: ASP.NET 2.0 CSS Friendly Control Adapters.
Between those adapters there’s a specific one for the Menu control. This adapter renders the Menu control as an unordered list using Div, Ul e Li HTML elements and this way allow us to easily apply CSS styles without loosing multi browser compatibility and with less Html signature. Here is an Html sample:
<div class="AspNet-Menu-Horizontal">
<ul class="AspNet-Menu">
<li class="AspNet-Menu-WithChildren AspNet-Menu-Selected"><a href="javascript:__doPostBack('ctl00$B$fvMenu','bTest 0')"
class="AspNet-Menu-Link AspNet-Menu-Selected">Test 0</a>
<ul>
<li class="AspNet-Menu-WithChildren AspNet-Menu-ParentSelected"><a href="javascript:__doPostBack('ctl00$B$fvMenu','bTest 0\\Test 1')"
class="AspNet-Menu-Link AspNet-Menu-ParentSelected">Test 1</a>
<ul>
<li class="AspNet-Menu-Leaf AspNet-Menu-ParentSelected"><a href="javascript:__doPostBack('ctl00$B$fvMenu','bTest 0\\Test 1\\Test 1a')"
class="AspNet-Menu-Link AspNet-Menu-ParentSelected">Test 1a</a> </li>
<li class="AspNet-Menu-Leaf AspNet-Menu-ParentSelected"><a href="javascript:__doPostBack('ctl00$B$fvMenu','bTest 0\\Test 1\\Test 1b')"
class="AspNet-Menu-Link AspNet-Menu-ParentSelected">Test 1b</a> </li>
<li class="AspNet-Menu-Leaf AspNet-Menu-ParentSelected"><a href="javascript:__doPostBack('ctl00$B$fvMenu','bTest 0\\Test 1\\Test 1c')"
class="AspNet-Menu-Link AspNet-Menu-ParentSelected">Test 1c</a> </li>
</ul>
</li>
<li class="AspNet-Menu-Leaf AspNet-Menu-ParentSelected"><a href="javascript:__doPostBack('ctl00$B$fvMenu','bTest 0\\Test 2')"
class="AspNet-Menu-Link AspNet-Menu-ParentSelected">Test 2</a> </li>
<li class="AspNet-Menu-Leaf AspNet-Menu-ParentSelected"><a href="javascript:__doPostBack('ctl00$B$fvMenu','bTest 0\\Test 3')"
class="AspNet-Menu-Link AspNet-Menu-ParentSelected">Test 3</a> </li>
<li class="AspNet-Menu-Leaf AspNet-Menu-ParentSelected"><a href="javascript:__doPostBack('ctl00$B$fvMenu','bTest 0\\Test 4')"
class="AspNet-Menu-Link AspNet-Menu-ParentSelected">Test 4</a> </li>
</ul>
</li>
</ul>
</div>
A great sample is available here and the source code can be downloaded here.
It is not a secret that I have a passion related to ASP.NET Controls ID and all related subjects.
This time I’ll write about a problem I found while migrating a NetFx 1.1 application to a new server.
The problem is about Validators and how they render the data needed to validate Client-Side.
Scenario NetFX 1.1
All data is rendered thru attributes and this way they must only follow the attributes naming conventions.
Scenario NetFX 2.0 or higher
Most required data is rendered thru Expando attributes. This means that an javascript object is created to host the required data.
At first look this seems quite the same, only with a different storage approach, but it hides one tricky issue related to naming convention differences between Html attributes and Javascript variables.
The tricky issue
I believe that most of us tries to follow the best patterns and naming conventions and if we all did this on old applications this wouldn’t be a problem.
While migrating an old .Text v0.91 application to a new server, without NetFX 1.1 installed, I found that all pages with Validators raise a javascript error.
Digging into it I found the error in this line:
var ctl00_pageBody-2_RequiredFieldValidator1 = document.all ? document.all["ctl00_pageBody-2_RequiredFieldValidator1"] : document.getElementById("ctl00_pageBody-2_RequiredFieldValidator1");
The problem is obvious, the character ‘-‘ is a javascript operator and cannot be used in a variable name . The javascript parser after finding the ‘-‘ say that an ‘;’ is expected after ‘ctl00_pageBody’.
So … Why this didn’t occurred in the old server? What lead us to this point?
As I noticed before, in NetFX 1.1 this object didn’t exist, all data were simple rendered as attributes.
I didn’t find any good reason for naming a control like this but in fact this is a absolutely valid control ID.
Solutions
There are two approaches, we can either force the validator to render attributes or change the ID value to remove unwanted characters.
The first is obviously the better one but as you will see is a global application change.
Instruct the validator to render attributes
The validator controls are ready to work in a legacy mode, but to enable that mode we need to change the all behavior of our application. We can do that adding the following web.config data:
<system.web>
<xhtmlConformance mode="Legacy"/>
While this solution is the one I like the most I choose to use the other simply because I don’t know exactly the potential side-effects, and I need to made a chirurgical change minimizing impacts.
Change the controls ID
This approach requires you to change all controls ID in the validators hierarchy to prevent javascript naming problems. It could take some time but, usually, it should present no problems.
That is not my case. It took me some time to find where the pageBody-2 control.
I ended up finding that it was an UserControl, loaded dynamically and its ID was also composed dynamically. Unfortunately, this was all done in a private method belonging to an internal base class and the only practical solution was to override the Page Render method and replace the pattern ‘_pageBody-‘ with ‘_pageBody_’.
I know it is a dirty solution … I don’t like it … but this is a short term solution before migrating the application to CommunityServer.
Mental note
Never use the ‘-‘ to name your controls ID property. Try the ‘_’ or any other without special meaning in Javascript.
A few months ago Scott Hanselman bring to all community fellows a new Visual Studio add-in called RockScroll.
RockScroll was an internal tool from Microsoft but Scott convinced Microsoft to allow him to make it available to community as a "Works on my machine" tool. This means that RockScroll is released with exactly zero warranty or support.
But what does this tool anyway? Simply replace the default vertical scrollbar with an improved one where the background is the thumbnail of the current code file.
Well, better take a look.
As you can see this add-in let you know where you are editing in a more accurate way and, beside this, you can also easily locate comment lines, breakpoints and changed lines.
The only point I dislike is related to regions. Since the thumbnail is generated based on the file content, if you have collapsed regions you will find difficult to scroll exactly where you want.
You can use it in both in Visual Studio 2005 and Visual Studio 2008. The Visual Studio 2010 will be shipped with a similar scrollbar(probably an improved version of RockScroll).
I've been using it in VS 2005 since was made available and I can say I didn't notice any related problem or performance hit.
You can get it here. Go try it now.
I made this post draft in September and forgot to publish it. Since then I redirect all colleagues and friends that notice I was using this add-in to this blog. Only a few days ago I notice the post wasn't there so, to them, my apologies.
"DreamSpark is simple, it's all about giving students Microsoft professional-level developer and design tools at no charge so you can chase your dreams and create the next big breakthrough in technology - or just get a head start on your career"
I dont know since when DreamSpark is available but this is another great Microsoft program.
So, if you are a student no more excuses are allowed. To learn better and faster, simply use the RampUp MSDN program and download all required software from DreamSpark.
More Posts
Next page »