რატომ შეიყვანეს ref და out საკვანძო სიტყვები C#-ში მიმთითებელი ტიპებისთვის?

მიუხედავად იმისა, რომ მიმთითებელი ტიპები გადაეცემა მითითებით (გადაეცემა მითითების ასლი), ref ან out გამოყენებით შესაძლებელია გადაცემა მიუთითებელი თვითონ ობიექტის მითითებით.

ეს შეიძლება იყოს სასარგებლო შემდეგ შემთხვევებში:

• ობიექტის მაგალითის შეცვლა: საშუალებას აძლევს მეთოდს შეცვალოს, რომელ მაგალითზე მიუთითებს ცვლადი-პარამეტრი, ახალი მაგალითის მინიჭებით.
• TryParse მეთოდების განხორციელება: მეთოდი აბრუნებს bool-ს, რომელიც მიუთითებს წარმატებაზე, და შედეგი იწერება out-პარამეტრში. out-ის გარეშე, საჭიროა გამონაკლისის გადატანა წარუმატებლობის დროს (რაც ყოველთვის სასურველი არაა), ან ტუპლის დაბრუნება.
• ეფექტიანობა (ძნელად, მაგრამ შესაძლებელია): ზოგიერთ ექსტრემალურ შემთხვევებში, თუ ობიექტი ძალიან დიდია და ხშირად უნდა შეიცვალოს მეთოდში, გადაცემა მითითებით (ref) შეიძლება იყოს ცოტათი უფრო ეფექტიანი, ვიდრე ახალი ობიექტის დაბრუნება (თუმცა ეს იშვიათია).

მაგალითი ref-ის გამოყენებით მაგალითის შეცვლის:

public class MyClass
{
    public int Value { get; set; }
}

public void ReplaceObject(ref MyClass obj)
{
    obj = new MyClass { Value = 10 }; // შეცვლის ობიექტის მითითებას
}

// ... სხვა ადგილას
MyClass instance = new MyClass { Value = 5 };
ReplaceObject(ref instance);
// ახლა, instance მითითებულია ახალ ობიექტზე, რომლის Value = 10

მაგალითი out-ის გამოყენებით:

public bool TryParseInt(string s, out int result)
{
    // პარსინგის ლოგიკა
    if (int.TryParse(s, out result))
    {
        return true;
    }
    result = 0; // შეცვლის მნიშვნელობას წარუმატებლობის შემთხვევაში
    return false;
}

// ... სხვა ადგილას
int parsedValue;
if (TryParseInt("123", out parsedValue))
{
    // წარმატებული პარსინგი
}