/// <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);
}
