/// <inheritdoc/>
/// <exception cref="NotSupportedException">Always thrown by "set" accessor (setter).</exception>
public object this[object key] {
get {
ArgumentValidator.EnsureArgumentIs <TKey>(key, "key");
return(innerDictionary[(TKey)key]);
}
set { throw Exceptions.CollectionIsReadOnly(null); }
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlLiteral <T> >(expression, "expression");
var replacingExpression = (SqlLiteral <T>)expression;
Value = replacingExpression.Value;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlVariable>(expression, "expression");
SqlVariable replacingExpression = expression as SqlVariable;
name = replacingExpression.Name;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlUserColumn>(expression, "expression");
SqlUserColumn replacingExpression = expression as SqlUserColumn;
this.expression = replacingExpression.Expression;
}
/// <inheritdoc/>
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlSubQuery>(expression, "expression");
SqlSubQuery replacingExpression = expression as SqlSubQuery;
query = replacingExpression.Query;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlPlaceholder>(expression, "expression");
var replacingExpression = (SqlPlaceholder)expression;
Id = replacingExpression.Id;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlCollate>(expression, "expression");
SqlCollate replacingExpression = expression as SqlCollate;
operand = replacingExpression.Operand;
collation = replacingExpression.Collation;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlUnary>(expression, "expression");
var replacingExpression = (SqlUnary)expression;
NodeType = replacingExpression.NodeType;
Operand = replacingExpression.Operand;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlParameterRef>(expression, "expression");
var replacingExpression = (SqlParameterRef)expression;
Name = replacingExpression.Name;
Parameter = replacingExpression.Parameter;
}
public override void ReplaceWith(SqlExpression expression)
{
var replacingExpression = expression as SqlColumn;
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlColumn>(expression, "expression");
sqlTable = replacingExpression.SqlTable;
name = replacingExpression.Name;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlCast>(expression, "expression");
var replacingExpression = (SqlCast)expression;
Operand = replacingExpression.Operand;
Type = replacingExpression.Type;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlNextValue>(expression, "expression");
SqlNextValue replacingExpression = expression as SqlNextValue;
sequence = replacingExpression.Sequence;
increment = replacingExpression.Increment;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlAggregate>(expression, "expression");
var replacingExpression = (SqlAggregate)expression;
NodeType = replacingExpression.NodeType;
distinct = replacingExpression.Distinct;
this.expression = replacingExpression.Expression;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlBinary>(expression, "expression");
var replacingExpression = (SqlBinary)expression;
NodeType = replacingExpression.NodeType;
Left = replacingExpression.Left;
Right = replacingExpression.Right;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlTrim>(expression, "expression");
var replacingExpression = (SqlTrim)expression;
this.expression = replacingExpression.expression;
trimCharacters = replacingExpression.trimCharacters;
trimType = replacingExpression.TrimType;
}
/// <summary>
/// This constructor is used to clone the instance.
/// </summary>
/// <param name="source">The type registry to clone the state of.</param>
protected TypeRegistry(TypeRegistry source)
{
ArgumentValidator.EnsureArgumentIs(source, GetType(), "source");
actions = new List <TypeRegistration>(source.actions);
actionSet = new HashSet <TypeRegistration>(source.actionSet);
types = new List <Type>(source.types);
typeSet = new HashSet <Type>(source.typeSet);
processor = source.processor;
assemblies = new Set <Assembly>(source.assemblies);
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlDynamicFilter>(expression, "expression");
var replacingExpression = (SqlDynamicFilter)expression;
Id = replacingExpression.Id;
Expressions.Clear();
Expressions.AddRange(replacingExpression.Expressions);
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentIs <SqlRound>(expression, "expression");
var replacingExpression = (SqlRound)expression;
Argument = replacingExpression.Argument;
Length = replacingExpression.Length;
Type = replacingExpression.Type;
Mode = replacingExpression.Mode;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlMatch>(expression, "expression");
SqlMatch replacingExpression = expression as SqlMatch;
value = replacingExpression.Value;
subQuery = replacingExpression.SubQuery;
matchType = replacingExpression.MatchType;
unique = replacingExpression.Unique;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlVariant>(expression, "expression");
var replacingExpression = (SqlVariant)expression;
Main = replacingExpression.Main;
Alternative = replacingExpression.Alternative;
Id = replacingExpression.Id;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlBetween>(expression, "expression");
SqlBetween replacingExpression = expression as SqlBetween;
NodeType = replacingExpression.NodeType;
left = replacingExpression.Left;
right = replacingExpression.Right;
expression = replacingExpression.Expression;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlLike>(expression, "expression");
SqlLike replacingExpression = expression as SqlLike;
this.expression = replacingExpression.expression;
pattern = replacingExpression.Pattern;
escape = replacingExpression.Escape;
not = replacingExpression.Not;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlExtract>(expression, "expression");
var replacingExpression = (SqlExtract)expression;
DateTimePart = replacingExpression.DateTimePart;
DateTimeOffsetPart = replacingExpression.DateTimeOffsetPart;
IntervalPart = replacingExpression.IntervalPart;
Operand = replacingExpression.Operand;
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlRow>(expression, "expression");
var replacingExpression = (SqlRow)expression;
expressions.Clear();
foreach (SqlExpression e in replacingExpression)
{
expressions.Add(e);
}
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlRowNumber>(expression, "expression");
var replacingExpression = (SqlRowNumber)expression;
OrderBy.Clear();
foreach (var item in replacingExpression.OrderBy)
{
OrderBy.Add(item);
}
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlUserFunctionCall>(expression, "expression");
SqlUserFunctionCall replacingExpression = expression as SqlUserFunctionCall;
name = replacingExpression.Name;
Arguments.Clear();
foreach (SqlExpression argument in replacingExpression.Arguments)
{
Arguments.Add(argument);
}
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlFunctionCall>(expression, "expression");
var replacingExpression = (SqlFunctionCall)expression;
FunctionType = replacingExpression.FunctionType;
Arguments.Clear();
foreach (SqlExpression argument in replacingExpression.Arguments)
{
Arguments.Add(argument);
}
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlCase>(expression, "expression");
SqlCase replacingExpression = expression as SqlCase;
value = replacingExpression.Value;
@else = replacingExpression.Else;
cases.Clear();
foreach (KeyValuePair <SqlExpression, SqlExpression> pair in replacingExpression)
{
cases.Add(pair);
}
}
public override void ReplaceWith(SqlExpression expression)
{
ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
ArgumentValidator.EnsureArgumentIs <SqlColumnRef>(expression, "expression");
SqlColumn = ((SqlColumnRef)expression).SqlColumn;
}
/// <inheritdoc/>
public bool Contains(object key)
{
ArgumentValidator.EnsureArgumentIs <TKey>(key, "key");
return(ContainsKey((TKey)key));
}