private string ToBase64String(object state)
{
LosFormatter lf = new LosFormatter();
StringWriter sw = new StringWriter();
lf.Serialize(sw, state);
byte[] b = Convert.FromBase64String(sw.ToString());
return Convert.ToBase64String(b);
}
protected override void SavePageStateToPersistenceMedium(object state)
{
LosFormatter lf = new LosFormatter();
StringWriter sw = new StringWriter();
lf.Serialize(sw, state);
byte[] b = Convert.FromBase64String(sw.ToString());
ClientScript.RegisterHiddenField("__VSTATE", Convert.ToBase64String(Compress(b)));
}
// viewstate
protected override void SavePageStateToPersistenceMedium(object state)
{
string file = this.GenerateFileName();
FileStream filestream = new FileStream(file, FileMode.Create);
LosFormatter formator = new LosFormatter();
formator.Serialize(filestream, state);
filestream.Flush();
filestream.Close();
filestream = null;
}
public override void Load()
{
string id = _session.ToString() + "|" + Page.Request.Url.ToString();
LosFormatter formatter = new LosFormatter();
if (Page.Session[id] == null)
{
throw new ArgumentException("session timeout ...");
}
string obj = Page.Session[id] as string;
Pair pair = formatter.Deserialize(obj) as Pair;
ViewState = pair.First;
ControlState = pair.Second;
}
/// <summary>
/// Compacta viewstate para página caso necessário
/// </summary>
/// <param name="BasePage">Referência da página que contém a viewstate</param>
/// <param name="viewState">Valor da viewstate recebido por SavePageStateToPersistenceMedium</param>
public static void CompressViewState(Page BasePage, object viewState)
{
// formatador para serializar a viewstate
LosFormatter formatter = new LosFormatter();
// responsável por receber os dados serializados da viewstate
StringWriter swViewState = new StringWriter();
// serializa viewstate
formatter.Serialize(swViewState, viewState);
// guarda valor original da viewstate
string OriginalViewState = swViewState.ToString();
// retira o base64
byte[] bytes = Convert.FromBase64String(OriginalViewState);
// compacta o conteúdo da viewstate
MemoryStream msViewState = new MemoryStream();
GZipStream Zip = new GZipStream(msViewState, CompressionMode.Compress, true);
Zip.Write(bytes, 0, bytes.Length);
Zip.Close();
bytes = msViewState.ToArray();
msViewState.Close();
// converte novo conteúdo, já compactado, para base64
string NewViewState = Convert.ToBase64String(bytes);
if (BasePage is GeneralDataPage)
{
CompressViewStateWithTelerik((GeneralDataPage)BasePage, OriginalViewState, NewViewState);
}
else
{
// verifica se a compactação diminui o tamanho da viewstate
// em pelo menos 10%, se não diminuir usa viewstate original
if (NewViewState.Length > OriginalViewState.Length * 0.9)
{
BasePage.ClientScript.RegisterHiddenField("__NVIEWSTATE", OriginalViewState);
}
else
{
BasePage.ClientScript.RegisterHiddenField("__NVIEWSTATE", "1'" + NewViewState);
}
}
}
/// <summary>
/// Call this method on page's "LoadPageStateFromPersistenceMedium" method
/// </summary>
/// <param name="request">Request object of page</param>
/// <returns>return this as "LoadPageStateFromPersistenceMedium" method result </returns>
public static object DecompressViewState(HttpRequest request)
{
StringBuilder viewStateBase64 = new StringBuilder();
int i = 0;
string viewStateChunk;
while ((viewStateChunk = request.Form["__VSTATE" + i]) != null)
{
viewStateBase64.Append(viewStateChunk);
i++;
}
byte[] bytes = Convert.FromBase64String(viewStateBase64.ToString());
bytes = Decompress(bytes);
LosFormatter formatter = new LosFormatter();
return(formatter.Deserialize(Convert.ToBase64String(bytes)));
}
public void Serialize_Value_Null()
{
LosFormatter lf = new LosFormatter();
MemoryStream ms = new MemoryStream();
lf.Serialize(ms, null);
string s1 = Encoding.UTF8.GetString(ms.GetBuffer(), 0, (int)ms.Length);
Assert.AreEqual("/wFk", s1, "#1");
StringWriter sw = new StringWriter();
lf.Serialize(sw, null);
string s2 = sw.ToString();
Assert.AreEqual("/wFk", s1, "#2");
}
protected override void SavePageStateToPersistenceMedium(object viewState)
{
#region
System.IO.StringWriter sw = new StringWriter();
LosFormatter lformat = new LosFormatter();
lformat.Serialize(sw, viewState);
string vString = sw.ToString();
bool userzip = false;
switch (VS_SaveMethod)
{
case ViewStateSaveMethod.Page:
{
if (vString.Length > limiteLength)
{
userzip = true;
byte[] mbytes = Compress(vString);
vString = System.Convert.ToBase64String(mbytes);
}
this.Page.ClientScript.RegisterHiddenField("__Benny_P", vString);
this.Page.ClientScript.RegisterHiddenField("__Benny_PZ", userzip.ToString().ToLower());
}
break;
case ViewStateSaveMethod.Cache:
{
string key = Guid.NewGuid().ToString().Replace("-", "");
MyCache <string> .Insert(key, vString, HttpContext.Current.Session.Timeout * 60);
this.Page.ClientScript.RegisterHiddenField("__Benny_C", key);
}
break;
case ViewStateSaveMethod.Session:
{
string key = Guid.NewGuid().ToString().Replace("-", "");
HttpContext.Current.Session[key] = vString;
this.Page.ClientScript.RegisterHiddenField("__Benny_S", key);
}
break;
}
#endregion
}
protected override void SavePageStateToPersistenceMedium(object pViewState)
{
//############
//Uma outra opção é se usar um Provider, envia o ViewState direto, sem compactação.
//Bastaria apenas fazer uma condição ( if (ViewStateProviderService.UseProvider) ) e chamar a linha abaixo.
//base.SavePageStateToPersistenceMedium(pViewState);
if (ViewStateProviderService.UseProvider)
{
base.SavePageStateToPersistenceMedium(pViewState);
}
else
{
Pair pair1;
System.Web.UI.PageStatePersister pageStatePersister1 = this.PageStatePersister;
Object ViewState;
if (pViewState is Pair)
{
pair1 = ((Pair)pViewState);
pageStatePersister1.ControlState = pair1.First;
ViewState = pair1.Second;
}
else
{
ViewState = pViewState;
}
LosFormatter mFormat = new LosFormatter();
StringWriter mWriter = new StringWriter();
mFormat.Serialize(mWriter, ViewState);
String mViewStateStr = mWriter.ToString();
byte[] pBytes = System.Convert.FromBase64String(mViewStateStr);
pBytes = Compressor.Compress(pBytes);
String vStateStr = System.Convert.ToBase64String(pBytes);
//pageStatePersister1.ViewState = vStateStr;
pageStatePersister1.Save();
//##### - Precisa averiguar se há uma forma compactar o pair1.First que é uma HybridDictionary.
//##### Do jeito que está, está compactando apenas o ViewState Pair e não o ViewState do Controle.
//Este irá salvar no hidden viewstate padrão ou no custom hidden viewstate_key.
//Ao salvar no hidden viewstate padrão o campo "pageStatePersister1.ViewState" acima, será preenchido.
base.SavePageStateToPersistenceMedium(vStateStr);
}
}
//implementation of method
private void SaveViewState(object viewState)
{
if (_formatter == null)
{
_formatter = new LosFormatter();
}
//Save the viewstate information
StringBuilder _viewState = new StringBuilder();
StringWriter _writer = new StringWriter(_viewState);
_formatter.Serialize(_writer, viewState);
long lRequestNumber = viewStateSvrMgr.GetViewStateSvrMgr().SaveViewState(_viewState.ToString());
//Need to register the viewstate hidden field (must be present or postback things don't
// work, we use in our case to store the request number)
ClientScript.RegisterHiddenField(VIEW_STATE_FIELD_NAME, lRequestNumber.ToString());
}
public override void Load()
{
if (!File.Exists(ViewStateFilePath))
{
base.ViewState = null;
base.ControlState = null;
}
else
{
StreamReader sr = File.OpenText(ViewStateFilePath);
string viewStateString = sr.ReadToEnd();
sr.Close();
LosFormatter los = new LosFormatter();
Pair pair = (Pair)los.Deserialize(viewStateString);
base.ViewState = pair.First;
base.ControlState = pair.Second;
}
}
// De-serialize view state
protected override object LoadPageStateFromPersistenceMedium()
{
var isCompressed = true;
var compressedViewState = Request.Form[_compressedViewState];
isCompressed = Convert.ToBoolean(Convert.ToInt32(compressedViewState.Substring(0, 1)));
compressedViewState = compressedViewState.Remove(0, 1);
var bytes = Convert.FromBase64String(compressedViewState);
if (isCompressed)
{
bytes = Compressor.Decompress <byte[]>(bytes);
}
var losformatter = new LosFormatter();
return(losformatter.Deserialize(Convert.ToBase64String(bytes)));
}
private void SetWizardState(WorkspaceWizardSetting value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
var formatter = new LosFormatter();
var writer = new StringWriter();
formatter.Serialize(writer, value);
var input = CurrentUserControl.FindControl("_settings") as HtmlInputHidden;
if (input == null)
{
return;
}
input.Value = writer.ToString();
}
protected override object LoadPageStateFromPersistenceMedium()
{
// determine the file to access
if (!File.Exists(ViewStateFilePath))
{
return(null);
}
else
{
// open the file
StreamReader sr = File.OpenText(ViewStateFilePath);
string viewStateString = sr.ReadToEnd();
sr.Close();
// deserialize the string
LosFormatter los = new LosFormatter();
return(los.Deserialize(viewStateString));
}
}
public void Serialize_Stream()
{
string s = "Hello world";
LosFormatter lf = new LosFormatter();
MemoryStream ms = new MemoryStream();
lf.Serialize(ms, s);
string s1 = Encoding.UTF8.GetString(ms.GetBuffer(), 0, (int)ms.Length);
#if NET_2_0
Assert.AreEqual("/wEFC0hlbGxvIHdvcmxk", s1, "#1");
#else
Assert.AreEqual("SGVsbG8gd29ybGQ=", s1, "#1");
#endif
string s2 = lf.Deserialize(s1) as string;
Assert.IsNotNull(s2, "#2");
Assert.AreEqual(s, s2, "#3");
}
public void Serialize_Stream_Null()
{
LosFormatter lf = new LosFormatter();
try
{
lf.Serialize((Stream)null, "test");
Assert.Fail("#1");
}
catch (ArgumentNullException ex)
{
Assert.AreEqual(typeof(ArgumentNullException), ex.GetType(), "#2");
Assert.IsNull(ex.InnerException, "#3");
Assert.IsNotNull(ex.Message, "#4");
Assert.IsNotNull(ex.ParamName, "#5");
Assert.AreEqual("stream", ex.ParamName, "#6");
}
}
public void Serialize_Output()
{
string s = "Hello world";
LosFormatter lf = new LosFormatter();
StringWriter sw = new StringWriter();
lf.Serialize(sw, s);
string s1 = sw.ToString();
#if NET_2_0
Assert.AreEqual("/wEFC0hlbGxvIHdvcmxk", s1, "#1");
#else
Assert.AreEqual("SGVsbG8gd29ybGQ=", s1, "#1");
#endif
string s2 = lf.Deserialize(s1) as string;
Assert.IsNotNull(s2, "#2");
Assert.AreEqual(s, s2, "#3");
}
/// <summary>
/// Saves the ViewState from the persistence medium
/// </summary>
protected override void SavePageStateToPersistenceMedium(object state)
{
var writer = new StringWriter();
try
{
var compression = ConfigurationManager.AppSettings["ViewStateCompression"];
if (string.IsNullOrEmpty(compression))
{
compression = "true";
}
if (bool.Parse(compression))
{
var formatter = new LosFormatter();
formatter.Serialize(writer, state);
var vState = writer.ToString();
var bytes = Convert.FromBase64String(vState);
bytes = Compressor.Compress(bytes);
vState = Convert.ToBase64String(bytes);
var sm = ScriptManager.GetCurrent(this);
if (sm != null && sm.IsInAsyncPostBack)
{
ScriptManager.RegisterHiddenField(this, "__VSTATE", vState);
}
else
{
Page.ClientScript.RegisterHiddenField("__VSTATE", vState);
}
}
else
{
base.SavePageStateToPersistenceMedium(state);
}
}
catch (Exception) { throw; }
finally
{
if (writer != null)
{
writer.Dispose(); writer = null;
}
}
}
protected override void SavePageStateToPersistenceMedium(object viewState)
{
CiroLightLibrary.BLL.ViewState myViewState = new ViewState();
if (Request["__DATABASE_VIEWSTATE"] != null)
{
myViewState.GUID = Request["__DATABASE_VIEWSTATE"].ToString();
}
else
{
myViewState.GUID = Guid.NewGuid().ToString();
}
LosFormatter myFormatter = new LosFormatter();
StringWriter myStringWriter = new StringWriter();
myFormatter.Serialize(myStringWriter, viewState);
myViewState.Value = myStringWriter.ToString();
myViewState.Save();
ScriptManager.RegisterHiddenField(this, "__DATABASE_VIEWSTATE", myViewState.GUID);
}
// este metodo almacena en sesion el viewstate de una pagina en particular.
public void ToSession(object viewState)
{
MemoryStream ms = new MemoryStream();
LosFormatter lf;
HttpContext ctx;
try
{
ctx = HttpContext.Current;
lf = new LosFormatter();
lf.Serialize(ms, viewState);
ctx.Session.Add(KEY_PERSISTENT_VIEWSTATENAME, ms);
}
catch (Exception ex)
{
throw ex;
}
}
protected override object LoadPageStateFromPersistenceMedium()
{
// Determinar si se puede acceder el archivo o no
if (!File.Exists(ViewStateFilePath))
{
return(null);
}
else
{
// Abrir el archivo
StreamReader sr = File.OpenText(ViewStateFilePath);
string viewStateString = sr.ReadToEnd();
sr.Close();
// Des serializar el viewstate que viene del archivo
LosFormatter los = new LosFormatter();
return(los.Deserialize(viewStateString));
}
}
private WorkspaceWizardSetting GetWizardState()
{
var input = CurrentUserControl.FindControl("_settings") as HtmlInputHidden;
if (input == null)
{
return(null);
}
var value = input.Value;
if (string.IsNullOrEmpty(input.Value))
{
return(null);
}
var formatter = new LosFormatter();
var result = formatter.Deserialize(value);
return(result as WorkspaceWizardSetting);
}
/// <summary>
/// Descompacta viewstate de uma página caso necessário
/// </summary>
/// <param name="BasePage">Referência da página que contém a viewstate</param>
/// <returns>Retorna viewstate já desserializada</returns>
public static object DecompressViewState(Page BasePage)
{
// tenta buscar viewstate compactada no form
string viewState = BasePage.Request.Form["__NVIEWSTATE"];
// se tem encontrou viewstate compactada no form, descompacta
if (viewState != null && viewState.Substring(0, 2) == "1'")
{
// retira os bytes de controle e retira o base64
byte[] bytes = Convert.FromBase64String(viewState.Remove(0, 2));
// descompacta o conteúdo da viewstate
MemoryStream msZippedViewState = new MemoryStream();
msZippedViewState.Write(bytes, 0, bytes.Length);
msZippedViewState.Position = 0;
GZipStream Zip = new GZipStream(msZippedViewState, CompressionMode.Decompress, true);
MemoryStream msViewState = new MemoryStream();
byte[] Buffer = new byte[128];
int ReadBytes = Zip.Read(Buffer, 0, Buffer.Length);
while (ReadBytes > 0)
{
msViewState.Write(Buffer, 0, ReadBytes);
ReadBytes = Zip.Read(Buffer, 0, Buffer.Length);
}
Zip.Close();
bytes = msViewState.ToArray();
msViewState.Close();
msZippedViewState.Close();
// converte novo conteúdo, já descompactado, para base 64
viewState = Convert.ToBase64String(bytes);
}
// formatador para desserializar a viewstate
LosFormatter formatter = new LosFormatter();
// retorna viewstate desserializada
if (viewState != null)
{
return(formatter.Deserialize(viewState));
}
return(null);
}
/// <summary>
/// Call this method on page's "SavePageStateToPersistenceMedium" method
/// </summary>
/// <param name="clientScript">ClientScript object of page</param>
/// <param name="viewState">parameter of "SavePageStateToPersistenceMedium" method</param>
public static void CompressViewState(ClientScriptManager clientScript, object viewState, int splitSize = 4000)
{
LosFormatter formatter = new LosFormatter();
StringWriter writer = new StringWriter();
formatter.Serialize(writer, viewState);
string viewStateString = writer.ToString();
byte[] bytes = Convert.FromBase64String(viewStateString);
bytes = Compress(bytes);
int byteSplitSize = splitSize / 4 * 3;
for (int i = 0; i <= bytes.Length / byteSplitSize; i++)
{
int offset = i * byteSplitSize;
string base64 = Convert.ToBase64String(bytes, offset, Math.Min(byteSplitSize, bytes.Length - offset));
clientScript.RegisterHiddenField("__VSTATE" + i, base64);
}
}
public void Ctor0_Deny_Unrestricted()
{
LosFormatter lf = new LosFormatter();
MemoryStream ms = new MemoryStream();
lf.Serialize(ms, "mono");
ms.Position = 0;
Assert.IsNotNull(lf.Deserialize(ms), "Deserialize(Stream)");
StringWriter sw = new StringWriter();
lf.Serialize(sw, "mono");
string s = sw.ToString();
StringReader sr = new StringReader(s);
Assert.IsNotNull(lf.Deserialize(sr), "Deserialize(TextReader)");
Assert.IsNotNull(lf.Deserialize(s), "Deserialize(string)");
}
public void SaveAllState_ViewState()
{
var testPageHolder = new TestPageHolder(true, RequestMode.Get);
ControlReplacer replacer = SetupControlReplacerForIntegrationTest(testPageHolder.NamingContainer, new StateLoadingStrategy());
testPageHolder.PageInvoker.InitRecursive();
var formatter = new LosFormatter();
var state = (Pair)formatter.Deserialize(replacer.SaveAllState());
Pair replacerViewState = (Pair)state.Second;
Assert.That(replacerViewState.First, Is.EqualTo("value"));
var namingContainerViewState = (Pair)((IList)(replacerViewState).Second)[1];
Assert.That(namingContainerViewState.First, Is.EqualTo("NamingContainerValue"));
var parentViewState = (Pair)((IList)(namingContainerViewState).Second)[1];
Assert.That(parentViewState.First, Is.EqualTo("ParentValue"));
}
protected override object LoadPageStateFromPersistenceMedium()
{
object state = null;
try
{
StreamReader reader = new StreamReader(this.GenerateFileName());
LosFormatter formator = new LosFormatter();
state = formator.Deserialize(reader);
reader.Close();
}
catch (Exception)
{
this.Response.Redirect(string.Format("{0}.aspx", Path.GetFileNameWithoutExtension(this.Page.AppRelativeVirtualPath)));
}
return(state);
}
protected override String getViewStateBase64FromXMLTree(String viewStateXML)
{
LosFormatter formatter = new LosFormatter();
StringBuilder sb = new StringBuilder();
StringWriter writer = new StringWriter(sb);
XmlDocument dom = new XmlDocument();
StringReader reader = new StringReader(viewStateXML);
dom.Load(reader);
XmlElement xmlElement = (XmlElement)dom.DocumentElement.GetElementsByTagName("ViewStateDeserialized").Item(0);
object viewStateObjectTree = null;
if (xmlElement.Name == "ViewStateDeserialized")
{
viewStateObjectTree = buildObjectElement((XmlElement)xmlElement.ChildNodes.Item(0));
}
formatter.Serialize(writer, viewStateObjectTree);
return(sb.ToString());
}
string SerializeOverloads(LosFormatter lf, string message)
{
string stream_ser;
using (MemoryStream ms = new MemoryStream()) {
lf.Serialize(ms, String.Empty);
stream_ser = Convert.ToBase64String(ms.ToArray());
}
string tw_ser;
using (MemoryStream ms = new MemoryStream()) {
using (TextWriter tw = new StreamWriter(ms)) {
lf.Serialize(tw, String.Empty);
}
tw_ser = Convert.ToBase64String(ms.ToArray());
}
Assert.AreEqual(stream_ser, tw_ser, message);
return(stream_ser);
}
protected override object LoadPageStateFromPersistenceMedium()
{
object state = null;
try
{
StreamReader reader = new StreamReader(GenerateFileName());
LosFormatter formator = new LosFormatter();
state = formator.Deserialize(reader);
reader.Close();
}
catch (Exception ex)
{
Console.Write(ex);
Response.Redirect(Path.GetFileNameWithoutExtension(Page.AppRelativeVirtualPath) + ".aspx");
}
return(state);
}
//implementation of method
private object LoadViewState()
{
if (_formatter == null)
{
_formatter = new LosFormatter();
}
//Check if the client has form field that stores request key
if (null == Request.Form[VIEW_STATE_FIELD_NAME])
{
//Did not see form field for viewstate, return null to try to continue (could log event...)
return(null);
}
//Make sure it can be converted to request number (in case of corruption)
long lRequestNumber = 0;
try
{
lRequestNumber = Convert.ToInt64(Request.Form[VIEW_STATE_FIELD_NAME]);
}
catch
{
//Could not covert to request number, return null (could log event...)
return(null);
}
//Get the viewstate for this page
string _viewState = viewStateSvrMgr.GetViewStateSvrMgr().GetViewState(lRequestNumber);
//If find the viewstate on the server, convert it so ASP.Net can use it
if (_viewState == null)
{
return(null);
}
else
{
return(_formatter.Deserialize(_viewState));
}
}
public string GetCallbackResult()
{
if (this.callbackException == null)
{
string result;
try
{
Hashtable hashtable = new Hashtable();
hashtable["Items"] = this.Items;
hashtable["Cells"] = this.GetCells();
if (this.EnableViewState)
{
using (StringWriter stringWriter = new StringWriter())
{
LosFormatter losFormatter = new LosFormatter();
losFormatter.Serialize(stringWriter, ViewStateHelper.ToHashtable(this.ViewState));
hashtable["VsUpdate"] = stringWriter.ToString();
}
}
result = SimpleJsonSerializer.Serialize(hashtable);
}
catch (Exception ex)
{
if (HttpContext.Current.IsDebuggingEnabled)
{
result = "$$$" + ex;
}
else
{
result = "$$$" + ex.Message;
}
}
return(result);
}
if (HttpContext.Current.IsDebuggingEnabled)
{
return("$$$" + this.callbackException);
}
return("$$$" + this.callbackException.Message);
}
// http://sandarenu.blogspot.com/2007/02/determining-viewstate-size.html
protected override void SavePageStateToPersistenceMedium(object state)
{
base.SavePageStateToPersistenceMedium(state); // $$$ need to verify if this is first or last.
if (ConfigurationManager.AppSettings["ShowViewStateWarningThreshHold"] != null)
{
int viewStateThreshHold = Convert.ToInt32(ConfigurationManager.AppSettings["ShowViewStateWarningThreshHold"]);
if (viewStateThreshHold != 0)
{
base.SavePageStateToPersistenceMedium(state);
var format = new LosFormatter();
var writer = new StringWriter();
format.Serialize(writer, state);
int viewStateSize = writer.ToString().Length;
if (viewStateSize >= viewStateThreshHold)
{
string pageName = GetCurrentPageName();
Alert.Show(string.Format("ViewStateSize for: {0} = {1}", pageName, viewStateSize.ToString()));
//HttpContext.Current.Trace.Warn(pageName + ": The ViewState Size is:", viewStateSize.ToString());
}
}
}
}
/// <summary>
/// Deserializes a resource key using LosFormatter.
/// </summary>
/// <remarks>
/// The resource keys need to be serialized as they can be arbitrary objects.
/// </remarks>
/// <param name="key">The key to deserialize.</param>
/// <returns>The deserialized key.</returns>
private object DeserializeResourceKey(string key)
{
LosFormatter input = new LosFormatter();
return input.Deserialize(key);
}
protected override void SavePageStateToPersistenceMedium(object state)
{
LosFormatter format = new LosFormatter();
StringWriter sw = new StringWriter();
format.Serialize(sw, state);
string vw = sw.ToString();
byte[] bytes = Convert.FromBase64String(vw);
bytes = Zip.Compress(bytes);
string vwFinal = Convert.ToBase64String(bytes);
ScriptManager.RegisterHiddenField(Page, "__VSTATE", vwFinal);
}
/*public string FormatarCnpj(string cnpj)
{
MaskedTextProvider mtpCnpj = new MaskedTextProvider(@"00\.000\.000/0000-00");
mtpCnpj.Set(cnpj);
return cnpj.ToString();
}*/
#endregion
#region LoadPageStateFromPersistenceMedium
protected override object LoadPageStateFromPersistenceMedium()
{
string vState = this.Request.Form["__VSTATE"];
Byte[] bytes = Convert.FromBase64String(vState);
bytes = Zip.Decompress(bytes);
LosFormatter format = new LosFormatter();
return format.Deserialize(Convert.ToBase64String(bytes));
}
private object ToObject(string viewstate)
{
byte[] b = Convert.FromBase64String(viewstate);
LosFormatter lf = new LosFormatter();
return lf.Deserialize(Convert.ToBase64String(b));
}
/// ------------------------------------------------------------------
/// <summary>
/// Override the default page state persister to use the Session state
/// for persistence.
/// </summary>
/// <returns></returns>
/// ------------------------------------------------------------------
protected override object LoadPageStateFromPersistenceMedium()
{
string viewStateKey = Security.Decrypt(Request.Form["__ViewStateKey__"]);
LosFormatter los = new LosFormatter();
string value = DiskCache.GetValue(viewStateKey);
object o = los.Deserialize(value);
return o;
}
/// ------------------------------------------------------------------
/// <summary>
/// Override the default page state persister to use the Session state
/// for persistence.
/// </summary>
/// <param name="state"></param>
/// ------------------------------------------------------------------
protected override void SavePageStateToPersistenceMedium(object state)
{
string viewStateKey = Security.Decrypt(ViewStateKey.Text);
LosFormatter los = new LosFormatter();
StringWriter sw = new StringWriter();
los.Serialize(sw, state);
DiskCache.Add(viewStateKey, sw.ToString());
}
protected override object LoadPageStateFromPersistenceMedium()
{
byte[] b = Convert.FromBase64String(Request.Form["__VSTATE"]);
LosFormatter lf = new LosFormatter();
return lf.Deserialize(Convert.ToBase64String(Decompress(b)));
}
/// <summary>
/// Serializes a resource key using LosFormatter.
/// </summary>
/// <remarks>
/// The resource keys need to be serialized as they can be arbitrary objects.
/// </remarks>
/// <param name="key">The key to serialize.</param>
/// <returns>The serialized key.</returns>
private string SerializeResourceKey(object key)
{
LosFormatter output = new LosFormatter();
StringWriter writer = new StringWriter();
output.Serialize(writer, key);
return writer.ToString();
}
