Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / NetFx40 / Tools / System.Activities.Core.Presentation / System / Activities / Presentation / DynamicArgumentDesigner.xaml.cs / 1586724 / DynamicArgumentDesigner.xaml.cs
//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------
namespace System.Activities.Presentation
{
using System.Activities.Presentation.Model;
using System.Activities.Presentation.View;
using System.Activities.Presentation.Hosting;
using System.Runtime;
using System.Collections;
using System.Collections.ObjectModel;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Linq;
using System.Globalization;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Input;
using System.Windows.Threading;
using System.Reflection;
internal sealed partial class DynamicArgumentDesigner : UserControl
{
public static readonly DependencyProperty ContextProperty =
DependencyProperty.Register("Context",
typeof(EditingContext),
typeof(DynamicArgumentDesigner));
public static readonly DependencyProperty OwnerActivityProperty =
DependencyProperty.Register("OwnerActivity",
typeof(ModelItem),
typeof(DynamicArgumentDesigner));
public static readonly DependencyProperty IsDirectionReadOnlyProperty =
DependencyProperty.Register("IsDirectionReadOnly",
typeof(bool),
typeof(DynamicArgumentDesigner),
new UIPropertyMetadata(true, OnIsDirectionReadOnlyChanged));
public static readonly DependencyProperty DynamicArgumentsProperty =
DependencyProperty.Register("DynamicArguments",
typeof(ObservableCollection),
typeof(DynamicArgumentDesigner),
new PropertyMetadata(new ObservableCollection()));
public static readonly DependencyProperty IsDictionaryProperty =
DependencyProperty.Register("IsDictionary",
typeof(bool?),
typeof(DynamicArgumentDesigner),
new PropertyMetadata(false));
public static readonly DependencyProperty UnderlyingArgumentTypeProperty =
DependencyProperty.Register("UnderlyingArgumentType",
typeof(Type),
typeof(DynamicArgumentDesigner),
new PropertyMetadata(typeof(Argument)));
public static readonly RoutedCommand CreateDynamicArgumentCommand = new RoutedCommand("CreateDynamicArgumentCommand", typeof(DynamicArgumentDesigner));
public static readonly RoutedCommand MoveUpArgumentCommand = new RoutedCommand("MoveUpArgumentCommand", typeof(DynamicArgumentDesigner));
public static readonly RoutedCommand MoveDownArgumentCommand = new RoutedCommand("MoveDownArgumentCommand", typeof(DynamicArgumentDesigner));
public const string DefaultArgumentPrefix = "Argument";
SubscribeContextCallback onReadOnlyStateChangedCallback;
static readonly Type InArgumentType = typeof(InArgument);
static readonly Type OutArgumentType = typeof(OutArgument);
static readonly Type InOutArgumentType = typeof(InOutArgument);
static readonly Type ArgumentType = typeof(Argument);
const int NameColumn = 0;
const int DirectionColumn = 1;
const int ArgumentTypeColumn = 2;
const int ExpressionColumn = 3;
bool isReadOnly;
bool hideDirection;
string argumentPrefix = DefaultArgumentPrefix;
string hintText;
DataGridHelper dgHelper;
ContextItemManager contextItemManager;
public DynamicArgumentDesigner()
{
InitializeComponent();
this.dgHelper = new DataGridHelper(this.WPF_DataGrid, this);
this.dgHelper.AddNewRowCommand = DynamicArgumentDesigner.CreateDynamicArgumentCommand;
this.HintText = null;
this.WPF_DataGrid.LoadingRow += this.DataGrid_Standard_LoadingRow;
this.WPF_DataGrid.SelectionChanged += this.OnDataGridSelectionChanged;
this.Loaded += (sender, e) =>
{
OnReadOnlyStateChanged(new ReadOnlyState());
this.ContextItemManager.Subscribe(this.OnReadOnlyStateChangedCallback);
this.OnDynamicArgumentsLoaded();
this.OnUnderlyingArgumentTypeChanged();
};
this.Unloaded += (sender, e) =>
{
this.ContextItemManager.Unsubscribe(this.OnReadOnlyStateChangedCallback);
};
DynamicArgumentWrapperObject.Editor = this;
}
ContextItemManager ContextItemManager
{
get
{
if (this.contextItemManager == null)
{
this.contextItemManager = this.OwnerActivity.GetEditingContext().Items;
}
return this.contextItemManager;
}
}
void OnReadOnlyStateChanged(ReadOnlyState state)
{
UpdateChildrenElementStatus();
}
void UpdateChildrenElementStatus()
{
this.isReadOnly = this.ContextItemManager.GetValue().IsReadOnly || this.DynamicArguments == null;
if (this.isReadOnly)
{
this.WPF_DataGrid.IsReadOnly = true;
this.Button_1.IsEnabled = false;
this.Button_2.IsEnabled = false;
}
}
void OnDataGridSelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (this.WPF_DataGrid.SelectedItems != null && this.WPF_DataGrid.SelectedItems.Count == 1 && !this.isReadOnly)
{
bool upHadFocus = Button_2.IsFocused;
bool downHadFocus = Button_1.IsFocused;
this.Button_2.IsEnabled = this.WPF_DataGrid.SelectedItem != null && this.WPF_DataGrid.SelectedIndex > 0;
this.Button_1.IsEnabled = this.WPF_DataGrid.SelectedItem != null && this.WPF_DataGrid.SelectedIndex < this.DynamicArguments.Count - 1;
if (!this.Button_1.IsEnabled && downHadFocus)
{
this.Button_2.Focus();
}
if (!this.Button_2.IsEnabled && upHadFocus)
{
this.Button_1.Focus();
}
}
else
{
this.Button_2.IsEnabled = this.Button_1.IsEnabled = false;
}
}
// The DataGrid does not bubble up KeyDown event and we expect the upper window to be closed when ESC key is down.
// Thus we added an event handler in DataGrid to handle ESC key and closes the uppper window.
void OnDataGridRowKeyDown(object sender, KeyEventArgs args)
{
DataGridRow row = (DataGridRow)sender;
if (args.Key == Key.Escape && !row.IsEditing && this.ParentDialog != null)
{
this.ParentDialog.CloseDialog(false);
}
}
protected override void OnInitialized(EventArgs e)
{
base.OnInitialized(e);
this.Unloaded += this.OnDynamicArgumentDesignerUnloaded;
}
SubscribeContextCallback OnReadOnlyStateChangedCallback
{
get
{
if (onReadOnlyStateChangedCallback == null)
{
onReadOnlyStateChangedCallback = new SubscribeContextCallback(OnReadOnlyStateChanged);
}
return onReadOnlyStateChangedCallback;
}
}
void OnDynamicArgumentDesignerUnloaded(object sender, RoutedEventArgs e)
{
this.WPF_DataGrid.LoadingRow -= this.DataGrid_Standard_LoadingRow;
this.Unloaded -= this.OnDynamicArgumentDesignerUnloaded;
}
public ObservableCollection DynamicArguments
{
get
{
return (ObservableCollection)GetValue(DynamicArgumentsProperty);
}
set
{
SetValue(DynamicArgumentsProperty, value);
if (value != null)
{
this.WPF_DataGrid.ItemsSource = value;
}
}
}
[Fx.Tag.KnownXamlExternal]
public ModelItem OwnerActivity
{
get { return (ModelItem)GetValue(OwnerActivityProperty); }
set { SetValue(OwnerActivityProperty, value); }
}
[Fx.Tag.KnownXamlExternal]
public EditingContext Context
{
get { return (EditingContext)GetValue(ContextProperty); }
set { SetValue(ContextProperty, value); }
}
public bool IsDirectionReadOnly
{
get { return (bool)GetValue(IsDirectionReadOnlyProperty); }
set { SetValue(IsDirectionReadOnlyProperty, value); }
}
public bool HideDirection
{
get
{
return this.hideDirection;
}
set
{
this.hideDirection = value;
if (this.hideDirection)
{
this.WPF_DataGrid.Columns[DynamicArgumentDesigner.DirectionColumn].Visibility = Visibility.Hidden;
}
else
{
this.WPF_DataGrid.Columns[DynamicArgumentDesigner.DirectionColumn].Visibility = Visibility.Visible;
}
}
}
public string ArgumentPrefix
{
get
{
return this.argumentPrefix;
}
set
{
this.argumentPrefix = value;
}
}
public string HintText
{
get
{
if (this.hintText != null)
{
return this.hintText;
}
else
{
return (string)this.FindResource("addDynamicArgumentNewRowLabel");
}
}
set
{
this.hintText = value;
if (hintText == null)
{
dgHelper.AddNewRowContent = (string)this.FindResource("addDynamicArgumentNewRowLabel");
}
else
{
dgHelper.AddNewRowContent = hintText;
}
}
}
public WorkflowElementDialog ParentDialog
{
get;
set;
}
static void OnIsDirectionReadOnlyChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
{
((DynamicArgumentDesigner)dependencyObject).OnIsDirectionReadOnlyChanged();
}
void OnIsDirectionReadOnlyChanged()
{
if (!this.IsDirectionReadOnly)
{
DataGridTemplateColumn directionCol = this.WPF_DataGrid.Columns[1] as DataGridTemplateColumn;
directionCol.CellEditingTemplate = (DataTemplate)this.WPF_DataGrid.FindResource("argumentDirectionEditingTemplate");
}
}
internal Type UnderlyingArgumentType
{
get
{
return (Type)GetValue(UnderlyingArgumentTypeProperty);
}
set
{
if (!typeof(Argument).IsAssignableFrom(value))
{
ErrorReporting.ShowErrorMessage(SR.NonSupportedDynamicArgumentType);
}
else
{
SetValue(UnderlyingArgumentTypeProperty, value);
OnUnderlyingArgumentTypeChanged();
}
}
}
void OnUnderlyingArgumentTypeChanged()
{
Type currentArgumentType = this.UnderlyingArgumentType;
if (currentArgumentType != null && (OutArgumentType.IsAssignableFrom(currentArgumentType) || InOutArgumentType.IsAssignableFrom(currentArgumentType)))
{
this.WPF_DataGrid.Columns[DynamicArgumentDesigner.ExpressionColumn].Header = (string)this.FindResource("assignToHeader");
}
else
{
this.WPF_DataGrid.Columns[DynamicArgumentDesigner.ExpressionColumn].Header = (string)this.FindResource("valueHeader");
}
}
internal bool? IsDictionary
{
get
{
return (bool?)GetValue(IsDictionaryProperty);
}
set
{
SetValue(IsDictionaryProperty, value);
}
}
internal static ObservableCollection ModelItemToWrapperCollection(ModelItem model, out bool isDictionary, out Type underlyingArgumentType)
{
string errorMessage = string.Empty;
underlyingArgumentType = null;
isDictionary = false;
if (model is ModelItemCollection)
{
underlyingArgumentType = model.GetCurrentValue().GetType().GetGenericArguments()[0];
if (!typeof(Argument).IsAssignableFrom(underlyingArgumentType))
{
errorMessage = SR.NonSupportedDynamicArgumentType;
}
}
else if (model is ModelItemDictionary)
{
Type underlyingKeyType = model.GetCurrentValue().GetType().GetGenericArguments()[0];
underlyingArgumentType = model.GetCurrentValue().GetType().GetGenericArguments()[1];
if (!typeof(Argument).IsAssignableFrom(underlyingArgumentType))
{
errorMessage = SR.NonSupportedDynamicArgumentType;
}
if (underlyingKeyType != typeof(string))
{
errorMessage += SR.NonSupportedDynamicArgumentKeyType;
}
isDictionary = true;
}
else
{
errorMessage = SR.NonSupportedModelItemCollectionOrDictionary;
}
if (!string.IsNullOrEmpty(errorMessage))
{
ErrorReporting.ShowErrorMessage(SR.NonSupportedModelItemCollectionOrDictionary);
return null;
}
if (isDictionary)
{
ObservableCollection wrappers = new ObservableCollection();
foreach (ModelItem item in GetArgumentCollection(model))
{
wrappers.Add(new DynamicArgumentWrapperObject(item.Properties["Key"].ComputedValue as string, item.Properties["Value"].Value));
}
return wrappers;
}
else
{
ObservableCollection wrappers = new ObservableCollection();
foreach (ModelItem item in GetArgumentCollection(model))
{
wrappers.Add(new DynamicArgumentWrapperObject(null, item));
}
return wrappers;
}
}
internal static void WrapperCollectionToModelItem(ObservableCollection wrappers, ModelItem data, bool isDictionary, Type underlyingArgumentType)
{
ModelItemCollection collection = GetArgumentCollection(data);
using (ModelEditingScope change = collection.BeginEdit(SR.UpdateDynamicArgumentsDescription))
{
if (isDictionary)
{
collection.Clear();
Type dictionaryEntryType = typeof(ModelItemKeyValuePair<,>).MakeGenericType(new Type[] { typeof(string), underlyingArgumentType });
foreach (DynamicArgumentWrapperObject wrapper in wrappers)
{
Argument argument = Argument.Create(wrapper.Type, wrapper.Direction);
object mutableKVPair = Activator.CreateInstance(dictionaryEntryType, new object[] { wrapper.Name, argument });
ModelItem argumentKVPair = collection.Add(mutableKVPair);
if (wrapper.Expression != null)
{
argumentKVPair.Properties["Value"].Value.Properties["Expression"].SetValue(wrapper.Expression.GetCurrentValue());
}
}
}
else
{
collection.Clear();
foreach (DynamicArgumentWrapperObject wrapper in wrappers)
{
Argument argument = Argument.Create(wrapper.Type, wrapper.Direction);
ModelItem argumentItem = collection.Add(argument);
if (wrapper.Expression != null)
{
argumentItem.Properties["Expression"].SetValue(wrapper.Expression.GetCurrentValue());
}
}
}
change.Complete();
}
}
static ModelItemCollection GetArgumentCollection(ModelItem data)
{
if (data is ModelItemCollection)
{
return (data as ModelItemCollection);
}
else if (data is ModelItemDictionary)
{
return (data as ModelItemDictionary).Properties["ItemsCollection"].Collection;
}
else
{
ErrorReporting.ShowErrorMessage(SR.NonSupportedModelItemCollectionOrDictionary);
return null;
}
}
void OnDynamicArgumentsLoaded()
{
Fx.Assert(this.Context != null, "EditingContext cannot be null");
Fx.Assert(this.IsDictionary != null, "IsDictionary is not set");
Fx.Assert(this.UnderlyingArgumentType != null, "UnderlyingArgumentType is not set");
if (!(this.IsDictionary.Value))
{
this.WPF_DataGrid.Columns[DynamicArgumentDesigner.NameColumn].Visibility = Visibility.Hidden;
}
if (null != this.DynamicArguments)
{
if (this.UnderlyingArgumentType == ArgumentType)
{
this.IsDirectionReadOnly = false;
}
if (this.UnderlyingArgumentType.IsGenericType)
{
Type[] innerArgumentTypes = this.UnderlyingArgumentType.GetGenericArguments();
if (innerArgumentTypes.Length > 0)
{
Type innerArgumentType = innerArgumentTypes[0];
this.WPF_DataGrid.Columns[DynamicArgumentDesigner.ArgumentTypeColumn].IsReadOnly = !innerArgumentType.IsGenericParameter;
}
}
}
this.WPF_DataGrid.ItemsSource = this.DynamicArguments;
UpdateChildrenElementStatus();
}
internal void ValidateEntry(DynamicArgumentWrapperObject entry, DependencyPropertyChangedEventArgs e)
{
if (e.Property == DynamicArgumentWrapperObject.NameProperty)
{
if (this.IsDictionary.Value)
{
DataGridRow row = entry.Row;
string newName = e.NewValue as string;
bool duplicates =
this.DynamicArguments.Any(
p => string.Equals(p.Name, newName) && p != entry);
if (duplicates || string.IsNullOrEmpty(newName))
{
entry.Name = e.OldValue as string;
if (duplicates)
{
ErrorReporting.ShowErrorMessage(string.Format(CultureInfo.CurrentCulture, SR.DuplicateArgumentName, newName));
}
else
{
ErrorReporting.ShowErrorMessage(string.Format(CultureInfo.CurrentCulture, SR.EmptyArgumentName));
}
}
entry.IsValidating = false;
}
}
else
{
if (e.Property == DynamicArgumentWrapperObject.DirectionProperty)
{
entry.UseLocationExpression = (entry.Direction != ArgumentDirection.In);
}
if ((e.Property != DynamicArgumentWrapperObject.ExpressionProperty) && (entry.Expression != null))
{
Activity expression = entry.Expression.GetCurrentValue() as Activity;
string expressionText = ExpressionHelper.GetExpressionString(expression, this.OwnerActivity);
if (expressionText != null)
{
Activity newExpression = ExpressionHelper.CreateExpression(entry.Type, expressionText, entry.UseLocationExpression, null);
entry.Expression = (this.OwnerActivity as IModelTreeItem).ModelTreeManager.WrapAsModelItem(null, newExpression);
}
}
entry.IsValidating = false;
}
}
internal string GetDefaultName()
{
if (!this.IsDictionary.Value)
{
return string.Empty;
}
else
{
var defaultNames = this.DynamicArguments.
Select(p => (string)p.Name).
Where(p => 0 == string.Compare(p, 0, this.ArgumentPrefix, 0, this.ArgumentPrefix.Length, StringComparison.Ordinal)).
Select(p => p.Substring(this.ArgumentPrefix.Length));
int maxNum = 1;
foreach (string numberPart in defaultNames)
{
int current;
if (int.TryParse(numberPart, out current))
{
if (current >= maxNum)
{
maxNum = current + 1;
}
}
}
return string.Format(CultureInfo.InvariantCulture, "{0}{1}", this.ArgumentPrefix, maxNum);
}
}
internal Type GetDefaultType()
{
Type[] genericArguments = this.UnderlyingArgumentType.GetGenericArguments();
if (genericArguments.Length == 0)
{
return typeof(string);
}
else
{
return genericArguments[0];
}
}
internal ArgumentDirection GetDefaultDirection()
{
if (this.UnderlyingArgumentType == ArgumentType)
{
return ArgumentDirection.In;
}
if (InArgumentType.IsAssignableFrom(this.UnderlyingArgumentType))
{
return ArgumentDirection.In;
}
if (OutArgumentType.IsAssignableFrom(this.UnderlyingArgumentType))
{
return ArgumentDirection.Out;
}
Fx.Assert(InOutArgumentType.IsAssignableFrom(this.UnderlyingArgumentType), "UnderlyingArgumentType should be of type OutArgumentType");
return ArgumentDirection.InOut;
}
//Hook LoadingRow event to set different row template () for new place holder
void DataGrid_Standard_LoadingRow(object sender, DataGridRowEventArgs e)
{
if (e.Row.Item != CollectionView.NewItemPlaceholder)
{
DynamicArgumentWrapperObject wrapper = e.Row.Item as DynamicArgumentWrapperObject;
wrapper.Row = e.Row;
}
}
void OnCreateDynamicArgumentExecute(object sender, ExecutedRoutedEventArgs e)
{
DynamicArgumentWrapperObject wrapper = new DynamicArgumentWrapperObject();
this.DynamicArguments.Add(wrapper);
this.dgHelper.BeginRowEdit(wrapper);
}
void OnMoveUpArgumentExecute(object sender, RoutedEventArgs e)
{
if (null != this.WPF_DataGrid.SelectedItem)
{
int selectedArgumentIndex = this.WPF_DataGrid.SelectedIndex;
if (selectedArgumentIndex > 0)
{
this.DynamicArguments.Move(selectedArgumentIndex, selectedArgumentIndex - 1);
}
this.OnDataGridSelectionChanged(this, null);
}
}
void OnMoveDownArgumentExecute(object sender, RoutedEventArgs e)
{
if (null != this.WPF_DataGrid.SelectedItem)
{
int selectedArgumentIndex = this.WPF_DataGrid.SelectedIndex;
if (selectedArgumentIndex < this.DynamicArguments.Count - 1)
{
this.DynamicArguments.Move(selectedArgumentIndex, selectedArgumentIndex + 1);
}
this.OnDataGridSelectionChanged(this, null);
}
}
void OnExpressionTextBoxLoaded(object sender, RoutedEventArgs args)
{
((ExpressionTextBox)sender).IsIndependentExpression = true;
}
}
sealed class DynamicArgumentWrapperObject : DependencyObject
{
public static readonly DependencyProperty ModelItemProperty = DependencyProperty.Register(
"ModelItem",
typeof(ModelItem),
typeof(DynamicArgumentWrapperObject),
new UIPropertyMetadata(null));
public static readonly DependencyProperty NameProperty = DependencyProperty.Register(
"Name",
typeof(string),
typeof(DynamicArgumentWrapperObject),
new UIPropertyMetadata(string.Empty, OnArgumentPropertyChanged));
public static readonly DependencyProperty ArgumentTypeProperty = DependencyProperty.Register(
"Type",
typeof(Type),
typeof(DynamicArgumentWrapperObject),
new UIPropertyMetadata(typeof(string), OnArgumentPropertyChanged));
public static readonly DependencyProperty DirectionProperty = DependencyProperty.Register(
"Direction",
typeof(ArgumentDirection),
typeof(DynamicArgumentWrapperObject),
new UIPropertyMetadata(ArgumentDirection.In, OnArgumentPropertyChanged));
public static readonly DependencyProperty ExpressionProperty =
DependencyProperty.Register(
"Expression",
typeof(ModelItem),
typeof(DynamicArgumentWrapperObject),
new UIPropertyMetadata(OnArgumentPropertyChanged));
public static readonly DependencyProperty UseLocationExpressionProperty =
DependencyProperty.Register(
"UseLocationExpression",
typeof(bool),
typeof(DynamicArgumentWrapperObject));
bool isInitializing;
const string ExpressionPropertyName = "Expression";
public string Name
{
get { return (string)GetValue(NameProperty); }
set { SetValue(NameProperty, value); }
}
public Type Type
{
get { return (Type)GetValue(ArgumentTypeProperty); }
set { SetValue(ArgumentTypeProperty, value); }
}
public ArgumentDirection Direction
{
get { return (ArgumentDirection)GetValue(DirectionProperty); }
set { SetValue(DirectionProperty, value); }
}
public ModelItem Expression
{
get { return (ModelItem)GetValue(ExpressionProperty); }
set { SetValue(ExpressionProperty, value); }
}
public bool UseLocationExpression
{
get { return (bool)GetValue(UseLocationExpressionProperty); }
set { SetValue(UseLocationExpressionProperty, value); }
}
internal bool IsValidating
{
get;
set;
}
internal DataGridRow Row
{
get;
set;
}
public static DynamicArgumentDesigner Editor
{
get;
set;
}
public DynamicArgumentWrapperObject()
{
this.isInitializing = true;
this.IsValidating = false;
this.Name = DynamicArgumentWrapperObject.Editor.GetDefaultName();
this.Type = DynamicArgumentWrapperObject.Editor.GetDefaultType();
this.Direction = DynamicArgumentWrapperObject.Editor.GetDefaultDirection();
this.UseLocationExpression = (this.Direction != ArgumentDirection.In);
this.isInitializing = false;
}
public DynamicArgumentWrapperObject(string argumentName, ModelItem argumentItem)
{
Fx.Assert(argumentItem != null, "argumentItem canot be null");
this.isInitializing = true;
this.IsValidating = false;
Argument argument = (Argument)argumentItem.GetCurrentValue();
this.Name = argumentName;
this.Direction = argument.Direction;
this.UseLocationExpression = (this.Direction != ArgumentDirection.In);
this.Type = argument.ArgumentType;
this.Expression = argumentItem.Properties[ExpressionPropertyName].Value;
this.isInitializing = false;
}
static void OnArgumentPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
{
DynamicArgumentWrapperObject wrapper = (DynamicArgumentWrapperObject)sender;
if (!wrapper.IsValidating && !wrapper.isInitializing)
{
wrapper.OnArgumentPropertyChanged(e);
}
}
void OnArgumentPropertyChanged(DependencyPropertyChangedEventArgs e)
{
Fx.Assert(DynamicArgumentWrapperObject.Editor != null, "collection editor is null!");
this.IsValidating = true;
DynamicArgumentWrapperObject.Editor.ValidateEntry(this, e);
}
// For screen reader to read the DataGrid row.
public override string ToString()
{
return string.IsNullOrEmpty(this.Name) ? "Parameter" : this.Name;
}
}
}
// 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
- ProviderCommandInfoUtils.cs
- Operators.cs
- externdll.cs
- InvalidFilterCriteriaException.cs
- OutputCacheSection.cs
- HtmlElementErrorEventArgs.cs
- CreateParams.cs
- SemanticBasicElement.cs
- ValidatorCollection.cs
- DateTimeOffset.cs
- ContextMenu.cs
- PeerCollaboration.cs
- Separator.cs
- Profiler.cs
- XamlVector3DCollectionSerializer.cs
- DragCompletedEventArgs.cs
- ObjectSet.cs
- UInt64.cs
- FlowDocumentScrollViewer.cs
- ContextConfiguration.cs
- X509Certificate2.cs
- EdmError.cs
- DataBoundLiteralControl.cs
- ViewgenContext.cs
- PageParserFilter.cs
- Collection.cs
- Table.cs
- ComponentEvent.cs
- SystemResources.cs
- ProfileGroupSettings.cs
- DataError.cs
- NetWebProxyFinder.cs
- UpdateRecord.cs
- FormsAuthenticationUser.cs
- SetterBaseCollection.cs
- TextClipboardData.cs
- FrameworkTemplate.cs
- DBConnectionString.cs
- DataGridColumnsPage.cs
- CompoundFileIOPermission.cs
- PenThreadWorker.cs
- SQLCharsStorage.cs
- PointLightBase.cs
- GuidelineSet.cs
- XamlSerializerUtil.cs
- ListBoxItemWrapperAutomationPeer.cs
- SafeRightsManagementPubHandle.cs
- TableItemProviderWrapper.cs
- RightsManagementPermission.cs
- _RequestCacheProtocol.cs
- CharacterBuffer.cs
- TemplateGroupCollection.cs
- ComplexLine.cs
- PerformanceCounterScope.cs
- AccessKeyManager.cs
- UriTemplateVariableQueryValue.cs
- Light.cs
- ellipse.cs
- Point.cs
- AssemblyNameProxy.cs
- _NativeSSPI.cs
- Freezable.cs
- RealProxy.cs
- UnsafeNativeMethods.cs
- Normalization.cs
- CompilerResults.cs
- DependencyObjectType.cs
- HttpRuntimeSection.cs
- JumpPath.cs
- OracleConnectionFactory.cs
- CryptographicAttribute.cs
- XmlElementAttribute.cs
- FixUp.cs
- GifBitmapEncoder.cs
- DesignBindingPicker.cs
- SimpleType.cs
- DataGridViewAutoSizeColumnsModeEventArgs.cs
- GACIdentityPermission.cs
- SimpleHandlerFactory.cs
- DocumentCollection.cs
- SafeCancelMibChangeNotify.cs
- EntityDesignerUtils.cs
- GeneralTransform3DGroup.cs
- ApplicationSettingsBase.cs
- HtmlHead.cs
- ExtensionSimplifierMarkupObject.cs
- MultiDataTrigger.cs
- StreamInfo.cs
- SerializationInfoEnumerator.cs
- DocobjHost.cs
- CheckBox.cs
- LeaseManager.cs
- FormatterServices.cs
- PathFigure.cs
- ListViewGroupItemCollection.cs
- IISMapPath.cs
- KeyValuePair.cs
- ResXResourceWriter.cs
- RegisteredExpandoAttribute.cs
- EdmPropertyAttribute.cs