Conferences
Home About Workshops Articles Writing Talks Books Contact

Expert Speaker

Richard speaks at all of the world's major .NET conferences. In the list below click on the symbol to read details about the selected conference.

Microsoft Livemeeting Webcast

1 December, 2004, 15:00 GMT

See msevents-eu.microsoft.com

  • .NET Configuration
    In this webcast Richard explains the details about how to provide configuration information for your .NET application. He will describe how the configuration mechanism works, how to read configuration values and present some of the .NET framework classes that use configuration settings. Richard will also explain how to write your own configuration handler so that you can add your own custom configuration settings. Finally, Richard will address some of the shortcomings of the configuration mechanism and suggest some ways to overcome them.

DevConnections

7-10 Novenmber, 2004, Mandalay Bay Resort and Casino, Las Vegas,  USA

See www.devconnections.com/devconnections/vs/

  • Exception Handling and .NET
    .NET encourages you to handle errors with exceptions. In this talk Richard will explain how exceptions are used in .NET and how you generate and catch them. He will show how exceptions are handled in multi threaded code, and in .NET remoting and what happens if you do not catch exceptions in these situations. Richard will also cover strategies of handling exceptions, and some of the pitfalls that occur when you provide exception handling. Finally, Richard will cover exception filters which are only available in VB.NET.
  • Instrumenting Your .NET Application
    .NET provides many features to instrument your application and in this talk Richard will investigate those classes and describe some of the issues that occur. He will start by covering the tracing and assert classes in .NET and explain the architecture and illustrate some of the problems that occur when these classes are used incorrectly. You will see how to extend the architecture to provide your own trace listeners. Next Richard will describe using the event log and explain how to generate and read event messages. Again, this facility has its issues and he will explain how to avoid the pitfalls. Finally, Richard will demystify the performance monitor classes and explain how to allow your application to provide information about the work it is doing.
  • Threading and .NET: the Pleasure and the Pitfalls
    Multithreading in .NET is simple and this is its big problem because threading comes with hidden dangers. In this talk Richard will explain the threading classes and how to use them, and he will describe the problems that you may experience. Richard will cover the issues of shared data and how to protect it, and then explain how deadlocks and race conditions occur and how to avoid them. Richard will describe how threads fit in with the application domain architecture and describe foreground and background threads, interrupting and terminating threads. Finally he will cover how exceptions are handled in multi threaded code and .NET thread pools.

WinDev 2004

October 25-29 2004, Boston, MA, USA

See www.butrain.bu.edu/windev/

  • Instrumenting Your .NET Application
    .NET provides many features to instrument your application and in this talk Richard will investigate those classes and describe some of the issues that occur. He will start by covering the tracing and assert classes in .NET and explain the architecture and illustrate some of the problems that occur when these classes are used incorrectly. You will see how to extend the architecture to provide your own trace listeners. Next Richard will describe using the event log and explain how to generate and read event messages. Again, this facility has its issues and he will explain how to avoid the pitfalls. Finally, Richard will demystify the performance monitor classes and explain how to allow your application to provide information about the work it is doing.
  • .NET Events and Delegates
    In this talk Richard will cover .NET delegates and events. He will start by describing what delegates are and how they are declared and used in both C# and VB.NET. He will explain how to call them synchronously and asynchronously and will explain how the async infrastructure works and handles situations like exceptions and return parameters. During this discussion Richard will describe the changes to asynch invocation that there are in Whidbey. In the second half of the talk he will explain what events are, how they differ from .NET delegates fields and give examples how the .NET framework uses events. Richard will explain the classes provided by the framework to make events more efficient and explain how to write the event members on your own classes.
  • Find Out Everything About Your .NET Objects With Reflection
    Metadata is a vital part of .NET because it provides .NET with the information it needs to determine versioning, type safety and security. Richard will explain what metadata is and how it is extended with attributes. He will look at the various types of attributes and explain how they relate to the runtime. He'll show you how attribute information is stored in assemblies and describe how that data is read at runtime through the Reflection API. Finally, Richard will discuss several examples of using attributes in your own code, as a notation device and as a mechanism to change how other classes use your types.

TechEd 2004

18 June - 2 July 2004, Amsterdam, NL

See www.microsoft.com/europe/teched/

  • .NET Diagnostics
    .NET has many classes to help you to diagnose faults in your applications and in this talk you will learn how to use these classes, see their shortcomings and find out how to overcome those problems. The talk will cover .NET tracing and you'll see how to generate traces from your code, how to read the data, and the issues that you'll get if you leave tracing turn on at run time. Yu will also see how to use asserts and learn about the potential problems that occur with the .NET provided assert dialogs and how to remedy these issues. Finally you'll see how to use event logging in .NET and learn about how the problems with the version 1.1 event logging class has been alleviated in Whidbey.
  • .NET Streams
    In this session, you will explore the new Streams API and you’ll learn to use it to access files and sockets, both synchronously and asynchronously. You’ll learn about character encoding, which will lead on to an explanation of the Stream reader and writer classes. Next we’ll review object serialization and formatters and you’ll see how to control the data that is serialized through attributes and Serializable.
  • .NET Threading Chalk and Talk

DevConnections

18 - 21 April 2004, Orlando, FL, USA

See www.devconnections.com

  • .NET Diagnostics
    .NET has many classes to help you to diagnose faults in your applications and in this talk Richard will explain how to use these classes and will point out their own shortcomings and how to overcome those problems. He will cover .NET tracing and explain how to generate them from your code, how to read the data, and the issues that you'll get if you leave tracing turn on. Richard will also explain asserts, explain what they are used for and describe the problems that occur with the .NET provided assert dialogs and how to remedy these issues. Finally he will explain event logging and tell you why you should not use it in this release of .NET.
  • Writing NT Services with .NET
    One of the great features of the .NET framework is its support for writing services. However, even though its is easy to write a service, it is not a simple task because you have to address the issue of installing and communicating with the service and respect the fact that a service can run under the most privileged of NT user accounts. In this talk Richard will address these issues and describe how to overcome them. At the end of the talk you will be able to create a high performance, well behaved, service.
  • .NET Serialization
    .NET has extensive support for serializing objects and in this talk Richard will explain how and why you will want to do this. he will explain marshal by value objects and their context agile nature and explain how to make an object MBV using the built-in serialization objects: formatters. Richard will then look further into the architecture, describing the ObjectManager and explaining object trees and how multiple references are handled in a serialized object. Finally, Richard will explain custom serialization and describe how to write custom serialization code in .NET.

Microsoft Research Academic Days in Dublin

13 - 16 April 2004, Dublin, Ireland

See research.microsoft.com

  • .NET Fusion
    Fusion is the technology that .NET uses to locate and load assemblies and has been designed to prevent the naming, versioning and location issues that are inherent in Windows Dynamic Link Libraries. Fusion is flexible and allows users to alter the way it works; it also maintains a log of its actions so that users can determine the source of problems when the occur. In this lab we will show how to use the facilities of Fusion and how to interpret the information that it logs. We’ll also show how to share libraries through the Global Assembly Cache (GAC) and how to change versioning through publisher policy files.
  • .NET Security
    There are two important aspects to .NET Security. The first aspect is ensuring that the code is legitimate and has not been tampered. The second aspect is that the code is trusted to perform the actions it attempts. In this lab we will show how .NET validates that an assembly has not been tampered when it is loaded and checks to see if it contains dangerous code through verification. We will also show .NET Code Access Security that uses evidence obtained from the code, rather than from the user, to determine the permissions that the code has to perform specific actions. We will show how to apply code access security to your code and how to configure .NET policy to change the trust given to an assembly.

.NET Workshop

5 February 2004

See www.richplum.co.uk

  • .NET Workshop
    This day long workshop on .NET covers all of the features of .NET. The modules are: .NET Types and Objects; Metadata; Assemblies: Probing, Binding and Versioning; Security; Configuration; Threads, Contexts and Application Domains; Delegates and Asynchronous Calls; Object Serialization; Streams and File I/O; Making Your Code Easier to Debug; Framework Library Overview.

DevConnections

12 - 15 October 2003, Palm Springs, USA

See www.devconnections.com

  • .NET Streams
    In this session, we’ll explore the new Streams API and you’ll learn to use it to access files and sockets, both synchronously and asynchronously. You’ll learn about character encoding, which will lead on to an explanation of the Stream reader and writer classes. Next we’ll review object serialization and formatters and you’ll see how to control the data that is serialized through attributes and ISerializable
  • .NET Contexts
    In this session, Richard will cover the details of .NET contexts and explain how to get information about them and how to manipulate them. All .NET objects run in a context. Some objects don’t care about which context they run in, others can move between contexts, and the rest are bound to contexts. We’ll look at these various types of objects and explain how to create and access them. You’ll see that contexts are flexible and configurable, and you’ll learn how to get information about them and how to write context plug-in code to create your own context, or to extend the features of an existing context.
  • "Everything You’ve Ever Wanted to Know About .NET .Config Files"
    .NET processes are configured using .config files. In this session, you’ll see the types of configuration that is possible, the various files that are used, and how to extend the architecture. You will see how the runtime reads the config file and when this occurs. You’ll learn how the classes read from the config file and how the runtime caches configuration data in your application’s app domain. See how to write a custom configuration handler to read a custom section in a configuration file and make this information available to your code. We’ll also investigate the issue of writing configuration data and cover some solutions that allow you to have per-user writable configurations.
     

DevConnections

4 - 10 May 2003, New Orleans, USA

See www.devconnections.com

  • Managed Extensions for C++
    This talk gives an overview of the extensions to C++ so that it can be used for .NET development. The talk will cover the new keywords and the compiler and linker switches. It will also explain how unmanaged code can be used with managed code and describe how the compiler achieves this. The talk will illustrate the concepts with examples and show the intermediate language that is generated.
  • Interop and Managed C++
    The purpose of this talk is to explain how to use unmanaged C++ in managed C++, and how to use managed code in unmanaged C++. I will start by explaining the various mechanisms to access unmanaged code - using unmanaged data in managed classes and calling unmanaged functions from managed code. I will show the how to call DLL exported functions, both through using the DLLImport attribute so that managed data types can be used as parameters and through P/Invoke so that unmanaged parameter data types can be used. In the second half of the talk I will cover accessing managed code from unmanaged code, and look at the gcroot<> templated wrapper classes around the GCHandle managed class.
  • ATL7 Architecture
    The architecture of ATL has been changed with the version change from 3 to 7. ATL3 code will still compile, but you will get far more facilities if you do things the ATL7 way. In this talk I will explain the new changes, and what they mean to the ATL developer. I will show how the global module code has been factorized into COM, windowing, and Win32 module code and the significance of this. I will show the classes used for DLLs, EXEs and services, new COM registration and support for the GIT. The object map is no longer needed for ATL servers, and I'll explain what is used instead.

VBits at VSLive! 

10 – 14 February 2003, San Francisco, USA

See www.vcdc.com

  • Implementing .NET Remoting
    .NET remotng allows you to access objects running in their own execution contexts in another domain, process or even on another machine. In this talk I will cover the details of the types of objects that can be accessed remotely, and the VB.NET code that you must write. I will explain the architecture of .NET remoting and look at channels, proxy objects, marshal by value and by reference, configuration through API calls and through configuration files. I will also explain how objects are activated and how to control the lifetime of long lived objects.
  • .NET Exceptions
    One of the biggest improvements in VB.NET is managed exceptions. Exceptions allow you to write integrated error handling routines and handle errors from third party code. In this talk I will explain how to throw exceptions and how to write exception handling code, I will descibe good practices of when and how to use exceptions. I will also explain how exceptions are used in distributed applications, with multi threaded and multi application domain processes and how they are handled in GUI applications. Finally, I will show how to write code to handle uncaught exceptions in console and GUI applications.

DevConnections

27 – 31 October 2002, Orlando, USA

See www.devconnections.com

  • Inside Managed C++ parts 1 and 2
    This talk gives an overview of the extensions to C++ so that it can be used for .NET development. The talk will cover the new keywords and the compiler and linker switches. It will also explain how unmanaged code can be used with managed code and describe how the compiler achieves this. The talk will illustrate the concepts with examples and show the intermediate language that is generated.
  • New Features in ATL7
    ATL7 comes with many new facilities, and this talk will concentrate on those that are not associated with COM. During this talk I will cover all the areas that ATL7 has provided support. This will include: threading and thread pooling; resource management features, with support for files, memory and handles; classes for the Win32 crypto APIs and NT security; support for exceptions; synchronization classes; extended lightweight containers and of course there is CString!

VSLive!

11 – 15 February 2002, San Francisco, USA

See www.vcdc.com

  • Advanced C#: Reflection and Custom Attributes
    Metadata is a vital part of .NET because it provides .NET with the information it needs to determine versioning, type safety and security. We will explain what metadata is and how it is extended with attributes. We'll look at the various types of attributes and explain how they relate to the runtime. We'll show you how attribute information is stored in assemblies and describe how that data is read at runtime through the Reflection API. Finally, we'll discuss several examples of using attributes in your own code, as a notation device and as a mechanism to change how other classes use your types.

XML In Action

January 2002, Potsdam, Germany

See www.microsoft.com/germany

  • Web Services with ATL Server
    This session describes the various parts of the ATL Server library and illustrates how the library can be used to write a web service. The talk starts with an overview of the architecture and the services that ATL Server provides. An example is developed using the ATL Server wizards through which the audience is shown how to generate WSDL, how to implenment webmethods and finally how to consume WSDL and use a web service.

.NET In Depth

January 2002, Potsdam, Germany

See www.microsoft.com/germany

  • Configuring .NET Applications
    In this session I explain how .NET applications are configured using XML files: When an application is started the system looks for an associated XML file and uses values in this file to configure the application.
  • Socket Programming with the .NET Framework Class Library
    This session explains the classes in the .NET Framework class library provided for socket programming

WinSummit

8 – 12 October 2001, Davros Switzerland

See http://www.winsummit.com

  • Working with ATL Server
    ATL Server is a new way to develop web applications and services. As a C++ template library it gives you a combination of power and flexibility to have complete control over your application and because ATL Server compiles to native machine code it means that you do not have a reliance on the .NET framework. This tutorial covers three main topics: C++ attributes, ATL Server and the ATL Server Utility Library. The Visual C++ compiler supports attributes which replaces the ATL3 maps, attributes are used for COM development, performance counters and web development. ATL Server provides classes to allow you to write ISAPI extensions, the library has classes for session management, authentication, cookies and forms. To facilitate web development, the ATL Server also provides a utility library with classes for crypto, security, file access, HTML and URL generation and regular expressions. The utility library also has extensive facilities for debugging and memory management and there are new tools in Visual Studio specifically for ATL Server debugging. At the end of this talk you will have a complete overview of the ATL Server library and an understanding of how it works - if your goal is to create flexible, high performance web services and applications then ATL Server is the library for you!

     
  • .NET streams
    In this talk I will show the new streams API and show how to use this to access files and sockets, both synchronously and asynchronously. I will explain character encoding and this will lead on to an explanation of the stream reader and writer classes. I will then explain object serialization and formatters and show how to control the data that is serialized through attributes and ISerializable.

WinDev, Boston

11 – 15 June 2001, Boston USA

See http://www.butrain.com/windev/

  • Interop and Managed C++
    The covers how to use unmanaged C++ in managed C++, and how to use managed code in unmanaged C++. I cover using unmanaged data in managed classes, calling DLL exported functions, through the DLLImport attribute and through P/Invoke. In the second half of the talk I cover accessing managed code from unmanaged code, and look at the gcroot<> templated wrapper classes around the GCHandle managed class.
  • VC Attributes
    The main focus of this talk is on the COM attributes of the unmanaged VC++ compiler. I explain how the code generated by these attributes compares with the equivalent code in ATL 3. I also show examples of using the ATL Server and performance monitor attributes as well as event generation.
  • Advanced ATL Server pt 1
    In these two talks I cover all the major issues of ATL Server. I cover the general architecture of the library, the new ATL threading classes covering the thread traits, the worker thread and thread pooling classes, details of using SRF stencils in ATL Server (the stencil handling process, how DLL handlers are identified and loaded), details of calling commands through stencil tags, default and alternative handlers, and explain how to pass parameters (both the standard data types and how to write a parse function for non-standard types).
  • Advanced ATL Server pt 2
    This talk follows on from the previous ATL Server talk. In it I cover session management, caching, authentication, developing web services with ATL Server (show the data types that you can use and how pointers, arrays and structs are accommodated and code that uses web services) debugging ATL Server and the new memory management features to get memory allocation statistics and report damaged memory blocks and leaks.

VBUG: Transition to .NET

2nd - 5th April 2001, Dudley, UK

See www.vbug.co.uk

  • C# Post Conference Seminar
    This one day seminar is an introductory talk about C# covering all the language issues as well as topics like attributes, streams and WinForms

XMLOne 2001

19 March – 22 March 2001, London, UK

See www.xmlconference.com

  • Managed C++
    Describes the extensions to C++ to allow you to write managed code
  • ATL Server
    Explains the architecture and facilities of ATL Server that allows you to write high performance ISAPI based web applications

DevWeek 2001, Europe

26 February – 2 March 2001, London, UK

See www.devweek.com

  • New Features of ATL7
    This describes the new classes in ATL7 and includes the new VC++ attributes
  • Application Development with C#
    Explains how to write client side applications in C# with WinForms
  • C# Attributes
    Explains what .NET attributes are and how to write them in C#
  • Managed C++
    Describes the extensions to C++ to allow you to write managed code
  • ATL Server
    Explains the architecture and facilities of ATL Server that allows you to write high performance ISAPI based web applications

VSLive!

13 January – 18 January 2001, San Francisco, USA

See www.vcdc.com

  • ATL7 For NonCOMs
    Describes the new features of ATL7 not associated with COM
  • COMplementing ATL7
    Describes the new COM features of ATL7
  • Which Attribute Should I Use?
    Compares and contrasts VC attributes, COM+ attributes and .NET attributes

VSLive!

19 September – 23 September 2000, Orlando, USA

See www.vcdc.com

  • ATL Enumerators
    Describes how to use the classes in ATL to write COM enumerators
  • ATL Debugging
    Describes the debugging facilities in ATL7
  • COM+ Interception and Type Information
    Describes type information and fast format strings and how these are vital to COM+ interception
  • Error Reporting In COM
    Describes error objects

Application Development 2000

19 June – 23 June 2000, London

See www.applicationdevelopment.com

  • Component and Framework: The Road to Enterprise Computing
    member of panel discussion chaired by Ken North

Visual C++ Developers Conference

16 April – 20 April 2000, Santa Clara, USA

See www.vcdc.com

  • Create Great Apps with ATL
    Day long pre conference workshop on ATL
  • ATL Enumerators
    Describes how to use the classes in ATL to write COM enumerators
  • COM+ Interception and Type Information
    Describes type information and fast format strings and how these are vital to COM+ interception
  • Guide to Threading and COM
    Describes in depth the how threading and apartments are handled in COM
  • Error Reporting In COM
    Describes error objects
  • COM2TheMax!
    Day long post conference workshop on COM and COM+

BASTA! 2000

13 March – 14 March, Frankfurt, Germany

See www.basta2000.de

  • VB and COM
    Explains how to create COM objects with VB
  • VB and COM+
    explains how to write COM+ objects with VB

DevWeek 2000, Europe

13 February – 18 February 2000, London

See www.devweek.com

  • COM+ Type Information and Interception
    Describes type information and fast format strings and how these are vital to COM+ interception
  • The COM+ Catalog and Configuration
    Explains the COM+ catalog and the tools you can use to manipulate it
  • DTC and Distributed Transactions
    Describes how the DTC works and investigates distributed transactions via TIP
  • COM+ Security
    Describes the details of COM+ security

Visual C++ Developers Conference

8 February – 11 February 2000, Bonn, Germany

See www.vcdc.com

  • Indepth ATL
    Workshop on ATL
  • Error reporting in COM
    Describes error objects
  • Guide to Threading and COM
    Describes in depth the how threading and apartments are handled in COM
  • ATL Enumerators
    Describes how to use the classes in ATL to write COM enumerators

Developer.au

5 October – 8 October 1999, Sydney, Australia

See www.developer.au

  • The Component Object Model
    Day long workshop on COM
  • Access Control and Authentication in COM and COM+
    Describing the security features of COM+

ATL Developer's Conference

See www.sellsbrothers.com

  • Developing shell extensions with ATL 3.0
    Describes how to write shell extensions using classes written in ATL3
 

(c) 2006 Richard Grimes