RazorEngine

Razor Html Attribute value

Creates a new Razor Html Attribute value.

The prefix of the attribute.

The Value of the attribute.

Indicates whether the attribute is a lital.

Convert from a tuple.

Convert from a tuple

Convert from a tuple.

Provides a base implementation of a compiler service.

The namespace for dynamic templates.

A prefix for all dynamically created classes.

This class only exists because we cannot use Func<ParserBase> in non security-critical class.

The parser creator.

Create a new ParserBaseCreator instance.

The parser creator.

Execute the given delegate.

Initialises a new instance of

The code language. The markup parser factory.

Gets or sets the set of code inspectors.

Gets or sets the assembly resolver.

Gets the code language.

Gets or sets whether the compiler service is operating in debug mode.

Gets or sets whether the compiler should load assemblies with Assembly.Load(byte[]) to prevent files from being locked.

Gets the markup parser.

Extension of a source file without dot ("cs" for C# files or "vb" for VB.NET files).

Tries to create and return a unique temporary directory.

the (already created) temporary directory

Returns a new temporary directory ready to be used. This can be overwritten in subclases to change the created directories.

Builds a type name for the specified template type.

The template type. The model type. The string type name (including namespace).

Compiles the type defined in the specified type context.

The type context which defines the type to compile. The compiled type.

Creates a used for class generation.

The template base type. The model type. The class name. An instance of .

Gets the source code from Razor for the given template.

The class name. The template to compile. The set of namespace imports. The template type. The model type.

Helper method to generate the prefered assembly name.

the context of the current compilation.

Inspects the source and returns the source code.

Gets the code compile unit used to compile a type.

A used to compile a type.

Gets the generator result.

The razor engine host. The compile context. The generator result.

Gets any required namespace imports.

The template type. The requested set of namespace imports. A set of namespace imports.

Returns a set of assemblies that must be referenced by the compiled template.

The set of assemblies.

Returns a set of references that must be referenced by the compiled template.

The set of references.

Helper method to get all references for the given compilation.

Inspects the generated code compile unit.

The code compile unit.

Disposes the current instance.

Disposes the current instance via the disposable pattern.

true when Dispose() was called manually.

Manages creation of instances.

Sets the used to create compiler service instances.

The compiler service factory to use.

Gets the for the specfied language.

The code language. The compiler service instance.

Gets the for the default .

The compiler service instance.

Provides service methods for compilation.

Determines if the specified type is an anonymous type.

The type to check. True if the type is an anonymous type, otherwise false.

Checks if the given type is a anonymous type or a generic type containing a reference type as generic type argument

the type to check true when there exists a reference to an anonymous type.

Determines if the specified type is a dynamic type.

The type to check. True if the type is an anonymous type, otherwise false.

Determines if the specified type is a compiler generated iterator type.

The type to check. True if the type is an iterator type, otherwise false.

Generates a random class name.

A new random class name.

Gets the public or protected constructors of the specified type.

The target type. An enumerable of constructors.

Resolves the C# name of the given type.

the type to emit. The full type name or dynamic if the type is an instance of an dynamic type.

Resolves the VB.net name of the given type.

the type to emit. The full type name or Object if the type is an instance of an dynamic type.

Gets the Iterator type for the given compiler generated iterator.

The target type. Tries to return IEnumerable of T if possible.

Gets an enumerable of all assemblies loaded in the current domain.

An enumerable of loaded assemblies.

Return the raw type name (including namespace) without any generic arguments. Returns the typename in a way it can be used in C# code.

Return the raw type name (including namespace) without any generic arguments. Returns the typename in a way it can be used in VB.net code.

Return the raw type name (including namespace) with the given modelTypeName as generic argument (if applicable). Returns the typename in a way it can be used in C# code.

Return the raw type name (including namespace) with the given modelTypeName as generic argument (if applicable). Returns the typename in a way it can be used in VB.net code.

Helper class to cleanup locked files and folders after the current AppDomain has been unloaded. (Because of locking they can't be deleted while the current AppDomain is up, see https://github.com/Antaris/RazorEngine/issues/244)

Simple helper object to print status messages across appdomains.

Print a status message

Print a error message.

A simple Printer which wrints in stdout and stderr.

Creates a new simple printer.

A simple printer writing only in stderr.

Create a new ErrorOnlyPrinter.

A new empty printer, which prints nothing.

Creates a new EmptyPrinter

Helper class to communicate with the Cleanup AppDomain. Inits the cleanup AppDomain (AssemblyResolve) and registers items to delete.

A helper to be able to subscribe to the DomainUnload event. Additionally we use this object to check if the printer lives in the wrong appdomain (which would lead to an application crash).

Subscribe to the DomainUnload event and call the helper back.

Check if the given printer object is valid.

Check if the given AppDomain is unloaded.

Init the current helper object with the given AppDomain.

Setup AssemblyResolve.

Gets or sets the printer that is used by default when creating new CrossAppDomainCleanUp objects. Do not use this property unless you know what you are doing. Settings this to a serializable object is safe, however setting this to a marshalbyrefobject can lead to errors if the object lives in the domain that is watched for unloading

A cleanup instance for the current AppDomain

Get the StrongName of the given assembly.

A helper method to register items to cleanup for the current AppDomain.

Throw an exception when we are on the default AppDomain

Create a new CrossAppDomainCleanUp object for the current AppDomain.

the appDomain to watch for unload.

This class only exists because we can't use a simple lambda.

Dispose the current instance.

Defines a code parser that supports the C# syntax.

Initialises a new instance of .

Parses the inherits statement.

Parses the model statement.

Defines a direct compiler service for the C# syntax.

Initialises a new instance of .

Specifies whether the strict mode parsing is enabled. The markup parser factory to use.

Extension of a source file without dot ("cs" for C# files or "vb" for VB.NET files).

Returns a set of assemblies that must be referenced by the compiled template.

The set of assemblies.

Builds a type name for the specified template type.

The template type. The model type. The string type name (including namespace).

Defines a code generator that supports C# syntax.

Initializes a new instance of the class.

Name of the class. Name of the root namespace. Name of the source file. The host. Flag to specify that this generator is running in struct mode.

Gets whether the code generator is running in strict mode.

Visits an error generated through parsing.

The error that was generated.

Provides a razor code language that supports the C# language.

Initialises a new instance

Flag to determine whether strict mode is enabled.

Gets whether strict mode is enabled.

Creates the code generator.

Name of the class. Name of the root namespace. Name of the source file. The host.

Provides a default implementation of a .

Creates a that supports the specified language.

The . An instance of .

Provides a base implementation of a direct compiler service.

Initialises a new instance of .

The razor code language. The code dom provider used to generate code. The markup parser factory.

The underlaying CodeDomProvider instance.

Creates the compile results for the specified .

The type context. The compiler results.

Inspects the GeneratorResults and returns the source code.

Generates any required contructors for the specified type.

The set of constructors. The code type declaration.

Compiles the type defined in the specified type context.

The type context which defines the type to compile. The compiled type.

Releases managed resources used by this instance.

Extends the class to allow implicit and explicit conversions to any interface type.

handles any conversion call.

true if successful.

Initializes a new instance of the type.

the target object for call forwarding. the supported interface types.

Initializes a new instance of the type.

the serialization info. the streaming context.

This interface can be used to define your own custom proxy if you preload it.

Advanced usage only! This is required as well as

Method used to Initialize Proxy

Base class of Emited ProxiesC:\Documents and Settings\jayt\My Documents\Visual Studio 2010\Projects\RazorEngine.Compilation.ImpromptuInterface\RazorEngine.Compilation.ImpromptuInterface\Optimization\

Initializes a new instance of the class.

Returns the proxied object

Method used to Initialize Proxy

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Actlike proxy should be equivalent to the objects they proxy

The other.

Returns a hash code for this instance.

A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.

Populates a with the data needed to serialize the target object.

The to populate with data. The destination (see ) for this serialization. The caller does not have the required permission.

Returns a that represents this instance.

A that represents this instance.

Meta info describing proxy usage. Can be used to preload proxy.

Initializes a new instance of the class.

The interfaces. The context.

Gets or sets the interfaces.

The interfaces.

Gets or sets the context.

The context.

Support Deserializing the proxy since on separate runs of an executable

Original Object

Intefaces

Type Context

Returns the real object that should be deserialized, rather than the object that the serialized stream specifies.

The from which the current object is deserialized. Returns the actual object that is put into the graph. The caller does not have the required permission. The call will not work on a medium trusted server.

Does most of the work buiding and caching proxies

Calls ActLike on the given object.

the interface to act like. the object "implementing" the interface (duck typing). the wrapper.

Writes the out DLL of types created between this call and being closed used for debugging of emitted IL code

The name. This may be used for generating an assembly for preloading proxies, however you must be very careful when doing so as changes could make the emitted asssembly out of date very easily.

Builds the type for the static proxy or returns from cache

Type of the context. The main interface. The other interfaces.

Builds the type.

Type of the context. The informal interface.

Preloads a proxy for ActLike to use.

Type of the proxy. The ActLikeProxyAttribute, if not provide it will be looked up. Returns false if there already is a proxy registered for the same type.

Preloads proxies that ActLike uses from assembly.

The assembly. Returns false if there already is a proxy registered for the same type.

Makes the property helper.

The builder. The type builder. The info. The get method. The set method. The emit info.

Emits new delegate type of the call site func.

The arg types. Type of the return.

Generates the delegate type of the call site function.

The arg types. Type of the return. The method info. Required for reference types or delegates with more than 16 arguments. The Type Builder. Required for reference types or delegates with more than 16 arguments.

Module Builder for buiding proxies

Extension Methods that make emiting code easier and easier to read

Used to automatically create label on dispose

Constructor

Finishes block

The false block.

Constructor

Finishes block

Gets the field info even if generic type parameter.

The type. Name of the field.

Gets the method info even if generic type parameter.

The type. Name of the method. The arg types.

Gets the method info even if generic type parameter.

The type. Name of the method.

Emits branch true. expects using keyword.

The generator. The condition. Using keyword allows you to set the emit code you are branching over and then automatically emits label when disposing


            		g.Emit(OpCodes.Ldsfld, tConvertField)))
            {
            tIlGen.EmitDynamicConvertBinder(CSharpBinderFlags.None, returnType, contextType);
            tIlGen.EmitCallsiteCreate(convertFuncType);
            tIlGen.Emit(OpCodes.Stsfld, tConvertField);
            }
            ]]>

Emits branch false. expects using keyword.

The generator. The condition. Using keyword allows you to set the emit code you are branching over and then automatically emits label when disposing


            		g.Emit(OpCodes.Ldsfld, tConvertField)))
            {
            tIlGen.EmitDynamicConvertBinder(CSharpBinderFlags.None, returnType, contextType);
            tIlGen.EmitCallsiteCreate(convertFuncType);
            tIlGen.Emit(OpCodes.Stsfld, tConvertField);
            }
            ]]>

Emits the call.

The generator. The target. The call. The parameters.

Emits creating the callsite.

The generator. Type of the func.

Emits the call invoke delegate.

The generator. Type of the func.

Emits an array.

The generator. Type of the array. The emit elements.

Emits the store location.

The generator. The location.

Emits the load argument.

The generator. The location.

Emits the load location.

The generator. The location.

Emits the dynamic method invoke binder.

The generator. The binding flags. The name. The generic parameters. The context. The arg info. The arg names.

Emits the dynamic set binder.

The generator. The binding flags. The name. The context. The arg types.

Emits the dynamic set binder dynamic params.

The generator. The flag. The name. The context. The arg types.

Emits the dynamic binary op binder.

The generator. The flag. Type of the expr. The context. The arg types.

Emits the dynamic get binder.

The generator. The binding flags. The name. The context. The arg types.

Emits creating the

The generator. The flag. The name.

Emits the dynamic convert binder.

The generator. The binding flag. Type of the return. The context.

Emits the dynamic event binder.

The generator. The binding flag. The name. The context.

Emits the typeof(Type)

The generator. The type.

Emits the typeof(Type)

The generator. The type.

Type that Encompasses Hashing a group of Types in various ways

Equalses the specified other.

The other.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Returns a hash code for this instance.

A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.

Implements the operator ==.

The left. The right. The result of the operator.

Implements the operator !=.

The left. The right. The result of the operator.

Types to be hashed

The Informal Interface to be hashed

Initializes a new instance of the class.

The more types.

Initializes a new instance of the class. For use when you have must distinguish one type; and the rest aren't strict

The type1. The more types.

Initializes a new instance of the class.

The type1. The informal interface.

Initializes a new instance of the class.

if set to true [strict order]. types.

Creates the TypeHash

The more types.

Creates the TypeHash

The type1. The more types.

Creates the TypeHash

The type1. The informal interface.

Creates the TypeHash

if set to true [strict order]. The more types.

Alias to swap method/property/event call name invoked on original

Initializes a new instance of the class.

The name.

Gets or sets the name.

The name.

Initializes a new instance of the class.

The max length that the list cannot grow beyound

Gets the enumerator. with bare bones this is good only once

LazyBinderType

Utility Class

Determines whether [is anonymous type] [the specified target].

The target. true if [is anonymous type] [the specified target]; otherwise, false.

Names the args if necessary.

The call info. The args.

Gets the target context.

The target. The context. if set to true [static context].

Fixes the context.

The context.

Gets the value. Conveinence Ext method

The info. The name.

Is Current Runtime Mono?

This interface can be used on your custom dynamic objects if you want impromptu interfaces without casting to object or using the static method syntax of ActLike. Also if you want to change the behavior for slightly for specific types as this will take precident when using the dynamic keyword or your specific type is known staticly.

This interface can be used on your custom dynamic objects if you want to know the interface you are impromptu-ly implementing.

Property used to pass interface information to proxied object

Sets the known property spec.

The known property spec.

Get access to target of original proxy

Gets the target.

The target.

Proxies Calls allows subclasser to override do extra actions before or after base invocation

This may not be as efficient as other proxies that can work on just static objects or just dynamic objects... Consider this when using.

Initializes a new instance of the class.

The target.

Initializes a new instance of the class.

The info. The context.

Populates a with the data needed to serialize the target object.

The to populate with data. The destination (see ) for this serialization. The caller does not have the required permission.

Returns the enumeration of all dynamic member names.

A sequence that contains dynamic member names.

Gets or sets the target.

The target.

Gets the call target.

The call target.

Provides the implementation for operations that get member values. Classes derived from the class can override this method to specify dynamic behavior for operations such as getting a value for a property.

Provides information about the object that called the dynamic operation. The binder.Name property provides the name of the member on which the dynamic operation is performed. For example, for the Console.WriteLine(sampleObject.SampleProperty) statement, where sampleObject is an instance of the class derived from the class, binder.Name returns "SampleProperty". The binder.IgnoreCase property specifies whether the member name is case-sensitive. The result of the get operation. For example, if the method is called for a property, you can assign the property value to . true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language determines the behavior. (In most cases, a run-time exception is thrown.)

Provides the implementation for operations that invoke an object. Classes derived from the class can override this method to specify dynamic behavior for operations such as invoking an object or a delegate.

Provides information about the invoke operation. The arguments that are passed to the object during the invoke operation. For example, for the sampleObject(100) operation, where sampleObject is derived from the class, [0] is equal to 100. The result of the object invocation. true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language determines the behavior. (In most cases, a language-specific run-time exception is thrown.

Forwards the invoke operation.

the binder the arguments the result true when successfull

Forwards the invoke operation.

the binder the value true when successfull

Forwards the invoke operation.

the binder the indexes the result true when successfull

Forwards the invoke operation.

the binder the indexes the value true when successfull

Forwards the convert operation.

the binder the result true when successfull

Forwards the Binary operation

Forwards the unary operation.

Equals the specified other.

The other.

Checks if the objects are equal.

the other object true when the current instance is equal to the given one.

Gets the hashcode of the current instance.

the hash code.

Implements the operator +.

The left. The right. The result of the operator.

Implements the operator -.

The left. The right. The result of the operator.

Gets or sets the delegate.

The delegate.

Gets or sets a value indicating whether this instance is adding.

true if this instance is adding; otherwise, false.

Late bind types from libraries not not at compile type

Initializes a new instance of the class.

The type.

Initializes a new instance of the class.

Qualified Name of the type.

Returns a late bound constructor

The late bound constructor

Forward argument to constructor including named arguments

Tries to invoke.

Gets a value indicating whether this Type is available at runtime.

true if this instance is available; otherwise, false.

The call target.

Initializes a new instance of the class.

The info. The context.

Dynamic Object that knows about the Impromtu Interface return types; Override Typical Dynamic Object methods, and use TypeForName to get the return type of an interface member.

Initializes a new instance of the class.

Initializes a new instance of the class. when deserializing

The info. The context.

Populates a with the data needed to serialize the target object.

The to populate with data. The destination (see ) for this serialization. The caller does not have the required permission.

Cache to avoid refelection for same Interfaces.

Hash for this instance to lookup cached values from

Keep Track of Known Property Spec

Gets or sets the known interfaces. Set should only be called be the factory methood

The known interfaces.

Gets or sets the known fake interface (string method name to return type mapping).

The known fake interface.

Returns the enumeration of all dynamic member names.

A sequence that contains dynamic member names.

Tries to get the type for the property name from the interface.

The name. The return Type.

Allows ActLike to be called via dyanmic invocation

The type of the interface. The other interfaces.

Type of Invocation

NotSet

Convert Implicit or Explicity

Get Property

Set Property

Get Indexer

Set Indexer

Invoke Method the has return value

Invoke Method that returns void

Invoke Method that could return a value or void

Invoke Constructor

Invoke +=

Invoke -=

Invoke Event Property Test

Invoke Directly

Invoke Directly DiscardResult

Invoke Directly Return Value

Storable representation of an invocation without the target

Defacto Binder Name for Explicit Convert Op

Defacto Binder Name for Implicit Convert Op

Defacto Binder Name for Indexer

Defacto Binder Name for Construvter

Gets or sets the kind.

The kind.

Gets or sets the name.

The name.

Gets or sets the args.

The args.

Creates the invocation.

The kind. The name. The args.

Initializes a new instance of the class.

The kind. The name. The args.

Equalses the specified other.

The other.

Equalses the specified other.

The other.

Get the hash code.

Invokes the invocation on specified target with specific args.

The target. The args.

Deprecated use

The target. The args.

Invokes the invocation on specified target.

The target.

Special Delegate used to make impromptu object methods first parameter is this.

Extension method for Dealing with Special Delegate Type

Determines whether [is special this delegate] [the specified del].

The del. true if [is special this delegate] [the specified del]; otherwise, false.

This interface can be used to access the original content of your emitted type;

Returns the proxied object

Main API

Creates a cached call site at runtime.

Type of the delegate. The CallSite binder. Member Name Permissions Context type The arg names. if set to true [static context]. if set to true [is event]. The CallSite Advanced usage only for serious custom dynamic invocation.

Creates the call site.

The binder. The name. The context. The arg names. if set to true [static context]. if set to true [is event]. /// Unit test that exhibits usage

(tBinder);
            tSite.Target.Invoke(tSite, tPoco, out tResult);
            Assert.AreEqual("success", tResult);
            ]]>

Dynamically Invokes a member method using the DLR

The target. The name. Can be a string it will be implicitly converted The args. The result Unit test that exhibits usage:


             (it => it.ToString());
            
                var tValue = 1;
                var tOut = Impromptu.InvokeMember(tExpando, "Func", tValue);
            
                Assert.AreEqual(tValue.ToString(), tOut);
             ]]>

Invokes the binary operator.

The left arg. The op. The right Arg.

Invokes the unary opartor.

The arg. The op.

Invokes the specified target using the DLR;

The target. The args.

Dynamically Invokes indexer using the DLR.

The target. The indexes.

Convenience version of InvokeSetIndex that separates value and indexes.

The target. The value The indexes

Invokes setindex.

The target. The indexes then value.

Dynamically Invokes a member method which returns void using the DLR

The target. The name. The args. Unit test that exhibits usage:


             (it => tTest = it);
            
                Impromptu.InvokeMemberAction(tExpando, "Action", tValue);
            
                Assert.AreEqual(tValue, tTest);
             ]]>

Invokes the action using the DLR

The target. The args.

Dynamically Invokes a set member using the DLR.

The target. The name. The value. Unit test that exhibits usage:

if you call a static property off a type with a static context the csharp dlr binder won't do it, so this method reverts to reflection

Dynamically Invokes a get member using the DLR.

The target. The name. The result. Unit Test that describes usage

Determines whether the specified name on target is event. This allows you to know whether to InvokeMemberAction add_{name} or a combo of {invokeget, +=, invokeset} and the corresponding remove_{name} or a combon of {invokeget, -=, invokeset}

The target. The name. true if the specified target is event; otherwise, false.

Invokes add assign with correct behavior for events.

The target. The name. The value.

Invokes add assign with correct behavior for events.

The target. The name. The value.

Invokes subtract assign with correct behavior for events.

The target. The name. The value.

Invokes subtract assign with correct behavior for events.

The target. The name. The value.

Invokes convert using the DLR.

The target. The type. if set to true [explicit].

Coerce to delegate.

(Obsolete)Invokes the constructor. misspelling

The type. The args.

Invokes the constuctor.

The type. The args.

FastDynamicInvoke extension method. Runs up to runs up to 20x faster than .

The del. The args.

Given a generic parameter count and whether it returns void or not gives type of Action or Func

The param count. if set to true [return void]. Type of Action or Func

Gets the member names of properties. Not all IDynamicMetaObjectProvider have support for this.

The target. if set to true [dynamic only]. Won't add reflected properties

Dynamically invokes a method determined by the CallSite binder and be given an appropriate delegate type

The Callsite The target. The args. Advanced use only. Use this method for serious custom invocation, otherwise there are other convenience methods such as , , and

Dynamically invokes a method determined by the CallSite binder and be given an appropriate delegate type

The Callsite The target. The args. Advanced use only. Use this method for serious custom invocation, otherwise there are other convenience methods such as , , and

Extension Method that Wraps an existing object with an Explicit interface definition

The type of the interface. The original object can be annoymous type, System.DynamicObject as well as any others. Optional other interfaces.

Unwraps the act like proxy (if wrapped).

The proxied object.

Extension Method that Wraps an existing object with an Interface of what it is implicitly assigned to.

The original dynamic. The other interfaces.

Makes static methods for the passed in property spec, designed to be used with old api's that reflect properties.

The original dynamic. The property spec.

Private helper method that initializes the proxy.

The proxytype. The original. The interfaces. The property spec.

This Extension method is called off the calling context to perserve permissions with the object wrapped with an explicit interface definition.

The type of the interface. The caller. The original dynamic. The other interfaces. UnitTest That describes usage


            (tTest);
                Assert.Throws(() => tNonExposed.Test());
            ]]>

Chainable Linq to Objects Method, allows you to wrap a list of objects with an Explict interface defintion

The type of the interface. The original dynamic. The other interfaces.

Static Method that wraps an existing dyanmic object with a explicit interface type

The original dynamic. The other interfaces.

This Extension method is called off the calling context to perserve permissions with the object wrapped with an explicit interface definition.

The caller. The original dynamic. The other interfaces.

Chainable Linq to Objects Method, allows you to wrap a list of objects, and preserve method permissions with a caller, with an Explict interface defintion

The type of the interface. The original dynamic. The caller. The other interfaces.

Use for Named arguments passed to InvokeMethods

Performs an explicit conversion from to .

The pair. The result of the conversion.

Create Function can set to variable to make cleaner syntax;

Initializes a new instance of the class.

The name. The value.

Gets or sets the argument name.

The name.

Gets or sets the argument value.

The value.

InvokeArg that makes it easier to Cast from any IDictionaryValue

Initializes a new instance of the class.

The name. The value.

Performs an explicit conversion from to .

The pair. The result of the conversion.

Specific version of InvokeContext which declares a type to be used to invoke static methods.

Performs an explicit conversion from to .

The type. The result of the conversion.

Initializes a new instance of the class.

The target.

Object that stores a context with a target for dynamic invocation

Create Function can set to variable to make cleaner syntax;

Gets or sets the target.

The target.

Gets or sets the context.

The context.

Gets or sets a value indicating whether [static context].

true if [static context]; otherwise, false.

Initializes a new instance of the class.

The target. if set to true [static context]. The context.

Initializes a new instance of the class.

The target. The context.

Various extension methods for add

Combines target with context.

The target. The context.

Combines target with context.

The type of the context. The target.

Combines target with context.

The target. The context.

Withes the static context.

The target. The context.

attaches generic args to string

The name. The generic args.

attaches name of the argument.

The argument. The name.

String or InvokeMemberName

Performs an implicit conversion from to .

The name. The result of the conversion.

Gets the name.

The name.

Gets the generic args.

The generic args.

Gets or sets a value indicating whether this member is special name.

true if this instance is special name; otherwise, false.

Name of Member with associated Generic parameterss

Create Function can set to variable to make cleaner syntax;

Performs an implicit conversion from to .

The name. The result of the conversion.

Initializes a new instance of the class.

The name. The generic args.

Initializes a new instance of the class.

The name. if set to true [is special name].

Equalses the specified other.

The other.

Equalses the specified other.

The other.

Determines whether the specified is equal to this instance.

The to compare with this instance. true if the specified is equal to this instance; otherwise, false.

Returns a hash code for this instance.

A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.

Attribute on Inteface to stop proxy from recursively proxying other interfaces

Attribute for Methods and Parameters on Custom Interfaces designed to be used with a dynamic implementation

The sole purpose of this class is to fix https://github.com/Antaris/RazorEngine/issues/267.

Defines an attribute that marks the presence of a dynamic model in a template.

Defines the required contract for implementing a code inspector.

Inspects the specified code unit.

The code unit. The code namespace declaration. The code type declaration. The code method declaration for the Execute method.

Defines the required contract for implementing a compiler service.

Gets or sets the set of code inspectors.

Gets or sets the reference resolver.

Gets or sets whether the compiler service is operating in debug mode.

Gets or sets whether the compiler should load assemblies with Assembly.Load(byte[]) to prevent files from being locked.

Compiles the type defined in the specified type context.

The type context which defines the type to compile. The compiled type.

Returns a set of assemblies that must be referenced by the compiled template.

The set of assemblies.

Defines the required contract for implementing a compiler service factory.

Creates a that supports the specified language.

The . An instance of .

Wraps a dynamic object for serialization of dynamic objects and anonymous type support. But this type will also make (static) types work which are not serializable.

A helper class to make sure the wrapped object does not leave its .

Initializes a new instance of the class.

the wrapped object. true when we allow missing properties.

Tries to find a member with the given name, the given arguments and the given parameter types and invokes that member.

the type we search for that member. the name of the member the arguments of the member the type of the arguments of the member the result of invoking the found member. true if a member was found and invoked.

Unwrap the currently wrapped object (note that this can cause crossing an app-domain boundary).

This method is used to delegate the invocation across the .

The invocation to cross the . The result of the invocation on the wrapped instance.

Initializes a new instance of the class.

The info. The context.

Populates a with the data needed to serialize the target object.

The to populate with data. The destination (see ) for this serialization. The caller does not have the required permission.

Try to find a type instance which has no references to anonymous types. Either we use the type or create a new one which implements the same interfaces.

Convert the given interface type instance in another interface type instance which is free of anonymous types.

Check if an instance is already wrapped with .

the object to check.

Create a wrapper around an dynamic object. This wrapper ensures that we can cross the , call internal methods (to make Anonymous types work), or call missing methods (when allowMissingMembers is true).

The object to wrap. true when we should not throw when missing members are invoked. the wrapped object.

A simple generic cast method. Used for the DynamicCast implementation.

A tricky dynamic cast (Cast in the runtime with dynamic types).

Checks if the fiven ParameterInfo array is compatible with the given type array.

Returnes true when the type of the given result is primitive. (ie should not be wrapped in another instance)

the object to check

Captures the invocation and invokes it on the wrapped object (possibly across the boundary.

The invocation the result

Tries to get the member.

The binder. The result.

Unwraps the current RazorDynamicObject.

the unwrapped object.

Unwraps the current dynamic object.

the unwrapped object.

Tries to convert the current instance.

The binder. The result.

Tries to set the member.

The binder. The value.

Forwards the binary operation

Forwads the unary operation

Tries the invoke member.

The binder. The args. The result.

Tries the index of the get.

The binder. The indexes. The result.

Tries the index of the set.

The binder. The indexes. The value.

Override ToString and remotely invoke our wrapped instance.

Whatever our wrapped instance returns.

Cleans up the instance.

Disposes the current instance.

Disposes the current instance via the disposable pattern.

true when Dispose() was called manually.

Defines the custom razor engine host.

Initialises a new instance of .

The code language. The markup parser factory delegate.

Gets or sets the default template type.

Gets or sets the default model type.

Decorates the code parser.

The code parser. The decorated parser.

Represents a reference for the compiler

Visitor pattern for the class.

Handle a direct assembly reference

Handle a file reference.

Handle a stream reference.

Handle a byte array reference.

The Type of the reference

Reference to a file

Reference to a assembly instace

Reference to a assembly stream.

Reference to a assembly within a byte array.

The type of the current reference.

execute the given visitor.

Create a compiler reference from the given file.

Create a compiler reference from the given assembly. NOTE: The CodeDom compiler doesn't support assembly references where assembly.Location is null (roslyn only)!

Create a compiler reference from the given stream. NOTE: The CodeDom compiler doesn't support stream references (roslyn only)!

Create a compiler reference from the given byte array. NOTE: The CodeDom compiler doesn't support byte array references (roslyn only)!

Default implementation for resolving an assembly name.

name of the assembly to resolve references to check the resolved assembly or null

Try to resolve the reference to a file (throws when this is not possible).

Checks if the given object is equal to the current object.

Gets a hashcode for the current object.

A visitor for the GetFile function.

A file reference.

The referenced file.

Visit the given visitor.

A direct assembly reference.

The referenced assembly.

Visit the visitor.

A stream reference.

The referenced stream.

Visit the given visitor.

A byte array reference.

The referenced byte array.

Visit the given visitor.

Tries to resolve the references for a given compilation option.

Resolve the reference for a compilation process.

gives context about the compilation process. The references that should be included (requested by the compiler itself) the references which will be used in the compilation process.

Resolves the assemblies by using all currently loaded assemblies. See

See

Provides (temporary) data about an compilation process.

The temporary folder for the compilation process

The generated source code for the template.

Creates a new CompilationData instance.

The generated source code for the template. The temporary folder for the compilation process

The generated source code of the template (can be null).

Deletes all remaining files

returns the temporary folder for the compilation process (can be null).

Destructs the current instance.

Clean up the compilation (ie delete temporary files).

Cleans up the data of the current compilation.

Defines a type context that describes a template to compile.

Initialises a new instance of .

Creates a new TypeContext instance with the given classname and the given namespaces.

Gets the class name.

Gets or sets the model type.

Gets the set of namespace imports.

Gets or sets the template content.

Gets or sets the base template type.

Adds compiler references to the current dynamic assembly resolve list.

the references to add to the dynamic resolve list.

Defines a code parser that supports the VB syntax.

Initialises a new instance of

Parses the inherits statement.

Parses the modeltype statement.

Defines a direct compiler service for the VB syntax.

Initialises a new instance of .

Specifies whether the strict mode parsing is enabled. The markup parser to use.

Extension of a source file without dot ("cs" for C# files or "vb" for VB.NET files).

Builds a type name for the specified template type.

The template type. The model type. The string type name (including namespace).

Defines a code generator that supports VB syntax.

Initializes a new instance of the class.

Name of the class. Name of the root namespace. Name of the source file. The host. Flag to specify that this generator is running in struct mode.

Gets whether the code generator is running in strict mode.

Visits an error generated through parsing.

The error that was generated.

Provides a razor code language that supports the VB language.

Initialises a new instance

Flag to determine whether strict mode is enabled.

Gets whether strict mode is enabled.

Creates the code generator.

Name of the class. Name of the root namespace. Name of the source file. The host. An instance of .

Enables access to objects across application domain boundaries. This type differs from by ensuring that the service lifetime is managed deterministically by the consumer.

Cleans up the instance.

Disconnects the remoting channel(s) of this object and all nested objects.

initializes the lifetime service for the current instance.

null

Disposes the current instance.

Disposes the current instance via the disposable pattern.

true when Dispose() was called manually.

Provides a readonly view of a configuration, and safe-copies all references.

Create a new readonly view (and copy) of the given configuration.

the configuration to copy.

Gets the activator.

Gets or sets whether to allow missing properties on dynamic models.

Gets the base template type.

Gets the caching provider.

Gets the code inspectors.

Gets the compiler service factory.

Gets whether the template service is operating in debug mode.

Loads all dynamic assemblies with Assembly.Load(byte[]). This prevents temp files from being locked (which makes it impossible for RazorEngine to delete them). At the same time this completely shuts down any sandboxing/security. Use this only if you have a limited amount of static templates (no modifications on rumtime), which you fully trust and when a seperate AppDomain is no solution for you!. This option will also hurt debugging. OK, YOU HAVE BEEN WARNED.

Gets the encoded string factory.

Gets the language.

Gets the namespaces.

Gets the reference resolver.

Gets the template resolver.

Provides a default implementation of a template service configuration.

Initialises a new instance of .

Gets or sets the activator.

Gets or sets whether to allow missing properties on dynamic models.

Gets or sets the base template type.

Gets the set of code inspectors.

Gets or sets the reference resolver

Gets or sets the caching provider.

Gets or sets the compiler service factory.

Gets whether the template service is operating in debug mode.

Gets or sets the encoded string factory.

Gets or sets the language.

Gets or sets the collection of namespaces.

Gets or sets the template resolver.

Provides a default implementation of a .

Initialises a new instance of .

The default configuration that we build a new configuration from.

Sets the activator.

The activator instance. The current configuration builder.

Sets the activator.

The activator type. The current configuration builder.

Sets the activator.

The activator delegate. The current configuration builder.

Adds the specified code inspector.

The code inspector type. The current configuration builder.

Adds the specified code inspector.

The code inspector. The current configuration builder.

Sets that dynamic models should be fault tollerant in accepting missing properties.

The current configuration builder.

Sets the compiler service factory.

The compiler service factory. The current configuration builder.

Sets the compiler service factory.

The compiler service factory type. The current configuration builder.

Sets the encoded string factory.

The encoded string factory. The current configuration builder.

Sets the encoded string factory.

The encoded string factory type. The current configuration builder.

Includes the specified namespaces

The set of namespaces to include. The current configuration builder.

Sets the resolve used to locate unknown templates.

The resolve type. The current configuration builder.

Sets the resolve used to locate unknown templates.

The resolve type. The current configuration builder.

Sets the resolver used to locate unknown templates.

The resolver instance to use. The current configuration builder.

Sets the resolver used to locate unknown templates.

The resolver instance to use. The current configuration builder.

Sets the resolver delegate used to locate unknown templates.

The resolver delegate to use. The current configuration builder.

The current configuration builder.

Sets the default activator.

The current configuration builder.

Sets the default compiler service factory.

The current configuration builder.

Sets the default encoded string factory.

The current configuration builder.

Sets the base template type.

The base template type. The current configuration builder/.

Sets the code language.

The code language. The current configuration builder.

Sets the encoding.

The encoding. The current configuration builder.

Defines a fluent template service configuration

Initialises a new instance of .

The delegate used to create the configuration.

Gets or sets the activator.

Gets or sets whether to allow missing properties on dynamic models.

Gets the base template type.

Gets the set of code inspectors.

Gets the reference resolver.

Gets the caching provider.

Gets or sets the compiler service factory.

Gets whether the template service is operating in debug mode.

Gets or sets the encoded string factory.

Gets or sets the language.

Gets or sets the collection of namespaces.

Gets the resolver.

Gets the template manager.

Defines the required contract for implementing a configuration builder.

Sets the activator.

The activator instance. The current configuration builder.

Sets the activator.

The activator type. The current configuration builder.

Sets the activator.

The activator delegate. The current configuration builder.

Adds the specified code inspector.

The code inspector type. The current configuration builder.

Adds the specified code inspector.

The code inspector. The current configuration builder.

Sets the compiler service factory.

The compiler service factory. The current configuration builder.

Sets the compiler service factory.

The compiler service factory type. The current configuration builder.

Sets the encoded string factory.

The encoded string factory. The current configuration builder.

Sets the encoded string factory.

The encoded string factory type. The current configuration builder.

Sets the resolve used to locate unknown templates.

The resolve type. The current configuration builder.

Sets the manager used to locate unknown templates.

The manager type. The current configuration builder.

Sets the resolver used to locate unknown templates.

The resolver instance to use. The current configuration builder.

Sets the manager used to locate unknown templates.

The manager instance to use. The current configuration builder.

Sets the resolver delegate used to locate unknown templates.

The resolver delegate to use. The current configuration builder.

Includes the specified namespaces

The set of namespaces to include. The current configuration builder.

The current configuration builder.

Sets the default activator.

The current configuration builder.

Sets the default compiler service factory.

The current configuration builder.

Sets the default encoded string factory.

The current configuration builder.

Sets the base template type.

The base template type. The current configuration builder/.

Sets the code language.

The code language. The current configuration builder.

Sets the encoding.

The encoding. The current configuration builder.

Defines the required contract for implementing template service configuration.

Gets the activator.

Gets or sets whether to allow missing properties on dynamic models.

Gets the base template type.

Gets the code inspectors.

Gets the reference resolver.

Gets the caching provider.

Gets the compiler service factory.

Gets whether the template service is operating in debug mode.

Gets the encoded string factory.

Gets the language.

Gets the namespaces.

Gets the template resolver.

Defines the main configuration section for the RazorEngine.

Gets the activator type.

Gets or sets whether to allow missing properties on dynamic models.

Gets the compiler service factory type.

Gets or sets the default language.

Gets the collection of namespaces.

Gets the template resolver type.

Gets the collection of template service configurations.

Gets an instance of that represents the current configuration.

An instance of , or null if no configuration is specified.

Defines a configuration of a namespace.

Gets the namespace.

Defines a collection of instances.

Creates a new for use with the collection.

The instance.

Gets a unique key for the specified element.

The configuration element. The key for the element.

Defines a configuration of a template service.

Gets the base template type.

Gets whether the template service is in debug mode.

Gets the encoded string factory type.

Gets the language.

Gets the name of the template service.

Gets the collection of namespaces.

Defines a collection of instances.

Creates a new for use with the collection.

The instance.

Gets a unique key for the specified element.

The configuration element. The key for the element.

This is a simple wrapper around an to provide an service.

Initialises a new instance of .

The resolver delegate.

Resolves the template content with the specified key.

The key of the template to resolve. The template content.

Adds a template dynamically.

the key of the template the source of the template

Gets the key for a template. See .

name of the template the type of the resolve-context the context (ie. parent template).

Represents a template service configuration that supports the xml configuration mechanism.

Initialises a new instance of .

The name of the template service configuration.

Gets the activator.

Gets or sets whether to allow missing properties on dynamic models.

Gets the base template type.

Gets the code inspectors.

Gets the reference resolver.

Gets the caching provider.

Gets the compiler service factory.

Gets whether the template service is operating in debug mode.

Gets the encoded string factory.

Gets the language.

Gets the namespaces.

Gets the template resolver.

Adds the namespaces from the specified collection.

The set of namespace configurations.

Gets an instance of the specified type.

The expected instance type. The type. The instance.

Gets the type with the specified name.

The type name.

Initialises the configuration.

The name of the template service configuration.

Initialises the configuration.

The core configuration. The service configuration.

Sets the activator.

The activator type.

Sets the base template type.

The base template type.

Sets the compiler service factory.

The compiler service factory type.

Sets the reference resolver.

The reference resolver type.

Sets the encoded string factory.

Sets the template resolver.

The template resolver type.

Sets the template manager.

The template manager type.

Provides quick access to the functionality of the class.

Quick access to RazorEngine. See .

Quick access to an isolated RazorEngine. See .

Helper for missing net40 methods, REMOVE me when we are net45 only.

Runs the given delegate in a new task (like Task.Run but works on net40).

This implementation adds ModifiedTime property to

Initializes a new instance

This value is used to check if cache is valid

An memory leaking invalidating caching provider (See ). This implementation does a very simple in-memory caching and allows you to release templates by trading with memory. File modification time is used to check if cached template is valid. WARNING: Use this caching provider only on AppDomains you recycle regularly, or to improve the debugging experience. Never use this in production without any recycle strategy.

Initializes a new instance

Try to retrieve a template from the cache. See . If cached template has different modification time, then the cache is invalidated.

An memory leaking invalidating caching provider (See ). This implementation does a very simple in-memory caching and allows you to release templates by trading with memory. WARNING: Use this caching provider only on AppDomains you recycle regularly, or to improve the debugging experience. Never use this in production without any recycle strategy.

Initializes a new instance of the class.

callback for files which need to be cleaned up.

The manages . See

Get the key used within a dictionary for a modelType.

Caches a template. See .

Invalidates the compilation of the given template with the given model-type. WARNING: leads to memory leaks

Invalidates all compilations of the given template. WARNING: leads to memory leaks

Invalidates all compilations. WARNING: leads to memory leaks

Try to retrieve a template from the cache. See .

Dispose the instance.

A wrapper around an instance to provide support for anonymous classes.

Checks if the given model-type has a reference to an anonymous type and throws.

the type to check

Checks if we need to wrap the given model in an instance and wraps it.

the model-type the original model true when we should allow missing properties on dynamic models. the original model or an wrapper object.

Provides template parsing and compilation in an isolated application domain.

A helper interface to get a custom configuration into a new AppDomain. Classes inheriting this interface should be Serializable (and not inherit from MarshalByRefObject).

Create a new configuration instance. This method should be executed in the new AppDomain.

A simple implementation to configure the and the .

Initializes a new instance

Create the configuration.

A simple implementation to use the default configuration.

Initializes a new instance

Create the configuration.

A simple sandbox helper to create the in the new .

Create the in the new .

Initializes a new instance of .

The instance to provide the configuration in the new . The application domain factory.

Creates a new instance which executes the templates in a new .

Creates an application domain.

The application domain factory. An instance of .

Releases resources used by this instance.

This method ensures the AppDomain is unloaded and any template assemblies are unloaded with it. Flag to determine whether the instance is being disposed explicitly.

Releases resources used by this instance.

Gets a given key from the implementation. See .

Checks if a given template is already cached.

Adds a given template to the template manager as dynamic template.

Compiles the specified template and caches it.

The key of the template. The model type.

Runs the given cached template. When the cache does not contain the template it will be compiled and cached beforehand.

Runs the given cached template.

A simple implementation inheriting from . This implementation assumes that the template-names are unique and returns the name as unique key. (So this implementation is used by and .

Initializes a new instance of the class.

Returns the name.

Checks if the names are equal.

Returns a hashcode for the current instance.

Defines the required contract for implementing a typed, runnable template reference.

The model type

Runs the template using the specified .

Manages the current list of assemblies, used for dynamic assembly resolution. When we compile assemblies we might have any , but once we load the template the runtime will search for it and trigger an event. We can handle the event by searching in the already used list of references, which is managed by this class.

All references we used until now.

Add references to the current list of compiler references. This member is threadsafe.

The compiler references to add.

Get the current set of instances. Note that this method returnes a copied snapshot and is therefore threadsafe. An other thread might add additional objects while we enumerate the list. But that should not matter as the event was triggered earlier.

the current list of compiler references.

Disposes the current instance.

A TemplateManager resolving remplates by path, given a list of folders to look into. Uses to save template modification time.

Initializes a new TemplateManager

the list of folders to look for templates.

Get the given key.

A TemplateManager loading templates from embedded resources.

Initializes a new TemplateManager.

The type from the assembly that contains embedded resources that will act as a root type for Assembly.GetManifestResourceStream() calls.

The type from the assembly that contains embedded resources

Resolve the given key

Get the given key.

Throws NotSupportedException.

A TemplateManager resolving templates by path, given a list of folders to look into.

Initializes a new TemplateManager.

the list of folders to look for templates.

Resolve the given key

Get the given key.

Resolve full file path using layout roots.

file name full file path

Throws NotSupportedException.

Happens when we could compile the template, but are unable to load the resulting assembly!

Initialises a new instance of .

The message.

Initialises a new instance of .

The message. The root cause.

Extensions for the .

Runs the template using the specified .

Typed, runnable template reference.

The model type

Initialises a new instance of .

Runs the template using the specified .

A ResolvePathTemplateManager which watches for changes in the filesytem and invalides the corresponding cache entries. WARNING: Use this only on AppDomains you recycle regularly, or to improve the debugging experience. Never use this in production without any recycle strategy.

Creates a new WatchingResolvePathTemplateManager.

the folders to watch and look for templates. the cache to invalidate

Resolve a template.

Gets a key for the given template.

Add a dynamic template (throws an exception)

Dispose the current manager.

Provides an that supports delegated template resolution.

Creates a new DelegateTemplateManager which throws an exception when we try to resolve something (supports dynamically adding templates).

Initialises a new instance of .

The resolver delegate.

Resolves the template content with the specified name.

The key of the template to resolve. The template content.

Dynamically add a new template.

the key of the template the source-code of the template

Use this API to remove a dynamic template. WARNING: using this API doesn't really help you if the template is already cached. So will need to invalidate the cache as well.

Creates a template-key instance (see also ).

The name of the template. the type of the resolve context. The context of the template (ie parent template). The template-key.

With a template key a template can be resolved and loaded. Implementations of this interface are provided along with the ITemplateManager implementation. See for a base implementation.

The name of the template (ie. when used in a @Include)

The layer where the template is to be resolved.

The context where the template is to be resolved (ie the parent template).

Gets a unique string which can be used as key by the caching layer.

Defines a cached template item.

Initialises a new instance of .

The cached hash code. The template type.

Gets the cached hash code of the template.

Gets the template type.

Defines a template service and the main API for running templates. Implements the interface.

Initialises a new instance of

The template service configuration.

Initialises a new instance of .

Initialises a new instance of

The code language. the encoding.

Creates a new instance.

Creates a new instance with the given configuration.

The internal core instance.

Gets the template service configuration.

Checks if a given template is already cached in the .

Adds a given template to the as dynamic template.

Releases managed resources used by this instance.

Are we explicitly disposing of this instance?

Gets an instance of a for a known encoding.

The encoding to get a factory for. An instance of

Compiles the given template, caches it and returns the result.

Compiles the specified template and caches it.

The key of the template. The model type.

Tries to resolve the template. When the cache misses we either throw an exception or compile the template. Otherwise the result is returned.

Runs the given cached template. When the cache does not contain the template it will be compiled and cached beforehand.

Runs the given cached template.

Helper method for the legacy class.

Gets a given key from the implementation. See .

A simple readonly implementation of .

The default caching provider (See ). This implementation does a very simple in-memory caching. It can handle when the same template is used with multiple model-types.

We wrap it without calling any memory leaking API.

Initializes a new instance of the class.

callback for files which need to be cleaned up.

The manages . See

Get the key used within a dictionary for a modelType.

Caches a template. See .

Try to retrieve a template from the cache. See .

Dispose the instance.

Provides a base implementation of an html template with a model.

This type does not currently serve a purpose, and the WriteAttribute* API has been migrated to the TemplateBase type. This type is not deprecated, as it may form the basis for a future template that supports MVC like @Html syntax. The model type.

Provides a default implementation of an .

Creates an instance of the specifed template.

The instance context. An instance of .

Provides a default implementation of an factory.

Creates the .

The instance.

Defines an activator that supports delegated activation.

Initialises a new instance of .

The delegated used to create an instance of the template.

Gets the activator.

Creates an instance of the specifed template.

The instance context. An instance of .

Provides an factory that supports delegated creation.

Initialises a new instance of .

The factory delegate.

Creates the .

The instance.

Provides an that supports delegated template resolution.

Initialises a new instance of .

The resolver delegate.

Resolves a template.

Defines a dynamic view bag.

Create a new DynamicViewBag.

Create a new DynamicViewBag by copying the given dictionary.

Create a copy of the given DynamicViewBag.

Add the given dictionary to the current DynamicViewBag

Adds the given dictionary to the current DynamicViewBag instance.

Add the given dictionary to the current DynamicViewBag

Adds the given list by evaluating the given property name.

Adds a single value.

Gets the set of dynamic member names.

An instance of .

Attempts to read a dynamic member from the object.

The binder. The result instance. True, always.

Attempts to set a value on the object.

The binder. The value to set. True, always.

Defines a context for tracking template execution.

Creates a new instance of ExecuteContext.

DO NOT USE, throws NotSupportedException.

Gets the current writer.

Defines a section used in layouts.

The name of the section. The delegate action used to write the section at a later stage in the template execution.

Gets the section delegate.

The name of the section. The section delegate.

Allows to pop all the section delegates for the executing action. This is required for nesting sections.

the executing section delegate. the parameter for the delegate.

Push the set of current sections to the stack.

Pops the template writer helper off the stack.

The template writer helper.

Pushes the specified template writer helper onto the stack.

The template writer helper.

Defines the required contract for implementing an activator.

Creates an instance of the specifed template.

The instance context. An instance of .

Defines the required contract for implementing an factory.

Creates the .

The instance.

This interface represents the caching layer.

Request that a given template should be cached.

The template to be cached. The key of the template.

Try to resolve a template within the cache.

the key of the template. the model-type of the template. the resolved template true if a template was found. Implementations MUST decide if they allow multiple model-types for the same template key and SHOULD throw a exception when a template is requested with the wrong type!

Every caching provider must manage a instance. This instance makes sure that all assemblies can be resolved properly.

Represents a compiled template.

The key for the template (used for resolving the source code).

The source of the template (ie the source code).

All temporary information about the compilation.

The actual Type object of the generated template.

The generated assembly of the template.

The type of the model (null = dynamic).

A internal contract for the class.

Gets the template service configuration.

Gets the encoded string factory.

Resolves the template, this is for internal use only

Adds a namespace that will be imported into the template.

The namespace to be imported.

Creates a new used to tracking templates.

The instance of

Defines contextual information for a template instance.

Initialises a new instance of .

The type loader. The template type.

Gets the type loader.

Gets the template type.

Gets the encoded string factory.

Resolves the template with the specified name.

The name of the template type in cache. The model or NULL if there is no model for the template. The resolved template.

Adds a namespace that will be imported into the template.

The namespace to be imported.

Creates a new for tracking templates.

The execute context.

Defines the required contract for implementing a template-manager.

Resolves the template with the specified key.

The key which should be resolved to a template source. The template content.

Get the key of a template. This method has to be implemented so that the manager can control the implementation. This way the cache api can rely on the unique string given by .

For example one template manager reads all template from a single folder, then the can simply return the template name. Another template manager can read from different folders depending whether we include a layout or including a template. In that situation the has to take that into account so that templates with the same name can not be confused. The name of the template how the template is resolved gets the context for the current resolve operation. Which template is resolving another template? (null = we search a global template) the key for the template

Adds a template dynamically to the current manager.

Represents a template source (ie the source code of a template).

When not null this file is used for debugging the template.

The source code of the template.

Get a reader to read the template.

Defines the required contract for implementing a template resolver.

Resolves the template content with the specified name.

The name of the template to resolve. The template content.

Defines the required contract for implementing a template service.

Gets the template service configuration.

Gets the encoded string factory.

Adds a namespace that will be imported into the template.

The namespace to be imported.

Creates a new used to tracking templates.

This parameter is ignored, set the Viewbag with template.SetData(null, viewBag) The instance of

Compiles the specified template.

The string template. The model type. The name of the template.

Create a template from the given razor code.

the string template the type of the template the model.

Create a sequence of templates

the templates the types the models run in parallel?

Backwards Compat

Get a given template (compiles the templates if not cached already)

See GetTemplate.

Returns whether or not a template by the specified name has been created already.

The name of the template. Whether or not the template has been created.

Remove a template by the specified name from the cache.

The name of the template type in cache. Whether or not the template has been removed.

Parses and returns the result of the specified string template.

The string template. The model instance or NULL if no model exists. The ViewBag initial contents or NULL for an initially empty ViewBag. The name of the template type in the cache or NULL if no caching is desired. The string result of the template.

Parses and returns the result of the specified string template.

Type of the model. Used to find out the type of the model, if model is NULL The string template. The model instance or NULL if no model exists. The ViewBag initial contents or NULL for an initially empty ViewBag. The name of the template type in the cache or NULL if no caching is desired. The string result of the template.

Parses the specified set of templates.

The set of string templates to partse. The set of models. The set of cache names. Flag to determine whether parsing in templates. The set of parsed template results.

Resolves the template with the specified name.

The name of the template. The model for the template. The resolved template.

Runs the template with the specified name.

The name of the template. The model. the viewbag The string result of the template.

Runs the specified name.

The template. The viewbag. The string result of the template.

Defines a template service.

Initialises a new instance of

The template service configuration.

Initialises a new instance of .

Initialises a new instance of

The code language. the encoding.

Gets the template service configuration.

Gets the encoded string factory.

Creates a new for creating template instances.

The template type. An instance of .

Adds a namespace that will be imported into the template.

The namespace to be imported.

Compiles the specified template.

The string template. The model type. The name of the template.

Creates a ExecuteContext

Creates an instance of from the specified string template.

The string template. type used in the compilation. The model instance. An instance of .

Creates a set of templates from the specified string templates and models.

The set of templates to create instances for. The set of models used to assign to templates. Flag to determine whether to create templates in parallel. the mode types. The enumerable set of template instances.

Creates a that can be used to instantiate an instance of a template.

The string template. The model type. An instance of .

Creates a set of template types from the specfied string templates.

The set of templates to create instances for. The modeltypes Flag to determine whether to create template types in parallel. The set of instances.

Releases managed resources used by this instance.

Are we explicitly disposing of this instance?

Gets an instance of a for a known encoding.

The encoding to get a factory for. An instance of

Gets a parellel query plan used to configure a parallel query.

The query item type. An instance of .

Gets an instance of the template using the cached compiled type, or compiles the template type if it does not exist in the cache.

The string template. The model instance. The name of the template type in the cache. An instance of .

Gets an instance of the template using the cached compiled type, or compiles the template type if it does not exist in the cache.

The model type. The string template. The model instance. The name of the template type in the cache. An instance of .

Gets the set of template instances for the specified string templates. Cached templates will be considered and if they do not exist, new types will be created and instantiated.

The set of templates to create. The set of models. The set of cache names. Flag to determine whether to get the templates in parallel. The set of instances.

Parses and returns the result of the specified string template.

The string template. The model instance. The viewbag. The cacheName. The string result of the template.

Parses and returns the result of the specified string template.

The string template. The model instance or NULL if no model exists. The ViewBag contents or NULL for an initially empty ViewBag. The name of the template type in the cache or NULL if no caching is desired. The string result of the template.

Parses the specified set of templates.

The set of string templates to parse. The set of models. The viewbags The set of cache names. Flag to determine whether parsing in parallel. The set of parsed template results.

Returns whether or not a template by the specified name has been created already.

The name of the template. Whether or not the template has been created.

NOT SUPPORTED.

Resolves the template with the specified name.

The name of the template. The model for the template. The resolved template.

Runs the template with the specified name.

The name of the template. The model. The viewBag. The string result of the template.

Runs the template with the specified name.

The template. The viewbag. The string result of the template.

A simple implementation inheriting from . This implementation assumes that the template-names are unique and returns the name as unique key. (So this implementation is used by and .

Initializes a new instance of the class.

Returns the name.

Checks if the names are equal.

Returns a hashcode for the current instance.

Represents a default parallel query plan.

The uses the default result. The degree of parallelism by default is Math.Min(ProcessorCount, 64). The item type.

Creates a parallel query for the specified source.

The source enumerable. The parallel query.

Defines the required contract for implementing a parallel query plan.

The item type.

Creates a parallel query for the specified source.

The source enumerable. The parallel query.

Provides template parsing and compilation in an isolated application domain.

Initialises a new instance of

The code language.

Initialises a new instance of

The encoding.

Initialises a new instance of

The application domain factory.

Initialises a new instance of .

The delegate used to create an application domain.

Initialises a new instance of

The code language. The encoding. The application domain factory.

Initialises a new instance of .

The code language. The delegate used to create an application domain.

Initialises a new instance of .

The code language. The encoding. The delegate used to create an application domain.

Initialises a new instance of .

The encoding. The delegate used to create an application domain.

Gets the template service configuration.

Gets the encoded string factory.

Adds a namespace that will be imported into the template.

The namespace to be imported.

Creates a new used to tracking templates.

This parameter is ignored, set the Viewbag with template.SetData(null, viewBag) The instance of

Compiles the specified template.

The string template. The model type. The name of the template.

Creates an application domain.

The application domain factory. An instance of .

Releases resources used by this instance.

This method ensures the AppDomain is unloaded and any template assemblies are unloaded with it. Flag to determine whether the instance is being disposed explicitly.

Releases resources used by this instance.

Gets an instance of the template using the cached compiled type, or compiles the template type if it does not exist in the cache.

The model type. The string template. The model instance. The name of the template type in the cache. An instance of .

Returns whether or not a template by the specified name has been created already.

The name of the template. Whether or not the template has been created.

Remove a template by the specified name from the cache.

The name of the template type in cache. Whether or not the template has been removed.

Parses and returns the result of the specified string template.

Resolves the template with the specified name.

The name of the template. The model for the template. The resolved template.

Backwards Compat

Backwards compat

Backwards compat.

Backwards compat

Backwards compat.

Defines the required contract for implementing a template.

Sets the internal template service.

OBSOLETE: Sets the template service.

Sets the cached template service.

Set the model of the template (if applicable).

Executes the compiled template.

Runs the template and returns the result.

The current execution context. The merged result of the template.

Writes the specified object to the result.

The value to write.

Writes the specified string to the result.

The literal to write.

Defines the required contract for implementing a template with a model.

The model type.

Gets the or sets the model.

Defines the required contract for implementing a template service. The main API for running templates.

Gets a given key from the implementation. See .

Checks if a given template is already cached.

Adds a given template to the template manager as dynamic template.

Compiles the specified template and caches it.

The key of the template. The model type.

Runs the given cached template. When the cache does not contain the template it will be compiled and cached beforehand.

Runs the given cached template.

Allows base templates to define require template imports when generating templates.

Initialises a new instance of .

The set of required namespace imports.

Gets the set of required namespace imports.

The type of a resolve action.

When we search for a template in as part of TemplateService.

When we search for a template which is included.

When we search for a layout template.

Provides a base implementation of a template. NOTE: This class is not serializable to prevent subtle errors in user IActivator implementations which would break the sandbox. (because executed in the wrong )

Because the old API (TemplateService) is designed in a way to make it impossible to init the model and the Viewbag at the same time (and because of backwards compatibility), we need to call the SetData method twice (only from within TemplateService so we can remove this bool once that has been removed). But the secound call we only need to set the Viewbag, therefore we save the state in this bool.

The current context, filled when we are currently writing a template instance.

Initialises a new instance of .

Gets or sets the layout template name.

Gets or sets the template service.

Gets or sets the current instance.

Gets the viewbag that allows sharing state between layout and child templates.

Gets the current writer.

Set the data for this template.

the model object for the current run. the viewbag for the current run.

Set the current model.

Defines a section that can written out to a layout.

The name of the section. The delegate used to write the section.

Includes the template with the specified name.

The name of the template type in cache. The model or NULL if there is no model for the template. The template writer helper.

Determines if the section with the specified name has been defined.

The section name.

Executes the compiled template.

Returns the specified string as a raw string. This will ensure it is not encoded.

The raw string to write. An instance of .

Resolves the layout template.

The name of the layout template. An instance of .

Runs the template and returns the result.

The current execution context. The merged result of the template.

Renders the section with the specified name.

The name of the section. Flag to specify whether the section is required. The template writer helper.

Renders the body of the template.

The template writer helper.

Writes the specified object to the result.

The value to write.

Writes the specified template helper result.

The template writer helper.

Writes an attribute to the result.

The name of the attribute.

Writes an attribute to the specified .

The writer. The name of the attribute to be written.

Writes the specified string to the result.

The literal to write.

Writes a string literal to the specified .

The writer. The literal to be written.

Writes a literal to the result.

The writer. The literal to be written.

Writes the specified object to the specified .

The writer. The value to be written.

Writes the specfied template helper result to the specified writer.

The writer. The template writer helper.

Resolves the specified path

The path. The resolved path.

Provides a base implementation of a template with a model.

The model type.

Initialises a new instance of .

Determines whether this template has a dynamic model.

Gets or sets the model.

Set the model.

Includes the template with the specified name.

The name of the template type in cache. The model or NULL if there is no model for the template. The template writer helper.

Includes the template with the specified name.

The name of the template type in cache. The model or NULL if there is no model for the template. The template writer helper.

Includes the template with the specified name, uses the current model and model-type.

The name of the template type in cache. The template writer helper.

Resolves the layout template.

The name of the layout template. An instance of .

Defines a compiler error.

The error text of the error.

The file name of the error source.

The line number of the error location

The column number of the error location.

The number of the error.

Indicates whether the error is a warning.

Creates a new Compiler error instance.

Defines an exception that occurs during compilation of the template.

Gets a exact error message of the given error collection

Initialises a new instance of .

The set of compiler errors. The source code that wasn't compiled. The source template that wasn't compiled.

Initialises a new instance of from serialised data.

The serialisation info. The streaming context.

Gets the set of compiler errors.

Gets some copilation specific (temporary) data.

Gets the generated source code.

Gets the source template that wasn't compiled.

Gets the object data for serialisation.

The serialisation info. The streaming context.

A base implementation for . You only need to provide the implementation which depends on the implementation.

See .

Create a new instance.

See See See

See .

Extensions for the .

Checks if a given template is already cached.

Adds a given template to the template manager as dynamic template.

See .

See . Convenience method which calls before calling .

See .

See . Convenience method which calls before calling .

Helper method to provide a TextWriter and return the written data.

See . Convenience method which creates a and returns the result as string.

See . Convenience method which calls before calling . Convenience method which creates a and returns the result as string.

See .

See . Convenience method which creates a and returns the result as string.

Adds and compiles a new template using the specified and returns a .

The model type

Adds and compiles a new template using the specified and returns a .

The model type

A simple implementation which represents an in-memory string.

Initializes a new instance.

The in-memory template sourcecode.

The template file or null if none exists.

Creates a new to read the in-memory stream.

Defines a type loader.

Initialises a new instance of

The application domain. The set of assemblies.

Creates an instance of the specified type.

The type to create. An instance of the type.

Releases resources used by this instance.

Flag to determine whether this instance is being disposed of explicitly.

Releases resources used by this reference.

Gets the delegate used to create an instance of the template type. This method will consider the cached constructor delegate before creating an instance of one.

The template type. The delegate instance.

Gets the delegate used to create an instance of the template type.

The template type. The delegate instance.

Resolves the assembly with the specified name.

The name of the assembly. The assembly instance, or null.

Defines an exception that occurs during template parsing.

Initialises a new instance of .

The error message generated by the parser. The character index of the error. The line index of the error.

Initialises a new instance of from serialised data.

The serialisation info. The streaming context.

Gets the column the parsing error occured.

Gets the line the parsing error occured.

Gets the object data for serialisation.

The serialisation info. The streaming context.

We need this for creating the templates.

Creates a new for tracking templates.

The execute context.

Gets the template service configuration.

Compiles the specified template.

The string template. The model type.

Creates an instance of from the specified string template.

The compiled template. The model instance or NULL if no model exists. An instance of .

Creates a that can be used to instantiate an instance of a template.

The string template. The model type or NULL if no model exists. An instance of .

Runs the specified template and returns the result.

The template to run. The ViewBag contents or NULL for an initially empty ViewBag. The string result of the template.

Creates a new for creating template instances.

The template type. An instance of .

Disposes the current instance.

Defines a template writer used for helper templates.

Initialises a new instance of .

The writer delegate used to write using the specified .

Executes the write delegate and returns the result of this .

The string result of the helper template.

Writes the helper result of the specified text writer.

The text writer to write the helper result to.

Defines the possible values for encoding.

Use html encoding.

Use raw text (no encoding)

Defines the possible supported code languages.

C# Language

Visual Basic Language

PositionTagged

Creates a new PositionTagged instance

The position.

The value.

Checks if the given object equals the current object.

Calculates a hash-code for the current instance.

Returns Value.ToString().

convert implicitely to the value.

Convert from a tuple.

Checks if the given instances are equal.

Checks if the given instances are not equal.

Provides quick access to template functions.

Gets the template service.

Compiles the specified template.

The string template. The name of the template.

Compiles the specified template.

The string template. The model type. The name of the template.

Compiles the specified template.

The model type. The string template. The name of the template.

Creates an instance of from the specified string template.

The string template. An instance of .

Creates an instance of from the specified string template.

The model type. The string template. The model instance. An instance of .

Creates a set of templates from the specified string templates.

The set of templates to create instances for. Flag to determine whether to create templates in parallel. The enumerable set of template instances.

Creates a set of templates from the specified string templates and models.

The model type. The set of templates to create instances for. The set of models used to assign to templates. Flag to determine whether to create templates in parallel. The enumerable set of template instances.

Creates a that can be used to instantiate an instance of a template.

The string template. An instance of .

Creates a that can be used to instantiate an instance of a template.

The string template. The model type. An instance of .

Crates a set of template types from the specfied string templates.

The set of templates to create instances for. Flag to determine whether to create template types in parallel. The set of instances.

Creates a set of template types from the specfied string templates.

The set of templates to create instances for. The model type. Flag to determine whether to create template types in parallel. The set of instances.

Gets an instance of the template using the cached compiled type, or compiles the template type if it does not exist in the cache.

The string template. The name of the template type in the cache. An instance of .

Gets an instance of the template using the cached compiled type, or compiles the template type if it does not exist in the cache.

The model type. The string template. The model instance. The name of the template type in the cache. An instance of .

Gets the set of template instances for the specified string templates. Cached templates will be considered and if they do not exist, new types will be created and instantiated.

The set of templates to create. The set of cache names. Flag to determine whether to get the templates in parallel. The set of instances.

Gets the set of template instances for the specified string templates. Cached templates will be considered and if they do not exist, new types will be created and instantiated.

The model type. The set of templates to create. The set of models. The set of cache names. Flag to determine whether to get the templates in parallel. The set of instances.

Parses and returns the result of the specified string template.

The string template. The string result of the template.

Parses and returns the result of the specified string template. This method will provide a cache check to see if the compiled template type already exists and is valid.

The string template. The name of the cached template type. The string result of the template.

Parses and returns the result of the specified string template.

The string template. The model instance. The string result of the template.

Parses and returns the result of the specified string template.

The model type. The string template. The model instance. The string result of the template.

Parses and returns the result of the specified string template.

The model type. The string template. The model instance. The name of the template type in the cache. The string result of the template.

Backwards Compat

Parses and returns the result of the specified string template.

The string template. The model instance. The name of the template type in the cache. The string result of the template.

Backwards Compat

Parses the specified set of templates.

The set of string templates to partse. Flag to determine whether parsing in templates. The set of parsed template results.

Parses the specified set of templates.

The set of string templates to partse. The set of cache names. Flag to determine whether parsing in templates. The set of parsed template results.

Parses the template and merges with the many models provided.

The model type. The razor template. The set of models. Flag to determine whether parsing in parallel. The set of parsed template results.

Parses the specified set of templates.

The model type. The set of string templates to partse. The set of models. Flag to determine whether parsing in templates. The set of parsed template results.

Parses the specified set of templates.

The model type. The set of string templates to partse. The set of models. The set of cache names. Flag to determine whether parsing in templates. The set of parsed template results.

Resolves the template with the specified name.

The name of the template. The resolved template.

Resolves the template with the specified name.

The name of the template. The model for the template. The resolved template.

Resolves the template with the specified name.

The name of the template. The model for the template. The resolved template.

Runs the template with the specified name.

The name of the template. The string result of the template.

Runs the template with the specified name.

The name of the template. The model. The string result of the template.

Runs the template with the specified name.

The model type. The name of the template. The model. The string result of the template.

Sets the template service.

The template service.

Represents a Html-encoded string.

Initialises a new instance of

The raw string to be encoded.

Gets the encoded string.

The encoded string.

Gets the string representation of this instance.

The string representation of this instance.

Represents a factory that creates instances.

Creates a instance for the specified raw string.

The raw string. An instance of .

Creates a instance for the specified object instance.

The object instance. An instance of .

Defines the required contract for implementing an encoded string.

Gets the encoded string.

The encoded string.

Defines the required contract for implementing a factory for building encoded strings.

Creates a instance for the specified raw string.

The raw string. An instance of .

Creates a instance for the specified object instance.

The object instance. An instance of .

Represents an unencoded string.

Initialises a new instance of

The value

Gets the encoded string.

The encoded string.

Gets the string representation of this instance.

The string representation of this instance.

Represents a factory that creates instances.

Creates a instance for the specified raw string.

Thevalue. An instance of .

Creates a instance for the specified object instance.

The value. An instance of .