.NET news >> Performance

Dynamic... But Fast: The Tale of Three Monkeys, A Wolf and the DynamicMethod and ILGenerator Classes

Mon, 21 Jul 2008 18:21:00 -0500

How to use the DynamicMethod and ILGenerator classes to create dynamic code at runtime that outperforms reflection

Extended Thread Pool

Wed, 09 Jul 2008 16:05:00 -0500

Your own extensible and configurable Thread Pool

Speed Test: Try / Catch Block

Tue, 24 Jun 2008 13:57:20 -0500

The try/catch block is used to capture thrown exceptions and to allow an application to recover gracefully from the problems that caused them. This article has been created to determine if the try/catch block causes a substantial performance penalty.

TLS: An exercise in concurrent programming

Sun, 11 May 2008 11:54:00 -0500

This article has two aims. Firstly, there are a series of five exercises that detail the process of successfully multi-threading a sequential algorithm with timely progress display in the UI. It also provides an implementation of a thread local storage class which can help realise the performance promise of many-core machines.

JIT Optimizations

Sun, 04 May 2008 07:33:00 -0500

In this article, we will look into JIT optimizations, with specific focus on inlining.

A Fast/Compact Serialization Framework

Tue, 01 Apr 2008 14:08:00 -0500

A framework for object serializiation/deserialization that is many times faster and yields compact output.

Tricky Programming on Multi-Core Processors

Fri, 29 Feb 2008 07:38:00 -0600

Nowadays, multi-core processing is a growing industry trend as single core processors rapidly reach the physical limits of possible complexity and speed. It's obvious that if such wonderful hardware exists, it should be supported in .NET, shouldn't it? To check this I looked for a well-known easy-parallelizable algorithm. The benchmark should have handled different .NET parallelizing techniques with memory and mathematical operations. In my opinion, the best algorithms that fit these requirements are QuickSort and Matrix multiplication. Please take into account, that this article doesn't describe any algorithms' optimization techniques. Instead it shows, how to parallelize your C# code and compares the performance of different approaches.

Implementing Bubble Sort with SSE2

Tue, 12 Feb 2008 12:32:00 -0600

How much faster will implementing "the generic bad algorithm" in SSE2 make it?

Caching Images in ASP.NET

Thu, 17 Jan 2008 13:52:00 -0600

There are a lot of ways to improve performance in web applications. One of the simplest but most effective methods is to cache images on the client. In this article I would like to show how we implemented image caching for our DotNetNuke website.

Implementing a super-fast, size-constrained generic cache

Wed, 16 Jan 2008 08:10:00 -0600

I work with performance-critical software that often requires some form of cache to function efficiently. However, there is also often a need to constrain memory usage, so I set out to create a high-performance cache with a maximum size.

Stream Pipeline

Mon, 17 Dec 2007 18:00:00 -0600

This month Stephen Toub explains how to make the most of dual processors when running encryption and compression tasks.

Squeezing more performance from SortedList

Sat, 20 Oct 2007 16:28:00 -0500

A SortedList implementations using a cyclic algorithm and C# IDictionary tweaks

Caching Data with a Web Service in Enterprise Library

Wed, 29 Aug 2007 18:51:09 -0500

The Caching Application Block's provider mechanism lets you create a custom provider that stores cached data anywhere you want. It was this that made me wonder if it was possible to cache data within or through a web service, which would allow the provider to cache its data almost anywhere�remotely or locally�without having to write specific code that is directly integrated within Enterprise Library. The principle is simple enough. Instead of having the backing store provider within the Caching Application Block interact directly with the backing store (the usual approach, as implemented in the Isolated Storage provider and Database provider), the backing store provider simply packages up the data and sends it to a web service..

Pooled Threads: Improve Scalability With New Thread Pool APIs

Tue, 21 Aug 2007 19:00:00 -0500

With the release of Windows Vista® and the upcoming release of Windows Server 2008, Microsoft has enriched the Windows platform with so much new technology for developers of managed applications that it's easy to overlook advancements that the native Windows developer can benefit from. The thread pool component that has been part of the platform since the release of Windows 2000, for example, has undergone a complete rearchitecture. The new implementation brings with it a new thread pool API that should make it much easier for developers to write correct code. The legacy APIs are still supported so that legacy applications can continue to run, but, as you'll see, there are many benefits to be gained from moving to the new APIs...

Optimize Managed Code For Multi-Core Machines

Tue, 21 Aug 2007 19:00:00 -0500

The Task Parallel Library (TPL) is designed to make it much easier to write managed code that can automatically use multiple processors. Using the library, you can conveniently express potential parallelism in existing sequential code, where the exposed parallel tasks will be run concurrently on all available processors. Usually this results in significant speedups. TPL is being created as a collaborative effort by Microsoft Research, the Microsoft Common Language Runtime (CLR) team, and the Parallel Computing Platform team. TPL is a major component of the Parallel FX library, the next generation of concurrency support for the Microsoft .NET Framework...

Cache Up to the Caching Application Block in Enterprise Library 3.0

Wed, 15 Aug 2007 17:25:50 -0500

Any application you write may require some sort of caching to meet the performance requirements of the business. Until the release of Enterprise Library, developers were forced to roll out their own caching implementations; however, developers now finally have a standard out-of-the-box caching solution that is fully tested�and it's free! The Caching Application Block provides a flexible and extensible caching mechanism that can be used at any or all layers of an application. It supports in-memory, database, or isolated storage stores for persisting the cached data. It also includes a set of very easy-to-use APIs that let you incorporate standard caching operations into your applications without needing to learn the complexities of the caching implementation. This article introduces the Caching Application Block and shows examples of how to use it to write robust caching implementations.

Make your web application run faster

Mon, 06 Aug 2007 08:11:00 -0500

It is easy to develop your own ASP.NET web application. But making it do some useful things for your users while keeping the design simple and elegant is not so easy. If you are lucky, your web application will be used by more than a handful of users, in that case, performance can become important. For some of the web applications I worked on, performance is vital: the company will lose money if users get frustrated with the slow response. There are many factors that can result in bad performance, the number of users is just one of them. As a developer in a big corporation, you usually don't have a chance to mess with real production servers. However, I think it is very helpful for developers to take a look at the servers that are hosting their applications...

Dynamic... but fast

Thu, 12 Jul 2007 10:45:00 -0500

How to use the DynamicMethod and ILGenerator classes to create dynamic code at runtime that outperforms reflection.

A threading framework to optimize interoperation between .NET and apartment threaded COM components

Wed, 02 May 2007 15:08:00 -0500

A generic solution and an accompanying threading framework to optimize calls between .NET and apartment threaded COM components

ImageTraverser

Thu, 19 Apr 2007 14:48:00 -0500

Microsoft's System.Drawing.Bitmap class is deceptively simple - just create a Bitmap from a file, then use the GetPixel() and SetPixel() methods to manipulate the image, right? Unfortunately, these two methods are terribly slow, so a lower-level traversal via pointers is necessary for decent performance. However, there is a reason that the .NET language designers are steadily moving away from pointers - code that utilizes them is usually brittle and error-prone, even when run under the CLR. Therefore, to minimize and isolate the use of unsafe code in my projects, I have encapsulated the necessary unsafe pointer code in this class, plus I have added several handy methods for dealing with image pixels. The end result is a robust class for traversing images (ie, retrieving and setting individual pixels) - hence the moniker ImageTraverser.

Boost ASP.NET Performance with Precompilation

Thu, 19 Apr 2007 13:43:00 -0500

The latest version of ASP.NET, version 2.0, supports several new and exciting features that promise to enhance developer productivity, administration and management, extensibility, and performance. One of these features is precompilation, which either developers or administrators can use to precompile ASP.NET applications before they are deployed. Moreover, the new precompilation feature can detect and provide warnings about any compilation failure issues, and lets you deploy applications without the need to store the source code on the deployment server. Precompilation can both reduce application response time and improve performance. This article explains how to use the new feature effectively.

HyperDescriptor: Accelerated dynamic property access

Wed, 18 Apr 2007 13:07:00 -0500

.NET provides flexible data-binding and runtime property access, but by default this is via reflection an is known to be relatively slow. This article uses the power of Reflection.Emit to provide a pre-compiled (and much accelerated) implementation for reflection properties, and demonstrates the use of TypeDescriptionProvider to dynamically apply this implementation to types. A lot of technical details are included, but this code is all provided in the source; as a consumer you have to do almost nothing. Really. You may wish to jump ahead to the usage scenarios, then dip back if you want to know what makes it all work.

9 Reusable Parallel Data Structures and Algorithms

Tue, 10 Apr 2007 19:00:00 -0500

This column is less about the mechanics of a common language runtime (CLR) feature and more about how to efficiently use what you�ve got at your disposal. Selecting the right data structures and algorithms is, of course, one of the most common yet important decisions a programmer must make. The wrong choice can make the difference between success and failure or, as is the case most of the time, good performance and, well, terrible performance. Given that parallel programming is often meant to improve performance and that it is generally more difficult than serial programming, the choices are even more fundamental to your success. In this column, we'll take a look at nine reusable data structures and algorithms that are common to many parallel programs and that you should be able to adapt with ease to your own .NET software. Each example is accompanied by fully working, though not completely hardened, tested, and tuned, code. The list is by no means exhaustive, but it represents some of the more common patterns. As you'll notice, many of the examples build on each other.

Speed Test: Switch vs If-Else-If

Sat, 24 Mar 2007 00:00:03 -0500

The .NET framework and the C# language provide two methods for conditional processing where multiple discrete values can be selected from. The switch statement is less flexible than the if-else-if ladder but is generally considered to be more efficient.

Improve Debugging And Performance Tuning With ETW

Mon, 12 Mar 2007 19:00:00 -0500

Event Tracing for Windows (ETW) provides general-purpose, high-speed tracing of events raised by both user-mode applications and kernel-mode device drivers. Learn how ETW can improve your development and debugging work.

Identifying NHibernate-Related Bottlenecks through Performance Monitoring

Sat, 03 Mar 2007 16:51:00 -0600

A distilled methodology for detecting and isolating NHibernate-related performance and scalability issues

Simple Performance Chart

Thu, 08 Feb 2007 17:39:00 -0600

The Simple Performance Chart is a UserControl that is designed and developed to display varying performance data like reads per second on a disk drive, the bandwidth for a server, or free CPU resources, in a visual, clean manner. It can be controlled by a built-in Timer, which makes synchronized display of values possible. The control offers several formatting options like border style, line colors and styles, widths, a background gradient, and so on.

Optimizing integer divisions with Multiply Shift in C#

Fri, 02 Feb 2007 20:55:00 -0600

An article on improving the performance of an algorithm by replacing integer divisions

Speed Testing and the Stopwatch Class

Sat, 20 Jan 2007 05:40:26 -0600

Software must operate at a speed that is acceptable to the end user. Often large improvements can be made by improving the speed of short-lived but heavily used routines. The speed of these can be accurately measured using the .NET 2.0 Stopwatch class.

Improving ASP.NET Application Performance and Scalability

Thu, 18 Jan 2007 15:53:42 -0600

Explore ways to reduce page load time, manage state efficiently, scale back on memory use, handle resources better, and improve data access in your ASP.NET applications.

Some Useful Concurrency Classes and A Small Testbench

Mon, 15 Jan 2007 18:20:00 -0600

Useful concurrency classes and small test bench in C#

Implementing the CLR Asynchronous Programming Model

Sun, 14 Jan 2007 18:00:00 -0600

Slow and unpredictable are words that typically characterize I/O operations. When an application performs a synchronous I/O operation, the application is basically giving up control to the device that is doing the actual work. For example, if an application calls the StreamRead method to read some bytes from a FileStream or NetworkStream, there is no telling how much time will pass before that method returns. If the file being read is on a local hard drive, then Read may return almost immediately. If the remote server housing the file is offline, then the Read method may wait several minutes before timing out and throwing an exception. During this time, the thread making the synchronous request is tied up. If that thread is the UI thread, the application is frozen and stops responding to user input. A thread waiting for synchronous I/O to complete is blocked, which means that thread is idle but is not allowed to perform useful work. To improve scalability, many application developers create more threads. Unfortunately, each thread introduces significant overhead such as its kernel object, user-mode and kernel-mode stacks, increased context switching, the calling of DllMain methods with thread attach/detach notifications, and so on. The result is actually reduced scalability. An application that wishes to remain responsive to the user, improve scalability and throughput, and increase reliability should not perform I/O operations synchronously. Instead, the application should use the common language runtime (CLR) Asynchronous Programming Model (APM) to perform asynchronous I/O operations..

Use SQL Parameters to Overcome Ad Hoc Performance Issues

Sun, 07 Jan 2007 21:06:00 -0600

Defining (rather loosely) ad hoc queries as SQL commands built as strings by an SQL client application and submitted to SQL Server.

Pure C# MiniLZO port

Fri, 22 Dec 2006 15:05:00 -0600

Fast stream compression using a ported minilzo for .NET.

ASP.NET AJAX under the hood secrets

Fri, 22 Dec 2006 09:47:00 -0600

Performance tips and hard-core tricks that change core runtimes, not for the faint hearted.

Output Caching in ASP.NET 2.0

Tue, 12 Dec 2006 18:00:00 -0600

One of the most sure-fire ways to improve a web application's performance is to employ caching. Caching takes some expensive operation and stores its results in a quickly accessible location. ASP.NET version 1.0 introduced two flavors of caching: Output Caching - caches the entire rendered markup of an ASP.NET web page or User Control for a specified duration. Data Caching - a programmatically-accessible, in-memory data cache for storing objects in the web server's memory. For a more in-depth discussion on ASP.NET 1.x's caching capabilities, refer to Scott McFarland's Caching with ASP.NET and Steve Smith's ASP.NET Caching: Techniques and Best Practices articles. In ASP.NET 2.0, the caching system has been extended to include SQL cache dependencies, cache profiles, and post-cache substitution for output cached pages. The Caching for Performance section of the ASP.NET 2.0 QuickStarts provides a good overview of ASP.NET 2.0's caching options. This article explores output caching in ASP.NET 2.0, starting with an overview of output caching and followed by a detailed look at creating pages that include both cached and non-cached markup using fragment caching and post-cache substitution techniques.

Optimizing Serialization in .NET

Mon, 27 Nov 2006 11:25:00 -0600

Provides code and techniques to enable developers to optimize serialization of data.

Queue-Linear Flood Fill: A Fast Flood Fill Algorithm

Wed, 15 Nov 2006 20:00:00 -0600

A super-fast flood fill algorithm and implementation, plus helpful optimization tips for image processing.

Fast Pointerless Image Processing in .NET

Wed, 15 Nov 2006 19:28:00 -0600

Process GDI+ images at blazing speeds, with no pointers or unsafe code. Eliminate the need for LockBits(), so you can edit the bits directly and update in real time.

Inside Diagnostic Tools for .NET

Tue, 14 Nov 2006 19:00:00 -0600

Many diagnostic tools use the CLR Profiling API-even those that aren't strictly profilers. So if you've ever wondered how these tools work, a look at the Profiling API is a good start. In this column, you'll see how they work and look at some useful tips and tricks. You'll also find some essential resources in the "Other Profiling Resources" sidebar. To use the CLR Profiling API, you create a DLL using an unmanaged language-typically C++, then you set some environment variables that instruct the common language runtime (CLR) to load the DLL and allow it to use the Profiling API. When loaded, this DLL effectively becomes an extension of the CLR itself, receiving callbacks, requesting information, and making changes deep within the implementation of the CLR. The Profiling API can provide notification of many activities within the CLR and managed code, including the creation and destruction of appdomains, loading and unloading assemblies, JIT compiling functions, executing functions, throwing and catching exceptions, and doing garbage collections. Using the Profiling API, you can get information about parts of the application, such as names and locations of assemblies, descriptions of types and functions, and locations and layout of objects in memory. Finally, you can use the Profiling API to modify settings, instructions, and the like, including disabling optimizations in the JIT compiler, changing the intermediate language (IL) for a function, or even creating new types and functions..

Observable property pattern, memory leaks, and weak delegates for .NET

Mon, 13 Nov 2006 12:11:00 -0600

This article is dedicated to the observable property design pattern, a very nice pattern used in the Microsoft .NET Framework, a possible memory leak problem with it, and gives a couple of ways to solve it.

Optimizing Serialization in .NET - part 2

Mon, 23 Oct 2006 13:58:00 -0500

Provides code and techniques to enable developers to optimize serialization of DataSets/DataTables.

CLR Inside Out: Investigating Memory Issues

Wed, 11 Oct 2006 19:00:00 -0500

Uncovering and correcting memory issues in managed applications can be difficult. Memory issues manifest themselves in different ways. For example, you may observe your application's memory usage growing unboundedly, eventually resulting in an Out Of Memory (OOM) exception. (Your application may even throw out-of-memory exceptions when there is plenty of physical memory available.) But any one of the following may indicate a possible memory issue: An OutOfMemoryException is thrown. The process is using too much memory for no obvious reason that you can determine. It appears that garbage collection is not cleaning up objects fast enough. The managed heap is overly fragmented. The application is excessively using the CPU. This column discusses the investigation process and shows you how to collect the data you need to determine what types of memory issues you are dealing with in your applications. This column does not cover how to actually fix problems you find, but it does give some good insights as to where to start.

How to Append to a Large XML File

Wed, 11 Oct 2006 11:19:00 -0500

Appending to an XML file can be tricky with large files in terms of speed and memory usage. This article covers the options available in .NET.

A fast equivalent for System.Random

Tue, 10 Oct 2006 12:12:00 -0500

A simple and fast random number generator that can be substituted in place of System.Random, with extra methods and fast re-initialization.

Speed Optimization with page and server controls, web application settings and coding practices

Mon, 25 Sep 2006 12:17:40 -0500

ASP.NET Applications speed optimizations regarding to use of page and server controls, web application settings and best coding practices

Creating a Custom .Net Profiler

Wed, 30 Aug 2006 12:07:00 -0500

Describes how to create your own custom profiler for any managed application

AltSerializer - An Alternate Binary Serializer

Mon, 28 Aug 2006 11:34:00 -0500

The AltSerializer is a replacement for the binary serializer built in to .NET.

FastPixel - A much faster alternative to Bitmap.SetPixel

Wed, 16 Aug 2006 03:23:00 -0500

Ever wanted something faster than SetPixel? Well you've found it.

Not Used Analysis - A IL code analysis tool for looking for types, methods, and fields that are not used

Fri, 11 Aug 2006 10:24:00 -0500

This tool analyses the IL of a list of assemblies, looking for types, methods, and fields that are not used by another list of assemblies. This lets you see if you have unused legacy code lying around that should be cleaned up.

ASP.NET 2.0 Performance Tuning Considerations

Fri, 04 Aug 2006 06:14:36 -0500

ASP.NET 2.0 has a lot of performance enhancements. In addition this article discusses on certain techniques which can improve the performance of applications.

Performance Console (PerfConsole)

Thu, 03 Aug 2006 15:03:00 -0500

The PerfConsole allows developers to analyze Visual Studio Performance Profiler's reports. It is a simple performance investigation tool which tries to adopt a debugger like experience to drilling into Visual Studio Performance Profiler generated data.

StringBuilder vs. String / Fast String Operations with .NET 2.0

Tue, 25 Jul 2006 18:31:00 -0500

Comparision of String/StringBuilder functions. Efficient String handling.

EasyPack - A Pushbutton Batch JavaScript Error Checking, Compression and Obsfucation Tool

Tue, 25 Jul 2006 09:04:00 -0500

EasyPack enables syntax checking, validation, compression and obsfucation of JavaScript files with a single click

System.Diagnostics.Stopwatch - always remember to use Reset

Tue, 18 Jul 2006 14:18:00 -0500

Wrong System.Diagnostics.Stopwatch s = new System.Diagnostics.Stopwatch(); s.Start(); for (i = 0; i < count; i++) Test1(); s.Stop(); Console.WriteLine("Test1: {0}", s.ElapsedMilliseconds); s.Start(); for (i = 0; i < count; i++) Test2(); s.Stop(); Console.WriteLine("Test2: {0}", s.ElapsedMilliseconds); Right System.Diagnostics.Stopwatch s = new System.Diagnostics.Stopwatch(); s.Start(); for (i = 0; i < count; i++) Test1(); s.Stop(); Console.WriteLine("Test1: {0}", s.ElapsedMilliseconds); s.Reset(); s.Start(); for (i = 0; i < count; i++) Test2(); s.Stop(); Console.WriteLine("Test2: {0}", s.ElapsedMilliseconds); Not that *cough* I would ever make this mistake or anything, but you know... it could happen to like, a friend, or something. Ya. My friend. :)

patterns & practices Guidance Explorer

Fri, 14 Jul 2006 16:36:55 -0500

What are the security and performance proven practices for .NET applications? You can use Guidance Explorer to find out. Guidance Explorer is a tool to help you find and use relevant patterns & practices guidance.

HTTP Compression - Quick and Dirty Solution

Tue, 11 Jul 2006 13:03:00 -0500

Use HTTP Compression on ASP.NET 2.0 pages

ViewState Compression

Mon, 10 Jul 2006 05:42:00 -0500

How to compress the ViewState of ASP.NET pages and save bandwidth

A General Fast Method Invoker

Tue, 27 Jun 2006 21:49:00 -0500

Method reflecting invoke is nice, but frequently do it can be too slow. This article describes an alternative method for dynamic method invoke.

Advanced Basics: Monitor Your Apps with System.Diagnostics

Mon, 26 Jun 2006 13:50:48 -0500

The System.Diagnostics namespace provides classes for interacting with event logs, performance counters, and system processes, and can really help when you've got bugs. Find out how.

Fast Dynamic Property Accessors

Fri, 23 Jun 2006 22:48:00 -0500

Fast run-time access to Property Values using the new (.Net 2.0) DynamicMethod class and a very small amount of Emitted IL code.

A Fast Serialization Technique

Fri, 19 May 2006 12:54:00 -0500

Transparently boosting serialization performance and shrinking the serialized object's size.

A Fast CSV Reader

Thu, 18 May 2006 16:03:00 -0500

A reader that provides fast, non-cached, forward-only access to CSV data.

Share The Load: Report Visual Studio Team System Load Test Results Via A Configurable Web Site

Wed, 03 May 2006 19:00:00 -0500

This article discusses a new load test tool in Visual Studio 2005 Team System for performance and stress testing your Web sites, Web services, and other server components. Combined with its handy reporting capabilities, the load test tool provides some powerful options for sharing and managing test results.

Concurrent Affairs: Reader/Writer Locks

Wed, 03 May 2006 19:00:00 -0500

The Microsoft .NET Framework Class Library includes a ReaderWriterLock class in the System.Threading namespace. This month Jeffrey Richter explains when to use it and how you can get better threading performance.

.NET Offers a "First Chance" to Squelch Performance-killing Hidden Exceptions

Wed, 03 May 2006 18:04:18 -0500

Uncaught exceptions in your .NET applications can turn an otherwise high-performance application into a snail, especially those that are allowed to be "eaten" by subsequent code. Find out how to use very handy "First Chance" exception feature in the .NET debugger to root out nasty hidden exceptions.

Cache In On the Enterprise Library Caching Block for .NET 2.0

Thu, 06 Apr 2006 14:31:53 -0500

Nearly every application needs to cache data. While you're probably familiar wth the caching functionality built into ASP.NET, the Enterprise Library Caching Block provides in-memory, file-based, or database caching storage for all your other .NET applications.

CLR Inside Out: The performance benefits of NGen.

Wed, 05 Apr 2006 19:00:00 -0500

JIT compilation has its advantages, but it has its drawbacks, too. NGen may help to improve the performance of your applications. Surupa Biswas shows you why and when.

TraceTool 6: The Swiss-Army knife of trace

Tue, 04 Apr 2006 12:24:00 -0500

A C#, C++, Delphi, and Java trace framework and a trace viewer: Tail, outputDebugString, event log, and with Log4J, Log4Net, and Microsoft Enterprise Instrumentation Framework (EIF) support. This comes with full support for Pocket PC development.

NTime - Performance unit testing tool

Fri, 31 Mar 2006 00:11:00 -0600

An article on a performance testing tool to test an application against its performance.

Performance Quiz #9 : IList List and array speed -- solution

Sun, 12 Mar 2006 08:46:00 -0600

In the test case as given there's a great deal of repeated work extracting the length of the array and accessing the items. This is because of the unusual property that arrays have -- they implement IList for potetially more than one T even due to inheritance. In the interest of economy alone then it is worthwhile to consolidate the IList implementations into some kind of secret helper but this has some consequences. Short results: Test Case Milliseconds Test1: Array 54 Test2: List 8 Test3: ArrayWrapper 14 Test4: Array via foreach 9 Test5: List via foreach 11 Test6: Array via special 6 Test7: List via special 8

Performance Quiz #9 : IList<T> List and array speed

Thu, 09 Mar 2006 18:31:00 -0600

A short and sweet quiz with lots of juicy discussion possibilities: public int Sum(IList<ushort> indices){ int result = 0; for (int i = 0; i < indices.Count; i++) result += indices[i]; return result;} Considering only the time it takes to do the Sum (i.e. assuming we had already set up the array/list) which gives better performance and why? // #1ushort[] tmp = new ushort[500000]; // this doesn't countSum(tmp);// this is what we are timing OR // #2List<ushort> tmp = new List<ushort>(500000); // this doesn't countfor (int i = 0; i < 500000; i++)tmp.Add(0); // this doesn't countSum(tmp); // this is what we are timing What say you gentle readers?

Built For Speed: Develop Turbocharged Apps For Windows Compute Cluster Server

Wed, 08 Mar 2006 18:00:00 -0600

This article explores the services provided by Compute Cluster Server 2003 and the tools provided by Visual Studio 2005 that will help you develop High-Perfomance Computing applications.

.NET Profiling: Write Profilers With Ease Using High-Level Wrapper Classes

Wed, 08 Mar 2006 18:00:00 -0600

Here Joachim H. Fröhlich and Reinhard Wolfinger show you how to get all the great functionality of the .NET Profiling API the easy way, with custom wrappers.

CLR Inside Out: Extending System.Diagnostics

Wed, 08 Mar 2006 18:00:00 -0600

CLR Inside Out: Extending System.Diagnostics

An O(ND) Difference Algorithm for C#

Mon, 06 Mar 2006 09:58:00 -0600

This article is about comparing text files, and the proven, best, and most famous algorithm to identify the differences between them.

Full-Text Search: Fast, Damn Fast and DotLucene

Mon, 06 Mar 2006 08:26:00 -0600

DotLucene Demo: Search 3.5 GB of text in 0.1 second!

Get Control and Performance with the Real Time Stylus API

Fri, 24 Feb 2006 18:49:42 -0600

The Real Time Stylus API provides an alternate way to receive pen input pen. This high performance API provides a great level of control to developers for a small penalty in added effort.

Xenocode Postbuild 2006 allows .NET applications to run anywhere

Wed, 22 Feb 2006 18:09:11 -0600

Xenocode Postbuild 2006 breakthrough technology allows .NET applications to run on any Windows PC, with or without the Framework, counteracts decompilation and reverse engineering, optimizes application size and performance, and dramatically reduces test and support costs by eliminating "DLL/versioning hell".

Fast/Compact Serialization Framework

Wed, 22 Feb 2006 15:13:00 -0600

A simple and fast way of "serializing objects by value" to compact binary representations.

Power to the People

Sat, 18 Feb 2006 01:05:56 -0600

Software can have a huge effect on the life span of a battery; scaling down functionality is an easy way to drastically increase the lifetime of mobile PC battery. Do your users a favor and find out how to optimize your applications' power requirements.

ASP.NET Best Practices for High Performance Applications

Fri, 17 Feb 2006 17:02:00 -0600

This article lists the techniques that you can use to maximize the performance of your ASP.NET applications. It provides common issues, design guidelines, and coding tips to build optimal and robust solutions.

High-Performance .NET Application Development & Architecture

Wed, 15 Feb 2006 09:25:00 -0600

This article demonstrates the art of creating and architecting high-performance and scalable .NET applications, covering all stages, from planning to development and their perspective best practices.

Winning Forms: Practical Tips For Boosting The Performance Of Windows Forms Apps

Mon, 13 Feb 2006 23:01:31 -0600

This article discusses techniques you can use to ensure that Windows Forms-based apps provide optimal performance to match the rich UI responsiveness they're known to provide.

How to write friendlier code for the Garbage Collector and to gain performance boost

Thu, 09 Feb 2006 21:46:00 -0600

Learn how to create objects in a way that diminishes the GC performance cost.

Using custom attributes to add performance counters to your application

Wed, 08 Feb 2006 17:31:00 -0600

A brief overview of what performance counters are and a library that makes their use a bit easier.

NCache 2.0

Mon, 30 Jan 2006 11:27:23 -0600

NCache is a high performance in-memory object caching solution for mission critical .NET applications with real-time data access needs. NCache not only lets you cache read-only data but also complex transactional data with relationships. As a result, your application can cache most of its data and dramatically improve performance.

.NET Framework: Introducing Generics in the CLR

Tue, 24 Jan 2006 21:21:37 -0600

Generics are a shipping feature of the .NET Framework 2.0, and managed code is faster, more maintainable, and more robust because of it. Jason Clark provides an in-depth look.

Exceptions and Performance in .NET

Thu, 19 Jan 2006 12:49:00 -0600

Almost every time exceptions are mentioned in mailing lists and newsgroups, people say they're really expensive, and should be avoided in almost all situations. Jon Skeet examines the claim.

CLR Inside Out: Improving Application Startup Time

Wed, 11 Jan 2006 01:24:42 -0600

Client application startup time is really important to users. In this month's CLR Inside Out column, the CLR team provides valuable tips on improving startup speeds.

Improve performance using ADO.NET 2.0 batch update feature

Mon, 19 Dec 2005 02:00:00 -0600

When you use SqlDataAdapter for performing updates, the SqlDataAdapter propagates the updates one by one. That means if there are 100 rows to be updated the SqlDataAdapter will execute 100 separate operations against the database. As you might have guessed this is not efficient while dealing with large number of rows. Fortunately SqlDataAdapter allows you to execute updates in batches. You can specify the batch size i.e. number of rows to be treated as a single batch via UpdateBatchSize property.

CLR Inside Out: Base Class Library Performance Tips and Tricks

Tue, 13 Dec 2005 02:00:00 -0600

CLR Inside Out: Base Class Library Performance Tips and Tricks

YourKit .NET Profiler

Fri, 09 Dec 2005 02:00:00 -0600

YourKit, LLC, known technology leader in Java profiler world, starts Early Access Program of its new .NET profiler. YourKit .NET Profiler 1.0 will be the first YourKit solution for .NET platform. The first version will support memory profiling as well as support CLR telemetry. Further versions will add CPU profiling support, as well as other memory profiling capabilities. Read more about features and dowload the software at http://www.yourkit.com/dotnet/

Memory Models: Understand the Impact of Low-Lock Techniques in Multithreaded Apps

Tue, 13 Sep 2005 03:00:00 -0500

Because the use of low-lock techniques in your application significantly increases the likelihood of introducing hard-to-find bugs, it is best to use them only when absolutely necessary. Here Vance Morrison demonstrates the limitations and subtleties low-lock techniques so that if you are forced to use them you have a better chance of using them correctly.

Concurrent Affairs: Performance-Conscious Thread Synchronization

Tue, 13 Sep 2005 03:00:00 -0500

Concurrent Affairs: Performance-Conscious Thread Synchronization

{ End Bracket }: Improving Managed DirectX Performance

Tue, 12 Jul 2005 03:00:00 -0500

{ End Bracket }: Improving Managed DirectX Performance

Reflection: Dodge Common Performance Pitfalls to Craft Speedy Applications

Tue, 14 Jun 2005 03:00:00 -0500

With reflection in .NET, you can load types, understand their members, make decisions about them, and execute, all within the safety of the managed runtime. But to use this power wisely, it's important to understand the associated costs and pitfalls to keep performance impact at a minimum. This article explains how.

Make It Snappy: Juice Up Your App with the Power of Hyper-Threading

Tue, 10 May 2005 03:00:00 -0500

In this article, the author explores the hyper-threading technology found on newer Intel Pentium 4 processors and demonstrates how adding parallelism to your code can improve performance on hyper-threaded machines. He covers advanced optimizations for hyper-threading and shows a number of useful patterns. Code samples are in C#, but you can apply the same principles in other languages as they apply to both managed and unmanaged applications.

JIT and Run: Drill Into .NET Framework Internals to See How the CLR Creates Runtime Objects

Tue, 12 Apr 2005 03:00:00 -0500

There's lots to explore in the .NET Framework 2.0, and plenty of digging to be done. If you want to get your hands dirty and learn some of the internals that will carry you through the next few years, you've come to the right place. This article explores CLR internals, including object instance layout, method table layout, method dispatching, interface-based dispatching, and various data structures.

Speed: NGen Revs Up Your Performance with Powerful New Features

Tue, 15 Mar 2005 02:00:00 -0600

In the .NET Framework 2.0, NGen has been greatly improved and offers a number of compelling new features to make it easier and faster to deploy high-performance managed applications. This article introduces some of these new features and explains how and when you should use NGen to improve the performance of your apps.

How to Write High-Performance C# Code

Sun, 12 Sep 2004 19:00:00 -0500

Writing code that runs quickly is sometimes at odds with writing code quickly. C.A.R. Hoare, computer science luminary and discoverer of the QuickSort algorithm, famously proclaimed, 'Premature optimization is the root of all evil.' The extreme programming design principle of 'You Aren't Gonna Need It' (YAGNI) argues against implementing any features, including performance optimizations, until they're needed.

Boosting Your .NET Application Performance

Sat, 07 Aug 2004 19:00:00 -0500

Confused about the tiers, performance or scalability of your .NET apps? If so, James has come to the resue with his personal insight, tips and tricks on how best to structure your .NET apps.

Get the Most Out of .NET

Sun, 20 Jul 2003 19:00:00 -0500

Here are some tips on how to improve the performance of your .NET applications. In the old Visual Basic 6 world, string manipulation was a performance issue that many developers spent time dealing with.