/// <summary>
/// Parses and returns the result of the specified string template.
/// </summary>
/// <param name="razorTemplate">The string template.</param>
/// <param name="model">The model instance or NULL if no model exists.</param>
/// <param name="viewBag">The ViewBag contents or NULL for an initially empty ViewBag.</param>
/// <param name="cacheName">The name of the template type in the cache or NULL if no caching is desired.</param>
/// <returns>The string result of the template.</returns>
public string Parse <T>(string razorTemplate, object model, DynamicViewBag viewBag, string cacheName)
{
if (disposed)
{
throw new ObjectDisposedException("IsolatedTemplateService");
}
if (model != null)
{
if (CompilerServicesUtility.IsDynamicType(model.GetType()))
{
throw new ArgumentException("IsolatedTemplateService instances do not support anonymous or dynamic types.");
}
}
return(_proxy.Parse <T>(razorTemplate, model, viewBag, cacheName));
}
/// <summary>
/// Creates an instance of <see cref="ITemplate{T}"/> from the specified string template.
/// </summary>
/// <param name="razorTemplate">
/// The string template.
/// If templateType is not NULL, this parameter may be NULL (unused).
/// </param>
/// <param name="templateType">
/// The template type or NULL if the template type should be dynamically created.
/// If razorTemplate is not NULL, this parameter may be NULL (unused).
/// </param>
/// <param name="model">The model instance or NULL if no model exists.</param>
/// <returns>An instance of <see cref="ITemplate{T}"/>.</returns>
public ITemplate CreateTemplate(string razorTemplate, Type templateType, object model)
{
if (disposed)
{
throw new ObjectDisposedException("IsolatedTemplateService");
}
if (model != null)
{
if (CompilerServicesUtility.IsDynamicType(model.GetType()))
{
throw new ArgumentException("IsolatedTemplateService instances do not support anonymous or dynamic types.");
}
}
return(_proxy.CreateTemplate(razorTemplate, templateType, model));
}
public IEnumerable <CompilerReference> GetReferences(TypeContext context, IEnumerable <CompilerReference> includeAssemblies = null)
{
var allAssembly = CompilerServicesUtility
.GetLoadedAssemblies();
var AssemblyToReference = allAssembly
.Where(a => !a.IsDynamic && File.Exists(a.Location) && !a.Location.Contains("CompiledRazorTemplates.Dynamic") && a.FullName.IndexOf("System.Web.Helpers") < 0) //(CompilerServiceBase.DynamicTemplateNamespace))
.GroupBy(a => a.GetName().Name).Select(grp => grp.First(y => y.GetName().Version == grp.Max(x => x.GetName().Version))) // only select distinct assemblies based on FullName to avoid loading duplicate assemblies
.Select(a => CompilerReference.From(a))
.Concat(includeAssemblies ?? Enumerable.Empty <CompilerReference>());
yield return(CompilerReference.From(HostingEnvironment.ApplicationPhysicalPath + @"Modules\Laser.Orchard.StartupConfig\bin\System.Web.Helpers.dll"));
foreach (var assembly in AssemblyToReference)
{
yield return(assembly);
}
}
/// <summary>
/// Checks if we need to wrap the given model in
/// an <see cref="RazorDynamicObject"/> instance and wraps it.
/// </summary>
/// <param name="modelType">the model-type</param>
/// <param name="original">the original model</param>
/// <param name="allowMissing">true when we should allow missing properties on dynamic models.</param>
/// <returns>the original model or an wrapper object.</returns>
internal static object GetDynamicModel(Type modelType, object original, bool allowMissing)
{
object result = original;
if (modelType == null && original != null)
{
// We try to make some things work:
if (CompilerServicesUtility.IsAnonymousTypeRecursive(original.GetType()))
{
// TODO: we should handle Configuration.AllowMissingPropertiesOnDynamic
result = RazorDynamicObject.Create(original, allowMissing);
}
else if (allowMissing)
{
result = RazorDynamicObject.Create(original, allowMissing);
}
}
return(result);
}
/// <summary>
/// See <see cref="IReferenceResolver.GetReferences(TypeContext,IEnumerable{CompilerReference})" />
/// </summary>
/// <param name="context"></param>
/// <param name="includeAssemblies"></param>
/// <returns></returns>
public IEnumerable <CompilerReference> GetReferences(
TypeContext context = null,
IEnumerable <CompilerReference> includeAssemblies = null)
{
return(CompilerServicesUtility.GetLoadedAssemblies()
.Where(
a =>
{
if (!a.IsDynamic && File.Exists(a.Location))
{
return !a.Location.Contains("CompiledRazorTemplates.Dynamic");
}
return false;
})
.GroupBy(a => a.GetName().Name)
.Select(grp => grp.First(y => y.GetName().Version == grp.Max(x => x.GetName().Version)))
.Select(CompilerReference.From)
.Concat(includeAssemblies ?? Enumerable.Empty <CompilerReference>()));
}
/// <summary>
/// Creates a set of template types from the specfied string templates.
/// </summary>
/// <param name="razorTemplates">The set of templates to create <see cref="Type"/> instances for.</param>
/// <param name="modelTypes">
/// The set of model types or NULL if no models exist for all templates.
/// Individual elements in this set may be NULL if no model exists for a specific template.
/// </param>
/// <param name="parallel">Flag to determine whether to create template types in parallel.</param>
/// <returns>The set of <see cref="Type"/> instances.</returns>
public IEnumerable <Type> CreateTemplateTypes(IEnumerable <string> razorTemplates, IEnumerable <Type> modelTypes, bool parallel = false)
{
if (disposed)
{
throw new ObjectDisposedException("IsolatedTemplateService");
}
if (modelTypes != null)
{
foreach (Type modelType in modelTypes)
{
if ((modelType != null) && CompilerServicesUtility.IsDynamicType(modelType))
{
throw new ArgumentException("IsolatedTemplateService instances do not support anonymous or dynamic types.");
}
}
}
return(_proxy.CreateTemplateTypes(razorTemplates, modelTypes, parallel));
}
private Tuple <object, Type> CheckModel(object model)
{
if (model == null)
{
return(Tuple.Create((object)null, (Type)null));
}
Type modelType = (model == null) ? typeof(object) : model.GetType();
bool isAnon = CompilerServicesUtility.IsAnonymousTypeRecursive(modelType);
if (isAnon ||
CompilerServicesUtility.IsDynamicType(modelType))
{
modelType = null;
if (isAnon || Configuration.AllowMissingPropertiesOnDynamic)
{
model = RazorDynamicObject.Create(model, Configuration.AllowMissingPropertiesOnDynamic);
}
}
return(Tuple.Create(model, modelType));
}
static void LoadMetadataReference()
{
Tools.MapPath("");
Tools.GetId();
string replstr = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "file:///" : "file://";
var assemblies = CompilerServicesUtility
.GetLoadedAssemblies()
.Where(a => !a.IsDynamic && File.Exists(a.CodeBase.Replace(replstr, "")))
.Select(a => (a.CodeBase.Replace(replstr, "")));
int c = assemblies.Count();
Constant.BaseNamespaces = new MetadataReference[c];
int i = 0;
foreach (string item in assemblies)
{
Constant.BaseNamespaces[i] = (MetadataReference.CreateFromFile(item));
i++;
}
}
/// <summary>
/// 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.
/// </summary>
/// <param name="razorTemplates">The set of templates to create.</param>
/// <param name="models">
/// The set of models or NULL if no models exist for all templates.
/// Individual elements in this set may be NULL if no model exists for a specific template.
/// </param>
/// <param name="cacheNames">The set of cache names.</param>
/// <param name="parallel">Flag to determine whether to get the templates in parallel.</param>
/// <returns>The set of <see cref="ITemplate"/> instances.</returns>
public IEnumerable <ITemplate> GetTemplates(IEnumerable <string> razorTemplates, IEnumerable <object> models, IEnumerable <string> cacheNames, bool parallel = false)
{
if (disposed)
{
throw new ObjectDisposedException("IsolatedTemplateService");
}
if (models != null)
{
foreach (object model in models)
{
if (model != null)
{
if (CompilerServicesUtility.IsDynamicType(model.GetType()))
{
throw new ArgumentException("IsolatedTemplateService instances do not support anonymous or dynamic types.");
}
}
}
}
return(_proxy.GetTemplates(razorTemplates, models, cacheNames, parallel));
}
private SpanCodeGenerator CreateModelCodeGenerator(string model)
{
return(new SetModelTypeCodeGenerator(model, (templateType, modelTypeName) => {
return CompilerServicesUtility.CSharpCreateGenericType(templateType, modelTypeName, true);
}));
}
/// <summary>
/// Builds a type name for the specified generic type.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="isDynamic">Specifies whether the type is dynamic.</param>
/// <returns>
/// The string typename (including namespace and generic type parameters).
/// </returns>
public override string BuildTypeNameInternal(Type type, bool isDynamic)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (!type.IsGenericType)
{
return(type.FullName);
}
return(type.Namespace
+ "."
+ type.Name.Substring(0, type.Name.IndexOf('`'))
+ "(Of "
+ (isDynamic ? "Object" : string.Join(", ", type.GetGenericArguments().Select(t => BuildTypeNameInternal(t, CompilerServicesUtility.IsDynamicType(t)))))
+ ")");
}
public void CompilerServiceUtility_CheckNormalGenericClass()
{
var result = CompilerServicesUtility.CSharpGetRawTypeName(typeof(AddLanguageInfo_Viewbag <>));
Assert.AreEqual("Test.RazorEngine.TestTypes.BaseTypes.AddLanguageInfo_Viewbag", result);
}
public void CompilerServiceUtility_CheckNestedClass()
{
var result = CompilerServicesUtility.CSharpGetRawTypeName(typeof(HostingClass.NestedBaseClass <>));
Assert.AreEqual("Test.RazorEngine.TestTypes.BaseTypes.HostingClass.NestedBaseClass", result);
}
public void CompilerServiceUtility_CheckNonGenericNestedType()
{
var result = CompilerServicesUtility.ResolveCSharpTypeName(typeof(HostingClass.NestedClass));
Assert.AreEqual("Test.RazorEngine.TestTypes.BaseTypes.HostingClass.NestedClass", result);
}
public void CompilerServiceUtility_CheckNonGenericType()
{
var result = CompilerServicesUtility.ResolveCSharpTypeName(typeof(System.String));
Assert.AreEqual("System.String", result);
}
public void CompilerServiceUtility_CheckDynamicType()
{
var result = CompilerServicesUtility.ResolveCSharpTypeName(typeof(System.Dynamic.DynamicObject));
Assert.AreEqual("dynamic", result);
}
