public class Foo
{
    public string Value1 {get;set;}
    public string Value2 {get;set;}
    public string Concat() => return Value1 + Value2;
}

public class Foo
{
    public string Concat(string value1, string value2) => return value1 + value2;
}

{
    id: 1,
    description: 'test'
}

obj.foo = "foo";

        protected IEnumerable<string> GetRemoteKeyValues(RemoteKeyAttribute attribute)
        {
            var sql = $"select {attribute.ColumnName} from {Properties.Settings.Default.SageServer}.{Properties.Settings.Default.SageDb}.dbo.{attribute.TableName}";
            if (!string.IsNullOrEmpty(attribute.FilterColumn) && !string.IsNullOrEmpty(attribute.FilterValue))
            {
                sql += $" where {attribute.FilterColumn} = '{attribute.FilterValue}'";
            }

        }

    public class Collection : EntityBase
    {
        [RemoteKey("COLLECTION")]
        public string Code { get; set; }
        public string Description { get; set; }
        public bool EnableFits { get; set; }
        public int ModelCodeLength { get; set; }
    }

    public RemoteKeyAttribute(string optFieldName)
        : this("CSOPTFD", "VALUE", "OPTFIELD", optFieldName)
    { }

var sql = $"select {attribute.ColumnName} from {Properties.Settings.Default.SageServer}.{Properties.Settings.Default.SageDb}.dbo.{attribute.TableName}";

var sql = $"select [{attribute.ColumnName}] from [{Properties.Settings.Default.SageServer}].[{Properties.Settings.Default.SageDb}].[dbo].[{attribute.TableName}]";

        private RemoteKeyAttribute RemoteKey(TEntity entity, string propertyName)
        {
            var property = entity.GetType().GetProperties().SingleOrDefault(p => p.Name == propertyName);
            if (property == null)
            {
                return null;
            }

            return property.GetCustomAttributes(typeof(RemoteKeyAttribute), true).SingleOrDefault() as RemoteKeyAttribute;
        }

        protected IEnumerable<string> GetRemoteKeyValues(TEntity entity, string propertyName)

        public IDictionary<string, RemoteKeyAttribute> RemoteKeys => GetType()
            .GetProperties()
            .Select(p => new {
                Name = p.Name,
                RemoteKey = p.GetCustomAttributes(typeof(RemoteKeyAttribute), true).SingleOrDefault() as RemoteKeyAttribute
            }).Where(k => k.RemoteKey != null)
            .ToDictionary(k => k.Name, k => k.RemoteKey);

    public abstract class EntityBase
    {
        private Lazy<IDictionary<string, RemoteKeyAttribute>> _remoteKeys;

        protected EntityBase()
        {
            _remoteKeys = new Lazy<IDictionary<string, RemoteKeyAttribute>>(() => GetType()
                .GetProperties()
                .Select(p => new
                    {
                        Name = p.Name,
                        RemoteKey = p.GetCustomAttributes(typeof(RemoteKeyAttribute), true).SingleOrDefault() as RemoteKeyAttribute

        private static readonly Dictionary<Type, object> TypeLogs = new Dictionary<Type, object>();

        public static object GetClassLogger(this Type type)
        {
            if (!TypeLogs.ContainsKey(type))
            {
                TypeLogs.Add(type, Activator.CreateInstance(typeof(ILogger<>).MakeGenericType(type)));
            }
            return TypeLogs[type];
        }

        public static ILogger<T> GetClassLogger<T>()
        {
            if (!TypeLogs.ContainsKey(typeof(T)))