.NET C# Как сделать заполнитель в Generics универсальным

Что-то вроде этого:

var genericType = typeof(TableQuery<>);
Type[] itemTypes = { Type.GetType("MyNamespace.Foo.Entities." + tableName) };
var concretType = genericType.MakeGenericType(itemTypes);
var query = Activator.CreateInstance(concretType);

Вы можете использовать отражение, как предложил @Christoph, но в этом случае есть более простой подход. Добавьте общий параметр TEntity в класс IRule вместо использования строкового свойства TableName и добавьте в класс метод GetTableQuery.

interface IRule<TEntity>
{
    string Rule { get; }
    string SaveToTable { get; }
    ReportEntity Handle(TableEntity entity);
    TableQuery<TEntity> GetTableQuery();
}

Затем в ваших реализациях IRule<TEntity> добавьте правильный объект. Например, для AddressRule.

    public class AddressRule : IRule<ContractAcccount>
    {
        public string TableName => "ContractAccount";

        public string Rule => "Email cannot be empty";

        public string SaveToTable => "XXXX";

        public ReportEntity Handle(TableEntity entity)
        {
            var contract = entity as ContractAccount;
            if(contract == null)
            {
                throw new Exception($"Expecting entity type {TableName}, but passed in invalid entity");
            }

            if (string.IsNullOrWhiteSpace(contract.Address))
            {
                var report = new ReportEntity(this.Rule, contract.UserId, contract.AccountNumber, contract.ContractNumber)
                {
                    PartitionKey = contract.UserId,
                    RowKey = contract.AccountNumber
                };

                return report;
            }

            return null;
        }

        public TableQuery<ContractAccount> GetTableQuery()
        {
            return new TableQuery<ContractAccount>();
        }
    }

Теперь в вашем методе Validate вы можете использовать метод GetTableQuery из файла IRule.

public async void Validate(CloudStorageAccount storageAccount)
{
    var tableClient = storageAccount.CreateCloudTableClient();

        //.....
        var query = rule.GetTableQuery();

        //...
        var rows = await tableToBeValidated.ExecuteQuerySegmentedAsync(query, token);
    }
    //...
}

Чем дольше я думаю об этом, тем больше у меня появляется ощущение, что вам нужно универсальное решение, а не решение с дженериками. Я предполагаю, что клиент таблицы в очереди

var tableClient = storageAccount.CreateCloudTableClient();

всегда возвращает что-то вроде DataTable или объекта с IEnumerable, независимо от того, запрашиваете ли вы ContractAccount или Bill. В этом случае может быть лучше иметь валидатор, который загружает все правила всех сущностей из базы данных (или с помощью заводских шаблонов или жестко закодированных), а затем применяет соответствующие правила к данной сущности.

Таким образом, набор правил может быть определен с использованием XML или другого вида сериализации (не является частью этого примера), и требуется всего несколько классов правил (я называю их EntityValidationRule).

Родитель всех правил для всех сущностей может выглядеть так:

public abstract class EntityValidationRule {

    //Private Fields
    private Validator validator;

    //Constructors

    public EntityValidationRule(String tableName, IEnumerable<String> affectedFields) {
        TableName = tableName ?? throw new ArgumentNullException(nameof(tableName));
        AffectedFields = affectedFields?.ToArray() ?? Array.Empty<String>();
    }

    //Public Properties

    public String TableName { get; }
    public String[] AffectedFields { get; }
    public virtual String Description { get; protected set; }

    //Public Methods

    public Boolean IsValid(DataRow record, ref IErrorDetails errorDetails) {
        if (record == null) throw new InvalidOperationException("Programming error in Validator.cs");
        if (!Validator.IdentifyerComparer.Equals(record.Table.TableName, TableName)) throw new InvalidOperationException("Programming error in Validator.cs");
        String myError = GetErrorMessageIfInvalid(record);
        if (myError == null) return true;
        errorDetails = CreateErrorDetails(record, myError);
        return false;
    }

    //Protected Properties

    public Validator Validator {
        get {
            return validator;
        }
        internal set {
            if ((validator != null) && (!Object.ReferenceEquals(validator, value))) {
                throw new InvalidOperationException("An entity validation rule can only be added to a single validator!");
            }
            validator = value;
        }
    }

    //Protected Methods

    protected virtual IErrorDetails CreateErrorDetails(DataRow record, String errorMessage) {
        return new ErrorDetails(record, this, errorMessage);
    }

    protected abstract String GetErrorMessageIfInvalid(DataRow record);

}

и, чтобы остаться с вашим примером, пример реализации для проверки пустого текстового поля может выглядеть так (с промежуточным классом OneFieldRule):

public abstract class OneFieldRule : EntityValidationRule {

    public OneFieldRule(String tableName, String fieldName) : base(tableName, new String[] { fieldName }) {
    }

    protected String FieldName => AffectedFields[0];

}

а вот так:

public class TextFieldMustHaveValue : OneFieldRule {

    public TextFieldMustHaveValue(String tableName, String fieldName) : base(tableName, fieldName) {
        Description = $"Field {FieldName} cannot be empty!";
    }

    protected override String GetErrorMessageIfInvalid(DataRow record) {
        if (String.IsNullOrWhiteSpace(record.Field<String>(FieldName))) {
            return Description;
        }
        return null;
    }

}

Затем центральный валидатор, который работает как служба для проверки любого объекта, который необходимо проверить, я мог бы реализовать следующим образом:

public sealed class Validator {

    //Private Fields
    private Dictionary<String, List<EntityValidationRule>> ruleDict;

    //Constructors

    //The list of all rules we just have somehow...
    public Validator(IEnumerable<EntityValidationRule> rules, StringComparer identifyerComparer) {
        if (rules == null) throw new ArgumentNullException(nameof(rules));
        if (identifyerComparer == null) identifyerComparer = StringComparer.OrdinalIgnoreCase;
        IdentifyerComparer = identifyerComparer;
        ruleDict = new Dictionary<String, List<EntityValidationRule>>(IdentifyerComparer);
        foreach (EntityValidationRule myRule in rules) {
            myRule.Validator = this;
            List<EntityValidationRule> myRules = null;
            if (ruleDict.TryGetValue(myRule.TableName, out myRules)) {
                myRules.Add(myRule);
            } else {
                myRules = new List<EntityValidationRule> { myRule };
                ruleDict.Add(myRule.TableName, myRules);
            }
        }
    }

    //Public Properties

    public StringComparer IdentifyerComparer { get; }

    //Public Methods

    public Boolean IsValid(DataRow record, ref IErrorDetails[] errors) {
        //Check whether the record is null
        if (record == null) {
            errors = new IErrorDetails[] { new ErrorDetails(record, null, "The given record is null!") };
            return false;
        }
        //Loop through every check and invoke them
        List<IErrorDetails> myErrors = null;
        IErrorDetails myError = null;
        foreach (EntityValidationRule myRule in GetRules(record.Table.TableName)) {
            if (myRule.IsValid(record, ref myError)) {
                if (myErrors == null) myErrors = new List<IErrorDetails>();
                myErrors.Add(myError);
            }
        }
        //Return true if there are no errors
        if (myErrors == null) return true;
        //Otherwise assign them as result and return false
        errors = myErrors.ToArray();
        return false;
    }

    //Private Methods

    private IEnumerable<EntityValidationRule> GetRules(String tableName) {
        if (ruleDict.TryGetValue(tableName, out List<EntityValidationRule> myRules)) return myRules;
        return Array.Empty<EntityValidationRule>();
    }

}

И детали ошибки как интерфейс:

public interface IErrorDetails {

    DataRow Entity { get; }
    EntityValidationRule Rule { get; }
    String ErrorMessage { get; }

}

... и его реализация:

public class ErrorDetails : IErrorDetails {

    public ErrorDetails(DataRow entity, EntityValidationRule rule, String errorMessage) {
        Entity = entity;
        Rule = rule;
        ErrorMessage = errorMessage;
    }

    public DataRow Entity { get; }

    public EntityValidationRule Rule { get; }

    public String ErrorMessage { get; }

}

Я знаю, что это совершенно другой подход, когда вы начали, но я думаю, что дженерики дают вам чертовски много работы с настраиваемыми сущностями, у которых есть настроенные валидаторы для каждой таблицы в вашей базе данных. И как только вы добавляете таблицу, код нужно писать, компилировать и распространять.