/// <summary>
/// Checks the prefix for a variable defined within a method or property.
/// </summary>
/// <param name="variable">The variable to check.</param>
/// <param name="element">The element that contains the variable.</param>
/// <param name="validPrefixes">A list of valid prefixes that should not be considered hungarian.</param>
private void CheckMethodVariablePrefix(
IVariable variable, Element element, Dictionary <string, string> validPrefixes)
{
Param.AssertNotNull(variable, "variable");
Param.AssertNotNull(element, "element");
Param.Ignore(validPrefixes);
// Skip past any prefixes in the name.
int index = NamingRules.MovePastPrefix(variable.VariableName);
// Do not check for name casing on fields and events. These are checked elsewhere since they are elements, not simple variables,
// and therefor fall under different rules.
bool checkCasing = element.ElementType != ElementType.Field && element.ElementType != ElementType.Event;
// Check whether the name starts with a lower-case letter.
if (variable.VariableName.Length > index && char.IsLower(variable.VariableName, index))
{
// Check for hungarian notation.
this.CheckHungarian(variable.VariableName, index, variable.Location.LineNumber, element, validPrefixes);
// Check casing on the variable.
if (checkCasing && (variable.VariableModifiers & VariableModifiers.Const) == VariableModifiers.Const)
{
// Constants must start with an upper-case letter.
this.AddViolation(element, variable.Location.LineNumber, Rules.ConstFieldNamesMustBeginWithUpperCaseLetter, variable.VariableName);
}
}
else if (checkCasing && (variable.VariableModifiers & VariableModifiers.Const) == 0)
{
// Non-constant method variables must start with a lower-case letter.
this.AddViolation(element, variable.Location.LineNumber, Rules.FieldNamesMustBeginWithLowerCaseLetter, variable.VariableName);
}
}
/// <summary>
/// Initializes a new instance of the ValidPrefixes class.
/// </summary>
/// <param name="analyzer">The analyzer that this settings page is attached to.</param>
public ValidPrefixes(NamingRules analyzer) : this()
{
Param.AssertNotNull(analyzer, "analyzer");
this.analyzer = analyzer;
}
/// <summary>
/// Checks a field for compliance with naming prefix rules.
/// </summary>
/// <param name="field">The field element.</param>
/// <param name="validPrefixes">A list of valid prefixes that should not be considered hungarian.</param>
private void CheckFieldPrefix(Field field, Dictionary <string, string> validPrefixes)
{
Param.AssertNotNull(field, "field");
Param.Ignore(validPrefixes);
// Skip past any prefixes in the name.
int index = NamingRules.MovePastPrefix(field.Name);
// Check whether the name starts with a lower-case letter.
if (char.IsLower(field.Name, index))
{
// Check for hungarian notation.
this.CheckHungarian(field.Name, index, field.LineNumber, field, validPrefixes);
// Check casing on the field.
if (field.Const)
{
// Const fields must start with an upper-case letter.
this.AddViolation(
field,
field.LineNumber,
Rules.ConstFieldNamesMustBeginWithUpperCaseLetter,
field.Name);
}
else if (field.AccessModifierType == AccessModifierType.Public ||
field.AccessModifierType == AccessModifierType.Internal ||
field.AccessModifierType == AccessModifierType.ProtectedInternal)
{
// Public or internal fields must start with an upper-case letter.
this.AddViolation(
field,
field.LineNumber,
Rules.AccessibleFieldsMustBeginWithUpperCaseLetter,
field.Name);
}
// Readonly fields which are not declared private must start with an upper-case letter.
if (field.Readonly && field.AccessModifierType != AccessModifierType.Private)
{
this.AddViolation(
field,
field.LineNumber,
Rules.NonPrivateReadonlyFieldsMustBeginWithUpperCaseLetter,
field.Name);
}
}
else
{
// Constants must always start with an upper-case letter,
// while readonly fields may start with either an upper-case or
// a lower-case letter. Public or internal fields
// also must always start with an upper-case letter.
if (!field.Const &&
!field.Readonly &&
field.AccessModifierType != AccessModifierType.Public &&
field.AccessModifierType != AccessModifierType.Internal &&
field.AccessModifierType != AccessModifierType.ProtectedInternal)
{
this.AddViolation(
field,
field.LineNumber,
Rules.FieldNamesMustBeginWithLowerCaseLetter,
field.Name);
}
}
}
/// <summary>
/// Initializes a new instance of the ValidPrefixes class.
/// </summary>
/// <param name="analyzer">The analyzer that this settings page is attached to.</param>
public ValidPrefixes(NamingRules analyzer) : this()
{
Param.AssertNotNull(analyzer, "analyzer");
this.analyzer = analyzer;
}