protected override bool Match(ConventionInfo convention) { //Note: We don't map metadata, because ApplicationService does it. Type targetPropType = convention.TargetProp.Type; Type sourcePropType = convention.SourceProp.Type; if (sourcePropType != targetPropType) { return false; } return base.Match(convention); }
protected override bool Match(ConventionInfo convention) { return String.Equals(convention.SourceProp.Name, convention.TargetProp.Name, StringComparison.InvariantCultureIgnoreCase); }
protected override object SetValue(ConventionInfo v) { return(v.SourceProp.Value == null ? null : (v.SourceProp.Value as IEnumerable <Entity>).Select(o => o.Id)); }
protected override bool Match(ConventionInfo c) { return(c.SourceProp.Name == "CustomerCountries" && c.TargetProp.Name == "Countries" && c.SourceProp.Value != null); }
protected override object SetValue(ConventionInfo c) { return(c.SourceProp.Value.ToString()); }
protected override void Inject(object source, object target) { if (!knownObjects.ContainsKey(source)) { knownObjects.Add(source, target); } foreach (var sp in source.GetType().GetProperties( BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) .Where(p => p.GetGetMethod(true) != null && p.GetIndexParameters().Count() == 0) .OrderBy(p => p.HasAttribute <SerializationPriorityAttribute>() ? p.GetCustomAttribute <SerializationPriorityAttribute>().Priority : int.MaxValue)) { var tp = target.GetType().GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Where(p => p.GetSetMethod(true) != null && p.GetIndexParameters().Count() == 0 && p.Name == sp.Name).SingleOrDefault(); if (tp != null) { var c = new ConventionInfo { Source = new ConventionInfo.TypeInfo { Type = sp.DeclaringType }, SourceProp = new ConventionInfo.PropInfo { Name = sp.Name }, Target = new ConventionInfo.TypeInfo { Type = tp.DeclaringType }, TargetProp = new ConventionInfo.PropInfo { Name = tp.Name }, }; if (Match(c)) { bool doit = true; bool regen = false; if (source is Component && ((Component)source).Hitpoints == 0) { } if (source is IReferrable && sp.Name == "ID") { // do special things for IDs var behavior = source == Root ? RootBehavior : SubordinateBehavior; if (behavior == IDCopyBehavior.PreserveSource) { doit = true; } else if (behavior == IDCopyBehavior.PreserveDestination) { doit = false; } else if (behavior == IDCopyBehavior.Regenerate) { doit = false; regen = true; } } object sv = null; if (doit && CanCopyFully(sp) && DeepCopy) { sv = sp.GetValue(source, null); if (sv == null) { sp.SetValue(target, null, null); // it's null, very simple } else if (!knownObjects.ContainsKey(sv)) { // copy object and use the copy var tv = CopyObject(source, sv); sp.SetValue(target, tv, null); } else { sp.SetValue(target, knownObjects[sv], null); // known object, don't bother copying again } } else if (doit && CanCopySafely(sp)) { sv = sp.GetValue(source, null); if (knownObjects.ContainsKey(sv)) { sp.SetValue(target, knownObjects[sv]); // use known copy } else { sp.SetValue(target, sv, null); // use original object } } if (regen) { // reassign ID var r = target as IReferrable; if (r.HasValidID()) { r.ReassignID(); } } } } } if (target is ICleanable) { (target as ICleanable).Clean(); } }
protected override object SetValue(ConventionInfo c) { // don't override these values return(c.TargetProp.Value); }
protected override object SetValue(ConventionInfo c) { //for value types and string just return the value as is if (c.SourceProp.Type.IsValueType || c.SourceProp.Type == typeof(string)) { return(c.SourceProp.Value); } //handle arrays if (c.SourceProp.Type.IsArray) { var arr = c.SourceProp.Value as Array; var clone = arr.Clone() as Array; for (int index = 0; index < arr.Length; index++) { var a = arr.GetValue(index); if (a.GetType().IsValueType || a.GetType() == typeof(string)) { continue; } clone.SetValue(Activator.CreateInstance(a.GetType()).InjectFrom <CloneInjection>(a), index); } return(clone); } if (c.SourceProp.Type.IsGenericType) { //handle IEnumerable<> also ICollection<> IList<> List<> if (c.SourceProp.Type.GetGenericTypeDefinition().GetInterfaces().Contains(typeof(IEnumerable))) { var t = c.SourceProp.Type.GetGenericArguments()[0]; if (t.IsValueType || t == typeof(string)) { return(c.SourceProp.Value); } /* * var tlist = typeof(List<>).MakeGenericType(t); * //var list = Activator.CreateInstance(tlist); * dynamic list = Activator.CreateInstance(tlist); * * var addMethod = tlist.GetMethod("Add"); * foreach (var o in c.SourceProp.Value as IEnumerable) { * var e = Activator.CreateInstance(t).InjectFrom<CloneInjection>(o); * //addMethod.Invoke(list, new[] { e }); // in 4.0 you can use dynamic and just do list.Add(e); * list.Add(e); * } * */ var tlist = typeof(List <>).MakeGenericType(t); dynamic list = Activator.CreateInstance(tlist); return(list); } //unhandled generic type, you could also return null or throw return(c.SourceProp.Value); } //for simple object types create a new instace and apply the clone injection on it return(Activator.CreateInstance(c.SourceProp.Type) .InjectFrom <CloneInjection>(c.SourceProp.Value)); }
protected override bool Match(ConventionInfo c) { _comparison = StringComparison.OrdinalIgnoreCase; return(base.Match(c)); }
protected override bool Match(ConventionInfo c) { var result = AuditNames.Contains(c.TargetProp.Name); return(result); }
protected override bool Match(ConventionInfo c) { return(c.SourceProp.Type == typeof(double) && c.TargetProp.Type == typeof(float)); }
private static object MapLists(ConventionInfo conventionInfo) { var genericArgument = conventionInfo.TargetProp.Type.GetGenericArguments()[0]; return(MapLists(genericArgument, conventionInfo.SourceProp.Value)); }
protected override bool Match(ConventionInfo c) { return(c.SourceProp.Name == c.TargetProp.Name && c.SourceProp.Type == typeof(string) && allowedProperties.Contains(c.SourceProp.Name)); }
protected override object SetValue(ConventionInfo c) { return(((Entity)c.SourceProp.Value).Id); }
protected override bool Match(ConventionInfo c) { return(c.TargetProp.Name == c.SourceProp.Name + "Id" && c.SourceProp.Type.IsSubclassOf(typeof(Entity)) && c.TargetProp.Type == typeof(int) && c.SourceProp.Value != null); }