Csla/PropertyInfo.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="PropertyInfo.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Maintains metadata about a property.</summary>
//-----------------------------------------------------------------------
using System;
using System.Linq;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
 
namespace Csla
{
  public class PropertyInfo<T> : Core.IPropertyInfo, IComparable
  {
    public PropertyInfo(string name)
      : this(name, null, null, DataBindingFriendlyDefault(), RelationshipTypes.None)
    { }
 
    public PropertyInfo(string name, RelationshipTypes relationship)
      : this(name, null, null, DataBindingFriendlyDefault(), relationship)
    { }
 
    public PropertyInfo(string name, T defaultValue)
      : this(name, null, null, defaultValue, RelationshipTypes.None)
    { }
 
    public PropertyInfo(string name, string friendlyName)
        : this(name, friendlyName, null, DataBindingFriendlyDefault(), RelationshipTypes.None)
    { }
 
    public PropertyInfo(string name, string friendlyName, Type containingType)
        : this(name, friendlyName, containingType, DataBindingFriendlyDefault(), RelationshipTypes.None)
    { }
 
    public PropertyInfo(string name, string friendlyName, Type containingType, T defaultValue)
        : this(name, friendlyName, containingType, defaultValue, RelationshipTypes.None)
    { }
 
    public PropertyInfo(string name, string friendlyName, Type containingType, RelationshipTypes relationship) 
      : this(name, friendlyName, null, DataBindingFriendlyDefault(), relationship)
    { }
 
    public PropertyInfo(string name, string friendlyName, Type containingType, T defaultValue, RelationshipTypes relationship)
    {
      Name = name;
      _friendlyName = friendlyName;
      _relationshipType = relationship;
      if (containingType != null)
        _propertyInfo = containingType.GetProperty(Name);
 
      _defaultValue = defaultValue;
    }
 
    public string Name { get; private set; }
 
    public Type Type
    {
      get { return typeof(T); }
    }
 
    private readonly System.Reflection.PropertyInfo _propertyInfo;
 
    private readonly string _friendlyName;
    public virtual string FriendlyName
    {
      get
      {
        string result = Name;
        if (!string.IsNullOrWhiteSpace(_friendlyName))
        {
          result = _friendlyName;
        }
        else if (_propertyInfo != null)
        {
          var display = _propertyInfo.GetCustomAttributes(typeof(DisplayAttribute), true).OfType<DisplayAttribute>().FirstOrDefault();
          if (display != null)
          {
            // DataAnnotations attribute.
            result = display.GetName();
          }
          else
          {
            // ComponentModel attribute.
            var displayName = _propertyInfo.GetCustomAttributes(typeof(DisplayNameAttribute), true).OfType<DisplayNameAttribute>().FirstOrDefault();
            if (displayName != null)
              result = displayName.DisplayName;
          }
        }
        return result;
      }
    }
 
    private readonly T _defaultValue;
    public virtual T DefaultValue
    {
      get { return _defaultValue; }
    }
 
    object Core.IPropertyInfo.DefaultValue
    {
      get { return DefaultValue; }
    }
 
    Core.FieldManager.IFieldData Core.IPropertyInfo.NewFieldData(string name)
    {
      return NewFieldData(name);
    }
 
    protected virtual Core.FieldManager.IFieldData NewFieldData(string name)
    {
      return new Core.FieldManager.FieldData<T>(name);
    }
 
 
    // Default value is ManagedField
    private RelationshipTypes _relationshipType = RelationshipTypes.None;
 
    public RelationshipTypes RelationshipType
    {
      get { return _relationshipType; }
    }
 
    private int _index = -1;
 
    int Core.IPropertyInfo.Index
    {
      get { return _index; }
      set { _index = value; }
    }
 
    public bool IsChild { get => typeof(Core.IBusinessObject).IsAssignableFrom(Type); }
 
    public System.Reflection.PropertyInfo GetPropertyInfo() => _propertyInfo;
 
    #region IComparable Members
 
    int IComparable.CompareTo(object obj)
    {
      return Name.CompareTo(((Core.IPropertyInfo)obj).Name);
    }
 
    #endregion
 
    public static T DataBindingFriendlyDefault()
    {
      // if T is string we need an empty string, not null, for data binding
      if (typeof(T) == typeof(string))
        return (T)(object)string.Empty;
 
      return default(T);
    }
  }
}