/// <summary> /// Cria o gerador associado com o tipo informado. /// </summary> /// <param name="typeName"></param> /// <returns></returns> public Query.IRecordKeyGenerator CreateGenerator(Colosoft.Reflection.TypeName typeName) { typeName.Require("typeName").NotNull(); Query.IRecordKeyGenerator result = null; var key = typeName.FullName; lock (_generators) if (_generators.TryGetValue(key, out result)) { return(result); } var typeMetadata = _typeSchema.GetTypeMetadata(key); if (typeMetadata == null) { result = new DefaultRecordKeyGenerator(typeName); } else { var keys = typeMetadata.GetKeyProperties().Select(f => f.Name).ToArray(); result = new Generator(typeName, _cultureInfo, keys); } lock (_generators) if (!_generators.ContainsKey(key)) { _generators.Add(key, result); } return(result); }
/// <summary> /// Adiciona os identificadores das propriedades. /// </summary> /// <param name="entityTypeName">Tipo da entidade.</param> /// <param name="nestedTypes">Rleção dos tipos aninhados.</param> /// <param name="listToAppend">Lista onde será adicionada a relação do caminho com a especiação para o caminho da propriedade</param> /// <param name="startString">Texto com o inicio do caminho para alcançar a propriedade.</param> /// <param name="clearPath"></param> /// <param name="propertyPath">Caminho para alcançar a propriedade.</param> /// <param name="currentSpecilizeString">Texto que representa a especialização.</param> private void PutsPropertiesIdentifier(Colosoft.Reflection.TypeName entityTypeName, List <Colosoft.Reflection.TypeName> nestedTypes, Dictionary <string, string> listToAppend, string startString, string clearPath, string propertyPath, string currentSpecilizeString) { IEnumerable <IEntityPropertyInfo> properties = _validationManager.LoadTypeProperties(entityTypeName); if (properties != null) { foreach (IEntityPropertyInfo property in properties) { string newPropertyPath = string.IsNullOrEmpty(propertyPath) ? property.FullName : string.Format("{0}.{1}", propertyPath, property.FullName); if (!string.IsNullOrEmpty(currentSpecilizeString)) { listToAppend.Add(string.Format("{0}{1}.{2}", startString, currentSpecilizeString, property.FullName), newPropertyPath); } else { listToAppend.Add((startString + property.FullName), newPropertyPath); } if (property.IsInstance && !nestedTypes.Contains(property.PropertyType, Colosoft.Reflection.TypeName.TypeNameFullNameComparer.Instance)) { var aux = GetIdentifierSpecialize(property.PropertyType, string.Format("{0}{1}.{2}.", startString, currentSpecilizeString, property.FullName), string.Format("{0}{1}.", clearPath, property.FullName), newPropertyPath, nestedTypes); foreach (var kp in aux) { listToAppend.Add(kp.Key, kp.Value); } } } } }
/// <summary> /// Recupera o identificador do manipulador do tipo informado. /// </summary> /// <param name="typeName"></param> /// <returns></returns> public int GetHandleId(Colosoft.Reflection.TypeName typeName) { string typeFullname = typeName.FullName; int handleId = 0; lock (_objLock) if (_typeToHandleMap.TryGetValue(typeFullname, out handleId)) { return(handleId); } if (typeName != null) { var typeMap = GetTypeMap(typeName); if (typeMap != null) { handleId = _typeHandle++; lock (_objLock) { _typeToHandleMap.Add(typeFullname, handleId); _map.Add(handleId, typeMap); } OnHandleAdded(handleId); return(handleId); } } lock (_objLock) _typeToHandleMap.Add(typeFullname, -1); return(-1); }
/// <summary> /// Cria uma instancia com os dados da entrada. /// </summary> /// <param name="typeName">Nome do tipo da entrada.</param> /// <param name="version"></param> /// <param name="queryResult">Resultado dos itens da entrada.</param> public DataEntry(Colosoft.Reflection.TypeName typeName, DateTime version, Query.IQueryResult queryResult) { typeName.Require("typeName").NotNull(); _typeName = typeName; _version = version; _result = queryResult; }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="typeName"></param> /// <param name="changeType"></param> /// <param name="record"></param> /// <param name="recordKey"></param> public TypeRecordChangedEventArgs(Colosoft.Reflection.TypeName typeName, TypeRecordChangeType changeType, IRecord record, RecordKey recordKey) { _typeName = typeName; _changeType = changeType; _record = record; _recordKey = recordKey; }
/// <summary> /// Método acionado quando um registro for inserido. /// </summary> /// <param name="typeName"></param> /// <param name="record"></param> protected virtual void OnTypeRecordInserted(Colosoft.Reflection.TypeName typeName, IRecord record) { if (TypeRecordChanged != null) { TypeRecordChanged(this, new TypeRecordChangedEventArgs(typeName, TypeRecordChangeType.Insert, record, null)); } }
/// <summary> /// Método acionado quando um registro for apagado. /// </summary> /// <param name="typeName"></param> /// <param name="recordKey"></param> protected virtual void OnTypeRecordDeleted(Colosoft.Reflection.TypeName typeName, RecordKey recordKey) { if (TypeRecordChanged != null) { TypeRecordChanged(this, new TypeRecordChangedEventArgs(typeName, TypeRecordChangeType.Delete, null, recordKey)); } }
/// <summary> /// Notifica que ocorreu um erro ao carregar as expecialização para a entidade. /// </summary> /// <param name="entityTypeName">Nome da entidade na qual a especialização foi carregada.</param> /// <param name="specialization">Instancia da especialização caso ela tenha sido carregada.</param> /// <param name="error">Error ocorrido.</param> public void OnEntitySpecializationError(Colosoft.Reflection.TypeName entityTypeName, Colosoft.Validation.IEntitySpecialization specialization, Exception error) { foreach (var i in this.Observers) { i.OnEntitySpecializationError(entityTypeName, specialization, error); } }
/// <summary> /// Processa a ação de exclusão. /// </summary> /// <param name="action"></param> private void ProcessDeleteAction(PersistenceAction action) { var observerManager = Colosoft.Query.RecordObserverManager.Instance; if (observerManager == null) { return; } Colosoft.Reflection.TypeName typeName = null; Query.Record record; Query.RecordKey recordKey; var deleteActionResult = action.Parameters.Where(f => f.Name == DeleteActionResultParameterName).Select(f => (IDeleteActionResult)f.Value).FirstOrDefault(); IEnumerable <Colosoft.Query.RecordKey> recordKeys = null; if (deleteActionResult == null) { typeName = GetActionRecord(action, out record, out recordKey); recordKeys = new Colosoft.Query.RecordKey[] { recordKey }; } else { typeName = new Reflection.TypeName(action.EntityFullName); recordKeys = deleteActionResult.RecordKeys; } observerManager.NotifyRecordDeleted(typeName, recordKeys); }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="dataSource"></param> /// <param name="recordValues">Instancia do registro que será processado.</param> /// <param name="recordDescriptor"></param> /// <param name="entityTypeName">Nome do tipo da entidade associada.</param> public RegisterRecordAsyncTask(DynamicQueryDataSource dataSource, object[] recordValues, Record.RecordDescriptor recordDescriptor, Colosoft.Reflection.TypeName entityTypeName) { _dataSource = dataSource; _recordValues = recordValues; _recordDescriptor = recordDescriptor; _entityTypeName = entityTypeName; }
/// <summary> /// Remove o registro do observer. /// </summary> /// <param name="typeName"></param> /// <param name="observer"></param> public void Unregister(Colosoft.Reflection.TypeName typeName, IQueryResultChangedObserver observer) { if (IsEnabled) { var typeNameEntry = GetTypeNameEntry(typeName); typeNameEntry.RemoveObserver(observer); } }
/// <summary> /// Registra o observer para o resultado da consulta. Toda vez /// que ocorrer alguma alteração que implique sobre os dados /// do resultado o observer será notificado. /// </summary> /// <param name="typeName">Nome do tipo no qual o resultado se basea.</param> /// <param name="observer">Instancia do observer.</param> public void Register(Colosoft.Reflection.TypeName typeName, IQueryResultChangedObserver observer) { if (IsEnabled && IsValidType(typeName)) { var typeNameEntry = GetTypeNameEntry(typeName); typeNameEntry.AddObserver(observer); } }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="typeName"></param> /// <param name="cultureInfo"></param> /// <param name="fieldNames"></param> internal Generator(Colosoft.Reflection.TypeName typeName, System.Globalization.CultureInfo cultureInfo, string[] fieldNames) { typeName.Require("typeName").NotNull(); fieldNames.Require("fieldNames").NotNull(); _typeName = typeName; _cultureInfo = cultureInfo; _fieldNames = fieldNames; }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="contractTypeName"></param> /// <param name="contractName"></param> /// <param name="type"></param> public ContractInfo(Colosoft.Reflection.TypeName contractTypeName, string contractName, Colosoft.Reflection.TypeName type) { _contractName = contractName; _contractTypeName = contractTypeName; if (type != null) { _types.Add(type); } }
/// <summary> /// Construtor de inicialização. /// </summary> /// <param name="typeName"></param> /// <param name="exports"></param> /// <param name="imports"></param> /// <param name="useDispatcher"></param> /// <param name="importingConstruct"></param> /// <param name="partCreationPolicy"></param> public PartDescription(Colosoft.Reflection.TypeName typeName, IEnumerable <ExportDescription> exports, IEnumerable <ImportDescription> imports, bool useDispatcher, ImportingConstructorDescription importingConstruct = null, System.ComponentModel.Composition.CreationPolicy partCreationPolicy = System.ComponentModel.Composition.CreationPolicy.Shared) { this.UseDispatcher = useDispatcher; this.Exports = exports; this.Imports = imports; this.ImportingConstructor = importingConstruct; this.TypeName = typeName; this.PartCreationPolicy = partCreationPolicy; }
/// <summary> /// Recupera o notificador de alterações no registro. /// </summary> /// <param name="typeName"></param> /// <param name="recordKey"></param> /// <returns></returns> public IRecordObserverNotifier GetRecordChangedNotifier(Colosoft.Reflection.TypeName typeName, RecordKey recordKey) { if (IsEnabled) { var typeNameEntry = GetTypeNameEntry(typeName); return(typeNameEntry.GetNotifier(recordKey)); } return(null); }
/// <summary> /// Adicionar o tipo que deve ser ignorado pelo gerenciador. /// </summary> /// <param name="typeName"></param> public void IgnoreType(Colosoft.Reflection.TypeName typeName) { typeName.Require("typeName").NotNull(); int index = _ignoreTypes.BinarySearch(typeName, Colosoft.Reflection.TypeName.TypeNameFullNameComparer.Instance); if (index < 0) { _ignoreTypes.Insert(~index, typeName); } }
/// <summary> /// Método acioando quando ocorre uma falha ao carrega o tipo. /// </summary> /// <param name="type"></param> /// <param name="exception"></param> protected virtual void OnFailLoadType(Colosoft.Reflection.TypeName type, Exception exception) { var e = new FailOnLoadTypeEventArgs(type, exception); if (FailOnLoadType != null) { FailOnLoadType(this, e); } _observer.FailOnLoadType(e); }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="catalog"></param> /// <param name="typeName"></param> /// <param name="exportDefinitions"></param> /// <param name="importDefinitions"></param> /// <param name="parameterImportDefinitions"></param> /// <param name="partCreationPolicy"></param> /// <param name="useDispatcher"></param> public ProviderComposablePartDefinition(ComposablePartCatalog catalog, Colosoft.Reflection.TypeName typeName, IList <ProviderExportDefinition> exportDefinitions, Lazy <IEnumerable <ImportDefinition> > importDefinitions, ProviderParameterImportDefinitionContainer parameterImportDefinitions, System.ComponentModel.Composition.CreationPolicy partCreationPolicy, bool useDispatcher) { _exports = exportDefinitions.Cast <ExportDefinition>().ToArray(); _imports = importDefinitions; _parameterImportDefinitions = parameterImportDefinitions; _catalog = catalog; _typeName = typeName; _partCreationPolicy = partCreationPolicy; _useDispatcher = useDispatcher; }
/// <summary> /// Move para o próximo nome de tipo que será processado. /// </summary> /// <returns></returns> private bool MoveNextTypeMetadata() { while (_typeMetadatasEnumerator != null && _typeMetadatasEnumerator.MoveNext()) { var typeMetadata = _typeMetadatasEnumerator.Current; _loader.Observer.OnStageChanged(new CacheLoaderStage("LoadingType", ResourceMessageFormatter.Create(() => Properties.Resources.CacheLoader_LoadingTypeName, typeMetadata.FullName))); _loader.Observer.OnCurrentProgressChanged(new System.ComponentModel.ProgressChangedEventArgs((_position++ *100 / _typeMetadatasCount), null)); if (_loader.Observer is IDataCacheLoaderObserver) { ((IDataCacheLoaderObserver)_loader.Observer).OnBeginLoadTypeMetadata(typeMetadata); } var typeName = new Colosoft.Reflection.TypeName(!string.IsNullOrEmpty(typeMetadata.Assembly) ? string.Format("{0}, {1}", typeMetadata.FullName, typeMetadata.Assembly) : typeMetadata.FullName); Query.IQueryResult result = null; try { var columns = new List <Query.ProjectionEntry>(typeMetadata.Select(f => new Query.ProjectionEntry(f.Name, null))); if (typeMetadata.IsVersioned && !columns.Exists(f => { var column = f.GetColumnInfo(); return(column != null && StringComparer.InvariantCultureIgnoreCase.Equals(column.Name, "RowVersion")); })) { columns.Add(new ProjectionEntry("RowVersion", null)); } result = _loader.SourceContext.CreateQuery().From(new Query.EntityInfo(typeMetadata.FullName)).Select(new Query.Projection(columns)).NoUseCache().Execute(); _recordEnumerator = result.GetEnumerator(); } catch (Exception ex) { var args = new CacheLoaderErrorEventArgs(ResourceMessageFormatter.Create(() => Properties.Resources.DataCacheLoader_CreateQueryError, typeMetadata.FullName), ex); _loader.OnLoadError(typeName, args); if (_loader.Observer is IDataCacheLoaderObserver) { ((IDataCacheLoaderObserver)_loader.Observer).OnEndLoadTypeMetadata(typeMetadata, ex); } continue; } _currentTypeName = typeName; _currentGenerator = _loader.RecordKeyFactory.CreateGenerator(_currentTypeName); return(true); } _currentTypeName = null; _currentGenerator = null; if (_recordEnumerator != null) { try { _recordEnumerator.Dispose(); } catch { } } _recordEnumerator = null; return(false); }
/// <summary> /// Tenta recupera as propriedade da versão do tipo da entidade com base no tipo informado. /// </summary> /// <param name="typeName">Tipo da versão da entidade.</param> /// <param name="uiContext">Nome do contexto visual usado para filtrar os dados.</param> /// <returns></returns> public IEnumerable <BusinessEntityTypeVersionProperty> GetTypeProperties(Colosoft.Reflection.TypeName typeName, string uiContext = null) { var key = CreateTypeVersionKey(typeName); BusinessEntityTypeVersion entityTypeVersion = null; if (_typeVersions.TryGetValue(key, out entityTypeVersion)) { return(entityTypeVersion.Properties.Where(f => uiContext == null || f.UIConfigurations.Where(x => x.UIContext == uiContext).Any())); } return(new BusinessEntityTypeVersionProperty[0]); }
/// <summary> /// Tenta recupera os dados da versão do tipo da entidade com base /// no tipo informado. /// </summary> /// <param name="typeName">Tipo que será pesquisado.</param> /// <returns>Versão do tipo da entidade correspondente ou null.</returns> public BusinessEntityTypeVersion GetTypeVersion(Colosoft.Reflection.TypeName typeName) { var key = CreateTypeVersionKey(typeName); BusinessEntityTypeVersion entityTypeVersion = null; if (_typeVersions.TryGetValue(key, out entityTypeVersion)) { return(entityTypeVersion); } return(null); }
/// <summary> /// Recupera o mapa para o nome do tipo informado. /// </summary> /// <param name="typeName"></param> /// <returns></returns> private Dictionary <string, object> GetTypeMap(Colosoft.Reflection.TypeName typeName) { var result = new Dictionary <string, object>(); result.Add("name", typeName.FullName); var attributes = new Dictionary <string, string>(); var sequence = new List <string>(); result.Add("attributes", attributes); result.Add("sequence", sequence); return(result); }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="entityLoader">Instancia do loader da entidade associada.</param> /// <param name="entityTypeManager">Instancia do gerenciador dos tipos de entidades.</param> /// <param name="sourceContext">Contexto de origem.</param> /// <param name="uiContext">Contexto de interface com o usuário.</param> /// <param name="typeName">Nome do associado com o observer.</param> /// <param name="collection">Coleção que sera observada.</param> public BusinessQueryResultChangedObserver(IEntityLoader entityLoader, IEntityTypeManager entityTypeManager, Query.ISourceContext sourceContext, string uiContext, Colosoft.Reflection.TypeName typeName, System.Collections.IList collection) : base(collection) { _entityLoader = entityLoader; _entityTypeManager = entityTypeManager; _sourceContext = sourceContext; _uiContext = uiContext; _typeName = typeName; if (Colosoft.Query.RecordObserverManager.Instance.IsEnabled) { Colosoft.Query.RecordObserverManager.Instance.Register(_typeName, this); } }
/// <summary> /// Recupera o membro específico. /// </summary> /// <param name="typeName"></param> /// <param name="memberName"></param> /// <returns>A <see cref="System.Reflection.MemberInfo"/> object.</returns> public System.Reflection.MemberInfo GetMemberInfo(Colosoft.Reflection.TypeName typeName, string memberName) { typeName.Require("typeName").NotNull(); System.Reflection.Assembly assembly = null; if (!_assemblies.TryGet(typeName.AssemblyName.Name, out assembly)) { throw new InvalidOperationException(string.Format("Not found assembly '{0}'", typeName.AssemblyName.Name)); } Type inspectedType = assembly.GetType(typeName.FullName, true, true); return((string.IsNullOrEmpty(memberName)) ? inspectedType : inspectedType.GetMember(memberName).FirstOrDefault()); }
/// <summary> /// Executa a ação para apagar os ados do registro no cache. /// </summary> /// <param name="action"></param> /// <returns></returns> private PersistenceActionResult ExecuteDeleteAction(PersistenceAction action) { var typeMetadata = _typeSchema.GetTypeMetadata(action.EntityFullName); if (typeMetadata == null) { return new PersistenceActionResult { Success = false, FailureMessage = ResourceMessageFormatter.Create(() => Properties.Resources.CachePersistenceExecuter_TypeMetadataNotFound, action.EntityFullName).Format(), } } ; var query = GetActionQuery(action, typeMetadata).CreateQueryInfo(); Queries.QueryResultSet queryResult = null; try { queryResult = ((CacheDataSource)_sourceContext.DataSource).ExecuteInCache(query); } catch (Exception ex) { return(new PersistenceActionResult { Success = false, FailureMessage = ResourceMessageFormatter.Create(() => Properties.Resources.CachePersistenceExecuter_ExecuteQueryInCacheError, Colosoft.Diagnostics.ExceptionFormatter.FormatException(ex, true)).Format() }); } var typeName = new Colosoft.Reflection.TypeName(action.EntityFullName); var keyGenerator = _keyFactory.Value.CreateGenerator(typeName); var recordKeys = new List <RecordKey>(); using (var recordEnumerator = new Colosoft.Caching.Queries.QueryResultSetRecordEnumerator(_typeSchema, Cache, queryResult, query)) { while (recordEnumerator.MoveNext()) { recordKeys.Add(RecordKeyFactory.Instance.Create(typeName, recordEnumerator.Current)); try { Cache.Remove(recordEnumerator.CurrentKey, new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation)); } catch (Exception ex) { return(new PersistenceActionResult { Success = false, FailureMessage = ex.Message }); } } } return(new PersistenceActionResult { Success = true, Result = new DeleteActionResult(recordKeys) }); }
/// <summary> /// Recupera os indices de consulta. /// </summary> /// <returns></returns> private Colosoft.Caching.Configuration.Dom.QueryIndex GetQueryIndices() { var classes = new List <Colosoft.Caching.Configuration.Dom.Class>(); foreach (var typeMetadata in _typeSchema.GetTypeMetadatas()) { Colosoft.Reflection.TypeName typeName = null; try { typeName = typeMetadata.GetTypeName(); } catch (Exception ex) { System.Diagnostics.Debug.Fail("An error ocurred where get typename from TypeMetadata", Colosoft.Diagnostics.ExceptionFormatter.FormatException(ex, true)); continue; } var attributes = new List <Colosoft.Caching.Configuration.Dom.Attrib>(); foreach (var propertyMetadata in typeMetadata) { if (propertyMetadata.IsCacheIndexed || propertyMetadata.ParameterType == PersistenceParameterType.IdentityKey || propertyMetadata.ParameterType == PersistenceParameterType.Key) { attributes.Add(new Colosoft.Caching.Configuration.Dom.Attrib { ID = propertyMetadata.Name, Name = propertyMetadata.Name, Type = propertyMetadata.PropertyType }); } } if (typeMetadata.IsVersioned && !attributes.Exists(f => StringComparer.InvariantCultureIgnoreCase.Equals(f.Name, "RowVersion"))) { attributes.Add(new Colosoft.Caching.Configuration.Dom.Attrib { ID = "RowVersion", Name = "RowVersion", Type = typeof(long).FullName }); } if (attributes.Count > 0) { classes.Add(new Colosoft.Caching.Configuration.Dom.Class { ID = typeName.FullName, Name = typeName.FullName, Attributes = attributes.ToArray() }); } else { } } return(new Colosoft.Caching.Configuration.Dom.QueryIndex { Classes = classes.ToArray() }); }
/// <summary> /// Remove o registro do tipo para ser carregado para o cache. /// </summary> /// <param name="typeName">Nome do tipo que será removido.</param> /// <returns></returns> public IDataCacheManager Unregister(Colosoft.Reflection.TypeName typeName) { typeName.Require("typeFullName").NotNull(); lock (_objLock) { var index = _typeNames.FindIndex(f => Reflection.TypeName.TypeNameFullNameComparer.Instance.Equals(f, typeName)); if (index >= 0) { _typeNames.RemoveAt(index); } } return(this); }
void Serialization.ICompactSerializable.Deserialize(Serialization.IO.CompactReader reader) { if (reader.ReadByte() == 1) { _typeName = new Reflection.TypeName(); _typeName.Deserialize(reader); } else { _typeName = null; } _version = reader.ReadDateTime(); }
/// <summary> /// Deserializa os dados da instancia. /// </summary> /// <param name="reader"></param> public override void Deserialize(Serialization.IO.CompactReader reader) { _typeName = new Reflection.TypeName(); _typeName.Deserialize(reader); var length = reader.ReadInt16(); var values = new object[length]; for (var i = 0; i < length; i++) { var type = (PrimitiveTypes)reader.ReadByte(); values[i] = Deserialize(reader, type); } SetValues(values); }