Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Core / Microsoft / Scripting / Compiler / LambdaCompiler.Unary.cs / 1305376 / LambdaCompiler.Unary.cs
/* ****************************************************************************
*
* Copyright (c) Microsoft Corporation.
*
* This source code is subject to terms and conditions of the Microsoft Public License. A
* copy of the license can be found in the License.html file at the root of this distribution. If
* you cannot locate the Microsoft Public License, please send an email to
* dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound
* by the terms of the Microsoft Public License.
*
* You must not remove this notice, or any other, from this software.
*
*
* ***************************************************************************/
using System.Diagnostics;
using System.Dynamic.Utils;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
#if SILVERLIGHT
using System.Core;
#endif
namespace System.Linq.Expressions.Compiler {
partial class LambdaCompiler {
private void EmitQuoteUnaryExpression(Expression expr) {
EmitQuote((UnaryExpression)expr);
}
private void EmitQuote(UnaryExpression quote) {
// emit the quoted expression as a runtime constant
EmitConstant(quote.Operand, quote.Type);
// Heuristic: only emit the tree rewrite logic if we have hoisted
// locals.
if (_scope.NearestHoistedLocals != null) {
// HoistedLocals is internal so emit as System.Object
EmitConstant(_scope.NearestHoistedLocals, typeof(object));
_scope.EmitGet(_scope.NearestHoistedLocals.SelfVariable);
_ilg.Emit(OpCodes.Call, typeof(RuntimeOps).GetMethod("Quote"));
if (quote.Type != typeof(Expression)) {
_ilg.Emit(OpCodes.Castclass, quote.Type);
}
}
}
private void EmitThrowUnaryExpression(Expression expr) {
EmitThrow((UnaryExpression)expr, CompilationFlags.EmitAsDefaultType);
}
private void EmitThrow(UnaryExpression expr, CompilationFlags flags) {
if (expr.Operand == null) {
CheckRethrow();
_ilg.Emit(OpCodes.Rethrow);
} else {
EmitExpression(expr.Operand);
_ilg.Emit(OpCodes.Throw);
}
EmitUnreachable(expr, flags);
}
private void EmitUnaryExpression(Expression expr, CompilationFlags flags) {
EmitUnary((UnaryExpression)expr, flags);
}
private void EmitUnary(UnaryExpression node, CompilationFlags flags) {
if (node.Method != null) {
EmitUnaryMethod(node, flags);
} else if (node.NodeType == ExpressionType.NegateChecked && TypeUtils.IsInteger(node.Operand.Type)) {
EmitExpression(node.Operand);
LocalBuilder loc = GetLocal(node.Operand.Type);
_ilg.Emit(OpCodes.Stloc, loc);
_ilg.EmitInt(0);
_ilg.EmitConvertToType(typeof(int), node.Operand.Type, false);
_ilg.Emit(OpCodes.Ldloc, loc);
FreeLocal(loc);
EmitBinaryOperator(ExpressionType.SubtractChecked, node.Operand.Type, node.Operand.Type, node.Type, false);
} else {
EmitExpression(node.Operand);
EmitUnaryOperator(node.NodeType, node.Operand.Type, node.Type);
}
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]
private void EmitUnaryOperator(ExpressionType op, Type operandType, Type resultType) {
bool operandIsNullable = TypeUtils.IsNullableType(operandType);
if (op == ExpressionType.ArrayLength) {
_ilg.Emit(OpCodes.Ldlen);
return;
}
if (operandIsNullable) {
switch (op) {
case ExpressionType.Not: {
if (operandType != typeof(bool?))
goto case ExpressionType.Negate;
Label labIfNull = _ilg.DefineLabel();
Label labEnd = _ilg.DefineLabel();
LocalBuilder loc = GetLocal(operandType);
// store values (reverse order since they are already on the stack)
_ilg.Emit(OpCodes.Stloc, loc);
// test for null
_ilg.Emit(OpCodes.Ldloca, loc);
_ilg.EmitHasValue(operandType);
_ilg.Emit(OpCodes.Brfalse_S, labEnd);
// do op on non-null value
_ilg.Emit(OpCodes.Ldloca, loc);
_ilg.EmitGetValueOrDefault(operandType);
Type nnOperandType = TypeUtils.GetNonNullableType(operandType);
EmitUnaryOperator(op, nnOperandType, typeof(bool));
// construct result
ConstructorInfo ci = resultType.GetConstructor(new Type[] { typeof(bool) });
_ilg.Emit(OpCodes.Newobj, ci);
_ilg.Emit(OpCodes.Stloc, loc);
_ilg.MarkLabel(labEnd);
_ilg.Emit(OpCodes.Ldloc, loc);
FreeLocal(loc);
return;
}
case ExpressionType.UnaryPlus:
case ExpressionType.NegateChecked:
case ExpressionType.Negate:
case ExpressionType.Increment:
case ExpressionType.Decrement:
case ExpressionType.OnesComplement:
case ExpressionType.IsFalse:
case ExpressionType.IsTrue: {
Debug.Assert(TypeUtils.AreEquivalent(operandType, resultType));
Label labIfNull = _ilg.DefineLabel();
Label labEnd = _ilg.DefineLabel();
LocalBuilder loc = GetLocal(operandType);
// check for null
_ilg.Emit(OpCodes.Stloc, loc);
_ilg.Emit(OpCodes.Ldloca, loc);
_ilg.EmitHasValue(operandType);
_ilg.Emit(OpCodes.Brfalse_S, labIfNull);
// apply operator to non-null value
_ilg.Emit(OpCodes.Ldloca, loc);
_ilg.EmitGetValueOrDefault(operandType);
Type nnOperandType = TypeUtils.GetNonNullableType(resultType);
EmitUnaryOperator(op, nnOperandType, nnOperandType);
// construct result
ConstructorInfo ci = resultType.GetConstructor(new Type[] { nnOperandType });
_ilg.Emit(OpCodes.Newobj, ci);
_ilg.Emit(OpCodes.Stloc, loc);
_ilg.Emit(OpCodes.Br_S, labEnd);
// if null then create a default one
_ilg.MarkLabel(labIfNull);
_ilg.Emit(OpCodes.Ldloca, loc);
_ilg.Emit(OpCodes.Initobj, resultType);
_ilg.MarkLabel(labEnd);
_ilg.Emit(OpCodes.Ldloc, loc);
FreeLocal(loc);
return;
}
case ExpressionType.TypeAs:
_ilg.Emit(OpCodes.Box, operandType);
_ilg.Emit(OpCodes.Isinst, resultType);
if (TypeUtils.IsNullableType(resultType)) {
_ilg.Emit(OpCodes.Unbox_Any, resultType);
}
return;
default:
throw Error.UnhandledUnary(op);
}
} else {
switch (op) {
case ExpressionType.Not:
if (operandType == typeof(bool)) {
_ilg.Emit(OpCodes.Ldc_I4_0);
_ilg.Emit(OpCodes.Ceq);
} else {
_ilg.Emit(OpCodes.Not);
}
break;
case ExpressionType.OnesComplement:
_ilg.Emit(OpCodes.Not);
break;
case ExpressionType.IsFalse:
_ilg.Emit(OpCodes.Ldc_I4_0);
_ilg.Emit(OpCodes.Ceq);
// Not an arithmetic operation -> no conversion
return;
case ExpressionType.IsTrue:
_ilg.Emit(OpCodes.Ldc_I4_1);
_ilg.Emit(OpCodes.Ceq);
// Not an arithmetic operation -> no conversion
return;
case ExpressionType.UnaryPlus:
_ilg.Emit(OpCodes.Nop);
break;
case ExpressionType.Negate:
case ExpressionType.NegateChecked:
_ilg.Emit(OpCodes.Neg);
break;
case ExpressionType.TypeAs:
if (operandType.IsValueType) {
_ilg.Emit(OpCodes.Box, operandType);
}
_ilg.Emit(OpCodes.Isinst, resultType);
if (TypeUtils.IsNullableType(resultType)) {
_ilg.Emit(OpCodes.Unbox_Any, resultType);
}
// Not an arithmetic operation -> no conversion
return;
case ExpressionType.Increment:
EmitConstantOne(resultType);
_ilg.Emit(OpCodes.Add);
break;
case ExpressionType.Decrement:
EmitConstantOne(resultType);
_ilg.Emit(OpCodes.Sub);
break;
default:
throw Error.UnhandledUnary(op);
}
EmitConvertArithmeticResult(op, resultType);
}
}
private void EmitConstantOne(Type type) {
switch (Type.GetTypeCode(type)) {
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.Int16:
case TypeCode.Int32:
_ilg.Emit(OpCodes.Ldc_I4_1);
break;
case TypeCode.Int64:
case TypeCode.UInt64:
_ilg.Emit(OpCodes.Ldc_I8, (long)1);
break;
case TypeCode.Single:
_ilg.Emit(OpCodes.Ldc_R4, 1.0f);
break;
case TypeCode.Double:
_ilg.Emit(OpCodes.Ldc_R8, 1.0d);
break;
default:
// we only have to worry about aritmetic types, see
// TypeUtils.IsArithmetic
throw ContractUtils.Unreachable;
}
}
private void EmitUnboxUnaryExpression(Expression expr) {
var node = (UnaryExpression)expr;
Debug.Assert(node.Type.IsValueType && !TypeUtils.IsNullableType(node.Type));
// Unbox_Any leaves the value on the stack
EmitExpression(node.Operand);
_ilg.Emit(OpCodes.Unbox_Any, node.Type);
}
private void EmitConvertUnaryExpression(Expression expr, CompilationFlags flags) {
EmitConvert((UnaryExpression)expr, flags);
}
private void EmitConvert(UnaryExpression node, CompilationFlags flags) {
if (node.Method != null) {
// User-defined conversions are only lifted if both source and
// destination types are value types. The C# compiler gets this wrong.
// In C#, if you have an implicit conversion from int->MyClass and you
// "lift" the conversion to int?->MyClass then a null int? goes to a
// null MyClass. This is contrary to the specification, which states
// that the correct behaviour is to unwrap the int?, throw an exception
// if it is null, and then call the conversion.
//
// We cannot fix this in C# but there is no reason why we need to
// propagate this bug into the expression tree API. Unfortunately
// this means that when the C# compiler generates the lambda
// (int? i)=>(MyClass)i, we will get different results for converting
// that lambda to a delegate directly and converting that lambda to
// an expression tree and then compiling it. We can live with this
// discrepancy however.
if (node.IsLifted && (!node.Type.IsValueType || !node.Operand.Type.IsValueType)) {
ParameterInfo[] pis = node.Method.GetParametersCached();
Debug.Assert(pis != null && pis.Length == 1);
Type paramType = pis[0].ParameterType;
if (paramType.IsByRef) {
paramType = paramType.GetElementType();
}
UnaryExpression e = Expression.Convert(
Expression.Call(
node.Method,
Expression.Convert(node.Operand, pis[0].ParameterType)
),
node.Type
);
EmitConvert(e, flags);
} else {
EmitUnaryMethod(node, flags);
}
} else if (node.Type == typeof(void)) {
EmitExpressionAsVoid(node.Operand, flags);
} else {
if (TypeUtils.AreEquivalent(node.Operand.Type, node.Type)) {
EmitExpression(node.Operand, flags);
} else {
// A conversion is emitted after emitting the operand, no tail call is emitted
EmitExpression(node.Operand);
_ilg.EmitConvertToType(node.Operand.Type, node.Type, node.NodeType == ExpressionType.ConvertChecked);
}
}
}
private void EmitUnaryMethod(UnaryExpression node, CompilationFlags flags) {
if (node.IsLifted) {
ParameterExpression v = Expression.Variable(TypeUtils.GetNonNullableType(node.Operand.Type), null);
MethodCallExpression mc = Expression.Call(node.Method, v);
Type resultType = TypeUtils.GetNullableType(mc.Type);
EmitLift(node.NodeType, resultType, mc, new ParameterExpression[] { v }, new Expression[] { node.Operand });
_ilg.EmitConvertToType(resultType, node.Type, false);
} else {
EmitMethodCallExpression(Expression.Call(node.Method, node.Operand), flags);
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
/* ****************************************************************************
*
* Copyright (c) Microsoft Corporation.
*
* This source code is subject to terms and conditions of the Microsoft Public License. A
* copy of the license can be found in the License.html file at the root of this distribution. If
* you cannot locate the Microsoft Public License, please send an email to
* dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound
* by the terms of the Microsoft Public License.
*
* You must not remove this notice, or any other, from this software.
*
*
* ***************************************************************************/
using System.Diagnostics;
using System.Dynamic.Utils;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
#if SILVERLIGHT
using System.Core;
#endif
namespace System.Linq.Expressions.Compiler {
partial class LambdaCompiler {
private void EmitQuoteUnaryExpression(Expression expr) {
EmitQuote((UnaryExpression)expr);
}
private void EmitQuote(UnaryExpression quote) {
// emit the quoted expression as a runtime constant
EmitConstant(quote.Operand, quote.Type);
// Heuristic: only emit the tree rewrite logic if we have hoisted
// locals.
if (_scope.NearestHoistedLocals != null) {
// HoistedLocals is internal so emit as System.Object
EmitConstant(_scope.NearestHoistedLocals, typeof(object));
_scope.EmitGet(_scope.NearestHoistedLocals.SelfVariable);
_ilg.Emit(OpCodes.Call, typeof(RuntimeOps).GetMethod("Quote"));
if (quote.Type != typeof(Expression)) {
_ilg.Emit(OpCodes.Castclass, quote.Type);
}
}
}
private void EmitThrowUnaryExpression(Expression expr) {
EmitThrow((UnaryExpression)expr, CompilationFlags.EmitAsDefaultType);
}
private void EmitThrow(UnaryExpression expr, CompilationFlags flags) {
if (expr.Operand == null) {
CheckRethrow();
_ilg.Emit(OpCodes.Rethrow);
} else {
EmitExpression(expr.Operand);
_ilg.Emit(OpCodes.Throw);
}
EmitUnreachable(expr, flags);
}
private void EmitUnaryExpression(Expression expr, CompilationFlags flags) {
EmitUnary((UnaryExpression)expr, flags);
}
private void EmitUnary(UnaryExpression node, CompilationFlags flags) {
if (node.Method != null) {
EmitUnaryMethod(node, flags);
} else if (node.NodeType == ExpressionType.NegateChecked && TypeUtils.IsInteger(node.Operand.Type)) {
EmitExpression(node.Operand);
LocalBuilder loc = GetLocal(node.Operand.Type);
_ilg.Emit(OpCodes.Stloc, loc);
_ilg.EmitInt(0);
_ilg.EmitConvertToType(typeof(int), node.Operand.Type, false);
_ilg.Emit(OpCodes.Ldloc, loc);
FreeLocal(loc);
EmitBinaryOperator(ExpressionType.SubtractChecked, node.Operand.Type, node.Operand.Type, node.Type, false);
} else {
EmitExpression(node.Operand);
EmitUnaryOperator(node.NodeType, node.Operand.Type, node.Type);
}
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]
private void EmitUnaryOperator(ExpressionType op, Type operandType, Type resultType) {
bool operandIsNullable = TypeUtils.IsNullableType(operandType);
if (op == ExpressionType.ArrayLength) {
_ilg.Emit(OpCodes.Ldlen);
return;
}
if (operandIsNullable) {
switch (op) {
case ExpressionType.Not: {
if (operandType != typeof(bool?))
goto case ExpressionType.Negate;
Label labIfNull = _ilg.DefineLabel();
Label labEnd = _ilg.DefineLabel();
LocalBuilder loc = GetLocal(operandType);
// store values (reverse order since they are already on the stack)
_ilg.Emit(OpCodes.Stloc, loc);
// test for null
_ilg.Emit(OpCodes.Ldloca, loc);
_ilg.EmitHasValue(operandType);
_ilg.Emit(OpCodes.Brfalse_S, labEnd);
// do op on non-null value
_ilg.Emit(OpCodes.Ldloca, loc);
_ilg.EmitGetValueOrDefault(operandType);
Type nnOperandType = TypeUtils.GetNonNullableType(operandType);
EmitUnaryOperator(op, nnOperandType, typeof(bool));
// construct result
ConstructorInfo ci = resultType.GetConstructor(new Type[] { typeof(bool) });
_ilg.Emit(OpCodes.Newobj, ci);
_ilg.Emit(OpCodes.Stloc, loc);
_ilg.MarkLabel(labEnd);
_ilg.Emit(OpCodes.Ldloc, loc);
FreeLocal(loc);
return;
}
case ExpressionType.UnaryPlus:
case ExpressionType.NegateChecked:
case ExpressionType.Negate:
case ExpressionType.Increment:
case ExpressionType.Decrement:
case ExpressionType.OnesComplement:
case ExpressionType.IsFalse:
case ExpressionType.IsTrue: {
Debug.Assert(TypeUtils.AreEquivalent(operandType, resultType));
Label labIfNull = _ilg.DefineLabel();
Label labEnd = _ilg.DefineLabel();
LocalBuilder loc = GetLocal(operandType);
// check for null
_ilg.Emit(OpCodes.Stloc, loc);
_ilg.Emit(OpCodes.Ldloca, loc);
_ilg.EmitHasValue(operandType);
_ilg.Emit(OpCodes.Brfalse_S, labIfNull);
// apply operator to non-null value
_ilg.Emit(OpCodes.Ldloca, loc);
_ilg.EmitGetValueOrDefault(operandType);
Type nnOperandType = TypeUtils.GetNonNullableType(resultType);
EmitUnaryOperator(op, nnOperandType, nnOperandType);
// construct result
ConstructorInfo ci = resultType.GetConstructor(new Type[] { nnOperandType });
_ilg.Emit(OpCodes.Newobj, ci);
_ilg.Emit(OpCodes.Stloc, loc);
_ilg.Emit(OpCodes.Br_S, labEnd);
// if null then create a default one
_ilg.MarkLabel(labIfNull);
_ilg.Emit(OpCodes.Ldloca, loc);
_ilg.Emit(OpCodes.Initobj, resultType);
_ilg.MarkLabel(labEnd);
_ilg.Emit(OpCodes.Ldloc, loc);
FreeLocal(loc);
return;
}
case ExpressionType.TypeAs:
_ilg.Emit(OpCodes.Box, operandType);
_ilg.Emit(OpCodes.Isinst, resultType);
if (TypeUtils.IsNullableType(resultType)) {
_ilg.Emit(OpCodes.Unbox_Any, resultType);
}
return;
default:
throw Error.UnhandledUnary(op);
}
} else {
switch (op) {
case ExpressionType.Not:
if (operandType == typeof(bool)) {
_ilg.Emit(OpCodes.Ldc_I4_0);
_ilg.Emit(OpCodes.Ceq);
} else {
_ilg.Emit(OpCodes.Not);
}
break;
case ExpressionType.OnesComplement:
_ilg.Emit(OpCodes.Not);
break;
case ExpressionType.IsFalse:
_ilg.Emit(OpCodes.Ldc_I4_0);
_ilg.Emit(OpCodes.Ceq);
// Not an arithmetic operation -> no conversion
return;
case ExpressionType.IsTrue:
_ilg.Emit(OpCodes.Ldc_I4_1);
_ilg.Emit(OpCodes.Ceq);
// Not an arithmetic operation -> no conversion
return;
case ExpressionType.UnaryPlus:
_ilg.Emit(OpCodes.Nop);
break;
case ExpressionType.Negate:
case ExpressionType.NegateChecked:
_ilg.Emit(OpCodes.Neg);
break;
case ExpressionType.TypeAs:
if (operandType.IsValueType) {
_ilg.Emit(OpCodes.Box, operandType);
}
_ilg.Emit(OpCodes.Isinst, resultType);
if (TypeUtils.IsNullableType(resultType)) {
_ilg.Emit(OpCodes.Unbox_Any, resultType);
}
// Not an arithmetic operation -> no conversion
return;
case ExpressionType.Increment:
EmitConstantOne(resultType);
_ilg.Emit(OpCodes.Add);
break;
case ExpressionType.Decrement:
EmitConstantOne(resultType);
_ilg.Emit(OpCodes.Sub);
break;
default:
throw Error.UnhandledUnary(op);
}
EmitConvertArithmeticResult(op, resultType);
}
}
private void EmitConstantOne(Type type) {
switch (Type.GetTypeCode(type)) {
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.Int16:
case TypeCode.Int32:
_ilg.Emit(OpCodes.Ldc_I4_1);
break;
case TypeCode.Int64:
case TypeCode.UInt64:
_ilg.Emit(OpCodes.Ldc_I8, (long)1);
break;
case TypeCode.Single:
_ilg.Emit(OpCodes.Ldc_R4, 1.0f);
break;
case TypeCode.Double:
_ilg.Emit(OpCodes.Ldc_R8, 1.0d);
break;
default:
// we only have to worry about aritmetic types, see
// TypeUtils.IsArithmetic
throw ContractUtils.Unreachable;
}
}
private void EmitUnboxUnaryExpression(Expression expr) {
var node = (UnaryExpression)expr;
Debug.Assert(node.Type.IsValueType && !TypeUtils.IsNullableType(node.Type));
// Unbox_Any leaves the value on the stack
EmitExpression(node.Operand);
_ilg.Emit(OpCodes.Unbox_Any, node.Type);
}
private void EmitConvertUnaryExpression(Expression expr, CompilationFlags flags) {
EmitConvert((UnaryExpression)expr, flags);
}
private void EmitConvert(UnaryExpression node, CompilationFlags flags) {
if (node.Method != null) {
// User-defined conversions are only lifted if both source and
// destination types are value types. The C# compiler gets this wrong.
// In C#, if you have an implicit conversion from int->MyClass and you
// "lift" the conversion to int?->MyClass then a null int? goes to a
// null MyClass. This is contrary to the specification, which states
// that the correct behaviour is to unwrap the int?, throw an exception
// if it is null, and then call the conversion.
//
// We cannot fix this in C# but there is no reason why we need to
// propagate this bug into the expression tree API. Unfortunately
// this means that when the C# compiler generates the lambda
// (int? i)=>(MyClass)i, we will get different results for converting
// that lambda to a delegate directly and converting that lambda to
// an expression tree and then compiling it. We can live with this
// discrepancy however.
if (node.IsLifted && (!node.Type.IsValueType || !node.Operand.Type.IsValueType)) {
ParameterInfo[] pis = node.Method.GetParametersCached();
Debug.Assert(pis != null && pis.Length == 1);
Type paramType = pis[0].ParameterType;
if (paramType.IsByRef) {
paramType = paramType.GetElementType();
}
UnaryExpression e = Expression.Convert(
Expression.Call(
node.Method,
Expression.Convert(node.Operand, pis[0].ParameterType)
),
node.Type
);
EmitConvert(e, flags);
} else {
EmitUnaryMethod(node, flags);
}
} else if (node.Type == typeof(void)) {
EmitExpressionAsVoid(node.Operand, flags);
} else {
if (TypeUtils.AreEquivalent(node.Operand.Type, node.Type)) {
EmitExpression(node.Operand, flags);
} else {
// A conversion is emitted after emitting the operand, no tail call is emitted
EmitExpression(node.Operand);
_ilg.EmitConvertToType(node.Operand.Type, node.Type, node.NodeType == ExpressionType.ConvertChecked);
}
}
}
private void EmitUnaryMethod(UnaryExpression node, CompilationFlags flags) {
if (node.IsLifted) {
ParameterExpression v = Expression.Variable(TypeUtils.GetNonNullableType(node.Operand.Type), null);
MethodCallExpression mc = Expression.Call(node.Method, v);
Type resultType = TypeUtils.GetNullableType(mc.Type);
EmitLift(node.NodeType, resultType, mc, new ParameterExpression[] { v }, new Expression[] { node.Operand });
_ilg.EmitConvertToType(resultType, node.Type, false);
} else {
EmitMethodCallExpression(Expression.Call(node.Method, node.Operand), flags);
}
}
}
}
// 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
- ArithmeticLiteral.cs
- ValueTable.cs
- DbMetaDataCollectionNames.cs
- DelegateSerializationHolder.cs
- ColumnMapCopier.cs
- HitTestDrawingContextWalker.cs
- DefaultHttpHandler.cs
- ConfigurationManagerInternal.cs
- DependencyPropertyKey.cs
- DropSourceBehavior.cs
- LinearGradientBrush.cs
- ConfigurationSchemaErrors.cs
- Scheduler.cs
- DBBindings.cs
- PersonalizationEntry.cs
- Parameter.cs
- EventMemberCodeDomSerializer.cs
- MessageDesigner.cs
- ParseChildrenAsPropertiesAttribute.cs
- OptimizerPatterns.cs
- ExpressionQuoter.cs
- ProviderBase.cs
- StringBuilder.cs
- PageVisual.cs
- SafeFileMappingHandle.cs
- ClipboardProcessor.cs
- Utils.cs
- ToggleButton.cs
- Int32Animation.cs
- MarginsConverter.cs
- CqlWriter.cs
- SequenceNumber.cs
- UnsafeNativeMethods.cs
- TypedTableBaseExtensions.cs
- QueryResults.cs
- Crc32Helper.cs
- WindowsUserNameSecurityTokenAuthenticator.cs
- ModifierKeysConverter.cs
- ApplicationSecurityInfo.cs
- XsdCachingReader.cs
- PrintDialog.cs
- ActiveXSerializer.cs
- ProfileServiceManager.cs
- NavigationWindow.cs
- DesignerEditorPartChrome.cs
- IdnMapping.cs
- GenericUriParser.cs
- MultilineStringEditor.cs
- AlignmentXValidation.cs
- Logging.cs
- XmlComment.cs
- CodeMemberEvent.cs
- SettingsPropertyWrongTypeException.cs
- ProcessInfo.cs
- QueuePropertyVariants.cs
- DataGridViewUtilities.cs
- URIFormatException.cs
- MDIClient.cs
- FeedUtils.cs
- InkCanvasSelectionAdorner.cs
- MobileControl.cs
- TypedTableGenerator.cs
- BooleanAnimationUsingKeyFrames.cs
- ConfigurationFileMap.cs
- HostProtectionPermission.cs
- TextRangeSerialization.cs
- AutomationIdentifierGuids.cs
- StaticResourceExtension.cs
- shaperfactory.cs
- SchemaElementLookUpTable.cs
- SrgsGrammar.cs
- TabControlEvent.cs
- GlobalEventManager.cs
- CellPartitioner.cs
- GeneratedCodeAttribute.cs
- Array.cs
- InvalidCastException.cs
- ConvertersCollection.cs
- CodeDelegateInvokeExpression.cs
- recordstate.cs
- PolicyValidationException.cs
- MobileTextWriter.cs
- Validator.cs
- SqlCommand.cs
- FlowchartDesigner.Helpers.cs
- WebPartManager.cs
- ContextBase.cs
- FlowNode.cs
- CachedTypeface.cs
- filewebrequest.cs
- FileAuthorizationModule.cs
- SourceElementsCollection.cs
- WeakEventTable.cs
- WebEventTraceProvider.cs
- MessageLoggingFilterTraceRecord.cs
- TypedReference.cs
- Label.cs
- Number.cs
- ValidationHelpers.cs
- MarkupWriter.cs