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

@@ -94,7 +94,7 @@ private static IntPtr GenerateObjectSchema(Type objectClass)
                 var objectType = "";
                 if (!p.PropertyType.IsValueType && p.PropertyType.Name!="String") {
                     if (p.PropertyType.Name == "RealmList`1")
-                        objectType = p.PropertyType.GenericTypeArguments [0].Name;
+                        objectType = p.PropertyType.GetGenericArguments()[0].Name;
                     else {
                         if (p.PropertyType.BaseType.Name == "RealmObject")
                             objectType = p.PropertyType.Name;
@@ -159,6 +159,32 @@ public object CreateObject(Type objectType)
             return result;
         }
 
+        public void Attach<T>(T obj) where T : RealmObject
+        {
+            if (obj == null)
+                throw new ArgumentNullException(nameof(obj));
+
+            if (obj.IsManaged)
+            {
+                if (obj.Realm._sharedRealmHandle == this._sharedRealmHandle)
+                    throw new RealmObjectAlreadyOwnedByRealmException("The object is already owned by this realm");
+
+                throw new RealmObjectOwnedByAnotherRealmException("Cannot attach an object to a realm when it's already owned by another realm");
+            }
+
+
+            if (!IsInTransaction)
+                throw new RealmOutsideTransactionException("Cannot attach 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)]
         internal static RowHandle CreateRowHandle(IntPtr rowPtr)
         {

RealmNet.Shared/RealmList.cs

@@ -119,6 +119,7 @@ public T this[int index]
 
         public void Add(T item)
         {
+            this.AttachObjectIfNeeded(item);
             var rowIndex = ((RealmObject)item).RowHandle.RowIndex;
             NativeLinkList.add(_listHandle, (IntPtr)rowIndex);        
         }
@@ -147,6 +148,9 @@ public IEnumerator<T> GetEnumerator()
 
         public int IndexOf(T item)
         {
+            if (!item.IsManaged)
+                throw new ArgumentException("Value does not belong to a realm", nameof(item));
+
             var rowIndex = ((RealmObject)item).RowHandle.RowIndex;
             return (int)NativeLinkList.find(_listHandle, (IntPtr)rowIndex, (IntPtr)0);        
         }
@@ -155,6 +159,8 @@ public void Insert(int index, T item)
         {
             if (index < 0)
                 throw new IndexOutOfRangeException ();
+
+            this.AttachObjectIfNeeded(item);
             var rowIndex = ((RealmObject)item).RowHandle.RowIndex;
             NativeLinkList.insert(_listHandle, (IntPtr)index, (IntPtr)rowIndex);        
         }
@@ -180,6 +186,12 @@ IEnumerator IEnumerable.GetEnumerator()
             return new RealmListEnumerator(this);
         }
 
+        private void AttachObjectIfNeeded(T obj)
+        {
+            if (!obj.IsManaged)
+                _parent.Realm.Attach(obj);
+        }
+
         #endregion
     }
 }

RealmNet.Shared/RealmNet.Shared.projitems

@@ -11,6 +11,8 @@
   <ItemGroup>
     <Compile Include="$(MSBuildThisFileDirectory)Attributes.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)exceptions\RealmDecryptionFailedException.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)exceptions\RealmObjectAlreadyOwnedByRealmException.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)
@@ -131,20 +157,20 @@ protected void SetValue<T>(string propertyName, T value)
         }
 
 
-        protected T GetListValue<T>(string propertyName) where T : RealmList<RealmObject>
+        protected RealmList<T> GetListValue<T>(string propertyName) where T : RealmObject
         {
             if (_realm == null)
                 throw new Exception("This object is not managed. Create through CreateObject");
 
             var tableHandle = _realm._tableHandles[GetType()];
             var columnIndex = NativeTable.get_column_index(tableHandle, propertyName, (IntPtr)propertyName.Length);
             var listHandle = tableHandle.TableLinkList (columnIndex, _rowHandle);
-            var ret = (T)Activator.CreateInstance(typeof(T));
+            var ret = Activator.CreateInstance<RealmList<T>>();
             ret.CompleteInit (this, listHandle);
             return ret;
         }
 
-        protected void SetListValue<T>(string propertyName, T value) where T : RealmList<RealmObject>
+        protected void SetListValue<T>(string propertyName, RealmList<T> value) where T : RealmObject
         {
             throw new NotImplementedException ("Setting a relationship list is not yet implemented");
         }
@@ -187,10 +213,16 @@ protected void SetObjectValue<T>(string propertyName, T value) where T : RealmOb
             var tableHandle = _realm._tableHandles[GetType()];
             var columnIndex = NativeTable.get_column_index(tableHandle, propertyName, (IntPtr)propertyName.Length);
             var rowIndex = _rowHandle.RowIndex;
-            if (value==null)
-                NativeTable.clear_link (tableHandle, columnIndex, (IntPtr)rowIndex);
+            if (value == null)
+            {
+                NativeTable.clear_link(tableHandle, columnIndex, (IntPtr)rowIndex);
+            }
             else
-                NativeTable.set_link (tableHandle, columnIndex, (IntPtr)rowIndex, (IntPtr)value.RowHandle.RowIndex);
+            {
+                if (!value.IsManaged)
+                    _realm.Attach(value);
+                NativeTable.set_link(tableHandle, columnIndex, (IntPtr)rowIndex, (IntPtr)value.RowHandle.RowIndex);
+            }
 
         }
 

RealmNet.Shared/exceptions/RealmObjectAlreadyOwnedByRealmException.cs

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

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)
+        {
+
+        }
+    }
+}