/// <summary>
/// Initializes a new instance of the OutlinerPluginData class.
/// </summary>
/// <param name="type">The type to create the metadata for.</param>
public OutlinerPluginData(Type type)
{
Throw.IfNull(type, "type");
this.Type = type;
OutlinerPluginAttribute pluginAttr = type.GetAttribute<OutlinerPluginAttribute>();
Throw.IfNull(pluginAttr, "OutlinerPlugin attribute not found on type.");
this.PluginType = pluginAttr.PluginType;
DisplayNameAttribute dispAtrr = type.GetAttribute<DisplayNameAttribute>();
if (dispAtrr != null)
this.DisplayName = dispAtrr.DisplayName;
else
this.DisplayName = type.Name;
LocalizedDisplayImageAttribute imgAttr = type.GetAttribute<LocalizedDisplayImageAttribute>();
if (imgAttr != null)
{
this.DisplayImageSmall = imgAttr.DisplayImageSmall;
this.DisplayImageLarge = imgAttr.DisplayImageLarge;
}
else
{
this.DisplayImageSmall = null;
this.DisplayImageLarge = null;
}
}
private ITypeLoader CreateTypeLoader(Type suiteBaseType, IEnumerable<ITestExtension> testExtensions)
{
var typeLoaderType = suiteBaseType.GetAttribute<TypeLoaderAttribute>().AssertNotNull().TypeLoaderType;
var operationOrdering = suiteBaseType.GetAttribute<OperationOrderingAttribute>().AssertNotNull().OperationDescriptors;
var builder = new ContainerBuilder();
builder.RegisterModule<UtilitiesModule>();
builder.RegisterModule(new ExtensibilityModule(typeLoaderType, operationOrdering));
builder.RegisterInstance(testExtensions).As<IEnumerable<ITestExtension>>();
var container = builder.Build();
return (ITypeLoader) container.Resolve(typeLoaderType);
}
/// <summary>
/// 生成控制器及视图
/// </summary>
/// <param name="type">要生成代码的模型类</param>
/// <param name="gen">生成内容选项</param>
public static void GenerateCommonCode(Type type, string gen)
{
if (type.FullName == null) return;
var packageName = type.FullName.Split('.')[3];
// var packageName = type.FullName.Substring(15, 2);
var modelName = type.Name;
var tableAttribute = type.GetAttribute<TableAttribute>();
var moduleName = tableAttribute != null ? tableAttribute.DisplayName : "未命名";
if (gen.Contains("Controller"))
GenContollerCode(packageName, modelName, moduleName);
if (gen.Contains("Index"))
GenIndexCode(packageName, modelName);
var inputForList = GetInputForList(type);
if (gen.Contains("Create"))
{
GenCreateCode(packageName, modelName, inputForList);
}
if (gen.Contains("Edit"))
{
GenEditCode(packageName, modelName, inputForList);
}
var addlist = GetAddList(type);
if (gen.Contains("QuickSearch"))
{
GenQuickSearchCode(packageName, modelName, addlist);
}
if (gen.Contains("Delete"))
GenDeleteCode(packageName, modelName, addlist);
if (gen.Contains("Details"))
GenDetailsCode(packageName, modelName, addlist);
}
public static Sheet GetSheet(Type t)
{
var sheetAttr = (SheetAttribute)t.GetAttribute(typeof(SheetAttribute));
var sheetName = sheetAttr != null ? sheetAttr.Name : t.Name;
var definedColumn = sheetAttr != null ? sheetAttr.DefinedColumn : "";
var startingComments = sheetAttr != null && sheetAttr.StartingComments != null ? sheetAttr.StartingComments.ToList() : new List<string>();
var properties = from property in t.GetRuntimeProperties()
where (property.GetMethod != null && property.GetMethod.IsPublic)
|| (property.SetMethod != null && property.SetMethod.IsPublic)
|| (property.GetMethod != null && property.GetMethod.IsStatic)
|| (property.SetMethod != null && property.SetMethod.IsStatic)
select property;
var columns = new List<Column>();
foreach(var property in properties)
{
var ignore = property.GetCustomAttribute(typeof(IgnoredColumnAttribute), true);
if (property.CanWrite && ignore == null)
{
columns.Add(new Column(property));
}
}
return new Sheet(sheetName, columns, definedColumn, startingComments);
}
/// <summary>
/// 构造模型绑定器
/// </summary>
/// <param name="name">成员名称</param>
/// <param name="type">成员类型</param>
/// <param name="defaultValue">缺省值</param>
public BindingInfo(string name, Type type, object defaultValue)
{
Name = name;
Type = type;
DefaultValue = new Lazy<object>(() => defaultValue);
BindAttribute attr = type.GetAttribute<BindAttribute>(false);
if (attr == null)
Exclude = Include = new string[0];
else
{
if (string.IsNullOrEmpty(attr.Prefix))
IsNullPrefix = false;
else
Prefix = attr.Prefix.ToLower() + ".";
Exclude = new ReadOnlyCollection<string>(SplitString(attr.Exclude));
Include = new ReadOnlyCollection<string>(SplitString(attr.Include));
}
var binderAttr = type.GetAttribute<CustomModelBinderAttribute>(false);
if (binderAttr != null)
ModelBinder = binderAttr.GetBinder();
if (ModelBinder == null)
ModelBinder = ModelBinders.GetBinder(type);
if (ModelBinder == null)
ModelBinder = _DefaultModelBinder;
}
/// <summary>
/// Initializes a new instance of the <see cref="ConnectorInfo"/>.
/// </summary>
/// <param name="adapterType">The type of transaction or market data adapter.</param>
public ConnectorInfo(Type adapterType)
{
if (adapterType == null)
throw new ArgumentNullException("adapterType");
if (!typeof(IMessageAdapter).IsAssignableFrom(adapterType))
throw new ArgumentException("adapterType");
AdapterType = adapterType;
Name = adapterType.GetDisplayName();
Description = adapterType.GetDescription();
Category = adapterType.GetCategory(LocalizedStrings.Str1559);
var targetPlatform = adapterType.GetAttribute<TargetPlatformAttribute>();
if (targetPlatform != null)
{
PreferLanguage = targetPlatform.PreferLanguage;
Platform = targetPlatform.Platform;
}
else
{
PreferLanguage = Languages.English;
Platform = Platforms.AnyCPU;
}
}
public IObjectInfo CreateObjectInfo(Type forType)
{
if (forType == null)
{
throw new ArgumentNullException("forType");
}
var tableAttribute = forType.GetAttribute<TableAttribute>(inherit: false);
if (tableAttribute == null)
{
throw new MappingException(ExceptionMessages.AttributeMappingConvention_NoTableAttribute.FormatWith(forType.FullName));
}
var identifierStrategy = IdentifierStrategy.DbGenerated;
var columns = this.CreateColumnInfos(forType, ref identifierStrategy);
var tableInfo = new TableInfo(columns, identifierStrategy, tableAttribute.Name, tableAttribute.Schema);
if (this.log.IsDebug)
{
this.log.Debug(LogMessages.MappingConvention_MappingTypeToTable, forType.FullName, tableInfo.Schema, tableInfo.Name);
}
return new PocoObjectInfo(forType, tableInfo);
}
/// <summary>
/// 获取生命周期
/// </summary>
public static Lifecycle GetLifecycle(Type type)
{
if (!type.IsDefined(typeof(LifeCycleAttribute), false))
return Lifecycle.Singleton;
return type.GetAttribute<LifeCycleAttribute>(false).Lifetime;
}
/// <summary>Creates a new <see cref="Descriptor"/> instance from a given type.</summary>
/// <param name="type">The type from which the descriptor will be created.</param>
public Descriptor(Type type) {
var attr = type.GetAttribute<DescriptorAttribute>();
if (attr != null) {
ParseXml(attr.Markup);
}
Subject = type;
}
internal static string Get(Type type)
{
var result = type.GetAttribute<SchemaAttribute>(false);
if(result == null)
return null;
return result._name;
}
public static IPropertyEditor TryCreateEditor(Type editedType, Type editorType)
{
CustomPropertyEditorAttribute attribute = editorType.GetAttribute<CustomPropertyEditorAttribute>();
if (attribute == null || !attribute.Inherit)
{
return PropertyEditorTools.TryCreateSpecificEditor(editedType, editedType, editorType);
}
for (Type type = editedType; type != null; type = type.BaseType)
{
IPropertyEditor propertyEditor = PropertyEditorTools.TryCreateSpecificEditor(type, editedType, editorType);
if (propertyEditor != null)
{
return propertyEditor;
}
Type[] interfaces = type.GetInterfaces();
for (int i = 0; i < interfaces.Length; i++)
{
Type usedEditedType = interfaces[i];
propertyEditor = PropertyEditorTools.TryCreateSpecificEditor(usedEditedType, editedType, editorType);
if (propertyEditor != null)
{
return propertyEditor;
}
}
}
return null;
}
private bool Match(Type bhvType, string searchString)
{
var bhvAttr = bhvType.GetAttribute<Behaviors.BehaviorModelAttribute>();
return CultureInfo.CurrentCulture.CompareInfo.IndexOf(bhvAttr.DefaultName, searchString, CompareOptions.IgnoreCase) >= 0
|| CultureInfo.CurrentCulture.CompareInfo.IndexOf(bhvType.FullName, searchString, CompareOptions.IgnoreCase) >= 0;
}
/// <summary>
/// Gets inspector data such as name and description for the
/// specified type.
/// </summary>
/// <param name="type">Type to get inspector data for.</param>
/// <param name="conditionalInspectors">Dictionary to be filled with conditions for inspectors to be shown.</param>
/// <returns>Inspector data for the specified type.</returns>
public static InspectorType GetInspectorType(
Type type,
ref Dictionary<InspectorPropertyAttribute, InspectorConditionalPropertyAttribute> conditionalInspectors)
{
List<InspectorPropertyAttribute> inspectorProperties = InspectorUtils.CollectInspectorProperties(
type, ref conditionalInspectors);
var inspectorTypeAttribute = type.GetAttribute<InspectorTypeAttribute>();
if (inspectorTypeAttribute == null)
{
return null;
}
var inspectorTypeData = new InspectorType
{
Attribute = inspectorTypeAttribute,
Name = type.Name,
Description = inspectorTypeAttribute.Description,
Properties = inspectorProperties,
Type = type,
};
return inspectorTypeData;
}
public AttributeDrivenPatternSchema(Type patternProviderInterface, Type patternClientInterface)
{
if (!patternProviderInterface.IsInterface)
throw new ArgumentException("Provided pattern provider type should be an interface", "patternProviderInterface");
if (!patternClientInterface.IsInterface)
throw new ArgumentException("Provided pattern client type should be an interface", "patternClientInterface");
_patternProviderInterface = patternProviderInterface;
_patternClientInterface = patternClientInterface;
var patternClientName = _patternClientInterface.Name;
if (!patternClientName.EndsWith("Pattern") || !patternClientName.StartsWith("I"))
throw new ArgumentException("Pattern client interface named incorrectly, should be IXxxPattern", "patternClientInterface");
var baseName = patternClientName.Substring(1, patternClientName.Length - "I".Length - "Pattern".Length);
if (_patternProviderInterface.Name != string.Format("I{0}Provider", baseName))
throw new ArgumentException(string.Format("Pattern provider interface named incorrectly, should be I{0}Provider", baseName));
_patternName = string.Format("{0}Pattern", baseName);
var patternGuidAttr = _patternProviderInterface.GetAttribute<PatternGuidAttribute>();
if (patternGuidAttr == null) throw new ArgumentException("Provided type should be marked with PatternGuid attribute");
_patternGuid = patternGuidAttr.Value;
_methods = patternProviderInterface.GetMethodsMarkedWith<PatternMethodAttribute>().Select(GetMethodHelper).ToArray();
_properties = patternProviderInterface.GetPropertiesMarkedWith<PatternPropertyAttribute>().Select(GetPropertyHelper).ToArray();
ValidateClientInterface();
_handler = new AttributeDrivenPatternHandler(this);
}
public byte GetDeliveryMode(Type messageType)
{
Preconditions.CheckNotNull(messageType, "messageType");
var deliveryModeAttribute = messageType.GetAttribute<DeliveryModeAttribute>();
if (deliveryModeAttribute == null)
return GetDeliveryModeInternal(connectionConfiguration.PersistentMessages);
return GetDeliveryModeInternal(deliveryModeAttribute.IsPersistent);
}
string GetCommandName(Type commandType)
{
string defaultName = commandType.Name.Replace("Command", "");
string commandName = commandType.HasAttribute<CommandNameAttribute>() ?
commandType.GetAttribute<CommandNameAttribute>().Name :
defaultName;
return commandName;
}
public string LabelForTypeConvention(Type type)
{
if (type.AttributeExists<LabelAttribute>())
{
return type.GetAttribute<LabelAttribute>().Label;
}
return type.Name.ToSeparatedWords();
}
public static string GetUsage(Type t)
{
var usage = t.GetAttribute<CommandUsageAttribute>(false);
if (usage != null)
{
return usage.Usage;
}
return "";
}
public void Process(Type type, Registry registry)
{
if(!_shouldAutoNotify(type))
return;
logger.InfoFormat("Registering autonotify for {0}", type.Name);
var fireOption = type.GetAttribute<AutoNotifyAttribute>().Fire;
var dependencyMap = new DependencyMap()
.Tap(m => m.Map.AddRange(GetDependencyMap(type.GetAttribute<AutoNotifyAttribute>().DependencyMap).Map))
.Tap(m => m.Map.AddRange(GetDependencyMapFromProps(type).Map));
if(type.IsInterface)
ConfigureInterface(type, registry, fireOption, dependencyMap);
else if(!type.IsAbstract)
ConfigureClass(type, registry, fireOption, dependencyMap);
}
internal CommandMetadata(Type commandType)
{
Name = commandType.GetFullCommandName();
var displayAttribute = commandType.GetAttribute<CommandDisplayAttribute>();
if (displayAttribute != null)
{
Description = displayAttribute.GetLocalizedDescription();
Usage = displayAttribute.GetLocalizedUsage();
}
}
/// <summary>
/// Gets the type of the base.
/// </summary>
/// <param name="wrapperType">Type of the wrapper.</param>
/// <returns></returns>
public static Type GetBaseType(Type wrapperType)
{
var @interfaces =
from @interface in wrapperType.GetInterfaces()
where @interface.QueryAttribute<CppClassAttribute>(attr => attr.Type != ClassType.Interface)
select @interface;
if (@interfaces.Count() <= 1)
return @interfaces.SingleOrDefault();
return wrapperType.GetAttribute<CppClassAttribute>(true).BaseType;
}
public static BehaviorChain ChainForType(Type type)
{
if (type.HasAttribute<UrlPatternAttribute>())
{
var route = type.GetAttribute<UrlPatternAttribute>().BuildRoute(type);
return new RoutedChain(route, type, type);
}
var chain = BehaviorChain.ForResource(type);
chain.IsPartialOnly = true;
return chain;
}
public static string GetBehaviorName(Type behaviorModelType)
{
if (behaviorModelType == null)
{
throw new ArgumentNullException("behaviorModelType");
}
var bhvAttr = behaviorModelType.GetAttribute<Behaviors.BehaviorModelAttribute>();
if (bhvAttr == null || bhvAttr.HideFromEditor)
{
throw new ArgumentException("behaviorModelType");
}
return bhvAttr.DefaultName;
}
public void ReturnsAttributeForTypes(Type type, Type expectedAttributeType, bool isNotNull)
{
var attribute = type.GetAttribute(expectedAttributeType);
if (isNotNull)
{
Assert.IsNotNull(attribute);
}
else
{
Assert.IsNull(attribute);
}
}
private static TypeConverter RegisterTypeConverterFor(Type type)
{
var converter_attr = type.GetAttribute<TypeConverterAttribute>();
if ( converter_attr != null ) {
// What is the difference between these two conditions?
TypeConverterSpecified[type] = true;
var converterType = TypeUtils.GetType(converter_attr.ConverterTypeName);
return TypeConverters[type] = Activator.CreateInstance(converterType) as TypeConverter;
} else {
// What is the difference between these two conditions?
TypeConverterSpecified[type] = false;
return TypeConverters[type] = TypeDescriptor.GetConverter(type);
}
}
private void CreateAppliesToFilter(Type modifierClass)
{
if (!typeof(InvocationHandler).IsAssignableFrom(modifierClass))
{
this.appliesToFilter = new TypedModifierAppliesToFilter();
if (modifierClass.IsAbstract)
{
this.appliesToFilter = new AndAppliesToFilter(this.appliesToFilter, new ImplementsMethodAppliesToFilter());
}
}
var appliesTo = modifierClass.GetAttribute<AppliesToAttribute>();
if (appliesTo != null)
{
foreach (Type appliesToClass in appliesTo.AppliesToTypes)
{
AppliesToFilter filter;
if (typeof(AppliesToFilter).IsAssignableFrom(appliesToClass))
{
try
{
filter = (AppliesToFilter)appliesToClass.NewInstance();
}
catch (Exception e)
{
throw; //new ConstructionException( e );
}
}
else if (typeof(Attribute).IsAssignableFrom(appliesToClass))
{
filter = new AnnotationAppliesToFilter(appliesToClass);
}
else // Type check
{
filter = new TypeCheckAppliesToFilter(appliesToClass);
}
this.appliesToFilter = this.appliesToFilter == null ? filter : new AndAppliesToFilter(this.appliesToFilter, filter);
}
}
if (this.appliesToFilter == null)
{
this.appliesToFilter = AppliesToEverything.Instance;
}
}
string DumpData(Type type, object data)
{
var dumpData = type.GetAttribute<DumpDataClassAttribute>(false);
if(dumpData != null)
return dumpData.Dump(type, data);
var memberCheck = Configuration.GetMemberCheck(type);
var results = type
.GetFields(AnyBinding)
.Cast<MemberInfo>()
.Concat(type.GetProperties(AnyBinding))
.Where(memberInfo => IsRelevant(memberInfo, type, data))
.Where(memberInfo => memberCheck(memberInfo, data))
.Select(memberInfo => Format(memberInfo, data))
.ToArray();
return FormatMemberDump(results);
}
internal static RuntimeSerializableAttribute GetRuntimeSerializableAttribute(Type _objectType)
{
RuntimeSerializableAttribute _serializableAttr = null;
lock (serializableAttributeCache)
{
// If cached value doesnt exist, then check if object implements RuntimeSerializableAttribute
if (!serializableAttributeCache.TryGetValue(_objectType, out _serializableAttr))
{
_serializableAttr = _objectType.GetAttribute<RuntimeSerializableAttribute>(false);
// Add it to cache collection
serializableAttributeCache[_objectType] = _serializableAttr;
}
}
return _serializableAttr;
}
void ConfigureDlg()
{
OrmMain.Count++;
number = OrmMain.Count;
logger.Debug("Открытие {0}", number);
Mode = OrmReferenceMode.Normal;
ButtonMode = ReferenceButtonMode.CanAll;
IOrmObjectMapping map = OrmMain.GetObjectDescription(objectType);
if (map != null)
{
map.ObjectUpdated += OnRefObjectUpdated;
TableView = map.TableView;
if (map.RefFilterClass != null)
{
FilterClass = map.RefFilterClass;
}
}
else
{
throw new InvalidOperationException(String.Format("Для использования диалога, класс {0} должен быть добавлен в мапинг OrmMain.ClassMappingList.", objectType));
}
object[] att = objectType.GetCustomAttributes(typeof(AppellativeAttribute), true);
if (att.Length > 0)
{
this.TabName = (att [0] as AppellativeAttribute).NominativePlural.StringToTitleCase();
}
var defaultMode = objectType.GetAttribute <DefaultReferenceButtonModeAttribute>(true);
if (defaultMode != null)
{
ButtonMode = defaultMode.ReferenceButtonMode;
}
if (!String.IsNullOrWhiteSpace(map.EditPermisionName))
{
if (!QSMain.User.Permissions [map.EditPermisionName])
{
ButtonMode &= ~ReferenceButtonMode.CanAll;
}
}
UpdateObjectList();
ytreeviewRef.Selection.Changed += OnTreeviewSelectionChanged;
}
public FormHelper(Type formModelType, Dictionary<T4DataType, string> fieldTypeTemplates, string defaultHtmlTemplate, string tag)
{
this.FormModelType = formModelType;
this.FieldTypeTemplates = fieldTypeTemplates;
this.DefaultHtmlTemplate = defaultHtmlTemplate;
this.Tag = tag;
//组特性
var t4FormGroupAttribute = formModelType.GetAttribute<T4FormGroupAttribute>(false);
if (t4FormGroupAttribute != null)
this.IsEnableFormGroup = true;
this.T4PropertyInfos = formModelType.GetT4PropertyInfos();
if (this.IsEnableFormGroup)
{
this.DefaultGroupName = t4FormGroupAttribute.GroupName;
this.Groups = this.T4PropertyInfos.Where(p => p.T4GroupInfo != null).Select(p => p.T4GroupInfo.Name).Distinct().ToList();
if (!this.Groups.Contains(t4FormGroupAttribute.GroupName)) this.Groups.Add(t4FormGroupAttribute.GroupName);
}
}
public ISuiteProvider Load(Type suiteType, IDictionary<Type, Lazy<IAssemblySetup>> assemblySetups, IIdentity assemblyIdentity)
{
var uninitializedSuite = FormatterServices.GetUninitializedObject(suiteType);
var subjectAttribute = suiteType.GetAttributeData<SuiteAttributeBase>();
var displayFormatAttribute = subjectAttribute.Constructor.GetAttributeData<DisplayFormatAttribute>();
var text = _introspectionPresenter.Present(displayFormatAttribute.ToCommon(), suiteType.ToCommon(), subjectAttribute.ToCommon());
var identity = assemblyIdentity.CreateChildIdentity(suiteType.FullName);
var resources = suiteType.GetAttribute<ResourcesAttribute>().GetValueOrDefault(x => x.Resources, () => new string[0]);
var provider = SuiteProvider.Create(identity, text, ignored: false, resources: resources);
InitializeAssemblySetupFields(uninitializedSuite, assemblySetups);
InitializeTypeSpecificFields(uninitializedSuite, provider);
InvokeConstructor(uninitializedSuite);
return provider;
}
private static object ExecCrearEditar(bool crear, string comando)
{
string SubComando = Lfx.Types.Strings.GetNextToken(ref comando, " ").Trim();
System.Type TipoLbl = Lbl.Instanciador.InferirTipo(SubComando);
Lbl.Atributos.Nomenclatura AtrNombre = TipoLbl.GetAttribute <Lbl.Atributos.Nomenclatura>();
if (crear && Lbl.Sys.Config.Actual.UsuarioConectado.TienePermiso(TipoLbl, Lbl.Sys.Permisos.Operaciones.Crear) == false)
{
return(new Lfx.Types.NoAccessOperationResult());
}
if (Lbl.Sys.Config.Actual.UsuarioConectado.TienePermiso(TipoLbl, Lbl.Sys.Permisos.Operaciones.Ver) == false)
{
return(new Lfx.Types.NoAccessOperationResult());
}
var ConnEditar = Lfx.Workspace.Master.GetNewConnection("Editar " + (AtrNombre == null ? SubComando : AtrNombre.NombreSingular)) as Lfx.Data.Connection;
Lbl.IElementoDeDatos Elemento = null;
if (crear)
{
Elemento = Lbl.Instanciador.Instanciar(TipoLbl, ConnEditar);
Elemento.Crear();
}
else
{
int ItemId = Lfx.Types.Parsing.ParseInt(Lfx.Types.Strings.GetNextToken(ref comando, " "));
Elemento = Lbl.Instanciador.Instanciar(TipoLbl, ConnEditar, ItemId);
}
Lfc.FormularioEdicion FormularioDeEdicion = Lfc.Instanciador.InstanciarFormularioEdicion(Elemento);
FormularioDeEdicion.DisposeConnection = true;
if (FormularioDeEdicion == null)
{
return(null);
}
return(FormularioDeEdicion);
}
void ConfigureDlg()
{
Mode = OrmReferenceMode.Normal;
ButtonMode = ReferenceButtonMode.CanAll;
buttonAdd.Visible = buttonEdit.Visible = buttonDelete.Visible = objectType != null;
if (objectType != null)
{
object[] att = objectType.GetCustomAttributes(typeof(AppellativeAttribute), true);
if (att.Length > 0)
{
this.TabName = (att[0] as AppellativeAttribute).NominativePlural.StringToTitleCase();
}
var defaultMode = objectType.GetAttribute <DefaultReferenceButtonModeAttribute>(true);
if (defaultMode != null)
{
ButtonMode = defaultMode.ReferenceButtonMode;
}
}
ormtableview.Selection.Changed += OnTreeviewSelectionChanged;
}
public void BindEntity()
{
persistentClass.IsAbstract = annotatedClass.IsAbstract;
persistentClass.ClassName = annotatedClass.Name;
persistentClass.NodeName = name;
//TODO:review this
//persistentClass.setDynamic(false); //no longer needed with the Entity name refactoring?
persistentClass.EntityName = (annotatedClass.Name);
BindDiscriminatorValue();
persistentClass.IsLazy = lazy;
if (proxyClass != null)
{
persistentClass.ProxyInterfaceName = proxyClass.Name;
}
persistentClass.DynamicInsert = dynamicInsert;
persistentClass.DynamicUpdate = dynamicUpdate;
if (persistentClass is RootClass)
{
RootClass rootClass = (RootClass)persistentClass;
bool mutable = true;
//priority on @Immutable, then @Entity.mutable()
if (annotatedClass.IsAttributePresent <ImmutableAttribute>())
{
mutable = false;
}
else
{
var entityAnn = annotatedClass.GetAttribute <EntityAttribute>();
if (entityAnn != null)
{
mutable = entityAnn.IsMutable;
}
}
rootClass.IsMutable = mutable;
rootClass.IsExplicitPolymorphism = ExplicitPolymorphismConverter.Convert(polymorphismType);
if (StringHelper.IsNotEmpty(where))
{
rootClass.Where = where;
}
if (cacheConcurrentStrategy != null)
{
rootClass.CacheConcurrencyStrategy = cacheConcurrentStrategy;
rootClass.CacheRegionName = cacheRegion;
//TODO: LazyPropertiesCacheable
//rootClass.LazyPropertiesCacheable = cacheLazyProperty ;
}
rootClass.IsForceDiscriminator = annotatedClass.IsAttributePresent <ForceDiscriminatorAttribute>();
}
else
{
if (explicitHibernateEntityAnnotation)
{
log.WarnFormat("[NHibernate.Annotations.Entity] used on a non root entity: ignored for {0}", annotatedClass.Name);
}
if (annotatedClass.IsAttributePresent <ImmutableAttribute>())
{
log.WarnFormat("[Immutable] used on a non root entity: ignored for {0}", annotatedClass.Name);
}
}
persistentClass.OptimisticLockMode = OptimisticLockModeConverter.Convert(optimisticLockType);
persistentClass.SelectBeforeUpdate = selectBeforeUpdate;
//set persister if needed
//[Persister] has precedence over [Entity.persister]
var persisterAnn = annotatedClass.GetAttribute <PersisterAttribute>();
System.Type persister = null;
if (persisterAnn != null)
{
persister = persisterAnn.Implementation;
}
else
{
var entityAnn = annotatedClass.GetAttribute <EntityAttribute>();
if (entityAnn != null && !BinderHelper.IsDefault(entityAnn.Persister))
{
try
{
persister = ReflectHelper.ClassForName(entityAnn.Persister);
}
catch (TypeLoadException tle)
{
throw new AnnotationException("Could not find persister class: " + persister, tle);
}
}
}
if (persister != null)
{
persistentClass.EntityPersisterClass = persister;
}
persistentClass.BatchSize = batchSize;
//SQL overriding
var sqlInsert = annotatedClass.GetAttribute <SQLInsertAttribute>();
var sqlUpdate = annotatedClass.GetAttribute <SQLUpdateAttribute>();
var sqlDelete = annotatedClass.GetAttribute <SQLDeleteAttribute>();
var sqlDeleteAll = annotatedClass.GetAttribute <SQLDeleteAllAttribute>();
var loader = annotatedClass.GetAttribute <LoaderAttribute>();
if (sqlInsert != null)
{
persistentClass.SetCustomSQLInsert(sqlInsert.Sql.Trim(), sqlInsert.Callable,
ExecuteUpdateResultCheckStyleConverter.Convert(sqlInsert.Check));
}
if (sqlUpdate != null)
{
persistentClass.SetCustomSQLUpdate(sqlUpdate.Sql.Trim(), sqlUpdate.Callable,
ExecuteUpdateResultCheckStyleConverter.Convert(sqlUpdate.Check));
}
if (sqlDelete != null)
{
persistentClass.SetCustomSQLDelete(sqlDelete.Sql, sqlDelete.Callable,
ExecuteUpdateResultCheckStyleConverter.Convert(sqlDelete.Check));
}
if (sqlDeleteAll != null)
{
persistentClass.SetCustomSQLDelete(sqlDeleteAll.Sql, sqlDeleteAll.Callable,
ExecuteUpdateResultCheckStyleConverter.Convert(sqlDeleteAll.Check));
}
if (loader != null)
{
persistentClass.LoaderName = loader.NamedQuery;
}
//tuplizers
if (annotatedClass.IsAttributePresent <TuplizerAttribute>())
{
foreach (TuplizerAttribute tuplizer in annotatedClass.GetAttributes <TuplizerAttribute>())
{
var mode = EntityModeConverter.Convert(tuplizer.EntityMode);
persistentClass.AddTuplizer(mode, tuplizer.Implementation.Name);
}
}
if (annotatedClass.IsAttributePresent <TuplizerAttribute>())
{
var tuplizer = annotatedClass.GetAttribute <TuplizerAttribute>();
var mode = EntityModeConverter.Convert(tuplizer.EntityMode);
persistentClass.AddTuplizer(mode, tuplizer.Implementation.Name);
}
if (!inheritanceState.HasParents)
{
var iter = filters.GetEnumerator();
while (iter.MoveNext())
{
var filter = iter.Current;
String filterName = filter.Key;
String cond = filter.Value;
if (BinderHelper.IsDefault(cond))
{
FilterDefinition definition = mappings.GetFilterDefinition(filterName);
cond = definition == null ? null : definition.DefaultFilterCondition;
if (StringHelper.IsEmpty(cond))
{
throw new AnnotationException("no filter condition found for filter " + filterName + " in " + name);
}
}
persistentClass.AddFilter(filterName, cond);
}
}
else
{
if (filters.Count > 0)
{
log.WarnFormat("@Filter not allowed on subclasses (ignored): {0}", persistentClass.EntityName);
}
}
log.DebugFormat("Import with entity name {0}", name);
try
{
mappings.AddImport(persistentClass.EntityName, name);
String entityName = persistentClass.EntityName;
if (!entityName.Equals(name))
{
mappings.AddImport(entityName, entityName);
}
}
catch (MappingException me)
{
throw new AnnotationException("Use of the same entity name twice: " + name, me);
}
}
protected override bool ValidateClassAttribute(System.Type type)
{
return(type.GetAttribute <TC>() != null);
}
private InstanceBox AutoResolveExpectType(Type expectType, bool singletonMode = false)
{
if (this.DisabledAutoResolving)
{
return(null);
}
Type actualType;
var defaultMappingAttr = expectType.GetAttribute <DefaultMappingAttribute>();
if (defaultMappingAttr != null)
{
actualType = defaultMappingAttr.ActualType;
}
else
{
//- 智能解析方式，不支持基类或值类型
if ((expectType.IsClass && expectType.IsAbstract) || expectType.IsValueType)
{
return(null);
}
if (!expectType.IsInterface)
{
return(this.InnerMapType(expectType, null, singletonMode));
}
//- 从映射事件获取
var instance = this.OnMapResolve(expectType);
if (instance != null)
{
this.Map(expectType, instance);
return(instance);
}
actualType = null;
//- 从智能映射表中获取（当前程序集）
var fullNames = DefaultMapFilter.GetAllActualType(expectType);
foreach (var fullName in fullNames)
{
actualType = expectType.Assembly.GetType(fullName, false);
if (actualType != null)
{
break;
}
}
//- 从智能映射表中获取（所有程序集）
if (actualType == null)
{
actualType = DefaultMapFilter.FindActualType(ObjectFactory.AllTypes, expectType, fullNames);
if (actualType == null)
{
return(null);
}
}
//- 判定实际类型是否已注册
if (this.CacheType.TryGetValue(actualType, out instance))
{
this.Map(expectType, instance);
return(instance);
}
}
//- 解析实际类型和预期类型
return(this.InnerMapType(actualType, expectType, singletonMode));
}
