public void Deny_Unrestricted ()
{
DataBindingCollection dbc = new DataBindingCollection ();
Assert.AreEqual (0, dbc.Count, "Count");
Assert.IsFalse (dbc.IsReadOnly, "IsReadOnly");
Assert.IsFalse (dbc.IsSynchronized, "IsSynchronized");
dbc.Add (db);
Assert.AreSame (db, dbc["property"], "this[string]");
Assert.IsNotNull (dbc.RemovedBindings, "RemovedBindings");
Assert.IsNotNull (dbc.SyncRoot, "SyncRoot");
Assert.IsNotNull (dbc.GetEnumerator (), "GetEnumerator");
dbc.CopyTo (new DataBinding[1], 0);
dbc.Clear ();
dbc.Add (db);
dbc.Remove (db);
dbc.Add (db);
dbc.Remove ("property");
dbc.Remove ("property", true);
#if NET_2_0
dbc.Changed += new EventHandler (Handler);
Assert.IsFalse (dbc.Contains ("property"), "Contains");
dbc.Changed -= new EventHandler (Handler);
#endif
}
private static bool CanSerializeAsInnerDefaultString(string filter, string name, Type type, ObjectPersistData persistData, PersistenceMode mode, DataBindingCollection dataBindings, ExpressionBindingCollection expressions)
{
if (((((type == typeof(string)) && (filter.Length == 0)) && ((mode == PersistenceMode.InnerDefaultProperty) || (mode == PersistenceMode.EncodedInnerDefaultProperty))) && ((dataBindings == null) || (dataBindings[name] == null))) && ((expressions == null) || (expressions[name] == null)))
{
if (persistData == null)
{
return true;
}
ICollection propertyAllFilters = persistData.GetPropertyAllFilters(name);
if (propertyAllFilters.Count == 0)
{
return true;
}
if (propertyAllFilters.Count == 1)
{
foreach (PropertyEntry entry in propertyAllFilters)
{
if ((entry.Filter.Length == 0) && (entry is ComplexPropertyEntry))
{
return true;
}
}
}
}
return false;
}
private void ApplyBoundProperties(Control control)
{
DataBindingCollection dataBindings = null;
IAttributeAccessor attributeAccessor = null;
foreach (BoundPropertyEntry entry in base.GetFilteredPropertyEntrySet(this._skinBuilder.BoundPropertyEntries))
{
this.InitBoundProperty(control, entry, ref dataBindings, ref attributeAccessor);
}
}
private void InitBoundProperty(Control control, BoundPropertyEntry entry, ref DataBindingCollection dataBindings, ref IAttributeAccessor attributeAccessor)
{
if (entry.ExpressionPrefix.Length != 0)
{
throw new InvalidOperationException(System.Web.SR.GetString("ControlBuilder_ExpressionsNotAllowedInThemes"));
}
if ((dataBindings == null) && (control != null))
{
dataBindings = ((IDataBindingsAccessor)control).DataBindings;
}
dataBindings.Add(new DataBinding(entry.Name, entry.Type, entry.Expression.Trim()));
}
private void ApplyBoundProperties(Control control)
{
DataBindingCollection dataBindings = null;
IAttributeAccessor attributeAccessor = null;
// If there are no filters in the picture, use the entries as is
ICollection entries = GetFilteredPropertyEntrySet(_skinBuilder.BoundPropertyEntries);
foreach (BoundPropertyEntry entry in entries)
{
InitBoundProperty(control, entry, ref dataBindings, ref attributeAccessor);
}
}
[Test] public void ChangeTest ()
{
DataBindingCollection a = new DataBindingCollection ();
a.Changed += delegate {
changed = true;
};
DataBinding b = new DataBinding ("a", typeof (DataBindingCollectionTest), "b");
a.Add (b);
Assert.AreEqual (true, changed, "DB1");
changed = false;
a.Clear ();
Assert.AreEqual (false, changed, "DB2");
a.Remove (b);
Assert.AreEqual (true, changed, "DB3");
}
private void InitBoundProperty(Control control, BoundPropertyEntry entry,
ref DataBindingCollection dataBindings, ref IAttributeAccessor attributeAccessor)
{
string expressionPrefix = entry.ExpressionPrefix;
// If we're in the designer, add the bound properties to the collections
if (expressionPrefix.Length == 0)
{
if (dataBindings == null && control is IDataBindingsAccessor)
{
dataBindings = ((IDataBindingsAccessor)control).DataBindings;
}
dataBindings.Add(new DataBinding(entry.Name, entry.Type, entry.Expression.Trim()));
}
else
{
throw new InvalidOperationException(SR.GetString(SR.ControlBuilder_ExpressionsNotAllowedInThemes));
}
}
private void InitBoundProperty(Control control, BoundPropertyEntry entry,
ref DataBindingCollection dataBindings, ref IAttributeAccessor attributeAccessor) {
string expressionPrefix = entry.ExpressionPrefix;
// If we're in the designer, add the bound properties to the collections
if (expressionPrefix.Length == 0) {
if (dataBindings == null && control is IDataBindingsAccessor) {
dataBindings = ((IDataBindingsAccessor)control).DataBindings;
}
dataBindings.Add(new DataBinding(entry.Name, entry.Type, entry.Expression.Trim()));
}
else {
throw new InvalidOperationException(SR.GetString(SR.ControlBuilder_ExpressionsNotAllowedInThemes));
}
}
private void InitBoundProperty(object obj, BoundPropertyEntry entry,
ref DataBindingCollection dataBindings, ref IAttributeAccessor attributeAccessor) {
string expressionPrefix = entry.ExpressionPrefix == null ? String.Empty : entry.ExpressionPrefix.Trim();
// If we're in the designer, add the bound properties to the collections
if (InDesigner) {
if (String.IsNullOrEmpty(expressionPrefix)) {
if (dataBindings == null && obj is IDataBindingsAccessor) {
dataBindings = ((IDataBindingsAccessor)obj).DataBindings;
}
dataBindings.Add(new DataBinding(entry.Name, entry.Type, entry.Expression.Trim()));
}
else {
if (obj is IExpressionsAccessor) {
string expression = entry.Expression == null ? String.Empty : entry.Expression.Trim();
((IExpressionsAccessor)obj).Expressions.Add(new ExpressionBinding(entry.Name, entry.Type, expressionPrefix, expression, entry.Generated, entry.ParsedExpressionData));
}
}
}
// If we're in no-compile mode, set the values for expressions that support evaluate
else {
if (!String.IsNullOrEmpty(expressionPrefix)) {
ExpressionBuilder eb = entry.ExpressionBuilder;
Debug.Assert(eb != null, "Did not expect null expression builder");
if (eb.SupportsEvaluate) {
string name = entry.Name;
// DevDiv Bugs 160497: Create the expression context with whatever information we have.
// We used to always use the TemplateControl one, but sometimes it's null, so we should
// fall back to the VirtualPath one if we can.
ExpressionBuilderContext expressionContext;
if (TemplateControl != null) {
expressionContext = new ExpressionBuilderContext(TemplateControl);
}
else {
expressionContext = new ExpressionBuilderContext(VirtualPath);
}
object value = eb.EvaluateExpression(obj, entry,
entry.ParsedExpressionData, expressionContext);
if (entry.UseSetAttribute) {
if (attributeAccessor == null) {
Debug.Assert(obj is IAttributeAccessor);
attributeAccessor = (IAttributeAccessor)obj;
}
attributeAccessor.SetAttribute(name, value.ToString());
}
else {
try {
PropertyMapper.SetMappedPropertyValue(obj, name, value, InDesigner);
}
catch (Exception e) {
throw new HttpException(SR.GetString(SR.Cannot_set_property, entry.ExpressionPrefix + ":" + entry.Expression, name), e);
}
}
}
else {
Debug.Fail("Got a ExpressionBuilder that does not support Evaluate in a non-compiled page");
}
}
else {
// no-compile Bind property handling
((Control)obj).DataBinding += new EventHandler(DataBindingMethod);
}
}
}
private static void SerializeAttributesRecursive(object obj, IDesignerHost host, string prefix, ObjectPersistData persistData, string filter, ArrayList attributes, DataBindingCollection dataBindings, ExpressionBindingCollection expressions, bool topLevelInDesigner)
{
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(obj);
if (obj is IDataBindingsAccessor)
{
dataBindings = ((IDataBindingsAccessor) obj).DataBindings;
}
if (obj is Control)
{
try
{
ControlCollection controls = ((Control) obj).Controls;
}
catch (Exception exception)
{
IComponentDesignerDebugService service = host.GetService(typeof(IComponentDesignerDebugService)) as IComponentDesignerDebugService;
if (service != null)
{
service.Fail(exception.Message);
}
}
}
if (obj is IExpressionsAccessor)
{
expressions = ((IExpressionsAccessor) obj).Expressions;
}
for (int i = 0; i < properties.Count; i++)
{
try
{
SerializeAttribute(obj, properties[i], dataBindings, expressions, host, prefix, persistData, filter, attributes, topLevelInDesigner);
}
catch (Exception exception2)
{
if (host != null)
{
IComponentDesignerDebugService service2 = host.GetService(typeof(IComponentDesignerDebugService)) as IComponentDesignerDebugService;
if (service2 != null)
{
service2.Fail(exception2.Message);
}
}
}
}
}
private static void SerializeAttribute(object obj, PropertyDescriptor propDesc, DataBindingCollection dataBindings, ExpressionBindingCollection expressions, IDesignerHost host, string prefix, ObjectPersistData persistData, string filter, ArrayList attributes, bool topLevelInDesigner)
{
DesignOnlyAttribute attribute = (DesignOnlyAttribute) propDesc.Attributes[typeof(DesignOnlyAttribute)];
if ((attribute == null) || !attribute.IsDesignOnly)
{
string name = propDesc.Name;
Type propertyType = propDesc.PropertyType;
PersistenceMode mode = ((PersistenceModeAttribute) propDesc.Attributes[typeof(PersistenceModeAttribute)]).Mode;
bool flag = (dataBindings != null) && (dataBindings[name] != null);
bool flag2 = (expressions != null) && (expressions[name] != null);
if (((flag || flag2) || (propDesc.SerializationVisibility != DesignerSerializationVisibility.Hidden)) && (((mode == PersistenceMode.Attribute) || ((flag && flag2) && (propertyType == typeof(string)))) || ((mode != PersistenceMode.InnerProperty) && (propertyType == typeof(string)))))
{
string str2 = string.Empty;
if (prefix.Length > 0)
{
str2 = prefix + "-" + name;
}
else
{
str2 = name;
}
if (propDesc.SerializationVisibility == DesignerSerializationVisibility.Content)
{
SerializeAttributesRecursive(propDesc.GetValue(obj), host, str2, persistData, filter, attributes, dataBindings, expressions, topLevelInDesigner);
}
else
{
IAttributeAccessor accessor = obj as IAttributeAccessor;
if (!propDesc.IsReadOnly || ((accessor != null) && (accessor.GetAttribute(str2) != null)))
{
string str3 = ConvertPersistToObjectModelName(str2);
if (!FilterableAttribute.IsPropertyFilterable(propDesc))
{
filter = string.Empty;
}
if (CanSerializeAsInnerDefaultString(filter, str3, propertyType, persistData, mode, dataBindings, expressions))
{
if (topLevelInDesigner)
{
attributes.Add(new Triplet(filter, str2, null));
}
}
else
{
bool flag3 = true;
object objB = null;
object objA = propDesc.GetValue(obj);
BindingType none = BindingType.None;
if (dataBindings != null)
{
DataBinding binding = dataBindings[str3];
if (binding != null)
{
objA = binding.Expression;
none = BindingType.Data;
}
}
if (none == BindingType.None)
{
if (expressions != null)
{
ExpressionBinding binding2 = expressions[str3];
if ((binding2 != null) && !binding2.Generated)
{
objA = binding2.ExpressionPrefix + ":" + binding2.Expression;
none = BindingType.Expression;
}
}
else if (persistData != null)
{
BoundPropertyEntry filteredProperty = persistData.GetFilteredProperty(filter, name) as BoundPropertyEntry;
if ((filteredProperty != null) && !filteredProperty.Generated)
{
objB = GetPropertyDefaultValue(propDesc, str2, persistData, filter, host);
if (object.Equals(objA, objB))
{
objA = filteredProperty.ExpressionPrefix + ":" + filteredProperty.Expression;
none = BindingType.Expression;
}
}
}
}
if (filter.Length == 0)
{
bool useResult = false;
bool flag5 = false;
if (none == BindingType.None)
{
flag5 = GetShouldSerializeValue(obj, name, out useResult);
}
if (useResult)
{
flag3 = flag5;
}
else
{
objB = GetPropertyDefaultValue(propDesc, str2, persistData, filter, host);
flag3 = !object.Equals(objA, objB);
}
}
else
{
objB = GetPropertyDefaultValue(propDesc, str2, persistData, filter, host);
flag3 = !object.Equals(objA, objB);
}
if (flag3)
{
string z = GetPersistValue(propDesc, propertyType, objA, none, topLevelInDesigner);
if (((topLevelInDesigner && (objB != null)) && ((z == null) || (z.Length == 0))) && ShouldPersistBlankValue(objB, propertyType))
{
z = string.Empty;
}
if ((z != null) && (!propertyType.IsArray || (z.Length > 0)))
{
attributes.Add(new Triplet(filter, str2, z));
}
else if (topLevelInDesigner)
{
attributes.Add(new Triplet(filter, str2, null));
}
}
else if (topLevelInDesigner)
{
attributes.Add(new Triplet(filter, str2, null));
}
if (persistData != null)
{
foreach (PropertyEntry entry2 in persistData.GetPropertyAllFilters(str3))
{
if (string.Compare(entry2.Filter, filter, StringComparison.OrdinalIgnoreCase) != 0)
{
string str5 = string.Empty;
if (entry2 is SimplePropertyEntry)
{
SimplePropertyEntry entry3 = (SimplePropertyEntry) entry2;
if (entry3.UseSetAttribute)
{
str5 = entry3.Value.ToString();
}
else
{
str5 = GetPersistValue(propDesc, entry2.Type, entry3.Value, BindingType.None, topLevelInDesigner);
}
}
else if (entry2 is BoundPropertyEntry)
{
BoundPropertyEntry entry4 = (BoundPropertyEntry) entry2;
if (entry4.Generated)
{
continue;
}
string propValue = entry4.Expression.Trim();
none = BindingType.Data;
string expressionPrefix = entry4.ExpressionPrefix;
if (expressionPrefix.Length > 0)
{
propValue = expressionPrefix + ":" + propValue;
none = BindingType.Expression;
}
str5 = GetPersistValue(propDesc, entry2.Type, propValue, none, topLevelInDesigner);
}
else if (entry2 is ComplexPropertyEntry)
{
ComplexPropertyEntry entry5 = (ComplexPropertyEntry) entry2;
str5 = (string) entry5.Builder.BuildObject();
}
attributes.Add(new Triplet(entry2.Filter, str2, str5));
}
}
}
}
}
}
}
}
}
private void InitBoundProperty(object obj, BoundPropertyEntry entry, ref DataBindingCollection dataBindings, ref IAttributeAccessor attributeAccessor)
{
string str = (entry.ExpressionPrefix == null) ? string.Empty : entry.ExpressionPrefix.Trim();
if (this.InDesigner)
{
if (string.IsNullOrEmpty(str))
{
if ((dataBindings == null) && (obj is IDataBindingsAccessor))
{
dataBindings = ((IDataBindingsAccessor) obj).DataBindings;
}
dataBindings.Add(new DataBinding(entry.Name, entry.Type, entry.Expression.Trim()));
}
else if (obj is IExpressionsAccessor)
{
string expression = (entry.Expression == null) ? string.Empty : entry.Expression.Trim();
((IExpressionsAccessor) obj).Expressions.Add(new ExpressionBinding(entry.Name, entry.Type, str, expression, entry.Generated, entry.ParsedExpressionData));
}
}
else
{
if (!string.IsNullOrEmpty(str))
{
ExpressionBuilderContext context;
ExpressionBuilder expressionBuilder = entry.ExpressionBuilder;
if (!expressionBuilder.SupportsEvaluate)
{
return;
}
string name = entry.Name;
if (this.TemplateControl != null)
{
context = new ExpressionBuilderContext(this.TemplateControl);
}
else
{
context = new ExpressionBuilderContext(this.VirtualPath);
}
object obj2 = expressionBuilder.EvaluateExpression(obj, entry, entry.ParsedExpressionData, context);
if (entry.UseSetAttribute)
{
if (attributeAccessor == null)
{
attributeAccessor = (IAttributeAccessor) obj;
}
attributeAccessor.SetAttribute(name, obj2.ToString());
return;
}
try
{
PropertyMapper.SetMappedPropertyValue(obj, name, obj2, this.InDesigner);
return;
}
catch (Exception exception)
{
throw new HttpException(System.Web.SR.GetString("Cannot_set_property", new object[] { entry.ExpressionPrefix + ":" + entry.Expression, name }), exception);
}
}
((Control) obj).DataBinding += new EventHandler(this.DataBindingMethod);
}
}
/*
* Set all the properties we have on the passed in object
* This is not called when generating code for compiling... it is
* used in design-mode, and at runtime when the user calls Page.ParseControl
*/
internal void SetProperties(object obj)
{
Debug.Assert(_fInDesigner, "Expected to be running in design mode.");
object[] parameters = new object[1];
IAttributeAccessor attributeAccessor = null;
DataBindingCollection dataBindings = null;
if (_fDataBound && (_entries.Count != 0))
{
Debug.Assert(obj is Control, "SetProperties on databindings PropertySetter should only be called for controls.");
dataBindings = ((IDataBindingsAccessor)obj).DataBindings;
}
// Get the supported attribute interfaces
if (_fSupportsAttributes)
{
attributeAccessor = (IAttributeAccessor)obj;
}
IEnumerator en = _entries.GetEnumerator();
while (en.MoveNext())
{
PropertySetterEntry entry = (PropertySetterEntry)en.Current;
if (entry._propType == null)
{
if (entry._fItemProp)
{
try {
object objValue = entry._builder.BuildObject();
parameters[0] = objValue;
MethodInfo methodInfo = _objType.GetMethod("Add", BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static,
null /*binder*/, new Type[] { objValue.GetType() }, null /*modifiers*/);
Util.InvokeMethod(methodInfo, obj, parameters);
}
catch (Exception) {
throw new HttpException(
HttpRuntime.FormatResourceString(SR.Cannot_add_value_not_collection, entry._value));
}
}
else
{
// If there is no property, use SetAttribute
if (attributeAccessor != null)
{
attributeAccessor.SetAttribute(entry._name, entry._value);
}
}
}
else
{
// Use the propinfo to set the prop
// Use either _propValue or _builder, whichever is set
if (entry._propValue != null)
{
try {
PropertyMapper.SetMappedPropertyValue(obj, entry._name, entry._propValue);
}
catch (Exception e) {
throw new HttpException(
HttpRuntime.FormatResourceString(SR.Cannot_set_property,
entry._value, entry._name), e);
}
}
else if (entry._builder != null)
{
if (entry._fReadOnlyProp)
{
// a complex property is allowed to be readonly
try {
object objValue;
// Get the property since its readonly
MethodInfo methodInfo = entry._propInfo.GetGetMethod();
objValue = Util.InvokeMethod(methodInfo, obj, null);
// now we need to initialize this property
entry._builder.InitObject(objValue);
}
catch (Exception e) {
throw new HttpException(
HttpRuntime.FormatResourceString(SR.Cannot_init, entry._name), e);
}
}
else
{
try {
object objValue = entry._builder.BuildObject();
parameters[0] = objValue;
// Set the property
MethodInfo methodInfo = entry._propInfo.GetSetMethod();
Util.InvokeMethod(methodInfo, obj, parameters);
}
catch (Exception e) {
throw new HttpException(
HttpRuntime.FormatResourceString(SR.Cannot_set_property,
entry._value, entry._name), e);
}
}
}
else if (dataBindings != null)
{
DataBinding binding = new DataBinding(entry._name, entry._propType, entry._value.Trim());
dataBindings.Add(binding);
}
else
{
Debug.Assert(false, "'" + entry._value + "' failed to be set on property '" + entry._name + "'.");
}
}
}
}
private void InitBoundProperty(Control control, BoundPropertyEntry entry, ref DataBindingCollection dataBindings, ref IAttributeAccessor attributeAccessor)
{
if (entry.ExpressionPrefix.Length != 0)
{
throw new InvalidOperationException(System.Web.SR.GetString("ControlBuilder_ExpressionsNotAllowedInThemes"));
}
if ((dataBindings == null) && (control != null))
{
dataBindings = ((IDataBindingsAccessor) control).DataBindings;
}
dataBindings.Add(new DataBinding(entry.Name, entry.Type, entry.Expression.Trim()));
}