Delegate
The delegate is declared in the SharedCode project (it doesn’t really matter where it is declared, as long as it is within the scope of any class that uses it):

 Public Delegate Sub MessageEventHandler(ByVal Sender As Object, ByVal e As ChatEventArgs) 

Remotable class and event source
The delegate is used by the Chatter class which is also in the SharedCode project. It appears in the event declaration of the Chatter class:

 Public Event MessageEvent As MessageEventHandler 

Client class and event handler
The Chatter class is declared in the  Client class as a private class member, FChatter. It is instantiated by the constructor, which also adds an event handler. The event handler handles the Chatter.MessageEvent which is of the type MessageEventHandler. The actual address of OnMessageEvent will be an address within the application domain of whatever application instantiates an object of type Client. Here’s where things can get a bit confusing. The Client class doesn’t get directly instantiated, instead this class has a shared (static) field that is given a reference to an object of it’s own type (it’s own class) when the Instance method is called for the first time.

The most important points here,  are that the Client constructor will only be called once (this is the Singleton pattern) and will use the AddHandler statement to add the address of the OnMessageEvent handler to the Client object. The address will be in the application domain of the application that calls the constructor.

Private Sub New()
RemotingConfiguration.Configure("client.exe.config", False)
FChatter = New Chatter
AddHandler FChatter.MessageEvent, AddressOf OnMessageEvent
End Sub

When it is called, the delegate is given the address of the OnMessageEvent handler in the application domain of whichever client called the Send, or ShowHistory method. This is important! The ClientApp is able to receive events from the remote Chatter object because the delegate for the event holds a reference to an event handler in the ClientApp‘s own memory space.

 Public Sub OnMessageEvent(ByVal Sender As Object, ByVal e As ChatEventArgs)

If (Not IsSelf(e.Sender)) Then
Broadcaster.Broadcast(Environment.NewLine)
Broadcaster.Broadcast("{0} said: {1}", e.Sender, e.Message)
Broadcaster.Broadcast("chat>")
End If
End Sub

 It is also important to remember how the MarshalByRefObject class works. The Chatter class inherits from MarshalByRefObject, which allows the methods of a Chatter object to appear in a remote application domain. In other words, a remote application can instantiate a Chatter object (which is really running in the server’s application domain) and call methods on that object. But, when the Chatter raises an event, it will call the event handler on the client. This call goes in the opposite direction, so the client also needs to inherit from MarshalByRefObject so that it’s event handler can be marshaled back to the Chatter object.

Additional Reading

From dotNetJunkies
Scott Stewart, 2003, Working With Events Over Remoting
(This article is quite helpful if you can get past the non-standard grammar.)

From Useless Inc.
Tomer Gabel, 2005, Events and .NET Remoting

Using  delegates

To use delegates you need three things:

1. A delegate declaration: A declaration of the signature of the handler procedure.
   (A class is actually defined behind the scenes in VB.)
2. A delegate object: An instance of the delegate type defined above which holds a pointer to the actual handler procedure.
3. A handler: The function that is called indirectly by the delegate.

When a call is made to the delegate, the call is forewarned to the handler.

There are three places that you need to add code to your project:

1. Outside the other class declarations:
   • Declare the delegate using the Delegate keyword. This is really a class declaration of your delegate type. This declaration defines the signature for event handing procedures of this type:
     Delegate Sub BirdsBitsEventHandler(ByVal sMessage As String)
2. In the class that will send a callback:
   • Declare (Dim) a variable of your delegate type:
     Dim BBMsgDelegate As BirdsBitsMessageHandler
   • Create a New instance of your delegate type:
     BBMsgDelegate = New BirdsBitsMessageHandler _
(AddressOf Form2.IncomingBirdsBitsMessage)
   • Indirectly call the event handler by calling Invoke on the delegate:
     BBMsgDelegate.Invoke("This is a test!")
3. In the module that will receive the callback:
   • Define the actual handler procedure:
     Public Sub IncomingBirdsBitsMessage(ByVal sMessage As String)
    TextBox1.Text = sMessage
End Sub

Exposing  and Handling Events

To use events, there are still three things you need:

1. A declaration of a delegate.
   (VB can generate a hidden delegate declaration when the event is declared.)
2. A declaration of the event.
3. An event handler.

A class that exposes an event defines a private (hidden) delegate field that holds pointers to all the clients that subscribe to the event. There are a number of ways to add events and event handlers to a classes.

There are two or three places (depending on your approach) that you need to add code to your project:

1.  Outside the other class declarations:
   (This step is only required for the first option in step 2.)
   • Declare the delegate using the Delegate keyword.
     Delegate Sub AFoundEventHandler(ByVal sMessage As String)
2. In the class that will send events:
   • Declare and raise an event of the delegate type.
     • Use the Event keyword to declare an event:
       Public Event AFound As AFoundEventHandler
     • Use the RaiseEvent keyword to send an event.
       Dim e As New EventArgs
RaiseEvent AFound(Me, e)

   • Or, declare and use an event type defined by the .NET Framework.
     This is the preferred approach!  (You can skip step 1, since the delegate for this event is defined in the .NET Framework.)
     • Use the Event keyword to declare an event of the type System.EventHandler. Public Event AFound As EventHandler
     • Use the RaiseEvent keyword to send an event.
Dim e As New EventArgs
RaiseEvent AFound(Me, e)

   • Or, Declare an event and a delegate in one statement: (If you use this option, you don’t need step 1 above since the delegate is declared along with the event) 
     • Use the Event keyword to declare an event. VB generates a hidden delegate with the signature of the event:
       Public Event AFound(ByVal sender As Object, ByVal e As EventArgs)
     • Use the RaiseEvent keyword to send an event.
       Dim e As New EventArgs
RaiseEvent AFound(Me, e)

3.  In the module that instantiates the event class:
   • Create an object for use with events. 
     • Use theWithEvents keyword to create an instance of the class:
       Dim WithEvents LetGet as new LetterGetter()
     • Use the Handles keyword to define an event handler:
Private Sub LetterGetter_AFound(ByVal sender As Object, ByVal e As EventArgs) Handles LetGet.AFound
  ' Do something
End Sub

   • Or, add an event handler to an existing object:
     • Declare an instance of the event class:
       Dim LetGet as new LetterGetter()
     • Define a subroutine to handle the event:
       Private Sub AFoundHandler(ByVal sender As Object, ByVal e As EventArgs)
  ' Do something
End Sub
     • Add a subroutine to handle the event using the Add Handler keyword:
       AddHandler LetGet.AFound, AddressOf AFoundHandler
     • Remove the handler (when no longer needed) using the Remove Handler keyword :
       RemoveHandler Obj.Ev_Event, AddressOf EventHandler

Introduction

I’m working on an application that can use two alternative user interfaces: a GUI, and a remote text terminal. Most of the time the application will be installed on a single computer and users will interact with the application through the Windows Forms GUI on that machine, and remote users will interact by sending text commands via TCP/IP. But there are also situations where users may wish to install the GUI on one machine and the application on another. In the old days, I would have solved this problem with DCOM. But, this is a .NET application, so I set out to learn the .NET way to solve this problem. (I made a decision at the beginning of the project to use .NET 2.0 rather than 3.0 or 3.5, since it is time tested and well documented.)

There are three general solutions available  in the .NET 2.0 Framework: ASP.NET (aka .NET web services, XML Web services), Enterprise Services (built on COM+), and .NET remoting. (With the introduction of Windows Communication Foundation in .NET 3.0 there are even more options.) You can read a good comparison of these methods in this MSDN Library article: .NET Framework Developer’s Guide: Choosing Communications Options in .NET. I chose .NET remoting because: 1) It doesn’t require IIS (or any other server). Our customer wouldn’t like the extra administrative overhead of having to set up and run an Internet server with this application. 2) Performance: .NET remoting over TCP or IPC gives better performance than .NET web services. 3) Preserves all the features of the managed code framework: the type system, pass by reference, etc.

There are three basic entities involved in .NET remoting: 1) The host- which just launches the remotable type. This will typically be housed in an .exe file. 2) The remotable type (class) – which runs in the application domain of the host, but presents it’s properties, methods, and events for consumption by a client in another application domain or on another machine. This is typically housed in a DLL. 3) The client- a class (usually housed in another .exe file) which instantiates an instance of the remotable type. The remotable type will appear as if it were running in this class’ application domain. You can read more about his in the MSDN article:  .NET Framework Developer’s Guide: .NET Remoting.

It is fairly simple to create each of these three entities:

1. To create a remotable type, you only need to define a class that inherits the MarshalByRefObject base class. Here’s an example from the MSDN .NET Framework Developer’s Guide: How to: Build a Remotable Type.
2. To create a host you need to do two things:
   - Create and register a server channel object, which will handle the networking protocols and serialization formats that transport requests to the remotable object.
   - Register the remotable type with the .NET remoting system so that it can use your channel to listen for requests for this type.
   Here’s an example from the MSDN .NET Framework Developer’s Guide: How to: Build a Hosting Application.
3. To create a client you need to do three things:
   - Create a register a client channel.
   - Activate the remotable object. Depending on the activation mode you may be getting a reference to an object that was already created and published by the host, or you may be creating the object remotely.
   Here’s an example from the MSDN .NET Framework Developer’s Guide: How to: Build a Client Application.

Building and running the “SimplestRemoting” sample code
Here are the steps I took to build and run the “SimplestRemotingVB” code sample from Platt’s book:

1) Imported  the SimplestRemotingHostVB  project into VS2005 using the conversion wizard which starts automatically when you open a project created in a previous version of Visual Studio.

a) Changed the following declaration to use Dim instead of Public:

Dim Chnl As Runtime.Remoting.Channels.Tcp.TcpServerChannel
(Note that I am showing the line as it is after I fixed it, not as it was originally)

b) Added the argument true to the following line:

Runtime.Remoting.Channels.ChannelServices.RegisterChannel(Chnl, True)

c) Deleted the “AssemblyInfo.vb” file, since it isn’t needed.

2) Imported the SimplestRemotingObjectVB project into VS2005.

3) Imported the SimplestRemotingClientVB project in to VS2005.

a) Added the argument true to the following line:

Runtime.Remoting.Channels.ChannelServices.RegisterChannel(Chnl, True)

 4) Delete all the existing files in bin/release/ and bin/debug/. (I did this after I had trouble with the VB2005 “rebuild” command. Sometimes it didn’t recreate all the executables.)

5) Build each project.

6) Run the host, SimplestRemotingHostVB.exe, and click the “Register” button. You may have antivirus or other security software that will try to block the remoting host from opening a TCP port. If this happens you may get a pop-up message that gives you the option to allow this program to open a port. (Norton does this.)

7) Run the client, SimplestRemotingClientVB.exe, and click the “Register” button, and then the “Get time” button. You should see your computer’s time displayed.

Discussion

I would have called this section FAQs, but these are just my questions, but often my questions are also other people’s questions too, so I’ll pass them on with the answers I found.

• Q: Do I need to run a web server like IIS, or apache in order to use a TCP channel with .NET remoting? 
  A: No.
• Q: How do I know I’m really creating a remote object (i.e., an object that really is in the host’s application domain and not in the client’s?)
  A1: Try running the client without first running the host and registering the remoting object. The client will throw an unhandled exception when you click on the “Get time” button. This doesn’t completely answer the question, but at least you know that the host is providing something that’s needed by the client.
  A2: Run the client in the VS2005 debugger. You will not see trace messages from the object in the immediate window. You will see trace messages when you run the host in the VS2005 debugger. Presumably the trace listener will not receive trace messages across a process boundary (or application domain?) so you only get trace messages in the host’s process since that is where the object is actually running.
• Q: Is the DLL which houses the remoting object loaded by both the host and the server?
  A: Yes, if you look at the host and server processes in a process viewer like ProcessExplorer, you see that SimpleRemotingObjectVB.dll is loaded into both processes. Apparently this is because it is running in the host process and it is loaded in the client process because the client reads meta-data from it.

Building and Running the ConfigFile Sample Code

There is another example program in chapter 10 of Platt’s book, in the section titled “Big Simplification: Configuration Files”. I imported and built these files, but I wasn’t able to get the client to work using the configuration files. I’ve added this VB2005 project to my Box.net folder, just in case one of you can help me figure out why it doesn’t work. Here are the symptoms:

• Everything builds without errors or warnings.
• The host runs and throws no exceptions when I click either of the buttons (the top button registers the remotable object programmatically, the bottom button registers it using the app.config file.)
• The client runs and throws no exceptions when I click the top button to register the remotable object using the app.config file. When I click the “Get time” button the application freezes.
• I commented out the client code that does configures the client using the app.config file and replaced it with code that programmatically configures the client. Everything works with this code. My conclusion is that the host code that uses app.config is working, but there is something wrong with either the client app.config file or the code that registers it.

Any suggestions as to why this isn’t working?

Further Reading
Here are some additional articles that you may find helpful:

From MSDN
2007, The MSDN Library, .NET Framework Developer’s Guide: .NET Framework Remoting Overview
Matt Travis, 2005, What’s new in .NET Remoting for the .NET Framework 2.0 (Video)
Web Services and Other Distributed Technologies, Reference: .NET Remoting (Links to MSDN resources on remoting)

From the CodeProject
(These three articles have code examples in C#)
Nishant Sivakumar, 2002, Absolute Beginners Introduction to Remoting
Lim Bio Liong, 2004, Simple but Potentially Useful .NET Remoting, Part 2
2007, Remoting Architecture in .NET

From Developer.com
Paul Kimmell, 2004, .NET Remoting and Event Handling in VB.NET, Part 2, Part 3
(This article is very helpful and informative. I was able to build and run the example in VS2005 on Vista.)

From The SecretGeek
2003, .NET Remoting: The Quick and Dirty Guide

From VB.NET Heaven:
2004, .NET Remoting Using VB.NET

 From “Welcome to the Metaverse”
Rich Turner, 2004, On the Road to Indigo: Is .NET Remoting Dead? (The answer: no! But… )

As I complete each lesson, I’ll add a link to my notes on this page: Exam 70-536: Application Development Foundation – Study Topics. Note that my lesson notes will be on pages, not posts. I’ll only post to let you know when I start  a new chapter.

I hope some of you will join me and add comments to the lesson pages. Whether you are studying for the MCTS or MCPD, it will be easier and more fun if we take the journey to certification together!

Events are signals that a sending object sends to a receiving object, or receiving objects to notify it (or them) of some action that occurred out in the real world (like a button click), or some change of state in the program (like the completion of a computation). A sending object is said to raise an event, and a receiving object is said to handle an event.

When a sending object sends and event, it does it by calling a method on the receiving object. But, a sending object doesn’t doesn’t always know which object or objects might be receiving events. This problem is solved by the use of an intermediary called a delegate. A delegate is a class that can hold a reference to a method on a receiving object. The sending object is then able to invoke a method on the receiving object indirectly via the delegate.  (If you’ve done C programming, you can think of a delegate as being similar to a function pointer, or a callback, but delegates are type-safe) A delegate class only needs a declaration, you don’t need to provide the implementation since the CLR will implement it. The declaration specifies the signature and methods that can be called.

While Delegates are a feature of the .NET Framework and not specific to any particular .NET Language, it is a lot easier to understand how they work by seeing an example. Here is an experiment that I wrote in VB2005: (This isn’t elegant programming, just a quick experiment to see how events and delegates work!) This example demonstrates delegate multicasting which means sending an event to multiple receiving objects. I also added code to allow objects to register their delegates at run-time. This allows you to design a much more flexible software system in which there are optional objects that may or may not be created at run time and thus couldn’t be ”hard wired” at design time to receive messages.

I created a windows forms project and added three forms: Form1, Form2, and Form3. The code from Form1 is shown below this paragraph. (I only showed the code I added, not the code created by the Forms Designer.) Form one just has one button on it. When you push the button, it invokes events for any delegates that have been registered through the method: BirdsBitsEventHandler(…).

—————————————————————————————–

Public Class Form1
    Public Delegate Sub BirdsBitsEventHandler(ByVal sMessage As String)
    Dim MultiBBEventDelegate As BirdsBitsEventHandler

—————————————————————————————–

    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        Form2.Show()
        Form3.Show()
    End Sub

—————————————————————————————–

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        If MultiBBEventDelegate IsNot Nothing Then
            MultiBBEventDelegate.Invoke(“This is a test of the BirdsBits event handler”)
        Else
            MsgBox(“No callbacks registered”)
        End If
    End Sub

—————————————————————————————–

    Public Sub RegiserHandler(ByRef BBEventDelegate As BirdsBitsEventHandler)

        If MultiBBEventDelegate Is Nothing Then
            MultiBBEventDelegate = BBEventDelegate
        Else
            MultiBBEventDelegate = System.Delegate.Combine(MultiBBEventDelegate, BBEventDelegate)
        End If

    End Sub

End Class

—————————————————————————————–

Form2 and Form3 are identical. The code from Form2 is shown below this paragraph. The form has one text box for displaying messages and a button for registering this form’s method: IncomingBirdsBitsMessage(…) with the sending form (Form1). You could actually have any number of receiving forms with this same code.

—————————————————————————————–

Public Class Form2    Public Sub IncomingBirdsBitsMessage(ByVal sMessage As String)
        TextBox1.Text = sMessage
    End Sub

—————————————————————————————–  

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        Dim DelegateForThisSub As New Form1.BirdsBitsEventHandler(AddressOf IncomingBirdsBitsMessage)
        Form1.RegiserHandler(DelegateForThisSub)
    End Sub
End Class  

—————————————————————————————–

Sources

• From the MSDN Library: NET Framework Developer’s Guide: Events and Delegates
• Balena, Francesc0. 2006. Chapter 7: Delegates and Events. Programming Visual Basic 2005: The Language. Microsoft Press : Redmond.

(The explaination of delegates and events in Balena is excellent. This is where I got most of my information.)

This looks like a huge amount of material to cover in a test. I wonder if the test really covers all of this material, or just a sampling of it? Does anyone who has taken the test have some insight into this? (I’m not looking for shortcuts to studying for the exam, I’m just curious!)

1. Developing applications that use system types and collections
   • Types: Manage data in a .NET Framework application by using the .NET Framework 2.0 system types. (Refer System namespace)
     •Value types
     •Nullable type
     •Reference types
     •Attributes
     •Generic types
     •Exception classes
     •Boxing and UnBoxing
     •TypeForwardedToAttribute Class
   •   Collections: Manage a group of associated data in a .NET Framework application by using collections. (Refer System.Collections namespace)
     •ArrayList class
     •Collection interfaces
     •ICollection interface and IList interface
     •IComparer interface and IEqualityComparer interface
     •IDictionary interface and IDictionaryEnumerator interface
     •IEnumerable interface and IEnumerator interface
     •Iterators
     •Hashtable class
     •CollectionBase class and ReadOnlyCollectionBase class
     •DictionaryBase class and DictionaryEntry class
     •Comparer class
     •Queue class
     •SortedList class
     •BitArray class
     •Stack class
   • Generic Collections: Improve type safety and application performance in a .NET Framework application by using generic collections. (Refer System.Collections.Generic namespace)
     •Collection.Generic interfaces
     •Generic IComparable interface (Refer System Namespace)
     •Generic ICollection interface and Generic IList interface
     •Generic IComparer interface and Generic IEqualityComparer interface
     •Generic IDictionary interface
     •Generic IEnumerable interface and Generic IEnumerator interface IHashCodeProvider interface
     •Generic Dictionary
     •Generic Dictionary class and Generic Dictionary.Enumerator structure
     •Generic Dictionary.KeyCollection class and Dictionary.KeyCollection.Enumerator structure
     •Generic Dictionary.ValueCollection class and Dictionary.ValueCollection.Enumerator structure
     •Generic Comparer class and Generic EqualityComparer class
     •Generic KeyValuePair structure
     •Generic List class, Generic List.Enumerator structure, and Generic SortedList class
     •Generic Queue class and Generic Queue.Enumerator structure
     •Generic SortedDictionary class
     •Generic LinkedList
     •Generic LinkedList class
     •Generic LinkedList.Enumerator structure
     •Generic LinkedListNode class
     •Generic Stack class and Generic Stack.Enumerator structure
   • Specialize Collections: Manage data in a .NET Framework application by using specialized collections. (Refer System.Collections.Specialized namespace)
     •Specialized String classes
     •StringCollection class
     • StringDictionary class
     • StringEnumerator class
     • Specialized Dictionary
     • HybridDictionary class
     • IOrderedDictionary interface and OrderedDictionary class
     • ListDictionary class
     • Named collections
     • NameObjectCollectionBase class
     • NameObjectCollectionBase.KeysCollection class
     • NameValueCollection class
     • CollectionsUtil
     • BitVector32 structure and BitVector32.Section structure
   • Interfaces: Implement .NET Framework interfaces to cause components to comply with standard contracts. (Refer System namespace)
     • IComparable interface
     • IDisposable interface
     • IConvertible interface
     • ICloneable interface
     • IEquatable interface
     • IFormattable interface
   • Events and Delegates: Control interactions between .NET Framework application components by using events and delegates. (Refer System namespace)
     • Delegate class
     • EventArgs class
     • EventHandler delegates
2. Implementing service processes, threading, and application domains in a .NET Framework application
   • Service Process: Implement, install, and control a service. (Refer System.ServiceProcess namespace)
     • Inherit from ServiceBase class
     • ServiceController class and ServiceControllerPermission class
     • ServiceInstaller and ServiceProcessInstaller class
     • SessionChangeDescription structure and SessionChangeReason enumeration
   • Threads: Develop multithreaded .NET Framework applications. (Refer System.Threading namespace)
     • Thread class
     • ThreadPool class
     • ThreadStart delegate and ParameterizedThreadStart delegate
     • Timeout class, Timer class, TimerCallback delegate, WaitCallback delegate, WaitHandle class, and WaitOrTimerCallback delegate
     • ThreadState enumeration and ThreadPriority enumeration
     • ReaderWriterLock class
     • AutoResetEvent class and ManualResetEvent class
     • IAsyncResult interface (Refer System namespace)
     • EventWaitHandle class, RegisterWaitHandle class, SendOrPostCallback delegate, and IOCompletionCallback delegate
     • Interlocked class
     • ExecutionContext class, HostExecutionContext class, HostExecutionContext Manager class, and ContextCallback delegate
     • LockCookie structure, Monitor class, Mutex class, and Semaphore class
   • Application domains: Create a unit of isolation for common language runtime in a .NET Framework application by using application domains. (Refer System namespace)
     • Create an application domain.
     • Unload an application domain.
     • Configure an application domain.
     • Retrieve setup information from an application domain.
     • Load assemblies into an application domain.
3. Embedding configuration, diagnostic, management, and installation features into a .NET Framework application
   • Configuration management: Embed configuration management functionality into a .NET Framework application. (Refer System.Configuration namespace)
     • Configuration class and ConfigurationManager class
     • ConfigurationElement class, ConfigurationElementCollection class, and ConfigurationElementProperty class
     • ConfigurationSection class, ConfigurationSectionCollection class, ConfigurationSectionGroup class, and ConfigurationSectionGroupCollection class
     • Implement ISettingsProviderService interface
     • Implement IApplicationSettingsProvider interface
     • ConfigurationValidatorBase class
   • Installation: Create a custom Microsoft Windows Installer for the .NET Framework components by using the System.Configuration.Install namespace, and configure the .NET Framework applications by using configuration files, environment variables, and the .NET Framework Configuration tool (Mscorcfg.msc).
     • Installer class
     • Configure which runtime version a .NET Framework application should use.
     • Configure where the runtime should search for an assembly.
     • Configure the location of an assembly and which version of the assembly to use.
     • Direct the runtime to use the DEVPATH environment variable when you search for assemblies.
     • AssemblyInstaller class
     • ComponentInstaller class
     • Configure a .NET Framework application by using the .NET Framework Configuration tool (Mscorcfg.msc).
     • ManagedInstallerClass class
     • InstallContext class
     • InstallerCollection class
     • InstallEventHandler delegate
     • Configure concurrent garbage collection.
     • Register remote objects by using configuration files.
   • Event logs: Manage an event log by using the System.Diagnostics namespace.
     • Write to an event log.
     • Read from an event log.
     • Create a new event log.
   • Diagnostics: Manage system processes and monitor the performance of a .NET Framework application by using the diagnostics functionality of the .NET Framework 2.0. (Refer System.Diagnostics namespace)
     • Get a list of all running processes.
     • Retrieve information about the current process.
     • Get a list of all modules that are loaded by a process.
     • PerformanceCounter class, PerformanceCounterCategory, and CounterCreationData class
     • Start a process both by using and by not using command-line arguments.
     • StackTrace class
     • StackFrame class
   • Debugging: Debug and trace a .NET Framework application by using the System.Diagnostics namespace.
     • Debug class and Debugger class
     • Trace class, CorrelationManager class, TraceListener class, TraceSource class, TraceSwitch class, XmlWriterTraceListener class, DelimitedListTraceListener class, and EventlogTraceListener class
     • Debugger attributes
     • DebuggerBrowsableAttribute class
     • DebuggerDisplayAttribute class
     • DebuggerHiddenAttribute class
     • DebuggerNonUserCodeAttribute class
     • DebuggerStepperBoundaryAttribute class
     • DebuggerStepThroughAttribute class
     • DebuggerTypeProxyAttribute class
     • DebuggerVisualizerAttribute class
   • Management information and Events: Embed management information and events into a .NET Framework application. (Refer System.Management namespace)
     • Retrieve a collection of Management objects by using the ManagementObjectSearcher class and its derived classes.
     • Enumerate all disk drivers, network adapters, and processes on a computer.
     • Retrieve information about all network connections.
     • Retrieve information about all services that are paused.
     • ManagementQuery class
     • EventQuery class
     • ObjectQuery class
     • Subscribe to management events by using the ManagementEventWatcher class.
4. Implementing serialization and input/output functionality in a .NET Framework application
   • Serialization: Serialize or deserialize an object or an object graph by using runtime serialization techniques. (Refer System.Runtime.Serialization namespace)
     • Serialization interfaces
     • IDeserializationCallback interface
     • IFormatter interface and IFormatterConverter interface
     • ISerializable interface
     • Serilization attributes
     • OnDeserializedAttribute class and OnDeserializingAttribute class
     • OnSerializedAttribute class and OnSerializingAttribute class
     • OptionalFieldAttribute class
     • SerializationEntry structure and SerializationInfo class
     • ObjectManager class
     • Formatter class, FormatterConverter class, and FormatterServices class
     • StreamingContext structure
   • XML serialization: Control the serialization of an object into XML format by using the System.Xml.Serialization namespace.
     • Serialize and deserialize objects into XML format by using the XmlSerializer class.
     • Control serialization by using serialization attributes.
     • Implement XML Serialization interfaces to provide custom formatting for XML serialization.
     • Delegates and event handlers are provided by the System.Xml.Serialization namespace
   • Custom serialization and deserialization: Implement custom serialization formatting by using the Serialization Formatter classes.
     • SoapFormatter class (Refer System.Runtime.Serialization.Formatters.Soap namespace)
     • BinaryFormatter class (Refer System.Runtime.Serialization.Formatters.Binary namespace)
   • File system: Access files and folders by using the File System classes. (Refer System.IO namespace)
     • File class and FileInfo class
     • Directory class and DirectoryInfo class
     • DriveInfo class and DriveType enumeration
     • FileSystemInfo class and FileSystemWatcher class
     • Path class
     • ErrorEventArgs class and ErrorEventHandler delegate
     • RenamedEventArgs class and RenamedEventHandler delegate
   • Stream classes: Manage byte streams by using Stream classes. (Refer System.IO namespace)
     • FileStream class
     • Stream class
     • MemoryStream class
     • BufferedStream class
   • Reader and Writer Classes: Manage the .NET Framework application data by using Reader and Writer classes. (Refer System.IO namespace)
     • StringReader class and StringWriter class
     • TextReader class and TextWriter class
     • StreamReader class and StreamWriter class
     • BinaryReader class and BinaryWriter class
   • Stream Compression and Decompression: Compress or decompress stream information in a .NET Framework application (refer System.IO.Compression namespace), and improve the security of application data by using isolated storage. (Refer System.IO.IsolatedStorage namespace)
     • IsolatedStorageFile class
     • IsolatedStorageFileStream class
     • DeflateStream class
     • GZipStream class
5. Improving the security of the .NET Framework applications by using the .NET Framework 2.0 security features
   • Code Access Security Policy: Implement code access security to improve the security of a .NET Framework application. (Refer System.Security namespace)
     • SecurityManager class
     • CodeAccessPermission class
     • Modify the Code Access security policy at the computer, user, and enterprise policy level by using the Code Access Security Policy tool (Caspol.exe).
     • PermissionSet class and NamedPermissionSet class
     • Standard Security interfaces
     • IEvidenceFactory interface
     • IPermission interface
   • Access Control: Implement access control by using the System.Security.AccessControl classes.
     • DirectorySecurity class, FileSecurity class, FileSystemSecurity class, and RegistrySecurity class
     • AccessRule class
     • AuthorizationRule class and AuthorizationRuleCollection class
     • CommonAce class, CommonAcl class, CompoundAce class, GenericAce class, and GenericAcl class
     • AuditRule class
     • MutexSecurity class, ObjectSecurity class, and SemaphoreSecurity class
   • Custom Authentication Scheme: Implement a custom authentication scheme by using the System.Security.Authentication classes. (Refer System.Security.Authentication namespace)
   • Cryptography: Encrypt, decrypt, and hash data by using the System.Security.Cryptography classes. (Refer System.Security.Cryptography namespace)
     • DES class and DESCryptoServiceProvider class
     • HashAlgorithm class
     • DSA class and DSACryptoServiceProvider class
     • SHA1 class and SHA1CryptoServiceProvider class
     • TripleDES and TripleDESCryptoServiceProvider class
     • MD5 class and MD5CryptoServiceProvider class
     • RSA class and RSACryptoServiceProvider class
     • RandomNumberGenerator class
     • CryptoStream class
     • CryptoConfig class
     • RC2 class and RC2CryptoServiceProvider class
     • AssymetricAlgorithm class
     • ProtectedData class and ProtectedMemory class
     • RijndaelManaged class and RijndaelManagedTransform class
     • CspParameters class
     • CryptoAPITransform class
     • Hash-based Message Authentication Code (HMAC)
     • HMACMD5 class
     • HMACRIPEMD160 class
     • HMACSHA1 class
     • HMACSHA256 class
     • HMACSHA384 class
     • HMACSHA512 class
   • Resource Permissions: Control permissions for resources by using the System.Security.Permission classes. (Refer System.Security.Permission namespace)
     • SecurityPermission class
     • PrincipalPermission class
     • FileIOPermission class
     • StrongNameIdentityPermission class
     • UIPermission class
     • UrlIdentityPermission class
     • PublisherIdentityPermission class
     • GacIdentityPermission class
     • FileDialogPermission class
     • DataProtectionPermission class
     • EnvironmentPermission class
     • IUnrestrictedPermission interface
     • RegistryPermission class
     • IsolatedStorageFilePermission class
     • KeyContainerPermission class
     • ReflectionPermission class
     • StorePermission class
     • SiteIdentityPermission class
     • ZoneIdentityPermission class
   • Code Privileges: Control code privileges by using System.Security.Policy classes. (Refer System.Security.Policy namespace)
     • ApplicationSecurityInfo class and ApplicationSecurityManager class
     • ApplicationTrust class and ApplicationTrustCollection class
     • Evidence class and PermissionRequestEvidence class
     • CodeGroup class, FileCodeGroup class, FirstMatchCodeGroup class, NetCodeGroup class, and UnionCodeGroup class
     • Condition classes
     • AllMembershipCondition class
     • ApplicationDirectory class and ApplicationDirectoryMembershipCondition class
     • GacInstalled class and GacMembershipCondition class
     • Hash class and HashMembershipCondition class
     • Publisher class and PublisherMembershipCondition class
     • Site class and SiteMembershipCondition class
     • StrongName class and StrongNameMembershipCondition class
     • Url class and UrlMembershipConditon class
     • Zone class and ZoneMembershipCondition class
     • PolicyLevel class and PolicyStatement class
     • IApplicationTrustManager interface, IMembershipCondition interface, and IIdentityPermissionFactory interface
   • Identity Information: Access and modify identity information by using the System.Security.Principal classes. (Refer System.Security.Principal namespace)
     • GenericIdentity class and GenericPrincipal class
     • WindowsIdentity class and WindowsPrincipal class
     • NTAccount class and SecurityIdentifier class
     • IIdentity interface and IPrincipal interface
     • WindowsImpersonationContext class
     • IdentityReference class and IdentityReferenceCollection class
6. Implementing interoperability, reflection, and mailing functionality in a .NET Framework application
   Expose COM components to the .NET Framework and the .NET Framework components to COM. (Refer System.Runtime.InteropServices namespace)
   • Import a type library as an assembly.
   • Add references to type libraries.
   • Type Library Importer (Tlbimp.exe)
   • Generate interop assemblies from type libraries.
   • Imported Library Conversion
   • Imported Module Conversion
   • Imported Type Conversion
   • Imported Member Conversion
   • Imported Parameter Conversion
   • TypeConverter class
   • Create COM types in managed code.
   • Compile an interop project.
   • Deploy an interop application.
   • Qualify the .NET Framework types for interoperation.
   • Apply Interop attributes, such as the ComVisibleAttribute class.
   • Package an assembly for COM.
   • Deploy an application for COM access.
   • Unmanaged DLLs: Call unmanaged DLL functions in a .NET Framework application, and control the marshaling of data in a .NET Framework application. (Refer System.Runtime.InteropServices namespace)
     • Platform Invoke
     • Create a class to hold DLL functions.
     • Create prototypes in managed code.
     • DllImportAttribute class
     • Call a DLL function.
     • Call a DLL function in special cases, such as passing structures and implementing callback functions.
     • Create a new Exception class and map it to an HRESULT.
     • Default marshaling behavior
     • Marshal data with Platform Invoke
     • Marshal data with COM Interop
     • MarshalAsAttribute class and Marshal class
   • Reflection: Implement reflection functionality in a .NET Framework application (refer System.Reflection namespace), and create metadata, Microsoft intermediate language (MSIL), and a PE file by using the System.Reflection.Emit namespace.
     • Assembly class
     • Assembly attributes
     • AssemblyAlgorithmIdAttribute class
     • AssemblyCompanyAttribute class
     • AssemblyConfigurationAttribute class
     • AssemblyCopyrightAttribute class
     • AssemblyCultureAttribute class
     • AssemblyDefaultAliasAttribute class
     • AssemblyDelaySignAttribute class
     • AssemblyDescriptionAttribute class
     • AssemblyFileVersionAttribute class
     • AssemblyFlagsAttribute class
     • AssemblyInformationalVersionAttribute class
     • AssemblyKeyFileAttribute class
     • AssemblyTitleAttribute class
     • AssemblyTrademarkAttribute class
     • AssemblyVersionAttribute class
     • Info classes
     • ConstructorInfo class
     • MethodInfo class
     • MemberInfo class
     • PropertyInfo class
     • FieldInfo class
     • EventInfo class
     • LocalVariableInfo class
     • Binder class and BindingFlags
     • MethodBase class and MethodBody class
     • Builder classes
     • AssemblyBuilder class
     • ConstructorBuilder class
     • EnumBuilder class
     • EventBuilder class
     • FieldBuilder class
     • LocalBuilder class
     • MethodBuilder class
     • ModuleBuilder class
     • ParameterBuilder class
     • PropertyBuilder class
     • TypeBuilder class
   • E-mail: Send electronic mail to a Simple Mail Transfer Protocol (SMTP) server for delivery from a .NET Framework application. (Refer System.Net.Mail namespace)
     • MailMessage class
     • MailAddress class and MailAddressCollection class
     • SmtpClient class, SmtpPermission class, and SmtpPermissionAttribute class
     • Attachment class, AttachmentBase class, and AttachmentCollection class
     • SmtpException class and SmtpFailedReceipientException class
     • SendCompletedEventHandler delegate
     • LinkedResource class and LinkedResourceCollection class
     • AlternateView class and AlternateViewCollection class
7. Implementing globalization, drawing, and text manipulation functionality in a .NET Framework application
   • Regional Formatting: Format data based on culture information. (Refer System.Globalization namespace) • Access culture and region information in a .NET Framework application.
     • CultureInfo class
     • CultureTypes enumeration
     • RegionInfo class
     • Format date and time values based on the culture.
     • DateTimeFormatInfo class
     • Format number values based on the culture.
     • NumberFormatInfo class
     • NumberStyles enumeration
     • Perform culture-sensitive string comparison.
     • CompareInfo class
     • CompareOptions enumeration
     • Build a custom culture class based on existing culture and region classes.
     • CultureAndRegionInfoBuilder class
     • CultureAndRegionModifier enumeration
   • Drawing namespace: Enhance the user interface of a .NET Framework application by using the System.Drawing namespace.
     • Enhance the user interface of a .NET Framework application by using brushes, pens, colors, and fonts.
     • Brush class
     • Brushes class
     • SystemBrushes class
     • TextureBrush class
     • Pen class
     • Pens class
     • SystemPens class
     • SolidBrush class
     • Color structure
     • ColorConverter class
     • ColorTranslator class
     • SystemColors class
     • StringFormat class
     • Font class
     • FontConverter class
     • FontFamily class
     • SystemFonts class
     • Enhance the user interface of a .NET Framework application by using graphics, images, bitmaps, and icons.
     • Graphics class
     • BufferedGraphics class
     • BufferedGraphicsManager class
     • Image class
     • ImageConverter class
     • ImageAnimator class
     • Bitmap class
     • Icon class
     • IconConverter class
     • SystemIcons class
     • Enhance the user interface of a .NET Framework application by using shapes and sizes.
     • Point Structure
     • PointConverter class
     • Rectangle Structure
     • RectangleConverter class
     • Size Structure
     • SizeConverter class
     • Region class
   • Text namespace: Enhance the text handling capabilities of a .NET Framework application (refer System.Text namespace), and search, modify, and control text in a .NET Framework application by using regular expressions. (Refer System.RegularExpressions namespace)
     • StringBuilder class
     • Regex class
     • Match class and MatchCollection class
     • Group class and GroupCollection class
     • Encode text by using Encoding classes
     • Encoding class
     • EncodingInfo class
     • ASCIIEncoding class
     • UnicodeEncoding class
     • UTF8Encoding class
     • Encoding Fallback classes
     • Decode text by using Decoding classes.
     • Decoder class
     • Decoder Fallback classes
     • Capture class and CaptureCollection class

Now, I’ve got a ton of experience  in C, C++, MFC, ATL and COM programming as well as some pretty respectable VB programming experience going all the way back to VB 4.0. I’m currently working on my first VB2005 project for one of my company’s clients, but I’d like to strengthen that experience with certification so that  future clients know I’m prepared to do .NET programming. That’s why I think this a good time for me to get MS certification. So, I bought a used copy of the MCAD/MCSD Self-Paced Training Kit. I got a good deal on it too! Two days ago I started posting about starting the certification process, and started studying for my MCSD.

But this morning, while surfing blogs, looking for posts by people studying for, or who had passed the MCSD exams, I discovered that the MCSD is no longer the preferred certification for developers. Microsoft has a “New Generation of Certifications“. The certification that is most appropriate for the work I am doing is MCPD: Windows Developer. Here are the requirements for getting this certification:

1. Pass the two exams required for a Microsoft Certified Technology Specialist MCTS: .NET Framework 2.0 Windows Applications:
   • Exam 70-536: TS: Microsoft .NET Framework 2.0 – Application Development Foundation

   • Exam 70-526: TS: Microsoft .NET Framework 2.0 – Windows-Based Client Development

2. Pass Exam 70–548: PRO: Designing and Developing Windows Applications by Using the Microsoft .NET Framework.

 So, the next step for me is to get a study guide for exam Exam 70-536. Microsoft has a self-paced training kit: MCTS Self-Paced Training Kit (Exam 70-536): Microsoft .NET Framework 2.0 – Application Development Foundation. I’ll probably take a look at it. Does anyone have any other recommendations?

8/9/07 3:45 PM Update: I bought the book.

8/16/07 Update: I finished the first lesson. If you want to join me, start here: Join me in studying for MCTS exam 70-536.

You use the MISL disassembler to view the assembly. If you haven’t used it before, you’ll be happy to hear that it’s easy to run. Just go to “Visual Studio Tools” on your start menu and select “Visual Studio 2005 Command Prompt”. In the DOS window that opens, type “ILDASM” which will launch the MISL disassembler in it’s own window. The MSDN “How to” article explains the rest. I recommend that you do this exercise, but don’t get sidetracked by trying to decipher everything in the manifest. It’s enough just to get the general idea of what’s in there. 

8/9/07 Update: I won’t be posting about any more lessons in this series. Read: MCSD is Outdated. Become an MCPD Instead to see why.

8/16/07 Update: If you would like to study for the MCTS or MCPD, then start here: Join me in studying for MCTS exam 70-536.

A summary of this lesson (my reading notes.)

1. The .NET framework has two elements:
   • The Common Language Runtime (CLR). The CLR manages code execution. It compiles MSIL (Microsoft Intermediate Language), allocates memory, manages threads, and does garbage collection.
   • The .NET Framework class library. The class library provides reusable types that are Common Language Specification (CLS) compliant and thus can be called from any .NET language.
2. Assemblies are the basic unit of a .NET application. They are a collection of code, resources, and metadata. The assembly has the following parts:
   • Assembly manifest. Each assembly has one manifest which provides:
     • Identity information, such as the assembly’s name and version number.
     • A list of all types exposed by the assembly.
     • A list of other assemblies required by the assembly
     • A list of code assess security instructions, including permissions required by the assembly and permissions to be denied the assembly.
   • Modules. Each assembly contains one or more modules which contain:
     • Code (MSIL). This is all, or part of, the code that makes up the application.
     • Metadata that describes the code
     • Type (class) metadata
3. Compilation and execution of a .NET application:
   • Applications written in a high level .NET language like VB or C# are compiled to MSIL for deployment in one or more assemblies. At least one assembly will have a .NET executable file (stored as MISL code) designated as the entry point of the application.
   • At the beginning of execution the first assembly is loaded into memory, then the CLR:
     1. Determines the requirements for running the program from the assembly’s manifest.
     2. Compares security permissions requested by the assembly with the system’s security policy.
     3. If the security permissions are appropriate, it creates a process for the application to run in.
     4. Runs the Just In Time (JIT) compiler to compile the first block of MSIL into native binary code and stores the code for use until the program exits.
     5. Initiates execution of the native code.
     6. Compiles and stores more blocks of MISL as needed while the application executes.

Additional resources on this topic

From the MSDN Library: Overview of the .NET Framework, How to: View Assembly Contents

Tutorials from Bean Software: .NET Framework Assemblies- Part 1, .NET Framework Assemblies- Part 2

From the CodeProject: A .NET Assembly Viewer

I really don’t like to study alone, so I’m inviting you  to join me. I’ll be posting my  questions, answer, and discoveries as I complete each lesson and lab in this text and I’m hoping you will also post your  observations, questions and answers in comments to the post for each lesson and lab.

8/9/07 Update: I won’t be studying for exam 70-306 after all. Read this post to see why: MCSD is Outdated. Become an MCPD Instead

8/16/07 Update: Join me in studying for the MCTS and MCPD. Start by reading here: Join me in studying for MCTS exam 70-536.

Here’s a list of the lessons and labs from the book’s table of contents:

CHAPTER 1 Introduction to the .NET Framework
Lesson 1: The .NET Framework and the Common Language Runtime
Lesson 2: The .NET Base Class Library
Lesson 3: Using Classes and Structures
Lesson 4: Using Methods
Lesson 5: Scope and Access Levels
Lesson 6: Garbage Collection
Lab 1: Classes and Garbage Collection

CHAPTER 2 Creating the User Interface
Lesson 1: User Interface Design Principles
Lesson 2: Using Forms
Lesson 3: Using Controls and Components
Lesson 4: Using Menus
Lesson 5: Validating User Input
Lab 2: The Virtual Doughnut Factory

CHAPTER 3 Types and Members
Lesson 1: Using Data Types
Lesson 2: Using Constants, Enums, Arrays, and Collections
Lesson 3: Implementing Properties
Lesson 4: Implementing Delegates and Events
Lab 3-1: Adding Components and Implementing Members
Lab 3-2: Creating a Class

CHAPTER 4 Object-Oriented Programming and Polymorphism
Lesson 1: Introduction to Object-Oriented Programming
Lesson 2: Overloading Members
Lesson 3: Interface Polymorphism
Lesson 4: Inheritance Polymorphism
Lab 4: Using Inherited Classes

CHAPTER 5 Testing and Debugging Your Application
Lesson 1: Using the Debugging Tools
Lesson 2: Using the Debug and Trace Classes
Lesson 3: Creating a Unit Test Plan
Lesson 4: Handling and Throwing Exceptions
Lab 5-1: Debugging an Application
Lab 5-2: Creating, Throwing, and Handling Exceptions
Lab 5-3: Implementing Tracing

CHAPTER 6 Data Access Using ADO.NET
Lesson 1: Overview of ADO.NET
Lesson 2: Overview of Structured Query Language
Lesson 3: Accessing Data
Lesson 4: Using DataSet Objects and Updating Data
Lesson 5: Binding, Viewing, and Filtering Data
Lesson 6: Using XML in ADO.NET
Lab 6-1: Connecting with a Database
Lab 6-2: Connecting with an XML Data Store

CHAPTER 7
Lesson 1: Using GDI+
Lesson 2: Authoring Controls
Lesson 3: Common Tasks Using Controls
Lab 7: Creating a Custom Control

CHAPTER 8 Advanced .NET Framework Topics
Lesson 1: Implementing Print Functionality
Lesson 2: Accessing and Invoking Components
Lesson 3: Implementing Accessibility
Lesson 4: Implementing Help in Your Application
Lesson 5: Globalization and Localization
Lab 8: Creating a Localized Form with Print Support

CHAPTER 9 Assemblies, Configuration, and Security
Lesson 1: Assemblies and Resources
Lesson 2: Configuring and Optimizing Your Application
Lesson 3: Securing Your Application
Lab 9: Configuring and Securing an Application

CHAPTER 10 Deploying Your Application
Lesson 1: Planning the Deployment of Your Project
Lesson 2: Configuring Your Setup Project
Lab 10: Creating an Installer Application

Additional Resources

From Microsoft:  

• Microsoft Certified Solution Developer
• Preparation Guide for Exam 70-306

From Bloggers:

• MCSD.Net Certification Trail
• Studying for VS2005 / .NET 2.0 Certifications

Documentation for the Microsoft UVC driver

A description of functions supported by Microsoft’s UVC driver (from a system administrator’s perspective). Can be found here: Availability of the USB video class driver for Windows XP

An updated driver that allows UVC-compliant cameras to render DV data from the host PC back to the device, and capture MPEG2 TS data from the device to the host PC can be downloaded here: Update for USB Video Class (UVC) driver in Windows XP Home and Professional with Service Pack 2

Specifications for USB classes, including UVC, are available on the USB Implementer’s forum at: Approved Class Specification Documents

The main programming documentation for the UVC driver is in the online MSDN library under: “Win32 and COM development – Windows Driver Kit – Device and Driver Technologies – Streaming Media – Design Guide – AVStream Minidrivers – USB Video Class Driver”. URL: Windows Driver Kit: Streaming Media Devices: USB Video Class Driver

(The above documentation is part of the Windows Driver Kit (WDK). This documentation is not included in the Windows SDK docs or in the MSDN Library for VS2005. You can download the documentation for the WDK from this page: Windows Driver Kit (WDK) Documentation)

Programming interfaces for the UVC driver

A Windows application can access the UVC driver via Microsoft DriectShow (Microsoft DirectShow 9.0), or via the kernel stream (also known as AVStream) interface, ks.sys (Windows Driver Kit: Streaming Media Devices: Kernel Streaming). Note that the MS UVC driver is a type of AVStream Minidriver. AVStream Minidrivers (Windows Driver Kit: Streaming Media Devices : AVStream Overview) conform to the Windows Driver Model (WDM) (Windows Driver Kit: Kernel-Mode Driver Architecture: Introduction to WDM), and WDM drivers are kernel mode drivers.

Next Post: Writing an application that uses the Microsoft UVC driver

I would like to write a video capture program for my Logitech web cam with a UVC driver. This camera has a button on the top that allows a user to snap a still picture, so I would like to be able to capture both video as well as still images. In addition, I want to use the bulk transfer USB mode so that my image transfer will be error free. This means I want to use UVC still image transfer method 3.

I was able to use graphedit.exe, one of the tools in the tools in the Windows driver kit, to connect the camera driver’s video pin to a video rendering filter and the still pin to another video rendering filter which allowed me to alternately capture video or still images running the filter graph in graphedit- Cool! But, I couldn’t find any properties on the still pin to tell me which still image capture method was being used.

I used both UVCView.exe and KsStudio.exe provided by the WDK for AVStream Testing and Debugging to see if I could determine what still image capture method, or what USB transfer mode was being used, but to no avail. I couldn’t figure out how to decipher the descriptors reported by UVCView, and I couldn’t find a property related to still image transfer methods in any of the KsStudio filters that are related to USB video capture.

I don’t know whether still image transfer mode is a property of the MS UVC that can be set by an application, or is “hard wired” in the MS UVC implementation, or is hard wired in the device (the camera’s) UVC driver implementation. If anyone can shed some light on these questions I would be quite appreciative!

8/7/07 Update:  I’ve been told that the MS UVC driver will support still image transfer via a bulk pipe, but the firmware in the camera device needs to implement the bulk pipe, it’s not something that is determined by the application using the UVC driver.

This project to write an app that captures video from the UVC driver is on hold. My priorities have shifted elsewhere for now.