public void AddValidationCallback(HttpCacheValidateHandler handler, object data)
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
this.Dirtied();
if (this._validationCallbackInfo == null)
{
this._validationCallbackInfo = new ArrayList();
}
this._validationCallbackInfo.Add(new ValidationCallbackInfo(handler, data));
}
public void AddValidationCallback(HttpCacheValidateHandler handler, object data)
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
if (validation_callbacks == null)
{
validation_callbacks = new ArrayList();
}
validation_callbacks.Add(new Pair(handler, data));
}
private void OnSerializingMethod(StreamingContext context)
{
if (this._validationCallbackInfo != null)
{
string[] strArray = new string[this._validationCallbackInfo.Length * 2];
for (int i = 0; i < this._validationCallbackInfo.Length; i++)
{
HttpCacheValidateHandler handler = this._validationCallbackInfo[i].handler;
string assemblyQualifiedTypeName = Util.GetAssemblyQualifiedTypeName(handler.Method.ReflectedType);
string name = handler.Method.Name;
strArray[i] = assemblyQualifiedTypeName;
strArray[i + 1] = name;
}
this._validationCallbackInfoForSerialization = strArray;
}
}
private void OnDeserializedMethod(StreamingContext context)
{
if (this._validationCallbackInfoForSerialization != null)
{
System.Web.ValidationCallbackInfo[] infoArray = new System.Web.ValidationCallbackInfo[this._validationCallbackInfoForSerialization.Length / 2];
for (int i = 0; i < this._validationCallbackInfoForSerialization.Length; i += 2)
{
string str = this._validationCallbackInfoForSerialization[i];
string method = this._validationCallbackInfoForSerialization[i + 1];
Type target = null;
if (!string.IsNullOrEmpty(str))
{
target = BuildManager.GetType(str, true, false);
}
if (target == null)
{
throw new SerializationException(System.Web.SR.GetString("Type_cannot_be_resolved", new object[] { str }));
}
HttpCacheValidateHandler handler = (HttpCacheValidateHandler)Delegate.CreateDelegate(typeof(HttpCacheValidateHandler), target, method);
infoArray[i] = new System.Web.ValidationCallbackInfo(handler, null);
}
this._validationCallbackInfo = infoArray;
}
}
public override void AddValidationCallback(HttpCacheValidateHandler handler, object data)
{
}
/// <summary>
/// Registers a validation callback for the current response.
/// </summary>
/// <param name="handler">The <see cref="T:System.Web.HttpCacheValidateHandler" /> value. </param>
/// <param name="data">
/// The arbitrary user-supplied data that is passed back to the
/// <see cref="M:System.Web.HttpCachePolicy.AddValidationCallback(System.Web.HttpCacheValidateHandler,System.Object)" />
/// delegate.
/// </param>
/// <exception cref="T:System.ArgumentNullException">The specified <paramref name="handler" /> is null. </exception>
public void AddValidationCallback(HttpCacheValidateHandler handler, object data)
{
policy.AddValidationCallback(handler, data);
}
public void AddValidationCallback (HttpCacheValidateHandler handler, object data)
{
if (handler == null)
throw new ArgumentNullException ("handler");
if (validation_callbacks == null)
validation_callbacks = new ArrayList ();
validation_callbacks.Add (new Pair (handler, data));
}
public virtual void AddValidationCallback(HttpCacheValidateHandler handler, object data)
{
throw new NotImplementedException();
}
public override void AddValidationCallback(HttpCacheValidateHandler handler, object data)
{
this._httpCachePolicy.AddValidationCallback(handler, data);
}
public virtual new void AddValidationCallback(HttpCacheValidateHandler handler, Object data)
{
}
/// <summary>
/// Registers a validation callback for the current response.
/// </summary>
/// <param name="handler">The object that will handle the request.</param>
/// <param name="data">The user-supplied data that is passed to the <see cref="M:System.Web.HttpCachePolicyBase.AddValidationCallback(System.Web.HttpCacheValidateHandler,System.Object)" /> delegate.</param>
public override void AddValidationCallback(HttpCacheValidateHandler handler, object data)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
this.validationCallbacks.Add(new Tuple<HttpCacheValidateHandler, object>(handler, data));
}
public virtual new void AddValidationCallback (HttpCacheValidateHandler handler, Object data)
{
}
public override void AddValidationCallback(HttpCacheValidateHandler handler, object data)
{
// No implementation - skip this call when AuthorizeAttribute calls it
}
internal ValidationCallbackInfo(HttpCacheValidateHandler handler, Object data) {
this.handler = handler;
this.data = data;
}
internal ValidationCallbackInfo(HttpCacheValidateHandler handler, object data)
{
this.handler = handler;
this.data = data;
}
void OnResolveRequestCache(object o, EventArgs args)
{
HttpApplication app = o as HttpApplication;
HttpContext context = app != null ? app.Context : null;
if (context == null)
{
return;
}
OutputCacheProvider provider = FindCacheProvider(app);
string vary_key = context.Request.FilePath;
CachedVaryBy varyby = provider.Get(vary_key) as CachedVaryBy;
string key;
CachedRawResponse c;
if (varyby == null)
{
return;
}
key = varyby.CreateKey(vary_key, context);
c = provider.Get(key) as CachedRawResponse;
if (c == null)
{
return;
}
lock (keysCacheLock) {
string invValue;
if (entriesToInvalidate != null && entriesToInvalidate.TryGetValue(vary_key, out invValue) && String.Compare(invValue, key, StringComparison.Ordinal) == 0)
{
provider.Remove(vary_key);
provider.Remove(key);
entriesToInvalidate.Remove(vary_key);
return;
}
}
ArrayList callbacks = c.Policy.ValidationCallbacks;
if (callbacks != null && callbacks.Count > 0)
{
bool isValid = true;
bool isIgnored = false;
foreach (Pair p in callbacks)
{
HttpCacheValidateHandler validate = (HttpCacheValidateHandler)p.First;
object data = p.Second;
HttpValidationStatus status = HttpValidationStatus.Valid;
try {
validate(context, data, ref status);
} catch {
// MS.NET hides the exception
isValid = false;
break;
}
if (status == HttpValidationStatus.Invalid)
{
isValid = false;
break;
}
else if (status == HttpValidationStatus.IgnoreThisRequest)
{
isIgnored = true;
}
}
if (!isValid)
{
OnRawResponseRemoved(key, c, CacheItemRemovedReason.Removed);
return;
}
else if (isIgnored)
{
return;
}
}
HttpResponse response = context.Response;
response.ClearContent();
IList cachedData = c.GetData();
if (cachedData != null)
{
Encoding outEnc = WebEncoding.ResponseEncoding;
foreach (CachedRawResponse.DataItem d in cachedData)
{
if (d.Length > 0)
{
response.BinaryWrite(d.Buffer, 0, (int)d.Length);
continue;
}
if (d.Callback == null)
{
continue;
}
string s = d.Callback(context);
if (s == null || s.Length == 0)
{
continue;
}
byte[] bytes = outEnc.GetBytes(s);
response.BinaryWrite(bytes, 0, bytes.Length);
}
}
response.ClearHeaders();
response.SetCachedHeaders(c.Headers);
response.StatusCode = c.StatusCode;
response.StatusDescription = c.StatusDescription;
app.CompleteRequest();
}
public virtual void AddValidationCallback (HttpCacheValidateHandler handler, object data)
{
NotImplemented ();
}
public void AddValidationCallback(HttpCacheValidateHandler handler, object data)
{
_httpCachePolicy.AddValidationCallback(handler, data);
}
public override void AddValidationCallback(HttpCacheValidateHandler handler, object data)
{
// No implementation - skip this call when AuthorizeAttribute calls it
}
/// <devdoc>
/// <para>Registers a validation callback for the current response.</para>
/// </devdoc>
public void AddValidationCallback(
HttpCacheValidateHandler handler, Object data) {
if (handler == null) {
throw new ArgumentNullException("handler");
}
Dirtied();
if (_validationCallbackInfo == null) {
_validationCallbackInfo = new ArrayList();
}
_validationCallbackInfo.Add(new ValidationCallbackInfo(handler, data));
}
public override void AddValidationCallback(HttpCacheValidateHandler handler, object data)
{
this._httpCachePolicy.AddValidationCallback(handler, data);
}
public virtual void AddValidationCallback(HttpCacheValidateHandler handler, object data) {
throw new NotImplementedException();
}
public virtual void AddValidationCallback(HttpCacheValidateHandler handler, object data)
{
NotImplemented();
}
public override void AddValidationCallback(HttpCacheValidateHandler handler, object data)
{
}
protected void Page_Load(object sender, EventArgs e)
{
HttpCacheValidateHandler val = new HttpCacheValidateHandler(ValidateCache);
this.Response.Cache.AddValidationCallback(val, null);
}
