Hi Don,

My apologies for the delayed response. I've been swamped with a large
number of support cases the last couple weeks. I was also tripped up by
several different problems in trying to solve this, but I was finally able
to get this working this evening.

The debugger implements an interface called IVsPersistSolutionOpts that we
can query for, off the IVsDebugger service. We then need to redefine a
couple of interfaces because the Microsoft.VisualStudio.OLE.Interop
assembly has a pretty heinous bug in it's definition of IStream.Write,
which prevents us from implementing an object that derives from this
interface. At least in this particular instance.

The last parameter to IStream::Write (in the native COM world) is a ULONG*
pbWritten. The interop assembly declares this as an "out ulong". The
problem is, it's perfectly legal to pass a NULL for this parameter (which
unfortunately is exactly what the debugger does when we pass said IStream
to it's IVsPersistSolutionOpts::WriteUserOptions.

We can't compile the code unless we make an assignment to the out
parameter. But because it's NULL, any attempt to assign a value to it, will
cause an exception to be thrown. Consequently, you'll have to redeclare
both the IStream and IVsPersistSolutionOpts interfaces, as follows:

   [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
   [Guid("0000000c-0000-0000-C000-000000000046")]
   internal interface IStream
   {
       // ISequentialStream portion
       void Read([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1),
Out] Byte[] pv, int cb, ulong[] pcbRead);
       void Write([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)]
Byte[] pv, int cb, ulong[] pcbWritten);

       // IStream portion
       void Seek(Int64 dlibMove, int dwOrigin, IntPtr plibNewPosition);
       void SetSize(Int64 libNewSize);
       void CopyTo(IStream pstm, Int64 cb, IntPtr pcbRead, IntPtr
pcbWritten);
       void Commit(int grfCommitFlags);
       void Revert();
       void LockRegion(Int64 libOffset, Int64 cb, int dwLockType);
       void UnlockRegion(Int64 libOffset, Int64 cb, int dwLockType);
       void Stat(out Microsoft.VisualStudio.OLE.Interop.STATSTG pstatstg,
int grfStatFlag);
       void Clone(out IStream ppstm);
   }

   // Customized IVsPersistSolutionOpts, so that we can pass our
customized IStream to the debugger's
   // IVsPersistSolutionOpts::WriteUserOptions. The IVsPersistSolutionOpts
   [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
   [Guid("53BA0F89-24DD-46E1-A7D6-ED24C039FBC4")]
   internal interface IVsPersistSolutionOpts
   {
       void SaveUserOptions([In, MarshalAs(UnmanagedType.Interface)]
IVsSolutionPersistence pPersistence);
       void LoadUserOptions([In, MarshalAs(UnmanagedType.Interface)]
IVsSolutionPersistence pPersistence, [In,
ComAliasName("Microsoft.VisualStudio.Shell.Interop.VSLOADUSEROPTS")] uint
grfLoadOpts);
       void WriteUserOptions([In, MarshalAs(UnmanagedType.Interface)]
IStream pOptionsStream, [In,
ComAliasName("Microsoft.VisualStudio.OLE.Interop.LPCOLESTR"),
MarshalAs(UnmanagedType.LPWStr)] string pszKey);
       void ReadUserOptions([In, MarshalAs(UnmanagedType.Interface)]
IStream pOptionsStream, [In,
ComAliasName("Microsoft.VisualStudio.OLE.Interop.LPCOLESTR"),
MarshalAs(UnmanagedType.LPWStr)] string pszKey);
   }

Note that I've changed last param to both Read and Write to a ulong[],
which allows us to check a NULL and readily make the assignment. I could
have used an IntPtr, but they we'd have to muck with the Marshal class to
return the pcbWritten and pcbRead values. Also, the IVsPersistSolutionOpts
methods will now use our custom IStream, instead of the one defined in the
interop assembly.

Next, we have to implement an object that supports our new IStream
interface, and can store the information when IStream.Write is invoked. I
created an object that derived from both the .Net MemoryStream object and
our new IStream. The IStream.Write simply calls the MemoryStream.Write
which stores the bits in a memory buffer. The ParseBuffer method then pulls
both the source directory strings, and the file to ignore strings out of
the buffer, and drops them into the member string arrays
(sourceDirectories, and ignoredFiles).

   // A dangerouly minimal IStream implementation that only supports
IStream.Write, in order
   // to get the "DebuggerFindSource" stream in the .SUO.
   internal class OptStream : MemoryStream, Microsoft.ReadSUO.IStream
   {
       public string[] sourceDirectories;
       public string[] ignoredFiles;

       // Parses the "DebuggerFindSourceStream and pulls out the
Solution's Source File Directories,
       // and Ignored source files, from the .SUO.
       public void ParseBuffer()
       {
           base.Seek(0, SeekOrigin.Begin);

           BinaryReader reader = new BinaryReader((Stream)this);
           System.Text.Encoding encoding = new
System.Text.UnicodeEncoding();
           
           // first two dwords are version numbers
           ulong verDirCache = reader.ReadUInt32();
           ulong verStringList = reader.ReadUInt32();
           
           // read Source Directories
           ulong numStrings = reader.ReadUInt32();
           
           if (numStrings > 0)
           {
               sourceDirectories = new string[numStrings];
               for (uint i = 0; i < numStrings; i++)
               {
                   // persisted as unicode strings
                   int numBytes = reader.ReadInt32();
                   char[] chars =
encoding.GetChars(reader.ReadBytes(numBytes));
                   sourceDirectories[i] = new string(chars).TrimEnd('\0');
               }
           }

           // read Ignored Files
           verStringList = reader.ReadUInt32();
           numStrings = reader.ReadUInt32();

           if (numStrings > 0)
           {
               ignoredFiles = new string[numStrings];
               for (uint j = 0; j < numStrings; j++)
               {
                   // persisted as unicode strings
                   int numBytes = reader.ReadInt32();
                   char[] chars =
encoding.GetChars(reader.ReadBytes(numBytes));
                   ignoredFiles[j] = new string(chars).TrimEnd('\0');
               }
           }
       }

       #region IStream Members

       public void Read(byte[] pv, int cb, ulong[] pcbRead)
       {
           throw new System.NotImplementedException("IStream::Read is not
implemented.");
       }

       public void Write(byte[] pv, int cb, ulong[] pcbWritten)
       {
           base.Write(pv, 0, cb);
           if (pcbWritten != null)
               pcbWritten[0] = (ulong)cb;
       }

       public void Seek(long dlibMove, int dwOrigin, IntPtr
plibNewPosition)
       {
           throw new System.NotImplementedException("IStream::Seek is not
implemented.");
       }

       public void SetSize(long libNewSize)
       {
           throw new System.NotImplementedException("IStream::SetSize is
not implemented.");
       }

       public void CopyTo(IStream pstm, long cb, IntPtr pcbRead, IntPtr
pcbWritten)
       {
           throw new System.NotImplementedException("IStream::CopyTo is
not implemented.");
       }

       public void Commit(int grfCommitFlags)
       {
           throw new System.NotImplementedException("IStream::Commit is
not implemented.");
       }

       public void Revert()
       {
           throw new System.NotImplementedException("IStream::Revert is
not implemented.");
       }

       public void LockRegion(long libOffset, long cb, int dwLockType)
       {
           throw new System.NotImplementedException("IStream::LockRegion
is not implemented.");
       }

       public void UnlockRegion(long libOffset, long cb, int dwLockType)
       {
           throw new System.NotImplementedException("IStream::UnlockRegion
is not implemented.");
       }

       public void Stat(out Microsoft.VisualStudio.OLE.Interop.STATSTG
pstatstg, int grfStatFlag)
       {
           throw new System.NotImplementedException("IStream::Stat is not
implemented.");
       }

       public void Clone(out IStream ppstm)
       {
           throw new System.NotImplementedException("IStream::Clone is not
implemented.");
       }

Finally, we just need to force the debugger to save it's settings to our
IStream. For example:

       private void OnReadSUO(object sender, EventArgs e)
       {
           // retrieve IVsPersistSolutionOpts interface from debugger
object
           IVsPersistSolutionOpts dbgPersistSlnOpts =
(IVsPersistSolutionOpts)GetService(typeof(IVsDebugger));

           // create a memory based IStream (using System.IO.MemoryStream)
           OptStream optStream = new OptStream();
           dbgPersistSlnOpts.WriteUserOptions((IStream)optStream,
"DebuggerFindSource");
           optStream.ParseBuffer();

           if (optStream.sourceDirectories != null)
           {
               Debug.WriteLine("Source Directories:");
               foreach (string dir in optStream.sourceDirectories)
                   Debug.WriteLine(dir);
           }

           if (optStream.ignoredFiles != null)
           {
               Debug.WriteLine("Ignored Source Files");
               foreach (string file in optStream.ignoredFiles)
                   Debug.WriteLine(file);
           }
       }
   }

The above code snippets are from my prototype package, and should probably
be sufficient for you to implement a workable solution. However, if you'd
like a copy of the prototype package I worked up, just fire me off an email
(removing the ".online" from my email address), and I'd be more than happy
to provide the entire project.

Sincerely,
Ed Dore [MSFT]

This post is 'AS IS' with no warranties and confers no rights.