Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / AddIn / Contract / System / AddIn / Contract / RemoteArgument.cs / 1305376 / RemoteArgument.cs
//------------------------------------------------------------------------------
///
/// Copyright (c) Microsoft Corporation. All Rights Reserved.
/// Information Contained Herein is Proprietary and Confidential.
///
//-----------------------------------------------------------------------------
using System;
using System.Diagnostics.CodeAnalysis;
namespace System.AddIn.Contract
{
///
/// Empty == System.Reflection.Missing
/// Intrinsic == All Primitive types, System.String
///
public enum RemoteArgumentKind
{
Missing,
Intrinsic,
IntrinsicArray,
Contract
}
///
/// Similar to the COM Variant type, this class can be used to safely
/// pass Contract compliant types through the IRemoteTypeContract
/// RemoteArgument passes, by value, the "Convertible" types.
/// These are: int, uint, long, ulong, short, ushort, sbyte, byte, char
/// decimal, float, double, bool, DateTime, DBNull, Empty and String
///
[Serializable]
[SuppressMessage("Microsoft.Performance", "CA1815:OverrideEqualsAndOperatorEqualsOnValueTypes")]
public struct RemoteArgument
{
#region Private Fields
//this ("value") clearly breaks the rule of "tranistive closure" by
//having a field typed as System.Object. We re-enforce the rule
//by ensuring the only things that can be assigned here are either
//intrinsic types or IContracts, and *never* exposing the object.
//This should be the *ONLY* exception, ever, and allows the rule
//to be enforced everywhere else
private object _value;
//byref is changeable, can be set and unset....
private bool isByRef;
//the following two fields are "readonly" because once they
//are set they are not allowed to change.
private readonly RemoteArgumentKind remoteArgKind;
private readonly TypeCode intrinsicTypeCode;
#endregion
#region Static Creation Methods
///
/// With all the various intrinsic types, in order to avoid each consumer
/// of this method having to write the large switch statement to decide which constructor
/// to call, we wrote it for you in this helper method. All primitive types
/// implement IConvertible, as do enum types, which fit into integral primitives
/// String *is* included here though it is not strictly a primitive type.
/// Anything with its own type code is included. Anything with TypeCode.Object throws
///
///
///
/// This overload allows the caller to create a byref remote argument
///
///
///
///
/// This overload allows the caller to convert between intrinsic types. The returned
/// remote argument will contain the type code specified or this will throw.
///
///
///
///
///
/// All of these properties do the same thing:
/// On get, validate return and typecode, return if
/// appropriate, else throw InvalidOperationException
/// On set, isByRef MUST be true, then validate kind
/// and typecode and set value if appropriate, else
/// throw InvalidOperationException
///
#region Contract
public IContract ContractValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Contract &&
this.intrinsicTypeCode == TypeCode.Object)
{
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (IContract)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Contract &&
this.intrinsicTypeCode == TypeCode.Object)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Reflection.Missing
public System.Reflection.Missing MissingValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Missing &&
this.intrinsicTypeCode == TypeCode.Empty)
{
//only one possible return value...
return System.Reflection.Missing.Value;
}
throw new InvalidOperationException();
}
}
#endregion
#region Primitive Types -- CLS Compliant
///
/// A Note on the implementation: We could have used
/// a generic helper function to eliminate so much duplicated
/// code. We chose not to to avoid misuse of the generic argument
/// Explicitly coding all of these leaves nothing to interpretation
/// on the use of a function.
///
#region System.Boolean
public System.Boolean BooleanValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Boolean)
{
if (this._value == null)
return default(System.Boolean);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Boolean)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Boolean)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Byte
public System.Byte ByteValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Byte)
{
if (this._value == null)
return default(System.Byte);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Byte)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Byte)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Char
public System.Char CharValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Char)
{
if (this._value == null)
return default(System.Char);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Char)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Char)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.DateTime
public System.DateTime DateTimeValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.DateTime)
{
if (this._value == null)
return default(System.DateTime);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.DateTime)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.DateTime)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.DBNull
public System.DBNull DBNullValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.DBNull)
{
if (this._value == null)
return default(System.DBNull);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.DBNull)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.DBNull)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Decimal
public System.Decimal DecimalValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Decimal)
{
if (this._value == null)
return default(System.Decimal);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Decimal)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Decimal)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Double
public System.Double DoubleValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Double)
{
if (this._value == null)
return default(System.Double);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Double)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Double)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Int16
public System.Int16 Int16Value
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Int16)
{
if (this._value == null)
return default(System.Int16);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Int16)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Int16)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Int32
public System.Int32 Int32Value
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Int32)
{
if (this._value == null)
return default(System.Int32);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Int32)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Int32)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Int64
public System.Int64 Int64Value
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Int64)
{
if (this._value == null)
return default(System.Int64);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Int64)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Int64)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Single
public System.Single SingleValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Single)
{
if (this._value == null)
return default(System.Single);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Single)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Single)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.String
public System.String StringValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.String)
{
if (this._value == null)
return default(System.String);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.String)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.String)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#endregion
#region Intrinsic Types -- Non-CLS Compliant
#region System.SByte
[CLSCompliant(false)]
public System.SByte SByteValue
{
get
{
if(this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.SByte)
{
if (this._value == null)
return default(System.SByte);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.SByte)this._value;
}
throw new InvalidOperationException();
}
set
{
if(this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.SByte)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.UInt16
[CLSCompliant(false)]
public System.UInt16 UInt16Value
{
get
{
if(this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.UInt16)
{
if (this._value == null)
return default(System.UInt16);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.UInt16)this._value;
}
throw new InvalidOperationException();
}
set
{
if(this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.UInt16)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.UInt32
[CLSCompliant(false)]
public System.UInt32 UInt32Value
{
get
{
if(this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.UInt32)
{
if (this._value == null)
return default(System.UInt32);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.UInt32)this._value;
}
throw new InvalidOperationException();
}
set
{
if(this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.UInt32)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.UInt64
[CLSCompliant(false)]
public System.UInt64 UInt64Value
{
get
{
if(this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.UInt64)
{
if (this._value == null)
return default(System.UInt64);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.UInt64)this._value;
}
throw new InvalidOperationException();
}
set
{
if(this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.UInt64)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#endregion
#region IntrinsicArray
[SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]
public System.Array ArrayValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.IntrinsicArray &&
this.intrinsicTypeCode != TypeCode.Object)
{
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Array)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.IntrinsicArray &&
this.intrinsicTypeCode != TypeCode.Object)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#endregion
#endregion
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
///
/// Copyright (c) Microsoft Corporation. All Rights Reserved.
/// Information Contained Herein is Proprietary and Confidential.
///
//-----------------------------------------------------------------------------
using System;
using System.Diagnostics.CodeAnalysis;
namespace System.AddIn.Contract
{
///
/// Empty == System.Reflection.Missing
/// Intrinsic == All Primitive types, System.String
///
public enum RemoteArgumentKind
{
Missing,
Intrinsic,
IntrinsicArray,
Contract
}
///
/// Similar to the COM Variant type, this class can be used to safely
/// pass Contract compliant types through the IRemoteTypeContract
/// RemoteArgument passes, by value, the "Convertible" types.
/// These are: int, uint, long, ulong, short, ushort, sbyte, byte, char
/// decimal, float, double, bool, DateTime, DBNull, Empty and String
///
[Serializable]
[SuppressMessage("Microsoft.Performance", "CA1815:OverrideEqualsAndOperatorEqualsOnValueTypes")]
public struct RemoteArgument
{
#region Private Fields
//this ("value") clearly breaks the rule of "tranistive closure" by
//having a field typed as System.Object. We re-enforce the rule
//by ensuring the only things that can be assigned here are either
//intrinsic types or IContracts, and *never* exposing the object.
//This should be the *ONLY* exception, ever, and allows the rule
//to be enforced everywhere else
private object _value;
//byref is changeable, can be set and unset....
private bool isByRef;
//the following two fields are "readonly" because once they
//are set they are not allowed to change.
private readonly RemoteArgumentKind remoteArgKind;
private readonly TypeCode intrinsicTypeCode;
#endregion
#region Static Creation Methods
///
/// With all the various intrinsic types, in order to avoid each consumer
/// of this method having to write the large switch statement to decide which constructor
/// to call, we wrote it for you in this helper method. All primitive types
/// implement IConvertible, as do enum types, which fit into integral primitives
/// String *is* included here though it is not strictly a primitive type.
/// Anything with its own type code is included. Anything with TypeCode.Object throws
///
///
///
/// This overload allows the caller to create a byref remote argument
///
///
///
///
/// This overload allows the caller to convert between intrinsic types. The returned
/// remote argument will contain the type code specified or this will throw.
///
///
///
///
///
/// All of these properties do the same thing:
/// On get, validate return and typecode, return if
/// appropriate, else throw InvalidOperationException
/// On set, isByRef MUST be true, then validate kind
/// and typecode and set value if appropriate, else
/// throw InvalidOperationException
///
#region Contract
public IContract ContractValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Contract &&
this.intrinsicTypeCode == TypeCode.Object)
{
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (IContract)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Contract &&
this.intrinsicTypeCode == TypeCode.Object)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Reflection.Missing
public System.Reflection.Missing MissingValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Missing &&
this.intrinsicTypeCode == TypeCode.Empty)
{
//only one possible return value...
return System.Reflection.Missing.Value;
}
throw new InvalidOperationException();
}
}
#endregion
#region Primitive Types -- CLS Compliant
///
/// A Note on the implementation: We could have used
/// a generic helper function to eliminate so much duplicated
/// code. We chose not to to avoid misuse of the generic argument
/// Explicitly coding all of these leaves nothing to interpretation
/// on the use of a function.
///
#region System.Boolean
public System.Boolean BooleanValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Boolean)
{
if (this._value == null)
return default(System.Boolean);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Boolean)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Boolean)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Byte
public System.Byte ByteValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Byte)
{
if (this._value == null)
return default(System.Byte);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Byte)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Byte)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Char
public System.Char CharValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Char)
{
if (this._value == null)
return default(System.Char);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Char)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Char)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.DateTime
public System.DateTime DateTimeValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.DateTime)
{
if (this._value == null)
return default(System.DateTime);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.DateTime)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.DateTime)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.DBNull
public System.DBNull DBNullValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.DBNull)
{
if (this._value == null)
return default(System.DBNull);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.DBNull)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.DBNull)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Decimal
public System.Decimal DecimalValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Decimal)
{
if (this._value == null)
return default(System.Decimal);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Decimal)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Decimal)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Double
public System.Double DoubleValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Double)
{
if (this._value == null)
return default(System.Double);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Double)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Double)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Int16
public System.Int16 Int16Value
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Int16)
{
if (this._value == null)
return default(System.Int16);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Int16)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Int16)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Int32
public System.Int32 Int32Value
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Int32)
{
if (this._value == null)
return default(System.Int32);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Int32)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Int32)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Int64
public System.Int64 Int64Value
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Int64)
{
if (this._value == null)
return default(System.Int64);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Int64)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Int64)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.Single
public System.Single SingleValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Single)
{
if (this._value == null)
return default(System.Single);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Single)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.Single)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.String
public System.String StringValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.String)
{
if (this._value == null)
return default(System.String);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.String)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.String)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#endregion
#region Intrinsic Types -- Non-CLS Compliant
#region System.SByte
[CLSCompliant(false)]
public System.SByte SByteValue
{
get
{
if(this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.SByte)
{
if (this._value == null)
return default(System.SByte);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.SByte)this._value;
}
throw new InvalidOperationException();
}
set
{
if(this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.SByte)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.UInt16
[CLSCompliant(false)]
public System.UInt16 UInt16Value
{
get
{
if(this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.UInt16)
{
if (this._value == null)
return default(System.UInt16);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.UInt16)this._value;
}
throw new InvalidOperationException();
}
set
{
if(this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.UInt16)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.UInt32
[CLSCompliant(false)]
public System.UInt32 UInt32Value
{
get
{
if(this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.UInt32)
{
if (this._value == null)
return default(System.UInt32);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.UInt32)this._value;
}
throw new InvalidOperationException();
}
set
{
if(this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.UInt32)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#region System.UInt64
[CLSCompliant(false)]
public System.UInt64 UInt64Value
{
get
{
if(this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.UInt64)
{
if (this._value == null)
return default(System.UInt64);
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.UInt64)this._value;
}
throw new InvalidOperationException();
}
set
{
if(this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.Intrinsic &&
this.intrinsicTypeCode == TypeCode.UInt64)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#endregion
#region IntrinsicArray
[SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]
public System.Array ArrayValue
{
get
{
if (this.remoteArgKind == RemoteArgumentKind.IntrinsicArray &&
this.intrinsicTypeCode != TypeCode.Object)
{
//do explicit cast here instead of "as"
//because we *want* it to throw if it is a
//bad cast. It would mean an invalid state
//of the struct.
return (System.Array)this._value;
}
throw new InvalidOperationException();
}
set
{
if (this.isByRef == true &&
this.remoteArgKind == RemoteArgumentKind.IntrinsicArray &&
this.intrinsicTypeCode != TypeCode.Object)
{
this._value = value;
}
else
{
throw new InvalidOperationException();
}
}
}
#endregion
#endregion
#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
- ColumnResizeAdorner.cs
- TileBrush.cs
- CodeRemoveEventStatement.cs
- Switch.cs
- RawStylusInputReport.cs
- SqlWebEventProvider.cs
- MasterPage.cs
- ReaderContextStackData.cs
- CookielessData.cs
- WebPartChrome.cs
- TableLayoutRowStyleCollection.cs
- HtmlShimManager.cs
- XmlNavigatorStack.cs
- Tuple.cs
- _ReceiveMessageOverlappedAsyncResult.cs
- Int32RectConverter.cs
- DataGridComponentEditor.cs
- SimpleTextLine.cs
- EnumMember.cs
- BuildResult.cs
- TreeNodeConverter.cs
- WebPartCloseVerb.cs
- HttpServerVarsCollection.cs
- __FastResourceComparer.cs
- BoundPropertyEntry.cs
- CollectionViewProxy.cs
- PrintController.cs
- BufferedGraphicsContext.cs
- SchemaConstraints.cs
- RemotingConfigParser.cs
- CollectionEditorDialog.cs
- Native.cs
- ButtonStandardAdapter.cs
- NonClientArea.cs
- contentDescriptor.cs
- UnsignedPublishLicense.cs
- HtmlPanelAdapter.cs
- DecoderReplacementFallback.cs
- WebPartVerbCollection.cs
- AmbientValueAttribute.cs
- OptimizerPatterns.cs
- BuilderPropertyEntry.cs
- IsolatedStorageFilePermission.cs
- ExceptQueryOperator.cs
- TemplateColumn.cs
- TimelineGroup.cs
- ToolStripItemClickedEventArgs.cs
- RoutingConfiguration.cs
- LogSwitch.cs
- HotSpot.cs
- GridView.cs
- KeyboardNavigation.cs
- TabControlCancelEvent.cs
- UncommonField.cs
- XPathAncestorQuery.cs
- ProfessionalColorTable.cs
- IMembershipProvider.cs
- APCustomTypeDescriptor.cs
- ComplexBindingPropertiesAttribute.cs
- HttpCacheVaryByContentEncodings.cs
- Panel.cs
- BufferedOutputStream.cs
- HttpHandlerAction.cs
- xdrvalidator.cs
- X509AsymmetricSecurityKey.cs
- ContractsBCL.cs
- sqlmetadatafactory.cs
- Sequence.cs
- FormatException.cs
- DynamicResourceExtension.cs
- ConcurrentStack.cs
- PeerTransportElement.cs
- SecurityKeyEntropyMode.cs
- TextTabProperties.cs
- CallbackException.cs
- WebPartChrome.cs
- DataGridViewCellLinkedList.cs
- Int32KeyFrameCollection.cs
- BroadcastEventHelper.cs
- Application.cs
- ObjectIDGenerator.cs
- FloaterBaseParagraph.cs
- ListenerConstants.cs
- Timer.cs
- FontFamilyValueSerializer.cs
- Panel.cs
- MouseEvent.cs
- CodeVariableDeclarationStatement.cs
- MaskedTextProvider.cs
- ContextBase.cs
- SerializeAbsoluteContext.cs
- ForceCopyBuildProvider.cs
- ListViewItemEventArgs.cs
- DataSetUtil.cs
- ProtectedConfigurationProviderCollection.cs
- Environment.cs
- TemporaryBitmapFile.cs
- UpDownEvent.cs
- SecurityTokenProvider.cs
- ExpressionEvaluator.cs