Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Extensions / UI / WebControls / QueryableDataSourceView.cs / 1305376 / QueryableDataSourceView.cs
#if ORYX_VNEXT
namespace Microsoft.Web.Data.UI.WebControls {
using Microsoft.Web.Data.UI.WebControls.Expressions;
#else
namespace System.Web.UI.WebControls {
using System.Web.UI.WebControls.Expressions;
#endif
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Globalization;
using System.Linq;
using System.Security.Permissions;
using System.Web;
using System.Web.Resources;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Diagnostics.CodeAnalysis;
using System.ComponentModel;
public abstract class QueryableDataSourceView : DataSourceView, IStateManager {
//basic query parameters for any Queryable source
private ParameterCollection _whereParameters;
private ParameterCollection _orderByParameters;
private ParameterCollection _orderGroupsByParameters;
private ParameterCollection _selectNewParameters;
private ParameterCollection _groupByParameters;
// CUD operations
private ParameterCollection _deleteParameters;
private ParameterCollection _updateParameters;
private ParameterCollection _insertParameters;
private HttpContext _context;
private DataSourceControl _owner;
private IDynamicQueryable _queryable;
private string _groupBy;
private string _orderBy;
private string _orderGroupsBy;
private string _selectNew;
private string _where;
private bool _autoGenerateOrderByClause;
private bool _autoGenerateWhereClause;
private bool _autoPage = true;
private bool _autoSort = true;
private bool _isTracking;
protected static readonly object EventSelected = new object();
protected static readonly object EventSelecting = new object();
private static readonly object EventQueryCreated = new object();
// using Hashtable for original values so that ObjectStateFormatter will serialize it properly in ViewState.
private Hashtable _originalValues;
protected QueryableDataSourceView(DataSourceControl owner, string viewName, HttpContext context)
: this(owner, viewName, context, new DynamicQueryableWrapper()) {
_context = context;
_owner = owner;
}
internal QueryableDataSourceView(DataSourceControl owner, string viewName, HttpContext context, IDynamicQueryable queryable)
: base(owner, viewName) {
_context = context;
_queryable = queryable;
_owner = owner;
}
public bool AutoGenerateOrderByClause {
get {
return _autoGenerateOrderByClause;
}
set {
if (_autoGenerateOrderByClause != value) {
_autoGenerateOrderByClause = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public bool AutoGenerateWhereClause {
get {
return _autoGenerateWhereClause;
}
set {
if (_autoGenerateWhereClause != value) {
_autoGenerateWhereClause = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public virtual bool AutoPage {
get {
return _autoPage;
}
set {
if (_autoPage != value) {
_autoPage = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public virtual bool AutoSort {
get {
return _autoSort;
}
set {
if (_autoSort != value) {
_autoSort = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public override bool CanDelete {
get {
return false;
}
}
public override bool CanInsert {
get {
return false;
}
}
// When AutoPage is false the user should manually page in the Selecting event.
public override bool CanPage {
get {
return true;
}
}
// When AutoPage is false the user must set the total row count in the Selecting event.
public override bool CanRetrieveTotalRowCount {
get {
return true;
}
}
// When AutoSort is false the user should manually sort in the Selecting event.
public override bool CanSort {
get {
return true;
}
}
public override bool CanUpdate {
get {
return false;
}
}
public virtual ParameterCollection DeleteParameters {
get {
if (_deleteParameters == null) {
_deleteParameters = new ParameterCollection();
}
return _deleteParameters;
}
}
protected abstract Type EntityType {
get;
}
public virtual ParameterCollection GroupByParameters {
get {
if (_groupByParameters == null) {
_groupByParameters = new ParameterCollection();
_groupByParameters.ParametersChanged += new EventHandler(OnQueryParametersChanged);
if (_isTracking) {
DataSourceHelper.TrackViewState(_groupByParameters);
}
}
return _groupByParameters;
}
}
protected bool IsTrackingViewState {
get {
return _isTracking;
}
}
public virtual ParameterCollection InsertParameters {
get {
if (_insertParameters == null) {
_insertParameters = new ParameterCollection();
}
return _insertParameters;
}
}
public virtual ParameterCollection OrderByParameters {
get {
if (_orderByParameters == null) {
_orderByParameters = new ParameterCollection();
_orderByParameters.ParametersChanged += new EventHandler(OnQueryParametersChanged);
if (_isTracking) {
DataSourceHelper.TrackViewState(_orderByParameters);
}
}
return _orderByParameters;
}
}
public virtual ParameterCollection OrderGroupsByParameters {
get {
if (_orderGroupsByParameters == null) {
_orderGroupsByParameters = new ParameterCollection();
_orderGroupsByParameters.ParametersChanged += new EventHandler(OnQueryParametersChanged);
if (_isTracking) {
DataSourceHelper.TrackViewState(_orderGroupsByParameters);
}
}
return _orderGroupsByParameters;
}
}
public virtual string OrderBy {
get {
return _orderBy ?? String.Empty;
}
set {
if (_orderBy != value) {
_orderBy = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public virtual string OrderGroupsBy {
get {
return _orderGroupsBy ?? String.Empty;
}
set {
if (_orderGroupsBy != value) {
_orderGroupsBy = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public virtual string GroupBy {
get {
return _groupBy ?? String.Empty;
}
set {
if (_groupBy != value) {
_groupBy = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public virtual ParameterCollection SelectNewParameters {
get {
if (_selectNewParameters == null) {
_selectNewParameters = new ParameterCollection();
_selectNewParameters.ParametersChanged += new EventHandler(OnQueryParametersChanged);
if (_isTracking) {
DataSourceHelper.TrackViewState(_selectNewParameters);
}
}
return _selectNewParameters;
}
}
[SuppressMessage("Microsoft.Naming", "CA1711:IdentifiersShouldNotHaveIncorrectSuffix",
Justification = "SelectNew refers to a projection and 'New' is not used as a suffix in this case")]
public virtual string SelectNew {
get {
return _selectNew ?? String.Empty;
}
set {
if (_selectNew != value) {
_selectNew = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public virtual ParameterCollection WhereParameters {
get {
if (_whereParameters == null) {
_whereParameters = new ParameterCollection();
_whereParameters.ParametersChanged += new EventHandler(OnQueryParametersChanged);
if (_isTracking) {
DataSourceHelper.TrackViewState(_whereParameters);
}
}
return _whereParameters;
}
}
public virtual string Where {
get {
return _where ?? String.Empty;
}
set {
if (_where != value) {
_where = value;
OnDataSourceViewChanged(EventArgs.Empty);
}
}
}
public virtual ParameterCollection UpdateParameters {
get {
if (_updateParameters == null) {
_updateParameters = new ParameterCollection();
}
return _updateParameters;
}
}
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", Justification = "Derived classes will use this to as the ParametersChanged EventHandler")]
protected void OnQueryParametersChanged(object sender, EventArgs e) {
RaiseViewChanged();
}
[SuppressMessage("Microsoft.Design", "CA1030:UseEventsWhereAppropriate", Justification = "An event exists already and it it protected")]
public void RaiseViewChanged() {
OnDataSourceViewChanged(EventArgs.Empty);
}
///
/// Gets the result to apply query
///
/// whereParameters = WhereParameters.ToDictionary(_context, _owner);
IOrderedDictionary orderByParameters = OrderByParameters.GetValues(_context, _owner).ToCaseInsensitiveDictionary();
IDictionary orderGroupsByParameters = OrderGroupsByParameters.ToDictionary(_context, _owner);
IDictionary selectNewParameters = SelectNewParameters.ToDictionary(_context, _owner);
IDictionary groupByParameters = GroupByParameters.ToDictionary(_context, _owner);
return new QueryContext(
whereParameters,
orderGroupsByParameters,
orderByParameters,
groupByParameters,
selectNewParameters,
arguments);
}
///
/// Creates a select expression based on parameters and properties
///
protected virtual IQueryable BuildQuery(DataSourceSelectArguments arguments) {
if (arguments == null) {
throw new ArgumentNullException("arguments");
}
// Create the query context
QueryContext context = CreateQueryContext(arguments);
// Clear out old values before selecting new data
_originalValues = null;
// Get the source of the query(root IQueryable)
object result = GetSource(context);
if (result != null) {
IQueryable source = QueryableDataSourceHelper.AsQueryable(result);
// Apply additional filterting
return ExecuteQuery(source, context);
}
return null;
}
protected virtual IQueryable ExecuteQuery(IQueryable source, QueryContext context) {
// Execute Query
source = ExecuteQueryExpressions(source, context);
// Execute Sorting
source = ExecuteSorting(source, context);
// Execute Paging
source = ExecutePaging(source, context);
return source;
}
protected IQueryable ExecuteQueryExpressions(IQueryable source, QueryContext context) {
if (source != null) {
QueryCreatedEventArgs queryArgs = new QueryCreatedEventArgs(source);
OnQueryCreated(queryArgs);
source = queryArgs.Query ?? source;
// Support the Dynamic Expression language used by LinqDataSource
if (AutoGenerateWhereClause) {
if (!String.IsNullOrEmpty(Where)) {
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
AtlasWeb.LinqDataSourceView_WhereAlreadySpecified, _owner.ID));
}
source = QueryableDataSourceHelper.CreateWhereExpression(context.WhereParameters, source, _queryable);
}
else if (!String.IsNullOrEmpty(Where)) {
source = _queryable.Where(source, Where, context.WhereParameters.ToEscapedParameterKeys(_owner));
}
if (AutoGenerateOrderByClause) {
if (!String.IsNullOrEmpty(OrderBy)) {
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
AtlasWeb.LinqDataSourceView_OrderByAlreadySpecified, _owner.ID));
}
source = QueryableDataSourceHelper.CreateOrderByExpression(context.OrderByParameters, source, _queryable);
}
else if (!String.IsNullOrEmpty(OrderBy)) {
source = _queryable.OrderBy(source, OrderBy, context.OrderByParameters.ToEscapedParameterKeys(_owner));
}
string groupBy = GroupBy;
if (String.IsNullOrEmpty(groupBy)) {
if (!String.IsNullOrEmpty(OrderGroupsBy)) {
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
AtlasWeb.LinqDataSourceView_OrderGroupsByRequiresGroupBy, _owner.ID));
}
}
else {
source = _queryable.GroupBy(source, groupBy, "it", context.GroupByParameters.ToEscapedParameterKeys(_owner));
if (!String.IsNullOrEmpty(OrderGroupsBy)) {
source = _queryable.OrderBy(source, OrderGroupsBy, context.OrderGroupsByParameters.ToEscapedParameterKeys(_owner));
}
}
if (!String.IsNullOrEmpty(SelectNew)) {
source = _queryable.Select(source, SelectNew, context.SelectParameters.ToEscapedParameterKeys(_owner));
}
return source;
}
return source;
}
protected IQueryable ExecuteSorting(IQueryable source, QueryContext context) {
string sortExpression = context.Arguments.SortExpression;
if (CanSort && AutoSort && !String.IsNullOrEmpty(sortExpression)) {
source = _queryable.OrderBy(source, sortExpression);
}
return source;
}
protected IQueryable ExecutePaging(IQueryable source, QueryContext context) {
if (CanPage && AutoPage) {
if (CanRetrieveTotalRowCount && context.Arguments.RetrieveTotalRowCount) {
context.Arguments.TotalRowCount = _queryable.Count(source);
}
if ((context.Arguments.MaximumRows > 0) && (context.Arguments.StartRowIndex >= 0)) {
source = _queryable.Skip(source, context.Arguments.StartRowIndex);
source = _queryable.Take(source, context.Arguments.MaximumRows);
}
}
else if (context.Arguments.RetrieveTotalRowCount && (context.Arguments.TotalRowCount == -1)) {
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
AtlasWeb.LinqDataSourceView_PagingNotHandled, _owner.ID));
}
return source;
}
protected virtual void LoadViewState(object savedState) {
if (savedState != null) {
object[] myState = (object[])savedState;
if (myState[0] != null) {
((IStateManager)WhereParameters).LoadViewState(myState[0]);
}
if (myState[1] != null) {
((IStateManager)OrderByParameters).LoadViewState(myState[1]);
}
if (myState[2] != null) {
((IStateManager)GroupByParameters).LoadViewState(myState[2]);
}
if (myState[3] != null) {
((IStateManager)OrderGroupsByParameters).LoadViewState(myState[3]);
}
if (myState[4] != null) {
((IStateManager)SelectNewParameters).LoadViewState(myState[4]);
}
if (myState[5] != null) {
_originalValues = (Hashtable)myState[5];
}
}
}
protected virtual object SaveViewState() {
object[] myState = new object[6];
myState[0] = DataSourceHelper.SaveViewState(_whereParameters);
myState[1] = DataSourceHelper.SaveViewState(_orderByParameters);
myState[2] = DataSourceHelper.SaveViewState(_groupByParameters);
myState[3] = DataSourceHelper.SaveViewState(_orderGroupsByParameters);
myState[4] = DataSourceHelper.SaveViewState(_selectNewParameters);
if ((_originalValues != null) && (_originalValues.Count > 0)) {
myState[5] = _originalValues;
}
return myState;
}
protected virtual void TrackViewState() {
_isTracking = true;
DataSourceHelper.TrackViewState(_whereParameters);
DataSourceHelper.TrackViewState(_orderByParameters);
DataSourceHelper.TrackViewState(_groupByParameters);
DataSourceHelper.TrackViewState(_orderGroupsByParameters);
DataSourceHelper.TrackViewState(_selectNewParameters);
}
#if ORYX_VNEXT
protected override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments) {
#else
protected internal override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments) {
#endif
ClearOriginalValues();
IQueryable source = BuildQuery(arguments);
IList results = source.ToList(source.ElementType);
// Store original values for concurrency
StoreOriginalValues(results);
return results;
}
protected void ClearOriginalValues() {
_originalValues = null;
}
protected virtual IDictionary GetOriginalValues(IDictionary keys) {
// Table data is stored in a hashtable with column names for keys and an ArrayList of row data for values.
// i.e, Hashtable { ID = ArrayList { 0, 1, 2 }, Name = ArrayList { "A", "B", "C" } }
if (_originalValues != null) {
// matches list keeps track of row indexes which match.
List matches = new List();
foreach (DictionaryEntry entry in keys) {
string propertyName = (String)entry.Key;
if (_originalValues.ContainsKey(propertyName)) {
object propertyValue = entry.Value;
// get the row values for the current column.
ArrayList values = (ArrayList)_originalValues[propertyName];
for (int i = 0; i < values.Count; i++) {
if (matches.Count <= i) { // first column
matches.Add(OriginalValueMatches(values[i], propertyValue));
}
else if (matches[i] == true) { // subsequent columns
matches[i] = OriginalValueMatches(values[i], propertyValue);
}
}
}
}
int rowIndex = matches.IndexOf(true);
// no rows match or too many rows match.
if ((rowIndex < 0) || (matches.IndexOf(true, rowIndex + 1) >= 0)) {
throw new InvalidOperationException(AtlasWeb.LinqDataSourceView_OriginalValuesNotFound);
}
// get original values for the matching row.
Dictionary rowValues = new Dictionary(_originalValues.Count,
StringComparer.OrdinalIgnoreCase);
foreach (DictionaryEntry entry in _originalValues) {
ArrayList value = (ArrayList)entry.Value;
rowValues.Add((string)entry.Key, value[rowIndex]);
}
return rowValues;
}
return null;
}
protected virtual void StoreOriginalValues(IList results) {
// Derived classes can override this function and call the overload
// to determine which columns it should store for optimistic concurrency
}
protected void StoreOriginalValues(IList results, Func include) {
PropertyDescriptorCollection props = TypeDescriptor.GetProperties(EntityType);
int numRows = results.Count;
int maxColumns = props.Count;
_originalValues = new Hashtable(maxColumns, StringComparer.OrdinalIgnoreCase);
foreach (PropertyDescriptor p in props) {
if (include(p) && p.PropertyType.IsSerializable) {
ArrayList values = new ArrayList(numRows);
_originalValues[p.Name] = values;
foreach (object currentRow in results) {
values.Add(p.GetValue(currentRow));
}
}
}
}
public int Update(IDictionary keys, IDictionary values, IDictionary oldValues) {
return ExecuteUpdate(keys, values, oldValues);
}
public int Delete(IDictionary keys, IDictionary oldValues) {
return ExecuteDelete(keys, oldValues);
}
public int Insert(IDictionary values) {
return ExecuteInsert(values);
}
protected QueryableDataSourceEditData BuildDeleteObject(IDictionary keys, IDictionary oldValues, IDictionary validationErrors) {
QueryableDataSourceEditData editData = new QueryableDataSourceEditData();
Type dataObjectType = EntityType;
IDictionary caseInsensitiveOldValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
IDictionary originalValues = GetOriginalValues(keys);
ParameterCollection deleteParameters = DeleteParameters;
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
deleteParameters,
keys,
caseInsensitiveOldValues,
validationErrors)) {
return editData;
}
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
deleteParameters,
oldValues,
caseInsensitiveOldValues,
validationErrors)) {
return editData;
}
if (originalValues != null) {
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
deleteParameters,
originalValues,
caseInsensitiveOldValues,
validationErrors)) {
return editData;
}
}
editData.OriginalDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveOldValues, validationErrors);
return editData;
}
protected QueryableDataSourceEditData BuildInsertObject(IDictionary values, IDictionary validationErrors) {
QueryableDataSourceEditData editData = new QueryableDataSourceEditData();
Type dataObjectType = EntityType;
IDictionary caseInsensitiveNewValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
InsertParameters,
InsertParameters.GetValues(_context, _owner),
caseInsensitiveNewValues,
validationErrors)) {
return editData;
}
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
InsertParameters,
values,
caseInsensitiveNewValues, validationErrors)) {
return editData;
}
editData.NewDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveNewValues, validationErrors);
return editData;
}
protected QueryableDataSourceEditData BuildUpdateObjects(IDictionary keys, IDictionary values, IDictionary oldValues, IDictionary validationErrors) {
QueryableDataSourceEditData editData = new QueryableDataSourceEditData();
Type dataObjectType = EntityType;
IDictionary caseInsensitiveNewValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
IDictionary caseInsensitiveOldValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
IDictionary originalValues = GetOriginalValues(keys);
// We start out with the old values, just to pre-populate the list with items
// that might not have corresponding new values. For example if a GridView has
// a read-only field, there will be an old value, but no new value. The data object
// still has to have *some* value for a given field, so we just use the old value.
ParameterCollection updateParameters = UpdateParameters;
// If we have validation errors bail out while merging bailout
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
updateParameters,
oldValues,
caseInsensitiveOldValues,
caseInsensitiveNewValues,
validationErrors)) {
return editData;
}
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
updateParameters,
keys,
caseInsensitiveOldValues,
caseInsensitiveNewValues,
validationErrors)) {
return editData;
}
if (originalValues != null) {
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
updateParameters,
originalValues,
caseInsensitiveOldValues,
caseInsensitiveNewValues,
validationErrors)) {
return editData;
}
}
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
updateParameters,
values,
caseInsensitiveNewValues,
validationErrors)) {
return editData;
}
editData.NewDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveNewValues, validationErrors);
if (editData.NewDataObject != null) {
editData.OriginalDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveOldValues, validationErrors);
}
return editData;
}
protected virtual int DeleteObject(object oldEntity) {
return 0;
}
protected virtual int UpdateObject(object oldEntity, object newEntity) {
return 0;
}
protected virtual int InsertObject(object newEntity) {
return 0;
}
protected abstract void HandleValidationErrors(IDictionary errors, DataSourceOperation operation);
protected override int ExecuteDelete(IDictionary keys, IDictionary oldValues) {
IDictionary errors = new Dictionary(StringComparer.OrdinalIgnoreCase);
QueryableDataSourceEditData editData = BuildDeleteObject(keys, oldValues, errors);
if (errors.Any()) {
HandleValidationErrors(errors, DataSourceOperation.Delete);
}
else {
return DeleteObject(editData.OriginalDataObject);
}
return -1;
}
protected override int ExecuteInsert(IDictionary values) {
IDictionary errors = new Dictionary(StringComparer.OrdinalIgnoreCase);
QueryableDataSourceEditData editData = BuildInsertObject(values, errors);
if (errors.Any()) {
HandleValidationErrors(errors, DataSourceOperation.Insert);
}
else {
return InsertObject(editData.NewDataObject);
}
return -1;
}
protected override int ExecuteUpdate(IDictionary keys, IDictionary values, IDictionary oldValues) {
IDictionary errors = new Dictionary(StringComparer.OrdinalIgnoreCase);
QueryableDataSourceEditData editData = BuildUpdateObjects(keys, values, oldValues, errors);
if (errors.Any()) {
HandleValidationErrors(errors, DataSourceOperation.Update);
}
else {
return UpdateObject(editData.OriginalDataObject, editData.NewDataObject);
}
return -1;
}
public event EventHandler QueryCreated {
add {
Events.AddHandler(EventQueryCreated, value);
}
remove {
Events.RemoveHandler(EventQueryCreated, value);
}
}
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
protected virtual void OnQueryCreated(QueryCreatedEventArgs e) {
EventHandler handler = (EventHandler)Events[EventQueryCreated];
if (handler != null) {
handler(this, e);
}
}
private bool OriginalValueMatches(object originalValue, object value) {
// NOTE: Comparing IEnumerable contents instead of instances to ensure that
// timestamp columns (of type byte[]) can be matched appropriately.
IEnumerable originalValueEnumerable = originalValue as IEnumerable;
IEnumerable valueEnumerable = value as IEnumerable;
if ((originalValueEnumerable != null) && (valueEnumerable != null)) {
return QueryableDataSourceHelper.EnumerableContentEquals(originalValueEnumerable, valueEnumerable);
}
return originalValue.Equals(value);
}
#region IStateManager Members
bool IStateManager.IsTrackingViewState {
get { return IsTrackingViewState; }
}
void IStateManager.LoadViewState(object state) {
LoadViewState(state);
}
object IStateManager.SaveViewState() {
return SaveViewState();
}
void IStateManager.TrackViewState() {
TrackViewState();
}
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- Int32AnimationUsingKeyFrames.cs
- FormViewAutoFormat.cs
- RequestUriProcessor.cs
- OrderablePartitioner.cs
- COM2FontConverter.cs
- __Filters.cs
- BindingMAnagerBase.cs
- _TransmitFileOverlappedAsyncResult.cs
- HttpResponseBase.cs
- WsatRegistrationHeader.cs
- BaseTreeIterator.cs
- WebPartEditorCancelVerb.cs
- SafeRightsManagementPubHandle.cs
- CustomAttributeBuilder.cs
- UserControl.cs
- IfAction.cs
- SelectorAutomationPeer.cs
- ToolStripManager.cs
- HtmlTable.cs
- AdvancedBindingEditor.cs
- SafeNativeMethods.cs
- OletxTransactionFormatter.cs
- GlyphElement.cs
- DropDownList.cs
- RadialGradientBrush.cs
- BooleanAnimationUsingKeyFrames.cs
- XsltSettings.cs
- WebPartAddingEventArgs.cs
- ErrorLog.cs
- COM2PictureConverter.cs
- PersistenceTypeAttribute.cs
- SessionSwitchEventArgs.cs
- AsymmetricSignatureFormatter.cs
- ButtonField.cs
- BaseParser.cs
- RegexInterpreter.cs
- SubstitutionDesigner.cs
- HtmlInputReset.cs
- NamedElement.cs
- GZipDecoder.cs
- CheckBoxPopupAdapter.cs
- InputReferenceExpression.cs
- HttpApplicationStateWrapper.cs
- XmlnsPrefixAttribute.cs
- EncoderParameters.cs
- ExpressionBinding.cs
- CodeTypeMemberCollection.cs
- QilBinary.cs
- XmlSchemaAttribute.cs
- Parameter.cs
- dbdatarecord.cs
- TreeViewHitTestInfo.cs
- UrlMapping.cs
- Repeater.cs
- DictionaryItemsCollection.cs
- CfgArc.cs
- ScriptManager.cs
- ListViewTableCell.cs
- InternalBase.cs
- StorageInfo.cs
- unsafenativemethodsother.cs
- OrderedDictionary.cs
- Group.cs
- MetadataExchangeBindings.cs
- EntryIndex.cs
- ScrollChrome.cs
- Light.cs
- ItemDragEvent.cs
- XamlTreeBuilderBamlRecordWriter.cs
- DispatcherEventArgs.cs
- GeometryDrawing.cs
- StrokeCollectionConverter.cs
- ToolStripSeparator.cs
- GridViewSortEventArgs.cs
- ThrowHelper.cs
- UInt64Storage.cs
- elementinformation.cs
- ListViewHitTestInfo.cs
- WorkflowPageSetupDialog.cs
- PointConverter.cs
- LicenseContext.cs
- CSharpCodeProvider.cs
- Soap.cs
- SqlTrackingService.cs
- DataGridViewCellStyle.cs
- DataGridViewCheckBoxColumn.cs
- WebPartDisplayModeCollection.cs
- BinaryReader.cs
- DesignerVerb.cs
- BookmarkScope.cs
- HttpCookie.cs
- WCFBuildProvider.cs
- CSharpCodeProvider.cs
- SecurityNegotiationException.cs
- CreateUserWizardAutoFormat.cs
- ReflectPropertyDescriptor.cs
- ExpressionVisitorHelpers.cs
- COM2Enum.cs
- SettingsPropertyIsReadOnlyException.cs
- StateBag.cs