Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

1273 lines
59 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="BlobPersonalizationState.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.UI.WebControls.WebParts {
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Web;
using System.Web.UI;
using System.Web.Util;
/// <devdoc>
/// </devdoc>
internal sealed class BlobPersonalizationState : PersonalizationState {
private const int PersonalizationVersion = (int)PersonalizationVersions.WhidbeyRTM;
private const string WebPartManagerPersonalizationID = "__wpm";
private bool _isPostRequest;
private IDictionary _personalizedControls;
private IDictionary _sharedState;
private IDictionary _userState;
private byte[] _rawUserData;
private IDictionary _extractedState;
/// <devdoc>
/// </devdoc>
public BlobPersonalizationState(WebPartManager webPartManager) : base(webPartManager) {
//
// Note that we don't use the IsPostBack property of Page because that
// is based on the presence of view state, which could be on the query string
// in a non-POST request as well. Instead we use the actual verb associated
// with the request.
// Note that there are other types of HttpVerb besides GET and POST. We only
// save personalization data for POST requests. (VSWhidbey 423433)
_isPostRequest = (webPartManager.Page.Request.HttpVerb == HttpVerb.POST);
}
/// <internalonly />
public override bool IsEmpty {
get {
return ((_extractedState == null) || (_extractedState.Count == 0));
}
}
/// <devdoc>
/// </devdoc>
private bool IsPostRequest {
get {
return _isPostRequest;
}
}
/// <devdoc>
/// </devdoc>
private PersonalizationScope PersonalizationScope {
get {
return WebPartManager.Personalization.Scope;
}
}
/// <devdoc>
/// This is for symmetry with the UserState property.
/// </devdoc>
private IDictionary SharedState {
get {
return _sharedState;
}
}
/// <devdoc>
/// User state is always loaded even if the WebPartManager is in shared
/// scope. So we on-demand deserialize the bytes.
/// </devdoc>
private IDictionary UserState {
get {
if (_rawUserData != null) {
_userState = DeserializeData(_rawUserData);
_rawUserData = null;
}
if (_userState == null) {
_userState = new HybridDictionary(/* caseInsensitive */ false);
}
return _userState;
}
}
/// <devdoc>
/// Does the work of applying personalization data into a control
/// </devdoc>
private void ApplyPersonalization(Control control, string personalizationID, bool isWebPartManager,
PersonalizationScope extractScope, GenericWebPart genericWebPart) {
Debug.Assert(control != null);
Debug.Assert(!String.IsNullOrEmpty(personalizationID));
if (_personalizedControls == null) {
_personalizedControls = new HybridDictionary(/* caseInsensitive */ false);
}
else {
// We shouldn't be applying personalization to the same control more than once
if (_personalizedControls.Contains(personalizationID)) {
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_CantApply, personalizationID));
}
}
IDictionary personalizableProperties =
PersonalizableAttribute.GetPersonalizablePropertyEntries(control.GetType());
if (SharedState == null) {
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotLoaded));
}
PersonalizationInfo sharedInfo = (PersonalizationInfo)SharedState[personalizationID];
PersonalizationInfo userInfo = null;
IDictionary defaultProperties = null;
IDictionary initialProperties = null;
PersonalizationDictionary customInitialProperties = null;
// WebPart.SetPersonalizationDirty() should only mark a control as dirty in the following circumstances:
// 1. During its IPersonalizable.Load() method
// 2. During its IVersioningPersonalizable.Load() method
// 3. During or after its ITrackingPersonalizable.EndLoad() method
// By exclusion, WebPart.SetPersonalizationDirty() should be a no-op in the following circumstances:
// 1. Before its IPersonalizable.Load() method
// 2. While we are setting the values of its [Personalizable] properties
// (VSWhidbey 392533)
ControlInfo ci = new ControlInfo();
ci._allowSetDirty = false;
_personalizedControls[personalizationID] = ci;
if (sharedInfo != null && sharedInfo._isStatic && !sharedInfo.IsMatchingControlType(control)) {
// Mismatch in saved data, so ignore it
sharedInfo = null;
if (PersonalizationScope == PersonalizationScope.Shared) {
SetControlDirty(control, personalizationID, isWebPartManager, true);
}
}
IPersonalizable customPersonalizable = control as IPersonalizable;
ITrackingPersonalizable trackingPersonalizable = control as ITrackingPersonalizable;
// The WebPart on which to set HasSharedData and HasUserData
WebPart hasDataWebPart = null;
if (!isWebPartManager) {
if (genericWebPart != null) {
hasDataWebPart = genericWebPart;
}
else {
Debug.Assert(control is WebPart);
hasDataWebPart = (WebPart)control;
}
}
try {
if (trackingPersonalizable != null) {
trackingPersonalizable.BeginLoad();
}
if (PersonalizationScope == PersonalizationScope.User) {
if (UserState == null) {
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotLoaded));
}
userInfo = (PersonalizationInfo)UserState[personalizationID];
if (userInfo != null && userInfo._isStatic && !userInfo.IsMatchingControlType(control)) {
// Mismatch in saved data, so ignore it
userInfo = null;
SetControlDirty(control, personalizationID, isWebPartManager, true);
}
if (customPersonalizable != null) {
PersonalizationDictionary customProperties = MergeCustomProperties(
sharedInfo, userInfo, isWebPartManager, hasDataWebPart, ref customInitialProperties);
if (customProperties != null) {
ci._allowSetDirty = true;
customPersonalizable.Load(customProperties);
ci._allowSetDirty = false;
}
}
if (!isWebPartManager) {
// Properties do not apply to the WebPartManager
IDictionary unusedSharedProperties = null;
IDictionary unusedUserProperties = null;
// To compute default properties in user scope, we must first
// apply the shared properties. Only differences detected from
// shared scope are to be persisted.
if (sharedInfo != null) {
IDictionary properties = sharedInfo._properties;
if ((properties != null) && (properties.Count != 0)) {
hasDataWebPart.SetHasSharedData(true);
unusedSharedProperties = SetPersonalizedProperties(control, personalizableProperties,
properties, PersonalizationScope.Shared);
}
}
defaultProperties = GetPersonalizedProperties(control, personalizableProperties, null, null,
extractScope);
// Now apply the user properties and hang on to the initial values
if (userInfo != null) {
IDictionary properties = userInfo._properties;
if ((properties != null) && (properties.Count != 0)) {
hasDataWebPart.SetHasUserData(true);
// We pass the extractScope as the PersonalizationScope in which to set the properties. For
// a shared WebPart, we want to only apply the user values to user properties, and not to
// shared properties. However, for an unshared WebPart, we want to apply the user values
// to both user and shared properties, since there is effectively no difference for an
// unshared WebPart. (VSWhidbey 349356)
unusedUserProperties = SetPersonalizedProperties(control, personalizableProperties,
properties, extractScope);
}
if ((trackingPersonalizable == null) || (trackingPersonalizable.TracksChanges == false)) {
initialProperties = properties;
}
}
bool hasUnusedProperties = ((unusedSharedProperties != null) || (unusedUserProperties != null));
if (hasUnusedProperties) {
IVersioningPersonalizable versioningPersonalizable = control as IVersioningPersonalizable;
if (versioningPersonalizable != null) {
IDictionary unusedProperties = null;
// Merge any unused properties, so they can be handed off to the
// control via IVersioningPersonalizable
if (unusedSharedProperties != null) {
unusedProperties = unusedSharedProperties;
if (unusedUserProperties != null) {
foreach (DictionaryEntry entry in unusedUserProperties) {
unusedProperties[entry.Key] = entry.Value;
}
}
}
else {
unusedProperties = unusedUserProperties;
}
ci._allowSetDirty = true;
versioningPersonalizable.Load(unusedProperties);
ci._allowSetDirty = false;
}
else {
// There were some unused properties, and they couldn't be loaded.
// Mark this control as dirty, so we clean up its personalization
// state later...
SetControlDirty(control, personalizationID, isWebPartManager, true);
}
}
}
}
else {
// Shared Personalization Scope
if (customPersonalizable != null) {
PersonalizationDictionary customProperties = MergeCustomProperties(
sharedInfo, userInfo, isWebPartManager, hasDataWebPart, ref customInitialProperties);
if (customProperties != null) {
ci._allowSetDirty = true;
customPersonalizable.Load(customProperties);
ci._allowSetDirty = false;
}
}
if (!isWebPartManager) {
IDictionary unusedProperties = null;
// Compute default properties. These are basically what was persisted
// in the markup
defaultProperties = GetPersonalizedProperties(control, personalizableProperties, null, null,
extractScope);
// Now apply shared properties and hang on to the initial values
if (sharedInfo != null) {
IDictionary properties = sharedInfo._properties;
if ((properties != null) && (properties.Count != 0)) {
hasDataWebPart.SetHasSharedData(true);
unusedProperties = SetPersonalizedProperties(control, personalizableProperties,
properties, PersonalizationScope.Shared);
}
if ((trackingPersonalizable == null) ||
(trackingPersonalizable.TracksChanges == false)) {
initialProperties = properties;
}
}
if (unusedProperties != null) {
IVersioningPersonalizable versioningPersonalizable = control as IVersioningPersonalizable;
if (versioningPersonalizable != null) {
ci._allowSetDirty = true;
versioningPersonalizable.Load(unusedProperties);
ci._allowSetDirty = false;
}
else {
// There were some unused properties, and they couldn't be loaded.
// Mark this control as dirty, so we clean up its personalization
// state later...
SetControlDirty(control, personalizationID, isWebPartManager, true);
}
}
}
}
}
finally {
ci._allowSetDirty = true;
if (trackingPersonalizable != null) {
trackingPersonalizable.EndLoad();
}
}
// Track this as one of the personalized controls
ci._control = control;
ci._personalizableProperties = personalizableProperties;
ci._defaultProperties = defaultProperties;
ci._initialProperties = initialProperties;
ci._customInitialProperties = customInitialProperties;
}
/// <internalonly />
public override void ApplyWebPartPersonalization(WebPart webPart) {
ValidateWebPart(webPart);
// Do not apply personalization to the UnauthorizedWebPart. It is never rendered
// in the page, so there is no point to applying the personalization to it.
// The personalization data from the original WebPart will be round-tripped in
// ExtractWebPartPersonalization(). We do apply personalization to the ErrorWebPart,
// because we want it to render with many of the personalized property values of the
// original WebPart.
if (webPart is UnauthorizedWebPart) {
return;
}
string personalizationID = CreatePersonalizationID(webPart, null);
// In ApplyPersonalization(), we need to extract the default properites in the same scope we will
// extract the properties in ExtractPersonalization().
PersonalizationScope extractScope = PersonalizationScope;
if ((extractScope == PersonalizationScope.User) && (!webPart.IsShared)) {
// This implies a user owned WebPart in User mode, so extract all
// the properties
extractScope = PersonalizationScope.Shared;
}
ApplyPersonalization(webPart, personalizationID, /* isWebPartManager */ false, extractScope,
/* genericWebPart */ null);
GenericWebPart genericWebPart = webPart as GenericWebPart;
if (genericWebPart != null) {
Control containedControl = genericWebPart.ChildControl;
personalizationID = CreatePersonalizationID(containedControl, genericWebPart);
ApplyPersonalization(containedControl, personalizationID, /* isWebPartManager */ false, extractScope,
genericWebPart);
}
}
/// <internalonly />
public override void ApplyWebPartManagerPersonalization() {
ApplyPersonalization(WebPartManager, WebPartManagerPersonalizationID, /* isWebPartManager */ true,
PersonalizationScope, /* genericWebPart */ null);
}
/// <devdoc>
/// Returns false if the set of new properties are the same as old ones; true if there
/// are differences.
/// </devdoc>
private bool CompareProperties(IDictionary newProperties, IDictionary oldProperties) {
int newCount = 0;
int oldCount = 0;
if (newProperties != null) {
newCount = newProperties.Count;
}
if (oldProperties != null) {
oldCount = oldProperties.Count;
}
if (newCount != oldCount) {
return true;
}
if (newCount != 0) {
foreach (DictionaryEntry entry in newProperties) {
object name = entry.Key;
object newValue = entry.Value;
if (oldProperties.Contains(name)) {
object oldValue = oldProperties[name];
if (Object.Equals(newValue, oldValue) == false) {
return true;
}
}
else {
return true;
}
}
}
return false;
}
private string CreatePersonalizationID(string ID, string genericWebPartID) {
Debug.Assert(!String.IsNullOrEmpty(ID));
if (!String.IsNullOrEmpty(genericWebPartID)) {
return ID + Control.ID_SEPARATOR + genericWebPartID;
}
else {
return ID;
}
}
private string CreatePersonalizationID(Control control, WebPart associatedGenericWebPart) {
if (associatedGenericWebPart != null) {
return CreatePersonalizationID(control.ID, associatedGenericWebPart.ID);
}
return CreatePersonalizationID(control.ID, null);
}
/// <devdoc>
/// Deserializes personalization data packed as a blob of binary data
/// into a dictionary with personalization IDs mapped to
/// PersonalizationInfo objects.
/// </devdoc>
private static IDictionary DeserializeData(byte[] data) {
IDictionary deserializedData = null;
if ((data != null) && (data.Length > 0)) {
Exception deserializationException = null;
int version = -1;
object[] items = null;
int offset = 0;
// Deserialize the data
try {
ObjectStateFormatter formatter =
new ObjectStateFormatter(null /* Page(used to determine encryption mode) */, false /*throwOnErrorDeserializing*/);
if (!HttpRuntime.DisableProcessRequestInApplicationTrust) {
// This is more of a consistency and defense-in-depth fix. Currently we believe
// only user code or code with restricted permissions will be running on the stack.
// However, to mirror the fix for Session State, and also to hedge against future
// scenarios where our current assumptions may change, we should restrict the running
// thread to only the permission set currently defined for the app domain.
// VSWhidbey 427533
if (HttpRuntime.NamedPermissionSet != null && HttpRuntime.ProcessRequestInApplicationTrust) {
HttpRuntime.NamedPermissionSet.PermitOnly();
}
}
items = (object[])formatter.DeserializeWithAssert(new MemoryStream(data));
if (items != null && items.Length != 0) {
version = (int)items[offset++];
}
}
catch (Exception e) {
deserializationException = e;
}
if (version == (int)PersonalizationVersions.WhidbeyBeta2 || version == (int)PersonalizationVersions.WhidbeyRTM) {
try {
// Build up the dictionary of PersonalizationInfo objects
int infoListCount = (int)items[offset++];
if (infoListCount > 0) {
deserializedData = new HybridDictionary(infoListCount, /* caseInsensitive */ false);
}
for (int i = 0; i < infoListCount; i++) {
string controlID;
bool isStatic;
Type controlType = null;
VirtualPath controlVPath = null;
// If this is a dynamic WebPart or control, the Type is not saved in personalization,
// so the first item is the controlID. If this is a static WebPart or control, the
// first item is the control Type.
object item = items[offset++];
if (item is string) {
controlID = (string)item;
isStatic = false;
}
else {
controlType = (Type)item;
if (controlType == typeof(UserControl)) {
controlVPath = VirtualPath.CreateNonRelativeAllowNull((string)items[offset++]);
}
controlID = (string)items[offset++];
isStatic = true;
}
IDictionary properties = null;
int propertyCount = (int)items[offset++];
if (propertyCount > 0) {
properties = new HybridDictionary(propertyCount, /* caseInsensitive */ false);
for (int j = 0; j < propertyCount; j++) {
string propertyName = ((IndexedString)items[offset++]).Value;
object propertyValue = items[offset++];
properties[propertyName] = propertyValue;
}
}
PersonalizationDictionary customProperties = null;
int customPropertyCount = (int)items[offset++];
if (customPropertyCount > 0) {
customProperties = new PersonalizationDictionary(customPropertyCount);
for (int j = 0; j < customPropertyCount; j++) {
string propertyName = ((IndexedString)items[offset++]).Value;
object propertyValue = items[offset++];
PersonalizationScope propertyScope =
(bool)items[offset++] ? PersonalizationScope.Shared : PersonalizationScope.User;
bool isSensitive = false;
if (version == (int)PersonalizationVersions.WhidbeyRTM) {
isSensitive = (bool)items[offset++];
}
customProperties[propertyName] =
new PersonalizationEntry(propertyValue, propertyScope, isSensitive);
}
}
PersonalizationInfo info = new PersonalizationInfo();
info._controlID = controlID;
info._controlType = controlType;
info._controlVPath = controlVPath;
info._isStatic = isStatic;
info._properties = properties;
info._customProperties = customProperties;
deserializedData[controlID] = info;
}
}
catch (Exception e) {
deserializationException = e;
}
}
// Check that there was no deserialization error, and that
// the data conforms to our known version
if ((deserializationException != null) ||
(version != (int)PersonalizationVersions.WhidbeyBeta2 && version != (int)PersonalizationVersions.WhidbeyRTM)) {
throw new ArgumentException(SR.GetString(SR.BlobPersonalizationState_DeserializeError),
"data", deserializationException);
}
}
if (deserializedData == null) {
deserializedData = new HybridDictionary(/* caseInsensitive */ false);
}
return deserializedData;
}
/// <devdoc>
/// Does the actual work of extracting personalizated data from a control
/// </devdoc>
private void ExtractPersonalization(Control control, string personalizationID, bool isWebPartManager,
PersonalizationScope scope, bool isStatic, GenericWebPart genericWebPart) {
Debug.Assert(control != null);
Debug.Assert(!String.IsNullOrEmpty(personalizationID));
if (_extractedState == null) {
_extractedState = new HybridDictionary(/* caseInsensitive */ false);
}
if (_personalizedControls == null) {
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotApplied));
}
ControlInfo ci = (ControlInfo)_personalizedControls[personalizationID];
// The ControlInfo should always have been already created in ApplyPersonalization().
// However, it will be null if the Control's ID has changed since we loaded personalization data.
// This is not supported, but we should throw a helpful exception. (VSWhidbey 372354)
if (ci == null) {
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_CantExtract, personalizationID));
}
ITrackingPersonalizable trackingPersonalizable = control as ITrackingPersonalizable;
IPersonalizable customPersonalizable = control as IPersonalizable;
IDictionary properties = ci._initialProperties;
PersonalizationDictionary customProperties = ci._customInitialProperties;
bool changed = false;
try {
if (trackingPersonalizable != null) {
trackingPersonalizable.BeginSave();
}
if (!IsPostRequest) {
// In non-POST requests, we only save those WebParts that indicated explicitely that
// they have changed. For other WebParts, we just round-trip the initial state
// that was loaded.
if (ci._dirty) {
// Always save IPersonalizable data if the WebPart has indicated that it is dirty
if (customPersonalizable != null) {
PersonalizationDictionary tempCustomProperties = new PersonalizationDictionary();
customPersonalizable.Save(tempCustomProperties);
if ((tempCustomProperties.Count != 0) ||
((customProperties != null) && (customProperties.Count != 0))) {
if (scope == PersonalizationScope.User) {
tempCustomProperties.RemoveSharedProperties();
}
customProperties = tempCustomProperties;
}
}
if (!isWebPartManager) {
// WebPartManager does not have personalizable properties
properties =
GetPersonalizedProperties(control, ci._personalizableProperties,
ci._defaultProperties, ci._initialProperties, scope);
}
changed = true;
}
}
else {
bool extractProperties = true;
bool diffWithInitialProperties = true;
if (ci._dirty) {
// WebPart is indicating that it is dirty, so there is no need
// for us to perform a diff
diffWithInitialProperties = false;
}
else if ((trackingPersonalizable != null) &&
(trackingPersonalizable.TracksChanges) &&
(ci._dirty == false)) {
// WebPart is indicating that it is not dirty, and since it
// tracks dirty-ness, theres no need to do additional work.
extractProperties = false;
}
if (extractProperties) {
// Always save IPersonalizable data if the WebPart has indicated that it is dirty
if (customPersonalizable != null && (ci._dirty || customPersonalizable.IsDirty)) {
PersonalizationDictionary tempCustomProperties = new PersonalizationDictionary();
customPersonalizable.Save(tempCustomProperties);
// The new custom properties should be used either if they are
// non-empty, or they are, but the original ones weren't, since
// that implies a change as well.
if ((tempCustomProperties.Count != 0) ||
((customProperties != null) && (customProperties.Count != 0))) {
if (tempCustomProperties.Count != 0) {
if (scope == PersonalizationScope.User) {
tempCustomProperties.RemoveSharedProperties();
}
customProperties = tempCustomProperties;
}
else {
customProperties = null;
}
// No point doing the diff, since we've already determined that the
// custom properties are dirty.
diffWithInitialProperties = false;
changed = true;
}
}
if (!isWebPartManager) {
// WebPartManager does not have personalizable properties
IDictionary newProperties =
GetPersonalizedProperties(control, ci._personalizableProperties,
ci._defaultProperties, ci._initialProperties, scope);
if (diffWithInitialProperties) {
bool different = CompareProperties(newProperties, ci._initialProperties);
if (different == false) {
extractProperties = false;
}
}
if (extractProperties) {
properties = newProperties;
changed = true;
}
}
}
}
}
finally {
if (trackingPersonalizable != null) {
trackingPersonalizable.EndSave();
}
}
PersonalizationInfo extractedInfo = new PersonalizationInfo();
extractedInfo._controlID = personalizationID;
if (isStatic) {
UserControl uc = control as UserControl;
if (uc != null) {
extractedInfo._controlType = typeof(UserControl);
extractedInfo._controlVPath = uc.TemplateControlVirtualPath;
}
else {
extractedInfo._controlType = control.GetType();
}
}
extractedInfo._isStatic = isStatic;
extractedInfo._properties = properties;
extractedInfo._customProperties = customProperties;
_extractedState[personalizationID] = extractedInfo;
if (changed) {
SetDirty();
}
if ((properties != null && properties.Count > 0) ||
(customProperties != null && customProperties.Count > 0)) {
// The WebPart on which to set HasSharedData and HasUserData
WebPart hasDataWebPart = null;
if (!isWebPartManager) {
if (genericWebPart != null) {
hasDataWebPart = genericWebPart;
}
else {
Debug.Assert(control is WebPart);
hasDataWebPart = (WebPart)control;
}
}
if (hasDataWebPart != null) {
if (PersonalizationScope == PersonalizationScope.Shared) {
hasDataWebPart.SetHasSharedData(true);
}
else {
hasDataWebPart.SetHasUserData(true);
}
}
}
}
/// <internalonly />
public override void ExtractWebPartPersonalization(WebPart webPart) {
ValidateWebPart(webPart);
// Round-trip the personalization data for a ProxyWebPart
ProxyWebPart proxyWebPart = webPart as ProxyWebPart;
if (proxyWebPart != null) {
RoundTripWebPartPersonalization(proxyWebPart.OriginalID, proxyWebPart.GenericWebPartID);
return;
}
PersonalizationScope extractScope = PersonalizationScope;
if ((extractScope == PersonalizationScope.User) && (!webPart.IsShared)) {
// This implies a user owned WebPart in User mode, so save all
// the properties
extractScope = PersonalizationScope.Shared;
}
bool isStatic = webPart.IsStatic;
string personalizationID = CreatePersonalizationID(webPart, null);
ExtractPersonalization(webPart, personalizationID, /* isWebPartManager */ false, extractScope, isStatic,
/* genericWebPart */ null);
GenericWebPart genericWebPart = webPart as GenericWebPart;
if (genericWebPart != null) {
Control containedControl = genericWebPart.ChildControl;
personalizationID = CreatePersonalizationID(containedControl, genericWebPart);
ExtractPersonalization(containedControl, personalizationID, /* isWebPartManager */ false,
extractScope, isStatic, genericWebPart);
}
}
/// <internalonly />
public override void ExtractWebPartManagerPersonalization() {
ExtractPersonalization(WebPartManager, WebPartManagerPersonalizationID, /* isWebPartManager */ true,
PersonalizationScope, /* isStatic */ true, /* genericWebPart */ null);
}
// Returns the AuthorizationFilter string for a WebPart before it is instantiated.
// Returns null if there is no personalized value for AuthorizationFilter, or if the
// personalized value has a type other than string.
public override string GetAuthorizationFilter(string webPartID) {
if (String.IsNullOrEmpty(webPartID)) {
throw ExceptionUtil.ParameterNullOrEmpty("webPartID");
}
return GetPersonalizedValue(webPartID, "AuthorizationFilter") as string;
}
/// <devdoc>
/// </devdoc>
internal static IDictionary GetPersonalizedProperties(Control control, PersonalizationScope scope) {
IDictionary personalizableProperties =
PersonalizableAttribute.GetPersonalizablePropertyEntries(control.GetType());
return GetPersonalizedProperties(control, personalizableProperties, null, null, scope);
}
/// <devdoc>
/// Does the work of retrieving personalized properties. If the scope is User, the shared
/// personalizable properties are not retrieved. If a non-null defaultPropertyState is
/// handed in, only the properties that are different from the default values are retrieved.
/// </devdoc>
private static IDictionary GetPersonalizedProperties(Control control,
IDictionary personalizableProperties,
IDictionary defaultPropertyState,
IDictionary initialPropertyState,
PersonalizationScope scope) {
Debug.Assert(control != null);
if (personalizableProperties.Count == 0) {
return null;
}
bool ignoreSharedProperties = (scope == PersonalizationScope.User);
IDictionary properties = null;
foreach (DictionaryEntry entry in personalizableProperties) {
PersonalizablePropertyEntry property = (PersonalizablePropertyEntry)entry.Value;
if (ignoreSharedProperties && (property.Scope == PersonalizationScope.Shared)) {
continue;
}
PropertyInfo pi = property.PropertyInfo;
Debug.Assert(pi != null);
//
string name = (string)entry.Key;
object value = FastPropertyAccessor.GetProperty(control, name, control.DesignMode);
bool saveProperty = true;
// Only compare to default value if there is no initial value.
if ((initialPropertyState == null || !initialPropertyState.Contains(name)) && defaultPropertyState != null) {
object defaultValue = defaultPropertyState[name];
if (Object.Equals(value, defaultValue)) {
saveProperty = false;
}
}
if (saveProperty) {
if (properties == null) {
properties = new HybridDictionary(personalizableProperties.Count, /* caseInsensitive */ false);
}
properties[name] = value;
}
}
return properties;
}
// Returns the value of a personalized property on a control
// Returns null if there is no personalized value for the property
private object GetPersonalizedValue(string personalizationID, string propertyName) {
Debug.Assert(!String.IsNullOrEmpty(personalizationID));
Debug.Assert(!String.IsNullOrEmpty(propertyName));
if (SharedState == null) {
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotLoaded));
}
PersonalizationInfo sharedInfo = (PersonalizationInfo)SharedState[personalizationID];
IDictionary sharedProperties = (sharedInfo != null) ? sharedInfo._properties : null;
if (PersonalizationScope == PersonalizationScope.Shared) {
if (sharedProperties != null) {
return sharedProperties[propertyName];
}
}
else {
if (UserState == null) {
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotLoaded));
}
PersonalizationInfo userInfo = (PersonalizationInfo)UserState[personalizationID];
IDictionary userProperties = (userInfo != null) ? userInfo._properties : null;
if (userProperties != null && userProperties.Contains(propertyName)) {
return userProperties[propertyName];
}
else if (sharedProperties != null) {
return sharedProperties[propertyName];
}
}
return null;
}
/// <devdoc>
/// </devdoc>
public void LoadDataBlobs(byte[] sharedData, byte[] userData) {
_sharedState = DeserializeData(sharedData);
_rawUserData = userData;
}
// Returns a PersonalizationDictionary containing a merged view of the custom properties
// in both the sharedInfo and the userInfo.
private PersonalizationDictionary MergeCustomProperties(PersonalizationInfo sharedInfo,
PersonalizationInfo userInfo,
bool isWebPartManager, WebPart hasDataWebPart,
ref PersonalizationDictionary customInitialProperties) {
PersonalizationDictionary customProperties = null;
bool hasSharedCustomProperties = (sharedInfo != null && sharedInfo._customProperties != null);
bool hasUserCustomProperties = (userInfo != null && userInfo._customProperties != null);
// Fill or set the customProperties dictionary
if (hasSharedCustomProperties && hasUserCustomProperties) {
customProperties = new PersonalizationDictionary();
foreach (DictionaryEntry entry in sharedInfo._customProperties) {
customProperties[(string)entry.Key] = (PersonalizationEntry)entry.Value;
}
foreach (DictionaryEntry entry in userInfo._customProperties) {
customProperties[(string)entry.Key] = (PersonalizationEntry)entry.Value;
}
}
else if (hasSharedCustomProperties) {
customProperties = sharedInfo._customProperties;
}
else if (hasUserCustomProperties) {
customProperties = userInfo._customProperties;
}
// Set the customInitialProperties dictionary
if (PersonalizationScope == PersonalizationScope.Shared && hasSharedCustomProperties) {
customInitialProperties = sharedInfo._customProperties;
}
else if (PersonalizationScope == PersonalizationScope.User && hasUserCustomProperties) {
customInitialProperties = userInfo._customProperties;
}
// Set the HasSharedData and HasUserData flags
if (hasSharedCustomProperties && !isWebPartManager) {
hasDataWebPart.SetHasSharedData(true);
}
if (hasUserCustomProperties && !isWebPartManager) {
hasDataWebPart.SetHasUserData(true);
}
return customProperties;
}
private void RoundTripWebPartPersonalization(string ID, string genericWebPartID) {
if (String.IsNullOrEmpty(ID)) {
throw ExceptionUtil.ParameterNullOrEmpty("ID");
}
// Round-trip personalization for control/WebPart
string personalizationID = CreatePersonalizationID(ID, genericWebPartID);
RoundTripWebPartPersonalization(personalizationID);
// Round-trip personalization for GenericWebPart, if necessary
if (!String.IsNullOrEmpty(genericWebPartID)) {
string genericPersonalizationID = CreatePersonalizationID(genericWebPartID, null);
RoundTripWebPartPersonalization(genericPersonalizationID);
}
}
private void RoundTripWebPartPersonalization(string personalizationID) {
Debug.Assert(personalizationID != null);
// Can't check that personalizationID is valid, since there may be no data
// for even a valid ID.
if (PersonalizationScope == PersonalizationScope.Shared) {
if (SharedState == null) {
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotLoaded));
}
if (SharedState.Contains(personalizationID)) {
_extractedState[personalizationID] = (PersonalizationInfo)SharedState[personalizationID];
}
}
else {
if (UserState == null) {
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotLoaded));
}
if (UserState.Contains(personalizationID)) {
_extractedState[personalizationID] = (PersonalizationInfo)UserState[personalizationID];
}
}
}
/// <devdoc>
/// </devdoc>
public byte[] SaveDataBlob() {
return SerializeData(_extractedState);
}
/// <devdoc>
/// Serializes a dictionary of IDs mapped to PersonalizationInfo
/// objects into a binary blob.
/// </devdoc>
private static byte[] SerializeData(IDictionary data) {
byte[] serializedData = null;
if ((data == null) || (data.Count == 0)) {
return serializedData;
}
ArrayList infoList = new ArrayList();
foreach (DictionaryEntry entry in data) {
PersonalizationInfo info = (PersonalizationInfo)entry.Value;
if (((info._properties != null) && (info._properties.Count != 0)) ||
((info._customProperties != null) && (info._customProperties.Count != 0))){
infoList.Add(info);
}
}
if (infoList.Count != 0) {
ArrayList items = new ArrayList();
items.Add(PersonalizationVersion);
items.Add(infoList.Count);
foreach (PersonalizationInfo info in infoList) {
// Only need to save the type information for static WebParts
if (info._isStatic) {
items.Add(info._controlType);
if (info._controlVPath != null) {
items.Add(info._controlVPath.AppRelativeVirtualPathString);
}
}
items.Add(info._controlID);
int propertyCount = 0;
if (info._properties != null) {
propertyCount = info._properties.Count;
}
items.Add(propertyCount);
if (propertyCount != 0) {
foreach (DictionaryEntry propertyEntry in info._properties) {
items.Add(new IndexedString((string)propertyEntry.Key));
items.Add(propertyEntry.Value);
}
}
int customPropertyCount = 0;
if (info._customProperties != null) {
customPropertyCount = info._customProperties.Count;
}
items.Add(customPropertyCount);
if (customPropertyCount != 0) {
foreach (DictionaryEntry customPropertyEntry in info._customProperties) {
items.Add(new IndexedString((string)customPropertyEntry.Key));
PersonalizationEntry personalizationEntry = (PersonalizationEntry)customPropertyEntry.Value;
items.Add(personalizationEntry.Value);
// PERF: Add a boolean instead of the Enum value
items.Add(personalizationEntry.Scope == PersonalizationScope.Shared);
// The IsSensitive property was added between Whidbey Beta2 and Whidbey RTM.
// VSWhidbey 502554 and 536907
items.Add(personalizationEntry.IsSensitive);
}
}
}
if (items.Count != 0) {
ObjectStateFormatter formatter = new ObjectStateFormatter(null, false);
MemoryStream ms = new MemoryStream(1024);
object[] state = items.ToArray();
if (!HttpRuntime.DisableProcessRequestInApplicationTrust){
// This is more of a consistency and defense-in-depth fix. Currently we believe
// only user code or code with restricted permissions will be running on the stack.
// However, to mirror the fix for Session State, and also to hedge against future
// scenarios where our current assumptions may change, we should restrict the running
// thread to only the permission set currently defined for the app domain.
// VSWhidbey 491449
if (HttpRuntime.NamedPermissionSet != null && HttpRuntime.ProcessRequestInApplicationTrust) {
HttpRuntime.NamedPermissionSet.PermitOnly();
}
}
formatter.SerializeWithAssert(ms, state);
serializedData = ms.ToArray();
}
}
return serializedData;
}
/// <devdoc>
/// Only actually sets the control as dirty if we have already started applying personalization
/// data (info != null), and we are forcing the control to be dirty (forceSetDirty), or the control
/// has called SetPersonalizationDirty() at the right time (info._allowSetDirty).
/// </devdoc>
private void SetControlDirty(Control control, string personalizationID, bool isWebPartManager,
bool forceSetDirty) {
Debug.Assert(control != null);
Debug.Assert(!String.IsNullOrEmpty(personalizationID));
if (_personalizedControls == null) {
throw new InvalidOperationException(SR.GetString(SR.BlobPersonalizationState_NotApplied));
}
ControlInfo info = (ControlInfo)_personalizedControls[personalizationID];
if (info != null && (forceSetDirty || info._allowSetDirty)) {
info._dirty = true;
}
}
/// <devdoc>
/// Called by WebPartPersonalization to copy the personalized values from one control
/// to another.
/// </devdoc>
internal static IDictionary SetPersonalizedProperties(Control control, IDictionary propertyState) {
IDictionary personalizableProperties =
PersonalizableAttribute.GetPersonalizablePropertyEntries(control.GetType());
// We pass PersonalizationScope.Shared, since we want to apply all values to their properties.
return SetPersonalizedProperties(control, personalizableProperties, propertyState, PersonalizationScope.Shared);
}
/// <devdoc>
/// Does the work of setting personalized properties
/// </devdoc>
private static IDictionary SetPersonalizedProperties(Control control, IDictionary personalizableProperties,
IDictionary propertyState, PersonalizationScope scope) {
if (personalizableProperties.Count == 0) {
// all properties were not used
return propertyState;
}
if ((propertyState == null) || (propertyState.Count == 0)) {
return null;
}
IDictionary unusedProperties = null;
foreach (DictionaryEntry entry in propertyState) {
string name = (string)entry.Key;
object value = entry.Value;
PersonalizablePropertyEntry property = (PersonalizablePropertyEntry)personalizableProperties[name];
bool propertySet = false;
// Do not apply a user value to a shared property. This scenario can happen if there
// is already User data for a property, then the property is changed from Personalizable(User)
// to Personalizable(Shared). (VSWhidbey 349456)
if (property != null &&
(scope == PersonalizationScope.Shared || property.Scope == PersonalizationScope.User)) {
PropertyInfo pi = property.PropertyInfo;
Debug.Assert(pi != null);
// If SetProperty() throws an exception, the property will be added to the unusedProperties collection
try {
FastPropertyAccessor.SetProperty(control, name, value, control.DesignMode);
propertySet = true;
}
catch {
}
}
if (!propertySet) {
if (unusedProperties == null) {
unusedProperties = new HybridDictionary(propertyState.Count, /* caseInsensitive */ false);
}
unusedProperties[name] = value;
}
}
return unusedProperties;
}
/// <internalonly />
public override void SetWebPartDirty(WebPart webPart) {
ValidateWebPart(webPart);
string personalizationID;
personalizationID = CreatePersonalizationID(webPart, null);
SetControlDirty(webPart, personalizationID, /* isWebPartManager */ false, /* forceSetDirty */ false);
GenericWebPart genericWebPart = webPart as GenericWebPart;
if (genericWebPart != null) {
Control containedControl = genericWebPart.ChildControl;
personalizationID = CreatePersonalizationID(containedControl, genericWebPart);
SetControlDirty(containedControl, personalizationID, /* isWebPartManager */ false, /* forceSetDirty */ false);
}
}
/// <internalonly />
public override void SetWebPartManagerDirty() {
SetControlDirty(WebPartManager, WebPartManagerPersonalizationID, /* isWebPartManager */ true,
/* forceSetDirty */ false);
}
/// <devdoc>
/// Used to track personalization information, i.e. the data,
/// and the associated object type and ID.
/// </devdoc>
private sealed class PersonalizationInfo {
public Type _controlType;
public VirtualPath _controlVPath;
public string _controlID;
public bool _isStatic;
public IDictionary _properties;
public PersonalizationDictionary _customProperties;
public bool IsMatchingControlType(Control c) {
if (c is ProxyWebPart) {
// This code path is currently never hit, since we only load personalization data
// for ErrorWebPart, and we only replace dynamic WebParts with the ErrorWebPart,
// and we only check IsMatchingControlType() for static WebParts. However, if this
// ever changes in the future, we will want to return true for ProxyWebParts.
return true;
}
else if (_controlType == null) {
// _controlType will be null if there is no longer a Type on the system with the
// saved type name.
return false;
}
else if (_controlType == typeof(UserControl)) {
UserControl uc = c as UserControl;
if (uc != null) {
return uc.TemplateControlVirtualPath == _controlVPath;
}
return false;
}
else {
return _controlType.IsAssignableFrom(c.GetType());
}
}
}
/// <devdoc>
/// Used to track personalization information for a Control instance.
/// </devdoc>
private sealed class ControlInfo {
public Control _control;
public IDictionary _personalizableProperties;
public bool _dirty;
public bool _allowSetDirty;
public IDictionary _defaultProperties;
public IDictionary _initialProperties;
public PersonalizationDictionary _customInitialProperties;
}
private enum PersonalizationVersions {
WhidbeyBeta2 = 1,
WhidbeyRTM = 2,
}
}
}