/// <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>
/// Recupera o registrao associado com a ação.
/// </summary>
/// <param name="action">Instancia da ação de persistencia realizada.</param>
/// <param name="record">Registro gerado.</param>
/// <param name="recordKey">Chave do registro.</param>
/// <returns>Nome do tipo associado.</returns>
private Colosoft.Reflection.TypeName GetActionRecord(PersistenceAction action, out Query.Record record, out Query.RecordKey recordKey)
{
var typeName = new Reflection.TypeName(action.EntityFullName);
var typeMetadata = TypeSchema.GetTypeMetadata(action.EntityFullName);
var typeFields = GetRecordFields(action.EntityFullName, typeMetadata);
var fields = new List <Query.Record.Field>();
var recordValues = new List <object>();
foreach (var actionParameter in action.Parameters)
{
var indexOf = 0;
for (; indexOf < typeFields.Count; indexOf++)
{
if (typeFields[indexOf].Name == actionParameter.Name)
{
break;
}
}
if (indexOf < typeFields.Count)
{
fields.Add(new Query.Record.Field(typeFields[indexOf].Name, typeFields[indexOf].Type));
recordValues.Add(actionParameter.Value);
}
}
if (typeMetadata.IsVersioned && !fields.Any(f => f.Name == "RowVersion"))
{
fields.Add(new Query.Record.Field("RowVersion", typeof(long)));
recordValues.Add(action.RowVersion);
}
var recordDescriptor = new Query.Record.RecordDescriptor("default", fields);
record = recordDescriptor.CreateRecord(recordValues.ToArray());
recordKey = RecordKeyFactory.Create(typeName, record);
return(typeName);
}
/// <summary>
/// Lê os dados serializados.
/// </summary>
/// <param name="reader"></param>
void System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
Name = reader.GetAttribute("name");
var type = reader.GetAttribute("type");
if (!string.IsNullOrEmpty(type))
{
Type = new Reflection.TypeName(type);
}
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
switch (reader.LocalName)
{
case "DefaultValue":
DefaultValue = reader.ReadElementContentAsString();
break;
default:
reader.Skip();
break;
}
}
reader.ReadEndElement();
}
else
{
reader.Skip();
}
}
/// <summary>
/// Carrega as informações das propriedades de um determinado tipo.
/// </summary>
/// <param name="entityTypeName">Tipo da entidade.</param>
/// <returns></returns>
public IEnumerable <IEntityPropertyInfo> LoadTypeProperties(Reflection.TypeName entityTypeName)
{
var typeFullName = entityTypeName.FullName;
var entityTypeNamespace = string.Join(".", entityTypeName.Namespace);
System.Collections.IList properties = null;
bool found = false;
lock (_entityProperties)
found = _entityProperties.TryGetValue(typeFullName, out properties);
if (!found)
{
foreach (var version in EntityTypeVersions)
{
if (Reflection.TypeName.TypeNameEqualityComparer.Instance.Equals(version.Type, entityTypeName))
{
properties = (System.Collections.IList)version.Properties;
lock (_entityProperties)
if (!_entityProperties.ContainsKey(entityTypeName.FullName))
{
_entityProperties.Add(entityTypeName.FullName, properties);
}
break;
}
}
}
if (properties != null)
{
for (var i = 0; i < properties.Count; i++)
{
yield return((IEntityPropertyInfo)properties[i]);
}
}
}
/// <summary>
/// Recupera os nomes dos campos que representam a chave do registro.
/// </summary>
/// <param name="typeName"></param>
/// <returns></returns>
public IEnumerable <string> GetKeyFields(Reflection.TypeName typeName)
{
typeName.Require("typeName").NotNull();
var generator = CreateGenerator(typeName) as Generator;
return(generator.FieldNames);
}
/// <summary>
/// Método acionado quando ocorre um erro no registro do EntityEventInfo.
/// </summary>
/// <param name="typeName"></param>
/// <param name="eventInfo"></param>
/// <param name="error"></param>
private void OnRegisterEventInfoError(Reflection.TypeName typeName, EntityEventInfo eventInfo, Exception error)
{
if (RegisterEventInfoError != null)
{
RegisterEventInfoError(this, new RegisterEntityEventInfoErrorArgs(typeName, eventInfo, error));
}
}
/// <summary>
/// Carrega os labels de uma propriedade.
/// </summary>
/// <param name="typeName">Tipo</param>
/// <param name="uiContext">Contexto com o usuário</param>
/// <returns></returns>
public IEnumerable <PropertyLabelInfo> GetLabels(Reflection.TypeName typeName, string uiContext)
{
var typeNamespace = string.Join(".", typeName.Namespace);
foreach (var version in EntityTypeVersions)
{
if (Reflection.TypeName.TypeNameEqualityComparer.Instance.Equals(version.Type, typeName))
{
for (var j = 0; j < version.Properties.Count; j++)
{
var property = version.Properties[j];
for (var x = 0; x < property.DefaultLabels.Count; x++)
{
var defaultLabel = property.DefaultLabels[x];
if (string.IsNullOrEmpty(defaultLabel.UIContext) || (uiContext != null && defaultLabel.UIContext == uiContext))
{
yield return(new PropertyLabelInfo {
Label = defaultLabel,
PropertyName = property.Name
});
}
}
}
yield break;
}
}
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="info">Informações do evento da entidade.</param>
/// <param name="entityType">Nome completo do tipo da entidade.</param>
/// <param name="subscription"></param>
public EventSubscriptionInfo(EntityEventInfo info, Reflection.TypeName entityType, Domain.IExecuteSubscription <TPayLoad> subscription)
{
subscription.Require("subscription").NotNull();
this.Info = info;
this.EntityType = entityType;
this.Subscription = subscription;
}
/// <summary>
/// Registra o tipo da entidade que será geranciada.
/// </summary>
/// <param name="entityType"></param>
public void Register(Type entityType)
{
entityType.Require("entityType").NotNull();
IEnumerable <EntityEventInfo> infos = null;
var typeName = new Reflection.TypeName(entityType.AssemblyQualifiedName);
if (IsRegistered(typeName))
{
return;
}
try
{
infos = GetEventInfo(typeName);
}
catch (Exception ex)
{
throw new RegisterEntityEventException(ResourceMessageFormatter.Create(() => Properties.Resources.EntityEventManager_GetEntityEventInfosError, typeName.FullName), ex);
}
Registered(typeName);
if (infos != null)
{
foreach (var i in infos)
{
Register(typeName, i);
}
}
}
/// <summary>
/// Registro o registro para ser observado.
/// </summary>
/// <param name="typeName"></param>
/// <param name="recordKey"></param>
/// <param name="observer"></param>
public void Register(Reflection.TypeName typeName, Query.RecordKey recordKey, Colosoft.Query.IRecordObserver observer)
{
if (IsEnabled && IsValidType(typeName))
{
var typeNameEntry = GetTypeNameEntry(typeName);
typeNameEntry.AddRecordKey(recordKey, observer);
}
}
/// <summary>
/// Remove o observador do sistema.
/// </summary>
/// <param name="typeName"></param>
/// <param name="observer"></param>
public void Unregister(Reflection.TypeName typeName, Colosoft.Query.IRecordObserver observer)
{
if (IsEnabled && IsValidType(typeName))
{
var typeNameEntry = GetTypeNameEntry(typeName);
typeNameEntry.RemoveObserver(observer);
}
}
/// <summary>
/// Recupera o hash code do nome do tipo.
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public int GetHashCode(Reflection.TypeName obj)
{
if (object.ReferenceEquals(obj, null))
{
return(0);
}
return(obj.AssemblyQualifiedName.GetHashCode());
}
/// <summary>
/// Carrega a customização de especialização da entidade, caso haja.
/// </summary>
/// <param name="entityTypeName">Tipo da entidade</param>
/// <returns></returns>
public override IEntitySpecialization LoadSpecilization(Reflection.TypeName entityTypeName)
{
var specializationId = Settings.GetEntitySpecializationId(entityTypeName);
if (specializationId.HasValue)
{
return(Extensions.ExtensionServiceLocator.Current.GetInstance <IEntitySpecialization>(specializationId.Value));
}
return(null);
}
/// <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>
/// Define que a o tipo da entidade de negócio foi registrado.
/// </summary>
/// <param name="entityType">Nome do tipo da entidade de negócio.</param>
protected virtual void Registered(Reflection.TypeName entityType)
{
lock (_registeredTypes)
{
var index = _registeredTypes.BinarySearch(entityType, Reflection.TypeName.TypeNameFullNameComparer.Instance);
if (index < 0)
{
_registeredTypes.Insert(~index, entityType);
}
}
}
/// <summary>
/// Carrega as informações das propriedades de um determinado tipo.
/// </summary>
/// <param name="entityTypeName">Tipo da entidade.</param>
/// <param name="propertyName">Nome da propriedade</param>
/// <returns></returns>
public override IEntityPropertyInfo LoadTypeProperty(Reflection.TypeName entityTypeName, string propertyName)
{
foreach (var i in LoadTypeProperties(entityTypeName))
{
if (i.FullName == propertyName)
{
return(i);
}
}
return(null);
}
/// <summary>
/// Lê os dados serializados.
/// </summary>
/// <param name="reader"></param>
void System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
if (reader.MoveToAttribute("uid"))
{
Uid = Guid.Parse(reader.ReadContentAsString());
}
if (reader.MoveToAttribute("name"))
{
Name = reader.ReadContentAsString();
}
if (reader.MoveToAttribute("type"))
{
var type = reader.ReadContentAsString();
if (!string.IsNullOrEmpty(type))
{
Type = new Reflection.TypeName(type);
}
}
reader.MoveToElement();
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (reader.LocalName == "Parameters")
{
reader.ReadStartElement();
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
if (reader.LocalName == "ValidationTypeParameter")
{
var parameter = new ValidationTypeParameter();
((System.Xml.Serialization.IXmlSerializable)parameter).ReadXml(reader);
Parameters.Add(parameter);
}
else
{
reader.Skip();
}
}
reader.ReadEndElement();
}
else if (reader.LocalName == "Description")
{
Description = reader.ReadElementContentAsString();
}
}
reader.ReadEndElement();
}
else
{
reader.Skip();
}
}
/// <summary>
/// Recupera o identificador da customização associada com o tipo da entidade.
/// </summary>
/// <param name="entityTypeName">Tipo da entidade na qual a customização está associada.</param>
/// <returns></returns>
public int?GetEntitySpecializationId(Reflection.TypeName entityTypeName)
{
foreach (var typeVersion in EntityTypeVersions)
{
if (Reflection.TypeName.TypeNameEqualityComparer.Instance.Equals(typeVersion.Type, entityTypeName))
{
return(typeVersion.CustomizationId);
}
}
return(null);
}
/// <summary>
/// Recupera a instancia das informações da entidade.
/// </summary>
/// <param name="entityTypeName"></param>
/// <returns></returns>
private static Info GetInfo(Reflection.TypeName entityTypeName)
{
lock (_infos)
{
Info info = null;
if (!_infos.TryGetValue(entityTypeName, out info))
{
info = new Info();
_infos.Add(entityTypeName, info);
}
return(info);
}
}
/// <summary>
/// Registra o nome do tipo que terá seus dados carregados para o cache na inicialização.
/// </summary>
/// <param name="typeName"></param>
public virtual IDataCacheManager Register(Reflection.TypeName typeName)
{
typeName.Require("typeFullName").NotNull();
lock (_objLock)
{
var index = _typeNames.BinarySearch(typeName, Reflection.TypeName.TypeNameFullNameComparer.Instance);
if (index < 0)
{
_typeNames.Insert(~index, typeName);
}
}
return(this);
}
/// <summary>
/// Registra o evento para a entidade.
/// </summary>
/// <param name="entityType">Nome da entidade.</param>
/// <param name="info">Informações do evento.</param>
private void Register(Reflection.TypeName entityType, EntityEventInfo info)
{
Domain.SubscriptionToken token = null;
switch (info.EventType)
{
case EntityEventType.Initialized:
token = RegisterEvent <EntityInitializedEvent, IEntityInitializedEventSubscription, EntityInitializedEventArgs>(entityType, info);
break;
case EntityEventType.PropertyChanging:
token = RegisterEvent <EntityPropertyChangingEvent, IEntityPropertyChangingEventSubscription, EntityPropertyChangingEventArgs>(entityType, info);
break;
case EntityEventType.PropertyChanged:
token = RegisterEvent <EntityPropertyChangedEvent, IEntityPropertyChangedEventSubscription, EntityPropertyChangedEventArgs>(entityType, info);
break;
case EntityEventType.Validating:
token = RegisterEvent <EntityValidatingEvent, IEntityValidatingEventSubscription, EntityValidatingEventArgs>(entityType, info);
break;
case EntityEventType.Validated:
token = RegisterEvent <EntityValidatedEvent, IEntityValidatedEventSubscription, EntityValidatedEventArgs>(entityType, info);
break;
case EntityEventType.Saving:
token = RegisterEvent <EntitySavingEvent, IEntitySavingEventSubscription, EntitySavingEventArgs>(entityType, info);
break;
case EntityEventType.Saved:
token = RegisterEvent <EntitySavedEvent, IEntitySavedEventSubscription, EntitySavedEventArgs>(entityType, info);
break;
case EntityEventType.Deleting:
token = RegisterEvent <EntityDeletingEvent, IEntityDeletingEventSubscription, EntityDeletingEventArgs>(entityType, info);
break;
case EntityEventType.Deleted:
token = RegisterEvent <EntityDeletedEvent, IEntityDeletedEventSubscription, EntityDeletedEventArgs>(entityType, info);
break;
}
if (token != null)
{
List <Domain.SubscriptionToken> tokens = _eventSubscribers[info.EventType];
lock (tokens)
tokens.Add(token);
}
}
/// <summary>
/// Recupera as configurações associadas com o tipo da entidade.
/// </summary>
/// <param name="entityTypeName">Tipo da entidade que será usado para filtrar as configurações.</param>
/// <returns></returns>
public IEnumerable <IPropertySettingsInfo> GetTypeSettings(Reflection.TypeName entityTypeName)
{
var typeFullName = entityTypeName.FullName;
var entityTypeNamespace = string.Join(".", entityTypeName.Namespace);
foreach (var version in EntityTypeVersions)
{
if (Reflection.TypeName.TypeNameEqualityComparer.Instance.Equals(version.Type, entityTypeName))
{
foreach (EntityTypeVersionProperty property in version.Properties)
{
yield return(new PropertySettingsInfoWrapper(version, property, uid => _inputRulesGroups.Where(f => f.Uid == uid).Select(f => (int?)f.InputRulesGroupId).FirstOrDefault()));
}
yield break;
}
}
}
public bool MoveNext()
{
_currentPosition++;
if (_currentPosition >= _package._zipFile.Count)
{
return(false);
}
var zipEntry = _package._zipFile[_currentPosition];
using (var stream = _package._zipFile.GetInputStream(zipEntry))
{
var outStream = new System.IO.MemoryStream((int)zipEntry.Size);
var read = 0;
while ((read = stream.Read(_buffer, 0, _buffer.Length)) > 0)
{
outStream.Write(_buffer, 0, read);
}
outStream.Position = 0;
try
{
var reader = new Colosoft.Serialization.IO.CompactBinaryReader(outStream);
var isNullTypeName = reader.ReadByte() == 0;
Colosoft.Reflection.TypeName typeName = null;
if (!isNullTypeName)
{
typeName = new Reflection.TypeName();
typeName.Deserialize(reader);
}
var version = reader.ReadDateTime();
var hasRecords = reader.ReadByte() == 1;
outStream.Position = 0;
_currrentStream = outStream;
_current = new Tuple <DataEntryVersion, System.IO.Stream>(new DataEntryVersion {
TypeName = typeName,
Version = version
}, outStream);
}
catch
{
outStream.Dispose();
throw;
}
}
return(true);
}
/// <summary>
/// Cria uma chave para o registro.
/// </summary>
/// <param name="typeName">Nome do tipo que representa os dados contidos no registro.</param>
/// <param name="record">Instancia do registro com os dados.</param>
/// <returns>Chave que representa o registro.</returns>
public Query.RecordKey Create(Reflection.TypeName typeName, Query.IRecord record)
{
typeName.Require("typeName").NotNull();
var generator = CreateGenerator(typeName);
var key = generator.GetSimpleKey(record);
long rowVersion = 0;
var index = 0;
for (; index < record.Descriptor.Count; index++)
{
if (StringComparer.InvariantCultureIgnoreCase.Equals(record.Descriptor[index].Name, "RowVersion"))
{
break;
}
}
if (index < record.Descriptor.Count)
{
rowVersion = (long)record.GetInt64(index);
}
return(new Query.RecordKey(key, rowVersion));
}
/// <summary>
/// Executa a ação para inserir um novo registro no cache.
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
private PersistenceActionResult ExecuteInsertAction(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(),
}
}
;
IEnumerable <Colosoft.Query.Record.Field> recordFields = null;
try
{
recordFields = GetRecordFields(action.EntityFullName, typeMetadata);
}
catch (Exception ex)
{
return(new PersistenceActionResult {
Success = false,
FailureMessage = ex.Message
});
}
var recordDescriptor = new Colosoft.Query.Record.RecordDescriptor(action.EntityFullName, recordFields);
var recordValues = new object[recordDescriptor.Count];
foreach (var actionParameter in action.Parameters)
{
var indexOf = 0;
for (; indexOf < recordDescriptor.Count; indexOf++)
{
if (StringComparer.InvariantCultureIgnoreCase.Equals(recordDescriptor[indexOf].Name, actionParameter.Name))
{
break;
}
}
if (indexOf < recordDescriptor.Count)
{
recordValues[indexOf] = actionParameter.Value;
}
else
{
return new PersistenceActionResult {
Success = false,
FailureMessage = ResourceMessageFormatter.Create(() => Properties.Resources.CachePersistenceExecuter_PropertyMetadataNotFound, actionParameter.Name, action.EntityFullName).Format()
}
};
}
var record = new CacheItemRecord(new Reflection.TypeName(action.EntityFullName), recordValues, recordDescriptor);
var typeName = new Reflection.TypeName(action.EntityFullName);
var keyGenerator = _keyFactory.Value.CreateGenerator(typeName);
var key = keyGenerator.GetKey(record);
var queryInfo = GetCacheEntryQueryInfo(Cache, Cache.GetTypeInfoMap(), record);
var insertResult = Cache.Insert(key, record, null, null, new Colosoft.Caching.Policies.PriorityEvictionHint(CacheItemPriority.Normal), null, null, queryInfo, new BitSet(), null, 0, LockAccessType.IGNORE_LOCK, null, null, new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation));
return(new PersistenceActionResult {
Success = true
});
}
/// <summary>
/// Executa a ação para atualizar os dados do registro no cache.
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
private PersistenceActionResult ExecuteUpdateAction(PersistenceAction action)
{
var typeName = new Reflection.TypeName(action.EntityFullName);
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()
});
}
Colosoft.Query.Record.RecordDescriptor recordDescriptor = null;
try
{
recordDescriptor = new Colosoft.Query.Record.RecordDescriptor(action.EntityFullName, GetRecordFields(action.EntityFullName, typeMetadata));
}
catch (Exception ex)
{
return(new PersistenceActionResult {
Success = false,
FailureMessage = ex.Message
});
}
var keyGenerator = _keyFactory.Value.CreateGenerator(typeName);
var typeInfoMap = Cache.GetTypeInfoMap();
var keysResult = queryResult.SearchKeysResult.ToArray();
if (keysResult.Length > 0)
{
foreach (var key in keysResult)
{
var record = CacheDataSource.CreateRecord(Cache, key, ref recordDescriptor, query);
var recordValues = new object[recordDescriptor.Count];
record.GetValues(recordValues);
foreach (var actionParameter in action.Parameters)
{
var indexOf = 0;
for (; indexOf < recordDescriptor.Count; indexOf++)
{
if (StringComparer.InvariantCultureIgnoreCase.Equals(recordDescriptor[indexOf].Name, actionParameter.Name))
{
break;
}
}
if (indexOf < recordDescriptor.Count)
{
recordValues[indexOf] = actionParameter.Value;
}
}
var newRecord = new CacheItemRecord(new Reflection.TypeName(action.EntityFullName), recordValues, recordDescriptor);
var newKey = keyGenerator.GetKey(newRecord);
try
{
var queryInfo = GetCacheEntryQueryInfo(Cache, typeInfoMap, newRecord);
Cache.Remove(key, new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation));
var insertResult = Cache.Insert(newKey, newRecord, null, null, new Colosoft.Caching.Policies.PriorityEvictionHint(CacheItemPriority.Normal), null, null, queryInfo, new BitSet(), null, 0, LockAccessType.IGNORE_LOCK, null, null, new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation));
}
catch (Exception ex)
{
return(new PersistenceActionResult {
Success = false,
FailureMessage = ex.Message
});
}
}
}
else
{
}
return(new PersistenceActionResult {
Success = true
});
}
/// <summary>
///
/// </summary>
/// <param name="typeName"></param>
/// <param name="collection"></param>
/// <returns></returns>
protected override Collections.INotifyCollectionChangedObserver CreateQueryResultChangedObserver(Reflection.TypeName typeName, System.Collections.IList collection)
{
if (Colosoft.Query.RecordObserverManager.Instance.IsEnabled)
{
throw new NotImplementedException();
}
return(null);
}
/// <summary>
/// Compara as instancias informadas.
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public bool Equals(Reflection.TypeName x, Reflection.TypeName y)
{
return(x != null && y != null && x.AssemblyQualifiedName == y.AssemblyQualifiedName);
}
protected override Collections.INotifyCollectionChangedObserver CreateQueryResultChangedObserver(Reflection.TypeName typeName, System.Collections.IList collection)
{
if (Colosoft.Query.RecordObserverManager.Instance.IsEnabled)
{
return(new EntityChildQueryResultChangedObserver(_childInfo, _childLoader, _entityTypeManager, _sourceContext, _uiContext, typeName, collection));
}
return(null);
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="contractName"></param>
/// <param name="contractType"></param>
public AssemblyRepositoryCatalogConflict(string contractName, Reflection.TypeName contractType)
{
this.ContractName = contractName;
this.ContractType = contractType;
}
