private void RegisterPropertyAttributes(string propName) { // Properties that are added after view model instantiation must be manually set so that // their values will be included in the updates to the client. foreach (var metaProp in RuntimeProperties.Where(x => x.Name.StartsWith(propName + "__"))) Set(metaProp.Value, metaProp.Name); }
private void RemoveExistingProperty(string propName) { RuntimeProperties.Where(x => x.Name == propName || x.Name.Contains(propName + "__")) .ToList() .ForEach(x => RuntimeProperties.Remove(x)); _propertyValues.TryRemove(propName, out object value); }
public void PinnableBlittableTest() { Assert.True(RuntimeProperties.IsPinnable("g")); Assert.False(RuntimeProperties.IsBlittable("g")); Assert.True(RuntimeProperties.IsPinnable(new int[] { 1, 2, 3 })); Assert.False(RuntimeProperties.IsBlittable(new int[] { 1, 2, 3 })); }
/// <summary> /// Adds a runtime observable property. /// </summary> /// <param name="propertyName">Property name.</param> private ReactiveProperty <T> AddProperty <T>(Type propertyType, ReactiveProperty <T> property) { if (_propertyValues.ContainsKey(property.Name)) { throw new InvalidOperationException($"{property.Name} already exists."); } property.Subscribe(_ => Changed(property.Name)); RuntimeProperties.Add(property); Set(property, property.Name); return(property); }
public void NilTest() { string s = "foo"; Assert.False(RuntimeProperties.IsDefault(s)); string s2 = null; Assert.True(RuntimeProperties.IsDefault(s2)); Assert.True(RuntimeProperties.IsDefault(default(int))); }
public void PinnableTest() { string s = "foo"; Assert.True(RuntimeProperties.IsPinnable(s)); string[] rg = { "foo", "bar" }; Assert.False(RuntimeProperties.IsPinnable(rg)); var rg2 = new[] { 1, 2, 3 }; Assert.True(RuntimeProperties.IsPinnable(rg2)); Assert.True(RuntimeProperties.IsPinnable(1)); Assert.False(RuntimeProperties.IsPinnable(new List <int> { 1, 2, 3 })); }
/// <summary> /// Constructor to create a wrapper for a view model that doesn't inherit from BaseVM. /// </summary> /// <param name="vm">View model instance.</param> internal BaseVM(INotifyPropertyChanged vm) : base() { _vmInstance = vm; vm.PropertyChanged += OnPropertyChanged; _changedProperties = _propertyDictionaries.Dequeue(); if (vm is IReactiveProperties && (vm as IReactiveProperties).RuntimeProperties != null) { var runtimeProperties = (vm as IReactiveProperties).RuntimeProperties.Where(prop => !string.IsNullOrWhiteSpace(prop.Name)).ToList(); runtimeProperties.ForEach(prop => { prop.PropertyChanged += OnPropertyChanged; RuntimeProperties.Add(prop); Set(prop, prop.Name); }); Disposed += (sender, e) => runtimeProperties.ForEach(prop => prop.PropertyChanged -= OnPropertyChanged); IgnoredProperties.Add(nameof(IReactiveProperties.RuntimeProperties)); } if (vm is IPushUpdates) { (vm as IPushUpdates).RequestPushUpdates += (sender, e) => RequestPushUpdates?.Invoke(this, e); } if (vm is IDisposable) { Disposed += (sender, e) => { vm.PropertyChanged -= OnPropertyChanged; (vm as IDisposable).Dispose(); } } ; if (vm is IBaseVMAccessor) { (vm as IBaseVMAccessor).OnInitialized?.Invoke(this); } }
protected BaseClrStructure(MemberInfo member) : this(RuntimeProperties.ResolveHandle(member)) { }
public void SizeTest2(object value) { Assert.AreEqual(RuntimeProperties.GetRawObjDataSize(value), Mem.SizeOf(value, SizeOfOptions.Data)); }
public void BlankTest() { Assert.True(RuntimeProperties.IsEmpty(Array.Empty <int>())); }
public void BoxedTest() { Assert.True(RuntimeProperties.IsBoxed((object)1)); }
public static string Dump <T>(ref T value, DumpOptions options, InspectorOptions options2) { switch (options) { case DumpOptions.Info: // var addrTable = new ConsoleTable("Addresses", ""); var addr = Mem.AddressOf(ref value); addrTable.AddRow("Address", addr); if (Mem.TryGetAddressOfHeap(value, out var heap)) { addrTable.AddRow("Address (heap)", heap); } addrTable.Write(ConsoleTableFormat.Minimal); // var infoTable = new ConsoleTable("Sizes", ""); infoTable.AddRow("Intrinsic", Mem.SizeOf <T>()); infoTable.AddRow("Auto", Mem.SizeOf(value, SizeOfOptions.Auto)); infoTable.Write(ConsoleTableFormat.Minimal); // var propTable = new ConsoleTable("Runtime info", ""); propTable.AddRow("Pinnable", RuntimeProperties.IsPinnable(value)); propTable.AddRow("Blittable", RuntimeProperties.IsBlittable(value)); propTable.AddRow("Boxed", RuntimeProperties.IsBoxed(value)); propTable.AddRow("Nil", RuntimeProperties.IsDefault(value)); propTable.AddRow("Uninitialized", RuntimeProperties.IsNullMemory(value)); propTable.AddRow("In GC heap", GCHeap.IsHeapPointer(Mem.AddressOfData(ref value))); return(propTable.ToMinimalString()); case DumpOptions.Sizes: var layoutTable = new ConsoleTable("Size Type", "Value"); var options1 = Enum.GetValues <SizeOfOptions>().ToList(); options1.Remove(SizeOfOptions.Heap); foreach (var option in options1) { var sizeOf = Mem.SizeOf(value, option); if (sizeOf == Native.INVALID) { continue; } layoutTable.AddRow(Enum.GetName(option), sizeOf); } var mt = value.GetMetaType(); if (!mt.RuntimeType.IsValueType) { layoutTable.AddRow(nameof(SizeOfOptions.Heap), Mem.SizeOf(value, SizeOfOptions.Heap)); } return(layoutTable.ToString()); case DumpOptions.Layout: var layoutTable1 = new ConsoleTable(); var flags = EnumHelper.GetSetFlags(options2); if (options2 == InspectorOptions.All) { flags.Remove(InspectorOptions.All); } layoutTable1.AddColumn(flags.Select(Enum.GetName)); // Rewrite options options2 = default; foreach (var flag in flags) { options2 |= flag; } var mt1 = value.GetMetaType(); var fields = mt1.Fields.Where(x => !x.IsStatic); int s = Mem.SizeOf(value, SizeOfOptions.Auto); var p = Mem.AddressOf(ref value); foreach (var metaField in fields) { var rowValues = new List <object>(); if (options2.HasFlag(InspectorOptions.Offset)) { rowValues.Add($"{metaField.Offset:X}"); } if (options2.HasFlag(InspectorOptions.Size)) { rowValues.Add(metaField.Size); } if (options2.HasFlag(InspectorOptions.Type)) { rowValues.Add(metaField.FieldType.Name); } if (options2.HasFlag(InspectorOptions.Name)) { rowValues.Add(metaField.Name); } if (options2.HasFlag(InspectorOptions.Address)) { var addr1 = Mem.AddressOfData(ref value) + metaField.Offset; rowValues.Add(addr1.ToString()); } if (options2.HasFlag(InspectorOptions.Value)) { object fieldVal; if (!mt1.RuntimeType.IsConstructedGenericType) { fieldVal = metaField.Info.GetValue(value); } else { fieldVal = "?"; } rowValues.Add($"{fieldVal}"); } layoutTable1.AddRow(rowValues.ToArray()); } if (value is string str) { for (int i = 1; i < str.Length; i++) { char c = str[i]; var rowValues = new List <object>(); int offsetBase = (i * sizeof(char)); if (options2.HasFlag(InspectorOptions.Offset)) { rowValues.Add($"{offsetBase + RuntimeProperties.StringOverhead - sizeof(char):X}"); } if (options2.HasFlag(InspectorOptions.Size)) { rowValues.Add(sizeof(char)); } if (options2.HasFlag(InspectorOptions.Type)) { rowValues.Add(nameof(Char)); } if (options2.HasFlag(InspectorOptions.Name)) { rowValues.Add($"Char #{i + 1}"); } if (options2.HasFlag(InspectorOptions.Address)) { if (Mem.TryGetAddressOfHeap(value, OffsetOptions.StringData, out var addr2)) { addr2 += offsetBase; rowValues.Add(addr2.ToString()); } } if (options2.HasFlag(InspectorOptions.Value)) { rowValues.Add($"{c}"); } layoutTable1.AddRow(rowValues.ToArray()); } } return(layoutTable1.ToString()); default: throw new ArgumentOutOfRangeException(nameof(options)); } }