Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / xsp / System / Web / UI / DataBinder.cs / 1 / DataBinder.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Web.UI {
using System;
using System.Globalization;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Data;
using System.Reflection;
using System.Security.Permissions;
using System.Web.Util;
///
/// Provides design-time support for RAD designers to
/// generate and parse
///
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
public sealed class DataBinder {
private static readonly char[] expressionPartSeparator = new char[] { '.'};
private static readonly char[] indexExprStartChars = new char[] { '[', '('};
private static readonly char[] indexExprEndChars = new char[] { ']', ')'};
///
/// Evaluates data binding expressions at runtime. While
/// this method is automatically called when you create data bindings in a RAD
/// designer, you can also use it declaratively if you want to simplify the casting
/// to a text string to be displayed on a browser. To do so, you must place the
/// <%# and %> tags, which are also used in standard ASP.NET data binding, around the data binding expression.
/// This method is particularly useful when data binding against controls that
/// are in a templated list.
///
/// Since this method is called at runtime, it can cause performance
/// to noticeably slow compared to standard ASP.NET databinding syntax.
/// Use this method judiciously.
///
///
public static object Eval(object container, string expression) {
if (expression == null) {
throw new ArgumentNullException("expression");
}
expression = expression.Trim();
if (expression.Length == 0) {
throw new ArgumentNullException("expression");
}
if (container == null) {
return null;
}
string[] expressionParts = expression.Split(expressionPartSeparator);
return DataBinder.Eval(container, expressionParts);
}
///
///
private static object Eval(object container, string[] expressionParts) {
Debug.Assert((expressionParts != null) && (expressionParts.Length != 0),
"invalid expressionParts parameter");
object prop;
int i;
for (prop = container, i = 0; (i < expressionParts.Length) && (prop != null); i++) {
string expr = expressionParts[i];
bool indexedExpr = expr.IndexOfAny(indexExprStartChars) >= 0;
if (indexedExpr == false) {
prop = DataBinder.GetPropertyValue(prop, expr);
}
else {
prop = DataBinder.GetIndexedPropertyValue(prop, expr);
}
}
return prop;
}
///
/// Evaluates data binding expressions at runtime and
/// formats the output as text to be displayed in the requesting browser. While this
/// method is automatically called when you create data bindings in a RAD designer,
/// you can also use it declaratively if you want to simplify the casting to a text
/// string to be displayed on a browser. To do so, you must place the <%# and %> tags, which are also used in standard ASP.NET data binding, around
/// the data binding expression.
/// This method is particularly useful when data binding against controls that
/// are in a templated list.
///
/// Since this method is called at
/// runtime, it can cause performance to noticeably slow compared to standard ASP.NET
/// databinding syntax. Use this method judiciously, particularly when string
/// formatting is not required.
///
///
public static string Eval(object container, string expression, string format) {
object value = DataBinder.Eval(container, expression);
if ((value == null) || (value == System.DBNull.Value)) {
return String.Empty;
}
else {
if (String.IsNullOrEmpty(format)) {
return value.ToString();
}
else {
return String.Format(format, value);
}
}
}
///
///
public static object GetPropertyValue(object container, string propName) {
if (container == null) {
throw new ArgumentNullException("container");
}
if (String.IsNullOrEmpty(propName)) {
throw new ArgumentNullException("propName");
}
object prop = null;
// get a PropertyDescriptor using case-insensitive lookup
PropertyDescriptor pd = TypeDescriptor.GetProperties(container).Find(propName, true);
if (pd != null) {
prop = pd.GetValue(container);
}
else {
throw new HttpException(SR.GetString(SR.DataBinder_Prop_Not_Found, container.GetType().FullName, propName));
}
return prop;
}
///
///
public static string GetPropertyValue(object container, string propName, string format) {
object value = DataBinder.GetPropertyValue(container, propName);
if ((value == null) || (value == System.DBNull.Value)) {
return string.Empty;
}
else {
if (String.IsNullOrEmpty(format)) {
return value.ToString();
}
else {
return string.Format(format, value);
}
}
}
///
///
public static object GetIndexedPropertyValue(object container, string expr) {
if (container == null) {
throw new ArgumentNullException("container");
}
if (String.IsNullOrEmpty(expr)) {
throw new ArgumentNullException("expr");
}
object prop = null;
bool intIndex = false;
int indexExprStart = expr.IndexOfAny(indexExprStartChars);
int indexExprEnd = expr.IndexOfAny(indexExprEndChars, indexExprStart + 1);
if ((indexExprStart < 0) || (indexExprEnd < 0) ||
(indexExprEnd == indexExprStart + 1)) {
throw new ArgumentException(SR.GetString(SR.DataBinder_Invalid_Indexed_Expr, expr));
}
string propName = null;
object indexValue = null;
string index = expr.Substring(indexExprStart + 1, indexExprEnd - indexExprStart - 1).Trim();
if (indexExprStart != 0)
propName = expr.Substring(0, indexExprStart);
if (index.Length != 0) {
if (((index[0] == '"') && (index[index.Length - 1] == '"')) ||
((index[0] == '\'') && (index[index.Length - 1] == '\''))) {
indexValue = index.Substring(1, index.Length - 2);
}
else {
if (Char.IsDigit(index[0])) {
// treat it as a number
int parsedIndex;
intIndex = Int32.TryParse(index, NumberStyles.Integer, CultureInfo.InvariantCulture, out parsedIndex);
if (intIndex) {
indexValue = parsedIndex;
}
else {
indexValue = index;
}
}
else {
// treat as a string
indexValue = index;
}
}
}
if (indexValue == null) {
throw new ArgumentException(SR.GetString(SR.DataBinder_Invalid_Indexed_Expr, expr));
}
object collectionProp = null;
if ((propName != null) && (propName.Length != 0)) {
collectionProp = DataBinder.GetPropertyValue(container, propName);
}
else {
collectionProp = container;
}
if (collectionProp != null) {
Array arrayProp = collectionProp as Array;
if (arrayProp != null && intIndex) {
prop = arrayProp.GetValue((int)indexValue);
}
else if ((collectionProp is IList) && intIndex) {
prop = ((IList)collectionProp)[(int)indexValue];
}
else {
PropertyInfo propInfo =
collectionProp.GetType().GetProperty("Item", BindingFlags.Public | BindingFlags.Instance, null, null, new Type[] { indexValue.GetType() }, null);
if (propInfo != null) {
prop = propInfo.GetValue(collectionProp, new object[] { indexValue});
}
else {
throw new ArgumentException(SR.GetString(SR.DataBinder_No_Indexed_Accessor, collectionProp.GetType().FullName));
}
}
}
return prop;
}
///
///
public static string GetIndexedPropertyValue(object container, string propName, string format) {
object value = DataBinder.GetIndexedPropertyValue(container, propName);
if ((value == null) || (value == System.DBNull.Value)) {
return String.Empty;
}
else {
if (String.IsNullOrEmpty(format)) {
return value.ToString();
}
else {
return string.Format(format, value);
}
}
}
///
///
public static object GetDataItem(object container) {
bool foundDataItem;
return DataBinder.GetDataItem(container, out foundDataItem);
}
///
///
public static object GetDataItem(object container, out bool foundDataItem) {
//
if (container == null) {
foundDataItem = false;
return null;
}
// If object implements IDataItemContainer, get value directly from interface
IDataItemContainer dataItemContainer = container as IDataItemContainer;
if (dataItemContainer != null) {
foundDataItem = true;
return dataItemContainer.DataItem;
}
// Otherwise, look for a property named "DataItem"
string dataItemPropertyName = "DataItem";
// Check whether the property exists
PropertyInfo propInfo = container.GetType().GetProperty(dataItemPropertyName,
BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
// If not, return null
//
if (propInfo == null) {
foundDataItem = false;
return null;
}
// If so, get the value
foundDataItem = true;
return propInfo.GetValue(container, null);
}
///
/// Returns true if the value is null, DBNull, or INullableValue.HasValue is false.
///
internal static bool IsNull(object value) {
if (value == null || Convert.IsDBNull(value)) {
return true;
}
return false;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Web.UI {
using System;
using System.Globalization;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Data;
using System.Reflection;
using System.Security.Permissions;
using System.Web.Util;
///
/// Provides design-time support for RAD designers to
/// generate and parse
///
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
public sealed class DataBinder {
private static readonly char[] expressionPartSeparator = new char[] { '.'};
private static readonly char[] indexExprStartChars = new char[] { '[', '('};
private static readonly char[] indexExprEndChars = new char[] { ']', ')'};
///
/// Evaluates data binding expressions at runtime. While
/// this method is automatically called when you create data bindings in a RAD
/// designer, you can also use it declaratively if you want to simplify the casting
/// to a text string to be displayed on a browser. To do so, you must place the
/// <%# and %> tags, which are also used in standard ASP.NET data binding, around the data binding expression.
/// This method is particularly useful when data binding against controls that
/// are in a templated list.
///
/// Since this method is called at runtime, it can cause performance
/// to noticeably slow compared to standard ASP.NET databinding syntax.
/// Use this method judiciously.
///
///
public static object Eval(object container, string expression) {
if (expression == null) {
throw new ArgumentNullException("expression");
}
expression = expression.Trim();
if (expression.Length == 0) {
throw new ArgumentNullException("expression");
}
if (container == null) {
return null;
}
string[] expressionParts = expression.Split(expressionPartSeparator);
return DataBinder.Eval(container, expressionParts);
}
///
///
private static object Eval(object container, string[] expressionParts) {
Debug.Assert((expressionParts != null) && (expressionParts.Length != 0),
"invalid expressionParts parameter");
object prop;
int i;
for (prop = container, i = 0; (i < expressionParts.Length) && (prop != null); i++) {
string expr = expressionParts[i];
bool indexedExpr = expr.IndexOfAny(indexExprStartChars) >= 0;
if (indexedExpr == false) {
prop = DataBinder.GetPropertyValue(prop, expr);
}
else {
prop = DataBinder.GetIndexedPropertyValue(prop, expr);
}
}
return prop;
}
///
/// Evaluates data binding expressions at runtime and
/// formats the output as text to be displayed in the requesting browser. While this
/// method is automatically called when you create data bindings in a RAD designer,
/// you can also use it declaratively if you want to simplify the casting to a text
/// string to be displayed on a browser. To do so, you must place the <%# and %> tags, which are also used in standard ASP.NET data binding, around
/// the data binding expression.
/// This method is particularly useful when data binding against controls that
/// are in a templated list.
///
/// Since this method is called at
/// runtime, it can cause performance to noticeably slow compared to standard ASP.NET
/// databinding syntax. Use this method judiciously, particularly when string
/// formatting is not required.
///
///
public static string Eval(object container, string expression, string format) {
object value = DataBinder.Eval(container, expression);
if ((value == null) || (value == System.DBNull.Value)) {
return String.Empty;
}
else {
if (String.IsNullOrEmpty(format)) {
return value.ToString();
}
else {
return String.Format(format, value);
}
}
}
///
///
public static object GetPropertyValue(object container, string propName) {
if (container == null) {
throw new ArgumentNullException("container");
}
if (String.IsNullOrEmpty(propName)) {
throw new ArgumentNullException("propName");
}
object prop = null;
// get a PropertyDescriptor using case-insensitive lookup
PropertyDescriptor pd = TypeDescriptor.GetProperties(container).Find(propName, true);
if (pd != null) {
prop = pd.GetValue(container);
}
else {
throw new HttpException(SR.GetString(SR.DataBinder_Prop_Not_Found, container.GetType().FullName, propName));
}
return prop;
}
///
///
public static string GetPropertyValue(object container, string propName, string format) {
object value = DataBinder.GetPropertyValue(container, propName);
if ((value == null) || (value == System.DBNull.Value)) {
return string.Empty;
}
else {
if (String.IsNullOrEmpty(format)) {
return value.ToString();
}
else {
return string.Format(format, value);
}
}
}
///
///
public static object GetIndexedPropertyValue(object container, string expr) {
if (container == null) {
throw new ArgumentNullException("container");
}
if (String.IsNullOrEmpty(expr)) {
throw new ArgumentNullException("expr");
}
object prop = null;
bool intIndex = false;
int indexExprStart = expr.IndexOfAny(indexExprStartChars);
int indexExprEnd = expr.IndexOfAny(indexExprEndChars, indexExprStart + 1);
if ((indexExprStart < 0) || (indexExprEnd < 0) ||
(indexExprEnd == indexExprStart + 1)) {
throw new ArgumentException(SR.GetString(SR.DataBinder_Invalid_Indexed_Expr, expr));
}
string propName = null;
object indexValue = null;
string index = expr.Substring(indexExprStart + 1, indexExprEnd - indexExprStart - 1).Trim();
if (indexExprStart != 0)
propName = expr.Substring(0, indexExprStart);
if (index.Length != 0) {
if (((index[0] == '"') && (index[index.Length - 1] == '"')) ||
((index[0] == '\'') && (index[index.Length - 1] == '\''))) {
indexValue = index.Substring(1, index.Length - 2);
}
else {
if (Char.IsDigit(index[0])) {
// treat it as a number
int parsedIndex;
intIndex = Int32.TryParse(index, NumberStyles.Integer, CultureInfo.InvariantCulture, out parsedIndex);
if (intIndex) {
indexValue = parsedIndex;
}
else {
indexValue = index;
}
}
else {
// treat as a string
indexValue = index;
}
}
}
if (indexValue == null) {
throw new ArgumentException(SR.GetString(SR.DataBinder_Invalid_Indexed_Expr, expr));
}
object collectionProp = null;
if ((propName != null) && (propName.Length != 0)) {
collectionProp = DataBinder.GetPropertyValue(container, propName);
}
else {
collectionProp = container;
}
if (collectionProp != null) {
Array arrayProp = collectionProp as Array;
if (arrayProp != null && intIndex) {
prop = arrayProp.GetValue((int)indexValue);
}
else if ((collectionProp is IList) && intIndex) {
prop = ((IList)collectionProp)[(int)indexValue];
}
else {
PropertyInfo propInfo =
collectionProp.GetType().GetProperty("Item", BindingFlags.Public | BindingFlags.Instance, null, null, new Type[] { indexValue.GetType() }, null);
if (propInfo != null) {
prop = propInfo.GetValue(collectionProp, new object[] { indexValue});
}
else {
throw new ArgumentException(SR.GetString(SR.DataBinder_No_Indexed_Accessor, collectionProp.GetType().FullName));
}
}
}
return prop;
}
///
///
public static string GetIndexedPropertyValue(object container, string propName, string format) {
object value = DataBinder.GetIndexedPropertyValue(container, propName);
if ((value == null) || (value == System.DBNull.Value)) {
return String.Empty;
}
else {
if (String.IsNullOrEmpty(format)) {
return value.ToString();
}
else {
return string.Format(format, value);
}
}
}
///
///
public static object GetDataItem(object container) {
bool foundDataItem;
return DataBinder.GetDataItem(container, out foundDataItem);
}
///
///
public static object GetDataItem(object container, out bool foundDataItem) {
//
if (container == null) {
foundDataItem = false;
return null;
}
// If object implements IDataItemContainer, get value directly from interface
IDataItemContainer dataItemContainer = container as IDataItemContainer;
if (dataItemContainer != null) {
foundDataItem = true;
return dataItemContainer.DataItem;
}
// Otherwise, look for a property named "DataItem"
string dataItemPropertyName = "DataItem";
// Check whether the property exists
PropertyInfo propInfo = container.GetType().GetProperty(dataItemPropertyName,
BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
// If not, return null
//
if (propInfo == null) {
foundDataItem = false;
return null;
}
// If so, get the value
foundDataItem = true;
return propInfo.GetValue(container, null);
}
///
/// Returns true if the value is null, DBNull, or INullableValue.HasValue is false.
///
internal static bool IsNull(object value) {
if (value == null || Convert.IsDBNull(value)) {
return true;
}
return false;
}
}
}
// 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
- WmlObjectListAdapter.cs
- AbandonedMutexException.cs
- HttpException.cs
- NameTable.cs
- FixedPageAutomationPeer.cs
- ItemCollectionEditor.cs
- DoubleKeyFrameCollection.cs
- InstallerTypeAttribute.cs
- FixedSOMFixedBlock.cs
- LoadedOrUnloadedOperation.cs
- StatusBarItemAutomationPeer.cs
- DataKeyPropertyAttribute.cs
- XmlCustomFormatter.cs
- IdentitySection.cs
- XmlTextAttribute.cs
- OutgoingWebRequestContext.cs
- DataTemplateKey.cs
- BaseCodePageEncoding.cs
- RootAction.cs
- EventSetter.cs
- SqlDataSourceQueryEditorForm.cs
- WebPartDeleteVerb.cs
- RelatedPropertyManager.cs
- SessionStateContainer.cs
- StreamingContext.cs
- IPPacketInformation.cs
- FormsAuthenticationConfiguration.cs
- DeferredSelectedIndexReference.cs
- TreeViewDesigner.cs
- DirectoryLocalQuery.cs
- ItemsPresenter.cs
- MatrixConverter.cs
- WMIGenerator.cs
- XmlSchemaSimpleTypeUnion.cs
- Repeater.cs
- ZoneButton.cs
- Int32CollectionValueSerializer.cs
- MergeFilterQuery.cs
- OdbcFactory.cs
- CodeAttributeArgument.cs
- VirtualDirectoryMappingCollection.cs
- DataSourceHelper.cs
- CompilationUnit.cs
- SafeHandle.cs
- Evidence.cs
- RepeaterItem.cs
- NotificationContext.cs
- QilGeneratorEnv.cs
- InternalControlCollection.cs
- Clause.cs
- SmiEventStream.cs
- AnnotationHelper.cs
- NamedObject.cs
- CuspData.cs
- PageCatalogPart.cs
- CodeSnippetTypeMember.cs
- Currency.cs
- QuotedPairReader.cs
- CodeParameterDeclarationExpression.cs
- ExpressionBuilderCollection.cs
- ButtonBase.cs
- FilteredXmlReader.cs
- Common.cs
- HttpRuntime.cs
- StyleModeStack.cs
- UnsafeNativeMethods.cs
- HttpStreamMessage.cs
- RuleRef.cs
- ContextInformation.cs
- XsltSettings.cs
- HwndHostAutomationPeer.cs
- LayoutEditorPart.cs
- HttpPostedFile.cs
- EnumUnknown.cs
- HttpProcessUtility.cs
- ErrorProvider.cs
- NativeCppClassAttribute.cs
- VersionedStreamOwner.cs
- WindowsGrip.cs
- DetailsViewCommandEventArgs.cs
- ToolStripRendererSwitcher.cs
- RoutedEventValueSerializer.cs
- EntityEntry.cs
- RequestTimeoutManager.cs
- LocalizedNameDescriptionPair.cs
- ClaimSet.cs
- DigestTraceRecordHelper.cs
- Rotation3D.cs
- FilteredDataSetHelper.cs
- ItemCheckEvent.cs
- WebServicesInteroperability.cs
- initElementDictionary.cs
- Menu.cs
- IntersectQueryOperator.cs
- DefaultPrintController.cs
- Missing.cs
- DataControlPagerLinkButton.cs
- HelpExampleGenerator.cs
- SingleAnimationBase.cs
- QuaternionAnimation.cs