Is there a way to transfer a value of an int from one object to another within the same class via method in c#

Question

    class Bank
{
    
        private String accoutNumber;
        private double credit;
        public String AccountNumber
        {
            get { return accoutNumber; }
            set { accoutNumber = value; }
        }
        public double Credit
    {
            get { return credit; }
            set { credit = value; }
        }
        

        public Bank() { }
        public Bank(String accoutNumber)
        {
            this.accoutNumber = accoutNumber;
        }
        public Bank(String accoutNumber, int credit)
        {
            this.accoutNumber = accoutNumber;
            this.credit = credit;
        }
       

        public void addBalance(int ammount) { credit += ammount; }
        public void vyber(int ammount)
        {
            if (ammount > credit)
                return;
            credit -= ammount;
        }
        public void transfer(int ammount, String accoutNumber)
        {
            if (ammount > credit)
                return;
            //else transfer from one object to another
        }

}

(in another file i am using the transfer method to transfer credit from one object to another, i just don't know how to do that, also i am not using any files for database, it is as simple as it could possible be)

    Bank object1 = new Bank("1234567890/1234", 10000);
    Bank object2 = new Bank("7845213154/1448", 7000);
    object1.transfer("7845213154/1448", 2000)
    //object1's credit = 8000
    //object2's credit = 9000 

Answer 1

It sounds like what you're trying to do here is:

• you have multiple objects of some type (perhaps called Account ), each of which has an identity defined by accountNumber
• when transferring funds, you want to look up a different account by number, and access that

Now: there is no automatic pre-build index of objects by their accountNumber . That is something you would need to add separately . For example, you might have a Dictionary<string, Account> , that you add each instance to:

var foo = new Account { accoutNumber = "12391", Credit = 420 };
var bar = new Account { accoutNumber = "58u98:a24", Credit = 9000 };

var accounts = new Dictionary<string, Account>();
accounts.Add(foo.accoutNumber , foo);
accounts.Add(bar.accoutNumber , bar);
// etc

Now, we can obtain accounts by their identity:

if (!accounts.TryGetValue(someAccountId, out var someAccount))
{
    throw new KeyNotFoundException("Target bank account not found");
}
// here, someAccount is the one we want by someAccountId
someAccount.DoSomething();

This, however, presents a problem; you wouldn't normally expect each individual Account object to keep hold of the entire set of accounts; you could have some account management type (which maintains the dictionary) perform both lookups and perform both deltas:

if (!accounts.TryGetValue(fromId, out var from))
{
    throw new KeyNotFoundException("Source bank account not found");
}
if (!accounts.TryGetValue(toId, out var to))
{
    throw new KeyNotFoundException("Destination bank account not found");
}
if (from.Balance < amount)
{
    throw new InvalidOperationException("Insufficient funds in source account");
}
from.AddBalance(-amount);
to.AddBalance(amount);

Note that this is not thread-safe. I'm guessing threading isn't a concern for what you're doing.

The alternative would be to pass in the accounts lookup to your method. This could the dictionary itself, or some helper service:

object1.Transfer("7845213154/1448", 2000, accounts);

and have the Transfer method do the lookup internally, after whatever validation you need:

public void Transfer(decimal amount, string accountNumber, Dictionary<string, Account> accounts)
{
    if (!accounts.TryGetValue(accountNumber, out var to))
    {
        throw new KeyNotFoundException("Destination bank account not found");
    }
    if (amount > credit)
    {
        throw new InvalidOperationException("Insufficient funds in source account");
    }
    AddBalance(-amount);
    to.AddBalance(amount);
}

Again, this is not thread-safe in any way, and is not transactional etc.

Answer 2

Would go something like this (refine some rules here and there about validation of account numbers and such).

public class Bank
{
    private static global::System.Collections.Generic.Dictionary<string, global::Bank> accounts = new System.Collections.Generic.Dictionary<string, global::Bank>(10000);
    private string accountNumber;
    private decimal credit;
    public string AccountNumber { get { return this.accountNumber; } }
    public decimal Credit { get { return this.credit; } }
    public void addBalance(decimal ammount) { this.credit += ammount; }
    public void vyber(int ammount) { if (ammount <= credit) { this.credit -= ammount; } }

    public static global::Bank GetAccount(string number)
    {
        if (string.IsNullOrEmpty(number)) { return null; }
        else
        {
            global::Bank bank = global::Bank.accounts[number];
            if (bank == null) { bank = new global::Bank(number); }
            return bank;
        }
    }

    public void transfer(decimal ammount, string number)
    {
        if (ammount <= credit && number != this.accountNumber)
        {
            global::Bank bank = global::Bank.GetAccount(number);
            if (bank == null) { throw new global::System.ArgumentException("Not Found"); }
            else
            {
                this.credit -= ammount;
                bank.addBalance(ammount);
            }
        }
    }

    private Bank(string number) { this.accountNumber = number; }
}