/// <summary>
/// Writes reflected metadata combined with the /doc comments to the
/// specified file.
/// </summary>
/// <remarks>
/// This is performed in a separate <see cref="AppDomain" />.
/// </remarks>
protected void MakeXmlFile(Project project, string fileName)
{
//if this.rep.UseNDocXmlFile is set,
//copy it to the temp file and return.
string xmlFile = MyConfig.UseNDocXmlFile;
if (xmlFile.Length > 0)
{
Trace.WriteLine("Loading pre-compiled XML information from: " + xmlFile);
File.Copy(xmlFile, fileName, true);
return;
}
AppDomain appDomain = null;
try
{
appDomain = AppDomain.CreateDomain("NDocReflection",
AppDomain.CurrentDomain.Evidence, AppDomain.CurrentDomain.SetupInformation);
appDomain.SetupInformation.ShadowCopyFiles = "true"; //only required for managed c++ assemblies
ReflectionEngine re = (ReflectionEngine)
appDomain.CreateInstanceAndUnwrap(typeof(ReflectionEngine).Assembly.FullName,
typeof(ReflectionEngine).FullName, false, BindingFlags.Public | BindingFlags.Instance,
null, new object[0], CultureInfo.InvariantCulture, new object[0],
AppDomain.CurrentDomain.Evidence);
ReflectionEngineParameters rep = new ReflectionEngineParameters(
project, MyConfig);
re.MakeXmlFile(rep, fileName);
}
finally
{
if (appDomain != null) AppDomain.Unload(appDomain);
}
}
/// <summary>
/// Gets the namespaces from assembly.
/// </summary>
/// <param name="rep">ReflectionEngine Parameters.</param>
/// <param name="assemblyFile">Assembly file name.</param>
/// <returns></returns>
public SortedList GetNamespacesFromAssembly(ReflectionEngineParameters rep, string assemblyFile)
{
this.rep = rep;
assemblyLoader = SetupAssemblyLoader();
try
{
Assembly a = assemblyLoader.LoadAssembly(assemblyFile);
SortedList namespaces = new SortedList();
foreach (Type t in a.GetTypes())
{
string ns = t.Namespace;
{
if (ns == null)
{
if ((!namespaces.ContainsKey("(global)")))
namespaces.Add("(global)", null);
}
else
{
if ((!namespaces.ContainsKey(ns)))
namespaces.Add(ns, null);
}
}
}
return namespaces;
}
catch (ReflectionTypeLoadException rtle)
{
StringBuilder sb = new StringBuilder();
if (assemblyLoader.UnresolvedAssemblies.Count > 0)
{
sb.Append("One or more required assemblies could not be located : \n");
foreach (string ass in assemblyLoader.UnresolvedAssemblies)
{
sb.AppendFormat(" {0}\n", ass);
}
sb.Append("\nThe following directories were searched, \n");
foreach (string dir in assemblyLoader.SearchedDirectories)
{
sb.AppendFormat(" {0}\n", dir);
}
}
else
{
Hashtable fileLoadExceptions = new Hashtable();
foreach (Exception loaderEx in rtle.LoaderExceptions)
{
System.IO.FileLoadException fileLoadEx = loaderEx as System.IO.FileLoadException;
if (fileLoadEx != null)
{
if (!fileLoadExceptions.ContainsKey(fileLoadEx.FileName))
{
fileLoadExceptions.Add(fileLoadEx.FileName, null);
sb.Append("Unable to load: " + fileLoadEx.FileName + "\r\n");
}
}
sb.Append(loaderEx.Message + Environment.NewLine);
sb.Append(loaderEx.StackTrace + Environment.NewLine);
sb.Append("--------------------" + Environment.NewLine + Environment.NewLine);
}
}
throw new DocumenterException(sb.ToString());
}
finally
{
assemblyLoader.Deinstall();
}
}
/// <summary>Builds an Xml string combining the reflected metadata with the /doc comments.</summary>
/// <remarks>This now evidently writes the string in utf-16 format (and
/// says so, correctly I suppose, in the xml text) so if you write this string to a file with
/// utf-8 encoding it will be unparseable because the file will claim to be utf-16
/// but will actually be utf-8.</remarks>
/// <returns>XML string</returns>
internal string MakeXml(ReflectionEngineParameters rep)
{
this.rep = rep;
StringWriter swriter = new StringWriter();
XmlWriter writer = new XmlTextWriter(swriter);
try
{
BuildXml(writer);
return swriter.ToString();
}
finally
{
if (writer != null) writer.Close();
if (swriter != null) swriter.Close();
}
}
/// <summary>Builds an Xml file combining the reflected metadata with the /doc comments.</summary>
/// <returns>full pathname of XML file</returns>
/// <remarks>The caller is responsible for deleting the xml file after use...</remarks>
internal void MakeXmlFile(ReflectionEngineParameters rep, string xmlFile)
{
this.rep = rep;
XmlTextWriter writer = null;
try
{
writer = new XmlTextWriter(xmlFile, Encoding.UTF8);
BuildXml(writer);
}
finally
{
if (writer != null) writer.Close();
}
}
/// <summary>
/// Returns reflected metadata combined with the /doc comments.
/// </summary>
/// <remarks>This now evidently writes the string in utf-16 format (and
/// says so, correctly I suppose, in the xml text) so if you write this string to a file with
/// utf-8 encoding it will be unparseable because the file will claim to be utf-16
/// but will actually be utf-8.</remarks>
/// <returns>XML string</returns>
/// <remarks>
/// This is performed in a separate <see cref="AppDomain" />.
/// </remarks>
protected string MakeXml(Project project)
{
//if MyConfig.UseNDocXmlFile is set,
//load the XmlBuffer from the file and return.
string xmlFile = MyConfig.UseNDocXmlFile;
if (xmlFile.Length > 0)
{
Trace.WriteLine("Loading pre-compiled XML information from: " + xmlFile);
using (TextReader reader = new StreamReader(xmlFile, Encoding.UTF8))
{
return reader.ReadToEnd();
}
}
AppDomain appDomain = null;
try
{
appDomain = AppDomain.CreateDomain("NDocReflection",
AppDomain.CurrentDomain.Evidence, AppDomain.CurrentDomain.SetupInformation);
appDomain.SetupInformation.ShadowCopyFiles = "true"; //only required for managed c++ assemblies
ReflectionEngine re = (ReflectionEngine)
appDomain.CreateInstanceAndUnwrap(typeof(ReflectionEngine).Assembly.FullName,
typeof(ReflectionEngine).FullName, false, BindingFlags.Public | BindingFlags.Instance,
null, new object[0], CultureInfo.InvariantCulture, new object[0],
AppDomain.CurrentDomain.Evidence);
ReflectionEngineParameters rep = new ReflectionEngineParameters(
project, MyConfig);
return re.MakeXml(rep);
}
finally
{
if (appDomain != null) AppDomain.Unload(appDomain);
}
}
/// <summary>
/// Loads the namespaces from assemblies.
/// </summary>
/// <param name="project">Project.</param>
public void LoadNamespacesFromAssemblies(Project project)
{
//let's try to create this in a new AppDomain
AppDomain appDomain = null;
try
{
appDomain = AppDomain.CreateDomain("NDocNamespaces");
ReflectionEngine re = (ReflectionEngine)
appDomain.CreateInstanceAndUnwrap(typeof(ReflectionEngine).Assembly.FullName,
typeof(ReflectionEngine).FullName, false, BindingFlags.Public | BindingFlags.Instance,
null, new object[0], CultureInfo.InvariantCulture, new object[0],
AppDomain.CurrentDomain.Evidence);
ReflectionEngineParameters rep = new ReflectionEngineParameters(project);
foreach (AssemblySlashDoc assemblySlashDoc in project.AssemblySlashDocs)
{
if (assemblySlashDoc.Assembly.Path.Length > 0)
{
string assemblyFullPath = assemblySlashDoc.Assembly.Path;
if (File.Exists(assemblyFullPath))
{
SortedList namespaces = re.GetNamespacesFromAssembly(rep, assemblyFullPath);
foreach (string ns in namespaces.GetKeyList())
{
if (_namespaces == null)
_namespaces = new SortedList();
if ((!_namespaces.ContainsKey(ns)))
{
_namespaces.Add(ns, null);
}
}
}
}
}
}
finally
{
if (appDomain != null) AppDomain.Unload(appDomain);
}
}
/// <summary>
/// Writes reflected metadata combined with the /doc comments to the
/// specified file.
/// </summary>
/// <remarks>
/// This is performed in a separate <see cref="AppDomain" />.
/// </remarks>
protected void MakeXmlFile(Project project, string fileName)
{
//if this.rep.UseNDocXmlFile is set,
//copy it to the temp file and return.
string xmlFile = MyConfig.UseNDocXmlFile;
if (xmlFile.Length > 0)
{
Trace.WriteLine("Loading pre-compiled XML information from: " + xmlFile);
File.Copy(xmlFile, fileName, true);
return;
}
AppDomain appDomain = null;
try
{
appDomain = AppDomain.CreateDomain("NDocReflection",
AppDomain.CurrentDomain.Evidence, AppDomain.CurrentDomain.SetupInformation);
appDomain.SetShadowCopyFiles(); //only required for managed c++ assemblies
ReflectionEngine re = null;
try {
//re = (ReflectionEngine)
// appDomain.CreateInstanceAndUnwrap(typeof(ReflectionEngine).Assembly.FullName,
// typeof(ReflectionEngine).FullName, false, BindingFlags.Public | BindingFlags.Instance,
// null, new object[0], CultureInfo.InvariantCulture, new object[0],
// //AppDomain.CurrentDomain.Evidence);
// new System.Security.Policy.Evidence());
re = new ReflectionEngine();
}
catch (System.Security.SecurityException e) {
System.Windows.Forms.MessageBox.Show(
e.Message + "\n" +
e.ToString() + "\n" +
e.PermissionState + "\n" +
e.PermissionType.ToString() + "\n" +
e.RefusedSet + "\n" +
e.Source + "\n" +
e.Url + "\n" +
e.Zone.ToString() + "\n" +
string.Empty
);
}
ReflectionEngineParameters rep = new ReflectionEngineParameters(
project, MyConfig);
re.MakeXmlFile(rep, fileName);
}
finally
{
if (appDomain != null) AppDomain.Unload(appDomain);
}
}
