Home » C # Methotlar (Yöntemler)

C # Methotlar (Yöntemler)

Eğitimin bu bölümünde, C # yöntemlerini ele alacağız.

Nesne yönelimli programlamada nesnelerle çalışıyoruz. Nesneler, bir programın temel yapı taşlarıdır. Nesneler, veri ve yöntemlerden oluşur. Yöntemler, oluşturulan nesnelerin durumunu değiştirir. Nesnelerin dinamik kısmıdırlar; veri statik kısımdır.

C # yöntem tanımı

Bir yöntem, bir dizi ifade içeren bir kod bloğudur. Yöntemler bir sınıf veya yapı içinde bildirilmelidir. Yöntemlerin yalnızca belirli bir görevi yerine getirmesi iyi bir programlama uygulamasıdır. Yöntemler programlara modülerlik getirir. Yöntemlerin doğru kullanımı aşağıdaki avantajları sağlar:

  • Kod tekrarını azaltmak
  • Karmaşık problemleri daha basit parçalara ayırmak
  • Kodun netliğini artırmak
  • Kodun yeniden kullanımı
  • Bilgi gizleme

C # yöntem özellikleri

Yöntemlerin temel özellikleri şunlardır:

  • Erişim düzeyi
  • Dönüş değeri türü
  • Yöntem adı
  • Yöntem parametreleri
  • Parantez
  • İfade bloğu

Yöntemlerin erişim düzeyi, erişim değiştiricilerle kontrol edilir. Yöntemlerin görünürlüğünü belirlerler. Yöntemi kimin arayabileceğini belirlerler. Yöntemler, çağırana bir değer döndürebilir. Metodumuzun bir değer döndürmesi durumunda, veri tipini sağlıyoruz. Değilse, voidyöntemimizin değer döndürmediğini belirtmek için anahtar kelimeyi kullanırız. Yöntem parametreleri parantez içine alınır ve virgülle ayrılır. Boş parantezler, yöntemin parametre gerektirmediğini gösterir. Yöntem bloğu {} karakterlerle çevrilidir. Blok, yöntem çağrıldığında yürütülen bir veya daha fazla ifade içerir . Boş bir yöntem bloğuna sahip olmak yasaldır.

C # yöntem imzası

Bir yöntem imzası , C # derleyicisi için bir yöntemin benzersiz bir tanımlamasıdır. İmza, bir yöntem adından ve biçimsel parametrelerinin her birinin türü ve türünden (değer, referans veya çıktı) oluşur. Yöntem imzası dönüş türünü içermez.

Herhangi bir yasal karakter, bir yöntem adına kullanılabilir. Kural olarak, yöntem adları büyük harfle başlar. Yöntem isimleri fiiller veya fiiller ve ardından sıfatlar veya isimlerdir. Sonraki her sözcük bir büyük harfle başlar. Aşağıdakiler, C # ‘daki tipik yöntem isimleridir:

  • Yürüt
  • FindId
  • SetName
  • GetName
  • CheckIfValid
  • TestValidity

C # basit örnek

Basit bir örnekle başlıyoruz.

using System;

namespace SimpleMethod
{
    class Base
    {
        public void ShowInfo()
        {
            Console.WriteLine("Bu Base sınıfıdır");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Base bs = new Base();
            bs.ShowInfo();
        }
    }
}

ShowInfo()Sınıfının adını yazdıran bir yöntemimiz var.

class Base
{
    public void ShowInfo()
    {
        Console.WriteLine("Bu Base sınıfıdır");
    }
}

Her yöntem bir sınıf veya yapı içinde tanımlanmalıdır. Bir adı olmalı. Bizim durumumuzda adı ShowInfo(). Yöntemin adından önce gelen anahtar sözcükler, erişim belirticisi ve dönüş türüdür. Parantezler, yöntemin adını takip eder. Yöntemin parametrelerini içerebilirler. Bizim yöntemimiz herhangi bir parametre almamaktadır.

Bu Main() yöntem,. Her konsolun veya GUI uygulamasının giriş noktasıdır. Beyan edilmelidir static. Nedenini daha sonra göreceğiz. Bir Main() yöntemin dönüş türü void veya olabilir intMain() Yöntemin erişim tanımlayıcısı atlandı. Böyle bir durumda, varsayılan olan kullanılır private. Yöntem public için erişim tanımlayıcısının kullanılması önerilmez Main(). Meclislerde başka herhangi bir yöntemle çağrılmaması gerekiyor. Uygulama başladığında onu çağırabilmesi gereken yalnızca CLR’dir.

Base bs = new Base();
bs.ShowInfo();

Base Sınıfın bir örneğini oluşturuyoruz . ShowInfo()Yöntemi nesne üzerine çağırıyoruz . Yöntemin bir örnek yöntemi olduğunu söylüyoruz, çünkü çağrılması için bir örneğe ihtiyacı var. Yöntem, nesne örneğini ve ardından üye erişim operatörü – nokta ve ardından yöntem adı belirtilerek çağrılır.

C # yöntemi parametreleri

Parametre, yönteme iletilen bir değerdir. Yöntemler bir veya daha fazla parametre alabilir. Yöntemler verilerle çalışıyorsa, verileri yöntemlere aktarmalıyız. Parantez içinde belirterek yapıyoruz. Yöntem tanımında, her parametre için bir isim ve tip sağlamalıyız.

using System;

namespace MethodParameters
{
    class Addition
    {
        public int AddTwoValues(int x, int y)
        {
            return x + y;
        }

        public int AddThreeValues(int x, int y, int z)
        {
            return x + y + z;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Addition a = new Addition();
            int x = a.AddTwoValues(12, 13);
            int y = a.AddThreeValues(12, 13, 14);

            Console.WriteLine(x);
            Console.WriteLine(y);
        }
    }
}

Yukarıdaki örnekte iki yöntemimiz var. Biri iki parametre alır, diğeri üç parametre alır.

public int AddTwoValues(int x, int y)
{
    return x + y;
}

AddTwoValues() Yöntem iki parametre alır. Bu parametrelerin inttürü vardır. Yöntem ayrıca çağırana bir tamsayı döndürür. returnYöntemden bir değer döndürmek için anahtar kelimeyi kullanırız.

public int AddThreeValues ​​(int x, int y, int z) 
{ 
    dönüş x + y + z; 
}

AddThreeValues()Önceki yönteme benzemektedir. Üç parametre alır.

int x = a.AddTwoValues ​​(12, 13);

AddTwoValues()Toplama nesnesinin yöntemini çağırıyoruz . İki değer alır. Bu değerler yönteme aktarılır. Yöntem, xdeğişkene atanan bir değer döndürür .

C # değişken bağımsız değişken sayısı

Bir yöntem, değişken sayıda argüman alabilir. Bunun için params anahtar kelimeyi kullanıyoruz. params Anahtar kelimeden sonra ek parametreye izin verilmez . params Bir yöntem bildiriminde yalnızca bir anahtar kelimeye izin verilir.

using System;

namespace SumOfValues
{
    class Program
    {
        static void Main(string[] args)
        {
            Sum(1, 2, 3);
            Sum(1, 2, 3, 4, 5);
        }

        static void Sum(params int[] list)
        {
            Console.WriteLine("{0} item", list.Length);
        
            int sum = 0;

            foreach (int i in list) 
            {
                sum = sum + i;
            }
            
            Console.WriteLine("Toplamları {0}", sum);
        }
    }
}

Sum() Değişken sayıda argüman alabilen bir yöntem oluşturuyoruz. Yöntem, yönteme aktarılan değerlerin toplamını hesaplayacaktır.

Toplam (1, 2, 3); 
Toplam (1, 2, 3, 4, 5);

Sum() Yöntemi iki kez çağırıyoruz . Bir durumda 3, ikinci durumda 5 argüman alır. Aynı yöntemi diyoruz.

statik _a total (params int [] liste) 
{ 
... 
}

Sum()Yöntem, tam sayı değerlerine ait değişken sayıda sunar. Tüm değerler liste dizisine eklenir.

Console.WriteLine ("{0} öğe var", list.Length);

Liste dizisinin uzunluğunu yazdırıyoruz.

int sum = 0;
foreach (int i in list) 
{
    sum = sum + i;
}

Listedeki değerlerin toplamını hesaplarız.

$ dotnet run 
3 öğe var Toplamları 
6 
5 öğe var 
Toplamları 15

Bu, örneğin çıktısıdır.

C # geri dönen demetler

C # yöntemleri, tuples kullanarak birden çok değer döndürebilir.

using System;
using System.Collections.Generic;
using System.Linq;

namespace ReturingTuples
{
    class Program
    {
        static void Main(string[] args)
        {
            var vals = new List<int> { 11, 21, 3, -4, -15, 16, 5 };

            (int min, int max, int sum) = BasicStats(vals);

            Console.WriteLine($"Min: {min}, Max: {max}, Sum: {sum}");
        }

        static (int, int, int) BasicStats(List<int> vals)
        {
            int sum = vals.Sum();
            int min = vals.Min();
            int max = vals.Max();

            return (min, max, sum);
        }
    }
}

BasicStats()Bir tamsayı listesinin temel istatistiklerini döndüren bir yönteme sahibiz .

System.Linq kullanarak;

Biz ithalat gerekir System.Linqiçin Sum()Min()ve Max()uzatma yöntemlerine.

var vals = new List <int> {11, 21, 3, -4, -15, 16, 5};

Bir tamsayı değerler listemiz var. Bu değerlerden bazı temel istatistikleri hesaplamak istiyoruz.

(int min, int max, int sum) = BasicStats (vals);

Tuple elemanlarını üç değişkene atamak için bir yapısızlaştırma işlemi kullanıyoruz.

static (int, int, int) BasicStats (List <int> vals) 
{

Yöntem bildirimi, bir demet döndürdüğümüzü belirtir.

getiri (min, maks, toplam); 

Üç öğeden oluşan bir demet döndürüyoruz.

$ dotnet çalıştırma 
Minimum: -15, Maksimum: 21, Toplam: 37

Bu çıktıdır.

C # anonim yöntemler

Anonim yöntemler, bir adı olmayan satır içi yöntemlerdir. Anonim yöntemler, ayrı bir yöntem oluşturma ihtiyacını ortadan kaldırarak kodlama ek yükünü azaltır. Anonim yöntemler olmadan, geliştiriciler genellikle yalnızca bir yöntemi çağırmak için bir sınıf oluşturmak zorunda kaldılar.

using System;
using System.Timers;

namespace AnonymousMethod
{
    class Program
    {
        static void Main(string[] args)
        {
            var timer = new Timer();

            timer.Elapsed += new ElapsedEventHandler(
                delegate(object source, ElapsedEventArgs e)
                {
                    Console.WriteLine("Event triggered at {0}", e.SignalTime);
                }
            );

            timer.Interval = 2000;
            timer.Enabled = true;

            Console.ReadLine();
        }
    }
}

Bir zamanlayıcı nesnesi oluşturuyoruz ve her 2 saniyede bir anonim yöntem olarak adlandırıyoruz.

var timer = new Timer ();

Bir Timersınıf, bir uygulamada yinelenen olaylar üretir.

timer.Elapsed + = new ElapsedEventHandler ( 
    delege (nesne kaynağı, ElapsedEventArgs e) 
    { 
        Console.WriteLine ("{0} 'de tetiklenen olay", e.SignalTime); 
    } 
);

Burada anonim yöntemi Elapsedetkinliğe ekliyoruz. delegateAnahtar kelime anonim yöntemi belirtmek için kullanılır.

Console.ReadLine ();

Bu sırada program kullanıcıdan bir girdi bekler. Return tuşuna bastığımızda program sona erer. Aksi takdirde, program olayların oluşturulmasından hemen önce biter.

C # bağımsız değişkenleri değere göre, başvuruya göre geçirme

C #, bağımsız değişkenleri yöntemlere geçirmenin iki yolunu destekler: değere göre ve başvuruya göre. Bağımsız değişkenlerin varsayılan aktarımı değere göredir. Değere göre argümanlar ilettiğimizde, yöntem yalnızca değerlerin kopyalarıyla çalışır. Bu, büyük miktarda veriyle çalıştığımızda performans ek yüklerine yol açabilir.

refReferansla bir değer iletmek için anahtar kelimeyi kullanırız. Değerleri referans olarak ilettiğimizde, yöntem gerçek değerlere bir referans alır. Orijinal değerler değiştirildiğinde etkilenir. Değerlerin bu şekilde aktarılması daha fazla zaman ve alan verimlidir. Öte yandan, hataya daha yatkındır.

Hangi argümanları iletme yolunu kullanmalıyız? Bu duruma bağlıdır. Çalışanların maaşları gibi bir dizi veriye sahip olduğumuzu varsayalım. Verilerin bazı istatistiklerini hesaplamak istiyorsak, onları değiştirmemize gerek yoktur. Değerlere göre geçebiliriz. Büyük miktarda veriyle çalışırsak ve hesaplama hızı kritikse, referans olarak geçeriz. Verileri değiştirmek istiyorsak, örneğin maaşlarda bazı indirimler veya artışlar yapmak istiyorsak, bunu referans olarak verebiliriz.

Aşağıdaki örnek, argümanları değerlere göre nasıl ilettiğimizi gösterir.

using System;

namespace PassingByValues
{
    class Program
    {
        static int a = 4;
        static int b = 7;

        static void Main(string[] args)
        {
            Console.WriteLine("Outside Swap method");
            Console.WriteLine("a is {0}", a);
            Console.WriteLine("b is {0}", b);

            Swap(a, b);

            Console.WriteLine("Outside Swap method");
            Console.WriteLine("a is {0}", a);
            Console.WriteLine("b is {0}", b);
        }

        static void Swap(int a, int b)
        {
            int temp = a;
            a = b;
            b = temp;

            Console.WriteLine("Inside Swap method");
            Console.WriteLine("a is {0}", a);
            Console.WriteLine("b is {0}", b);
        }        
    }
}

Swap()Yöntem arasındaki sayıları değiştirir a ve bdeğişkenler. Orijinal değişkenler etkilenmez.

statik int a = 4; 
statik int b = 7;

Başlangıçta bu iki değişken başlatılır. Değişkenler static, statik yöntemlerden kullanıldıkları için bildirilmelidir .

Takas (a, b);

Swap()Yöntemi diyoruz . Yöntem argüman olarak ave bdeğişkenleri alır .

int temp = a; 
a = b; 
b = sıcaklık;

Swap()Yöntemin içinde değerleri değiştiriyoruz. aVe bdeğişkenlerinin yerel olarak tanımlandığını unutmayın . Sadece Swap()yöntem içinde geçerlidirler .

$ dotnet run 
Outside Swap yöntemi 
a 4'tür 
b 7 
Inside Swap metodu 
a 7 
b 4 
Outside Swap metodu 
a 4 
b 7

Çıktı, orijinal değişkenlerin etkilenmediğini gösterir.

Sonraki kod örneği, değerleri yönteme başvuruya göre iletir. Orijinal değişkenler Swap()yöntem içinde değiştirilir . Hem yöntem tanımı hem de yöntem çağrısı refanahtar kelimeyi kullanmalıdır .

using System;

namespace PassingByReference
{
    class Program
    {
        static int a = 4;
        static int b = 7;

        static void Main(string[] args)
        {
            Console.WriteLine("Outside Swap method");
            Console.WriteLine("a is {0}", a);
            Console.WriteLine("b is {0}", b);

            Swap(ref a, ref b);

            Console.WriteLine("Outside Swap method");
            Console.WriteLine("a is {0}", a);
            Console.WriteLine("b is {0}", b);
        }

        static void Swap(ref int a, ref int b)
        {
            int temp = a;
            a = b;
            b = temp;
            
            Console.WriteLine("Inside Swap method");
            Console.WriteLine("a is {0}", a);
            Console.WriteLine("b is {0}", b);
        }
    }
}

Bu örnekte, Swap () yönteminin çağrılması orijinal değerleri değiştirecektir.

Takas (ref a, ref b);

Yöntemi iki argümanla çağırıyoruz. Bağımsız refdeğişkenleri başvuruya göre geçirdiğimizi belirtmek için önlerinde anahtar kelime bulunur.

statik void Swap (ref int a, ref int b) 
{ 
... 
}

Ayrıca yöntem bildiriminde, refderleyiciye değerlere değil parametrelere referansları kabul ettiğimizi bildirmek için anahtar sözcüğü kullanırız .

$ dotnet run 
Outside Swap yöntemi 
a 4'tür 
b 7 
Inside Swap metodu 
a 7 
b 4 
Outside Swap metodu 
a 7 
b 4'tür

Burada Swap()yöntemin değişkenlerin değerlerini gerçekten değiştirdiğini görüyoruz .

outAnahtar kelime benzer refanahtar kelime. Aradaki fark, refanahtar kelimeyi kullanırken değişkenin geçmeden önce başlatılması gerektiğidir. İle outanahtar kelime, bu başlatılmamış olabilir. Hem yöntem tanımı hem de yöntem çağrısı outanahtar kelimeyi kullanmalıdır .

using System;

namespace OutKeyword
{
    class Program
    {
        static void Main(string[] args)
        {
            int val;
            SetValue(out val);

            Console.WriteLine(val);
        }

        static void SetValue(out int i)
        {
            i = 12;
        }        
    }
}

Bir örnek, outanahtar kelimenin kullanımını göstermektedir .

int val; 
SetValue (çıkış değeri);

Val değişkeni bildirildi, ancak başlatılmadı. Değişkeni SetValue()yönteme aktarıyoruz.

statik boşluk SetValue (out int i) 
{ 
    i = 12; 
}

İçinde SetValue()yöntemin daha sonra konsola basılmış bir değer atanır.

C # yöntemi aşırı yükleme

Yöntem aşırı yükleme , girdi türünde birbirinden farklı olan aynı adla birkaç yöntemin oluşturulmasına izin verir.

Yöntem aşırı yüklemesi ne işe yarar? Qt5 kütüphanesi, kullanım için güzel bir örnek verir. QPainterSınıf bir dikdörtgen çizmek için üç yöntem vardır. İsimleri drawRect()ve parametreleri farklıdır. Biri kayan noktalı dikdörtgen bir nesneye referans alır, diğeri tamsayı dikdörtgen nesneye referans alır ve sonuncusu dört parametre alır: x, y, genişlik, yükseklik. Qt geliştirilen edildiği dildir C ++ dili, yöntem aşırı yüklenmesini olmasaydı, kütüphanenin yaratıcıları gibi yöntemler isim olurdu drawRectRectF()drawRectRect()drawRectXYWH(). Yöntem aşırı yüklemeli çözüm daha zariftir.

using System;

namespace Overloading
{
    class Sum
    {
        public int GetSum()
        {
            return 0;
        }

        public int GetSum(int x)
        {
            return x;
        }

        public int GetSum(int x, int y)
        {
            return x + y;
        }
    }

    class Program
    {
        static void Main()
        {
            var s = new Sum();

            Console.WriteLine(s.GetSum());
            Console.WriteLine(s.GetSum(20));
            Console.WriteLine(s.GetSum(20, 30));
        }
    }
}

Adında üç yöntemimiz var GetSum(). Giriş parametrelerinde farklılık gösterirler.

public int GetSum (int x) 
{ 
    dönüş x; 
}

Bu bir parametre alır.

Console.WriteLine (s.GetSum ()); 
Console.WriteLine (s.GetSum (20)); 
Console.WriteLine (s.GetSum (20, 30));

Her üç yöntemi de diyoruz.

$ dotnet çalıştırma 
0 
20 
50

Ve bu, örneği çalıştırdığımızda elde ettiğimiz şeydir.

C # özyineleme

Matematik ve bilgisayar bilimlerinde özyineleme, tanımlanmakta olan yöntemin kendi tanımı içinde uygulandığı yöntemleri tanımlamanın bir yoludur. Başka bir deyişle, özyinelemeli bir yöntem kendisini işini yapmaya çağırır. Özyineleme, birçok programlama görevini çözmek için yaygın olarak kullanılan bir yaklaşımdır.

Tipik bir örnek, faktöryel hesaplamadır.

using System;

namespace Recursion
{
    class Program
    {
        static void Main(string[] args)
        {        
            Console.WriteLine(Factorial(6));
            Console.WriteLine(Factorial(10));
        }

        static int Factorial(int n)
        {
            if (n == 0)
            {
                return 1;
            } else
            {
                return n * Factorial(n-1);
            }
        }
    }
}

Bu kod örneğinde, iki sayının faktöriyelini hesaplıyoruz.

dönüş n * Faktörel (n-1);

Faktöriyel yöntemin gövdesinin içinde, değiştirilmiş bir argümanla faktöriyel yöntemi çağırıyoruz. İşlev kendisini çağırır.

$ dotnet run 
720 
3628800

Sonuçlar bunlar.

C # yöntem kapsamı

Bir yöntemin içinde bildirilen bir değişkenin bir yöntem kapsamı vardır. Kapsam bir isim o ismin yeterlilik olmadan adıyla ilan kişiye atfen mümkün olacağı programın metin bölgesidir. Bir yöntemin içinde bildirilen bir değişkenin bir yöntem kapsamı vardır. Yerel kapsam olarak da adlandırılır. Değişken yalnızca bu belirli yöntemde geçerlidir.

using System;

namespace MethodScope
{
    class Test
    {
        int x = 1;

        public void exec1()
        {
            Console.WriteLine(this.x);
            Console.WriteLine(x);
        }

        public void exec2()
        {
            int z = 5;

            Console.WriteLine(x);
            Console.WriteLine(z);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var ts = new Test();
            ts.exec1();
            ts.exec2();
        }
    }
}

Önceki örnekte, ve yöntemlerinin xdışında tanımlanmış değişkenimiz var . Değişkenin bir sınıf kapsamı vardır. Sınıf tanımının her yerinde geçerlidir , örneğin küme parantezleri arasında. exec1()exec2()Test

public void exec1 () 
{         
    Console.WriteLine (this.x); 
    Console.WriteLine (x); 
}

X alanı olarak da adlandırılan x değişkeni bir örnek değişkendir. Ve böylece thisanahtar kelime aracılığıyla erişilebilir . exec1()Yöntem içinde de geçerlidir ve çıplak adıyla anılabilir. Her iki ifade de aynı değişkeni ifade eder.

public void exec2 () 
{         
    int z = 5; 
    
    Console.WriteLine (x); 
    Console.WriteLine (z); 
}   

X değişkenine exec2()yöntemde de erişilebilir . zDeğişken tanımlanan exec2()yöntem. Yöntem kapsamına sahiptir. Sadece bu yöntemde geçerlidir.

$ dotnet çalıştırma 
1 
1 
1 
5

Bu, programın çıktısıdır.

Bir yöntemin içinde tanımlanan bir değişkenin yerel / yöntem kapsamı vardır. Yerel bir değişken, bir örnek değişkenle aynı ada sahipse, örnek değişkenini gölgeler . Sınıf değişkenine, this anahtar kelime kullanılarak yöntem içinde hala erişilebilir .

using System;

namespace Shadowing
{
    class Test
    {
        int x = 1;

        public void exec()
        {
            int x = 3;

            Console.WriteLine(this.x);
            Console.WriteLine(x);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var ts = new Test();
            ts.exec();
        }
    }
}

Yukarıdaki örnekte, xdeğişkeni exec()yöntemin dışında ve yöntemin içinde exec() bildiriyoruz. Her iki değişken de aynı ada sahiptir, ancak farklı kapsamlarda yaşadıkları için birbirleriyle çelişmezler.

Console.WriteLine (this.x); 
Console.WriteLine (x);

Değişkenlere farklı şekilde erişilir. xYerel değişken denilen yöntem içinde tanımlanan değişken, sadece adıyla erişilir. Örnek değişkeni, thisanahtar sözcük kullanılarak belirtilebilir .

$ dotnet run 
1 
3

Bu, programın çıktısıdır.

C # statik yöntemler

Statik yöntemler, nesnenin bir örneği olmadan çağrılır. Statik bir yöntemi çağırmak için sınıfın adını ve nokta operatörünü kullanırız. Statik yöntemler yalnızca statik üye değişkenlerle çalışabilir. Statik yöntemler genellikle nesne durumuna yanıt olarak değişmeyen verileri veya hesaplamaları temsil etmek için kullanılır. Bir örnek, çeşitli hesaplamalar için statik yöntemler içeren bir matematik kitaplığıdır. staticAnahtar kelimeyi statik bir yöntem bildirmek için kullanırız . Statik değiştirici olmadığında, yöntemin bir örnek yöntem olduğu söylenir. thisAnahtar kelimeyi statik yöntemlerde kullanamayız . Yalnızca örnek yöntemlerinde kullanılabilir.

Main()Yöntem C # konsol ve GUI uygulaması için bir giriş noktasıdır. C # ‘da Main()yöntemin statik olması gerekir. Uygulama başlamadan önce henüz bir nesne oluşturulmaz. Statik olmayan yöntemleri çağırmak için bir nesne örneğine ihtiyacımız var. Statik yöntemler, bir sınıfın somutlaştırılmasından önce mevcuttur, bu nedenle statik, ana giriş noktasına uygulanır.

using System;

namespace StaticMethod
{
    class Basic
    {
        static int Id = 2321;

        public static void ShowInfo()
        {
            Console.WriteLine("This is Basic class");
            Console.WriteLine("The Id is: {0}", Id);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Basic.ShowInfo();
        }
    }
}

Kod örneğimizde statik bir ShowInfo()yöntem tanımlıyoruz .

statik int Id = 2321;

Statik bir yöntem yalnızca statik değişkenlerle çalışabilir.

public static void ShowInfo () 
{ 
    Console.WriteLine ("Bu Temel sınıftır"); 
    Console.WriteLine ("Kimlik: {0}", Kimlik); 
}

Bu bizim statik ShowInfo()yöntemimizdir. Statik bir Id üyesi ile çalışır.

Basic.ShowInfo ();

Statik bir yöntemi çağırmak için bir nesne örneğine ihtiyacımız yoktur. Sınıfın adını ve nokta operatörünü kullanarak yöntemi çağırıyoruz.

$ dotnet run 
Bu Temel sınıftır 
Kimlik: 2321

Bu, örneğin çıktısıdır.

C # gizleme yöntemleri

Türetilmiş bir sınıf bir temel sınıftan miras aldığında, temel sınıfta zaten mevcut olan yöntemleri tanımlayabilir. Elde ettiğimiz sınıfın yöntemini sakladığımızı söylüyoruz . Derleyiciyi bir yöntemi gizleme niyetimiz hakkında açıkça bilgilendirmek için newanahtar kelimeyi kullanırız . Bu anahtar kelime olmadan derleyici bir uyarı verir.

using System;

namespace HidingMethods
{
    class Base
    {
        public void Info()
        {
            Console.WriteLine("This is Base class");
        }
    }

    class Derived : Base
    {
        public new void Info()
        {
            base.Info();
            Console.WriteLine("This is Derived class");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var d = new Derived();
            d.Info();
        }
    }
}

İki sınıfımız var: Derivedve Basesınıf. DerivedSınıf devralır Basesınıfında. Her ikisinin de adlı bir yöntemi var Info().

Sınıf Türetilmiş: Temel 
{ 
... 
}

(:) karakteri bir sınıftan miras almak için kullanılır.

genel yeni boşluk Bilgisi () 
{     
    base.Info (); 
    Console.WriteLine ("Bu, Türetilmiş sınıftır"); 
}

Bu, sınıftaki Info()yöntemin bir uygulamasıdır DerivednewTemel sınıftan bir metodu sakladığımızı derleyiciye bildirmek için anahtar kelimeyi kullanırız . Yine de orijinal Info()yönteme ulaşabileceğimizi unutmayın . baseAnahtar kelime yardımıyla Info() , Basesınıfın yöntemini de çağırıyoruz .

$ dotnet run 
Bu, Temel sınıf 
Bu, Türetilmiş sınıftır

Her iki yöntemi de çağırdık.

C # geçersiz kılma yöntemleri

Şimdi iki yeni anahtar kelime tanıtacağız: virtual anahtar kelime ve overrideanahtar kelime. Her ikisi de yöntem değiştiricileridir. Nesnelerin polimorfik davranışını uygulamak için kullanılırlar. virtualAnahtar kelime sanal bir yöntem oluşturur. Sanal yöntemler türetilmiş sınıflarda yeniden tanımlanabilir. Türetilmiş sınıfta daha sonra söz konusu overrideyöntemi yeniden tanımlamak için anahtar kelimeyi kullanırız. Türetilmiş sınıftaki yöntemin önünde override anahtar sözcük varsa, türetilmiş sınıfın nesneleri, temel sınıf yöntemi yerine bu yöntemi çağırır.

using System;

namespace Overriding
{
    class Base
    {
        public virtual void Info()
        {
            Console.WriteLine("This is Base class");
        }
    }

    class Derived : Base
    {
        public override void Info()
        {
            Console.WriteLine("This is Derived class");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Base[] objs = { new Base(), new Derived(), new Base(),
                        new Base(), new Base(), new Derived() };

            foreach (Base obj in objs)
            {
                obj.Info();
            }
        }
    }
}

BaseVe Derived nesnelerinden oluşan bir dizi oluşturuyoruz . Diziyi gözden geçiririz ve Info() hepsine yöntemi çağırırız .

public virtual void Info () 
{ 
    Console.WriteLine ("Bu Base sınıfıdır"); 
}

Bu, Basesınıfın sanal yöntemidir . Türetilmiş sınıflarda geçersiz kılınması beklenmektedir.

genel geçersiz kılma void Info () 
{ 
    Console.WriteLine ("Bu Türetilmiş sınıftır"); 
}

Sınıftaki temel Info()yöntemi geçersiz kılıyoruz Derived. Biz kullanmak overrideanahtar kelimeyi.

Base [] objs = {new Base (), new Derived (), new Base (), 
                new Base (), new Base (), new Derived ()};

Burada bir dizi Baseve Derived nesne oluşturuyoruz. BaseDizi bildirimimizde türü kullandığımıza dikkat edin. Bunun nedeni, bir Derivedsınıfın Base ondan miras aldığı için sınıfa dönüştürülebilmesidir . Bunun tersi doğru değil. Bir dizide her iki nesneye sahip olmanın tek yolu, tüm olası nesneler için miras hiyerarşisinde en üstte olan bir türü kullanmaktır.

foreach (nesnelerdeki temel nesneler) 
{ 
    nesn.Info (); 
}

Diziyi dolaşırız ve dizideki Info()tüm nesneleri çağırırız .

$ dotnet run 
Bu, Temel sınıf 
Bu, Türetilmiş sınıf 
Bu, Temel sınıf 
Bu, Temel sınıf 
Bu, Temel sınıf 
Bu, Türetilmiş sınıftır

Bu çıktıdır.

Şimdi overrideanahtar kelime için newanahtar kelimeyi değiştirin . Örneği tekrar derleyin ve çalıştırın.

$ dotnet run 
Bu Base sınıfı 
Bu Base sınıfı 
Bu Base sınıfı 
Bu Base sınıfı 
Bu Base sınıfı 
Bu Base sınıfıdır

Bu sefer farklı bir çıktımız var.

C # yerel işlevler

C # 7.0 yerel işlevleri tanıttı. Bunlar, diğer yöntemlerin içinde tanımlanan işlevlerdir.

using System;

namespace LocalFunction
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("Enter your name: ");

            string name = Console.ReadLine();
            string message = BuildMessage(name);

            Console.WriteLine(message);


            string BuildMessage(string value)
            {

                string msg = String.Format("Hello {0}!", value);

                return msg;
            }
        }
    }
}

Örnekte, yöntemin BuildMessage()içinde tanımlanan ve çağrılan yerel bir fonksiyonumuz var Main().

C # mühürlü yöntemler

Mühürlü bir yöntem, aynı imzaya sahip miras alınan bir sanal yöntemi geçersiz kılar. Kapalı bir yöntem ayrıca geçersiz kılma değiştiricisi ile işaretlenecektir. Kullanılması sealedyöntemini geçersiz kılmasını, ayrıca şunlar arasından modifiye önler türetilmiş bir sınıfı. Daha ileri kelime önemlidir. İlk olarak, bir yöntem sanal olmalıdır. Daha sonra geçersiz kılınmalıdır. Ve bu noktada mühürlenebilir.

using System;

namespace SealedMethods
{
    class A
    {
        public virtual void F()
        {
            Console.WriteLine("A.F");
        }

        public virtual void G()
        {
            Console.WriteLine("A.G");
        }
    }

    class B : A
    {
        public override void F()
        {
            Console.WriteLine("B.F");
        }

        public sealed override void G()
        {
            Console.WriteLine("B.G");
        }
    }

    class C : B
    {
        public override void F()
        {
            Console.WriteLine("C.F");
        }

        /*public override void G()
        {
            Console.WriteLine("C.G");
        }*/
    }

    class SealedMethods
    {
        static void Main(string[] args)
        {
            B b = new B();
            b.F();
            b.G();

            C c = new C();
            c.F();
            c.G();
        }
    }
}

Önceki örnekte, yöntemi G()B sınıfında mühürledik .

genel mühürlenmiş geçersiz kılma void G () 
{ 
    Console.WriteLine ("BG"); 
}

Yöntem G()Bsınıfın atasında aynı ada sahip bir yöntemi geçersiz kılar . Yöntemin daha fazla geçersiz kılınmasını önlemek için de mühürlenmiştir.

/ * genel geçersiz kılma void G () 
{ 
    Console.WriteLine ("CG"); 
} * /

Bu satırlar yorumlanmıştır çünkü aksi takdirde kod örneği derlenmeyecektir. Derleyici aşağıdaki hatayı verir: Program.cs (38,30): CS0239 hatası: ‘CG ()’: devralınan üye ‘BG ()’ mühürlendiğinden geçersiz kılınamaz

cG ();

Bu satır konsola “BG ()” yazdırır.

$ dotnet run 
BF 
BG 
CF 
BG

Bu çıktıdır.

Yöntemler için C # ifade gövde tanımları

Yöntemler için ifade gövdesi tanımları, bir yöntem uygulamasını çok kısa ve okunabilir bir biçimde tanımlamamıza izin verir.

yöntem bildirimi => ifade

Bu genel sözdizimidir.

using System;

namespace ExpBodyDef 
{
    class User 
    {
        public string Name { get; set; }
        public string Occupation { get; set; }

        public override string ToString() => $"{Name} is a {Occupation}";
    }

    class Program 
    {
        static void Main (string[] args) 
        {
            var user = new User();
            user.Name = "John Doe";
            user.Occupation = "gardener";

            Console.WriteLine(user);
        }
    }
}

Örnekte, ToString()yöntemin gövdesine bir ifade gövdesi tanımı sağlıyoruz.

genel geçersiz kılma dizesi ToString () => $ "{Ad} bir {Meslek}";

İfade gövdesi tanımı, sözdizimini basitleştirir.

C # eğitiminin bu bölümünde, yöntemleri ele aldık.

Have your say!

0 0

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>

Lost Password

Please enter your username or email address. You will receive a link to create a new password via email.

Kıbrıs Web Yazılım