Witaj, Mac — przewodnik

Środowisko Xamarin.Mac umożliwia tworzenie w pełni natywnych aplikacji dla komputerów Mac w językach C# i .NET przy użyciu tych samych interfejsów API systemu macOS, które są używane podczas tworzenia aplikacji w języku Objective-C lub Swift. Ponieważ środowisko Xamarin.Mac integruje się bezpośrednio z programem Xcode, deweloper może użyć narzędzia Interface Builder środowiska Xcode do utworzenia interfejsów użytkownika aplikacji (lub opcjonalnie utworzyć je bezpośrednio w kodzie C#).

Ponadto, ponieważ aplikacje platformy Xamarin.Mac są napisane w językach C# i .NET, kod można udostępniać aplikacjom mobilnym Xamarin.iOS i Xamarin.Android; wszystko, zapewniając natywne środowisko na każdej platformie.

W tym artykule przedstawiono kluczowe pojęcia niezbędne do utworzenia aplikacji dla komputerów Mac przy użyciu platformy Xamarin.Mac, Visual Studio dla komputerów Mac i narzędzia Xcode Interface Builder, przechodząc przez proces tworzenia prostej aplikacji Hello, Mac, która zlicza liczbę kliknięć przycisku:

Zostaną omówione następujące pojęcia:

• Visual Studio dla komputerów Mac — wprowadzenie do Visual Studio dla komputerów Mac i sposób tworzenia aplikacji platformy Xamarin.Mac.
• Anatomia aplikacji Xamarin.Mac — co składa się z aplikacji platformy Xamarin.Mac.
• Xcode's Interface Builder — jak używać narzędzia Interface Builder środowiska Xcode do definiowania interfejsu użytkownika aplikacji.
• Gniazda i akcje — jak używać placówek i akcji do podłączania kontrolek w interfejsie użytkownika.
• Wdrażanie/testowanie — jak uruchomić i przetestować aplikację platformy Xamarin.Mac.

Wymagania

Tworzenie aplikacji platformy Xamarin.Mac wymaga:

• Komputer Mac z systemem macOS High Sierra (10.13) lub nowszym.
• Xcode 10 lub nowszy.
• Najnowsza wersja platformy Xamarin.Mac i Visual Studio dla komputerów Mac.

Aby uruchomić aplikację utworzoną za pomocą platformy Xamarin.Mac, potrzebne są następujące elementy:

• Komputer Mac z systemem macOS 10.7 lub nowszym.

Ostrzeżenie

Nadchodząca wersja platformy Xamarin.Mac 4.8 będzie obsługiwała tylko system macOS w wersji 10.9 lub wyższej. Poprzednie wersje platformy Xamarin.Mac obsługiwały system macOS w wersji 10.7 lub wyższej, ale starsze wersje systemu macOS nie posiadają odpowiedniej infrastruktury TLS do obsługi protokołu TLS 1.2. W przypadku systemu macOS 10.7 lub macOS 10.8 należy użyć platformy Xamarin.Mac w wersji 4.6 lub wcześniejszej.

Uruchamianie nowej aplikacji Xamarin.Mac w Visual Studio dla komputerów Mac

Jak wspomniano powyżej, ten przewodnik przeprowadzi Cię przez kroki tworzenia aplikacji dla komputerów Mac o nazwie Hello_Mac , która dodaje pojedynczy przycisk i etykietę do okna głównego. Po kliknięciu przycisku etykieta będzie wyświetlać liczbę kliknięć.

Aby rozpocząć pracę, wykonaj następujące czynności:

1. Uruchom Visual Studio dla komputerów Mac:

   

2. Kliknij przycisk Nowy projekt..., aby otworzyć okno dialogowe Nowy projekt, a następnie wybierz pozycjęAplikacja kakaowa aplikacji> dla komputerów Mac> i kliknij przycisk Dalej:

   

3. Wprowadź Hello_Mac wartość w polu Nazwa aplikacji i pozostaw wszystko inne jako domyślne. Kliknij przycisk Dalej:

   

4. Potwierdź lokalizację nowego projektu na komputerze:

   

5. Kliknij przycisk Utwórz.

Visual Studio dla komputerów Mac utworzy nową aplikację platformy Xamarin.Mac i wyświetli domyślne pliki, które zostaną dodane do rozwiązania aplikacji:

Visual Studio dla komputerów Mac używa tej samej struktury rozwiązania i projektu co program Visual Studio 2019. Rozwiązanie to kontener, który może przechowywać co najmniej jeden projekt; projekty mogą obejmować aplikacje, biblioteki pomocnicze, aplikacje testowe itp. Szablon Plik > nowy projekt tworzy rozwiązanie i projekt aplikacji automatycznie.

Anatomia aplikacji Xamarin.Mac

Programowanie aplikacji platformy Xamarin.Mac jest bardzo podobne do pracy z platformą Xamarin.iOS. System iOS używa struktury CocoaTouch, która jest odchudzoną wersją cocoa, używaną przez komputery Mac.

Przyjrzyj się plikom w projekcie:

• Plik Main.cs zawiera główny punkt wejścia aplikacji. Po uruchomieniu Main aplikacji klasa zawiera pierwszą uruchamianą metodę.
• Plik AppDelegate.cs zawiera klasę AppDelegate , która jest odpowiedzialna za nasłuchiwanie zdarzeń z systemu operacyjnego.
• Plik Info.plist zawiera właściwości aplikacji, takie jak nazwa aplikacji, ikony itp.
• Plik Entitlements.plist zawiera uprawnienia dla aplikacji i umożliwia dostęp do takich elementów, jak piaskownica i obsługa usługi iCloud.
• Main.storyboard definiuje interfejs użytkownika (system Windows i menu) dla aplikacji i określa wzajemne połączenia między systemem Windows za pośrednictwem Segues. Scenorysy to pliki XML zawierające definicję widoków (elementy interfejsu użytkownika). Ten plik można utworzyć i utrzymać za pomocą narzędzia Interface Builder wewnątrz programu Xcode.
• ViewController.cs jest kontrolerem głównego okna. Kontrolery zostaną szczegółowo omówione w innym artykule, ale na razie kontroler może być uważany za główny aparat dowolnego konkretnego widoku.
• Plik ViewController.designer.cs zawiera kod kanalizacji, który ułatwia integrację z interfejsem użytkownika ekranu głównego.

W poniższych sekcjach zapoznasz się z niektórymi z tych plików. Później zostaną one dokładniej zbadane, ale warto teraz zrozumieć ich podstawy.

Main.cs

Plik Main.cs jest bardzo prosty. Zawiera on metodę statyczną Main , która tworzy nowe wystąpienie aplikacji platformy Xamarin.Mac i przekazuje nazwę klasy, która będzie obsługiwać zdarzenia systemu operacyjnego, co w tym przypadku jest klasą AppDelegate :

using System;
using System.Drawing;
using Foundation;
using AppKit;
using ObjCRuntime;

namespace Hello_Mac
{
    class MainClass
    {
        static void Main (string[] args)
        {
            NSApplication.Init ();
            NSApplication.Main (args);
        }
    }
}

AppDelegate.cs

Plik AppDelegate.cs zawiera klasę AppDelegate , która jest odpowiedzialna za tworzenie okien i nasłuchiwanie zdarzeń systemu operacyjnego:

using AppKit;
using Foundation;

namespace Hello_Mac
{
    [Register ("AppDelegate")]
    public class AppDelegate : NSApplicationDelegate
    {
        public AppDelegate ()
        {
        }

        public override void DidFinishLaunching (NSNotification notification)
        {
            // Insert code here to initialize your application
        }

        public override void WillTerminate (NSNotification notification)
        {
            // Insert code here to tear down your application
        }
    }
}

Ten kod jest prawdopodobnie nieznany, chyba że deweloper utworzył wcześniej aplikację dla systemu iOS, ale jest dość prosty.

Metoda DidFinishLaunching jest uruchamiana po utworzeniu wystąpienia aplikacji i jest odpowiedzialna za rzeczywiste utworzenie okna aplikacji i rozpoczęcie procesu wyświetlania w nim widoku.

Metoda WillTerminate zostanie wywołana, gdy użytkownik lub system utworzyli wystąpienie zamknięcia aplikacji. Deweloper powinien użyć tej metody, aby sfinalizować aplikację przed jej zamknięciem (na przykład zapisanie preferencji użytkownika lub rozmiaru i lokalizacji okna).

ViewController.cs

Kakao (i przez wyprowadzanie, CocoaTouch) używa tego, co jest znane jako wzorzec MVC ( Model View Controller ). Deklaracja ViewController reprezentuje obiekt, który kontroluje rzeczywiste okno aplikacji. Ogólnie rzecz biorąc, dla każdego utworzonego okna (i dla wielu innych elementów w oknach) istnieje kontroler, który jest odpowiedzialny za cykl życia okna, taki jak wyświetlanie, dodawanie nowych widoków (kontrolek) do niego itp.

Klasa ViewController jest kontrolerem głównego okna. Kontroler jest odpowiedzialny za cykl życia okna głównego. Zostanie to szczegółowo zbadane później, na razie przyjrzyj się temu szybko:

using System;

using AppKit;
using Foundation;

namespace Hello_Mac
{
    public partial class ViewController : NSViewController
    {
        public ViewController (IntPtr handle) : base (handle)
        {
        }

        public override void ViewDidLoad ()
        {
            base.ViewDidLoad ();

            // Do any additional setup after loading the view.
        }

        public override NSObject RepresentedObject {
            get {
                return base.RepresentedObject;
            }
            set {
                base.RepresentedObject = value;
                // Update the view, if already loaded.
            }
        }
    }
}

ViewController. Projektant.cs

Plik projektanta dla klasy Main Window jest początkowo pusty, ale zostanie automatycznie wypełniony przez Visual Studio dla komputerów Mac, ponieważ interfejs użytkownika jest tworzony za pomocą narzędzia Xcode Interface Builder:

// WARNING
//
// This file has been generated automatically by Visual Studio for Mac to store outlets and
// actions made in the UI designer. If it is removed, they will be lost.
// Manual changes to this file may not be handled correctly.
//
using Foundation;

namespace Hello_Mac
{
    [Register ("ViewController")]
    partial class ViewController
    {
        void ReleaseDesignerOutlets ()
        {
        }
    }
}

Projektant pliki nie powinny być edytowane bezpośrednio, ponieważ są one automatycznie zarządzane przez Visual Studio dla komputerów Mac w celu udostępnienia kodu kanalizacji, który umożliwia dostęp do kontrolek, które zostały dodane do dowolnego okna lub widoku w aplikacji.

Po utworzeniu projektu aplikacji Xamarin.Mac i podstawowa wiedza na temat jej składników przejdź do środowiska Xcode, aby utworzyć interfejs użytkownika przy użyciu narzędzia Interface Builder.

Info.plist

Plik Info.plist zawiera informacje o aplikacji Xamarin.Mac, takie jak nazwa i identyfikator pakietu:

Definiuje również scenorys , który będzie używany do wyświetlania interfejsu użytkownika dla aplikacji Xamarin.Mac na liście rozwijanej Interfejs główny . W powyższym Main przykładzie na liście rozwijanej element odnosi się do Main.storyboard elementu w drzewie źródłowym projektu w Eksplorator rozwiązań. Definiuje również ikony aplikacji, określając katalog zasobów zawierający je (w tym przypadku AppIcon ).

Entitlements.plist

Plik aplikacji Entitlements.plist kontroluje uprawnienia, które aplikacja Xamarin.Mac ma, takie jak piaskownica i usługa iCloud:

W przypadku Hello world przykładu żadne uprawnienia nie będą wymagane. W następnej sekcji pokazano, jak używać narzędzia Interface Builder środowiska Xcode do edytowania pliku Main.storyboard i definiowania interfejsu użytkownika aplikacji Xamarin.Mac.

Wprowadzenie do narzędzi Xcode i Interface Builder

W ramach programu Xcode firma Apple utworzyła narzędzie o nazwie Interface Builder, które umożliwia deweloperowi wizualne tworzenie interfejsu użytkownika w projektancie. Środowisko Xamarin.Mac bezproblemowo integruje się z narzędziem Interface Builder, co umożliwia tworzenie interfejsu użytkownika przy użyciu tych samych narzędzi co Objective-C użytkownicy.

Aby rozpocząć pracę, kliknij Main.storyboard dwukrotnie plik w Eksplorator rozwiązań, aby otworzyć go do edycji w programie Xcode i narzędziu Interface Builder:

Powinno to spowodować uruchomienie programu Xcode i wyglądać podobnie do tego zrzutu ekranu:

Przed rozpoczęciem projektowania interfejsu zapoznaj się z krótkim omówieniem środowiska Xcode, aby orientować się z głównymi funkcjami, które będą używane.

Uwaga

Deweloper nie musi używać środowiska Xcode i Interface Builder do tworzenia interfejsu użytkownika dla aplikacji platformy Xamarin.Mac. Interfejs użytkownika można utworzyć bezpośrednio z poziomu kodu języka C#, ale wykracza to poza zakres tego artykułu. Dla uproszczenia będzie ona używać narzędzia Interface Builder do tworzenia interfejsu użytkownika w pozostałej części tego samouczka.

Składniki programu Xcode

Podczas otwierania pliku scenorysu w środowisku Xcode z Visual Studio dla komputerów Mac zostanie otwarty z nawigatorem projektu po lewej stronie, hierarchią interfejsu i edytorem interfejsu w środku oraz sekcją Narzędzia właściwości & po prawej stronie:

W poniższych sekcjach przedstawiono działania poszczególnych funkcji środowiska Xcode oraz sposób ich używania do tworzenia interfejsu dla aplikacji platformy Xamarin.Mac.

Nawigacja po projekcie

Podczas otwierania pliku scenorysu do edycji w środowisku Xcode Visual Studio dla komputerów Mac tworzy plik projektu Xcode w tle w celu komunikowania zmian między samym sobą a programem Xcode. Później, gdy deweloper przełącza się z powrotem do Visual Studio dla komputerów Mac z programu Xcode, wszelkie zmiany wprowadzone w tym projekcie są synchronizowane z projektem Xamarin.Mac przez Visual Studio dla komputerów Mac.

Sekcja Nawigacja nad projektem umożliwia deweloperowi nawigowanie między wszystkimi plikami tworzącym ten projekt shim Xcode. Zazwyczaj będą one zainteresowane tylko plikami .storyboard na tej liście, takimi jak Main.storyboard.

Hierarchia interfejsu

Sekcja Hierarchia interfejsu umożliwia deweloperowi łatwy dostęp do kilku kluczowych właściwości interfejsu użytkownika, takich jak jego symbole zastępczei okno główne. Ta sekcja może służyć do uzyskiwania dostępu do poszczególnych elementów (widoków) tworzących interfejs użytkownika i dostosowania sposobu ich zagnieżdżenia przez przeciągnięcie ich w hierarchii.

Edytor interfejsów

Sekcja Edytor interfejsu zawiera powierzchnię, na której interfejs użytkownika jest graficzny. Przeciągnij elementy z sekcji Biblioteka sekcji Narzędzia właściwości&, aby utworzyć projekt. W miarę dodawania elementów interfejsu użytkownika (widoków) do powierzchni projektowej zostaną one dodane do sekcji Hierarchia interfejsu w kolejności, w której są wyświetlane w Edytorze interfejsów.

Narzędzia właściwości &

Sekcja Właściwości & narzędzi jest podzielona na dwie główne sekcje : Właściwości (nazywane również inspektorami) i Bibliotekę:

Początkowo ta sekcja jest prawie pusta, jednak jeśli deweloper wybierze element w edytorze interfejsu lub hierarchii interfejsu, sekcja Właściwości zostanie wypełniona informacjami na temat danego elementu i właściwości, które mogą dostosować.

W sekcji Właściwości znajduje się osiem różnych kart Inspektor, jak pokazano na poniższej ilustracji:

Właściwości & — typy narzędzi

Od lewej do prawej są następujące karty:

• File Inspector — Inspektor plików zawiera informacje o plikach, takie jak nazwa pliku i lokalizacja edytowanego pliku Xib.
• Szybka pomoc — karta Szybka pomoc zawiera kontekstową pomoc opartą na tym, co zostało wybrane w programie Xcode.
• Identity Inspector — Inspektor tożsamości zawiera informacje o wybranej kontrolce/widoku.
• Attributes Inspector — Inspektor atrybutów umożliwia deweloperowi dostosowywanie różnych atrybutów wybranej kontrolki/widoku.
• Size Inspector — Inspektor rozmiaru umożliwia deweloperowi kontrolowanie rozmiaru i zmiany rozmiaru wybranej kontrolki/widoku.
• Inspektor połączeń — Inspektor połączeń pokazuje połączenia gniazda i akcji wybranych kontrolek. Gniazda i akcje zostaną omówione szczegółowo poniżej.
• Bindings Inspector — Inspektor powiązań umożliwia deweloperowi konfigurowanie kontrolek, dzięki czemu ich wartości są automatycznie powiązane z modelami danych.
• View Effects Inspector — Inspektor efektów widoku umożliwia deweloperowi określenie wpływu na kontrolki, takie jak animacje.

Sekcja Biblioteka służy do znajdowania kontrolek i obiektów do umieszczania w projektancie w celu graficznego kompilowania interfejsu użytkownika:

Tworzenie interfejsu

Po omówieniu podstaw środowiska IDE Xcode i narzędzia Interface Builder deweloper może utworzyć interfejs użytkownika dla widoku głównego.

Wykonaj następujące kroki, aby użyć narzędzia Interface Builder:

1. W programie Xcode przeciągnij przycisk push z sekcji Biblioteka:

   

2. Upuść przycisk na widok (pod kontrolerem okna) w Edytorze interfejsu:

   

3. Kliknij właściwość Title w Inspektorze atrybutów i zmień tytuł przycisku na Kliknij mnie:

   

4. Przeciągnij etykietę z sekcji biblioteka:

   

5. Upuść etykietę na okno obok przycisku w Edytorze interfejsów:

   

6. Chwyć prawy uchwyt na etykiecie i przeciągnij go do momentu, gdy znajduje się w pobliżu krawędzi okna:

   

7. Wybierz właśnie dodany przycisk w Edytorze interfejsów, a następnie kliknij ikonę Edytor ograniczeń w dolnej części okna:

   

8. W górnej części edytora kliknij czerwone belki I-Beam w górnej i lewej części. W miarę zmieniania rozmiaru okna spowoduje to pozostawienie przycisku w tej samej lokalizacji w lewym górnym rogu ekranu.

9. Następnie zaznacz pola Wysokość i Szerokość i użyj domyślnych rozmiarów. Powoduje to zachowanie tego samego rozmiaru przycisku po zmianie rozmiaru okna.

10. Kliknij przycisk Dodaj ograniczenia 4, aby dodać ograniczenia i zamknąć edytor.

11. Wybierz etykietę i ponownie kliknij ikonę Edytor ograniczeń :

    

12. Klikając czerwone wiązki I-Beam u góry , po prawej i lewej stronie Edytora ograniczeń, informuje etykietę, aby utknęła w podanych lokalizacjach X i Y, a następnie zwiększać i zmniejszać w miarę zmiany rozmiaru okna w uruchomionej aplikacji.

13. Ponownie zaznacz pole Wysokość i użyj domyślnego rozmiaru, a następnie kliknij przycisk Dodaj 4 ograniczenia , aby dodać ograniczenia i zamknąć edytor.

14. Zapisz zmiany w interfejsie użytkownika.

Podczas zmiany rozmiaru i przenoszenia kontrolek wokół zwróć uwagę, że narzędzie Interface Builder udostępnia przydatne wskazówki dotyczące przyciągania oparte na wytycznych dotyczących interfejsu użytkownika systemu macOS. Te wytyczne pomogą deweloperowi tworzyć wysokiej jakości aplikacje, które będą miały znajomy wygląd i działanie dla użytkowników komputerów Mac.

Zapoznaj się z sekcją Hierarchia interfejsu , aby zobaczyć, jak pokazano układ i hierarchię elementów tworzących interfejs użytkownika:

W tym miejscu deweloper może wybrać elementy do edycji lub przeciągania w celu zmiany kolejności elementów interfejsu użytkownika w razie potrzeby. Jeśli na przykład element interfejsu użytkownika był objęty innym elementem, może przeciągnąć go na dół listy, aby był to najbardziej górny element w oknie.

Po utworzeniu interfejsu użytkownika deweloper będzie musiał uwidocznić elementy interfejsu użytkownika, aby platforma Xamarin.Mac mogła uzyskiwać do nich dostęp i korzystać z nich w kodzie języka C#. W następnej sekcji , Outlet i Actions (Akcje) pokazano, jak to zrobić.

Gniazda i akcje

Co to są punkty sprzedaży i akcje? W tradycyjnym programowaniu interfejsu użytkownika platformy .NET po dodaniu kontrolka w interfejsie użytkownika jest automatycznie uwidaczniana jako właściwość. Elementy działają inaczej na komputerze Mac, po prostu dodanie kontrolki do widoku nie sprawia, że jest dostępny dla kodu. Deweloper musi jawnie uwidocznić element interfejsu użytkownika w kodzie. W tym celu firma Apple oferuje dwie opcje:

• Gniazda — gniazda są analogiczne do właściwości. Jeśli deweloper podłącza kontrolkę do gniazda, jest on udostępniany kodowi za pośrednictwem właściwości, dzięki czemu może wykonywać takie czynności, jak dołączanie procedur obsługi zdarzeń, wywoływanie metod itp.
• Actions — akcje są analogiczne do wzorca polecenia w WPF. Na przykład gdy akcja jest wykonywana na kontrolce, na przykład kliknięcie przycisku, kontrolka automatycznie wywoła metodę w kodzie. Akcje są zaawansowane i wygodne, ponieważ deweloper może połączyć wiele kontrolek z tą samą akcją.

W środowisku Xcode punkty iakcje są dodawane bezpośrednio w kodzie za pomocą przeciągania kontrolek. Mówiąc dokładniej, oznacza to, że w celu utworzenia gniazda lub akcji deweloper wybierze element sterujący, aby dodać wylot lub akcję , przytrzymać klawisz Control na klawiaturze i przeciągnąć tę kontrolkę bezpośrednio do kodu.

W przypadku deweloperów platformy Xamarin.Mac oznacza to, że deweloper przeciągnie plik wycinków Objective-C odpowiadający plikowi C#, w którym chce utworzyć punkt wyjścia lub akcję. Visual Studio dla komputerów Mac utworzono plik o nazwie ViewController.h w ramach projektu Xcode podkładki, który został wygenerowany w celu użycia konstruktora interfejsu:

Ten plik wycinkowy .h dubluje ViewController.designer.cs element automatycznie dodawany do projektu Xamarin.Mac po utworzeniu nowego NSWindow . Ten plik będzie używany do synchronizowania zmian wprowadzonych przez konstruktora interfejsu i jest miejscem tworzenia placówek i akcji w celu uwidocznienia elementów interfejsu użytkownika w kodzie C#.

Dodawanie gniazda

Mając podstawową wiedzę na temat punktów sprzedaży i akcji , utwórz punkt wylotowy , aby uwidocznić etykietę utworzoną w kodzie języka C#.

Wykonaj następujące czynności:

1. W programie Xcode w prawym górnym rogu ekranu kliknij przycisk Podwójne kółko , aby otworzyć Edytor Asystenta:

   

2. Program Xcode przełączy się do trybu widoku podzielonego z edytorem interfejsów po jednej stronie i edytorem kodu po drugiej stronie.

3. Zwróć uwagę, że program Xcode automatycznie wybrał plik ViewController.m w Edytorze kodu, co jest niepoprawne. W dyskusji na temat powyższych punktów sprzedaży i akcji deweloper będzie musiał wybrać element ViewController.h .

4. W górnej części Edytora kodu kliknij link automatyczny i wybierz ViewController.h plik:

   

5. Program Xcode powinien teraz mieć wybrany prawidłowy plik:

   

6. Ostatni krok był bardzo ważny!: jeśli nie wybrano poprawnego pliku, nie będzie można utworzyć placówek i akcji lub zostaną one ujawnione niewłaściwej klasie w języku C#!

7. W Edytorze interfejsów przytrzymaj klawisz Control na klawiaturze i kliknij przycisk przeciągnij etykietę utworzoną powyżej do edytora kodu tuż poniżej @interface ViewController : NSViewController {} kodu:

   

8. Zostanie wyświetlone okno dialogowe. W polu Połączenie pozostaw wartość Outlet i wprowadź wartość ClickedLabelw polu Nazwa:

   

9. Kliknij przycisk Połącz , aby utworzyć gniazdo:

   

10. Zapisz zmiany w pliku.

Dodawanie akcji

Następnie uwidocznij przycisk w kodzie C#. Podobnie jak powyżej etykieta, deweloper może połączyć przycisk do gniazda. Ponieważ chcemy odpowiedzieć tylko na klikany przycisk, użyj akcji.

Wykonaj następujące czynności:

1. Upewnij się, że program Xcode jest nadal w Edytorze Asystenta , a plik ViewController.h jest widoczny w Edytorze kodu.

2. W Edytorze interfejsów przytrzymaj klawisz Control na klawiaturze i kliknij przycisk utworzony powyżej w edytorze @property (assign) IBOutlet NSTextField *ClickedLabel; kodu tuż poniżej kodu:

   

3. Zmień typ połączenia na Akcja:

   

4. Wprowadź ClickedButton jako nazwę:

   

5. Kliknij przycisk Połącz , aby utworzyć akcję:

   

6. Zapisz zmiany w pliku.

Dzięki przewodowemu interfejsowi użytkownika i uwidocznieniu kodu w języku C# przełącz się z powrotem na Visual Studio dla komputerów Mac i zezwłań synchronizację zmian wprowadzonych w środowisku Xcode i narzędziu Interface Builder.

Uwaga

Utworzenie interfejsu użytkownika iakcji dla tej pierwszej aplikacji trwało prawdopodobnie dużo czasu, ale wprowadzono wiele nowych pojęć i wiele czasu spędziło na nowym terenie. Po ćwiczeniu przez pewien czas i pracy z Interface Builder ten interfejs i wszystkie jego gniazda i akcje można utworzyć w ciągu zaledwie minuty lub dwóch.

Synchronizowanie zmian za pomocą programu Xcode

Po przełączeniu dewelopera z powrotem do Visual Studio dla komputerów Mac z programu Xcode wszelkie zmiany wprowadzone w programie Xcode zostaną automatycznie zsynchronizowane z projektem Xamarin.Mac.

Wybierz plik ViewController.designer.cs w Eksplorator rozwiązań, aby zobaczyć, jak w kodzie C# zostały podłączone przewodowe akcję i wylot:

Zwróć uwagę, że dwie definicje w pliku ViewController.designer.cs :

[Outlet]
AppKit.NSTextField ClickedLabel { get; set; }

[Action ("ClickedButton:")]
partial void ClickedButton (Foundation.NSObject sender);

Utwórz wiersz z definicjami w pliku w programie ViewController.h Xcode:

@property (assign) IBOutlet NSTextField *ClickedLabel;
- (IBAction)ClickedButton:(id)sender;

Visual Studio dla komputerów Mac nasłuchuje zmian w pliku .h, a następnie automatycznie synchronizuje te zmiany w odpowiednim pliku .designer.cs, aby uwidocznić je w aplikacji. Zwróć uwagę, że plik ViewController.designer.cs jest klasą częściową, dlatego Visual Studio dla komputerów Mac nie musi modyfikować pliku ViewController.cs, co spowoduje zastąpienie wszelkich zmian wprowadzonych przez dewelopera do klasy.

Zwykle deweloper nigdy nie będzie musiał otwierać pliku ViewController.designer.cs, który został przedstawiony w tym miejscu tylko do celów edukacyjnych.

Uwaga

W większości sytuacji Visual Studio dla komputerów Mac automatycznie zobaczy wszelkie zmiany wprowadzone w środowisku Xcode i zsynchronizuje je z projektem Xamarin.Mac. W przypadku wystąpienia wyłączenia, które synchronizacja nie jest wykonywana automatycznie, przełącz się z powrotem do środowiska Xcode, a następnie wróć do Visual Studio dla komputerów Mac ponownie. Zwykle rozpoczyna się cykl synchronizacji.

Pisanie kodu

Po utworzeniu interfejsu użytkownika i jego elementach interfejsu użytkownika uwidocznionych w kodzie za pośrednictwem punktów iakcji jesteśmy w końcu gotowi napisać kod, aby ożywić program.

W przypadku tej przykładowej aplikacji przy każdym kliknięciu pierwszego przycisku etykieta zostanie zaktualizowana, aby pokazać, ile razy przycisk został kliknięty. Aby to zrobić, otwórz ViewController.cs plik do edycji, klikając go dwukrotnie w Eksplorator rozwiązań:

Najpierw utwórz zmienną na poziomie klasy w ViewController klasie, aby śledzić liczbę kliknięć, które wystąpiły. Edytuj definicję klasy i ustaw ją jako następującą:

namespace Hello_Mac
{
    public partial class ViewController : NSViewController
    {
        private int numberOfTimesClicked = 0;
        ...

Następnie w tej samej klasie (ViewController) przesłoń metodę ViewDidLoad i dodaj kod, aby ustawić początkowy komunikat dla etykiety:

public override void ViewDidLoad ()
{
    base.ViewDidLoad ();

    // Set the initial value for the label
    ClickedLabel.StringValue = "Button has not been clicked yet.";
}

Użyj metody ViewDidLoad, zamiast innej metody, takiej jak Initialize, ponieważ ViewDidLoad jest wywoływana po załadowaniu systemu operacyjnego i utworzeniu wystąpienia interfejsu użytkownika z pliku scenorysu . Jeśli deweloper próbował uzyskać dostęp do kontrolki etykiety przed pełnym załadowaniem i utworzeniem wystąpienia pliku scenorysu , zostanie wyświetlony NullReferenceException błąd, ponieważ kontrolka etykiety jeszcze nie istnieje.

Następnie dodaj kod, aby odpowiedzieć użytkownikowi na kliknięcie przycisku. Dodaj następującą metodę częściową ViewController do klasy :

partial void ClickedButton (Foundation.NSObject sender) {
    // Update counter and label
    ClickedLabel.StringValue = string.Format("The button has been clicked {0} time{1}.",++numberOfTimesClicked, (numberOfTimesClicked < 2) ? "" : "s");
}

Ten kod jest dołączany do akcji utworzonej w programach Xcode i Interface Builder i będzie wywoływany za każdym razem, gdy użytkownik kliknie przycisk.

Testowanie aplikacji

Nadszedł czas, aby skompilować i uruchomić aplikację, aby upewnić się, że działa zgodnie z oczekiwaniami. Deweloper może skompilować i uruchomić wszystko w jednym kroku lub skompilować go bez uruchamiania.

Za każdym razem, gdy aplikacja jest tworzona, deweloper może wybrać odpowiedni rodzaj kompilacji:

• Debugowanie — kompilacja debugowania jest kompilowana w pliku .app (application) z kilkoma dodatkowymi metadanymi, które umożliwiają deweloperowi debugowanie tego, co się dzieje podczas działania aplikacji.
• Wydanie — kompilacja wydania tworzy również plik .app , ale nie zawiera informacji o debugowaniu, więc jest mniejszy i wykonywany szybciej.

Deweloper może wybrać typ kompilacji z selektora konfiguracji w lewym górnym rogu ekranu Visual Studio dla komputerów Mac:

Kompilowanie aplikacji

W przypadku tego przykładu potrzebujemy tylko kompilacji debugowania, dlatego upewnij się, że wybrano opcję Debugowanie . Najpierw skompiluj aplikację, naciskając klawisz {B lub z menu Kompilacja wybierz pozycję Kompiluj wszystko.

Jeśli nie wystąpiły żadne błędy, na pasku stanu Visual Studio dla komputerów Mac zostanie wyświetlony komunikat Build Succeeded (Powodzenie kompilacji). Jeśli wystąpiły błędy, przejrzyj projekt i upewnij się, że powyższe kroki zostały wykonane poprawnie. Zacznij od potwierdzenia, że kod (zarówno w środowisku Xcode, jak i w Visual Studio dla komputerów Mac) jest zgodny z kodem w samouczku.

Uruchamianie aplikacji

Istnieją trzy sposoby uruchamiania aplikacji:

• Naciśnij klawisz {+Enter.
• Z menu Uruchom wybierz pozycję Debuguj.
• Kliknij przycisk Odtwórz na pasku narzędzi Visual Studio dla komputerów Mac (tuż nad Eksplorator rozwiązań).

Aplikacja zostanie skompilowana (jeśli nie została jeszcze skompilowana), uruchom ją w trybie debugowania i wyświetli główne okno interfejsu:

Jeśli przycisk jest klikany kilka razy, etykieta powinna zostać zaktualizowana o liczbę:

Gdzie dalej

Podstawy pracy z aplikacją platformy Xamarin.Mac nie działają, zapoznaj się z następującymi dokumentami, aby lepiej zrozumieć:

• Wprowadzenie do scenorysów — ten artykuł zawiera wprowadzenie do pracy z scenorysami w aplikacji Xamarin.Mac. Obejmuje tworzenie i konserwowanie interfejsu użytkownika aplikacji przy użyciu scenorysów i narzędzia Xcode Interface Builder.
• Windows — w tym artykule opisano pracę z systemem Windows i panelami w aplikacji platformy Xamarin.Mac. Obejmuje tworzenie i konserwowanie systemu Windows i paneli w programie Xcode i konstruktorze interfejsu, ładowanie systemu Windows i paneli z plików xib przy użyciu systemu Windows i odpowiadanie na system Windows w kodzie języka C#.
• Okna dialogowe — w tym artykule opisano pracę z oknami dialogowymi i modalnymi systemami Windows w aplikacji Xamarin.Mac. Obejmuje tworzenie i konserwowanie modalnego systemu Windows w środowisku Xcode i konstruktorze interfejsu, pracę ze standardowymi oknami dialogowymi, wyświetlanie i odpowiadanie na system Windows w kodzie języka C#.
• Alerty — w tym artykule opisano pracę z alertami w aplikacji platformy Xamarin.Mac. Obejmuje tworzenie i wyświetlanie alertów z poziomu kodu C# oraz reagowanie na alerty.
• Menu — menu są używane w różnych częściach interfejsu użytkownika aplikacji dla komputerów Mac; z menu głównego aplikacji w górnej części ekranu, aby wyświetlić menu podręczne i kontekstowe, które mogą być wyświetlane w dowolnym miejscu w oknie. Menu są integralną częścią środowiska użytkownika aplikacji dla komputerów Mac. W tym artykule opisano pracę z menu cocoa w aplikacji Xamarin.Mac.
• Paski narzędzi — w tym artykule opisano pracę z paskami narzędzi w aplikacji platformy Xamarin.Mac. Obejmuje tworzenie i konserwę. Paski narzędzi w narzędziu Xcode i konstruktorze interfejsu, sposób uwidaczniania elementów paska narzędzi w kodzie przy użyciu punktów i akcji, włączania i wyłączania elementów paska narzędzi, a na koniec odpowiadania na elementy paska narzędzi w kodzie języka C#.
• Widoki tabel — w tym artykule opisano pracę z widokami tabel w aplikacji platformy Xamarin.Mac. Obejmuje on tworzenie i obsługę widoków tabel w programie Xcode i konstruktorze interfejsu, sposób uwidaczniania elementów widoku tabeli w kodzie przy użyciu punktów i akcji, wypełniania elementów tabeli i reagowania na elementy widoku tabeli w kodzie C#.
• Widoki konspektu — w tym artykule opisano pracę z widokami konspektu w aplikacji platformy Xamarin.Mac. Obejmuje tworzenie i obsługę widoków konspektu w programie Xcode i konstruktorze interfejsu, sposób uwidaczniania elementów widoku konspektu w kodzie przy użyciu punktów i akcji, wypełniania elementów konspektu i reagowania na elementy widoku konspektu w kodzie języka C#.
• Listy źródłowe — w tym artykule opisano pracę z listami źródłowymi w aplikacji platformy Xamarin.Mac. Obejmuje tworzenie i konserwację list źródłowych w programie Xcode i konstruktorze interfejsu, sposób uwidaczniania elementów list źródłowych w kodzie przy użyciu punktów i akcji, wypełniania elementów listy źródłowej i reagowania na elementy listy źródłowej w kodzie C#.
• Widoki kolekcji — w tym artykule opisano pracę z widokami kolekcji w aplikacji platformy Xamarin.Mac. Obejmuje tworzenie i obsługę widoków kolekcji w środowisku Xcode i konstruktorze interfejsu, sposób uwidaczniania elementów widoku kolekcji w kodzie przy użyciu gniazd i akcji, wypełniania widoków kolekcji i reagowania na widoki kolekcji w kodzie C#.
• Praca z obrazami — w tym artykule opisano pracę z obrazami i ikonami w aplikacji platformy Xamarin.Mac. Obejmuje tworzenie i konserwowanie obrazów potrzebnych do utworzenia ikony aplikacji oraz używanie obrazów zarówno w kodzie C#, jak i w narzędziu Xcode Interface Builder.

Galeria przykładów dla komputerów Mac zawiera gotowe do użycia przykłady kodu ułatwiające naukę platformy Xamarin.Mac.

Jedną z kompletnych aplikacji platformy Xamarin.Mac, która zawiera wiele funkcji, które użytkownik spodziewa się znaleźć w typowej aplikacji dla komputerów Mac, to przykładowa aplikacja SourceWriter. SourceWriter to prosty edytor kodu źródłowego, który zapewnia obsługę uzupełniania kodu i wyróżniania prostej składni.

Kod SourceWriter został w pełni skomentowany i, jeśli jest dostępny, linki zostały dostarczone z kluczowych technologii lub metod do odpowiednich informacji w dokumentacji platformy Xamarin.Mac.

Podsumowanie

W tym artykule opisano podstawy standardowej aplikacji platformy Xamarin.Mac. Omówiono tworzenie nowej aplikacji w Visual Studio dla komputerów Mac, projektowanie interfejsu użytkownika w środowisku Xcode i narzędziu Interface Builder, uwidacznianie elementów interfejsu użytkownika w kodzie C# przy użyciu gniazd i akcji, dodawanie kodu do pracy z elementami interfejsu użytkownika, a na koniec kompilowanie i testowanie aplikacji Xamarin.Mac.

Linki powiązane

• Wskazówki dotyczące interfejsu użytkownika systemu macOS