<?xml version="1.0" encoding="iso-8859-1"?>
<rss version="2.0">
  <channel>
    <title>DotNetKicks.com - published clr stories</title>
    <description>the latest published clr stories from DotNetKicks.com</description>
    <link>http://www.dotnetkicks.com/</link>
    <language>en-us</language>
    <copyright>Atweb Publishing Ltd.</copyright>
    <docs>http://backend.userland.com/rss</docs>
    <generator>DotNetKicks.com - .NET links, community driven</generator>
    <ttl>30</ttl>
    <item>
      <title>Taking the Magic out of Expression</title>
      <description>Concise introduction to expression trees. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fwww.codethinked.com%2fpost%2f2008%2f11%2f29%2fTaking-the-Magic-out-of-Expression.aspx"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fwww.codethinked.com%2fpost%2f2008%2f11%2f29%2fTaking-the-Magic-out-of-Expression.aspx" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/Taking_the_Magic_out_of_Expression</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/Taking_the_Magic_out_of_Expression</guid>
      <pubDate>Mon, 01 Dec 2008 13:31:12 GMT</pubDate>
    </item>
    <item>
      <title>Debugging gac assemblies</title>
      <description>An easy description on how to debug your assemblies when they are put in gac &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fgttools.com%2f2008%2f03%2fdebugging-gac-assemblies%2f"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fgttools.com%2f2008%2f03%2fdebugging-gac-assemblies%2f" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/Debugging_gac_assemblies</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/Debugging_gac_assemblies</guid>
      <pubDate>Sun, 30 Nov 2008 15:17:33 GMT</pubDate>
    </item>
    <item>
      <title>Common Language Runtime Beginner Series Part 1:-CLR Basics</title>
      <description>CLR or Common Language Runtime is a very important part of whole .net Framework and its utter importance is not seen by most of us as it works behind the scenes.This beginner series of my articles will help you to know what actually CLR is in simple terms and what are its basic features.As of now this articles tells the basics about the CLR and why is it useful over others. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fsmallworkarounds.blogspot.com%2f2008%2f11%2fcommon-language-runtime-beginner-series.html"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fsmallworkarounds.blogspot.com%2f2008%2f11%2fcommon-language-runtime-beginner-series.html" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/Common_Language_Runtime_Beginner_Series_Part_1_CLR_Basics</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/Common_Language_Runtime_Beginner_Series_Part_1_CLR_Basics</guid>
      <pubDate>Sun, 30 Nov 2008 07:05:46 GMT</pubDate>
    </item>
    <item>
      <title>Stupid NUnit Tricks #3 Foiled!</title>
      <description>Revelation of a CLR bug. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fwww.atalasoft.com%2fcs%2fblogs%2fstevehawley%2farchive%2f2008%2f11%2f24%2fstupid-nunit-tricks-3-foiled.aspx"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fwww.atalasoft.com%2fcs%2fblogs%2fstevehawley%2farchive%2f2008%2f11%2f24%2fstupid-nunit-tricks-3-foiled.aspx" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/Stupid_NUnit_Tricks_3_Foiled</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/Stupid_NUnit_Tricks_3_Foiled</guid>
      <pubDate>Tue, 25 Nov 2008 14:56:12 GMT</pubDate>
    </item>
    <item>
      <title>Update on the GDR that is coming for .NET Framework 3.5 SP1</title>
      <description>As you've probably heard, we are working on an update for .NET3.5 SP1 and its 2.0/3.0 sub-components which will contain fixes for the small number of bugs reported by customers since the release of 3.5 SP1 this summer. More information regarding the specific bug fixes included in the update will be provided in a knowledge base article that will be released with this update, although at the end of September I blogged about this upcoming &amp;quot;GDR&amp;quot; (General Distribution Release) update to .NET 3.5 SP1 and listed the bugs I've been able to confirm so far as being fixed. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fwww.hanselman.com%2fblog%2fUpdateOnTheGDRThatIsComingForNETFramework35SP1.aspx"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fwww.hanselman.com%2fblog%2fUpdateOnTheGDRThatIsComingForNETFramework35SP1.aspx" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/Update_on_the_GDR_that_is_coming_for_NET_Framework_3_5_SP1</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/Update_on_the_GDR_that_is_coming_for_NET_Framework_3_5_SP1</guid>
      <pubDate>Sun, 16 Nov 2008 19:21:40 GMT</pubDate>
    </item>
    <item>
      <title>Functional .NET 4.0 - Tuples and Zip</title>
      <description>F# vs .NET 4.0 &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fcodebetter.com%2fblogs%2fmatthew.podwysocki%2farchive%2f2008%2f11%2f16%2ffunctional-net-4-0-tuples-and-zip.aspx"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fcodebetter.com%2fblogs%2fmatthew.podwysocki%2farchive%2f2008%2f11%2f16%2ffunctional-net-4-0-tuples-and-zip.aspx" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/Functional_NET_4_0_Tuples_and_Zip</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/Functional_NET_4_0_Tuples_and_Zip</guid>
      <pubDate>Mon, 17 Nov 2008 18:46:02 GMT</pubDate>
    </item>
    <item>
      <title>Path.Combine - Be aware of a Slash in the Second Parameter</title>
      <description>This is an old blog post, but this quirk caught me today. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fcoolthingoftheday.blogspot.com%2f2008%2f02%2fpathcombine-be-aware-of-slash-in-second.html"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fcoolthingoftheday.blogspot.com%2f2008%2f02%2fpathcombine-be-aware-of-slash-in-second.html" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/Path_Combine_Be_aware_of_a_Slash_in_the_Second_Parameter</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/Path_Combine_Be_aware_of_a_Slash_in_the_Second_Parameter</guid>
      <pubDate>Fri, 14 Nov 2008 23:41:04 GMT</pubDate>
    </item>
    <item>
      <title>Breaking changes to the String class in .NET 4.0</title>
      <description>This change will affect the behavior of the String.StartsWith, String.EndsWith, String.IndexOf and String.LastIndexOf methods by changing them to perform an ordinal (byte-for-byte) comparison by default instead of a culture-sensitive comparison using CultureInfo.CurrentCulture. In addition, the default overloads of String.ToUpper, String.ToLower, Char.ToUpper and Char.ToLower will be changed to use CultureInfo.InvariantCulture instead of CultureInfo.CurrentCulture. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fdavesbox.com%2farchive%2f2008%2f11%2f12%2fbreaking-changes-to-the-string-class.aspx"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fdavesbox.com%2farchive%2f2008%2f11%2f12%2fbreaking-changes-to-the-string-class.aspx" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/Breaking_changes_to_the_String_class_in_NET_4_0</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/Breaking_changes_to_the_String_class_in_NET_4_0</guid>
      <pubDate>Fri, 14 Nov 2008 13:31:13 GMT</pubDate>
    </item>
    <item>
      <title>Creating a generic CLR audit trigger</title>
      <description>There's an interesting article at SqlJunkies about how to create a generic CLR audit trigger. But there is just one small problem with this trigger code. The PerformedBy column of the Audit table in the sample code is set to the UserID of the connection string which in most applications would be the same UserID for all connections because of connection pooling. This means the trigger will log all operations performed by the application but it will not log the real user (application user) who made the change. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fdotnethitman.spaces.live.com%2fblog%2fcns!E149A8B1E1C25B14!304.entry"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fdotnethitman.spaces.live.com%2fblog%2fcns!E149A8B1E1C25B14!304.entry" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/Creating_a_generic_CLR_audit_trigger</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/Creating_a_generic_CLR_audit_trigger</guid>
      <pubDate>Sat, 08 Nov 2008 20:36:58 GMT</pubDate>
    </item>
    <item>
      <title>Scott Guthrie on Smack and Meth (or was it MEF?)</title>
      <description>In this video, Scott Guthrie (aka ScottGu), explains how his team originally used Smack (their nickname for Simple Managed C or  SMC) to write ASP.NET.  However, they later decided to write it in C# on the CLR.  Scott explains why the decision was &amp;quot;important&amp;quot;, &amp;quot;super risky&amp;quot; and the &amp;quot;single biggest&amp;quot; they made in regards to server-side .NET.  It is (in my view) a really interesting bit of .NET history. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fbentaylor.org%2fScott-Guthrie-On-Smack-And-Meth-Or-Was-It-MEF-Exclusive-Microsoft-PDC-Video.aspx"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fbentaylor.org%2fScott-Guthrie-On-Smack-And-Meth-Or-Was-It-MEF-Exclusive-Microsoft-PDC-Video.aspx" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/Scott_Guthrie_on_Smack_and_Meth_or_was_it_MEF</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/Scott_Guthrie_on_Smack_and_Meth_or_was_it_MEF</guid>
      <pubDate>Tue, 04 Nov 2008 18:58:56 GMT</pubDate>
    </item>
    <item>
      <title>For vs Foreach Performance (in .NET)</title>
      <description>Timing the difference between a &amp;quot;for&amp;quot; loop and a more &amp;quot;modern&amp;quot; version using &amp;quot;foreach&amp;quot; and Enumerable.Range. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fwww.madprops.org%2fblog%2ffor-vs-foreach-performance%2f"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fwww.madprops.org%2fblog%2ffor-vs-foreach-performance%2f" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/For_vs_Foreach_Performance_in_NET</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/For_vs_Foreach_Performance_in_NET</guid>
      <pubDate>Tue, 28 Oct 2008 23:11:18 GMT</pubDate>
    </item>
    <item>
      <title>.NET Memory Model Bytecode Reordering - Mark Nicholson</title>
      <description>The .NET ECMA specified memory model is weaker than the x86 hardware memory model. When you run your multi-threaded .NET applications on a multi-processor machine with a weak memory model, such as the Intel Itanium Architecture (IA64), your programs may not execute as expected.

This is because weaker memory models can reorder memory operations (loads and stores) out of program sequence in order to improve performance. This reordering is guaranteed to have no visible side-effects on a single thread of execution. However, if you are accessing memory across threads, and the stores to, and loads from that memory are reordered, this may produce undesirable side-effects, effectively breaking your well-crafted application.

.NET only offers a full memory fence that is a read (load) and write (store) memory barrier (fence) in one, via System.Threading.Thread.MemoryBarrier. Some hardware platforms offer separate read and write memory barriers, which can further improve performance. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fdotnet.org.za%2fmarkn%2farchive%2f2008%2f10%2f21%2fnet-memory-model-bytecode-reordering.aspx"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fdotnet.org.za%2fmarkn%2farchive%2f2008%2f10%2f21%2fnet-memory-model-bytecode-reordering.aspx" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/NET_Memory_Model_Bytecode_Reordering_Mark_Nicholson</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/NET_Memory_Model_Bytecode_Reordering_Mark_Nicholson</guid>
      <pubDate>Fri, 24 Oct 2008 13:51:34 GMT</pubDate>
    </item>
    <item>
      <title>IronScheme 1.0 beta 1 released</title>
      <description>IronScheme 1.0 beta 1 has been released. 

It implements the entire R6RS Scheme specification. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fwww.codeplex.com%2fIronScheme%2fRelease%2fProjectReleases.aspx%3fReleaseId%3d14059"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fwww.codeplex.com%2fIronScheme%2fRelease%2fProjectReleases.aspx%3fReleaseId%3d14059" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/IronScheme_1_0_beta_1_released</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/IronScheme_1_0_beta_1_released</guid>
      <pubDate>Tue, 21 Oct 2008 11:38:07 GMT</pubDate>
    </item>
    <item>
      <title>Enterprise .NET Community: Introduction to C# Anonymous Methods</title>
      <description>Generics are often introduced as the mainstream language feature of Whidbey (.NET2). However, while surfing off the beaten path I realized that new features named anonymous methods and iterators are also very interesting. Unlike generics, these two features don't imply new IL instructions set changes compared to .NET1 IL instructions set or any CTS changes. All the magic is in the compilers. This article is the first of a series of two articles dedicated to these new features. While these articles unfold, you will understand the reasons for beginning with anonymous methods. Both articles share the same structure: first a basic introduction to the functionality, followed by a strong analysis of the compiler work before drilling into advanced uses. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fwww.theserverside.net%2ftt%2farticles%2fshowarticle.tss%3fid%3dAnonymousMethods"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fwww.theserverside.net%2ftt%2farticles%2fshowarticle.tss%3fid%3dAnonymousMethods" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/Enterprise_NET_Community_Introduction_to_C_Anonymous_Methods</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/Enterprise_NET_Community_Introduction_to_C_Anonymous_Methods</guid>
      <pubDate>Tue, 21 Oct 2008 00:43:22 GMT</pubDate>
    </item>
    <item>
      <title>Survey Time: What .NET Framework features do you use?</title>
      <description>&amp;quot;Hey folks, as I've said before, one of the things I like to do is take your comments, questions and feedback directly to the right folks inside Microsoft.&amp;quot; - Scott Hanselman &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fwww.hanselman.com%2fblog%2fSurveyTimeWhatNETFrameworkFeaturesDoYouUse.aspx"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fwww.hanselman.com%2fblog%2fSurveyTimeWhatNETFrameworkFeaturesDoYouUse.aspx" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/Survey_Time_What_NET_Framework_features_do_you_use</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/Survey_Time_What_NET_Framework_features_do_you_use</guid>
      <pubDate>Tue, 14 Oct 2008 00:33:44 GMT</pubDate>
    </item>
    <item>
      <title>Generate An Assembly Source Code Using The Reflector</title>
      <description>If you are a .NET developer, you should probably know the .NET Reflector which is a great tool for viewing, navigating and searching through the class hierarchies of .NET assemblies (even if you don't have the code for them). I am using this tool a lot but here is something I only recently discovered: one can export an assembly and let the Reflector generate its source code. The output of this process is a directory with a project file and all of the source files. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fwww.dev102.com%2f2008%2f10%2f13%2fgenerate-an-assembly-source-code-using-the-reflector%2f"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fwww.dev102.com%2f2008%2f10%2f13%2fgenerate-an-assembly-source-code-using-the-reflector%2f" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/Generate_An_Assembly_Source_Code_Using_The_Reflector</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/Generate_An_Assembly_Source_Code_Using_The_Reflector</guid>
      <pubDate>Mon, 13 Oct 2008 13:16:17 GMT</pubDate>
    </item>
    <item>
      <title>F# : absolute power corrupts absolutely, but F# removes side-effects</title>
      <description>Functional programming is so addictive. It reminds me when I could code with no team, no deadline, no broken processes or cultures to navigate. I do hope this becomes a common option for general development or at least C# continues to borg functional ideas. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fblog.domaindotnet.com%2f2008%2f10%2f07%2ff-absolute-power-over-your-code-corrupts-absolutely-but-f-removes-side-effect-corruption-so-uh-there-goes-my-analogy%2f"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fblog.domaindotnet.com%2f2008%2f10%2f07%2ff-absolute-power-over-your-code-corrupts-absolutely-but-f-removes-side-effect-corruption-so-uh-there-goes-my-analogy%2f" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/architecture/F_absolute_power_corrupts_absolutely_but_F_removes_side_effects</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/architecture/F_absolute_power_corrupts_absolutely_but_F_removes_side_effects</guid>
      <pubDate>Wed, 08 Oct 2008 04:34:49 GMT</pubDate>
    </item>
    <item>
      <title>What's new in .NET Framework 4.0?</title>
      <description>Good question. There are a few things we know about Microsoft's managed application runtime and class library: There will be major updates to the Windows Communication Foundation (WCF) and Workflow Foundation (WF). According to this announcement along with this post by Steven Martin we are going to see "better support for Web 2.0 technologies like REST, POX and ATOM" and a 10x performance increase in WF.  &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fwww.itwriting.com%2fblog%2f943-whats-new-in-net-framework-40.html"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fwww.itwriting.com%2fblog%2f943-whats-new-in-net-framework-40.html" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/What_s_new_in_NET_Framework_4_0</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/What_s_new_in_NET_Framework_4_0</guid>
      <pubDate>Fri, 03 Oct 2008 18:59:25 GMT</pubDate>
    </item>
    <item>
      <title>How Do Locks Lock?</title>
      <description>A detailed explanation of how a locks like ReaderWriterLockSlim really work. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fwww.moserware.com%2f2008%2f09%2fhow-do-locks-lock.html"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fwww.moserware.com%2f2008%2f09%2fhow-do-locks-lock.html" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/How_Do_Locks_Lock</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/How_Do_Locks_Lock</guid>
      <pubDate>Tue, 30 Sep 2008 12:31:02 GMT</pubDate>
    </item>
    <item>
      <title>[.NET] Generics Perfomance Myth (and Tony Northrup VS Wendy Sarret)</title>
      <description>According to Microsoft, Generics are faster than casting (boxing/unboxing): is it just a myth? &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fdotnetbutchering.blogspot.com%2f2008%2f09%2fnet-generic-perfomance-myth-and-tony.html"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fdotnetbutchering.blogspot.com%2f2008%2f09%2fnet-generic-perfomance-myth-and-tony.html" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/NET_Generics_Perfomance_Myth_and_Tony_Northrup_VS_Wendy_Sarret</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/NET_Generics_Perfomance_Myth_and_Tony_Northrup_VS_Wendy_Sarret</guid>
      <pubDate>Thu, 25 Sep 2008 19:38:22 GMT</pubDate>
    </item>
    <item>
      <title>Herding Code #17:Matt Podwysocki on F# and Functional Programming</title>
      <description>This week Matt Podwysocki puts the fun in functional programming with a deep dive into F#. We've heard plenty of high level discussions of F# and functional programming lately, so we tried to dig into the gory details as much as possible:

    * What is functional programming, and why should we care?
    * Types of applications that would and wouldn't benefit from F#
    * How F# differs from C# 3.x and Javascript
    * How F# is being used (games, scripting, data analysis and scrubbing, etc.)
    * F# pattern matching
    * Using F# in your C# or VB based applications today
    * Getting started: F# Interactive, reading the F# source, books and resources
    * Interaction with DLR
    * Functional features we'd like to see in C# and VB
    * Spec# and Sing#
 &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fherdingcode.com%2f%3fp%3d45"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fherdingcode.com%2f%3fp%3d45" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/Herding_Code_17_Matt_Podwysocki_on_F_and_Functional_Programming</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/Herding_Code_17_Matt_Podwysocki_on_F_and_Functional_Programming</guid>
      <pubDate>Fri, 19 Sep 2008 21:47:50 GMT</pubDate>
    </item>
    <item>
      <title>Displaying time in relative format</title>
      <description>Many websites specially forum sites display time relative to the current time as "3 Hours 25 Minutes ago", "30 Seconds ago" etc. In this post I will show a method using which we can convert datetime into descriptive relative time string. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fnirandas.com%2fblog%2findex.php%2fdisplaying-time-in-relative-format%2f"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fnirandas.com%2fblog%2findex.php%2fdisplaying-time-in-relative-format%2f" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/Displaying_time_in_relative_format_1</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/Displaying_time_in_relative_format_1</guid>
      <pubDate>Sat, 30 Aug 2008 00:55:59 GMT</pubDate>
    </item>
    <item>
      <title>30 Common String Operations in C# and VB.NET - Part II</title>
      <description>In the previous article, 30 Common String Operations in C# and VB.NET - Part I, we explored 15 common String operations while working with the String class. In Part II of the article, we will continue with the series and cover 15 more. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fwww.dotnetcurry.com%2fShowArticle.aspx%3fID%3d190"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fwww.dotnetcurry.com%2fShowArticle.aspx%3fID%3d190" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/30_Common_String_Operations_in_C_and_VB_NET_Part_II</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/30_Common_String_Operations_in_C_and_VB_NET_Part_II</guid>
      <pubDate>Wed, 27 Aug 2008 08:01:02 GMT</pubDate>
    </item>
    <item>
      <title>How To Inject a Managed Assembly (DLL) into Another Process</title>
      <description>An easy way to inject a .NET assembly (class library, etc.) into the address space of another application, even an unmanaged application. &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fwww.codingthewheel.com%2farchives%2fhow-to-inject-a-managed-assembly-dll"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fwww.codingthewheel.com%2farchives%2fhow-to-inject-a-managed-assembly-dll" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/How_To_Inject_a_Managed_Assembly_DLL_into_Another_Process</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/How_To_Inject_a_Managed_Assembly_DLL_into_Another_Process</guid>
      <pubDate>Sat, 23 Aug 2008 11:12:11 GMT</pubDate>
    </item>
    <item>
      <title>What If I Don't Call Dispose() on my LINQ to SQL DataContext Object?</title>
      <description>Steven Walther recently posted on the subject of disposing of DataContext objects and provided some interesting insight into what actually happens.  From what he says it sounds like the DataContext object acts much like the SqlDataAdapter class.  It opens the connection right before a query is executed and closes it immediately after.  I don't want to steal Steven's thunder so check out his post on the subject (the last part of the article talks about the consequences.or lack of consequences.of not calling Dispose()).   &lt;br /&gt;&lt;br /&gt;&lt;br /&gt;&lt;a href="http://www.dotnetkicks.com/kick/?url=http%3a%2f%2fweblogs.asp.net%2fdwahlin%2farchive%2f2008%2f08%2f19%2fwhat-if-i-don-t-call-dispose-on-my-linq-to-sql-datacontext-object.aspx"&gt;&lt;img src="http://www.dotnetkicks.com/Services/Images/KickItImageGenerator.ashx?url=http%3a%2f%2fweblogs.asp.net%2fdwahlin%2farchive%2f2008%2f08%2f19%2fwhat-if-i-don-t-call-dispose-on-my-linq-to-sql-datacontext-object.aspx" border="0" alt="kick it on DotNetKicks.com" /&gt;&lt;/a&gt;
</description>
      <link>http://www.dotnetkicks.com/clr/What_If_I_Don_t_Call_Dispose_on_my_LINQ_to_SQL_DataContext_Object</link>
      <guid isPermaLink="true">http://www.dotnetkicks.com/clr/What_If_I_Don_t_Call_Dispose_on_my_LINQ_to_SQL_DataContext_Object</guid>
      <pubDate>Wed, 20 Aug 2008 22:05:41 GMT</pubDate>
    </item>
  </channel>
</rss>