Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

144 lines
4.4 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="SimpleHandlerBuildProvider.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.Compilation {
using System;
using System.IO;
using System.Collections;
using System.Reflection;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Web.Configuration;
using System.Web.Util;
using System.Web.UI;
[BuildProviderAppliesTo(BuildProviderAppliesTo.Web)]
internal abstract class SimpleHandlerBuildProvider: InternalBuildProvider {
private SimpleWebHandlerParser _parser;
internal override IAssemblyDependencyParser AssemblyDependencyParser {
get { return _parser; }
}
protected abstract SimpleWebHandlerParser CreateParser();
public override CompilerType CodeCompilerType {
get {
Debug.Assert(_parser == null);
_parser = CreateParser();
_parser.SetBuildProvider(this);
_parser.IgnoreParseErrors = IgnoreParseErrors;
_parser.Parse(ReferencedAssemblies);
return _parser.CompilerType;
}
}
protected internal override CodeCompileUnit GetCodeCompileUnit(out IDictionary linePragmasTable) {
Debug.Assert(_parser != null);
CodeCompileUnit ccu = _parser.GetCodeModel();
linePragmasTable = _parser.GetLinePragmasTable();
return ccu;
}
public override void GenerateCode(AssemblyBuilder assemblyBuilder) {
CodeCompileUnit codeCompileUnit = _parser.GetCodeModel();
// Bail if we have nothing we need to compile
if (codeCompileUnit == null)
return;
assemblyBuilder.AddCodeCompileUnit(this, codeCompileUnit);
// Add all the assemblies
if (_parser.AssemblyDependencies != null) {
foreach (Assembly assembly in _parser.AssemblyDependencies) {
assemblyBuilder.AddAssemblyReference(assembly, codeCompileUnit);
}
}
// NOTE: we can't actually generate the fast factory because it would give
// a really bad error if the user specifies a classname which doesn't match
// the actual class they define. A bit unfortunate, but not that big a deal...
// tell the host to generate a fast factory for this type (if any)
//string generatedTypeName = _parser.GeneratedTypeName;
//if (generatedTypeName != null)
// assemblyBuilder.GenerateTypeFactory(generatedTypeName);
}
public override Type GetGeneratedType(CompilerResults results) {
Type t;
if (_parser.HasInlineCode) {
// This is the case where the asmx/ashx has code in the file, and it
// has been compiled.
Debug.Assert(results != null);
t = _parser.GetTypeToCache(results.CompiledAssembly);
}
else {
// This is the case where the asmx/ashx has no code and is simply
// pointing to an existing assembly. Set the UsesExistingAssembly
// flag accordingly.
t = _parser.GetTypeToCache(null);
}
return t;
}
public override ICollection VirtualPathDependencies {
get {
return _parser.SourceDependencies;
}
}
internal CompilerType GetDefaultCompilerTypeForLanguageInternal(string language) {
return GetDefaultCompilerTypeForLanguage(language);
}
internal CompilerType GetDefaultCompilerTypeInternal() {
return GetDefaultCompilerType();
}
internal TextReader OpenReaderInternal() {
return OpenReader();
}
internal override ICollection GetGeneratedTypeNames() {
// Note that _parser.TypeName does not necessarily point to the type defined in the handler file,
// it could be any type that can be referenced at runtime, App_Code for example.
return new SingleObjectCollection(_parser.TypeName);
}
}
internal class WebServiceBuildProvider: SimpleHandlerBuildProvider {
protected override SimpleWebHandlerParser CreateParser() {
return new WebServiceParser(VirtualPath);
}
}
internal class WebHandlerBuildProvider: SimpleHandlerBuildProvider {
protected override SimpleWebHandlerParser CreateParser() {
return new WebHandlerParser(VirtualPath);
}
}
}