Code:
/ 4.0 / 4.0 / untmp / 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.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- BaseParagraph.cs
- WebContentFormatHelper.cs
- HostProtectionException.cs
- SystemIcmpV6Statistics.cs
- ObjectKeyFrameCollection.cs
- LogEntryHeaderv1Deserializer.cs
- MostlySingletonList.cs
- Visitor.cs
- RtfToken.cs
- ExecutionEngineException.cs
- Serializer.cs
- CollectionEditor.cs
- InternalConfigRoot.cs
- WriterOutput.cs
- XmlSchemaExporter.cs
- RadioButton.cs
- RunClient.cs
- TranslateTransform3D.cs
- XmlDataCollection.cs
- WizardPanel.cs
- TargetControlTypeCache.cs
- Compiler.cs
- ParameterCollection.cs
- XmlAnyElementAttributes.cs
- ApplicationSecurityInfo.cs
- userdatakeys.cs
- ChtmlImageAdapter.cs
- HandleTable.cs
- Material.cs
- WindowShowOrOpenTracker.cs
- HotSpot.cs
- TemplatedMailWebEventProvider.cs
- NativeMethodsOther.cs
- KeyValuePairs.cs
- ButtonChrome.cs
- CodeCatchClauseCollection.cs
- DefaultHttpHandler.cs
- Soap.cs
- ConfigurationCollectionAttribute.cs
- PrintDialog.cs
- ModifierKeysValueSerializer.cs
- Propagator.cs
- StringAttributeCollection.cs
- Adorner.cs
- BindToObject.cs
- LiteralText.cs
- RequestTimeoutManager.cs
- RowUpdatedEventArgs.cs
- TreePrinter.cs
- RowParagraph.cs
- FormParameter.cs
- PerfCounters.cs
- InitiatorSessionSymmetricMessageSecurityProtocol.cs
- CategoryValueConverter.cs
- ListViewHitTestInfo.cs
- WindowVisualStateTracker.cs
- JoinSymbol.cs
- VsPropertyGrid.cs
- LocalValueEnumerator.cs
- COM2PropertyBuilderUITypeEditor.cs
- FileUpload.cs
- AccessText.cs
- MsmqIntegrationValidationBehavior.cs
- PersistNameAttribute.cs
- BinaryObjectReader.cs
- Update.cs
- transactioncontext.cs
- _ListenerResponseStream.cs
- IList.cs
- TreeNodeBinding.cs
- Bezier.cs
- Border.cs
- MenuAdapter.cs
- ObjectQueryProvider.cs
- TraceUtils.cs
- TypeSystem.cs
- SymbolTable.cs
- EnumBuilder.cs
- Error.cs
- Quad.cs
- CookieHandler.cs
- QueryAsyncResult.cs
- ComboBoxItem.cs
- ServicePoint.cs
- RegistryExceptionHelper.cs
- InternalTypeHelper.cs
- COM2PropertyPageUITypeConverter.cs
- SourceFilter.cs
- StructuredTypeInfo.cs
- IdentifierCollection.cs
- PolicyStatement.cs
- FreezableOperations.cs
- Application.cs
- CodeSnippetStatement.cs
- HttpHandler.cs
- FrameAutomationPeer.cs
- XmlDownloadManager.cs
- DataBoundControlActionList.cs
- CmsInterop.cs
- Color.cs