Standalone objects support

RealmNet.Shared/Attributes.cs

@@ -1,8 +1,9 @@
 /* Copyright 2015 Realm Inc - All Rights Reserved
  * Proprietary and Confidential
  */
- 
+
 using System;
+using System.Reflection;
 
 namespace RealmNet
 {
@@ -30,4 +31,15 @@ public MapToAttribute(string mapping)
     public class WovenAttribute : Attribute
     {
     }
+
+    [AttributeUsage(AttributeTargets.Property)]
+    public class WovenPropertyAttribute : Attribute
+    {
+        internal string BackingFieldName { get; private set; }
+
+        public WovenPropertyAttribute(string backingFieldName)
+        {
+            this.BackingFieldName = backingFieldName;
+        }
+    }
 }

RealmNet.Shared/Realm.cs

@@ -148,6 +148,33 @@ public object CreateObject(Type objectType)
             return result;
         }
 
+        public void Add<T>(T obj) where T : RealmObject
+        {
+            if (obj == null)
+                throw new ArgumentNullException(nameof(obj));
+
+            if (obj.IsManaged)
+            {
+                // the object is already owned by this realm, so do nothing I guess
+                if (obj.Realm._sharedRealmHandle == this._sharedRealmHandle)
+                    return;
+
+                throw new RealmObjectOwnedByAnotherRealmException("Cannot add an object to a realm when it's already owned by another realm");
+            }
+
+
+            if (!IsInTransaction)
+                throw new RealmOutsideTransactionException("Cannot add a Realm object outside write transactions");
+
+            var tableHandle = _tableHandles[typeof(T)];
+
+            var rowPtr = NativeTable.add_empty_row(tableHandle);
+            var rowHandle = CreateRowHandle(rowPtr);
+
+            obj._Manage(this, rowHandle);
+            obj._CopyDataFromBackingFieldsToRow();
+        }
+
         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
         private static RowHandle CreateRowHandle(IntPtr rowPtr)
         {

RealmNet.Shared/RealmNet.Shared.projitems

@@ -11,6 +11,7 @@
   <ItemGroup>
     <Compile Include="$(MSBuildThisFileDirectory)Attributes.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)exceptions\RealmDecryptionFailedException.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)exceptions\RealmObjectOwnedByAnotherRealmException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)exceptions\RealmOutsideTransactionException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)exceptions\RealmFileExistsException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)exceptions\RealmInvalidDatabaseException.cs" />

RealmNet.Shared/RealmObject.cs

@@ -1,8 +1,11 @@
 /* Copyright 2015 Realm Inc - All Rights Reserved
  * Proprietary and Confidential
  */
- 
+
 using System;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
 using System.Runtime.InteropServices;
 
 namespace RealmNet
@@ -12,14 +15,37 @@ public class RealmObject
         private Realm _realm;
         private RowHandle _rowHandle;
 
+        internal Realm Realm => _realm;
         internal RowHandle RowHandle => _rowHandle;
 
+        internal protected bool IsManaged => _realm != null;
+
         internal void _Manage(Realm realm, RowHandle rowHandle)
         {
             _realm = realm;
             _rowHandle = rowHandle;
         }
 
+        internal void _CopyDataFromBackingFieldsToRow()
+        {
+            Debug.Assert(this.IsManaged);
+
+            var thisType = this.GetType();
+            var wovenProperties = from prop in thisType.GetProperties()
+                                  let backingField = prop.GetCustomAttributes(false)
+                                                         .OfType<WovenPropertyAttribute>()
+                                                         .Select(a => a.BackingFieldName)
+                                                         .SingleOrDefault()
+                                  where backingField != null
+                                  select new { Info = prop, Field = thisType.GetField(backingField, BindingFlags.Instance | BindingFlags.NonPublic) };
+
+            foreach (var prop in wovenProperties)
+            {
+                var value = prop.Field.GetValue(this);
+                prop.Info.SetValue(this, value, null);
+            }
+        }
+
         protected T GetValue<T>(string propertyName)
         {
             if (_realm == null)

RealmNet.Shared/exceptions/RealmObjectOwnedByAnotherRealmException.cs

@@ -0,0 +1,14 @@
+/* Copyright 2015 Realm Inc - All Rights Reserved
+ * Proprietary and Confidential
+ */
+
+namespace RealmNet
+{
+    public class RealmObjectOwnedByAnotherRealmException : RealmException
+    {
+        public RealmObjectOwnedByAnotherRealmException(string detailMessage) : base(detailMessage)
+        {
+
+        }
+    }
+}

RealmNetWeaver/ModuleWeaver.cs

@@ -22,6 +22,8 @@ public class ModuleWeaver
 
     TypeSystem typeSystem;
 
+    MethodReference realmObjectIsManagedGetter;
+
     // Init logging delegates to make testing easier
     public ModuleWeaver()
     {
@@ -52,6 +54,7 @@ public void Execute()
         var assemblyToReference = ModuleDefinition.AssemblyResolver.Resolve("RealmNet");
 
         var realmObjectType = assemblyToReference.MainModule.GetTypes().First(x => x.Name == "RealmObject");
+        realmObjectIsManagedGetter = ModuleDefinition.ImportReference(realmObjectType.Properties.Single(x => x.Name == "IsManaged").GetMethod);
         var genericGetValueReference = MethodNamed(realmObjectType, "GetValue");
         var genericSetValueReference = MethodNamed(realmObjectType, "SetValue");
         //var getListValueReference = MethodNamed(realmObjectType, "GetListValue");
@@ -60,6 +63,11 @@ public void Execute()
         var wovenAttributeClass = assemblyToReference.MainModule.GetTypes().First(x => x.Name == "WovenAttribute");
         var wovenAttributeConstructor = ModuleDefinition.Import(wovenAttributeClass.GetConstructors().First());
 
+        var wovenPropertyAttributeClass = assemblyToReference.MainModule.GetTypes().First(x => x.Name == "WovenPropertyAttribute");
+        var wovenPropertyAttributeConstructor = ModuleDefinition.ImportReference(wovenPropertyAttributeClass.GetConstructors().First());
+        var corlib = ModuleDefinition.AssemblyResolver.Resolve((AssemblyNameReference)ModuleDefinition.TypeSystem.CoreLibrary);
+        var stringType = ModuleDefinition.ImportReference(corlib.MainModule.GetType("System.String"));
+
         foreach (var type in GetMatchingTypes())
         {
             Debug.WriteLine("Weaving " + type.Name);
@@ -70,6 +78,8 @@ public void Execute()
                 if (mapToAttribute != null)
                     columnName = ((string)mapToAttribute.ConstructorArguments[0].Value);
 
+                var backingField = GetBackingField(prop);
+
                 Debug.Write("  -- Property: " + prop.Name + " (column: " + columnName + ".. ");
                 //TODO check if has either setter or getter and adjust accordingly - https://github.com/realm/realm-dotnet/issues/101
                 if (prop.PropertyType.Namespace == "RealmNet" && prop.PropertyType.Name == "RealmList`1")
@@ -89,6 +99,10 @@ public void Execute()
                     throw new NotSupportedException($"class '{type.Name}' field '{columnName}' is a {prop.PropertyType.Name} which is not yet supported");
                 }
 
+                var wovenPropertyAttribute = new CustomAttribute(wovenPropertyAttributeConstructor);
+                wovenPropertyAttribute.ConstructorArguments.Add(new CustomAttributeArgument(stringType, backingField.Name));
+                prop.CustomAttributes.Add(wovenPropertyAttribute);
+
                 Debug.WriteLine("");
             }
 
@@ -99,18 +113,41 @@ public void Execute()
         return;
     }
 
-
     void AddGetter(PropertyDefinition prop, string columnName, MethodReference getValueReference)
     {
         var specializedGetValue = new GenericInstanceMethod(getValueReference);
         specializedGetValue.GenericArguments.Add(prop.PropertyType);
 
-        prop.GetMethod.Body.Instructions.Clear();
-        var getProcessor = prop.GetMethod.Body.GetILProcessor();
-        getProcessor.Emit(OpCodes.Ldarg_0);
-        getProcessor.Emit(OpCodes.Ldstr, columnName);
-        getProcessor.Emit(OpCodes.Call, specializedGetValue);
-        getProcessor.Emit(OpCodes.Ret);
+        /// A synthesized property getter looks like this:
+        ///   0: ldarg.0
+        ///   1: ldfld <backingField>
+        ///   2: ret
+        /// We want to change it so it looks like this:
+        ///   0: ldarg.0
+        ///   1: call RealmNet.RealmObject.get_IsManaged
+        ///   2: brfalse.s 7
+        ///   3: ldarg.0
+        ///   4: ldstr <columnName>
+        ///   5: call RealmNet.RealmObject.GetValue<T>
+        ///   6: ret
+        ///   7: ldarg.0
+        ///   8: ldfld <backingField>
+        ///   9: ret
+        /// This is roughly equivalent to:
+        ///   if (!base.IsManaged) return this.<backingField>;
+        ///   else return base.GetValue<T>(<columnName>);
+
+        var start = prop.GetMethod.Body.Instructions.First();
+        var il = prop.GetMethod.Body.GetILProcessor();
+
+        il.InsertBefore(start, il.Create(OpCodes.Ldarg_0));
+        il.InsertBefore(start, il.Create(OpCodes.Call, realmObjectIsManagedGetter));
+        il.InsertBefore(start, il.Create(OpCodes.Brfalse_S, start));
+        il.InsertBefore(start, il.Create(OpCodes.Ldarg_0));
+        il.InsertBefore(start, il.Create(OpCodes.Ldstr, columnName));
+        il.InsertBefore(start, il.Create(OpCodes.Call, specializedGetValue));
+        il.InsertBefore(start, il.Create(OpCodes.Ret));
+
         Debug.Write("[get] ");
     }
 
@@ -120,13 +157,39 @@ void AddSetter(PropertyDefinition prop, string columnName, MethodReference setVa
         var specializedSetValue = new GenericInstanceMethod(setValueReference);
         specializedSetValue.GenericArguments.Add(prop.PropertyType);
 
-        prop.SetMethod.Body.Instructions.Clear();
-        var setProcessor = prop.SetMethod.Body.GetILProcessor();
-        setProcessor.Emit(OpCodes.Ldarg_0);
-        setProcessor.Emit(OpCodes.Ldstr, columnName);
-        setProcessor.Emit(OpCodes.Ldarg_1);
-        setProcessor.Emit(OpCodes.Call, specializedSetValue);
-        setProcessor.Emit(OpCodes.Ret);
+        /// A synthesized property setter looks like this:
+        ///   0: ldarg.0
+        ///   1: ldarg.1
+        ///   2: stfld <backingField>
+        ///   3: ret
+        /// We want to change it so it looks like this:
+        ///   0: ldarg.0
+        ///   1: call RealmNet.RealmObject.get_IsManaged
+        ///   2: brfalse.s 8
+        ///   3: ldarg.0
+        ///   4: ldstr <columnName>
+        ///   5: ldarg.1
+        ///   6: call RealmNet.RealmObject.SetValue<T>
+        ///   7: ret
+        ///   8: ldarg.0
+        ///   9: ldarg.1
+        ///   10: stfld <backingField>
+        ///   11: ret
+        /// This is roughly equivalent to:
+        ///   if (!base.IsManaged) this.<backingField> = value;
+        ///   else base.SetValue<T>(<columnName>, value);
+
+        var start = prop.SetMethod.Body.Instructions.First();
+        var il = prop.SetMethod.Body.GetILProcessor();
+
+        il.InsertBefore(start, il.Create(OpCodes.Ldarg_0));
+        il.InsertBefore(start, il.Create(OpCodes.Call, realmObjectIsManagedGetter));
+        il.InsertBefore(start, il.Create(OpCodes.Brfalse_S, start));
+        il.InsertBefore(start, il.Create(OpCodes.Ldarg_0));
+        il.InsertBefore(start, il.Create(OpCodes.Ldstr, columnName));
+        il.InsertBefore(start, il.Create(OpCodes.Ldarg_1));
+        il.InsertBefore(start, il.Create(OpCodes.Call, specializedSetValue));
+        il.InsertBefore(start, il.Create(OpCodes.Ret));
 
         Debug.Write("[set] ");
     }
@@ -151,4 +214,13 @@ void AddHelloWorld( TypeDefinition newType)
         processor.Emit(OpCodes.Ret);
         newType.Methods.Add(method);
     }
+
+    private static FieldReference GetBackingField(PropertyDefinition property)
+    {
+        return property.GetMethod.Body.Instructions
+            .Where(o => o.OpCode == OpCodes.Ldfld)
+            .Select(o => o.Operand)
+            .OfType<FieldReference>()
+            .SingleOrDefault();
+    }
 }

RealmNetWeaver/RealmNetWeaver.Fody.csproj

@@ -68,4 +68,7 @@
     <PostBuildEvent Condition="'Windows_NT'=='$(os)'">xcopy/Y $(TargetPath) $(SolutionDir)Tools</PostBuildEvent>
     <PostBuildEvent Condition="'Unix'=='$(os)'">cp $(TargetPath) $(SolutionDir)Tools</PostBuildEvent>
   </PropertyGroup>
+  <PropertyGroup>
+    <PostBuildEvent>xcopy /Y "$(TargetPath)" "$(SolutionDir)Tools"</PostBuildEvent>
+  </PropertyGroup>
 </Project>

Tests/IntegrationTests.Shared/IntegrationTests.Shared.projitems

@@ -13,6 +13,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)IntegrationTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)PerformanceTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Person.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)StandAloneObjectTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)TestHelpers.cs" />
   </ItemGroup>
 </Project>

Tests/IntegrationTests.Shared/IntegrationTests.cs

@@ -194,6 +194,35 @@ public void CreateObjectOutsideTransactionShouldFail()
             Assert.Throws<RealmOutsideTransactionException>(() => _realm.CreateObject<Person>());
         }
 
+        [Test]
+        public void AddOutsideTransactionShouldFail()
+        {
+            var obj = new Person();
+            Assert.Throws<RealmOutsideTransactionException>(() => _realm.Add(obj));
+        }
+
+        [Test]
+        public void AddNullObjectShouldFail()
+        {
+            Assert.Throws<ArgumentNullException>(() => _realm.Add(null as Person));
+        }
+
+        [Test]
+        public void AddAnObjectFromAnotherRealmShouldFail()
+        {
+            Person p;
+            using (var transaction = _realm.BeginWrite())
+            {
+                p = _realm.CreateObject<Person>();
+                transaction.Commit();
+            }
+
+            using (var otherRealm = Realm.GetInstance(Path.GetTempFileName()))
+            {
+                Assert.Throws<RealmObjectOwnedByAnotherRealmException>(() => otherRealm.Add(p));
+            }
+        }
+
         [Test]
         public void SetPropertyOutsideTransactionShouldFail()
         {