Dictionary or custom Collection I have a list of rule names coming from .xml file. These rule names needs to be validated against rule names in database (Validator.cs). If valid, then Id of these rule names are used to fetch user data from database (ExportService.cs).

I am using a Dictionary object to save name, Id pair from database -  

Validator.cs

var rulesDictionary = new Dictionary&lt;string, string&gt;();
while (sqlDataReader.Read())
{
    string ruleName = sqlDataReader["NAME"].ToString();
    string ruleLink = sqlDataReader["LINK"].ToString();
    rulesDictionary.Add(ruleName, ruleLink);
}


The values coming from XML file are validated against this dictionary as -

ExportService.cs

if (DepositRulesDictionary.ContainsKey(xmlRuleName1) == false)
{
     //log error
}


If all the values are valid, then this dictionary is further used to pass 'ruleLink' values in ExportService.cs.

I used Dictionary object in this instance as it returns O(1) result for validating XML file values.  

My XML file is not going to be very big, so efficiency is not a major concern right now.

My question is what is more recommended -  


Dictionary&lt;string, string&gt; object or   
List&lt;T&gt; where T is having two properties of Name and Link.


For scalability and unit-testability?
I think you are too concerned with the implementation right now. 

The last part of the question 


  ... recommended ... for scalability and unit-testability?


is the most important one.

Let's imaging you were to write the test for this feature. You would start off by designing the API that the user of the functionality would ultimately consume. Secondly as far as the tests go ... they could careless how it is implemented 'under the hood' it only cares that it meets the requirements performance just being on possible requirement. Many times asymptotic complexity doesn't even play a critical role unless n is large. Take for example Strassen matrix multiplication it is only practical for larger matrices.

For scalability I'm assuming you mean maintainability and extensibility. The best way to achieve that is to use the dependency inversion principle (DIP) so that you are not depending on either a list or a dict but instead on the correct abstraction.

One possible abstraction is that the rules represent a validation.

interface IValidator&lt;T&gt;
{
   bool IsValid(T item);
}


Your test would look as follows.

[Test]
void NoRulesEverythingIsFalse()
{
    var rules = new Rules();
    Assert.False(rules.IsValid(""));
}

[Test]
void SingleRule()
{
    var rules = new Rules(new[] 
    {
        new LinkedRule("abc", "Only abc is allowed.")
    });
    Assert.True(rules.IsValid("abc"));
    Assert.AreEqual(
        rules.GetLinkForRule("abc"),
        "Only abc is allowed.");
    Assert.False(rules.IsValid("123"));
}


Now with this you can implement it however you want as long as your test pass. Feel free to add a performance test if it is required.

// LinkedRule.cs
struct LinkedRule {
    string Rule { get; set; }
    string Link { get; set; }
}


// Rules.cs
class Rules : IValidator&lt;string&gt;
{
    private Dictionary&lt;string, LinkedRule&gt; RulesToLinks { get; }

    public RuleValidator(IEnumerable&lt;LinkedRule&gt; linkedRules)
    {
        RulesToLinks = linkedRules.ToDictionary(
            x =&gt; x.Rule);
    }

    public bool IsValid(string rule) =&gt;
        RulesToLinks.Keys.Contains(rule);

    public string GetLinkForRule(string rule) =&gt; RulesToLinks[rule];

    // ...
}