Using strings in an enum

The accounts number changed and they contain also digits...

You're using the wrong tool for the job then. The values of an enumerated type are meant to be defined at compile time. If the account numbers change then you should be using a more advanced type (i.e., a class) which will allow for mutation (if needed) and also more advanced formatting for the UI layer.

Ed S. is correct; an enum is the wrong tool for the job. To elaborate on his answer:

Enum values are constants and constants are required to be logically constant for all time, past, present and future. If an enum value can possibly change over time without its meaning changing then it should not be an enum or const in the first place.

Similarly, if the set of things in the enum can change over time, even if their values stay the same, then an enum is probably a bad idea. You do not want to be in this situation:

enum Banks 
{
    BankOfFoo,
    BankOfBar,
    BankOfBlah,
    BankOfABC
}

and then next version, Bank Of Foo has bought Bank of Bar, Bank of Blah has gone out of business and Bank of ABC has changed their name to Bank of DEF, and a brand new Bank Of XYZ has been formed.

Enums are the wrong mechanism for representing stuff that changes over time. You should not be using an enum for this, and you should not be using a const string either.

var accounts = new Dictionary<string,string>();
accounts.Add("Bank of America", "ABC12345");
accounts.Add("Bank of India", "122-6X-666");

string number = accounts["Bank of America"];

Or, if you prefer to stick to an enum:

public enum Accounts {
    BankOfAmerica,
    BankOfIndia
}

var accounts = new Dictionary<Accounts,string>();
accounts.Add(Accounts.BankOfAmerica, "ABC12345");
accounts.Add(Accounts.BankOfIndia, "122-6X-666");

string number = accounts[Accounts.BankOfAmerica];

You would be better off using a class for BankAccount, like so:

public class BankAccount
{
    public string Name { get; set; }
    public int Number { get; set;}

    public BankAccount(string name, int number)
    {
        Name = name;
        Number = number;
    }
}

And then holding the actual accounts in a collection, like a List:

public List<BankAccount> BankAccounts = new List<BankAccount>();

You can then easily search the bank account by number or by name, or pretty much by any property by using a loop or LINQ:

public BankAccount GetAccountByName(string name)
{
    return BankAccounts.FirstOrDefault(a => a.Name == name);
}

And when you've found the BankAccount object you want to change, it's just a matter of changing the property:

var account = GetAccountByName("BankOfAmerica");

account.Number = 12345678;

Or by creating a method that does that for you. Enums aren't the way to go with this; they're a collection of constants which have to be defined at compile time, and aren't meant to be changed. Even if it takes you a lot of time to implement a change like this, it's worth it in the long run and will only make things easier from there on.

Why don't you use Attributes?

class AccountAttribute : Attribute 
{
    public string MyValue { get; set; }
    // add any other stuff...
}

public enum Accounts
{
    [Account(MyValue = "A")]
    BankOfAmerica = 123654,

    [Account(MyValue = "B")]
    BankOfIndia = 765091
}

After that, you just use stadard reflexion to get your custom attributes on your fields.

I don't think any of these answers properly address this question. What is really needed here is a database to store this data which can change over time. Trying to store changing data in code is generally a bad idea, because it will require that you recompile every time the data changes.

A database table with columns for the AccountId, AccountName (and possibly other data that needs to be stored) is definitely the most robust solution. If this is just a quick and dirty app it doesn't even need to be a full fledged database, something like SQLite or SQL Server Express would work.

You can then access this table through code with ADO .NET or an Object-Relational-Mapper of your choice.