static public void Assert(bool condition)
{
BCLDebug.Assert(condition);
}
static public void Assert(bool condition, string message)
{
BCLDebug.Assert(condition, message);
}
/// <summary>
/// Try to get the value of the switch.
/// </summary>
/// <param name="switchName">The name of the switch</param>
/// <param name="isEnabled">A variable where to place the value of the switch</param>
/// <returns>A return value of true represents that the switch was set and <paramref name="isEnabled"/> contains the value of the switch</returns>
public static bool TryGetSwitch(string switchName, out bool isEnabled)
{
if (switchName == null)
{
throw new ArgumentNullException("switchName");
}
if (switchName.Length == 0)
{
throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "switchName");
}
if (s_defaultsInitialized == false)
{
InitializeDefaultSwitchValues();
}
#if DEBUG
BCLDebug.Assert(s_defaultsInitialized == true, "AppContext defaults should have been initialized.");
#endif
// By default, the switch is not enabled.
isEnabled = false;
SwitchValueState switchValue;
lock (s_switchMap)
{
if (s_switchMap.TryGetValue(switchName, out switchValue))
{
// The value is in the dictionary.
// There are 3 cases here:
// 1. The value of the switch is 'unknown'. This means that the switch name is not known to the system (either via defaults or checking overrides).
// Example: This is the case when, during a servicing event, a switch is added to System.Xml which ships before mscorlib. The value of the switch
// Will be unknown to mscorlib.dll and we want to prevent checking the overrides every time we check this switch
// 2. The switch has a valid value AND we have read the overrides for it
// Example: TryGetSwitch is called for a switch set via SetSwitch
// 3. The switch has the default value and we need to check for overrides
// Example: TryGetSwitch is called for the first time for a switch that has a default value
// 1. The value is unknown
if (switchValue == SwitchValueState.UnknownValue)
{
isEnabled = false;
return(false);
}
// We get the value of isEnabled from the value that we stored in the dictionary
isEnabled = (switchValue & SwitchValueState.HasTrueValue) == SwitchValueState.HasTrueValue;
// 2. The switch has a valid value AND we have checked for overrides
if ((switchValue & SwitchValueState.HasLookedForOverride) == SwitchValueState.HasLookedForOverride)
{
return(true);
}
// 3. The switch has a valid value, but we need to check for overrides.
// Regardless of whether or not the switch has an override, we need to update the value to reflect
// the fact that we checked for overrides.
bool overrideValue;
if (AppContextDefaultValues.TryGetSwitchOverride(switchName, out overrideValue))
{
// we found an override!
isEnabled = overrideValue;
}
// Update the switch in the dictionary to mark it as 'checked for override'
s_switchMap[switchName] = (isEnabled ? SwitchValueState.HasTrueValue : SwitchValueState.HasFalseValue)
| SwitchValueState.HasLookedForOverride;
return(true);
}
else
{
// The value is NOT in the dictionary
// In this case we need to see if we have an override defined for the value.
// There are 2 cases:
// 1. The value has an override specified. In this case we need to add the value to the dictionary
// and mark it as checked for overrides
// Example: In a servicing event, System.Xml introduces a switch and an override is specified.
// The value is not found in mscorlib (as System.Xml ships independent of mscorlib)
// 2. The value does not have an override specified
// In this case, we want to capture the fact that we looked for a value and found nothing by adding
// an entry in the dictionary with the 'sentinel' value of 'SwitchValueState.UnknownValue'.
// Example: This will prevent us from trying to find overrides for values that we don't have in the dictionary
// 1. The value has an override specified.
bool overrideValue;
if (AppContextDefaultValues.TryGetSwitchOverride(switchName, out overrideValue))
{
isEnabled = overrideValue;
// Update the switch in the dictionary to mark it as 'checked for override'
s_switchMap[switchName] = (isEnabled ? SwitchValueState.HasTrueValue : SwitchValueState.HasFalseValue)
| SwitchValueState.HasLookedForOverride;
return(true);
}
// 2. The value does not have an override.
s_switchMap[switchName] = SwitchValueState.UnknownValue;
}
}
return(false); // we did not find a value for the switch
}
// Note: Do not add any code in this ctor because it is not called
// when we set up _sharedStatics via AppDomain::SetupSharedStatics
private SharedStatics()
{
BCLDebug.Assert(false, "SharedStatics..ctor() is never called.");
}
// This method should never be called. Its sole purpose is to shut up the compiler
// because it warns about private fields that are never used. Most of these fields
// are used in unmanaged code.
#if _DEBUG
internal IntPtr NeverCallThis()
{
m_ptr = (IntPtr)0;
BCLDebug.Assert(false, "NeverCallThis");
return(m_ptr);
}
// Return the Unicode category for Unicode character <= 0x00ff.
private static UnicodeCategory GetLatin1UnicodeCategory(char ch)
{
BCLDebug.Assert(IsLatin1(ch), "Char.GetLatin1UnicodeCategory(): ch should be <= 007f");
return((UnicodeCategory)(categoryForLatin1[(int)ch]));
}
private static HashEntry GetHashEntry(Type enumType)
{
HashEntry hashEntry = (HashEntry)fieldInfoHash[enumType];
if (hashEntry == null)
{
// To reduce the workingset we clear the hashtable when a threshold number of elements are inserted.
if (fieldInfoHash.Count > maxHashElements)
{
fieldInfoHash.Clear();
}
ulong[] values = null;
String[] names = null;
BCLDebug.Assert(enumType.BaseType == typeof(Enum), "Base type must of type Enum");
if (enumType.BaseType == typeof(Enum))
{
InternalGetEnumValues(enumType, ref values, ref names);
}
// If we switch over to EnumBuilder, this code path will be required.
else
{
// fall back on reflection for odd cases
FieldInfo[] flds = enumType.GetFields(BindingFlags.Static | BindingFlags.Public);
values = new ulong[flds.Length];
names = new String[flds.Length];
for (int i = 0; i < flds.Length; i++)
{
names[i] = flds[i].Name;
values[i] = ToUInt64(flds[i].GetValue(null));
}
// Insertion Sort these values in ascending order.
// We use this O(n^2) algorithm, but it turns out that most of the time the elements are already in sorted order and
// the common case performance will be faster than quick sorting this.
for (int i = 1; i < values.Length; i++)
{
int j = i;
String tempStr = names[i];
ulong val = values[i];
bool exchanged = false;
// Since the elements are sorted we only need to do one comparision, we keep the check for j inside the loop.
while (values[j - 1] > val)
{
names[j] = names[j - 1];
values[j] = values[j - 1];
j--;
exchanged = true;
if (j == 0)
{
break;
}
}
if (exchanged)
{
names[j] = tempStr;
values[j] = val;
}
}
}
hashEntry = new HashEntry(names, values);
fieldInfoHash[enumType] = hashEntry;
}
return(hashEntry);
}
public void NotifyEvent(ConfigEvents nEvent)
{
BCLDebug.Trace("REMOTE", "NotifyEvent " + ((Enum)nEvent).ToString() + "\n");
}
// GetRealObject uses the data we have in m_data and m_unityType to do a lookup on the correct
// object to return. We have specific code here to handle the different types which we support.
// The reflection types (Assembly, Module, and Type) have to be looked up through their static
// accessors by name.
public virtual Object GetRealObject(StreamingContext context)
{
Assembly assem;
BCLDebug.Trace("SER", "[GetRealObject] UnityType:", m_unityType);
switch (m_unityType)
{
case EmptyUnity:
BCLDebug.Trace("SER", "[GetRealObject]Returning Empty.Value");
BCLDebug.Trace("SER", "[GetRealObject]Empty's value is: ", Empty.Value, "||");
return(Empty.Value);
case NullUnity:
return(DBNull.Value);
case MissingUnity:
return(Missing.Value);
case RuntimeTypeUnity:
if (m_data == null || m_data.Length == 0 || m_assemName == null)
{
BCLDebug.Trace("SER", "UnitySerializationHolder.GetRealObject Type. Data is: ", m_data);
throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientDeserializationState"));
}
if (m_assemName.Length == 0)
{
return(RuntimeType.GetTypeInternal(m_data, false, false, false));
}
assem = FormatterServices.LoadAssemblyFromString(m_assemName);
if (assem == null)
{
BCLDebug.Trace("SER", "UnitySerializationHolder.GetRealObject Type. AssemblyName is: ", m_assemName, " but we can't load it.");
throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientDeserializationState"));
}
Type t = assem.GetTypeInternal(m_data, false, false, false);
return(t);
case ModuleUnity:
if (m_data == null || m_data.Length == 0 || m_assemName == null)
{
BCLDebug.Trace("SER", "UnitySerializationHolder.GetRealObject Module. Data is: ", m_data);
throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientDeserializationState"));
}
assem = FormatterServices.LoadAssemblyFromString(m_assemName);
if (assem == null)
{
BCLDebug.Trace("SER", "UnitySerializationHolder.GetRealObject Module. AssemblyName is: ", m_assemName, " but we can't load it.");
throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientDeserializationState"));
}
Module namedModule = assem.GetModule(m_data);
if (namedModule == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_UnableToFindModule"));
}
return(namedModule);
case AssemblyUnity:
if (m_data == null || m_data.Length == 0 || m_assemName == null)
{
BCLDebug.Log("UnitySerializationHolder.GetRealObject. Assembly. Data is: " + ((m_data == null)?"<null>":m_data));
throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientDeserializationState"));
}
assem = FormatterServices.LoadAssemblyFromString(m_assemName);
if (assem == null)
{
BCLDebug.Trace("SER", "UnitySerializationHolder.GetRealObject Module. AssemblyName is: ", m_assemName, " but we can't load it.");
throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientDeserializationState"));
}
return(assem);
default:
//This should never happen because we only use the class internally.
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidUnity"));
}
}
private static String InternalFormattedHexString(Object value)
{
TypeCode typeCode = Convert.GetTypeCode(value);
switch (typeCode)
{
case TypeCode.SByte:
{
Byte result = (byte)(sbyte)value;
return(result.ToString("X2", null));
}
case TypeCode.Byte:
{
Byte result = (byte)value;
return(result.ToString("X2", null));
}
case TypeCode.Int16:
{
UInt16 result = (UInt16)(Int16)value;
return(result.ToString("X4", null));
}
case TypeCode.UInt16:
{
UInt16 result = (UInt16)value;
return(result.ToString("X4", null));
}
case TypeCode.UInt32:
{
UInt32 result = (UInt32)value;
return(result.ToString("X8", null));
}
case TypeCode.Int32:
{
UInt32 result = (UInt32)(int)value;
return(result.ToString("X8", null));
}
case TypeCode.UInt64:
{
UInt64 result = (UInt64)value;
return(result.ToString("X16", null));
}
case TypeCode.Int64:
{
UInt64 result = (UInt64)(Int64)value;
return(result.ToString("X16", null));
}
// All unsigned types will be directly cast
default:
BCLDebug.Assert(false, "Invalid Object type in Format");
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_UnknownEnumType"));
}
}
// Compares this enum and the object. The have to be of the same type or a ArgumentException is thrown
// Returns 0 if equal, -1 if less than, or 1 greater then the target
/// <include file='doc\Enum.uex' path='docs/doc[@for="Enum.CompareTo"]/*' />
public int CompareTo(Object target)
{
// Validate the parameters
if (target == null)
{
return(1);
}
// Check if both of them are of the same type
Type thisType = this.GetType();
Type targetType = target.GetType();
if (thisType != targetType)
{
throw new ArgumentException(String.Format(Environment.GetResourceString("Arg_EnumAndObjectMustBeSameType"),
targetType.ToString(), thisType.ToString()));
}
FieldInfo thisField = GetValueField(thisType);
FieldInfo targetField = GetValueField(targetType);
// Retrieve the value from the field.
Object thisResult = ((RuntimeFieldInfo)thisField).InternalGetValue(this, false);
Object targetResult = ((RuntimeFieldInfo)targetField).InternalGetValue(target, false);
TypeCode typeCode = this.GetTypeCode();
switch (typeCode)
{
case TypeCode.Int32:
case TypeCode.SByte:
case TypeCode.Int16:
case TypeCode.Int64:
{
Int64 result = Convert.ToInt64(thisResult);
Int64 compareTo = Convert.ToInt64(targetResult);
if (result == compareTo)
{
return(0);
}
if (result < compareTo)
{
return(-1);
}
else
{
return(1);
}
}
case TypeCode.UInt32:
case TypeCode.Byte:
case TypeCode.UInt16:
case TypeCode.UInt64:
{
UInt64 result = Convert.ToUInt64(thisResult);
UInt64 compareTo = Convert.ToUInt64(targetResult);
if (result == compareTo)
{
return(0);
}
if (result < compareTo)
{
return(-1);
}
else
{
return(1);
}
}
default:
BCLDebug.Assert(false, "Invalid switch case for CompareTo function");
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_UnknownEnumType"));
}
}
//
// This function will convert an ExceptionResource enum value to the resource string.
//
internal static string GetResourceName(ExceptionResource resource)
{
string resourceName = null;
switch (resource)
{
case ExceptionResource.Argument_ImplementIComparable:
resourceName = "Argument_ImplementIComparable";
break;
case ExceptionResource.Argument_AddingDuplicate:
resourceName = "Argument_AddingDuplicate";
break;
case ExceptionResource.ArgumentOutOfRange_BiggerThanCollection:
resourceName = "ArgumentOutOfRange_BiggerThanCollection";
break;
case ExceptionResource.ArgumentOutOfRange_Count:
resourceName = "ArgumentOutOfRange_Count";
break;
case ExceptionResource.ArgumentOutOfRange_Index:
resourceName = "ArgumentOutOfRange_Index";
break;
case ExceptionResource.ArgumentOutOfRange_InvalidThreshold:
resourceName = "ArgumentOutOfRange_InvalidThreshold";
break;
case ExceptionResource.ArgumentOutOfRange_ListInsert:
resourceName = "ArgumentOutOfRange_ListInsert";
break;
case ExceptionResource.ArgumentOutOfRange_NeedNonNegNum:
resourceName = "ArgumentOutOfRange_NeedNonNegNum";
break;
case ExceptionResource.ArgumentOutOfRange_SmallCapacity:
resourceName = "ArgumentOutOfRange_SmallCapacity";
break;
case ExceptionResource.Arg_ArrayPlusOffTooSmall:
resourceName = "Arg_ArrayPlusOffTooSmall";
break;
case ExceptionResource.Arg_RankMultiDimNotSupported:
resourceName = "Arg_RankMultiDimNotSupported";
break;
case ExceptionResource.Arg_NonZeroLowerBound:
resourceName = "Arg_NonZeroLowerBound";
break;
case ExceptionResource.Argument_InvalidArrayType:
resourceName = "Argument_InvalidArrayType";
break;
case ExceptionResource.Argument_InvalidOffLen:
resourceName = "Argument_InvalidOffLen";
break;
case ExceptionResource.Argument_ItemNotExist:
resourceName = "Argument_ItemNotExist";
break;
case ExceptionResource.InvalidOperation_CannotRemoveFromStackOrQueue:
resourceName = "InvalidOperation_CannotRemoveFromStackOrQueue";
break;
case ExceptionResource.InvalidOperation_EmptyQueue:
resourceName = "InvalidOperation_EmptyQueue";
break;
case ExceptionResource.InvalidOperation_EnumOpCantHappen:
resourceName = "InvalidOperation_EnumOpCantHappen";
break;
case ExceptionResource.InvalidOperation_EnumFailedVersion:
resourceName = "InvalidOperation_EnumFailedVersion";
break;
case ExceptionResource.InvalidOperation_EmptyStack:
resourceName = "InvalidOperation_EmptyStack";
break;
case ExceptionResource.InvalidOperation_EnumNotStarted:
resourceName = "InvalidOperation_EnumNotStarted";
break;
case ExceptionResource.InvalidOperation_EnumEnded:
resourceName = "InvalidOperation_EnumEnded";
break;
case ExceptionResource.NotSupported_KeyCollectionSet:
resourceName = "NotSupported_KeyCollectionSet";
break;
case ExceptionResource.NotSupported_ReadOnlyCollection:
resourceName = "NotSupported_ReadOnlyCollection";
break;
case ExceptionResource.NotSupported_ValueCollectionSet:
resourceName = "NotSupported_ValueCollectionSet";
break;
case ExceptionResource.NotSupported_SortedListNestedWrite:
resourceName = "NotSupported_SortedListNestedWrite";
break;
case ExceptionResource.Serialization_InvalidOnDeser:
resourceName = "Serialization_InvalidOnDeser";
break;
case ExceptionResource.Serialization_MissingKeyValuePairs:
resourceName = "Serialization_MissingKeyValuePairs";
break;
case ExceptionResource.Serialization_NullKey:
resourceName = "Serialization_NullKey";
break;
case ExceptionResource.Argument_InvalidType:
resourceName = "Argument_InvalidType";
break;
case ExceptionResource.Argument_InvalidArgumentForComparison:
resourceName = "Argument_InvalidArgumentForComparison";
break;
case ExceptionResource.InvalidOperation_NoValue:
resourceName = "InvalidOperation_NoValue";
break;
case ExceptionResource.InvalidOperation_RegRemoveSubKey:
resourceName = "InvalidOperation_RegRemoveSubKey";
break;
case ExceptionResource.Arg_RegSubKeyAbsent:
resourceName = "Arg_RegSubKeyAbsent";
break;
case ExceptionResource.Arg_RegSubKeyValueAbsent:
resourceName = "Arg_RegSubKeyValueAbsent";
break;
case ExceptionResource.Arg_RegKeyDelHive:
resourceName = "Arg_RegKeyDelHive";
break;
case ExceptionResource.Security_RegistryPermission:
resourceName = "Security_RegistryPermission";
break;
case ExceptionResource.Arg_RegSetStrArrNull:
resourceName = "Arg_RegSetStrArrNull";
break;
case ExceptionResource.Arg_RegSetMismatchedKind:
resourceName = "Arg_RegSetMismatchedKind";
break;
case ExceptionResource.UnauthorizedAccess_RegistryNoWrite:
resourceName = "UnauthorizedAccess_RegistryNoWrite";
break;
case ExceptionResource.ObjectDisposed_RegKeyClosed:
resourceName = "ObjectDisposed_RegKeyClosed";
break;
case ExceptionResource.Arg_RegKeyStrLenBug:
resourceName = "Arg_RegKeyStrLenBug";
break;
case ExceptionResource.Argument_InvalidRegistryKeyPermissionCheck:
resourceName = "Argument_InvalidRegistryKeyPermissionCheck";
break;
case ExceptionResource.NotSupported_InComparableType:
resourceName = "NotSupported_InComparableType";
break;
default:
BCLDebug.Assert(false, "The enum value is not defined, please checked ExceptionArgumentName Enum.");
return(string.Empty);
}
return(resourceName);
}
//
// This function will convert an ExceptionArgument enum value to the argument name string.
//
internal static string GetArgumentName(ExceptionArgument argument)
{
string argumentName = null;
switch (argument)
{
case ExceptionArgument.array:
argumentName = "array";
break;
case ExceptionArgument.arrayIndex:
argumentName = "arrayIndex";
break;
case ExceptionArgument.capacity:
argumentName = "capacity";
break;
case ExceptionArgument.collection:
argumentName = "collection";
break;
case ExceptionArgument.list:
argumentName = "list";
break;
case ExceptionArgument.converter:
argumentName = "converter";
break;
case ExceptionArgument.count:
argumentName = "count";
break;
case ExceptionArgument.dictionary:
argumentName = "dictionary";
break;
case ExceptionArgument.dictionaryCreationThreshold:
argumentName = "dictionaryCreationThreshold";
break;
case ExceptionArgument.index:
argumentName = "index";
break;
case ExceptionArgument.info:
argumentName = "info";
break;
case ExceptionArgument.key:
argumentName = "key";
break;
case ExceptionArgument.match:
argumentName = "match";
break;
case ExceptionArgument.obj:
argumentName = "obj";
break;
case ExceptionArgument.queue:
argumentName = "queue";
break;
case ExceptionArgument.stack:
argumentName = "stack";
break;
case ExceptionArgument.startIndex:
argumentName = "startIndex";
break;
case ExceptionArgument.value:
argumentName = "value";
break;
case ExceptionArgument.name:
argumentName = "name";
break;
case ExceptionArgument.mode:
argumentName = "mode";
break;
default:
BCLDebug.Assert(false, "The enum value is not defined, please checked ExceptionArgumentName Enum.");
return(string.Empty);
}
return(argumentName);
}
static public void Fail(string message)
{
BCLDebug.Assert(false, message);
}
public static bool IsDefined(Type enumType, Object value)
{
if (enumType == null)
{
throw new ArgumentNullException("enumType");
}
if (!(enumType is RuntimeType))
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "enumType");
}
if (!enumType.IsEnum)
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeEnum"), "enumType");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
// Check if both of them are of the same type
Type valueType = value.GetType();
if (!(valueType is RuntimeType))
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "valueType");
}
Type underlyingType = GetUnderlyingType(enumType);
// If the value is an Enum then we need to extract the underlying value from it
if (valueType.IsEnum)
{
Type valueUnderlyingType = GetUnderlyingType(valueType);
if (valueType != enumType)
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumAndObjectMustBeSameType"), valueType.ToString(), enumType.ToString()));
}
valueType = valueUnderlyingType;
}
else
// The value must be of the same type as the Underlying type of the Enum
if ((valueType != underlyingType) && (valueType != stringType))
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumUnderlyingTypeAndObjectMustBeSameType"), valueType.ToString(), underlyingType.ToString()));
}
// If String is passed in
if (valueType == stringType)
{
// Get all of the Fields
String[] names = GetHashEntry(enumType).names;
for (int i = 0; i < names.Length; i++)
{
if (names[i].Equals((string)value))
{
return(true);
}
}
return(false);
}
ulong[] values = GetHashEntry(enumType).values;
// Look at the 8 possible enum base classes
if (valueType == intType || valueType == typeof(short) || valueType == typeof(ushort) || valueType == typeof(byte) || valueType == typeof(sbyte) || valueType == typeof(uint) || valueType == typeof(long) || valueType == typeof(ulong))
{
ulong val = ToUInt64(value);
return(BinarySearch(values, val) >= 0);
}
BCLDebug.Assert(false, "Unknown enum type");
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_UnknownEnumType"));
}
// equals returns true IIF the delegate is not null and has the
// same target, method and invocation list as this object
public override sealed bool Equals(Object obj)
{
if (obj == null || !InternalEqualTypes(this, obj))
{
return(false);
}
MulticastDelegate d = obj as MulticastDelegate;
if (d == null)
{
return(false);
}
if (_invocationCount != (IntPtr)0)
{
// there are 4 kind of delegate kinds that fall into this bucket
// 1- Multicast (_invocationList is Object[])
// 2- Secure (_invocationList is Delegate)
// 3- Unmanaged FntPtr (_invocationList == null)
// 4- Open virtual (_invocationCount == MethodDesc of target)
if (_invocationList == null)
{
if (IsUnmanagedFunctionPtr())
{
if (!d.IsUnmanagedFunctionPtr())
{
return(false);
}
if (_methodPtr != d._methodPtr)
{
return(false);
}
if (GetUnmanagedCallSite() != d.GetUnmanagedCallSite())
{
return(false);
}
return(true);
}
return(base.Equals(obj));
}
else
{
if ((_invocationList as Delegate) != null)
{
// this is a secure delegate so we need to unwrap and check the inner one
return(_invocationList.Equals(obj));
}
else
{
BCLDebug.Assert((_invocationList as Object[]) != null, "empty invocation list on multicast delegate");
return(InvocationListEquals(d));
}
}
}
else
{
// among the several kind of delegates falling into this bucket one has got a non
// empty _invocationList (open static with special sig)
// to be equals we need to check that _invocationList matches (both null is fine)
// and call the base.Equals()
if (_invocationList != null)
{
if (!_invocationList.Equals(d._invocationList))
{
return(false);
}
return(base.Equals(d));
}
// now we know 'this' is not a special one, so we can work out what the other is
if (d._invocationList != null || d._invocationCount != (IntPtr)0)
{
if ((d._invocationList as Delegate) != null)
{
// this is a secure delegate so we need to unwrap and check the inner one
return((d._invocationList as Delegate).Equals(this));
}
return(false);
}
// now we can call on the base
return(base.Equals(d));
}
}
private Delegate GetDelegate(DelegateEntry de)
{
Delegate d;
if (de.methodName == null || de.methodName.Length == 0)
{
throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientDeserializationState"));
}
Assembly assem = FormatterServices.LoadAssemblyFromStringNoThrow(de.assembly);
if (assem == null)
{
BCLDebug.Trace("SER", "[DelegateSerializationHolder.ctor]: Unable to find assembly for TargetType: ", de.assembly);
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_AssemblyNotFound"), de.assembly));
}
Type type = assem.GetTypeInternal(de.type, false, false, false);
assem = FormatterServices.LoadAssemblyFromStringNoThrow(de.targetTypeAssembly);
if (assem == null)
{
BCLDebug.Trace("SER", "[DelegateSerializationHolder.ctor]: Unable to find assembly for TargetType: ", de.targetTypeAssembly);
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_AssemblyNotFound"), de.targetTypeAssembly));
}
Type targetType = assem.GetTypeInternal(de.targetTypeName, false, false, false);
if (de.target == null && targetType == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientDeserializationState"));
}
if (type == null)
{
BCLDebug.Trace("SER", "[DelegateSerializationHolder.GetRealObject]Missing Type");
throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientDeserializationState"));
}
if (targetType == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientDeserializationState"));
}
Object target = null;
if (de.target != null) //We have a delegate to a non-static object
{
target = RemotingServices.CheckCast(de.target, targetType);
d = Delegate.CreateDelegate(type, target, de.methodName);
}
else
{
//For a static delegate
d = Delegate.CreateDelegate(type, targetType, de.methodName);
}
// We will refuse to create delegates to methods that are non-public.
MethodInfo mi = d.Method;
if (mi != null)
{
if (!mi.IsPublic)
{
throw new SerializationException(
Environment.GetResourceString("Serialization_RefuseNonPublicDelegateCreation"));
}
}
return(d);
}