Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / Sys / System / Configuration / SettingsPropertyValue.cs / 1 / SettingsPropertyValue.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Configuration {
using System.Collections;
using System.Collections.Specialized;
using System.Runtime.Serialization;
using System.Configuration.Provider;
using System.Globalization;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Xml.Serialization;
using System.ComponentModel;
using System.Security.Permissions;
using System.Reflection;
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
public class SettingsPropertyValue
{
public string Name { get { return _Property.Name; } }
public bool IsDirty { get { return _IsDirty; } set { _IsDirty = value; }}
public SettingsProperty Property { get { return _Property; } }
public bool UsingDefaultValue { get { return _UsingDefaultValue; } }
public SettingsPropertyValue(SettingsProperty property)
{
_Property = property;
}
public object PropertyValue
{
get
{
if (!_Deserialized)
{
_Value = Deserialize();
_Deserialized = true;
}
if (_Value != null && !Property.PropertyType.IsPrimitive && !(_Value is string) && !(_Value is DateTime))
{
_UsingDefaultValue = false;
_ChangedSinceLastSerialized = true;
_IsDirty = true;
}
return _Value;
}
set
{
_Value = value;
_IsDirty = true;
_ChangedSinceLastSerialized = true;
_Deserialized = true;
_UsingDefaultValue = false;
}
}
public object SerializedValue
{
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
get {
if (_ChangedSinceLastSerialized) {
_ChangedSinceLastSerialized = false;
_SerializedValue = SerializePropertyValue();
}
return _SerializedValue;
}
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
set {
_UsingDefaultValue = false;
_SerializedValue = value;
}
}
public bool Deserialized
{
get { return _Deserialized; }
set { _Deserialized = value; }
}
private bool IsHostedInAspnet() {
// See System.Web.Hosting.ApplicationManager::PopulateDomainBindings
return AppDomain.CurrentDomain.GetData(".appDomain") != null;
}
private object Deserialize()
{
object val = null;
//////////////////////////////////////////////
/// Step 1: Try creating from Serailized value
if (SerializedValue != null)
{
try {
if (SerializedValue is string) {
val = GetObjectFromString(Property.PropertyType, Property.SerializeAs, (string)SerializedValue);
} else {
MemoryStream ms = new System.IO.MemoryStream((byte[])SerializedValue);
try {
val = (new BinaryFormatter()).Deserialize(ms);
} finally {
ms.Close();
}
}
}
catch (Exception exception) {
try {
if (IsHostedInAspnet()) {
object[] args = new object[] { Property, this, exception};
const string webBaseEventTypeName = "System.Web.Management.WebBaseEvent, " + AssemblyRef.SystemWeb;
Type type = Type.GetType(webBaseEventTypeName, true);
type.InvokeMember("RaisePropertyDeserializationWebErrorEvent",
BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.InvokeMethod,
null, null, args, CultureInfo.InvariantCulture);
}
}
catch {
}
}
if (val != null && !Property.PropertyType.IsAssignableFrom(val.GetType())) // is it the correct type
val = null;
}
//////////////////////////////////////////////
/// Step 2: Try creating from default value
if (val == null)
{
_UsingDefaultValue = true;
if (Property.DefaultValue == null || Property.DefaultValue.ToString() == "[null]") {
if (Property.PropertyType.IsValueType)
return Activator.CreateInstance(Property.PropertyType);
else
return null;
}
if (!(Property.DefaultValue is string)) {
val = Property.DefaultValue;
} else {
try {
val = GetObjectFromString(Property.PropertyType, Property.SerializeAs, (string)Property.DefaultValue);
} catch(Exception e) {
throw new ArgumentException(SR.GetString(SR.Could_not_create_from_default_value, Property.Name, e.Message));
}
}
if (val != null && !Property.PropertyType.IsAssignableFrom(val.GetType())) // is it the correct type
throw new ArgumentException(SR.GetString(SR.Could_not_create_from_default_value_2, Property.Name));
}
//////////////////////////////////////////////
/// Step 3: Create a new one by calling the parameterless constructor
if (val == null)
{
if (Property.PropertyType == typeof(string)) {
val = "";
} else {
try {
val = Activator.CreateInstance(Property.PropertyType);
} catch {}
}
}
return val;
}
private static object GetObjectFromString(Type type, SettingsSerializeAs serializeAs, string attValue)
{
// Deal with string types
if (type == typeof(string) && (attValue == null || attValue.Length < 1 || serializeAs == SettingsSerializeAs.String))
return attValue;
// Return null if there is nothing to convert
if (attValue == null || attValue.Length < 1)
return null;
// Convert based on the serialized type
switch (serializeAs)
{
case SettingsSerializeAs.Binary:
byte[] buf = Convert.FromBase64String(attValue);
MemoryStream ms = null;
try {
ms = new System.IO.MemoryStream(buf);
return (new BinaryFormatter()).Deserialize(ms);
} finally {
if (ms != null)
ms.Close();
}
case SettingsSerializeAs.Xml:
StringReader sr = new StringReader(attValue);
XmlSerializer xs = new XmlSerializer(type);
return xs.Deserialize(sr);
case SettingsSerializeAs.String:
TypeConverter converter = TypeDescriptor.GetConverter(type);
if (converter != null && converter.CanConvertTo(typeof(String)) && converter.CanConvertFrom(typeof(String)))
return converter.ConvertFromInvariantString(attValue);
throw new ArgumentException(SR.GetString(SR.Unable_to_convert_type_from_string, type.ToString()), "type");
default:
return null;
}
}
private object SerializePropertyValue()
{
if (_Value == null)
return null;
if (Property.SerializeAs != SettingsSerializeAs.Binary)
return ConvertObjectToString(_Value, Property.PropertyType, Property.SerializeAs, Property.ThrowOnErrorSerializing);
MemoryStream ms = new System.IO.MemoryStream();
try {
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(ms, _Value);
return ms.ToArray();
} finally {
ms.Close();
}
}
private static string ConvertObjectToString(object propValue, Type type, SettingsSerializeAs serializeAs, bool throwOnError)
{
if (serializeAs == SettingsSerializeAs.ProviderSpecific) {
if (type == typeof(string) || type.IsPrimitive)
serializeAs = SettingsSerializeAs.String;
else
serializeAs = SettingsSerializeAs.Xml;
}
try {
switch (serializeAs) {
case SettingsSerializeAs.String:
TypeConverter converter = TypeDescriptor.GetConverter(type);
if (converter != null && converter.CanConvertTo(typeof(String)) && converter.CanConvertFrom(typeof(String)))
return converter.ConvertToInvariantString(propValue);
throw new ArgumentException(SR.GetString(SR.Unable_to_convert_type_to_string, type.ToString()), "type");
case SettingsSerializeAs.Binary :
MemoryStream ms = new System.IO.MemoryStream();
try {
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(ms, propValue);
byte[] buffer = ms.ToArray();
return Convert.ToBase64String(buffer);
} finally {
ms.Close();
}
case SettingsSerializeAs.Xml :
XmlSerializer xs = new XmlSerializer(type);
StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
xs.Serialize(sw, propValue);
return sw.ToString();
}
} catch (Exception) {
if (throwOnError)
throw;
}
return null;
}
private object _Value = null;
private object _SerializedValue = null;
private bool _Deserialized = false;
private bool _IsDirty = false;
private SettingsProperty _Property = null;
private bool _ChangedSinceLastSerialized = false;
private bool _UsingDefaultValue = true;
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Configuration {
using System.Collections;
using System.Collections.Specialized;
using System.Runtime.Serialization;
using System.Configuration.Provider;
using System.Globalization;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Xml.Serialization;
using System.ComponentModel;
using System.Security.Permissions;
using System.Reflection;
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
public class SettingsPropertyValue
{
public string Name { get { return _Property.Name; } }
public bool IsDirty { get { return _IsDirty; } set { _IsDirty = value; }}
public SettingsProperty Property { get { return _Property; } }
public bool UsingDefaultValue { get { return _UsingDefaultValue; } }
public SettingsPropertyValue(SettingsProperty property)
{
_Property = property;
}
public object PropertyValue
{
get
{
if (!_Deserialized)
{
_Value = Deserialize();
_Deserialized = true;
}
if (_Value != null && !Property.PropertyType.IsPrimitive && !(_Value is string) && !(_Value is DateTime))
{
_UsingDefaultValue = false;
_ChangedSinceLastSerialized = true;
_IsDirty = true;
}
return _Value;
}
set
{
_Value = value;
_IsDirty = true;
_ChangedSinceLastSerialized = true;
_Deserialized = true;
_UsingDefaultValue = false;
}
}
public object SerializedValue
{
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
get {
if (_ChangedSinceLastSerialized) {
_ChangedSinceLastSerialized = false;
_SerializedValue = SerializePropertyValue();
}
return _SerializedValue;
}
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
set {
_UsingDefaultValue = false;
_SerializedValue = value;
}
}
public bool Deserialized
{
get { return _Deserialized; }
set { _Deserialized = value; }
}
private bool IsHostedInAspnet() {
// See System.Web.Hosting.ApplicationManager::PopulateDomainBindings
return AppDomain.CurrentDomain.GetData(".appDomain") != null;
}
private object Deserialize()
{
object val = null;
//////////////////////////////////////////////
/// Step 1: Try creating from Serailized value
if (SerializedValue != null)
{
try {
if (SerializedValue is string) {
val = GetObjectFromString(Property.PropertyType, Property.SerializeAs, (string)SerializedValue);
} else {
MemoryStream ms = new System.IO.MemoryStream((byte[])SerializedValue);
try {
val = (new BinaryFormatter()).Deserialize(ms);
} finally {
ms.Close();
}
}
}
catch (Exception exception) {
try {
if (IsHostedInAspnet()) {
object[] args = new object[] { Property, this, exception};
const string webBaseEventTypeName = "System.Web.Management.WebBaseEvent, " + AssemblyRef.SystemWeb;
Type type = Type.GetType(webBaseEventTypeName, true);
type.InvokeMember("RaisePropertyDeserializationWebErrorEvent",
BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.InvokeMethod,
null, null, args, CultureInfo.InvariantCulture);
}
}
catch {
}
}
if (val != null && !Property.PropertyType.IsAssignableFrom(val.GetType())) // is it the correct type
val = null;
}
//////////////////////////////////////////////
/// Step 2: Try creating from default value
if (val == null)
{
_UsingDefaultValue = true;
if (Property.DefaultValue == null || Property.DefaultValue.ToString() == "[null]") {
if (Property.PropertyType.IsValueType)
return Activator.CreateInstance(Property.PropertyType);
else
return null;
}
if (!(Property.DefaultValue is string)) {
val = Property.DefaultValue;
} else {
try {
val = GetObjectFromString(Property.PropertyType, Property.SerializeAs, (string)Property.DefaultValue);
} catch(Exception e) {
throw new ArgumentException(SR.GetString(SR.Could_not_create_from_default_value, Property.Name, e.Message));
}
}
if (val != null && !Property.PropertyType.IsAssignableFrom(val.GetType())) // is it the correct type
throw new ArgumentException(SR.GetString(SR.Could_not_create_from_default_value_2, Property.Name));
}
//////////////////////////////////////////////
/// Step 3: Create a new one by calling the parameterless constructor
if (val == null)
{
if (Property.PropertyType == typeof(string)) {
val = "";
} else {
try {
val = Activator.CreateInstance(Property.PropertyType);
} catch {}
}
}
return val;
}
private static object GetObjectFromString(Type type, SettingsSerializeAs serializeAs, string attValue)
{
// Deal with string types
if (type == typeof(string) && (attValue == null || attValue.Length < 1 || serializeAs == SettingsSerializeAs.String))
return attValue;
// Return null if there is nothing to convert
if (attValue == null || attValue.Length < 1)
return null;
// Convert based on the serialized type
switch (serializeAs)
{
case SettingsSerializeAs.Binary:
byte[] buf = Convert.FromBase64String(attValue);
MemoryStream ms = null;
try {
ms = new System.IO.MemoryStream(buf);
return (new BinaryFormatter()).Deserialize(ms);
} finally {
if (ms != null)
ms.Close();
}
case SettingsSerializeAs.Xml:
StringReader sr = new StringReader(attValue);
XmlSerializer xs = new XmlSerializer(type);
return xs.Deserialize(sr);
case SettingsSerializeAs.String:
TypeConverter converter = TypeDescriptor.GetConverter(type);
if (converter != null && converter.CanConvertTo(typeof(String)) && converter.CanConvertFrom(typeof(String)))
return converter.ConvertFromInvariantString(attValue);
throw new ArgumentException(SR.GetString(SR.Unable_to_convert_type_from_string, type.ToString()), "type");
default:
return null;
}
}
private object SerializePropertyValue()
{
if (_Value == null)
return null;
if (Property.SerializeAs != SettingsSerializeAs.Binary)
return ConvertObjectToString(_Value, Property.PropertyType, Property.SerializeAs, Property.ThrowOnErrorSerializing);
MemoryStream ms = new System.IO.MemoryStream();
try {
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(ms, _Value);
return ms.ToArray();
} finally {
ms.Close();
}
}
private static string ConvertObjectToString(object propValue, Type type, SettingsSerializeAs serializeAs, bool throwOnError)
{
if (serializeAs == SettingsSerializeAs.ProviderSpecific) {
if (type == typeof(string) || type.IsPrimitive)
serializeAs = SettingsSerializeAs.String;
else
serializeAs = SettingsSerializeAs.Xml;
}
try {
switch (serializeAs) {
case SettingsSerializeAs.String:
TypeConverter converter = TypeDescriptor.GetConverter(type);
if (converter != null && converter.CanConvertTo(typeof(String)) && converter.CanConvertFrom(typeof(String)))
return converter.ConvertToInvariantString(propValue);
throw new ArgumentException(SR.GetString(SR.Unable_to_convert_type_to_string, type.ToString()), "type");
case SettingsSerializeAs.Binary :
MemoryStream ms = new System.IO.MemoryStream();
try {
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(ms, propValue);
byte[] buffer = ms.ToArray();
return Convert.ToBase64String(buffer);
} finally {
ms.Close();
}
case SettingsSerializeAs.Xml :
XmlSerializer xs = new XmlSerializer(type);
StringWriter sw = new StringWriter(CultureInfo.InvariantCulture);
xs.Serialize(sw, propValue);
return sw.ToString();
}
} catch (Exception) {
if (throwOnError)
throw;
}
return null;
}
private object _Value = null;
private object _SerializedValue = null;
private bool _Deserialized = false;
private bool _IsDirty = false;
private SettingsProperty _Property = null;
private bool _ChangedSinceLastSerialized = false;
private bool _UsingDefaultValue = true;
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- ModelPropertyCollectionImpl.cs
- BufferedGraphics.cs
- PackUriHelper.cs
- SafeTokenHandle.cs
- AnimatedTypeHelpers.cs
- InterleavedZipPartStream.cs
- MarshalByValueComponent.cs
- OracleDataAdapter.cs
- WebResourceAttribute.cs
- WebServiceHandler.cs
- MonthCalendarDesigner.cs
- WebPartConnectionsDisconnectVerb.cs
- ToolStripDropDown.cs
- GPPOINTF.cs
- RegexInterpreter.cs
- DbParameterCollectionHelper.cs
- PrivilegedConfigurationManager.cs
- InvocationExpression.cs
- InitializingNewItemEventArgs.cs
- XmlSchemaCollection.cs
- MetadataArtifactLoaderCompositeFile.cs
- DeploymentSection.cs
- MultipartContentParser.cs
- SubstitutionDesigner.cs
- NamespaceQuery.cs
- ScaleTransform.cs
- WebColorConverter.cs
- MergeLocalizationDirectives.cs
- EntityDataSourceState.cs
- OuterProxyWrapper.cs
- BinaryObjectReader.cs
- StylusOverProperty.cs
- DispatchWrapper.cs
- SQLMembershipProvider.cs
- EntityType.cs
- StylusPointCollection.cs
- CodeExporter.cs
- SharedPersonalizationStateInfo.cs
- FirstMatchCodeGroup.cs
- HuffmanTree.cs
- ArcSegment.cs
- PerformanceCounterPermission.cs
- HttpServerVarsCollection.cs
- AssociationTypeEmitter.cs
- VersionedStreamOwner.cs
- ToolBar.cs
- DelegateBodyWriter.cs
- PermissionRequestEvidence.cs
- WizardStepBase.cs
- ComponentRenameEvent.cs
- DockPattern.cs
- WebPartEditVerb.cs
- DataGridView.cs
- Win32MouseDevice.cs
- ContentPropertyAttribute.cs
- ClientProxyGenerator.cs
- HttpPostedFile.cs
- SqlRemoveConstantOrderBy.cs
- CompiledRegexRunner.cs
- DetailsViewUpdatedEventArgs.cs
- ExtendedProperty.cs
- PointHitTestResult.cs
- ByteConverter.cs
- LinqDataSourceDeleteEventArgs.cs
- RelationshipEnd.cs
- Simplifier.cs
- XmlAnyAttributeAttribute.cs
- XmlSchemaAppInfo.cs
- ObjectConverter.cs
- ValuePatternIdentifiers.cs
- InkCanvasInnerCanvas.cs
- DataFieldConverter.cs
- SystemThemeKey.cs
- CrossAppDomainChannel.cs
- DashStyles.cs
- ContentHostHelper.cs
- LocalValueEnumerator.cs
- CheckBoxList.cs
- FilterElement.cs
- ReceiveCompletedEventArgs.cs
- ProfileSection.cs
- Queue.cs
- Filter.cs
- ContextProperty.cs
- MSAANativeProvider.cs
- SqlDataSourceSummaryPanel.cs
- Timer.cs
- DragDropHelper.cs
- XmlIncludeAttribute.cs
- OrderedDictionaryStateHelper.cs
- OutputCache.cs
- RedBlackList.cs
- Matrix.cs
- SynchronizationLockException.cs
- FullTextState.cs
- FormattedText.cs
- GroupDescription.cs
- Size3D.cs
- InstallerTypeAttribute.cs
- DataBindingList.cs