public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection propvals) { foreach (SettingsPropertyValue propval in propvals) SetValue(propval); SettingsXML.Save(Path.Combine(GetAppSettingsPath(), GetAppSettingsFilename())); }
public void Setup() { settings = new SettingsContext(); container = new TinyIoCContainer(); logger = new Mock<ILogger>(); }
public void Setup() { settings = new SettingsContext(false, ".min"); bundle = new BundleImpl(); bundle.Extension = "css"; bundle.Hash = new byte[1]; generator = new BasicUrlGenerator<BundleImpl>(settings); }
public void Setup() { settings = new SettingsContext(); asset = new AssetBaseImpl(); bundle = new StyleSheetBundle(); bundle.Assets.Add(asset); processor = new ExpandPathProcessor(settings); }
public void Setup() { directory = new Mock<IDirectory>(); settings = new SettingsContext(); settings.AppRootDirectory = directory.Object; runner = new Mock<IImagePipelineRunner>(); processor = new ImageProcessor(settings, runner.Object); }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection props) { var values = new SettingsPropertyValueCollection(); foreach (SettingsProperty setting in props) { var value = new SettingsPropertyValue(setting); value.IsDirty = false; value.SerializedValue = GetValue(setting); values.Add(value); } return values; }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection props) { //Create new collection of values SettingsPropertyValueCollection values = new SettingsPropertyValueCollection(); //Iterate through the settings to be retrieved foreach (SettingsProperty setting in props) { SettingsPropertyValue value = new SettingsPropertyValue(setting); value.IsDirty = false; value.SerializedValue = GetValue(setting); values.Add(value); } return values; }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection props) { // Create new collection of values SettingsPropertyValueCollection values = new SettingsPropertyValueCollection(); string version = GetCurrentVersionNumber(); // Iterate through the settings to be retrieved foreach (SettingsProperty prop in props) { SettingsPropertyValue value = GetPropertyValue(prop, version); Debug.Assert(value != null); values.Add(value); } return values; }
public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection propvals) { //Iterate through the settings to be stored //Only dirty settings are included in propvals, and only ones relevant to this provider foreach (SettingsPropertyValue propval in propvals) { SetValue(propval); } try { SettingsXML.Save(Path.Combine(GetAppSettingsPath(), GetAppSettingsFilename())); } catch (Exception ex) { } //Ignore if cant save, device been ejected }
// 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); }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection properties) { SettingsPropertyValueCollection settings = new SettingsPropertyValueCollection(); // Do nothing if there are no properties to retrieve if (properties.Count == 0) return settings; // For properties lacking an explicit SerializeAs setting, set // SerializeAs to String for strings and primitives, and XML // for everything else foreach (SettingsProperty property in properties) { if (property.SerializeAs == SettingsSerializeAs.ProviderSpecific) { if (property.PropertyType.IsPrimitive || property.PropertyType == typeof(String)) { property.SerializeAs = SettingsSerializeAs.String; } else { property.SerializeAs = SettingsSerializeAs.Xml; } } settings.Add(new SettingsPropertyValue(property)); } // Get the user name or anonymous user ID string username = (string) context["UserName"]; // NOTE: Consider validating the user name here to prevent // malicious user names such as "../Foo" from targeting // directories other than Profile_Data // Load the profile if (!String.IsNullOrEmpty(username)) { StreamReader reader = null; string[] names; string values; byte[] buf = null; try { // Open the file containing the profile data try { string path = string.Format(ProfilePathFormatString, username.Replace('\\', '_')); reader = new StreamReader(path); } catch (IOException) { // Not an error if file doesn't exist return settings; } // Read names, values, and buf from the file names = reader.ReadLine().Split(':'); values = reader.ReadLine(); if (!string.IsNullOrEmpty(values)) { UnicodeEncoding encoding = new UnicodeEncoding(); values = encoding.GetString (Convert.FromBase64String(values)); } string temp = reader.ReadLine(); if (!String.IsNullOrEmpty(temp)) { buf = Convert.FromBase64String(temp); } else buf = new byte[0]; } finally { if (reader != null) reader.Close(); } // Decode names, values, and buf and initialize the // SettingsPropertyValueCollection returned to the caller DecodeProfileData(names, values, buf, settings); } return settings; }
public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection collection) { Monitor.Enter(SetValuesLock); try { foreach (SettingsPropertyValue propval in collection) { SetValue(propval); } SyncToDisk(); } catch { // ignore } finally { Monitor.Exit(SetValuesLock); } }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection) { Monitor.Enter(GetValuesLock); SettingsPropertyValueCollection values = new SettingsPropertyValueCollection(); //Iterate through the settings to be retrieved foreach(SettingsProperty setting in collection) { SettingsPropertyValue value = new SettingsPropertyValue(setting); value.IsDirty = false; value.SerializedValue = GetValue(setting); values.Add(value); } Monitor.Exit(GetValuesLock); return values; }
public virtual void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection values) {}
public virtual SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection properties) {}
public virtual SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property) {}
// Will be called when MySettingsClass.Upgrade() is called // This method's job is to update the location where the settings are stored // with the previous version's values. GetPropertyValues, overriden from the // SettingsProvider base, will be called to retrieve the new values from the // storage location public void Upgrade(SettingsContext context, SettingsPropertyCollection properties) { // If there's no previous version, do nothing (just like the LFSP) string previousVersion = GetPreviousVersionNumber(); if (string.IsNullOrEmpty(previousVersion)) { return; } // Delete the current setting values Reset(context); // Copy the old settings to the new version string currentVersion = GetCurrentVersionNumber(); using (RegistryKey keyPrevious = Registry.LocalMachine.OpenSubKey(GetSubKeyPath(previousVersion), false)) using (RegistryKey keyCurrent = Registry.LocalMachine.CreateSubKey(GetSubKeyPath(currentVersion), RegistryKeyPermissionCheck.ReadWriteSubTree)) { foreach (string valueName in keyPrevious.GetValueNames()) { object serializedValue = keyPrevious.GetValue(valueName); if (serializedValue != null) { keyCurrent.SetValue(valueName, serializedValue); } } } }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection) { string username = (string)context["UserName"]; bool isAuthenticated = (bool)context["IsAuthenticated"]; Dictionary<string, object> values = _profileValues.ContainsKey(username) ? _profileValues[username] : null; SettingsPropertyValueCollection spvc = new SettingsPropertyValueCollection(); foreach (SettingsProperty prop in collection) { SettingsPropertyValue spv = new SettingsPropertyValue(prop); if (values != null && values.ContainsKey(prop.Name)) { spv.PropertyValue = values[prop.Name]; } else { spv.PropertyValue = prop.DefaultValue; } spvc.Add(spv); } return spvc; }
// SetPropertyValue is invoked when ApplicationSettingsBase.Save is called // ASB makes sure to pass each provider only the values marked for that provider, // whether on a per setting or setting class-wide basis public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection propvals) { // Iterate through the settings to be stored string version = GetCurrentVersionNumber(); foreach (SettingsPropertyValue propval in propvals) { // If property hasn't been set, no need to save it if (!propval.IsDirty || (propval.SerializedValue == null)) { continue; } // Application-scoped settings can't change // NOTE: the settings machinery may cause or allow an app-scoped setting // to become dirty, in which case, like the LFSP, we ignore it instead // of throwning an exception if (IsApplicationScoped(propval.Property)) { continue; } using (RegistryKey key = CreateRegKey(propval.Property, version)) { key.SetValue(propval.Name, propval.SerializedValue); } } }
public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection properties) { // Get information about the user who owns the profile string username = (string) context["UserName"]; bool authenticated = (bool) context["IsAuthenticated"]; // NOTE: Consider validating the user name here to prevent // malicious user names such as "../Foo" from targeting // directories other thanProfile_Data // Do nothing if there is no user name or no properties if (String.IsNullOrEmpty(username) || properties.Count == 0) return; // Format the profile data for saving string names = String.Empty; string values = String.Empty; byte[] buf = null; EncodeProfileData(ref names, ref values, ref buf, properties, authenticated); // Do nothing if no properties need saving if (names == String.Empty) return; // Save the profile data StreamWriter writer = null; try { string path = string.Format(ProfilePathFormatString, username.Replace('\\', '_')); writer = new StreamWriter(path, false); writer.WriteLine(names); if (!String.IsNullOrEmpty(values)) { UnicodeEncoding encoding = new UnicodeEncoding(); writer.WriteLine(Convert.ToBase64String(encoding.GetBytes(values))); } else { writer.WriteLine(); } if (buf != null && buf.Length > 0) writer.WriteLine(Convert.ToBase64String(buf)); else writer.WriteLine(); } finally { if (writer != null) writer.Close(); } }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext sc, SettingsPropertyCollection properties) { // create the collection to return SettingsPropertyValueCollection spvc = new SettingsPropertyValueCollection(); #region Check The Function Parameters Are Valid // check we have the user profile information. if (sc == null) { return spvc; } // check we do have the profile information for the properties to be retrieved. // check we do have properties in the profile if (properties == null || properties.Count < 1) { return spvc; } // get the username // get if the user is authenticated // if the username is null or empty, return empty property value collection Boolean isAuthenticated = (Boolean)sc["IsAuthenticated"]; String username = (String)sc["UserName"]; if (String.IsNullOrEmpty(username)) { return spvc; } #endregion #region Fill the collection to return with the profile properties initialized to their default values foreach (SettingsProperty sp in properties) { // If the serialization is up to us to decide, try and see if it can be serialised as a string // otherwise serialise as XML if (sp.SerializeAs == SettingsSerializeAs.ProviderSpecific) { // If it is a primitive type or a string, then just store it as a string if (sp.PropertyType.IsPrimitive || (sp.PropertyType == typeof(string))) { sp.SerializeAs = SettingsSerializeAs.String; } else // Else serialize it as XML { sp.SerializeAs = SettingsSerializeAs.Xml; } } // create a property value based on the profile property settings, including default value // Add the property value to the collection to return spvc.Add(new SettingsPropertyValue(sp)); } #endregion #region Retrieve the stored property values from the database try { GetNonDefaultPropertyValuesForUser(username, spvc); } catch (Exception e) { // if anything went wrong, throw an exception throw new ProviderException(String.Format( "Error getting profile property values from database.\nUsername: '******'\nIs Authenticated: {1}", username, isAuthenticated.ToString()), e); } #endregion return spvc; }
public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection collection) { IProfile dal = Snitz.Membership.Helpers.Factory<IProfile>.Create("Profile"); dal.TableName = _table; dal.SetPropertyValues(context, collection); }
public override void SetPropertyValues(SettingsContext sc, SettingsPropertyValueCollection properties) { #region Check The Function Parameters Are Valid // check we have the user profile information. if (sc == null) { return; } // check we do have the profile information for the properties to be retrieved. // check we do have properties in the profile if (properties == null || properties.Count < 1) { return; } // get the username // get if the user is authenticated // if the username is null or empty, quit String username = (String)sc["UserName"]; Boolean isAuthenticated = (Boolean)sc["IsAuthenticated"]; if (String.IsNullOrEmpty(username)) { return; } #endregion #region Build A List Of Items To Be Actually Saved // build a list List<SettingsPropertyValue> columnData = new List<SettingsPropertyValue>(properties.Count); // add all properties to be saved to the list foreach (SettingsPropertyValue spv in properties) { // iIf the property is dirty "written to or used", add it to the list if (spv.IsDirty) { // if the user is anonymous and the property is not marked "AllowAnonymous", skip this property if (!isAuthenticated && !((Boolean)spv.Property.Attributes["AllowAnonymous"])) { continue; } // add the property to the list columnData.Add(spv); } } // if the list is empty, quit if (columnData.Count < 1) { return; } #endregion #region Save The List To The Database try { // make a conection using (SqlConnection conn = new SqlConnection(_connectionStringName)) { // set the command object to the stored procedure used to save the properties // set the command to use the connection // set the command timeout value // initialize the common stored procedure parameters to their values SqlCommand SetPropertyCommand = new SqlCommand("aspnet_Profile_SetProperty", conn); SetPropertyCommand.CommandTimeout = _commandTimeout; SetPropertyCommand.CommandType = CommandType.StoredProcedure; SetPropertyCommand.Parameters.Add("@ApplicationName", SqlDbType.NVarChar, 256).Value = base.ApplicationName; SetPropertyCommand.Parameters.Add("@PropertyName", SqlDbType.NVarChar, 256); SetPropertyCommand.Parameters.Add("@PropertyUsingDefaultValue", SqlDbType.Bit); SetPropertyCommand.Parameters.Add("@PropertyValueString", SqlDbType.NVarChar, Int32.MaxValue); SetPropertyCommand.Parameters.Add("@PropertyValueBinary", SqlDbType.VarBinary, Int32.MaxValue); SetPropertyCommand.Parameters.Add("@UserName", SqlDbType.NVarChar, 256).Value = username; SetPropertyCommand.Parameters.Add("@IsUserAnonymous", SqlDbType.Bit).Value = !isAuthenticated; SetPropertyCommand.Parameters.Add("@CurrentTimeUtc", SqlDbType.DateTime).Value = DateTime.UtcNow; // for each property on the list foreach (SettingsPropertyValue spv in columnData) { // set the rest of the stored procedure parameters according to each specific property features SetPropertyCommand.Parameters["@PropertyName"].Value = spv.Property.Name; // if the property is using the same value as DdefaultValue // otherwise continue your normal insert/update procedure if (spv.Property.DefaultValue.Equals(spv.SerializedValue) == true) { // just mark the procedures parameter @PropertyUsingDefaultValue to true // to remove the entry from the database so it switches back to default // the other values are not really significant so use DBNull SetPropertyCommand.Parameters["@PropertyUsingDefaultValue"].Value = 1; SetPropertyCommand.Parameters["@PropertyValueString"].Value = DBNull.Value; SetPropertyCommand.Parameters["@PropertyValueBinary"].Value = DBNull.Value; } else { // set the parameter @PropertyUsingDefaultValue to false so the procedure would insert/update SetPropertyCommand.Parameters["@PropertyUsingDefaultValue"].Value = 0; // if the property value is null, set both string and binary values to null // otherwise set the appropriate one to the property value after it has been serialized properly if ((spv.Deserialized && spv.PropertyValue == null) || (!spv.Deserialized && spv.SerializedValue == null)) { SetPropertyCommand.Parameters["@PropertyValueString"].Value = DBNull.Value; SetPropertyCommand.Parameters["@PropertyValueBinary"].Value = DBNull.Value; } else { // get the serialized property value //spv.SerializedValue = SerializePropertyValue(spv.Property, spv.PropertyValue); // set the approporiate parameter of the stored procedure to the serialized value // if the serialized value is a string store it in the @PropertyValueString parameter and set the other to DBNull // otherwise store the value in the @PropertyValueBinary and set the other to DBNull if (spv.SerializedValue is String) { SetPropertyCommand.Parameters["@PropertyValueString"].Value = spv.SerializedValue; SetPropertyCommand.Parameters["@PropertyValueBinary"].Value = DBNull.Value; } else { SetPropertyCommand.Parameters["@PropertyValueString"].Value = DBNull.Value; SetPropertyCommand.Parameters["@PropertyValueBinary"].Value = spv.SerializedValue; } } } // if the connection is closed, open it if (conn.State == ConnectionState.Closed) { conn.Open(); } // execute the stored procedure // if no rows were affected, then throw an error, because nothing has been saved! if (SetPropertyCommand.ExecuteNonQuery() == 0) { throw new ProviderException(String.Format("Updating the profile property '{0}' in the database failed!", spv.Name)); } } } } catch (Exception e) { // if anything went wrong, throw an exception throw new ProviderException(String.Format( "Error setting profile property value to database.\nUsername: '******'\nIs Authenticated: {1}", username, isAuthenticated.ToString()), e); } #endregion }
// Save any of the applications settings that have changed (flagged as "dirty") public override void SetPropertyValues(SettingsContext sContext, SettingsPropertyValueCollection settingsColl) { // Set the values in XML foreach (SettingsPropertyValue spVal in settingsColl) { SetSetting(spVal); } // Write the XML file to disk try { XMLConfig.Save(System.IO.Path.Combine(GetAppPath(), GetSettingsFilename())); } catch (Exception ex) { // Create an informational message for the user if we cannot save the settings. // Enable whichever applies to your application type. // Uncomment the following line to enable a MessageBox for forms-based apps System.Windows.Forms.MessageBox.Show(ex.Message, "Error writting configuration file to disk", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error); // Uncomment the following line to enable a console message for console-based apps //Console.WriteLine("Error writing configuration file to disk: " + ex.Message); } }
// Retrieve settings from the configuration file public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext sContext, SettingsPropertyCollection settingsColl) { // Create a collection of values to return SettingsPropertyValueCollection retValues = new SettingsPropertyValueCollection(); // Create a temporary SettingsPropertyValue to reuse SettingsPropertyValue setVal; // Loop through the list of settings that the application has requested and add them // to our collection of return values. foreach (SettingsProperty sProp in settingsColl) { setVal = new SettingsPropertyValue(sProp); setVal.IsDirty = false; setVal.SerializedValue = GetSetting(sProp); retValues.Add(setVal); } return retValues; }
public void Initialize(SettingsContext context, SettingsPropertyCollection properties, SettingsProviderCollection providers) {}
public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection collection) { string username = (string)context["UserName"]; bool isAuthenticated = (bool)context["IsAuthenticated"]; Dictionary<string, object> values = _profileValues.ContainsKey(username) ? _profileValues[username] : null; if (values == null) { values = new Dictionary<string, object>(); _profileValues[username] = values; } foreach (SettingsPropertyValue propValue in collection) { values[propValue.Property.Name] = propValue.PropertyValue; } }
public virtual void Reset(SettingsContext context) {}
public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection propvals) { //Iterate through the settings to be stored //Only dirty settings are included in propvals, and only ones relevant to this provider foreach (SettingsPropertyValue propval in propvals) { SetValue(propval); } try { string settingsFile = System.IO.Path.Combine(GetAppSettingsPath(), GetAppSettingsFilename()); if(!File.Exists(settingsFile)) { Directory.CreateDirectory(GetAppSettingsPath()); File.Create(settingsFile).Close(); } SettingsXML.Save(System.IO.Path.Combine(GetAppSettingsPath(), GetAppSettingsFilename())); } catch (Exception ex) { MessageBox.Show(ex.Message); } }
public virtual void Upgrade(SettingsContext context, SettingsPropertyCollection properties) {}