Files
mono/mcs/class/System.Web/System.Web.Compilation/UserControlCompiler.cs
T
Gonzalo Paniagua Javier be2bff830e 2002-11-26 Gonzalo Paniagua Javier <[email protected]>
* list: added/removed files.

	* System.Web.Compilation/AspGenerator.cs: reworked user control
	compilation. Provide the options as a Hashtable for use in compilation.
	Create the user controls in the private bin path of the domain.

	* System.Web.Compilation/BaseCompiler.cs: base class for the various
	compiler types.

	* System.Web.Compilation/CachingCompiler.cs: actually executes mcs and
	do some poor caching (it will use Cache when finished).

	* System.Web.Compilation/CompilationException.cs: this exception has
	enough information to generate a nice error page.
	* System.Web.Compilation/CompilationResult.cs: used in caching.

	* System.Web.Compilation/PageCompiler.cs: now derives from BaseCompiler

	* System.Web.Compilation/TemplateFactory.cs: no longer needed.

	* System.Web.Compilation/UserControlCompiler.cs: new class used when
	compiling user controls.
	* System.Web.Compilation/WebServiceCompiler.cs: derives from
	BaseCompiler.
	* System.Web.Mail/SmtpMail.cs: i don't wanna see that warning :-).
	* System.Web.UI/TemplateParser.cs: fixed BaseType.
	* System.Web.UI/UserControlParser.cs: helper class to compile user
	controls.

svn path=/trunk/mcs/; revision=9191
2002-11-26 02:52:25 +00:00

106 lines
2.8 KiB
C#

//
// System.Web.Compilation.UserControlCompiler
//
// Authors:
// Gonzalo Paniagua Javier ([email protected])
//
// (C) 2002 Ximian, Inc (http://www.ximian.com)
//
using System;
using System.IO;
using System.Reflection;
using System.Web.UI;
using System.Web.Util;
namespace System.Web.Compilation
{
class UserControlCompiler : BaseCompiler
{
UserControlParser userControlParser;
string sourceFile;
string targetFile;
internal UserControlCompiler (UserControlParser userControlParser, string targetFile)
{
this.userControlParser = userControlParser;
this.targetFile = targetFile;
}
public override Type GetCompiledType ()
{
string inputFile = userControlParser.InputFile;
sourceFile = GenerateSourceFile (userControlParser);
CachingCompiler compiler = new CachingCompiler (this);
CompilationResult result = new CompilationResult ();
if (compiler.Compile (result) == false)
throw new CompilationException (result);
Assembly assembly = Assembly.LoadFrom (result.OutputFile);
Type [] types = assembly.GetTypes ();
if (types.Length != 1)
throw new CompilationException ("More than 1 Type in a user control?", result);
result.Data = types [0];
return types [0];
}
public override string Key {
get {
return userControlParser.InputFile;
}
}
public override string SourceFile {
get {
return sourceFile;
}
}
public override string TargetFile {
get {
if (targetFile == null)
targetFile = Path.ChangeExtension (sourceFile, ".dll");
return targetFile;
}
}
public static Type CompileUserControlType (UserControlParser userControlParser)
{
CompilationCacheItem item = CachingCompiler.GetCached (userControlParser.InputFile);
if (item != null && item.Result != null) {
if (item.Result != null)
return item.Result.Data as Type;
throw new CompilationException (item.Result);
}
UserControlCompiler pc = new UserControlCompiler (userControlParser, null);
return pc.GetCompiledType ();
}
static string GenerateSourceFile (UserControlParser userControlParser)
{
string inputFile = userControlParser.InputFile;
Stream input = File.OpenRead (inputFile);
AspParser parser = new AspParser (inputFile, input);
parser.Parse ();
AspGenerator generator = new AspGenerator (inputFile, parser.Elements);
generator.BaseType = userControlParser.BaseType.ToString ();
generator.ProcessElements ();
userControlParser.Text = generator.GetCode ().ReadToEnd ();
//FIXME: should get Tmp dir for this application
string csName = Path.GetTempFileName () + ".cs";
WebTrace.WriteLine ("Writing {0}", csName);
StreamWriter output = new StreamWriter (File.OpenWrite (csName));
output.Write (userControlParser.Text);
output.Close ();
return csName;
}
}
}