private void ToReference(object targetObject, MarshalReference mr, IPropertyMap propertyMap, RefreshBehaviorType refreshBehavior)
        {
            object value = null;
            if (mr.Type.Length > 0 && mr.IsNull == false)
                value = ToReferenceValue(targetObject, mr.Type, mr.Value, mr, propertyMap);

            Context.ObjectManager.SetPropertyValue(targetObject, propertyMap.Name, value);
            if (mr.HasOriginal)
            {
                object orgValue = null;
                if (mr.OriginalType.Length > 0 && mr.WasNull == false)
                    orgValue = ToReferenceValue(targetObject, mr.OriginalType, mr.OriginalValue,mr, propertyMap);

                Context.ObjectManager.SetOriginalPropertyValue(targetObject, propertyMap.Name, orgValue);
                if (mr.IsNull != mr.WasNull || (value != null && orgValue != null && value.Equals(orgValue) == false))
                {
                    this.Context.ObjectManager.SetUpdatedStatus(targetObject, propertyMap.Name, true);
                    //redundant, done once for object by outer caller
                    //this.Context.UnitOfWork.RegisterDirty(targetObject, propertyMap.Name, true);
                }
            }
            Context.ObjectManager.SetNullValueStatus(targetObject, propertyMap.Name, mr.IsNull);
        }
 private MarshalReference FromReference(object sourceObject, IPropertyMap propertyMap)
 {
     MarshalReference mr = new MarshalReference();
     mr.Name = propertyMap.Name;
     object value = Context.ObjectManager.GetPropertyValue(sourceObject, propertyMap.Name);
     if (value != null)
     {
         IClassMap classMap = Context.DomainMap.MustGetClassMap(value.GetType());
         mr.Type = classMap.GetName() ;
         mr.IsNull = false;
     }
     else
     {
         IClassMap refClassMap = propertyMap.MustGetReferencedClassMap() ;
         if (refClassMap != null)
             mr.Type = refClassMap.GetName() ;
         mr.IsNull = true;
     }
     mr.Value = FromPropertyReference(sourceObject, value, propertyMap);
     if (Context.ObjectManager.HasOriginalValues(sourceObject, propertyMap.Name))
     {
         object orgValue =  Context.ObjectManager.GetOriginalPropertyValue(sourceObject, propertyMap.Name);
         mr.OriginalValue = FromPropertyReference(sourceObject, orgValue, propertyMap);
         mr.HasOriginal = true;
         if (orgValue != null)
         {
             IClassMap orgClassMap = Context.DomainMap.MustGetClassMap(orgValue.GetType());
             mr.OriginalType = orgClassMap.GetName() ;
             mr.WasNull = false;
         }
         else
         {
             IClassMap refClassMap = propertyMap.MustGetReferencedClassMap() ;
             if (refClassMap != null)
                 mr.OriginalType = refClassMap.GetName() ;
             mr.WasNull = true;
         }
     }
     else
     {
         //mr.OriginalValue = FromPropertyReference(sourceObject, null, propertyMap);
         mr.HasOriginal = false;
     }
     return mr;
 }
 public object ToReferenceValue(object targetObject, string type, MarshalReferenceValue value, MarshalReference mr, IPropertyMap propertyMap)
 {
     IClassMap classMap = Context.DomainMap.MustGetClassMap(type);
     Type realType = Context.AssemblyManager.MustGetTypeFromClassMap(classMap);
     string identity = GetIdentity(mr, value);
     return Context.GetObjectById(identity, realType, true);
 }
 public string GetIdentity(MarshalReference marshalReference, MarshalReferenceValue marshalReferenceValue)
 {
     IClassMap classMap = Context.DomainMap.MustGetClassMap(marshalReference.Type);
     StringBuilder id = new StringBuilder() ;
     string sep = classMap.IdentitySeparator;
     if (sep == "") { sep = "|"; }
     foreach (IPropertyMap propertyMap in classMap.GetIdentityPropertyMaps())
     {
         if (propertyMap.ReferenceType == ReferenceType.None)
         {
             MarshalProperty mp = marshalReferenceValue.GetReferenceProperty(propertyMap.Name);
             id.Append(mp.Value + sep);
         }
         else
         {
             MarshalReference mr = marshalReferenceValue.GetReferenceReference(propertyMap.Name);
             id.Append(GetIdentity(mr, marshalReferenceValue) + sep);
         }
     }
     if (id.Length > 0) { id.Length -= sep.Length; }
     return id.ToString();
 }
        public virtual MarshalReference FromObjectAsReference(object sourceObject)
        {
            IClassMap classMap = Context.DomainMap.MustGetClassMap(sourceObject.GetType());
            MarshalReference mr = new MarshalReference();
            mr.Type = classMap.GetName();
            foreach (IPropertyMap propertyMap in classMap.GetIdentityPropertyMaps())
            {
                if (propertyMap.ReferenceType == ReferenceType.None)
                {
                    if (propertyMap.IsCollection)
                    {

                    }
                    else
                    {
                        mr.Value.ReferenceProperties.Add(FromProperty(sourceObject, propertyMap));
                    }
                }
                else
                {
                    if (propertyMap.IsCollection)
                    {

                    }
                    else
                    {
                        mr.Value.ReferenceProperties.Add(FromReference(sourceObject, propertyMap));
                    }
                }
            }

            return mr;
        }
        public object ToReferenceValue(object targetObject, string type, MarshalReferenceValue value, MarshalReference mr, IPropertyMap propertyMap)
        {
            IClassMap classMap = Context.DomainMap.MustGetClassMap(type);
            Type      realType = Context.AssemblyManager.MustGetTypeFromClassMap(classMap);
            string    identity = GetIdentity(mr, value);

            return(Context.GetObjectById(identity, realType, true));
        }