Formları kullanarak uygulama geliştirme metodolojisi. GUI Uygulamaları Oluşturma c'de GUI uygulamaları nasıl yazılır

İyi günler! Bu eğitimde, MS Visual Studio'da ilk GUI uygulamanızı oluşturacağız. Grafik uygulamalar için bir nevi "Merhaba Dünya" olacak. Windows Forms kullanmanın C# programcıları için grafik uygulamalar (grafiksel kullanıcı arayüzüne sahip uygulamalar) oluşturmanın tek yolu olmadığını hemen söyleyeceğim, ancak bundan öğrenmeye başlamak daha iyidir. Ve böylece Visual Studio'yu başlatıyoruz.

Başlatıldı mı? Sonra iş için! Ana menüye gidiyoruz ve aşağıdaki şekilde gösterildiği gibi "Dosya - Yeni - Proje" öğesini seçiyoruz.

Görünen pencerede:

sol tarafta "Şablonlar - Visual C # - Windows" öğesini seçin;
ana alanda "Windows Forms Uygulaması" öğesini seçin;
pencerenin alt kısmında projenin adını girin ve diskteki yerini belirtin.

Genel olarak, aşağıdaki şekilde gösterildiği gibi.

Neye ihtiyacınız olduğunu belirttiniz mi? Ardından "Tamam" düğmesine tıklayın. Şimdi şöyle bir şey görmelisiniz (ana alanlar dikdörtgenlerle vurgulanmıştır):

Yukarıdaki resimde ana alanları etiketledim: tasarımcı alanı (sol üst), çözüm gezgini alanı (sağ üst) ve özellikler alanı (sağ alt). Bunlar en sık çalışacağımız alanlar.

Tasarımcı alanında artık boş bir “form” var, bu sözde pencere, bu durumda programımızın ana penceresi. Özellikler alanı, tasarımcıda seçilen öğenin, bu durumda formumuzun özelliklerini görüntüler, ancak çözüm gezgini alanı, programın formları (pencereleri) ile ilgili olanlar da dahil olmak üzere proje dosyalarını içerir. Şimdi formumuzu biraz değiştirelim ve bu ilk uygulamayı çalıştıralım.

Bunu yapmak için, tasarımcıdaki formu seçin (bunun için forma sol tıklamanız yeterlidir) ve "Metin" satırını bulduğumuz özellikler bloğuna gidin (kelime metindir, aradığımız kelimedir). sol sütunda), aşağıdaki şekilde gösterildiği gibi.

Uygulamanın ana formunun "Metin" özelliği

Lütfen sol sütunun adı (mülk adı) gösterdiğini ve sağ sütunun değerini gösterdiğini unutmayın.

Bu durumda, bir text özelliği ile ilgileniyoruz ve değeri pencere başlığında gösteriliyor, bu yüzden şimdi oraya kendimizden bir şey koyalım, örneğin, aşağıdaki şekilde gösterildiği gibi "Ana pencere" gibi:

Artık projeyi oluşturabilir ve çalıştırabilirsiniz. Bunu yapmak için ana menüye gidin ve "Yap - Çözüm Oluştur" seçeneğini seçin. Ardından uygulamayı başlatıyoruz, bunun için ana menüde "Hata Ayıkla - Hata Ayıklamadan Çalıştır" öğesini seçiyoruz. Sonuç olarak, aşağıdaki pencereyi görmelisiniz.

Bir sonraki derste, form tasarımcısı ile basit çalışmalara ve GUI öğelerinin kurulumuna bakacağız ve bu ders sona erdi, ilk grafik uygulamasını oluşturduk, kurduk ve başlattık.

C++, en güçlü ve talep gören programlama dillerinden biridir. Üzerine her gün, genellikle bir GUI kullanılarak yüzlerce uygulama yazılır. Bununla birlikte, bir programcı için grafiklerle çalışmak her zaman uygun değildir - bu durumda hazır grafik kitaplıkları kullanılır. Uygulamaların grafik bölümünün geliştirilmesini olabildiğince hızlı ve kolay hale getirecekler.

SFML

Qt

Platformlar arası kitaplık Cocos2D-X, mobil oyunların geliştirilmesini basitleştirmek için tasarlanmıştır. Qt ile aynı platformları destekler. Avantajlar arasında, kullanılabilirliği, kullanım kolaylığı ve Cocos Creator kütüphanesine dayalı ayrı bir oyun tasarımcısının oluşturulmasına dikkat etmek önemlidir. Motora dayalı oyunların listesi, mevcut tüm platformlarda çalışan dünyaca ünlü BADLAND'ı içerir.

Başka bir şey

Bir oyun oluştururken büyük hacimlerde grafik ve animasyonla çalışmanız gerekiyorsa, Cocos2D-X yerine Unity kullanmak daha iyidir. Unity, Photoshop, Maya veya Blender gibi araçlarla sorunsuz bir şekilde entegre olma yeteneğine sahiptir. Cocos2D-X'te tüm grafikler harici olarak eklenir ve koddan referans alınır.

Runet'te bu kütüphanede ders yok, ancak geliştiricilerden mükemmel bir İngilizce kursu var.

meyve suyu

Belki de en ünlü grafik kitaplıklarından biri. GTK+, birçok sistemde yaygın olarak kullanılan bir grafik çerçevesidir. Başlangıçta GIMP'nin bir bileşeni olarak tasarlandı, ancak ilk kararlı sürümün yayınlanmasından sonraki 20 yıl içinde yüzlerce başka uygulamada kullanım buldu.

Şimdi GTK +, aynı QT'den daha düşük olmayan tam teşekküllü bir grafik çerçevedir. Farklı programlama dillerini destekler ve gelişmeye devam eder.

Başka bir şey

Bir zamanlar, kitaplık, ödenen Qt'ye alternatif olarak oluşturuldu. GTK+, C dilini destekleyen birkaç çerçeveden biridir.Kütüphane çapraz platformdur, ancak Linux'taki programların Windows veya Mac'ten daha yerel göründüğüne dair bir görüş vardır (GTK+, KDE'de bile iyi desteklenir). İlginç bir şekilde, bazı çapraz platform sorunları nedeniyle Wireshark Qt'ye geçti.

İlk programın bir örneği Wikipedia'da görülebilir.

C++ ile ilgili diğer ilginç makaleler burada bulunabilir.

Çözüm

Yukarıda, yalnızca C++'da değil, bazen diğer dillerde (örneğin, Qt ve GTK+) GUI'lerle çalışmak için en popüler teknolojiler bulunmaktadır. Ancak, her zaman belirli bir teknolojinin özelliklerini dikkate almalısınız. Uygulamanızın özelliklerinin bir listesini yazın, tüm kitaplıkların ve çerçevelerin açıklamalarını tekrar okuyun ve ancak bundan sonra projeye gerçekten en uygun olanı seçin.

Son güncelleme: 05/26/2019

Xamarin.Forms'da görsel arayüz sayfalardan oluşur. Sayfa, Page sınıfının bir nesnesidir, tüm ekran alanını kaplar. Yani bir mobil cihazın ekranında gördüğümüz şey bir sayfadır. Bir uygulamanın bir veya daha fazla sayfası olabilir.

Sayfa, sırayla düğmeler ve metin alanları gibi standart görsel öğelerin yanı sıra diğer düzen öğelerini içeren düzen kaplarından birini içerik olarak kabul eder.

Bir önceki konuda oluşturulan HelloApp projesini ele alalım (veya yeni bir tane oluştur). Varsayılan olarak, arabirimin tamamı App.xaml.cs dosyasında bulunan ve geçerli uygulamayı temsil eden App sınıfında oluşturulur:

Varsayılan kodu:

Sistemi Kullanmak; Xamarin.Forms kullanarak; Xamarin.Forms.Xaml kullanarak; ad alanı HelloApp ( genel kısmi sınıf Uygulama: Uygulama ( genel Uygulama() ( InitializeComponent(); MainPage = new MainPage(); ) korumalı geçersiz kılma void OnStart() ( // Uygulamanız başladığında işleyin ) korumalı geçersiz kılma void OnSleep() ( / / Uygulamanız uyuduğunda işleyin ) korumalı geçersiz kılma void OnResume() ( // Uygulamanız devam ettiğinde işleyin ) )

App sınıfı, ilk olarak nesneyi başlatan InitializeComponent() yönteminin çağrıldığı ve ardından MainPage özelliğinin ayarlandığı yapıcı ile başlar. Bu özellik aracılığıyla, App sınıfı, uygulamanın ana sayfasını ayarlar. Bu durumda MainPage.xaml ve MainPage.xaml.cs dosyalarında tanımlanan sınıf olan HelloApp.MainPage sınıfı tarafından tanımlanır.

Ancak bu yol tek yol değildir. Xamarin.Forms, C# kodunu kullanarak veya html'ye benzer xaml dilini veya bu yaklaşımların bir kombinasyonunu kullanarak bildirimsel olarak görsel bir arabirim oluşturmanıza olanak tanır.

C# kodundan arayüz oluşturma

HelloApp projesine StartPage adını vereceğimiz normal bir C# sınıfı ekleyelim.

Ve bu sınıfta aşağıdaki içeriği tanımlayın:

Xamarin.Forms'u Kullanmak; ad alanı HelloApp ( class StartPage: ContentPage ( public StartPage() ( Label başlığı = new Label() ( Metin = "Xamarin Forms'dan Merhaba" ); this.Content = başlık; ) )

Bu sınıf bir sayfayı temsil eder, bu nedenle ContentPage sınıfından miras alır. Yapıcı, sayfanın içeriği olarak ayarlanan metinli bir etiket oluşturur (this.Content = başlık).

MainPage'i başlangıç sayfası olarak belirlemek için App sınıfını değiştirelim:

Xamarin.Forms'u Kullanmak; ad alanı HelloApp ( genel kısmi sınıf Uygulama: Uygulama ( genel Uygulama() ( InitializeComponent(); MainPage = new StartPage(); ) korumalı geçersiz kılma void OnStart() ( // Uygulamanız başladığında işleyin ) korumalı geçersiz kılma void OnSleep() ( / / Uygulamanız uyuduğunda işleyin ) korumalı geçersiz kılma void OnResume() ( // Uygulamanız devam ettiğinde işleyin ) )

MainPage özelliği artık yeni oluşturulan StartPage'i işaret ediyor.

Ayrıca Visual Studio'nun en basit kodla yeni sayfa sınıfları eklemek için hazır bir şablonu olduğunu da belirtmekte fayda var. Bu nedenle, yeni bir sayfa eklemek için, yeni bir öğe eklerken İçerik Sayfası (C#) şablonunu seçmeniz gerekir:

Bu sınıf, çözümün ana projesine eklenir (bu durumda HelloApp'tir).

Eklenen sayfa sınıfı aşağıdaki koda sahip olacaktır:

Sistemi Kullanmak; System.Collections.Generic kullanarak; System.Linq kullanarak; System.Reflection.Emit kullanarak; System.Text'i kullanarak; Xamarin.Forms kullanarak; ad alanı HelloApp ( genel sınıf Sayfa1: ContentPage ( genel Sayfa1() ( İçerik = yeni StackLayout ( Çocuklar = ( yeni Etiket ( Metin = "Merhaba Sayfa") ) ) ) )

Bu sınıf ayrıca temel ContentPage sınıfından miras alacak ve yukarıda oluşturulan MainPage sınıfıyla hemen hemen aynı organizasyona sahip olacaktır.

Ayrıca uygulama sınıfında bu sayfayı başlangıç sayfası olarak ayarlayabiliriz:

Xamarin.Forms'u Kullanmak; ad alanı HelloApp ( genel kısmi sınıf Uygulama: Uygulama ( genel Uygulama() ( InitializeComponent(); MainPage = yeni Sayfa1(); ) //........... ) )

En sevdiğim dilin C++ olduğuna dair hemen bir rezervasyon yapacağım, pratik olarak “çocukluğumdan beri” yazıyorum ve yazmak için en iyi dillerden biri olarak önemini inkar etmeyeceğim. herhangi bir amaç için programlar. Ayrıca, başka bir holivar başlatmak veya "işaretçileri" ölçmek için hiçbir neden göremiyorum. Bu makale, dille ilgili kötü bir deneyimin sadece bir açıklamasıdır ve bilgisi gelecekte diğer programcılara yardımcı olacak bazı yönlerini açıklar.

Bir gün gelişmekte olan bir GUI sınıf kitaplığına rastladım. C++ ve daha spesifik olarak sınıfları, örnekleri ve hiyerarşileri açısından bu dil, özellikle widget'lar, sınıf pencereleri ve alt pencereler gibi öğeler olmak üzere GUI denetimi kavramına inanılmaz derecede yakın görünüyor. Bununla birlikte, C++ ve pencere sisteminin OO modelleri farklıdır. C++, belirteç kapsamı, statik tür denetimi ve derleme zamanı tanımlı hiyerarşileri olan "statik" bir dil olarak tasarlanmıştır. Pencereler ve nesneleri ise doğaları gereği dinamiktir, genellikle yaratıldıkları tek prosedürün veya bloğun dışında yaşarlar; Widget hiyerarşileri büyük ölçüde düzen, görünürlük ve olay akışları tarafından tanımlanır. Dinamik ve geometrik pencere ve kontrol hiyerarşileri ve olay akışı gibi grafik kullanıcı arabiriminin temelleri, C++ sözdizimi veya semantiği tarafından doğrudan desteklenmez. Bu nedenle, bu işlevler C++ GUI kodunda çoğaltılmalıdır. Bu, grafik araç takımının veya pencere yöneticisi işlevselliğinin çoğaltılmasına yol açar, kod "şişirilir", C++'ın birçok "güçlü" özelliğini terk etmek zorunda kalırız (örneğin, derleme zamanında tip denetimi). Makale, C++/GUI "uyumsuzluklarına" ilişkin bazı basit örnekler sunmaktadır.

Yapıcılar oluşturmayın (veya en azından bunları kullanmayın)

Ortaya çıkan sınıf, üst sınıfın bir sanal yöntemini geçersiz kıldığında, temel sınıf oluşturucu yürütülürken geçersiz kılmanın etkili olmadığını unutmayın. Bu, özellikle nesneler GUI olaylarına yanıt veren widget'lar istediğinde can sıkıcıdır. sınıf varsayalım Temel_Pencere ekranda siyah beyaz bir vanilya penceresi oluşturmayı amaçlıyordu:

ClassBasic_Window(
halka açık:
Basic_Window(Rect rect) ( gt_create_window(rect,visible,this); )
sanal boşluk handle_create_event() ( set_background(WHITE); )
};

Burada gt_create_window() ana grafik araç setinin düşük seviyeli çağrısından sorumludur (örneğin, xvt_win_create()). Bu işlev, enstrümantasyon verileri için yer ayırır, pencere yöneticisine bildirir, o nesneyi bir olay dinleyicisi olarak kaydeder ve yukarıdaki örnekte, ekrandaki pencereye grafik çıktısını başlatır.
Diyelim ki somutlaştırmak istiyoruz Temel_Pencere, ancak kırmızı bir arka plana sahip. Genellikle, bir sınıfın davranışını değiştirmek için ondan çıkarmanız ve karşılık gelen sanal yöntemleri geçersiz kılmanız gerekir. Yazıyoruz:

Sınıf RedWindow: public Basic_Window(
sanal boşluk handle_create_event() ( set_background(RED); )
halka açık:
RedWindow(Rect rect) : Basic_Window(Rect rect) ()
};
redWindow red_window(default_rect);

Fakat red_window kırmızı değil beyaz görünecek! Yaratmak KırmızıPencere, önce ana nesne oluşturulmalıdır. Bitirdikten sonra Basic_Window::Basic_Window(), sanal tablolar KırmızıPencere etkili olmak, yöntem handle_create_event() geçersiz olur ve yapıcı KırmızıPencere() gerçekleştirildi. yapıcı Temel_Pencere() nesneye olay göndermeye hemen başlayan bir grafik aracı nesnesini kaydeder (örneğin, bir CREATE olayı). yapıcı Temel_Pencere() henüz bitmedi (garanti edilmez), bu nedenle geçersiz kılınan sanal yöntem henüz yerinde değil. Böylece CREATE olayı işlenecek Basic_Window::handle_create_event(). Sanal Tablolar KırmızıPencere sınıflar yalnızca temel sınıf tamamen oluşturulduğunda, yani pencere zaten ekranda olduğunda oluşturulacaktır. Bu aşamada pencerenin rengini değiştirmek can sıkıcı bir hataya yol açacaktır.

Basit bir geçici çözüm vardır: Her oluşturucunun bir GUI araç seti nesnesini kaydetmesini önleyin. Olay işleme, türetilmiş sınıflara başlatmanın sonunu geri tutacak şekilde yapılandırılacaktır. Ekrandaki widget'ları, bir uygulamanın bellekteki GUI nesnesinin "yüzü" olarak düşünmek çok cezbedicidir. Yukarıdaki örneğin gösterdiği gibi, ekran ve C++ nesnesi arasındaki bu bağlantının uygulanması o kadar kolay değildir: ayrı olarak doğarlar.

Olayları değiştirmenin sözdizimsel yolu yok

Sınıf kitaplığının bir sınıf GUI'si içerdiğini varsayalım PictPencere hangi bir pencerede bir fotoğraf görüntüler:

Sınıf PictWindow(
resim resmi;
halka açık:
sanal boşluk yeniden boyama() ( gt_draw_pict(resim); )
...
};

Görüntünün belirli bir alanına küçük bir dikdörtgen yerleştirmek istiyoruz. Bu amaçla, alt sınıfları deneyebiliriz PictPencere:

doğrult;
sanal boşluk yeniden boyama() ( gt_draw_rect(rect); )
};

Ne yazık ki, somutlaştırdığımızda OvWindow, boş bir pencerede sadece bir dikdörtgen göreceğiz ve görüntü yok. olduğu andan itibaren OvWindow::repaint() yeniden tanımlar PictWindow::repaint(), pencere çizilmek üzereyken son fonksiyon çağrılmayacaktır. uygulamak zorunda kaldık OvWindow Böyle:

Sınıf OvWindow: genel PictWindow(
doğrult;
sanal boşluk yeniden boyama() ( PictWindow::repaint(); gt_draw_rect(rect); )
halka açık:
OvWindow(void): PictWindow()()
};

yapıcı OvWindow yöntemi olduğunu vurgulamak için yola çıktı. OvWindow::repaint() yapıcıların yaptığı gibi üst sınıfa ertelenmelidir. Gerçekten de, türetilmiş nesnenin yapıcısı, karşılık gelen nesnenin yapıcısını baştan çağırır. repaint(), onu geçersiz kılan temel sınıftaki parent: yöntemine ertelenmelidir.

Alt satır: Zayıf C++ / GUI uyumluluğu

C++ "statik" bir dil olarak tasarlanmıştır:

belirteç takibi ile
statik tip kontrolü
statik sınıf hiyerarşileri ile
çöp toplama yok
tanımlı derleme zamanı hiyerarşileri olmayan bir mesaj sistemi ile

GUI nesneleri:

dinamik nesnelerle karakterize edilir ve genellikle kendi türlerinde tek olanlardır.
yaratıldıkları sınırların çok ötesinde yaşama eğilimindedirler.
hiyerarşiler, büyük ölçüde, sınıf mirasına göre değil, olayların akışına ve konumlarına göre belirlenir.
hiyerarşiler, genellikle öngörülemeyen kullanıcı eylemlerine yanıt olarak çalışma zamanında oluşturulur ve yok edilir

C++, mesajlaşma ve aktarımlar için dinamik güvenliği desteklemek üzere tasarlanmamıştır (istisnalar dışında). Tüm bunlar, grafiksel araçların ve pencere yöneticisi işlevselliğinin tekrarlanmasına, kod yayılmasına, güvenli olmayan işlevlerin kullanılmasına ve C++'ın birçok güçlü yönünün terk edilmesine yol açar.

sonuçlar

Tabii ki, tüm bu "takıntılar" ölümcül değildir. C++ çok yönlü ve güçlü bir dildir ve bu nedenle olası tüm hesaplama algoritmalarını ifade etme yeteneğine sahiptir. Bu nedenle, bir uygulama içinde bulunanlar gibi dinamik özellikler gerektiriyorsa, tcl/tk, Şema/Tk, dipnot ve benzeri; C++ kullanarak her zaman onlar gibi bir şey yapabilirsiniz. Öte yandan, tüm bu özelliklerin bulunduğu bir dil neden kullanılmasın?

Son güncelleme: 07.10.2019

Bir arabirim, bazı işlevleri tanımlayabilen bir referans türünü temsil eder - bir uygulama olmadan bir dizi yöntem ve özellik. Daha sonra bu işlevsellik, bu arabirimleri kullanan sınıflar ve yapılar tarafından uygulanır.

Arayüz tanımı

interface anahtar sözcüğü, bir interface tanımlamak için kullanılır. Kural olarak, C#'daki arabirim adları büyük I harfiyle başlar, örneğin, IComparable, IEnumerable (Macar notasyonu olarak adlandırılır), ancak bu bir gereklilik değil, daha çok bir programlama stilidir.

Bir arayüz neyi tanımlayabilir? Genel olarak, arayüzler aşağıdaki varlıkları tanımlayabilir:

Özellikler

Dizin oluşturucular
Statik alanlar ve sabitler (C# 8.0'dan beri)

Ancak, arayüzler statik olmayan değişkenleri tanımlayamaz. Örneğin, tüm bu bileşenleri tanımlayan en basit arayüz:

Arayüz IMovable ( // sabit sabit int minSpeed = 0; // minimum hız // statik değişken statik int maxSpeed = 60; // maksimum hız // yöntem void Move(); // hareket // özellik dizesi Ad ( get; set ; ) // temsilci adı void MoveHandler(string mesajı); // olay için bir temsilci tanımlama // event event MoveHandler MoveEvent; // motion event )

Bu durumda, hareketli bir nesneyi temsil eden IMovable arabirimi tanımlanır. Bu arabirim, hareketli bir nesnenin yeteneklerini tanımlayan çeşitli bileşenler içerir. Yani arayüz, hareketli bir nesnenin sahip olması gereken bazı işlevleri tanımlar.

Bir arabirimin yöntemleri ve özellikleri bir uygulamaya sahip olmayabilir, bu durumda soyut yöntemlere ve soyut sınıfların özelliklerine daha yakındırlar. Bu durumda, arayüz, bazı hareketleri temsil edecek bir Move yöntemini tanımlar. Uygulaması yoktur, parametre almaz ve hiçbir şey döndürmez.

Aynısı bu durumda Name özelliği için de geçerlidir. İlk bakışta, otomatik bir özellik gibi görünüyor. Ancak gerçekte bu, bir otomatik özelliği değil, uygulaması olmayan bir arabirimdeki bir özellik tanımıdır.

Bir arabirimin bildirilmesinde bir nokta daha: eğer üyeleri - yöntemleri ve özellikleri erişim değiştiricilerine sahip değilse, ancak aslında erişim varsayılan olarak geneldir, çünkü arabirimin amacı, uygulama için işlevselliği sınıfına göre tanımlamaktır. Bu, varsayılan olarak sınıflarda ve yapılarda özel değiştiriciye sahip olan sabitler ve statik değişkenler için de geçerlidir. Arayüzlerde, varsayılan olarak genel değiştiriciye sahiptirler. Ve örneğin, IMovable arayüzünün minSpeed sabitine ve maxSpeed değişkenine başvurabiliriz:

Static void Main(string args) ( Console.WriteLine(IMovable.maxSpeed); Console.WriteLine(IMovable.minSpeed); )

Ama ayrıca, C# 8.0 ile başlayarak, arayüz bileşenleri için erişim değiştiricilerini açıkça belirtebiliriz:

Arayüz IMovable ( public const int minSpeed = 0; // minimum hız özel static int maxSpeed = 60; // maksimum hız public void Move(); korumalı dahili dize Adı ( get; set; ) // genel temsilcinin adı void MoveHandler(dize mesajı); // olay genel olayı için bir temsilci tanımlama MoveHandler MoveEvent; // hareket olayı )

C# 8.0 ile başlayarak, arabirimler, yöntemlerin ve özelliklerin varsayılan uygulamalarını destekler. Bu, tıpkı sıradan sınıflarda ve yapılarda olduğu gibi, bir uygulaması olan arabirimlerde tam teşekküllü yöntemler ve özellikler tanımlayabileceğimiz anlamına gelir. Örneğin, Move yönteminin varsayılan bir uygulamasını tanımlayalım:

Arabirim IMovable ( // varsayılan yöntem uygulaması void Move() ( Console.WriteLine("Walking"); ) )

Arayüzlerde varsayılan özelliklerin uygulanması ile durum biraz daha karmaşıktır, çünkü arayüzlerde statik olmayan değişkenleri tanımlayamayız ve buna bağlı olarak arayüz özelliklerinde bir nesnenin durumunu değiştiremeyiz. Ancak, özellikler için varsayılan bir uygulama da tanımlayabiliriz:

IMovable Arabirimi ( void Move() ( Console.WriteLine("Walking"); ) // varsayılan özellik uygulaması // salt okunur özellik int MaxSpeed ( get ( return 0; ) ) )

Arayüzün özel yöntemleri ve özellikleri varsa (yani özel değiştirici ile), bunların varsayılan bir uygulamaya sahip olmaları gerektiğini belirtmekte fayda var. Aynısı, herhangi bir statik yöntem ve özellik için de geçerlidir (mutlaka özel olması gerekmez):

Arayüz IMovable ( public const int minSpeed = 0; // minimum hız özel static int maxSpeed = 60; // maksimum hız // mesafeyi kat etmek için geçen süreyi bul static double GetTime(çift mesafe, çift hız) ) = > mesafe / hız; static int MaxSpeed ( get ( maxSpeed döndür; ) set ( if (value > 0) maxSpeed = value; ) ) ) ) sınıf Program ( static void Main(string args) ( Console.WriteLine (IMovable.MaxSpeed); IMovable.MaxSpeed = 65;Console.WriteLine(IMovable.MaxSpeed);double time = IMovable.GetTime(100, 10);Console.WriteLine(time); ) )

Arayüz erişim değiştiricileri

Sınıflar gibi, arabirimler de varsayılan olarak dahili erişim düzeyine sahiptir; bu, böyle bir arabirimin yalnızca mevcut projede mevcut olduğu anlamına gelir. Ancak public değiştirici ile arayüzü herkese açık hale getirebiliriz:

Genel arayüz IMovable ( void Move(); )

Visual Studio'nun ayrı bir dosyaya yeni bir arayüz eklemek için özel bir bileşeni olduğunu belirtmekte fayda var. Projeye bir arayüz eklemek için, projeye sağ tıklayıp beliren bağlam menüsünde Ekle -> Yeni Öğe... öğesini seçebilir ve yeni bir bileşen eklemek için iletişim kutusundaki Arayüz öğesini seçebilirsiniz.

Mühür