On 06/01/2005 5:10 AM, in article
83b31e2a.0501052110.529cb1aa@posting.google.com, "MailInterface"

The MSDN sample doesn't write out the resources except in its XML format, if
you change the code as follows (apologies if it gets mangled by line
breaks):

SampleResourceService.cs

using System;
using System.Resources;
using System.ComponentModel.Design;
using System.IO;
using System.Collections;

namespace SampleDesignerHost
{
   /// Resource service using .resx files
   public class SampleResourceService : IResourceService, IDisposable
   {
       private Hashtable writers;
       private Hashtable readers;
       private IDesignerHost host;
       private MemoryStream ms;
       // Track whether Dispose has been called.
       private Boolean disposed = false;

       public SampleResourceService(IDesignerHost host)
       {
           this.host = host;
           writers = new Hashtable();
           readers = new Hashtable();
       }

       ~SampleResourceService()
       {
           Dispose(false);
       }

       private void SerializationComplete()
       {
           foreach (IResourceWriter writer in writers.Values)
           {
               if (writer != null)
               {
                   writer.Close();
                   writer.Dispose();
               }
           }
           writers.Clear();

           foreach (IResourceReader reader in readers.Values)
           {
               if (reader != null)
               {
                   reader.Close();
                   reader.Dispose();
               }
           }
           readers.Clear();
       }

       public byte[] Resources
       {
           get
           {
               SerializationComplete();
               return ms.GetBuffer();
           }
       }

       #region Implementation of IResourceService

       public System.Resources.IResourceReader
GetResourceReader(System.Globalization.CultureInfo info)
       {          
           ResXResourceReader reader = (ResXResourceReader) readers[info];
           if (reader == null)
           {
               if (ms == null)
               {
                   ms = new MemoryStream();
               }
               reader = new ResXResourceReader(ms);
               readers.Add(info, reader);
           }
           return reader;
       }

       public System.Resources.IResourceWriter
GetResourceWriter(System.Globalization.CultureInfo info)
       {
           ResXResourceWriter writer = (ResXResourceWriter) writers[info];
           if (writer == null)
           {
               if (ms == null)
               {
                   ms = new MemoryStream();
               }
               writer = new ResXResourceWriter(ms);
               writers.Add(info, writer);
           }
           return writer;
       }

       #endregion

       #region IDisposable Members

       public void Dispose()
       {
           Dispose(true);
           GC.SuppressFinalize(this);
       }

       private void Dispose(Boolean disposing)
       {
           // Check to see if Dispose has already been called.
           if(!disposed)
           {
               SerializationComplete();
           }
           disposed = true;
       }

       #endregion
   }
}

SampleDesignerLoader.cs - Save method

       /// Save the current state of the loader. If the user loaded the
file
       /// or saved once before, then he doesn't need to select a file
again.
       /// Unless this is being called as a result of "Save As..." being
clicked,
       /// in which case forceFilePrompt will be true.
       internal void Save(bool forceFilePrompt)
       {
           try
           {
               if (dirty)
               {
                   // Flush any changes to the buffer.
                   Flush();
               }

               // If the buffer has no name or this is a "Save As...",
               // prompt the user for a file name. The user can save
               // either the C#, VB, or XML (though only the XML can be
loaded).
               //
               int filterIndex = 3;
               if ((fileName == null) || forceFilePrompt)
               {
                   SaveFileDialog dlg = new SaveFileDialog();
                   dlg.DefaultExt = "xml";
                   dlg.Filter = "C# Files|*.cs|Visual Basic Files|*.vb|XML
Files|*.xml";

                   if (dlg.ShowDialog() == DialogResult.OK)
                   {
                       fileName = dlg.FileName;
                       filterIndex = dlg.FilterIndex;
                   }
               }

               if (fileName != null)
               {
                   switch (filterIndex)
                   {
                       case 1:
                       {
                           // Generate C# code from our codeCompileUnit and
save it.
                           CodeGeneratorOptions o = new
CodeGeneratorOptions();
                           o.BlankLinesBetweenMembers = true;
                           o.BracingStyle = "C";
                           o.ElseOnClosing = false;
                           o.IndentString = "    ";
                           StreamWriter sw = new StreamWriter(fileName);
                           CSharpCodeProvider cs = new
CSharpCodeProvider();

cs.CreateGenerator().GenerateCodeFromCompileUnit(codeCompileUnit, sw, o);
                           sw.Close();
                       } break;
                       case 2:
                       {
                           // Generate VB code from our codeCompileUnit and
save it.
                           CodeGeneratorOptions o = new
CodeGeneratorOptions();
                           o.BlankLinesBetweenMembers = true;
                           o.BracingStyle = "C";
                           o.ElseOnClosing = false;
                           o.IndentString = "    ";
                           StreamWriter sw = new StreamWriter(fileName);
                           VBCodeProvider vb = new VBCodeProvider();

vb.CreateGenerator().GenerateCodeFromCompileUnit(codeCompileUnit, sw, o);
                           sw.Close();
                       } break;
                       case 3:
                       {
                           // Write out our xmlDocument to a file.
                           StringWriter sw = new StringWriter();
                           XmlTextWriter xtw = new XmlTextWriter(sw);
                           xtw.Formatting = Formatting.Indented;
                           xmlDocument.WriteTo(xtw);

                           // Get rid of our artificial super-root before
we save out
                           // the XML.
                           //
                           string cleanup =
sw.ToString().Replace("<DOCUMENT_ELEMENT>", "");
                           cleanup = cleanup.Replace("</DOCUMENT_ELEMENT>",
"");
                           xtw.Close();
                           StreamWriter file = new StreamWriter(fileName);
                           file.Write(cleanup);
                           file.Close();
                       } break;
                   }

                   //------------------------------------------------
                   // SHL - Write out the resources into a resx file
                   {
                       SampleResourceService rs = (SampleResourceService)
this.host.GetService(typeof(IResourceService));
                       FileStream resxfile = new
FileStream(Path.ChangeExtension(fileName, ".resx"), FileMode.Create,
FileAccess.Write );
                       byte[] buf = rs.Resources;
                       resxfile.Write(buf, 0, buf.Length);
                       resxfile.Flush();
                       resxfile.Close();
                   }
                   //------------------------------------------------

                   unsaved = false;
               }
           }
           catch(Exception ex)
           {
               MessageBox.Show("Error during save: " + ex.Message);
           }
       }

Then it will write out a .resx file for the form in the same way as VS.NET
does. You can then convert this to a .resources file using RESGEN.EXE in the
framework SDK, and you can link it with the code for the form in your call
to the command line compiler (i.e. VBC.EXE or CSC.EXE depending on your
language). If you don't want to require the SDK with your app, it's very
easy to reproduce this function of RESGEN (load the file with a
ResXResourceReader, write it out with a ResourceWriter) in your own code
before you call the compiler. Alternatively, you could change the
ResXResourceReader and ResXResourceWriter declarations in
SampleResourceService.cs above back to ResourceWriter and ResourceReader
respectively, but I find the resx format is useful as then you can open the
forms in VS.NET if necessary.

Hope that helps,

Simon