public virtual OutputCacheParameters GetOutputCacheParameters()
{
OutputCacheParameters parameters = new OutputCacheParameters();
parameters.CacheProfile = cacheProfile;
parameters.Duration = duration;
if (context.CurrentPage != null && context.CurrentPage.Expires.HasValue)
{
DateTime expires = context.CurrentPage.Expires.Value;
if (expires > N2.Utility.CurrentTime() && expires < N2.Utility.CurrentTime().AddSeconds(parameters.Duration))
{
parameters.Duration = (int)expires.Subtract(N2.Utility.CurrentTime()).TotalSeconds;
}
}
parameters.Enabled = Enabled;
parameters.Location = OutputCacheLocation.Server;
if (!string.IsNullOrEmpty(varyByHeader))
{
parameters.VaryByHeader = varyByHeader;
}
if (!string.IsNullOrEmpty(varyByCustom))
{
parameters.VaryByCustom = varyByCustom;
}
parameters.VaryByParam = varyByParam;
return(parameters);
}
protected override void GenerateClassAttributes()
{
base.GenerateClassAttributes();
if ((base._sourceDataClass != null) && (this.Parser.OutputCacheParameters != null))
{
OutputCacheParameters outputCacheParameters = this.Parser.OutputCacheParameters;
if (outputCacheParameters.Duration > 0)
{
CodeAttributeDeclaration declaration = new CodeAttributeDeclaration("System.Web.UI.PartialCachingAttribute");
CodeAttributeArgument argument = new CodeAttributeArgument(new CodePrimitiveExpression(outputCacheParameters.Duration));
declaration.Arguments.Add(argument);
argument = new CodeAttributeArgument(new CodePrimitiveExpression(outputCacheParameters.VaryByParam));
declaration.Arguments.Add(argument);
argument = new CodeAttributeArgument(new CodePrimitiveExpression(outputCacheParameters.VaryByControl));
declaration.Arguments.Add(argument);
argument = new CodeAttributeArgument(new CodePrimitiveExpression(outputCacheParameters.VaryByCustom));
declaration.Arguments.Add(argument);
argument = new CodeAttributeArgument(new CodePrimitiveExpression(outputCacheParameters.SqlDependency));
declaration.Arguments.Add(argument);
argument = new CodeAttributeArgument(new CodePrimitiveExpression(this.Parser.FSharedPartialCaching));
declaration.Arguments.Add(argument);
if (MultiTargetingUtil.IsTargetFramework40OrAbove)
{
argument = new CodeAttributeArgument("ProviderName", new CodePrimitiveExpression(this.Parser.Provider));
declaration.Arguments.Add(argument);
}
base._sourceDataClass.CustomAttributes.Add(declaration);
}
}
}
public void Test_OutputCacheAttribute()
{
OutputCacheAttribute a = new OutputCacheAttribute();
a.CacheProfile = "_CacheProfile";
a.Duration = 2;
a.Location = OutputCacheLocation.Server;
a.NoStore = true;
a.SqlDependency = "_SqlDependency";
a.VaryByContentEncoding = "_VaryByContentEncoding";
a.VaryByCustom = "_VaryByCustom";
a.VaryByHeader = "_VaryByHeader";
a.VaryByParam = "_VaryByParam";
OutputCacheParameters settings = a.CacheSettings;
Assert.AreEqual(2, settings.Duration);
string requestText = @"
GET http://www.fish-web-demo.com/Pages/Demo/Authorize/Everyone.aspx HTTP/1.1
";
using (WebContext context = WebContext.FromRawText(requestText)) {
try {
a.SetResponseCache(context.HttpContext);
}
catch { }
// 这里不太容易做断言，只能看一下代码有没有覆盖。
}
}
public void ProcessRequest(HttpContext context)
{
var physicalFileName = context.Server.MapPath(context.Request.FilePath);
var dependentFiles = GetFileDependencies(physicalFileName) ?? Enumerable.Empty <string>();
dependentFiles = dependentFiles.Concat(new[] { physicalFileName }); // ensure this file is included
context.Response.AddCacheDependency(new CacheDependency(dependentFiles.ToArray()));
Render(physicalFileName, context.Response.Output);
// Process with caching ()
OutputCacheParameters cacheParams = getCacheParams();
using (OutputCachedPage page = new OutputCachedPage(cacheParams))
{
page.ProcessRequest(context);
}
// has to be done here as Page seems to overwrite it.
context.Response.ContentType = ContentType;
var cache = context.Response.Cache;
cache.SetLastModifiedFromFileDependencies();
cache.SetOmitVaryStar(true); // Old IE stops caching if it gets a "Vary: *" header
}
internal BuildResultNoCompilePage(Type baseType, TemplateParser parser) : base(baseType, parser)
{
PageParser parser2 = (PageParser)parser;
this._traceEnabled = parser2.TraceEnabled;
this._traceMode = parser2.TraceMode;
if (parser2.OutputCacheParameters != null)
{
this._outputCacheData = parser2.OutputCacheParameters;
if ((this._outputCacheData.Duration == 0) || (this._outputCacheData.Location == OutputCacheLocation.None))
{
this._outputCacheData = null;
}
else
{
this._fileDependencies = new string[parser2.SourceDependencies.Count];
int num = 0;
foreach (string str in (IEnumerable)parser2.SourceDependencies)
{
this._fileDependencies[num++] = str;
}
}
}
this._validateRequest = parser2.ValidateRequest;
this._stylesheetTheme = parser2.StyleSheetTheme;
}
protected ActionResult CacheableView(string viewName, Query.Query query, Func <ModelCollection> modelAccessor, Action <OutputCacheParameters> changeSettings)
{
if (query.IsCacheable)
{
var settings = new OutputCacheParameters
{
Duration = query.CacheDuration,
VaryByParam = null,
VaryByContentEncoding = null,
VaryByControl = null,
VaryByCustom = null,
VaryByHeader = null
};
changeSettings(settings);
return(new CacheableViewResult
{
ViewName = viewName,
ViewData = ViewData,
TempData = TempData,
ModelAccessor = modelAccessor,
CacheSettings = settings
});
}
return(View(viewName, modelAccessor()));
}
public virtual OutputCacheParameters GetOutputCacheParameters()
{
OutputCacheParameters parameters = new OutputCacheParameters();
parameters.CacheProfile = cacheProfile;
parameters.Duration = duration;
if (context.CurrentPage != null && context.CurrentPage.Expires.HasValue)
{
DateTime expires = context.CurrentPage.Expires.Value;
if (expires > N2.Utility.CurrentTime() && expires < N2.Utility.CurrentTime().AddSeconds(parameters.Duration))
{
parameters.Duration = (int)expires.Subtract(N2.Utility.CurrentTime()).TotalSeconds;
}
}
parameters.Enabled = enabled;
parameters.Location = OutputCacheLocation.Server;
//parameters.NoStore = NoStore;
//parameters.SqlDependency = SqlDependency;
//parameters.VaryByContentEncoding = VaryByContentEncoding;
//parameters.VaryByControl = VaryByControl;
//parameters.VaryByCustom = VaryByCustom;
//parameters.VaryByHeader = VaryByHeader;
parameters.VaryByParam = varyByParam;
return(parameters);
}
public void CacheSettingsProperty()
{
// Arrange
OutputCacheAttribute attr = new OutputCacheAttribute()
{
CacheProfile = "SomeProfile",
Duration = 50,
Location = OutputCacheLocation.Downstream,
NoStore = true,
SqlDependency = "SomeSqlDependency",
VaryByContentEncoding = "SomeContentEncoding",
VaryByCustom = "SomeCustom",
VaryByHeader = "SomeHeader",
VaryByParam = "SomeParam",
};
// Act
OutputCacheParameters cacheSettings = attr.CacheSettings;
// Assert
Assert.Equal("SomeProfile", cacheSettings.CacheProfile);
Assert.Equal(50, cacheSettings.Duration);
Assert.Equal(OutputCacheLocation.Downstream, cacheSettings.Location);
Assert.Equal(true, cacheSettings.NoStore);
Assert.Equal("SomeSqlDependency", cacheSettings.SqlDependency);
Assert.Equal("SomeContentEncoding", cacheSettings.VaryByContentEncoding);
Assert.Equal("SomeCustom", cacheSettings.VaryByCustom);
Assert.Equal("SomeHeader", cacheSettings.VaryByHeader);
Assert.Equal("SomeParam", cacheSettings.VaryByParam);
}
public static void InitOutputCache(ICacheManager cacheManager, HttpContext context)
{
if (!cacheManager.Enabled)
{
return;
}
OutputCacheParameters cacheSettings = cacheManager.GetOutputCacheParameters();
}
internal BuildResultNoCompileUserControl(Type baseType, TemplateParser parser) : base(baseType, parser)
{
UserControlParser parser2 = (UserControlParser)parser;
OutputCacheParameters outputCacheParameters = parser2.OutputCacheParameters;
if ((outputCacheParameters != null) && (outputCacheParameters.Duration > 0))
{
this._cachingAttribute = new PartialCachingAttribute(outputCacheParameters.Duration, outputCacheParameters.VaryByParam, outputCacheParameters.VaryByControl, outputCacheParameters.VaryByCustom, outputCacheParameters.SqlDependency, parser2.FSharedPartialCaching);
this._cachingAttribute.ProviderName = parser2.Provider;
}
}
public void InitialValues()
{
OutputCacheParameters o = new OutputCacheParameters();
Assert.IsNull(o.CacheProfile, "CacheProfile");
Assert.IsTrue(o.Duration == 0, "Duration");
Assert.IsTrue(o.Enabled, "Enabled");
Assert.IsTrue(o.Location == OutputCacheLocation.Any, "OutputCacheLocation");
Assert.IsFalse(o.NoStore, "NoStore");
Assert.IsNull(o.SqlDependency, "SqlDependency");
Assert.IsNull(o.VaryByControl, "VaryByControl");
Assert.IsNull(o.VaryByCustom, "VaryByCustom");
Assert.IsNull(o.VaryByHeader, "VaryByHeader");
Assert.IsNull(o.VaryByParam, "VaryByParam");
}
private void CheckFirefoxChecking()
{
if (!Request.UserAgent.Contains("Mozilla"))
{
return;
}
var outputCacheSettings = new OutputCacheParameters()
{
Duration = 0,
Location = OutputCacheLocation.None,
NoStore = true
};
InitOutputCache(outputCacheSettings);
}
protected override void BuildFrameworkInitializeMethodContents(CodeMemberMethod method)
{
if (this.Parser.StyleSheetTheme != null)
{
CodeExpression right = new CodePrimitiveExpression(this.Parser.StyleSheetTheme);
CodeExpression left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "StyleSheetTheme");
CodeAssignStatement statement = new CodeAssignStatement(left, right);
method.Statements.Add(statement);
}
base.BuildFrameworkInitializeMethodContents(method);
CodeMethodInvokeExpression expression3 = new CodeMethodInvokeExpression {
Method = { TargetObject = new CodeThisReferenceExpression(), MethodName = "AddWrappedFileDependencies" }
};
expression3.Parameters.Add(new CodeFieldReferenceExpression(base._classTypeExpr, "__fileDependencies"));
method.Statements.Add(expression3);
if (this.Parser.OutputCacheParameters != null)
{
OutputCacheParameters outputCacheParameters = this.Parser.OutputCacheParameters;
if (((outputCacheParameters.CacheProfile != null) && (outputCacheParameters.CacheProfile.Length != 0)) || ((outputCacheParameters.Duration != 0) || (outputCacheParameters.Location == OutputCacheLocation.None)))
{
CodeMethodInvokeExpression expression4 = new CodeMethodInvokeExpression {
Method = { TargetObject = new CodeThisReferenceExpression(), MethodName = "InitOutputCache" }
};
expression4.Parameters.Add(new CodeFieldReferenceExpression(base._classTypeExpr, "__outputCacheSettings"));
method.Statements.Add(expression4);
}
}
if (this.Parser.TraceEnabled != TraceEnable.Default)
{
method.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TraceEnabled"), new CodePrimitiveExpression(this.Parser.TraceEnabled == TraceEnable.Enable)));
}
if (this.Parser.TraceMode != TraceMode.Default)
{
method.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TraceModeValue"), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(TraceMode)), this.Parser.TraceMode.ToString())));
}
if (this.Parser.ValidateRequest)
{
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression {
Method = { TargetObject = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Request"), MethodName = "ValidateInput" }
};
method.Statements.Add(new CodeExpressionStatement(expression));
}
}
static OutputCacheParameters getCacheParams()
{
OutputCacheParameters cacheParams;
if (cacheProfileExists(CACHE_PROFILE_NAME))
{
cacheParams = new OutputCacheParameters
{
CacheProfile = CACHE_PROFILE_NAME
};
}
else // default
{
cacheParams = new OutputCacheParameters
{
Duration = 86400, // 1 day
Enabled = true,
Location = OutputCacheLocation.Any,
VaryByParam = "*"
};
}
return(cacheParams);
}
/*
* Add metadata attributes to the class
*/
protected override void GenerateClassAttributes()
{
base.GenerateClassAttributes();
// If the user control has an OutputCache directive, generate
// an attribute with the information about it.
if (_sourceDataClass != null && Parser.OutputCacheParameters != null)
{
OutputCacheParameters cacheSettings = Parser.OutputCacheParameters;
if (cacheSettings.Duration > 0)
{
CodeAttributeDeclaration attribDecl = new CodeAttributeDeclaration(
"System.Web.UI.PartialCachingAttribute");
CodeAttributeArgument attribArg = new CodeAttributeArgument(
new CodePrimitiveExpression(cacheSettings.Duration));
attribDecl.Arguments.Add(attribArg);
attribArg = new CodeAttributeArgument(new CodePrimitiveExpression(cacheSettings.VaryByParam));
attribDecl.Arguments.Add(attribArg);
attribArg = new CodeAttributeArgument(new CodePrimitiveExpression(cacheSettings.VaryByControl));
attribDecl.Arguments.Add(attribArg);
attribArg = new CodeAttributeArgument(new CodePrimitiveExpression(cacheSettings.VaryByCustom));
attribDecl.Arguments.Add(attribArg);
attribArg = new CodeAttributeArgument(new CodePrimitiveExpression(cacheSettings.SqlDependency));
attribDecl.Arguments.Add(attribArg);
attribArg = new CodeAttributeArgument(new CodePrimitiveExpression(Parser.FSharedPartialCaching));
attribDecl.Arguments.Add(attribArg);
// Use the providerName argument only when targeting 4.0 and above.
if (MultiTargetingUtil.IsTargetFramework40OrAbove)
{
attribArg = new CodeAttributeArgument("ProviderName", new CodePrimitiveExpression(Parser.Provider));
attribDecl.Arguments.Add(attribArg);
}
_sourceDataClass.CustomAttributes.Add(attribDecl);
}
}
}
/*
* Build the contents of the FrameworkInitialize method
*/
protected override void BuildFrameworkInitializeMethodContents(CodeMemberMethod method)
{
// Generate code to apply stylesheet before calling base.FrameworkInitialize();
if (Parser.StyleSheetTheme != null)
{
CodeExpression rightExpr = new CodePrimitiveExpression(Parser.StyleSheetTheme);
CodeExpression leftExpr = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), _styleSheetThemePropertyName);
CodeAssignStatement setStatment = new CodeAssignStatement(leftExpr, rightExpr);
method.Statements.Add(setStatment);
}
base.BuildFrameworkInitializeMethodContents(method);
CodeMethodInvokeExpression addDeps = new CodeMethodInvokeExpression();
addDeps.Method.TargetObject = new CodeThisReferenceExpression();
addDeps.Method.MethodName = "AddWrappedFileDependencies";
addDeps.Parameters.Add(new CodeFieldReferenceExpression(_classTypeExpr, fileDependenciesName));
method.Statements.Add(addDeps);
if (Parser.OutputCacheParameters != null)
{
OutputCacheParameters cacheSettings = Parser.OutputCacheParameters;
if ((cacheSettings.CacheProfile != null && cacheSettings.CacheProfile.Length != 0) ||
cacheSettings.Duration != 0 ||
cacheSettings.Location == OutputCacheLocation.None)
{
CodeMethodInvokeExpression call = new CodeMethodInvokeExpression();
call.Method.TargetObject = new CodeThisReferenceExpression();
call.Method.MethodName = "InitOutputCache";
call.Parameters.Add(new CodeFieldReferenceExpression(
_classTypeExpr,
outputCacheSettingsFieldName));
method.Statements.Add(call);
}
}
if (Parser.TraceEnabled != TraceEnable.Default)
{
method.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TraceEnabled"),
new CodePrimitiveExpression(Parser.TraceEnabled == TraceEnable.Enable)));
}
if (Parser.TraceMode != TraceMode.Default)
{
method.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TraceModeValue"),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(TraceMode)), Parser.TraceMode.ToString())));
}
if (Parser.ValidateRequest)
{
// e.g. Request.ValidateInput();
CodeMethodInvokeExpression invokeExpr = new CodeMethodInvokeExpression();
invokeExpr.Method.TargetObject = new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(), "Request");
invokeExpr.Method.MethodName = "ValidateInput";
method.Statements.Add(new CodeExpressionStatement(invokeExpr));
}
else if (MultiTargetingUtil.TargetFrameworkVersion >= VersionUtil.Framework45)
{
// Only emit the ValidateRequestMode setter if the target framework is 4.5 or higher.
// On frameworks 4.0 and earlier that property did not exist.
CodePropertyReferenceExpression left = new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(), "ValidateRequestMode");
CodeFieldReferenceExpression right = new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(typeof(ValidateRequestMode)), "Disabled");
CodeAssignStatement statement = new CodeAssignStatement(left, right);
method.Statements.Add(statement);
}
}
public OutputCachedPage(OutputCacheParameters cacheSettings)
{
this.ID = Guid.NewGuid().ToString();
_cacheSettings = cacheSettings;
}
public CustomOutputCacheAttribute()
{
_cacheSettings = new OutputCacheParameters {
VaryByParam = "*"
};
}
protected override void BuildDefaultConstructor()
{
base.BuildDefaultConstructor();
if (base.CompilParams.IncludeDebugInformation)
{
CodeAssignStatement statement = new CodeAssignStatement {
Left = new CodePropertyReferenceExpression(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Server"), "ScriptTimeout"),
Right = new CodePrimitiveExpression(0x1c9c380)
};
base._ctor.Statements.Add(statement);
}
if (this.Parser.TransactionMode != 0)
{
base._ctor.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TransactionMode"), new CodePrimitiveExpression(this.Parser.TransactionMode)));
}
if (this.Parser.AspCompatMode)
{
base._ctor.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "AspCompatMode"), new CodePrimitiveExpression(this.Parser.AspCompatMode)));
}
if (this.Parser.AsyncMode)
{
base._ctor.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "AsyncMode"), new CodePrimitiveExpression(this.Parser.AsyncMode)));
}
if (this.Parser.OutputCacheParameters != null)
{
OutputCacheParameters outputCacheParameters = this.Parser.OutputCacheParameters;
if (((outputCacheParameters.CacheProfile != null) && (outputCacheParameters.CacheProfile.Length != 0)) || ((outputCacheParameters.Duration != 0) || (outputCacheParameters.Location == OutputCacheLocation.None)))
{
CodeMemberField field;
field = new CodeMemberField(typeof(OutputCacheParameters), "__outputCacheSettings")
{
Attributes = field.Attributes | MemberAttributes.Static,
InitExpression = new CodePrimitiveExpression(null)
};
base._sourceDataClass.Members.Add(field);
CodeConditionStatement statement2 = new CodeConditionStatement {
Condition = new CodeBinaryOperatorExpression(new CodeFieldReferenceExpression(base._classTypeExpr, "__outputCacheSettings"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null))
};
CodeVariableDeclarationStatement statement3 = new CodeVariableDeclarationStatement {
Type = new CodeTypeReference(typeof(OutputCacheParameters)),
Name = "outputCacheSettings"
};
statement2.TrueStatements.Insert(0, statement3);
CodeObjectCreateExpression right = new CodeObjectCreateExpression {
CreateType = new CodeTypeReference(typeof(OutputCacheParameters))
};
CodeVariableReferenceExpression left = new CodeVariableReferenceExpression("outputCacheSettings");
CodeAssignStatement statement4 = new CodeAssignStatement(left, right);
statement2.TrueStatements.Add(statement4);
if (outputCacheParameters.IsParameterSet(OutputCacheParameter.CacheProfile))
{
CodeAssignStatement statement5 = new CodeAssignStatement(new CodePropertyReferenceExpression(left, "CacheProfile"), new CodePrimitiveExpression(outputCacheParameters.CacheProfile));
statement2.TrueStatements.Add(statement5);
}
if (outputCacheParameters.IsParameterSet(OutputCacheParameter.Duration))
{
CodeAssignStatement statement6 = new CodeAssignStatement(new CodePropertyReferenceExpression(left, "Duration"), new CodePrimitiveExpression(outputCacheParameters.Duration));
statement2.TrueStatements.Add(statement6);
}
if (outputCacheParameters.IsParameterSet(OutputCacheParameter.Enabled))
{
CodeAssignStatement statement7 = new CodeAssignStatement(new CodePropertyReferenceExpression(left, "Enabled"), new CodePrimitiveExpression(outputCacheParameters.Enabled));
statement2.TrueStatements.Add(statement7);
}
if (outputCacheParameters.IsParameterSet(OutputCacheParameter.Location))
{
CodeAssignStatement statement8 = new CodeAssignStatement(new CodePropertyReferenceExpression(left, "Location"), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(OutputCacheLocation)), outputCacheParameters.Location.ToString()));
statement2.TrueStatements.Add(statement8);
}
if (outputCacheParameters.IsParameterSet(OutputCacheParameter.NoStore))
{
CodeAssignStatement statement9 = new CodeAssignStatement(new CodePropertyReferenceExpression(left, "NoStore"), new CodePrimitiveExpression(outputCacheParameters.NoStore));
statement2.TrueStatements.Add(statement9);
}
if (outputCacheParameters.IsParameterSet(OutputCacheParameter.SqlDependency))
{
CodeAssignStatement statement10 = new CodeAssignStatement(new CodePropertyReferenceExpression(left, "SqlDependency"), new CodePrimitiveExpression(outputCacheParameters.SqlDependency));
statement2.TrueStatements.Add(statement10);
}
if (outputCacheParameters.IsParameterSet(OutputCacheParameter.VaryByControl))
{
CodeAssignStatement statement11 = new CodeAssignStatement(new CodePropertyReferenceExpression(left, "VaryByControl"), new CodePrimitiveExpression(outputCacheParameters.VaryByControl));
statement2.TrueStatements.Add(statement11);
}
if (outputCacheParameters.IsParameterSet(OutputCacheParameter.VaryByCustom))
{
CodeAssignStatement statement12 = new CodeAssignStatement(new CodePropertyReferenceExpression(left, "VaryByCustom"), new CodePrimitiveExpression(outputCacheParameters.VaryByCustom));
statement2.TrueStatements.Add(statement12);
}
if (outputCacheParameters.IsParameterSet(OutputCacheParameter.VaryByContentEncoding))
{
CodeAssignStatement statement13 = new CodeAssignStatement(new CodePropertyReferenceExpression(left, "VaryByContentEncoding"), new CodePrimitiveExpression(outputCacheParameters.VaryByContentEncoding));
statement2.TrueStatements.Add(statement13);
}
if (outputCacheParameters.IsParameterSet(OutputCacheParameter.VaryByHeader))
{
CodeAssignStatement statement14 = new CodeAssignStatement(new CodePropertyReferenceExpression(left, "VaryByHeader"), new CodePrimitiveExpression(outputCacheParameters.VaryByHeader));
statement2.TrueStatements.Add(statement14);
}
if (outputCacheParameters.IsParameterSet(OutputCacheParameter.VaryByParam))
{
CodeAssignStatement statement15 = new CodeAssignStatement(new CodePropertyReferenceExpression(left, "VaryByParam"), new CodePrimitiveExpression(outputCacheParameters.VaryByParam));
statement2.TrueStatements.Add(statement15);
}
CodeFieldReferenceExpression expression3 = new CodeFieldReferenceExpression(base._classTypeExpr, "__outputCacheSettings");
CodeAssignStatement statement16 = new CodeAssignStatement(expression3, left);
statement2.TrueStatements.Add(statement16);
base._ctor.Statements.Add(statement2);
}
}
}
protected virtual void InitOutputCache(OutputCacheParameters parameters)
{
new OutputCachedPage(parameters).ProcessRequest(this.Context);
}
/*
* Build the default constructor
*/
protected override void BuildDefaultConstructor()
{
base.BuildDefaultConstructor();
if (CompilParams.IncludeDebugInformation)
{
// If in debug mode, set the timeout to some huge value (ASURT 49427)
// Server.ScriptTimeout = 30000000;
CodeAssignStatement setScriptTimeout = new CodeAssignStatement();
setScriptTimeout.Left = new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(
new CodeThisReferenceExpression(), "Server"),
"ScriptTimeout");
setScriptTimeout.Right = new CodePrimitiveExpression(DebugScriptTimeout);
_ctor.Statements.Add(setScriptTimeout);
}
if (Parser.TransactionMode != 0 /*TransactionOption.Disabled*/)
{
_ctor.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TransactionMode"),
new CodePrimitiveExpression(Parser.TransactionMode)));
}
if (Parser.AspCompatMode)
{
_ctor.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "AspCompatMode"),
new CodePrimitiveExpression(Parser.AspCompatMode)));
}
if (Parser.AsyncMode)
{
_ctor.Statements.Add(new CodeAssignStatement(
new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "AsyncMode"),
new CodePrimitiveExpression(Parser.AsyncMode)));
}
if (Parser.OutputCacheParameters != null)
{
OutputCacheParameters cacheSettings = Parser.OutputCacheParameters;
if ((cacheSettings.CacheProfile != null && cacheSettings.CacheProfile.Length != 0) ||
cacheSettings.Duration != 0 ||
cacheSettings.Location == OutputCacheLocation.None)
{
// Add the following code snippet as a static on the class:
//
// private static OutputCacheParameters __outputCacheSettings = null;
//
CodeMemberField outputCacheSettingsField = new CodeMemberField(typeof(OutputCacheParameters), outputCacheSettingsFieldName);
outputCacheSettingsField.Attributes |= MemberAttributes.Static;
outputCacheSettingsField.InitExpression = new CodePrimitiveExpression(null);
_sourceDataClass.Members.Add(outputCacheSettingsField);
// Then, add the following code to the default constructor:
//
// if (__outputCacheSettings == null)
// __outputCacheSettings = new OutputCacheParameters(.....)
//
// This is the "if (__outputCacheSettings == null)" part
CodeConditionStatement outputCacheSettingsCondition = new CodeConditionStatement();
outputCacheSettingsCondition.Condition = new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(
_classTypeExpr,
outputCacheSettingsFieldName),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null));
// This is the "__outputCacheSettings = new OutputCacheParameters()" part
// e.g. declare local variable: OutputCacheParameters outputCacheSettings;
CodeVariableDeclarationStatement outputCacheSettingsDeclaration = new CodeVariableDeclarationStatement();
outputCacheSettingsDeclaration.Type = new CodeTypeReference(typeof(OutputCacheParameters));
outputCacheSettingsDeclaration.Name = outputCacheSettingsLocalName;
outputCacheSettingsCondition.TrueStatements.Insert(0, outputCacheSettingsDeclaration);
// e.g. outputCacheSettings = new outputCacheParameters;
CodeObjectCreateExpression cacheSettingsObject = new CodeObjectCreateExpression();
cacheSettingsObject.CreateType = new CodeTypeReference(typeof(OutputCacheParameters));
CodeVariableReferenceExpression outputCacheSettings =
new CodeVariableReferenceExpression(outputCacheSettingsLocalName);
CodeAssignStatement setOutputCacheObject =
new CodeAssignStatement(outputCacheSettings, cacheSettingsObject);
// Add the statement to the "true" clause
outputCacheSettingsCondition.TrueStatements.Add(setOutputCacheObject);
if (cacheSettings.IsParameterSet(OutputCacheParameter.CacheProfile))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "CacheProfile"),
new CodePrimitiveExpression(cacheSettings.CacheProfile));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.Duration))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "Duration"),
new CodePrimitiveExpression(cacheSettings.Duration));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.Enabled))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "Enabled"),
new CodePrimitiveExpression(cacheSettings.Enabled));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.Location))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "Location"),
new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(typeof(OutputCacheLocation)),
cacheSettings.Location.ToString()));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.NoStore))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "NoStore"),
new CodePrimitiveExpression(cacheSettings.NoStore));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.SqlDependency))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "SqlDependency"),
new CodePrimitiveExpression(cacheSettings.SqlDependency));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByControl))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "VaryByControl"),
new CodePrimitiveExpression(cacheSettings.VaryByControl));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByCustom))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "VaryByCustom"),
new CodePrimitiveExpression(cacheSettings.VaryByCustom));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByContentEncoding))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "VaryByContentEncoding"),
new CodePrimitiveExpression(cacheSettings.VaryByContentEncoding));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByHeader))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "VaryByHeader"),
new CodePrimitiveExpression(cacheSettings.VaryByHeader));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByParam))
{
CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
new CodePropertyReferenceExpression(outputCacheSettings, "VaryByParam"),
new CodePrimitiveExpression(cacheSettings.VaryByParam));
outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
}
// e.g. __outputCacheSettings = outputCacheSettings;
CodeFieldReferenceExpression staticOutputCacheSettings =
new CodeFieldReferenceExpression(_classTypeExpr, outputCacheSettingsFieldName);
CodeAssignStatement assignOutputCacheSettings =
new CodeAssignStatement(staticOutputCacheSettings, outputCacheSettings);
// Add the statement to the "true" clause
outputCacheSettingsCondition.TrueStatements.Add(assignOutputCacheSettings);
_ctor.Statements.Add(outputCacheSettingsCondition);
}
}
}
public OutputCachedPage(OutputCacheParameters cacheSettings)
{
// Tracing requires Page IDs to be unique.
ID = Guid.NewGuid().ToString();
_cacheSettings = cacheSettings;
}
// Methods
public OutputCachedPage(OutputCacheParameters cacheParams)
{
this.ID = Guid.NewGuid().ToString();
this._cacheParams = cacheParams;
}
