Control Implementation of ISynchronizeInvoke
Describes how you can call the Control class implementation of
ISynchronizeInvoke to call code on the UI thread. |
15 Jan 2005 |
Using
Worker Threads in Windows Forms
Explains how to use a worker thread to run lengthy routines and how to
synchronise access to the user interface elements. |
1 Jan 2005 |
Handling Lengthy Routines in a Form
Describes the problems with having length code in Windows Forms event
handlers and one method to solve the problem. |
15 Dec 2004 |
Volatile Reads and Writes
Explains how to prevent reordering of reads and writes of variables which
is vital in a multi threaded application. |
1 Dec 2004 |
Standard .NET Performance Counters
This final part of this mini-series outlines the performance counters
that are installed by .NET to allow you to monitor how the runtime is
working and how your own assemblies are performing. |
15 Nov 2004 |
Writing Performance Counters
Illustrating how to create your own performance counters in your
applications. |
1 Nov 2004 |
Reading .NET Performance Counters
The second part of this series explains how to use the .NET framework
classes to read the performance counters provided by another process. |
15 Oct 2004 |
.NET Performance Counters
First part of a series of articles on performance counters. This
articles gives an overview of what performance counters are and the
registration that you need to perform. |
1 Oct 2004 |
Socket Asynchronous Calls
Describes how the System.Net.Socket class implements asynchronous
methods |
15 Sept 2004 |
FileStream Asynchronous Calls
Describes how the FileStream file access methods are implemented to perform asynchronous calls |
1 Sept 2004 |
System Async Calls
First article describes some of the methiods that you can call asynchronously without using a delegate |
15 Aug 2004 |
Free .NET Development Tools from Microsoft
Outlines the tools that you can download for free from Microsoft and use for .NET development |
1 Aug 2004 |
Event Log Categories
Describing how you can use categories in .NET |
15 July 2004 |
Event Handlers
Comparing identifying event handler methods through interfaces and attributes |
1 July 2004 |
Notification and Delegate Lifetimes
Investigates the lifetime issues involved in adding a delegate to an event |
15 June 2004 |
Do We Need Edit and Continue?
A personal opinion about VB.NET edit and continue in Whidbey |
1 June 2004 |
Command Line and Visual Studio Tools
Here I outline support in Visual Studio for projects and how you can use
project files to run tools in 'build events'. |
15 May 2004 |
.NET Notifications
Here I outline delegates and events as a tightly coupled notification
mechanism and COM+ as a loosely coupled notificaton mechanism. |
1 May 2004 |
Java:
Worth Another Look?
Visual Studio .NET 2003 is provided with J#, a Java-like language.
Far better than this, is that much of the JDK has been implemented as a
managed library that you can call from any .NET language and in this
article I give an example of using Java's ZIP file support. |
15 April 2004 |
Base64
Stream Class
In this article I present a stream class that you can use to encode and
decode Base64 data. |
1 April 2004 |
The
Base64 Classes in the Framework Library
The framework library provides some classes to encode data in
Base64. However, these classes are not perfect for the reasons that I
outline here. |
15 March 2004 |
Versatile
Streams
This is the first in three articles on streams. This first article
explains streams and how to implement your own stream class. |
1 March 2004 |
XML
Serialization
The XmlSerializer class is used to obtain the state of an object
from a XML file, or create an XML file from an object's state. Unlike
the SOAP formatter, the XmlSerializer class is instructed by attributes
on the .NET class. These attributes allow you to have fine control over
the format of the XML file that is generated. So XML Serialization
provides a flexible mechanism to store object state in XML files. |
15 February 2004 |
Visual
Studio Application Wizards
Here I outline the problems of the UI-less project wizards in Visual
Studio .NET 2003 and explain the format of the files that make up
project wizards. |
1 February 2004 |
A
Personal .NET Review of 2003
There have been some important changes in .NET announced in 2003, in
this article I list the various .NET events I have attended and the
effect they have had on .NET |
15 January 2004 |
Custom
Marshalling
Following on from the previous article, this article goes into the
details of custom marshalling |
1 January 2004 |
[DllImport]
Marshalling
Does the managed C++ developer every have to use [DllImport]? Doesn't
IJW do every thing that [DllImport] does? The answer is no to the second
question, [DllImport] allows you to customize the marshalling, so
managed C++ developers sometimes do need to use [DllImport]. |
15 December 2003 |
Optional
Values in Whidbey
I investigate some of the issues I have found with using optional values
that are provided in Whidbey thyrough its new support for generics. |
1 December 2003 |
Is
.NET Too big Part 2
Following on from the last article I analyse the DLLs that are loaded
automatically by a bare-bones .NET application and question why DLLs
that are not needed are loaded. |
15 November 2003 |
Is
.NET Too big Part 1
In this article I speculate whether the .NET redistributable is too big
and outline how I would partitian the redistributable into mandatory and
optional parts |
1 November 2003 |
Raw
Sockets and .NET
Raw sockets can be used to manipulate IP packets at the packet level.
Winsock 2 gives access to raw sockets for administrators and .NET is
implemented using Winsock 2. |
15 October 2003 |
.NET
Performance
Here, I present some code thatI have used to compare the performance
of native C++ with .NET code written with managed C++. I found that for
a computationally intensive routine the two have similar performance. |
1 October 2003 |
Comparisons
Explains how data is compared in .NET |
15 September 2003 |
Windows
Properties
Win32 windows can be associated with 'properties' in this article I show
how you can use them in .NET |
1 September 2003 |
Single
Instance of a .NET Application
Explaining some techniques to ensure that just one instance of an application runs
at a particular time. |
15 August 2003 |
Windows
Class Names and Windows Forms
Windows Forms is just a wrapper over Win32 windowing, in this article I
explain how Windows Forms creates and registers a windows class, |
1 August 2003 |
Structure
Storage Property Sets
How don you know who wrote a Word document? How do you find this out
with .NET? |
15 July 2003 |
Satellite
Assemblies
What are they? What are they used for? |
1 July 2003 |
.NET
Code Optimization
Talking about the managed C++ code optimizer. |
15 June 2003 |
More
.NET and COM Issues
Highlighting the reasons why you should be careful about /codebase |
1 June 2003 |
Why
.NET
I think everyone should ask this question at least once a day. Why use
.NET? My answer is that security is the most important reason. |
15 May 2003 |
Fusion
The second part to the DLL Hell article |
1 May 2003 |
.NET
and DLL Hell
In this two part article I explain what causes DLL Hell and how to solve
it |
15 April 2003 |
The
.NET Console Class
The v1.x System.Console class is a first try by Microsoft. In this
article I give an improved class. (Stop Press! The new version in
Whidbey will have all of the features that I mention.) |
1 April 2003 |
Com
Apartments and .NET Threads
Talks about the default apartment types in .NET and some of the
problems it can cause |
15 March 2003 |
Serializing
Delegates
You can serialize a delegate to persistent store. This explains how,
and muses about what you can do with it |
1 March 2003 |
| The
Visual Studio Expression Evaluator part 2 |
15 February 2003 |
The
Visual Studio Expression Evaluator
In this article I explain the facility in the VS.NET IDE for evaluating
expressions including your program's variables. |
1 February 2003 |
.NET
Applications and Working Set
In this article I explain why Windows Forms appear to use such a large
amount of memory and how you can (at least initially) reduce this memory
usage drastically. |
15 January 2003 |
Exceptions
and GUI Applications
Exceptions get special handling in GUI applications and in
this article I explain the mechanism. |
1 January 2003 |
Exceptions
and Threads
Exceptions are thrown on a thread. If the thread does not catch an
exception then the thread will die. In this article I explain this
mechanism, and describe how to provide a application domain based
handler for unhandled exceptions. |
15 December 2002 |
Application
Domains and Unmanaged Transitions
Managed C++ is wonderful because it allows you to call unmanaged code in
a way that is not possible with other .NET languages. However, there is
a bug in the runtime that means that in a process that has more than one
application domain the runtime 'forgets' the domain where a call to
unmanaged code originated. I explain this bug in this article. |
1 December 2002 |
.NET
Installers
.NET strives to enable XCOPY deployment, but in some case this is not
possible. In this article I explain how to provide code that will be
called at installation and uninstallation. |
15 November 2002 |
Destructors
Part 2
C# 'destructors' are actually the implementation that will be used for
finalization. In this article I describe how this relates to C++
finalizers and the issues that occur if you derive a C++ class from a C#
class with a finalizer. |
1 November 2002 |
Destructors
Part 1
.NET has a concept of 'finalization' which differs in many significant
ways to C++ destructors. However, when you write a C++ .NET class the
compiler will generate a destructor, and in this article I explain how
you can use this. |
15 October 2002 |
Loading
Configuration Files
Following on from my earlier article on configuration, I use this
article to describe how to load a specific configuration file. |
1 October 2002 |
Managed
C++ and GUI Development
There are several pitfuls involved in writing .NET GUI code with managed
C++ and in this article I explain what they are and how to avoid them. |
15 September 2002 |
The
NT Event Log
This is my favourite peeve. The .NETdesigners have been sloppy and have
taken the VB6 implementation for the .NET EventLog class. This code is
really poor and in this article I explain why you should never
use the EventLog class to generate NT event log messages. |
1 September 2002 |
Diagnostic
Asserts
Here I explain asserts and how to use them. I describe why I think
the C# wizard designers are wrong with respect to asserts and I descibe
a bug in the .NET assert code and breifly explain how to fix it. |
15 August 2002 |
Tracing
Code Part 2
In this article I follow up by explainig why I say that tracing release
code can be damaging. |
1 August 2002 |
Tracing
Code Part 1
Tracing is useful when testing code. It is rarely useful for release
code where tracing can be damaging. In this article I describe the
tracing classes. |
15 July 2002 |
Properties
and the Windows Forms Library
The Windows Forms Library has a striking resemblance to unmanaged Visual
Basic forms. One really irritating feature is the excessive use
of properties and in this article I explain why the Windows Forms team
made a really big mistake with this excessive dependence. Often
the code does not work the way you expect, sometimes it runs code
multiple times and other times seemingly unrelated code is called.
Its far easier to eshew properties and just use methods as I explain in
this article. |
1 July 2002 |
.NET
Exceptions
When should you use exceptions in .NET code? |
15 June 2002 |
C++ Delegates
I always wondered why C++ delegate contructors looked the way they did.
So I went back to native C++ and looked how pointer to members behaved
and then wrote a template around pointer to members to make the
mechanism more generic and found that I got a class that looked very
similar to the delegate class created by the C++ compiler. More details
are in this article. |
1 June 2002 |
Configuration
In this article I present the basic features of .NET configuration. |
15 May 2002 |
Custom
Event Methods
If you define an event the compiler will generate the code to combine
and remove delegates from the event and to raise the event. You can
write these methods yourself using a different delegate storage
mechanism. |
1 May 2002 |
Varargs
The .NET spec allows methods to have a variable number of
arguments, but currently the only way to write such methods is
directly in IL. C++ does allow you to access methods with varargs, but
not write them. C# does not even allow you to call varargs method, but
simulates the action with [ParamArray]. However, [ParamArray] is not
treated the same as varargs by C++. Basically it is a mess. |
15 April 2002 |
Pointers
In this article I describe the basic features of C++ .NET pointers and
explain features like interior pointers |
1 April 2002 |
.NET
Languages
Here I set the scene by describing my impression of the plethora of
.NET Languages |
15 March 2002 |
