public TypedReference GetNextArg(RuntimeTypeHandle rth) { if (sigPtr != IntPtr.Zero) { // This is an ordinary ArgIterator capable of determining // types from a signature. Just do a regular GetNextArg. return GetNextArg(); } else { // Prevent abuse of this API with a default ArgIterator (it // doesn't require permission to create a zero-inited value // type). Check that ArgPtr isn't zero or this API will allow a // malicious caller to increment the pointer to an arbitrary // location in memory and read the contents. if (ArgPtr == IntPtr.Zero) throw new ArgumentNullException(); TypedReference result = new TypedReference (); // reference to TypedReference is banned, so have to pass result as pointer unsafe { InternalGetNextArg(&result, rth.GetRuntimeType()); } return result; } }
public static int test_0_typedref() { int i = 5; System.TypedReference r = __makeref(i); System.Type t = __reftype(r); if (t != typeof(int)) { return(1); } int j = __refvalue(r, int); if (j != 5) { return(2); } try { object o = __refvalue(r, object); } catch (InvalidCastException) { } return(0); }
public static void SetTypedReference (TypedReference target, object value) { if (value == null) { throw new ArgumentNullException ("value"); } throw new NotImplementedException (); }
public override unsafe object GetValueDirect(TypedReference obj) { if (obj.IsNull) { throw new ArgumentException(Environment.GetResourceString("Arg_TypedReference_Null")); } return RuntimeFieldHandle.GetValueDirect(this, (RuntimeType) this.FieldType, (void*) &obj, (RuntimeType) this.DeclaringType); }
public static System.IntPtr AddressOf <T>(this T t) { unsafe { System.TypedReference reference = __makeref(t); return(*(System.IntPtr *)(&reference)); } }
private static String buildLCS( /*int[,,,]*/TypedReference _b, /*char[]*/ TypedReference _X, /*int[]*/ TypedReference _ind) { int _i = 0; for (TypedReference i = __makeref(_i); __refvalue(i, int) < RANK; _i++) if (__refvalue(_ind, int[])[__refvalue(i, int)] == 0) return "";
public static bool Get(ref IStruct @this) { System.TypedReference tr = __makeref(@this); @this = __refvalue(tr, IStruct); return(true); }
public static System.IntPtr AddressOf <T>(T t) //refember ReferenceTypes are references to the CLRHeader //where TOriginal : struct { System.TypedReference reference = __makeref(t); return(*(System.IntPtr *)(&reference)); }
static System.IntPtr AddressOfRef <T>(ref T t) { unsafe { System.TypedReference reference = __makeref(t); System.TypedReference *pRef = &reference; return((System.IntPtr)pRef); //(&pRef) } }
static System.IntPtr AddressOfRef <T>(ref T t) //refember ReferenceTypes are references to the CLRHeader //where TOriginal : struct { System.TypedReference reference = __makeref(t); System.TypedReference *pRef = &reference; return((System.IntPtr)pRef); //(&pRef) }
private static void TestRef(TypedReference _ref) { if (__reftype(_ref) == typeof(Array)) { for (int i = 0; i < __refvalue(_ref, Array).Length; i++) __refvalue(_ref, Array).SetValue(new Test(), i); } if (__reftype(_ref) == typeof(long[])) { for (int i = 0; i < __refvalue(_ref, long[]).Length; i++)
public TypedReference GetNextArg() { TypedReference result = new TypedReference (); // reference to TypedReference is banned, so have to pass result as pointer unsafe { FCallGetNextArg (&result); } return result; }
public virtual void PackRef(TypedReference _ref, int iterCount) { if (++iterCount == ITERATIONS) { UnpackRef(_ref, iterCount); } else { ulong N = UnpackRef(_ref, 0); PackRef(__makeref(N), iterCount); } }
private static void TestRef(TypedReference _ref) { if (__reftype(_ref) == typeof(ulong[,])) { for (int i = 0; i < 2; i++) { for (int j = 0; j < 3; j++) { __refvalue(_ref, ulong[,])[i, j]--; } } } }
private static void PackRef(TypedReference _ref, int iterCount) { if (++iterCount == ITERATIONS) { Console.WriteLine(ITERATIONS.ToString() + " refs packed."); UnpackRef(_ref, iterCount); } else { ulong N = UnpackRef(_ref, 0); PackRef(__makeref(N), iterCount); } }
public unsafe TypedReference GetNextArg(RuntimeTypeHandle rth) { if (this.sigPtr != IntPtr.Zero) { return this.GetNextArg(); } if (this.ArgPtr == IntPtr.Zero) { throw new ArgumentNullException(); } TypedReference reference = new TypedReference(); this.InternalGetNextArg((void*) &reference, rth); return reference; }
public static TypedReference MakeTypedReference(Object target, FieldInfo[] flds) { if (target == null) throw new ArgumentNullException("target"); if (flds == null) throw new ArgumentNullException("flds"); Contract.EndContractBlock(); if (flds.Length == 0) throw new ArgumentException(Environment.GetResourceString("Arg_ArrayZeroError")); IntPtr[] fields = new IntPtr[flds.Length]; // For proper handling of Nullable<T> don't change GetType() to something like 'IsAssignableFrom' // Currently we can't make a TypedReference to fields of Nullable<T>, which is fine. RuntimeType targetType = (RuntimeType)target.GetType(); for (int i = 0; i < flds.Length; i++) { RuntimeFieldInfo field = flds[i] as RuntimeFieldInfo; if (field == null) throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeFieldInfo")); if (field.IsInitOnly || field.IsStatic) throw new ArgumentException(Environment.GetResourceString("Argument_TypedReferenceInvalidField")); if (targetType != field.GetDeclaringTypeInternal() && !targetType.IsSubclassOf(field.GetDeclaringTypeInternal())) throw new MissingMemberException(Environment.GetResourceString("MissingMemberTypeRef")); RuntimeType fieldType = (RuntimeType)field.FieldType; if (fieldType.IsPrimitive) throw new ArgumentException(Environment.GetResourceString("Arg_TypeRefPrimitve")); if (i < (flds.Length - 1) && !fieldType.IsValueType) throw new MissingMemberException(Environment.GetResourceString("MissingMemberNestErr")); fields[i] = field.FieldHandle.Value; targetType = fieldType; } #if MONO return MakeTypedReferenceInternal (target, flds); #else TypedReference result = new TypedReference (); // reference to TypedReference is banned, so have to pass result as pointer unsafe { InternalMakeTypedReference(&result, target, fields, targetType); } return result; #endif }
int InstAddASecondBunchOfInts(int a, __arglist) { int result = 0; System.ArgIterator iter = new System.ArgIterator(__arglist); int argCount = iter.GetRemainingCount(); for (int i = 0; i < argCount; i++) { System.TypedReference typedRef = iter.GetNextArg(); result += (int)TypedReference.ToObject(typedRef); } return(result); }
static int AddABunchOfShorts(__arglist) { int result = 0; System.ArgIterator iter = new System.ArgIterator(__arglist); int argCount = iter.GetRemainingCount(); for (int i = 0; i < argCount; i++) { System.TypedReference typedRef = iter.GetNextArg(); result += (short)TypedReference.ToObject(typedRef); } return(result); }
public virtual ulong UnpackRef(TypedReference _ref, int iterCount) { if (iterCount++ == ITERATIONS) { if (__refvalue(_ref, ulong) == MAGIC) { throw new ArgumentException(); //cleanup in an unusual way } else { throw new Exception(); } } else return __refvalue(_ref, ulong); }
public static unsafe TypedReference MakeTypedReference(object target, FieldInfo[] flds) { if (target == null) { throw new ArgumentNullException("target"); } if (flds == null) { throw new ArgumentNullException("flds"); } if (flds.Length == 0) { throw new ArgumentException(Environment.GetResourceString("Arg_ArrayZeroError")); } RuntimeFieldHandle[] handleArray = new RuntimeFieldHandle[flds.Length]; System.Type type = target.GetType(); for (int i = 0; i < flds.Length; i++) { FieldInfo info = flds[i]; if (!(info is RuntimeFieldInfo)) { throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeFieldInfo")); } if (info.IsInitOnly || info.IsStatic) { throw new ArgumentException(Environment.GetResourceString("Argument_TypedReferenceInvalidField")); } if ((type != info.DeclaringType) && !type.IsSubclassOf(info.DeclaringType)) { throw new MissingMemberException(Environment.GetResourceString("MissingMemberTypeRef")); } System.Type fieldType = info.FieldType; if (fieldType.IsPrimitive) { throw new ArgumentException(Environment.GetResourceString("Arg_TypeRefPrimitve")); } if ((i < (flds.Length - 1)) && !fieldType.IsValueType) { throw new MissingMemberException(Environment.GetResourceString("MissingMemberNestErr")); } handleArray[i] = info.FieldHandle; type = fieldType; } TypedReference reference = new TypedReference(); InternalMakeTypedReference((void*) &reference, target, handleArray, type.TypeHandle); return reference; }
private static ulong UnpackRef(TypedReference _ref, int iterCount) { if (iterCount++ == ITERATIONS) { Console.WriteLine(ITERATIONS.ToString() + " refs unpacked."); if (__refvalue(_ref, ulong) == MAGIC) { Console.WriteLine("Passed."); throw new ArgumentException(); //cleanup in an unusual way } else { Console.WriteLine("failed."); throw new Exception(); } } else return __refvalue(_ref, ulong); }
[System.Security.SecuritySafeCritical] // auto-generated public unsafe static Object ToObject(TypedReference value) { return InternalToObject(&value); }
public static RuntimeTypeHandle TargetTypeToken (TypedReference value) { return __reftype(value).TypeHandle; }
public extern static object ToObject(TypedReference value);
public static TypedReference MakeTypedReference(object target, FieldInfo[] flds) { if (target == null) { throw new ArgumentNullException(nameof(target)); } if (flds == null) { throw new ArgumentNullException(nameof(flds)); } if (flds.Length == 0) { throw new ArgumentException(SR.Arg_ArrayZeroError, nameof(flds)); } IntPtr[] fields = new IntPtr[flds.Length]; // For proper handling of Nullable<T> don't change GetType() to something like 'IsAssignableFrom' // Currently we can't make a TypedReference to fields of Nullable<T>, which is fine. RuntimeType targetType = (RuntimeType)target.GetType(); for (int i = 0; i < flds.Length; i++) { RuntimeFieldInfo?field = flds[i] as RuntimeFieldInfo; if (field == null) { throw new ArgumentException(SR.Argument_MustBeRuntimeFieldInfo); } if (field.IsStatic) { throw new ArgumentException(SR.Format(SR.Argument_TypedReferenceInvalidField, field.Name)); } if (targetType != field.GetDeclaringTypeInternal() && !targetType.IsSubclassOf(field.GetDeclaringTypeInternal())) { throw new MissingMemberException(SR.MissingMemberTypeRef); } RuntimeType fieldType = (RuntimeType)field.FieldType; if (fieldType.IsPrimitive) { throw new ArgumentException(SR.Format(SR.Arg_TypeRefPrimitve, field.Name)); } if (i < (flds.Length - 1) && !fieldType.IsValueType) { throw new MissingMemberException(SR.MissingMemberNestErr); } fields[i] = field.FieldHandle.Value; targetType = fieldType; } TypedReference result = default; // reference to TypedReference is banned, so have to pass result as pointer unsafe { InternalMakeTypedReference(&result, target, fields, targetType); } return(result); }
static void G(System.TypedReference t) { __refvalue(t, string) = Orange; }
internal extern void SetValueDirect(RuntimeTypeHandle fieldType, TypedReference obj, Object value, RuntimeTypeHandle contextType);
/// <summary>Returns the internal metadata type handle for the specified TypedReference.</summary> /// <returns>The internal metadata type handle for the specified TypedReference.</returns> /// <param name="value">The TypedReference for which the type handle is requested. </param> /// <filterpriority>1</filterpriority> public static RuntimeTypeHandle TargetTypeToken(TypedReference value) { return(new RuntimeTypeHandle(value.klass)); }
private static String Format(TypedReference format, TypedReference _ref) { int length = __refvalue(format, String).Length; char[] chars = __refvalue(format, String).ToCharArray(); String result = ""; int arg = 0; for (int I = 0; I < length; I++) { if (chars[I] != '%') result += chars[I]; else { I++; if (I >= length) throw new Exception(); bool FALSE = false; bool TRUE = true; TypedReference bLong = __makeref(FALSE); if (chars[I] == 'l') { bLong = __makeref(TRUE); I++; if (I >= length) throw new Exception(); } if (arg++ == 1) throw new Exception(); switch (chars[I]) { case 'b': if (__refvalue(bLong, bool)) throw new Exception(); if (__reftype(_ref) != typeof(bool)) throw new Exception(); if (__refvalue(_ref, bool)) result += "true"; else result += "false"; break; case 'd': if (__refvalue(bLong, bool)) { if (__reftype(_ref) != typeof(long)) throw new Exception(); result += __refvalue(_ref, long).ToString(); } else { if (__reftype(_ref) != typeof(int)) throw new Exception(); result += __refvalue(_ref, int).ToString(); } break; case 'u': if (__refvalue(bLong, bool)) { if (__reftype(_ref) != typeof(UInt64)) throw new Exception(); result += __refvalue(_ref, ulong).ToString(); } else { if (__reftype(_ref) != typeof(uint)) throw new Exception(); result += __refvalue(_ref, uint).ToString(); } break; case 'f': if (__refvalue(bLong, bool)) { if (__reftype(_ref) != typeof(double)) throw new Exception(); result += __refvalue(_ref, double).ToString(); } else { if (__reftype(_ref) != typeof(float)) throw new Exception(); result += __refvalue(_ref, float).ToString(); } break; case 's': if (__refvalue(bLong, bool)) throw new Exception(); if (__reftype(_ref) != typeof(String)) throw new Exception(); result += __refvalue(_ref, String) != null ? __refvalue(_ref, String) : "(null)"; break; case 't': if (__refvalue(bLong, bool)) throw new Exception(); if (__reftype(_ref) != typeof(DateTime)) throw new Exception(); result += __refvalue(_ref, DateTime).ToString(); break; case 'p': if (__refvalue(bLong, bool)) throw new Exception(); if (__reftype(_ref) != typeof(PlatformID)) throw new Exception(); result += __refvalue(_ref, PlatformID).ToString(); break; case 'e': if (__refvalue(bLong, bool)) throw new Exception(); if (__reftype(_ref) != typeof(Mood)) throw new Exception(); switch (__refvalue(_ref, Mood)) { case Mood.good: result += "good"; break; case Mood.bad: result += "bad"; break; case Mood.worse: result += "worse"; break; default: throw new Exception(); } break; default: throw new Exception(); } } } return result; }
public static TypedReference MakeTypedReference(Object target, FieldInfo[] flds) { if (target == null) { throw new ArgumentNullException("target"); } if (flds == null) { throw new ArgumentNullException("flds"); } if (flds.Length == 0) { throw new ArgumentException(Environment.GetResourceString("Arg_ArrayZeroError")); } else { RuntimeFieldHandle[] fields = new RuntimeFieldHandle[flds.Length]; // For proper handling of Nullable<T> don't change GetType() to something like 'IsAssignableFrom' // Currently we can't make a TypedReference to fields of Nullable<T>, which is fine. Type targetType = target.GetType(); for (int i = 0; i < flds.Length; i++) { FieldInfo field = flds[i]; if (!(field is RuntimeFieldInfo)) { throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeFieldInfo")); } else if (field.IsInitOnly || field.IsStatic) { throw new ArgumentException(Environment.GetResourceString("Argument_TypedReferenceInvalidField")); } if (targetType != field.DeclaringType && !targetType.IsSubclassOf(field.DeclaringType)) { throw new MissingMemberException(Environment.GetResourceString("MissingMemberTypeRef")); } Type fieldType = field.FieldType; if (fieldType.IsPrimitive) { throw new ArgumentException(Environment.GetResourceString("Arg_TypeRefPrimitve")); } if (i < flds.Length - 1) { if (!fieldType.IsValueType) { throw new MissingMemberException(Environment.GetResourceString("MissingMemberNestErr")); } } fields[i] = field.FieldHandle; targetType = fieldType; } TypedReference result = new TypedReference(); // reference to TypedReference is banned, so have to pass result as pointer unsafe { InternalMakeTypedReference(&result, target, fields, targetType.TypeHandle); } return(result); } }
public static object ToObject(TypedReference value) { return(Intrinsics.GetBoxedDataFromPointer(value.pointer)); }
public static unsafe object ToObject(TypedReference value) { return(InternalToObject(&value)); }
public static void SetTypedReference(TypedReference target, object value) { throw new NotImplementedException(); }
public static Type GetTargetType(TypedReference value) { return(__reftype(value)); }
public static RuntimeTypeHandle TargetTypeToken(TypedReference value) { return(value.type); }
internal static RuntimeTypeHandle RawTargetTypeToken(TypedReference value) { return(value._typeHandle); }
/// <summary>Returns the type of the target of the specified TypedReference.</summary> /// <returns>The type of the target of the specified TypedReference.</returns> /// <param name="value">The value whose target's type is to be returned. </param> /// <filterpriority>1</filterpriority> public static Type GetTargetType(TypedReference value) { throw new NotImplementedException(); }
public virtual void SetValueDirect(TypedReference obj, object value) { throw new NotSupportedException(Environment.GetResourceString("NotSupported_AbstractNonCLS")); }
public unsafe static void SetTypedReference(TypedReference target, Object value) { InternalSetTypedReference(&target, value); }
internal extern Object GetValueDirect(RuntimeTypeHandle fieldType, TypedReference obj, RuntimeTypeHandle contextType);
public static RuntimeTypeHandle TargetTypeToken(TypedReference value) { return(__reftype(value).TypeHandle); }
static void F(System.TypedReference t) { __refvalue(t, int) = Pass; }
public void TestExpressionExtensions() { MyTestClass testClass = new MyTestClass(); //Todo ... show how to allow to TypedReference use inside the body System.TypedReference member = __makeref(testClass.Test); System.Type type = typeof(System.Reflection.PropertyInfo); System.Reflection.MethodInfo setter = Media.Common.Extensions.ExpressionExtensions.SymbolExtensions.LoadSetter(() => testClass.Test.Equals(null)); System.Console.WriteLine("setter Name: " + setter.Name); System.Console.WriteLine(".Test => " + testClass.Test); setter.Invoke(testClass, new[] { "Test" }); if (false == (string.Compare(testClass.Test, "Test") == 0)) { throw new System.Exception("Did not invoke setter"); } System.Console.WriteLine(".Test => " + testClass.Test); testClass = new MyTestClass <int>(); MyTestClass <int> casted = testClass as MyTestClass <int>; System.Console.WriteLine("<int>.Test => " + testClass.Test); setter.Invoke(testClass, new[] { "Test" }); if (false == (string.Compare(testClass.Test, "Test") == 0)) { throw new System.Exception("Did not invoke setter"); } System.Console.WriteLine(".Test => " + testClass.Test); System.Console.WriteLine("<int>.Test => " + ((MyTestClass <int>)testClass).Test); System.Console.WriteLine("<int>.Property => " + ((MyTestClass <int>)testClass).Property); setter = Media.Common.Extensions.ExpressionExtensions.SymbolExtensions.LoadSetter(() => ((MyTestClass <int>)testClass).Property.Equals(null)); System.Console.WriteLine("setter Name: " + setter.Name); setter.Invoke(testClass, new object[] { 1 }); if (false == (casted.Property == 1)) { throw new System.Exception("Did not invoke setter"); } System.Console.WriteLine("<int>.Property => " + ((MyTestClass <int>)testClass).Property); System.Console.WriteLine("<int>.Property => " + casted.Property); setter = Media.Common.Extensions.ExpressionExtensions.SymbolExtensions.LoadSetter(() => casted.AnotherProperty.Equals(null)); System.Console.WriteLine("<int>.AnotherProperty => " + ((MyTestClass <int>)testClass).AnotherProperty); System.Console.WriteLine("<int>.AnotherProperty => " + casted.AnotherProperty); setter.Invoke(testClass, new object[] { 2 }); if (false == (casted.AnotherProperty == 2)) { throw new System.Exception("Did not invoke setter"); } System.Console.WriteLine("<int>.AnotherProperty => " + ((MyTestClass <int>)testClass).AnotherProperty); System.Console.WriteLine("<int>.AnotherProperty => " + casted.AnotherProperty); System.Reflection.TypeInfo typeInfo = Media.Common.Extensions.ExpressionExtensions.SymbolExtensions.GetTypeInfo(() => new MyTestClass <int>()); if (typeInfo.GetGenericArguments()[0] != typeof(int)) { throw new System.Exception("Not correct type"); } System.Console.WriteLine("TypeInfo.Name " + typeInfo.Name); System.Console.WriteLine("TypeInfo.MetadataToken " + typeInfo.MetadataToken); if (typeInfo.GetGenericArguments()[0] != typeof(int)) { throw new System.Exception("Not correct type"); } typeInfo = Media.Common.Extensions.ExpressionExtensions.SymbolExtensions.GetTypeInfo(() => (typeof(MyTestClass <int>)).GetType()); if (typeInfo.GetGenericArguments()[0] != typeof(int)) { throw new System.Exception("Not correct type"); } System.Type unboundedType = typeof(MyTestClass <>); typeInfo = Media.Common.Extensions.ExpressionExtensions.SymbolExtensions.GetTypeInfo(() => (unboundedType).GetType()); System.Console.WriteLine("TypeInfo.Name " + typeInfo.Name); System.Console.WriteLine("TypeInfo.MetadataToken " + typeInfo.MetadataToken); System.Reflection.MethodInfo methodInfo = Media.Common.Extensions.ExpressionExtensions.SymbolExtensions.GetMethodInfo(() => ((MyTestClass <int>)null).Method()); if (false.Equals(methodInfo.DeclaringType.Equals(typeof(MyTestClass <int>)))) { throw new System.Exception("Not correct type"); } System.Console.WriteLine("GetMethodInfo.Name " + methodInfo.Name); System.Console.WriteLine("GetMethodInfo.MetadataToken " + methodInfo.MetadataToken); }
public unsafe static void SetTypedReference(TypedReference target, Object value) { #if MONO throw new NotImplementedException ("SetTypedReference"); #else InternalSetTypedReference(&target, value); #endif }
public static Type GetTargetType(TypedReference value) { return(default(Type)); }
public static Type GetTargetType(TypedReference value) { return(Type.GetTypeFromHandle(value.type)); }
public override void SetValueDirect(TypedReference obj, Object value) { throw new NotImplementedException(); }
public static Type GetTargetType (TypedReference value) { return __reftype(value); }
private extern static void InternalObjectToTypedReference(TypedReference byrefValue, Object value, RuntimeTypeHandle typeHandle);
public override Object GetValueDirect(TypedReference obj) { if (obj.IsNull) throw new ArgumentException(Environment.GetResourceString("Arg_TypedReference_Null")); Contract.EndContractBlock(); unsafe { // Passing TypedReference by reference is easier to make correct in native code return RuntimeFieldHandle.GetValueDirect(this, (RuntimeType)FieldType, &obj, (RuntimeType)DeclaringType); } }
public unsafe void SetValue(object pValue, int pIndex) { TypedReference reference = new TypedReference(); InternalGetValueReference(&reference, 1, &pIndex); InternalSetValueReference(&reference, pValue); }
public static void SetTypedReference(TypedReference target, object?value) { throw new NotSupportedException(); }
public override Object GetValueDirect(TypedReference obj) { throw new NotImplementedException(); }
public override Object GetValueDirect(TypedReference obj) { return GetValue(null); }
public static object ToObject(TypedReference arg0) { return(default(object)); }
public override void SetValueDirect(TypedReference obj,Object value) { throw new FieldAccessException(Environment.GetResourceString("Acc_ReadOnly")); }
private static void Test(String format, TypedReference arg, String result) { String s = Format(__makeref(format), arg); if (s != result) { throw new Exception(); } }
public static Type GetTargetType(TypedReference value) => Type.GetTypeFromHandle(value._typeHandle);