public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { writer.WriteStartObject(); writer.WritePropertyName("@#IModel"); writer.WriteValue("0"); if (_writeTypeInfo) { writer.WritePropertyName("__type"); var valueType = value.GetType(); if (TypeCacheUtils.IsGeneratedType(valueType)) { valueType = valueType.BaseType; } if (valueType != null) { var assemblyQualifiedName = valueType.AssemblyQualifiedName; writer.WriteValue(assemblyQualifiedName); } } foreach (PropertyInfo prop in value.GetType().GetProperties()) { if (TypeCacheUtils.IsExcludedProperty(prop)) { continue; } //This check might be innecessary if we are serializing Deltas because the delta should not include the UniqueID if (!_writeUniqueId && string.Equals(prop.Name, "UniqueID")) { continue; } writer.WritePropertyName(prop.Name); serializer.Serialize(writer, prop.GetValue(value, null)); } writer.WriteEndObject(); }
private static void ReportOwnerException(PropertyInfoEx propEx, IStateObject newValue, string old_Uid) { var stackTrace = new System.Diagnostics.StackTrace(4, true); var ownerInfo = " Not owner info available"; var ownerObject = StateManager.Current.GetParentEx(newValue); if (ownerObject != null) { var format = " The owner of the object is an instance of class {0}, it is {1}. Look for property {2}. It could have been set during a Build call that is still of process or during an Initialize.Init which is the WebMap equivalent of a constructor. If it is used as parent reference reimplement the property as a non virtual, [StateManagement(None)] calculated property using ViewManager.GetParent(), you can also use [Reference] attribute or disable interception by removing virtual from the property"; if (StateManager.AllBranchesAttached(ownerObject)) { ownerInfo = string.Format(format, TypeCacheUtils.GetOriginalTypeName(ownerObject.GetType()), " ATTACHED ", StateManager.GetLastPartOfUniqueID(newValue)); } else { ownerInfo = string.Format(format, "NOT ATTACHED", TypeCacheUtils.GetOriginalTypeName(ownerObject.GetType()), StateManager.GetLastPartOfUniqueID(newValue)); } } throw new InvalidOperationException( "LazyBehaviour::ProcessSetter object has already an Owner." + ownerInfo + "\r\n" + "UniqueID: " + old_Uid + "\r\n" + "Additional Info: \r\n" + "ViewModel Type: " + newValue.GetType().FullName + "\r\n" + "Property Type: " + propEx.prop.PropertyType.FullName + "\r\n" + "Error Location: " + stackTrace.ToString()); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { Type valueType = value.GetType(); if (TypeCacheUtils.IsControlArray(valueType)) { writer.WriteStartObject(); var coll = (IObservableCollectionMarkerInterface)value; writer.WritePropertyName("UniqueID"); writer.WriteValue(coll.UniqueID); writer.WritePropertyName("Count"); writer.WriteValue(coll.Count); writer.WritePropertyName("@arr"); writer.WriteValue("1"); writer.WriteEndObject(); } else { try { base.WriteJson(writer, value, serializer); } catch (Exception ex) { System.Diagnostics.Debug.Fail("StateObjectSerializerIndex::WriteJSON error trying to seialize object " + ex.Message); writer.WriteStartObject(); writer.WriteEndObject(); } } }
private Delegate PublishInternal(EventPromiseInfo eventHandlerInfo, string eventId, IStateObject source, bool doNotCall, params object[] args) { var delegateType = TypeCacheUtils.GetType(eventHandlerInfo.DelegateType); Delegate eventDelegate = PromiseUtils.FromContinuationInfo(delegateType, eventHandlerInfo, source) as Delegate; if (eventDelegate == null) { TraceUtil.TraceError("EventAggregator::PublishInternal Error publishing event. Continuation could not be restored"); return(null); } if (doNotCall) { return(eventDelegate); } TraceUtil.TraceInformation("Publishing event " + eventId); if (eventDelegate != null) { try { eventDelegate.Method.Invoke(eventDelegate.Target, args); } catch (TargetInvocationException tiex) { var baseException = tiex.GetBaseException(); PreserveStackTrace(baseException); throw baseException; } } return(eventDelegate); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { JObject jobj = JObject.Load(reader); var assemblyQualifiedType = jobj["__type"].Value <string>(); Type targetType = Type.GetType(assemblyQualifiedType, false, false); if (TypeCacheUtils.IsControlArray(targetType)) { var size = jobj["Count"].Value <int>(); var uid = jobj["UniqueID"].Value <string>(); dynamic value = IocContainerImplWithUnity.Current.ResolveUnPrepared(targetType); value.SetupLazy(size, uid); return(value); } object newInstance = IocContainerImplWithUnity.Current.ResolveUnPrepared(targetType); foreach (JProperty prop in jobj.Properties().ToList()) { if (prop.Name == "__type") { continue; } //WARNING Fasterflect result might vary frp, the reflection results PropertyInfo reflectedProperty = targetType.Property(prop.Name); object adapterValue = Convert.ChangeType(prop.Value, reflectedProperty.PropertyType); reflectedProperty.SetValue(newInstance, adapterValue, null); } return(newInstance); }
/// <summary> /// Indicates if this is a valid type combination /// </summary> /// <param name="t"></param> /// <returns></returns> internal bool IsSupportedKeyValuePairDictionary(Type t) { if (t.IsGenericType) { var types = t.GetGenericArguments(); var key = types[0]; var value = types[1]; var validKey = (IsValueTypeOrStringOrTypeNotStruct(key) || typeof(IStateObject).IsAssignableFrom(key)); var validValue = (IsValueTypeOrStringOrType(value) || typeof(IStateObject).IsAssignableFrom(value) || SurrogatesDirectory.IsSurrogateRegistered(value)); if (!validValue && value.IsGenericType) { var genericValueType = value.GetGenericTypeDefinition(); if (genericValueType == typeof(IList <>)) { validValue = TypeCacheUtils.IsSupportedGenericTypeForList(value); } else if (genericValueType == typeof(IDictionary <,>)) { validValue = IsSupportedKeyValuePairDictionary(value); } } return(validKey && validValue); } throw new ArgumentException("This method should only be called for generic types"); }
/// <summary> /// Watchers can not be applied on IStateObjects. So we need to validate that /// </summary> /// <param name="type"></param> private static void ValidateWatcherType(MemberInfo memInfo) { Type type = null; string elementName = memInfo.Name; if (memInfo is FieldInfo) { var finfo = (FieldInfo)memInfo; type = finfo.FieldType; #if DEBUG Debug.Assert(!typeof(IStateObject).IsAssignableFrom(type), string.Format("DeltaTracker::ValidateWatcherType Error: The watcher attribute on {0}.{1} is wrong " + "because watcher attributes are meant to be used on fields that have a FieldType is not an IStateObject", TypeCacheUtils.GetOriginalTypeName(finfo.DeclaringType), elementName)); #endif } else if (memInfo is PropertyInfo) { var pinfo = (PropertyInfo)memInfo; type = pinfo.PropertyType; var isVirtual = pinfo.GetGetMethod().IsVirtual; Debug.Assert(!typeof(IStateObject).IsAssignableFrom(type) && !isVirtual, string.Format("DeltaTracker::ValidateWatcherType Error: The watcher attribute on {0}.{1} is wrong because watcher attributes are meant to be used on non-virtual properties of types that are not an IStateObject", TypeCacheUtils.GetOriginalTypeName(pinfo.DeclaringType), elementName)); } }
public static IEnumerable <PropertyInfo> GetPropertiesForAppState(Type type) { lock (syncPropsForAppState) { List <PropertyInfo> props; if (!propsfoprAppState.TryGetValue(type, out props)) { props = new List <PropertyInfo>(); foreach (PropertyInfo prop in type.Properties(BindingFlags.Public | BindingFlags.Instance)) { //We will load only Visual Objects or Lists if (typeof(IViewModel).IsAssignableFrom(prop.PropertyType) || typeof(IDependentViewModel).IsAssignableFrom(prop.PropertyType) || TypeCacheUtils.IsAnIListOfSomethingThatImplementsIStateObject(prop.PropertyType)) { //If this is a indexed property then skip if (prop.GetIndexParameters().Length > 0) { continue; } if (TypeCacheUtils.IsExcludedPropertyForClient(prop)) { continue; } props.Add(prop); } } propsfoprAppState.Add(type, props); } return(props); } }
public static void AddToTypeContractorCache(Type t) { if (SHORTENTYPENAME) { lock (SyncTypeTables) { if (TypeCacheUtils.IsGeneratedType(t)) { //We will map the intercept types to their base types //This typecontractor cache is used for serialization //We do not need to know the intercepted type var interceptedType = t; TypeCacheUtils.GetOriginalType(ref t); string currentKey; if (!typeContractorReverse.TryGetValue(t, out currentKey)) { AddToTypeContractorCache(t); currentKey = typeContractorReverse[t]; } typeContractorReverse.Add(interceptedType, currentKey); } else { string key = typeContractorForward.Count.ToBase95ToString(PADDEDCONTRACTEDTYPENAME); if (key.Length == 1) { key += '~'; //by now the size is 2 then only add one char '~' } typeContractorForward.Add(key, t); typeContractorReverse.Add(t, key); } } } }
private object ReadInputAsType() { object val = reader.Value; reader.Read(); val = TypeCacheUtils.GetType((string)val); return(val); }
public override JsonContract ResolveContract(Type type) { //We do not want two different contracts for the proxy type and the actual type if (TypeCacheUtils.IsGeneratedType(type)) { TypeCacheUtils.GetOriginalType(ref type); } return(base.ResolveContract(type)); }
public override void BindToName(Type serializedType, out string assemblyName, out string typeName) { //var longAssemblyName = serializedType.Assembly.FullName; if (TypeCacheUtils.IsGeneratedType(serializedType)) { serializedType = serializedType.BaseType; } TypeCacheUtils.AssemblyQualifiedNameCache(serializedType, out assemblyName, out typeName); }
public void Initialize(IStateManager stateManager, IReferenceManager referenceManager, ISurrogateManager surrogateManager) { this.stateManager = stateManager; this.referenceManager = referenceManager; this.surrogateManager = surrogateManager; var tkey = typeof(TKey); var tvalue = typeof(TValue); var tkeyIsValueTypeOrStringOrTypeNotStruct = IsValueTypeOrStringOrTypeNotStruct(tkey); var tvalueIsValueTypeOrString = IsValueTypeOrStringOrType(tvalue); if (tkeyIsValueTypeOrStringOrTypeNotStruct && tvalueIsValueTypeOrString) { implementation = new DictCase1 <TKey, TValue>(); CaseType = 1; } else if (tkeyIsValueTypeOrStringOrTypeNotStruct && (typeof(IStateObject).IsAssignableFrom(tvalue) || TypeCacheUtils.IsIListOrIDictionary(tvalue)) ) { implementation = new DictCase2 <TKey, TValue>(stateManager, referenceManager); ((DictCase2 <TKey, TValue>)implementation).SetParent(this); CaseType = 2; } else if (tkeyIsValueTypeOrStringOrTypeNotStruct && typeof(Delegate).IsAssignableFrom(tvalue)) { implementation = new DictCase5 <TKey, TValue>(stateManager, surrogateManager); CaseType = 5; } else if (typeof(IStateObject).IsAssignableFrom(tkey) && tvalueIsValueTypeOrString) { implementation = new DictCase3 <TKey, TValue>(); CaseType = 3; } else if (typeof(IStateObject).IsAssignableFrom(tkey) && (typeof(IStateObject).IsAssignableFrom(tvalue) || TypeCacheUtils.IsIListOrIDictionary(tvalue)) ) { implementation = new DictCase4 <TKey, TValue>(); CaseType = 4; } else if (tkeyIsValueTypeOrStringOrTypeNotStruct && SurrogatesDirectory.IsSurrogateRegistered(tvalue)) { implementation = new DictCase6 <TKey, TValue>(stateManager, surrogateManager, referenceManager); ((DictCase6 <TKey, TValue>)implementation).SetParent(this); CaseType = 6; } else { throw new NotSupportedException(); } }
public override bool IsCompatibleWith(object value) { var valueType = value.GetType(); if (valueType.IsValueType && TypeCacheUtils.IsAnUserStructType(valueType)) { return(true); } return(false); }
public static int GetModelTypedInt(Type type) { if (TypeCacheUtils.IsGeneratedType(type)) { type = type.BaseType; } int mappedType = 0; ClientSideMappingInfo.TryGetValue(type, out mappedType); return(mappedType); }
/// <summary> ///If field is an Action<> there is no problem ///but if field is Func<> then that means that ///for int Foo(bool,string) it would be something ///like int,bool,string and to find foo we would need to do GetMethod("Foo",,{ bool,string} ); /// </summary> /// <param name="field">field containing delegate inside a DisplayClass</param> /// <returns></returns> private static Type[] ExtractParameterTypesForDelegateInField(FieldInfo field) { var parameterTypes = field.FieldType.GetGenericArguments(); if (TypeCacheUtils.IsFuncType(field.FieldType)) { var res = new Type[parameterTypes.Length - 1]; Array.Copy(parameterTypes, 0, res, 0, res.Length); parameterTypes = res; } return(parameterTypes); }
internal static void RegisterDeltaTrackerConverter(Type converterType, AppStateJsonConverter att) { var modelTypeID = TypeCacheUtils.GetModelTypedInt(att.Model); if (modelTypeID <= 0) { throw new ArgumentException("A Delta Tracker Converter cannot be registered for type " + att.Model); } var converter = converterType.DelegateForCallMethod("ProcessDelta", new Type[] { typeof(object), typeof(object) }); converters.Add(modelTypeID, converter); }
public SerializerMethods(JsonReader reader, Type keyType, Type valueType) { this.reader = reader; this.keyType = keyType; this.valueType = valueType; //First assign delegate depending on keyType if (typeof(string) == keyType) { ReadKeyMethod = ReadInputAsString; } else if (typeof(Type) == keyType) { ReadKeyMethod = ReadInputAsType; } else if (typeof(IStateObject).IsAssignableFrom(keyType)) { ReadKeyMethod = ReadInputAsStateObject; } else if (keyType.IsEnum) { ReadKeyMethod = ReadInputAsEnum; } else { ReadKeyMethod = ReadInputAsOther; } //Second assign delegate depending on valueType if (typeof(string) == valueType) { ReadValueMethod = ReadInputAsString; } else if (typeof(Type) == valueType) { ReadValueMethod = ReadInputAsType; } else if (valueType.IsEnum) { ReadValueMethod = ReadInputValueAsEnum; } else if (typeof(IStateObject).IsAssignableFrom(valueType) || TypeCacheUtils.IsIListOrIDictionary(valueType) || typeof(Delegate).IsAssignableFrom(valueType) || SurrogatesDirectory.IsSurrogateRegistered(valueType)) { ReadValueMethod = ReadInputAsStateObject; } else { ReadValueMethod = ReadInputValueAsOther; } }
public T PublishDelegate <T>(string eventId) { Delegate result = null; var eventHandlerInfo = _stateManager.GetObject(eventId) as EventPromiseInfo; if (eventHandlerInfo != null) { var delegateType = TypeCacheUtils.GetType(eventHandlerInfo.DelegateType); result = PromiseUtils.FromContinuationInfo(delegateType, eventHandlerInfo) as Delegate; } return(result == null ? default(T) : (T)(object)Delegate.CreateDelegate(typeof(T), result.Target, result.Method)); }
internal static void InitializeResolver() { StaticContainer.InitContainer = () => IocContainerImplWithUnity.Current; ConventionBasedHelper.Container = IocContainerImplWithUnity.Current; //REgister ContinuationInfo for shorten type info on JSON TypeCacheUtils.AddToTypeContractorCache(typeof(PromiseInfo)); TypeCacheUtils.AddToTypeContractorCache(typeof(UniqueIDGenerator)); TypeCacheUtils.AddToTypeContractorCache(typeof(ViewsState)); TypeCacheUtils.AddToTypeContractorCache(typeof(List <ViewInfo>)); TypeCacheUtils.AddToTypeContractorCache(typeof(List <ClientCommand>)); TypeCacheUtils.AddToTypeContractorCache(typeof(List <PromiseInfo>)); TypeCacheUtils.AddToTypeContractorCache(typeof(List <string>)); TypeCacheUtils.AddAssemblyToTypeContractorCache(typeof(int).Assembly); TypeCacheUtils.AddAssemblyToTypeContractorCache(typeof(Bootstrapper).Assembly); }
/// <summary> /// Makes sure that client metadata is already loaded /// </summary> public static void LoadClientTypeMetadataTable() { bool hasValues = TypeCacheUtils.DefaultAndAliasMappings.Count > 0; if (!hasValues) { Debug.WriteLine("Loading Client Type Metadata tables"); foreach (var item in TypeCacheUtils.ClientSideMappingInfo) { try { TypeCacheUtils.FillDefaultAndAliasInfoForType(item.Key, item.Value); } catch (Exception) { /*Ignore exception */ } } Debug.WriteLine("Finished Loading Client Type Metadata tables"); } }
public SerializerMethods(JsonWriter writer, Type keyType, Type valueType) { this.writer = writer; this.keyType = keyType; this.valueType = valueType; //First assign delegate depending on keyType if (typeof(string) == keyType) { WriteKeyMethod = WriteKeyGeneric; } else if (typeof(Type) == keyType) { WriteKeyMethod = WriteKeyType; } else if (typeof(IStateObject).IsAssignableFrom(keyType)) { WriteKeyMethod = WriteKeyStateObject; } else { WriteKeyMethod = WriteKeyGeneric; } //Second assign delegate depending on valueType if (typeof(string) == valueType) { WriteValueMethod = WriteValueGeneric; } else if (typeof(Type) == valueType) { WriteValueMethod = WriteValueType; } else if (typeof(IStateObject).IsAssignableFrom(valueType) || TypeCacheUtils.IsIListOrIDictionary(valueType) || typeof(Delegate).IsAssignableFrom(valueType) || SurrogatesDirectory.IsSurrogateRegistered(valueType)) { WriteValueMethod = WriteValueStateObject; } else { WriteValueMethod = WriteValueGeneric; } }
private static void RestoreDelegateField(BinaryReader reader, object instance, FieldInfo field) { //First we retrieve the ID for the target object of delegate var targetID = reader.ReadString(); if (targetID == "NULL") { //This is an static method var declaringTypeName = reader.ReadString(); var declaringType = TypeCacheUtils.GetType(declaringTypeName); } else if (targetID == "INST") { var methodName = reader.ReadString(); //Is this an Action<> or Func<> if (field.FieldType.IsGenericType) { Type[] parameterTypes = ExtractParameterTypesForDelegateInField(field); var methodInfo = instance.GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, null, parameterTypes, null); var delegateValue = CreateDelegateFromMethodInfo(instance, methodInfo); field.SetValue(instance, delegateValue); } } else { var targetInstance = StateManager.Current.GetObject(targetID); if (targetInstance == null) { throw new NotSupportedException("Instance for delegate could not be retrieved"); } //This is an IStateObject var methodName = reader.ReadString(); //Is this an Action<> or Func<> if (field.FieldType.IsGenericType) { Type[] parameterTypes = ExtractParameterTypesForDelegateInField(field); var methodInfo = instance.GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, null, parameterTypes, null); var delegateValue = CreateDelegateFromMethodInfo(targetInstance, methodInfo); field.SetValue(instance, delegateValue); } } }
private void ProcessIfOrphan() { if (!StateManager.AllBranchesAttached(_current.UniqueID)) { //If we enter here we are Orphans :( //We asumme we got here because we are inside a surrogate and //that means that there is an StateObjectSurrogate associated with the parentObject if (parentCandidate == null) { var typeName = TypeCacheUtils.GetOriginalTypeName(_current.GetType()); throw new NotSupportedException("The wrapped stated of type " + typeName + "object with ID" + _current.UniqueID + " does not have a valid parent reference"); } var parentSurrogate = StateManager.Current.surrogateManager.GetSurrogateFor(parentCandidate, generateIfNotFound: false); if (parentSurrogate == null) { var typeName = TypeCacheUtils.GetOriginalTypeName(_current.GetType()); throw new NotSupportedException("The wrapped stated of type " + typeName + "object with ID" + _current.UniqueID + " does not have a valid parent SURROGATE reference"); } AdoptionInformation.StaticAdopt(parentSurrogate, _current); } }
private static string LoadTypeTable() { var res = new Dictionary <string, string>(StringComparer.Ordinal); TypeCacheUtils.LoadClientTypeMetadataTable(); foreach (var item in TypeCacheUtils.ClientSideMappingInfo) { res.Add(item.Value + "", item.Key.FullName.Replace('.', '_')); } var serializer = new Newtonsoft.Json.JsonSerializer(); var result = new Result() { DefaultsAndAlias = TypeCacheUtils.DefaultAndAliasMappings, TypesInfo = res }; var stringWriter = new System.IO.StringWriter(); serializer.Serialize(stringWriter, result); var typeInfoTable = stringWriter.ToString(); return(typeInfoTable); }
public object ObjectToRaw(object obj) { var builderObjectToRaw = new StringBuilder(500); using (var writerObjectToRaw = new StringWriter(builderObjectToRaw)) { var type = obj.GetType(); //No longer necessary TypeCacheUtils typeMarks make the mark of the //UnIntercepted and InterceptedTypes equal //if (TypeCacheUtils.IsGeneratedType(type)) //{ // TypeCacheUtils.GetOriginalType(ref type); //} //builderObjectToRaw.Clear(); string typeMark = null; if (TypeCacheUtils.ISSAFETOSHORTENALLTYPES && TypeCacheUtils.SHORTENTYPENAME) { typeMark = TypeCacheUtils.AssemblyQualifiedNameCache(type); } #pragma warning disable 0162 else { typeMark = TypeCacheUtils.AssemblyQualifiedNameCache(type); } #pragma warning restore 0162 builderObjectToRaw.Append(typeMark); var depentdsC = obj as IDependentsContainer; if (depentdsC != null && depentdsC.Dependents != null) { builderObjectToRaw.Append(string.Join(",", depentdsC.Dependents)); } builderObjectToRaw.Append("?"); using (JsonTextWriter jw = new JsonTextWriter(writerObjectToRaw)) { jw.ArrayPool = JsonArrayPool.Instance; sessionStorageSerializer.Serialize(writerObjectToRaw, obj, type); } } return(builderObjectToRaw.ToString()); }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { writer.WriteStartObject(); writer.WritePropertyName("$type"); var valueType = value.GetType(); if (TypeCacheUtils.IsGeneratedType(valueType)) { valueType = valueType.BaseType; } if (valueType != null) { var assemblyQualifiedName = valueType.AssemblyQualifiedName; writer.WriteValue(assemblyQualifiedName); } var viewmodel = (IStateObject)value.GetPropertyValue("ViewModel"); var uid = viewmodel.UniqueID; writer.WritePropertyName("UniqueID"); writer.WriteValue(uid); writer.WriteEndObject(); }
protected override List <MemberInfo> GetSerializableMembers(Type type) { if (TypeCacheUtils.IsAnStructType(type) || (type == typeof(CurrentState)) || (type == typeof(ViewsState)) || (type == typeof(ClientCommand))) { return(base.GetSerializableMembers(type)); } List <MemberInfo> props = new List <MemberInfo>(); foreach (var propEx in TypePropertiesCache.GetArrayPropertiesOrderedByIndex(type)) { if (propEx != null && !propEx.IsExcludedPropertyForSerialization(serverSide, skipUniqueId, skipObjectProperties)) { props.Add(propEx.prop); } } return(props); }
public System.Web.Mvc.ActionResult QueryClose(string viewId) { //Find corresponding Form Type var genericInterface = typeof(UpgradeHelpers.Interfaces.ILogicWithViewModel <>); var view = StateManager.Current.GetObject(viewId) as UpgradeHelpers.Interfaces.IViewModel; if (view == null) { TraceUtil.TraceError("QueryClose issue for View {0}", viewId); return(new UpgradeHelpers.WebMap.Server.AppChanges()); } var viewType = view.GetType(); //Get original type if View was instrumented TypeCacheUtils.GetOriginalType(ref viewType); var interfaceBindingFormAndViewTogether = genericInterface.MakeGenericType(viewType); //I assume that the matching form logic is defined in the same assembly and that there is only one foreach (var clazz in viewType.Assembly.GetTypes()) { if (interfaceBindingFormAndViewTogether.IsAssignableFrom(clazz)) { var logic = IocContainerImplWithUnity.Current.Resolve(clazz, new object[] { view, }) as UpgradeHelpers.Interfaces.ILogicWithViewModel <UpgradeHelpers.Interfaces.IViewModel>; if (logic == null) { TraceUtil.WriteLine("WebMapViewManagerController::QueryClose error could not recover form object"); } else { ViewManager.DisposeView(logic); } break; } } return(new UpgradeHelpers.WebMap.Server.AppChanges()); }
internal void RegisterType(Type typeToRegister) { #if DETAILED_DEBUG Trace.TraceInformation("Processing type " + typeToRegister.FullName); #endif if (typeToRegister != null && typeof(IStateObject).IsAssignableFrom(typeToRegister) && //This is to make eliminating false cases faster (typeof(IDependentModel).IsAssignableFrom(typeToRegister) || typeof(IDependentViewModel).IsAssignableFrom(typeToRegister) || typeof(IViewModel).IsAssignableFrom(typeToRegister) || (typeof(IModel).IsAssignableFrom(typeToRegister)))) { try { if (!typeToRegister.IsAbstract && !typeToRegister.IsInterface) { if (typeof(NoInterception).IsAssignableFrom(typeToRegister)) { TraceUtil.TraceInformation("Excluding type from interception " + typeToRegister.FullName); non_interceptedTypes.Add(typeToRegister); } else { interceptedTypes.Add(typeToRegister); if (!typeToRegister.IsGenericType) { InitializationHelpers.LoadTypeHierarchy(typeToRegister); } } TypeCacheUtils.AddClientTypeRegistration(typeToRegister); } } catch (Exception registerTypeException) { Trace.TraceError("Bootstrapper::RegisterAllTypes problem while registering type " + typeToRegister.FullName + " Message " + registerTypeException.Message); } } }