MSDN Magazine: CLR Inside Out
CLR Inside Out: Code Contracts
Melitta Andersen - August 2009
This article will share some of the best practices that the Base Class Libraries (BCL) team devised as they added the code contract libraries and started to take advantage of them in their own code.
CLR Inside Out: Building Tuple
Matt Ellis - July 2009
In this column, the author lays out some guiding principles that you should follow when working with the ASP.NET MVC framework.
CLR Inside Out: Memory Usage Auditing For .NET Applications
Subramanian Ramaswamy and Vance Morrison - June 2009
Memory usage can have a direct impact on how fast an application executes and thus is important to optimize. In this article we discuss the basics of memory optimization for .NET programs.
CLR Inside Out: Understanding The CLR Binder
Aarthi Ramamurthy and Mark Miller - May 2009
In this article, we cover some of the best practices for assembly binding and loading using the CLR.
CLR Inside Out: CLR Optimizations In .NET Framework 3.5 SP1
Surupa Biswas - April 2009
See the changes the CLR team made to the CLR .for NET Framework 3.5 SP1 and the improvements you’ll get running your existing CLR 2.0-based apps against this service pack.
CLR Inside Out: Isolated Storage In Silverlight 2
Justin Van Patten - March 2009
See how to get the most out of isolated storage in Silverlight to keep your applications safe.
CLR Inside Out: Handling Corrupted State Exceptions
Andrew Pardoe - February 2009
There’s a danger in using one-size-fits-all exception handling, and you need to know how to avoid it by being as specific as possible about how you handle errors.
CLR Inside Out: Best Practices For Managed And Native Code Interoperability
Jesse Kaplan - January 2009
There are many factors to consider when building your app with both managed and native code. Find out how to employ interop and how to choose the interop that’s right for you.
CLR Inside Out: Thread Management In The CLR
Erika Fuentes and Eric Eilebrecht - December 2008
Getting the performance you want in concurrent applications is not as straightforward as you might think. See how common threading issues can affect your application.
CLR Inside Out: International Applications
Melitta Andersen - November 2008
The CLR team takes a look inside the System.Globalization namespace to explain how to handle data formats for proper localization and globalization.
CLR Inside Out: Security In Silverlight 2
Andrew Dai - October 2008
Andrew Dai of the CLR team discusses the Transparency model, which creates a strong isolation boundary between privileged and unprivileged code for Silverlight apps.
CLR Inside Out: Unhandled Exception Processing In The CLR
Gaurav Khanna - September 2008
In this installment of CLR Inside Out Gaurav Khanna explains everything you need to know about unhandled exception processing in the .NET Framework.
CLR Inside Out: Program Silverlight with the CoreCLR
Andrew Pardoe - August 2008
The CoreCLR provides the perfect set of CLR classes and functionality for the Web.
CLR Inside Out: Extend Windows Forms Apps Using System.AddIn
Mueez Siddiqui - July 2008
See how Windows Forms applications can be adapted to use the new .NET Add-in framework (System.AddIn) this month.
CLR Inside Out: Large Object Heap Uncovered
Maoni Stephens - June 2008
This month CLR Inside Out reveals the secrets behind the Large Object Heap—what’s there, when it’s released, how the garbage collector handles the objects there.
CLR Inside Out: Measure Early and Often for Performance, Part 2
Vance Morrison - May 2008
In the second of a two-part series, Vance Morrison delves into the meaning of performance measurements, explaining what the numbers mean to you.
CLR Inside Out: Measure Early and Often for Performance, Part 1
Vance Morrison - April 2008
In this month’s column, get the inside scoop on how to build performance into your apps from the start, rather than dealing with the fallout after you deploy them.
CLR Inside Out: Improving Application Startup Performance
Claudio Caldato - March 2008
Application startup performance matters to users, and there's plenty you can do to improve it. Here's a look at where to begin.
CLR Inside Out: Dynamic Languages and Silverlight
Jimmy Schementi - February 2008
DLRConsole gives you an interactive environment for playing with dynamic languages in Silverlight.
CLR Inside Out: Marshaling between Managed and Unmanaged Code
Yi Zhang and Xiaoying Guo - January 2008
Marshaling is an important part of .NET interop. It allows you to call into unmanaged code from managed code. This column will help you get started.
CLR Inside Out: Writing Reliable .NET Code
Alessandro Catorcini and Brian Grunkemeyer - December 2007
Here's a look at how code fails and techniques for writing more reliable and resilient managed code.
CLR Inside Out: Managing Object Lifetime
Tim Fischer - November 2007
Although the .NET Framework provides a managed execution environment, it is important to consider object lifetime management and write code that uses and releases resources correctly. The CLR team shows you how.
CLR Inside Out: IronPython and the Dynamic Language Runtime
Bill Chiles - October 2007
This column uses the .NET version of the Python programming languages IronPython to demonstrate the value of dynamic languages and the new Dynamic Language Runtime.
CLR Inside Out: COM Connection Points
Thottam R. Sriram - September 2007
We create an Active Template Library (ATL) connection point server.
CLR Inside Out: Collections Best Practices
Inbar Gazit - August 2007
This month Inbar Gazit shows readers how to get the most out of the System.Collections namespace.
CLR Inside Out: Digging into IDisposable
Shawn Farkas - July 2007
This month: cleaning up resources that are not garbage collected by the CLR garbage collector.
CLR Inside Out: Reflections on Reflection
Mike Repass - June 2007
This month's installment of CLR Inside Out takes on reflection and the System.Reflection namespace.
CLR Inside Out: 9 Reusable Parallel Data Structures and Algorithms
Joe Duffy - May 2007
CLR Inside Out: New Library Classes in "Orcas"
Mike Downen, Inbar Gazit, and Justin Van Patten - April 2007
The next version of Visual Studio currently code-named “Orcas”supports advanced encryption algorithms, Elliptic curve cryptography, big integers, and other security enhancements. The CLR team explains.
CLR Inside Out: .NET Application Extensibility, Part 2
Jack Gudenkauf and Jesse Kaplan - March 2007
CLR Inside Out: .NET Application Extensibility
Jack Gudenkauf and Jesse Kaplan - February 2007
This month the CLR team introduces the new System.AddIn namespace in the Base Class Library, which will be available in the next release of Visual Studio.
CLR Inside Out: Introduction to COM Interop
Thottam R. Sriram - January 2007
The CLR allows seamless interactions between Microsoft .NET applications and COM. But how, exactly? The CLR team knows.
CLR Inside Out: Inside Diagnostic Tools for .NET
Jonathan Keljo - December 2006
In this installment of CLR Inside Out, a look inside the CLR Profiling API and tools that use it.
CLR Inside Out: Investigating Memory Issues
Claudio Caldato and Maoni Stephens - November 2006
Memory issues can manifest in a wide variety of ways. This column shows you how to collect the data you need to determine what types of mem¬ory issues you are experiencing.
CLR Inside Out: IronPython
James Schementi - October 2006
IronPython, the CLR implementation of the dynamic programming language Python is introduced this month.
CLR Inside Out: Using concurrency for scalability
Joe Duffy - September 2006
Because of the popularity of multiprocessor machines, many concurrency articles focus on how to make concurrency safe in your code. However, they don't deal with how to get concurrency into your code in the first place.
CLR Inside Out: CLR Hosting APIs
Alessandro Catorcini and Piotr Puszkiewicz - August 2006
By using the CLR 2.0 hosting APIs, developers of native hosts can execute managed code in-process with complete knowledge and control over how the CLR behavior can affect their application.
CLR Inside Out: Using Strong Name Signatures
Mike Downen - July 2006
Strong name signatures (and signing in general) are a key facet of Microsoft® . NET Framework security. But regardless of how well designed . NET signatures may be, they won’t offer the maximum benefit if you don’t know how to use them properly.
CLR Inside Out: Windows Vista Globalization Features
Shawn Steele - June 2006
Windows XP and the Microsoft .NET Framework both have APIs that support globalization. Windows Vista™ will further extend globalization support by introducing several new features.
CLR Inside Out: The Performance Benefits of NGen.
Surupa Biswas - May 2006
T ypically, methods in managed executables are just-in-time (JIT) compiled. The machine code generated by the JIT compiler is thrown away once the process running that executable exits; therefore, the method must be recompiled when the application is run again.
CLR Inside Out: Extending System.Diagnostics
Krzysztof Cwalina - April 2006
The System. Diagnostics namespace in the Microsoft® . NET Framework contains powerful tracing capabilities. This includes the main tracing API: TraceSource. As you will see, the tracing APIs in System.
CLR Inside Out: Ensuring .NET Framework 2.0 Compatibility
Jesse Kaplan - March 2006
If we learned only one thing about compatibility in the past few years, it is that compatibility is much more than avoiding breaking changes. On the Microsoft®. NET Framework and Visual Studio® teams, we do our part to ensure that the products we build are stable platforms that developers can truly rely on.
CLR Inside Out: Improving Application Startup Time
Claudio Caldato - February 2006
Visual Studio is a wonderful development environment, whose IntelliSense®, integrated debugging, online help, and code snippets help boost your performance as a developer. But just because you're writing code fast doesn't mean you're writing fast code.
CLR Inside Out: Base Class Library Performance Tips and Tricks
Kit George - January 2006
The common language runtime (CLR) sits at the very heart of managed code. Indeed, it is the heart of managed code, so to understand managed code you need to understand the CLR.