// Will be called when MySettingsClass.GetPreviousVersion(propName) is called
// This method's job is to retrieve a setting value from the previous version
// of the settings w/o updating the setting at the storage location
public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty prop)
{
// If there's no previous setting version, return an empty property
// NOTE: the LFSP returns an empty property for all app-scoped settings, so so do we
string previousVersion = GetPreviousVersionNumber();
if (IsApplicationScoped(prop) || string.IsNullOrEmpty(previousVersion))
{
// NOTE: can't just return null, as the settings engine turns that into
// a default property -- have to return a SettingsPropertyValue object
// with the PropertyValue set to null to really build an empty property
SettingsPropertyValue propval = new SettingsPropertyValue(prop);
propval.PropertyValue = null;
return propval;
}
// Get the property value from the previous version
// NOTE: if it's null, the settings machinery will assume the current default value
// ideally, we'd want to use the previous version's default value, but a) that's
// likely to be the current default value and b) if it's not, that data is lost
return GetPropertyValue(prop, previousVersion);
}
private static string GetDefaultValue(SettingsProperty setting)
{
return(setting.DefaultValue?.ToString() ?? string.Empty);
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection properties)
{
ExTraceGlobals.ProgramFlowTracer.TraceFunction <ExchangeSettingsProvider>(0L, "-->ExchangeSettingsProvider.GetPropertyValues: {0}", this);
SettingsPropertyValueCollection settingsPropertyValueCollection = new SettingsPropertyValueCollection();
string key = (string)context["SettingsKey"];
IDictionary dictionary = (IDictionary)this.settingsStore[key];
foreach (object obj in properties)
{
SettingsProperty settingsProperty = (SettingsProperty)obj;
string name = settingsProperty.Name;
SettingsPropertyValue settingsPropertyValue = new SettingsPropertyValue(settingsProperty);
if (dictionary == null || !dictionary.Contains(name))
{
goto IL_114;
}
ExTraceGlobals.DataFlowTracer.TraceFunction <string, object, Type>(0L, "*--ExchangeSettingsProvider.GetPropertyValues: Converting and setting value: {0} = {1} as {2}", name, dictionary[name], settingsProperty.PropertyType);
if (dictionary[name] != null || !settingsProperty.PropertyType.IsValueType)
{
try
{
settingsPropertyValue.PropertyValue = Convert.ChangeType(dictionary[name], settingsProperty.PropertyType);
goto IL_24D;
}
catch (InvalidCastException arg)
{
ExTraceGlobals.DataFlowTracer.TraceError <InvalidCastException>(0L, "Exception in ExchangeSettingsProvider.GetPropertyValues: {0}", arg);
settingsPropertyValue.PropertyValue = settingsPropertyValue.Property.DefaultValue;
goto IL_24D;
}
goto IL_114;
}
settingsPropertyValue.PropertyValue = settingsPropertyValue.Property.DefaultValue;
IL_24D:
settingsPropertyValueCollection.Add(settingsPropertyValue);
continue;
IL_114:
if (string.IsNullOrEmpty((string)settingsProperty.DefaultValue))
{
ExTraceGlobals.DataFlowTracer.TraceFunction <string, Type>(0L, "*--ExchangeSettingsProvider.GetPropertyValues: Setting to null: {0} as {1}", name, settingsProperty.PropertyType);
settingsPropertyValue.PropertyValue = null;
goto IL_24D;
}
if (typeof(Enum).IsAssignableFrom(settingsProperty.PropertyType))
{
ExTraceGlobals.DataFlowTracer.TraceFunction <string, object, Type>(0L, "*--ExchangeSettingsProvider.GetPropertyValues: Converting and setting enum value: {0} = {1} as {2}", name, settingsProperty.DefaultValue, settingsProperty.PropertyType);
settingsPropertyValue.PropertyValue = EnumValidator.Parse(settingsProperty.PropertyType, (string)settingsProperty.DefaultValue, EnumParseOptions.IgnoreCase);
goto IL_24D;
}
MethodInfo method = settingsProperty.PropertyType.GetMethod("Parse", BindingFlags.Static | BindingFlags.Public, null, new Type[]
{
typeof(string)
}, null);
if (null != method)
{
ExTraceGlobals.DataFlowTracer.TraceFunction <string, object, Type>(0L, "*--ExchangeSettingsProvider.GetPropertyValues: Parsing value: {0} = {1} as {2}", name, settingsProperty.DefaultValue, settingsProperty.PropertyType);
settingsPropertyValue.PropertyValue = method.Invoke(null, new object[]
{
settingsProperty.DefaultValue
});
goto IL_24D;
}
ExTraceGlobals.DataFlowTracer.TraceFunction <string, object, Type>(0L, "*--ExchangeSettingsProvider.GetPropertyValues: Using default value: {0} = {1} as {2}", name, settingsProperty.DefaultValue, settingsProperty.PropertyType);
settingsPropertyValue.SerializedValue = settingsProperty.DefaultValue;
goto IL_24D;
}
ExTraceGlobals.ProgramFlowTracer.TraceFunction <ExchangeSettingsProvider>(0L, "<--ExchangeSettingsProvider.GetPropertyValues: {0}", this);
return(settingsPropertyValueCollection);
}
ProfilePropertyViewModel.ProfilePropertyType PropTypeFromPropertyType(SettingsProperty prop)
{
return(prop.PropertyType == typeof(Boolean) ?
ProfilePropertyViewModel.ProfilePropertyType.Boolean :
ProfilePropertyViewModel.ProfilePropertyType.String);
}
// Creates a sub-key under HKCU\Software\CompanyName\ProductName\version
RegistryKey CreateRegKey(SettingsProperty prop, string version)
{
Debug.Assert(!IsApplicationScoped(prop), "Can't get Registry key for a read-only Application scoped setting: " + prop.Name);
return Registry.LocalMachine.CreateSubKey(GetSubKeyPath(version));
}
// Retrieve values from the configuration file, or if the setting does not exist in the file,
// retrieve the value from the application's default configuration
private object GetSetting(SettingsProperty setProp)
{
object retVal;
try
{
// Search for the specific settings node we are looking for in the configuration file.
// If it exists, return the InnerText or InnerXML of its first child node, depending on the setting type.
// If the setting is serialized as a string, return the text stored in the config
if (setProp.SerializeAs.ToString() == "String")
{
return XMLConfig.SelectSingleNode("//setting[@name='" + setProp.Name + "']").FirstChild.InnerText;
}
// If the setting is stored as XML, deserialize it and return the proper object. This only supports
// StringCollections at the moment - I will likely add other types as I use them in applications.
else
{
string settingType = setProp.PropertyType.ToString();
string xmlData = XMLConfig.SelectSingleNode("//setting[@name='" + setProp.Name + "']").FirstChild.InnerXml;
XmlSerializer xs = new XmlSerializer(typeof(string[]));
string[] data = (string[])xs.Deserialize(new XmlTextReader(xmlData, XmlNodeType.Element, null));
switch (settingType)
{
case "System.Collections.Specialized.StringCollection":
StringCollection sc = new StringCollection();
sc.AddRange(data);
return sc;
default:
return "";
}
}
}
catch (Exception)
{
// Check to see if a default value is defined by the application.
// If so, return that value, using the same rules for settings stored as Strings and XML as above
if ((setProp.DefaultValue != null))
{
if (setProp.SerializeAs.ToString() == "String")
{
retVal = setProp.DefaultValue.ToString();
}
else
{
string settingType = setProp.PropertyType.ToString();
string xmlData = setProp.DefaultValue.ToString();
XmlSerializer xs = new XmlSerializer(typeof(string[]));
string[] data = (string[])xs.Deserialize(new XmlTextReader(xmlData, XmlNodeType.Element, null));
switch (settingType)
{
case "System.Collections.Specialized.StringCollection":
StringCollection sc = new StringCollection();
sc.AddRange(data);
return sc;
default: return "";
}
}
}
else
{
retVal = "";
}
}
return retVal;
}
public virtual SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property) {}
static bool IsRoaming(SettingsProperty property)
{
return(property.Attributes.ContainsKey(typeof(SettingsManageabilityAttribute)));
}
public SettingsPropertyValueSerializable(SettingsProperty property) : base(property)
{
}
public SalesforceProfileProperty(SettingsProperty property, string salesforceName)
: base(property)
{
this.SalesforceName = salesforceName;
}
// Looks in the "attribute bag" for a given property to determine if it is user-scoped
bool IsUserScoped(SettingsProperty prop)
{
return HasSettingScope(prop, typeof(UserScopedSettingAttribute));
}
// Looks in the "attribute bag" for a given property to determine if it is app-scoped
bool IsApplicationScoped(SettingsProperty prop)
{
return HasSettingScope(prop, typeof(ApplicationScopedSettingAttribute));
}
// Checks for app or user-scoped based on the attributeType argument
// Also checks for sanity, i.e. a setting not marked as both or neither scope
// (just like the LFSP)
bool HasSettingScope(SettingsProperty prop, Type attributeType)
{
// TODO: add support for roaming
Debug.Assert((attributeType == typeof(ApplicationScopedSettingAttribute)) || (attributeType == typeof(UserScopedSettingAttribute)));
bool isAppScoped = prop.Attributes[typeof(ApplicationScopedSettingAttribute)] != null;
bool isUserScoped = prop.Attributes[typeof(UserScopedSettingAttribute)] != null;
// Check constraints
if (isUserScoped && isAppScoped)
{
throw new Exception("Can't mark a setting as User and Application-scoped: " + prop.Name);
}
else if (!isUserScoped && !isAppScoped)
{
throw new Exception("Must mark a setting as User or Application-scoped: " + prop.Name);
}
// Return scope check result
if (attributeType == typeof(ApplicationScopedSettingAttribute))
{
return isAppScoped;
}
else if (attributeType == typeof(UserScopedSettingAttribute))
{
return isUserScoped;
}
else
{
Debug.Assert(false);
return false;
}
}
SettingsPropertyValue GetPropertyValue(SettingsProperty prop, string version)
{
SettingsPropertyValue value = new SettingsPropertyValue(prop);
// Only User-scoped settings can be found in the Registry.
// By leaving the Application-scoped setting's value at null,
// we get the "default" value
if (IsUserScoped(prop))
{
using (RegistryKey key = CreateRegKey(prop, version))
{
value.SerializedValue = key.GetValue(prop.Name);
}
}
value.IsDirty = false;
return value;
}
// do nothing public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property) => new SettingsPropertyValue(property);
private static bool IsUserScoped(SettingsProperty property)
{
return(SettingsPropertyExtensions.IsUserScoped(property));
}
public ProfileColumnData(string col, SettingsProperty pv, object val, SqlDbType type)
{
EnsureValidTableOrColumnName(col);
ColumnName = col;
PropertyValue = pv;
Value = val;
DataType = type;
}
// Methods
public void Add(SettingsProperty property)
{
}
public ProfileInfoCollection FindProfilesByPropertyValue(SettingsProperty property, SearchOperator searchOperator, object value)
{
// instantiate an empty ProfileInfoCollection to use it for return
ProfileInfoCollection pic = new ProfileInfoCollection();
// try and open the connection and get the results
try
{
// get the connection we're going to use
using (SqlConnection conn = new SqlConnection(_connectionStringName))
{
// instantiate a SettingsPropertyValue from the property
// to use it to serialize the value for comparison with the database
SettingsPropertyValue spv = new SettingsPropertyValue(property);
spv.PropertyValue = value;
// set common parameters of the aspnet_Profile_FindProfiles stored procedure
SqlCommand FindProfilesCommand = new SqlCommand("aspnet_Profile_FindProfiles", conn);
FindProfilesCommand.CommandType = CommandType.StoredProcedure;
FindProfilesCommand.CommandTimeout = _commandTimeout;
FindProfilesCommand.Parameters.Add("@ApplicationName", System.Data.SqlDbType.NVarChar, 256).Value = base.ApplicationName;
FindProfilesCommand.Parameters.Add("@PropertyName", System.Data.SqlDbType.NVarChar, 256).Value = property.Name;
FindProfilesCommand.Parameters.Add("@OperatorType", System.Data.SqlDbType.Int).Value = (Int32)searchOperator;
// if the serialized property value is of type string
// carry on if the size is within allowed limits
Boolean bTooBig = false;
if (spv.SerializedValue is String)
{
// if the serialized value is bigger than the PropertyValueString column's length
if (((String)spv.SerializedValue).Length > Int32.MaxValue)
{
bTooBig = true;
}
else
{
if (searchOperator == SearchOperator.Contains || searchOperator == SearchOperator.FreeText)
{
// if the searchOperator is a freetext operator then pass the value unaltered
FindProfilesCommand.Parameters.Add("@PropertyValueString",
System.Data.SqlDbType.NVarChar, Int32.MaxValue).Value = spv.PropertyValue;
FindProfilesCommand.Parameters.Add("@PropertyValueBinary",
System.Data.SqlDbType.VarBinary, Int32.MaxValue).Value = DBNull.Value;
}
else
{
// otherwise serialise the value before passing it
FindProfilesCommand.Parameters.Add("@PropertyValueString",
System.Data.SqlDbType.NVarChar, Int32.MaxValue).Value = spv.SerializedValue;
FindProfilesCommand.Parameters.Add("@PropertyValueBinary",
System.Data.SqlDbType.VarBinary, Int32.MaxValue).Value = DBNull.Value;
}
// set the parameter @PropertyType to indicate the property is a string
FindProfilesCommand.Parameters.Add("@PropertyType", System.Data.SqlDbType.Bit).Value = 0;
}
}
else
{
if (((SqlBinary)spv.SerializedValue).Length > Int32.MaxValue)
{
bTooBig = true;
}
else
{
if (searchOperator == SearchOperator.Contains || searchOperator == SearchOperator.FreeText)
{
// if the searchOperator is a freetext operator then pass the value unaltered to the
// @PropertyValueString because we are passing a string anyway not a binary
FindProfilesCommand.Parameters.Add("@PropertyValueString",
System.Data.SqlDbType.NVarChar, Int32.MaxValue).Value = spv.PropertyValue;
FindProfilesCommand.Parameters.Add("@PropertyValueBinary",
System.Data.SqlDbType.VarBinary, Int32.MaxValue).Value = DBNull.Value;
}
else
{
// otherwise just serialise the value and pass it to the @PropertyBinaryValue
FindProfilesCommand.Parameters.Add("@PropertyValueString",
System.Data.SqlDbType.NVarChar, Int32.MaxValue).Value = DBNull.Value;
FindProfilesCommand.Parameters.Add("@PropertyValueBinary",
System.Data.SqlDbType.VarBinary, Int32.MaxValue).Value = spv.SerializedValue;
}
// set the parameter @PropertyType to indicate the property is a binary
FindProfilesCommand.Parameters.Add("@PropertyType", System.Data.SqlDbType.Bit).Value = 1;
}
}
if (bTooBig)
{
// if the size is out of limits throw an exception
throw new ProviderException("Property value length is too big.");
}
// Open the database
conn.Open();
// Get a DataReader for the results we need
using (SqlDataReader rdr = FindProfilesCommand.ExecuteReader(CommandBehavior.CloseConnection))
{
while (rdr.Read())
{
// create a ProfileInfo with the data you got back from the current record of the SqlDataReader
ProfileInfo pi = new ProfileInfo(rdr.GetString(rdr.GetOrdinal("UserName")),
rdr.GetBoolean(rdr.GetOrdinal("IsAnonymous")),
DateTime.SpecifyKind(rdr.GetDateTime(rdr.GetOrdinal("LastActivityDate")), DateTimeKind.Utc),
DateTime.SpecifyKind(rdr.GetDateTime(rdr.GetOrdinal("LastUpdatedDate")), DateTimeKind.Utc), 0);
// add the ProfileInfo you just created to the ProfileInfoCollection that we will return
pic.Add(pi);
}
}
}
}
catch (Exception e)
{
// if anything went wrong, throw an exception
throw new ProviderException("An error occured while finding profiles with your search criteria!", e);
}
return pic;
}
public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property)
{
throw new NotImplementedException();
}
private string GetValue(SettingsProperty setting)
{
Monitor.Enter(GetLock);
string ret = "";
try
{
ret = SettingsXML.SelectSingleNode(SETTINGSROOT + "/" + setting.Name).InnerText;
}
catch
{
if (setting.DefaultValue != null)
{
ret = setting.DefaultValue.ToString();
}
else
{
ret = "";
}
}
finally
{
Monitor.Exit(GetLock);
}
return ret;
}
public static string CreateSettingValue(SettingsProperty property, MigrationScope migrationScope, SettingValue settingValue)
{
return(CreateSettingValue(SettingsPropertyHelper.GetDescriptor(property), migrationScope, settingValue));
}
private bool IsRoaming(SettingsProperty prop)
{
//Determine if the setting is marked as Roaming
foreach (DictionaryEntry d in prop.Attributes)
{
Attribute a = (Attribute)d.Value;
if (a is System.Configuration.SettingsManageabilityAttribute)
{
return true;
}
}
return false;
}
public SettingsProperty(SettingsProperty propertyToCopy)
{
}
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
static private void InitializeStatic()
{
if (!ProfileManager.Enabled || s_Initialized)
{
if (s_InitializeException != null)
{
throw s_InitializeException;
}
return;
}
lock (s_InitializeLock) {
if (s_Initialized)
{
if (s_InitializeException != null)
{
throw s_InitializeException;
}
return;
}
try {
ProfileSection config = MTConfigUtil.GetProfileAppConfig();
bool fAnonEnabled = (HostingEnvironment.IsHosted ? AnonymousIdentificationModule.Enabled : true);
Type baseType = ProfileBase.InheritsFromType;
bool hasLowTrust = HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Low);
s_Properties = new SettingsPropertyCollection();
// Step 0: Add all dynamic profile properties set programatically during PreAppStart
ProfileBase.AddPropertySettingsFromConfig(baseType, fAnonEnabled, hasLowTrust, ProfileManager.DynamicProfileProperties, null);
//////////////////////////////////////////////////////////////////////
// Step 1: Add Properties from the base class (if not ProfileBase)
if (baseType != typeof(ProfileBase))
{
//////////////////////////////////////////////////////////////////////
// Step 2: Construct a hashtable containing a list of all the property-names in the ProfileBase type
PropertyInfo[] baseProps = typeof(ProfileBase).GetProperties();
NameValueCollection baseProperties = new NameValueCollection(baseProps.Length);
foreach (PropertyInfo baseProp in baseProps)
{
baseProperties.Add(baseProp.Name, String.Empty);
}
//////////////////////////////////////////////////////////////////////
// Step 3: For each property in the derived class, add it to the s_Properties class.
PropertyInfo[] props = baseType.GetProperties();
foreach (PropertyInfo prop in props)
{
if (baseProperties[prop.Name] == null) //not in the base class
{
ProfileProvider prov = hasLowTrust ? ProfileManager.Provider : null;
bool readOnly = false;
SettingsSerializeAs serializeAs = SettingsSerializeAs.ProviderSpecific;
string defaultValue = String.Empty;
bool allowAnonymous = false;
string customData = null;
//////////////////////////////////////////////////////////////////////
// Step 4: For the property, get the attributes
Attribute[] attribs = Attribute.GetCustomAttributes(prop, true);
foreach (Attribute attrib in attribs)
{
if (attrib is SettingsSerializeAsAttribute)
{
serializeAs = ((SettingsSerializeAsAttribute)attrib).SerializeAs;
}
else if (attrib is SettingsAllowAnonymousAttribute)
{
allowAnonymous = ((SettingsAllowAnonymousAttribute)attrib).Allow;
if (!fAnonEnabled && allowAnonymous)
{
throw new ConfigurationErrorsException(SR.GetString(SR.Annoymous_id_module_not_enabled, prop.Name), config.ElementInformation.Properties["inherits"].Source, config.ElementInformation.Properties["inherits"].LineNumber);
}
}
else if (attrib is System.ComponentModel.ReadOnlyAttribute)
{
readOnly = ((System.ComponentModel.ReadOnlyAttribute)attrib).IsReadOnly;
}
else if (attrib is DefaultSettingValueAttribute)
{
defaultValue = ((DefaultSettingValueAttribute)attrib).Value;
}
else if (attrib is CustomProviderDataAttribute)
{
customData = ((CustomProviderDataAttribute)attrib).CustomProviderData;
}
else if (hasLowTrust && attrib is ProfileProviderAttribute)
{
prov = ProfileManager.Providers[((ProfileProviderAttribute)attrib).ProviderName];
if (prov == null)
{
throw new ConfigurationErrorsException(SR.GetString(SR.Profile_provider_not_found, ((ProfileProviderAttribute)attrib).ProviderName), config.ElementInformation.Properties["inherits"].Source, config.ElementInformation.Properties["inherits"].LineNumber);
}
}
}
//////////////////////////////////////////////////////////////////////
// Step 5: Add the property to the s_Properties
SettingsAttributeDictionary settings = new SettingsAttributeDictionary();
settings.Add("AllowAnonymous", allowAnonymous);
if (!string.IsNullOrEmpty(customData))
{
settings.Add("CustomProviderData", customData);
}
SettingsProperty sp = new SettingsProperty(prop.Name, prop.PropertyType, prov, readOnly, defaultValue, serializeAs, settings, false, true);
s_Properties.Add(sp);
}
}
}
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Step 6: Add all properties from config
if (config.PropertySettings != null)
{
AddPropertySettingsFromConfig(baseType, fAnonEnabled, hasLowTrust, config.PropertySettings, null);
foreach (ProfileGroupSettings pgs in config.PropertySettings.GroupSettings)
{
AddPropertySettingsFromConfig(baseType, fAnonEnabled, hasLowTrust, pgs.PropertySettings, pgs.Name);
}
}
}
catch (Exception e) {
if (s_InitializeException == null)
{
s_InitializeException = e;
}
}
// If there are no properties, create an empty collection.
if (s_Properties == null)
{
s_Properties = new SettingsPropertyCollection();
}
// Make the properties collection read-only
s_Properties.SetReadOnly();
s_Initialized = true;
}
// Throw an exception if there was an exception during initialization
if (s_InitializeException != null)
{
throw s_InitializeException;
}
}
public static SettingsPropertyValueCollection DeserializeSettingsPropertyValueCollection(List <ProfilePropertyValueContract> oSerializedSettingsPropertyValueCollection)
{
#region VARIABLES
System.Configuration.SettingsPropertyValueCollection oSettingsPropertyValueCollection;
string sCurrentPropertyName;
Type oCurrentPropertyType;
string sCurrentPropertyDefaultValue;
SettingsPropertyValue oSettingsCurrentPropertyValue;
SettingsProperty oCurrentSettingsProperty;
#endregion
oSettingsPropertyValueCollection = null;
if (oSerializedSettingsPropertyValueCollection != null)
{
oSettingsPropertyValueCollection = new SettingsPropertyValueCollection();
foreach (var oPropertySerialized in oSerializedSettingsPropertyValueCollection)
{
if (oPropertySerialized.ProfileProperty != null)
{
sCurrentPropertyName = oPropertySerialized.ProfileProperty.Name;
if (!string.IsNullOrEmpty(sCurrentPropertyName))
{
oCurrentSettingsProperty = new SettingsProperty(sCurrentPropertyName);
if (oPropertySerialized.ProfileProperty.Type != null)
{
oCurrentPropertyType = !string.IsNullOrEmpty(oPropertySerialized.ProfileProperty.Type)? Type.GetType(oPropertySerialized.ProfileProperty.Type) : typeof(string);
oCurrentSettingsProperty.PropertyType = oCurrentPropertyType;
oCurrentSettingsProperty.IsReadOnly = oPropertySerialized.ProfileProperty.IsReadOnly;
sCurrentPropertyDefaultValue = oPropertySerialized.ProfileProperty.DefaultValue;
if (!string.IsNullOrEmpty(sCurrentPropertyDefaultValue))
{
oCurrentSettingsProperty.DefaultValue = sCurrentPropertyDefaultValue;
}
if (oPropertySerialized.ProfileProperty.Attributes != null)
{
foreach (var oPropertyAttributeSerialized in oPropertySerialized.ProfileProperty.Attributes)
{
oCurrentSettingsProperty.Attributes.Add(oPropertyAttributeSerialized.Key, oPropertyAttributeSerialized.Value);
}
}
//Must set the type to use the PropertyValue otherwise you will get " NullReferenceException when trying to access the PropertyValue"
oSettingsCurrentPropertyValue = new SettingsPropertyValue(oCurrentSettingsProperty);
if (!string.IsNullOrEmpty(oPropertySerialized.Value))
{
oSettingsCurrentPropertyValue.PropertyValue = oPropertySerialized.Value;;
}
else
{
oSettingsCurrentPropertyValue.PropertyValue = null;
}
oSettingsPropertyValueCollection.Add(oSettingsCurrentPropertyValue);
}
}
}
}
}
return(oSettingsPropertyValueCollection);
}
public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property)
{
ExTraceGlobals.ProgramFlowTracer.TraceFunction <ExchangeSettingsProvider>(0L, "*--ExchangeSettingsProvider.GetPreviousVersion: {0}", this);
throw new NotSupportedException();
}
static SettingsProperty CreateSettingsProperty(PropertyInfo property)
{
SettingsProperty sp = new SettingsProperty(property.Name);
Attribute [] attributes = (Attribute [])property.GetCustomAttributes(false);
SettingsAttributeDictionary attDict = new SettingsAttributeDictionary();
bool defaultAssigned = false;
sp.SerializeAs = SettingsSerializeAs.ProviderSpecific;
sp.PropertyType = property.PropertyType;
sp.IsReadOnly = false;
sp.ThrowOnErrorDeserializing = false;
sp.ThrowOnErrorSerializing = true;
for (int i = 0; i < attributes.Length; i++)
{
if (attributes [i] is DefaultSettingValueAttribute)
{
sp.DefaultValue = ((DefaultSettingValueAttribute)attributes [i]).Value;
defaultAssigned = true;
}
else if (attributes [i] is SettingsProviderAttribute)
{
Type providerType = HttpApplication.LoadType(((SettingsProviderAttribute)attributes [i]).ProviderTypeName);
sp.Provider = (SettingsProvider)Activator.CreateInstance(providerType);
sp.Provider.Initialize(null, null);
}
else if (attributes [i] is SettingsSerializeAsAttribute)
{
sp.SerializeAs = ((SettingsSerializeAsAttribute)attributes [i]).SerializeAs;
}
else if (attributes [i] is SettingsAllowAnonymousAttribute)
{
sp.Attributes ["AllowAnonymous"] = ((SettingsAllowAnonymousAttribute)attributes [i]).Allow;
}
else if (attributes [i] is CustomProviderDataAttribute)
{
sp.Attributes ["CustomProviderData"] = ((CustomProviderDataAttribute)attributes [i]).CustomProviderData;
}
else if (attributes [i] is ApplicationScopedSettingAttribute ||
attributes [i] is UserScopedSettingAttribute ||
attributes [i] is SettingsDescriptionAttribute ||
attributes [i] is SettingAttribute)
{
attDict.Add(attributes [i].GetType(), attributes [i]);
}
}
if (sp.Provider == null)
{
sp.Provider = ProfileManager.Provider;
}
if (sp.Attributes ["AllowAnonymous"] == null)
{
sp.Attributes ["AllowAnonymous"] = false;
}
if (!defaultAssigned && sp.PropertyType == typeof(string) && sp.DefaultValue == null)
{
sp.DefaultValue = String.Empty;
}
return(sp);
}
set => SetValue(SettingsProperty, value);
static void InitProperties()
{
SettingsPropertyCollection properties = new SettingsPropertyCollection();
ProfileSection config = (ProfileSection)WebConfigurationManager.GetSection("system.web/profile");
RootProfilePropertySettingsCollection ps = config.PropertySettings;
for (int i = 0; i < ps.GroupSettings.Count; i++)
{
ProfileGroupSettings pgs = ps.GroupSettings [i];
ProfilePropertySettingsCollection ppsc = pgs.PropertySettings;
for (int s = 0; s < ppsc.Count; s++)
{
SettingsProperty settingsProperty = CreateSettingsProperty(pgs, ppsc [s]);
ValidateProperty(settingsProperty, ppsc [s].ElementInformation);
properties.Add(settingsProperty);
}
}
for (int s = 0; s < ps.Count; s++)
{
SettingsProperty settingsProperty = CreateSettingsProperty(null, ps [s]);
ValidateProperty(settingsProperty, ps [s].ElementInformation);
properties.Add(settingsProperty);
}
if (config.Inherits.Length > 0)
{
Type profileType = ProfileParser.GetProfileCommonType(HttpContext.Current);
if (profileType != null)
{
Type properiesType = profileType.BaseType;
for (; ;)
{
PropertyInfo [] pi = properiesType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (pi.Length > 0)
{
for (int i = 0; i < pi.Length; i++)
{
properties.Add(CreateSettingsProperty(pi [i]));
}
}
if (properiesType.BaseType == null ||
properiesType.BaseType == typeof(ProfileBase))
{
break;
}
properiesType = properiesType.BaseType;
}
}
}
properties.SetReadOnly();
lock (Profiles_SettingsPropertyCollection) {
if (_properties == null)
{
_properties = properties;
}
}
}
public virtual SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property)
{
}
public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property)
{
return(_provider.GetPreviousVersion(context, property));
}
public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property)
{
// do nothing
return(new SettingsPropertyValue(property));
}
static bool IsRoaming(SettingsProperty property)
{
return(property.Attributes
.Cast <DictionaryEntry>()
.Any(a => a.Value is SettingsManageabilityAttribute));
}
private static bool IsUserScoped(SettingsProperty property)
{
return(CollectionUtils.Contains(property.Attributes.Values, attribute => attribute is UserScopedSettingAttribute));
}
private static bool IsRoaming(SettingsProperty prop)
{
return(prop.Attributes.Cast <DictionaryEntry>().Select <DictionaryEntry, Attribute>((Func <DictionaryEntry, Attribute>)(d => (Attribute)d.Value)).OfType <SettingsManageabilityAttribute>().Any <SettingsManageabilityAttribute>());
}
public static void save_Setting(string setting_Name, string setting_Value)
{
//----------< save_Settings() >----------
string property_name = setting_Name;
//< Setting erstellen >
SettingsProperty prop = null;
if (Properties.Settings.Default.Properties[property_name] != null)
{
//< existing Setting >
prop = Properties.Settings.Default.Properties[property_name];
//</ existing Setting >
}
else
{
//< new Setting >
prop = new System.Configuration.SettingsProperty(property_name);
prop.PropertyType = typeof(string);
Properties.Settings.Default.Properties.Add(prop);
Properties.Settings.Default.Save();
Properties.Settings.Default.Upgrade();
//</ new Setting >
}
//</ Setting erstellen >
//< set value >
Properties.Settings.Default.Properties[property_name].DefaultValue = setting_Value;
//</ set value >
//< Save Settings File >
Properties.Settings.Default.Save();
//</ Save Settings File >
//----------</ save_Settings() >----------
}
private bool IsUserScoped(SettingsProperty settingsProperty)
{
return(CollectionUtils.Contains(settingsProperty.Attributes.Values,
delegate(object obj) { return obj is UserScopedSettingAttribute; }));
}
// Constructors
public SettingsPropertyValue(SettingsProperty property)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SettingsPropertyColumn"/> class.
/// </summary>
/// <param name="settings">
/// The settings.
/// </param>
/// <param name="dataType">
/// The data type.
/// </param>
/// <param name="size">
/// The size.
/// </param>
public SettingsPropertyColumn(SettingsProperty settings, SqlDbType dataType, int size)
{
this.DataType = dataType;
this.Settings = settings;
this.Size = size;
}
// Methods
public void Add(SettingsProperty property)
{
}
private static bool IsUserScoped(SettingsProperty property)
{
return((from DictionaryEntry entry in property.Attributes select(Attribute) entry.Value).OfType <UserScopedSettingAttribute>().Any());
}
string GetValue(SettingsProperty setting)
{
string ret = "";
try
{
ret = SettingsXML.SelectSingleNode(SETTINGSROOT + "/" + setting.Name).InnerText;
}
catch (Exception)
{
if (setting.DefaultValue != null)
ret = setting.DefaultValue.ToString();
}
return ret;
}
public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property)
{
return(value);
}
private string GetValue(SettingsProperty setting)
{
string ret = "";
try
{
if (IsRoaming(setting))
{
ret = SettingsXML.SelectSingleNode(SETTINGSROOT + "/" + setting.Name).InnerText;
}
else
{
ret = SettingsXML.SelectSingleNode(SETTINGSROOT + "/" + Environment.MachineName + "/" + setting.Name).InnerText;
}
}
catch (Exception ex)
{
if ((setting.DefaultValue != null))
{
ret = setting.DefaultValue.ToString();
}
else
{
ret = "";
}
}
return ret;
}
/// <summary>
/// Returns the value of the named settings property for the previous version of the same application.
/// </summary>
/// <param name="context">A <c>System.Configuration.SettingsContext</c> that describes where the application settings property is used.</param>
/// <param name="property">The <c>System.Configuration.SettingsProperty</c> whose value is to be returned.</param>
/// <returns>A <c>System.Configuration.SettingsPropertyValue</c> representing the application setting if found; otherwise, <c>null</c>.</returns>
public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property)
{
throw new NotSupportedException("Get Previous Version is not supported");
}
void Verify_PropertyChangedFired(string propertyName, SettingsProperty settingsProperty)
{
//------------Setup for test--------------------------
var propertyChanged = false;
var viewModel = new TestSettingsViewModel(new Mock<IEventAggregator>().Object, new Mock<IPopupController>().Object, AsyncWorkerTests.CreateSynchronousAsyncWorker().Object, new Mock<IWin32Window>().Object);
viewModel.PropertyChanged += (sender, args) =>
{
if(args.PropertyName == propertyName)
{
propertyChanged = true;
}
};
//------------Execute Test---------------------------
switch(settingsProperty)
{
case SettingsProperty.HasErrors:
viewModel.HasErrors = true;
break;
case SettingsProperty.IsDirty:
viewModel.IsDirty = true;
break;
case SettingsProperty.IsSaved:
viewModel.IsSaved = true;
break;
}
//------------Assert Results-------------------------
Assert.IsTrue(propertyChanged);
}
public SettingsProperty(SettingsProperty propertyToCopy)
{
}
