Vázání dat a kódování klíč-hodnota v Xamarin. Mac

Tento článek se zabývá používáním kódování klíč-hodnota a sledování hodnoty klíč-hodnota, které umožňuje datovou vazbu na prvky uživatelského rozhraní v Interface Builder Xcode.

Přehled

Při práci s C# a .NET v aplikaci Xamarin. Mac máte přístup ke stejným technikům kódování a datových vazeb dat, které vývojář pracuje v Objective-C a Objective-C . Protože se Xamarin. Mac integruje přímo s Xcode, můžete použít Interface Builder Xcode k vázání dat s prvky uživatelského rozhraní místo psaní kódu.

Pomocí kódování klíč-hodnota a technik vytváření datových vazeb ve vaší aplikaci Xamarin. Mac můžete výrazně snížit množství kódu, který musíte napsat a udržovat, aby naplnili a pracovali s prvky uživatelského rozhraní. Máte také výhodu dalšího oddělení vašich zálohovaných dat (datového modelu) od uživatelského rozhraní front-end (Controller-View-Controller), což usnadňuje údržbu a pružnější návrh aplikací.

Příklad aplikace

V tomto článku se seznámíte se základy práce s kódováním klíč-hodnota a datovou vazbou v aplikaci Xamarin. Mac. Důrazně doporučujeme, abyste nejprve pracovali v článku Hello, Mac , konkrétně v částech Úvod k Xcode a Interface Builder a akcím a akcím , které se týkají klíčových konceptů a technik, které v tomto článku budeme používat.

Můžete se podívat Exposing C# classes / methods to Objective-C i na část dokumentu Exposing C# classes / methods to Objective-C a vysvětluje RegisterExport atributy a použité k navýšení tříd jazyka C# do Objective-C objektů a prvků uživatelského rozhraní.

Co je kódování klíč-hodnota

Kódování klíč-hodnota (KVC) je mechanismus pro přístup k vlastnostem objektu nepřímo, a to pomocí klíčů (speciálně formátovaných řetězců) k identifikaci vlastností namísto jejich přístupu přes proměnné instance nebo metody přístupového objektu ( get/set ). Implementací přístupových kódů odpovídajících předpisům kódování klíčů v aplikaci Xamarin. Mac získáte přístup k dalším funkcím macOS (dříve označovaným jako "OS X"), jako je například pozorování klíč-hodnota (KVO), vázání dat, základní data, vazby kakaa a vytváření skriptů.

Pomocí kódování klíč-hodnota a technik vytváření datových vazeb ve vaší aplikaci Xamarin. Mac můžete výrazně snížit množství kódu, který musíte napsat a udržovat, aby naplnili a pracovali s prvky uživatelského rozhraní. Máte také výhodu dalšího oddělení vašich zálohovaných dat (datového modelu) od uživatelského rozhraní front-end (Controller-View-Controller), což usnadňuje údržbu a pružnější návrh aplikací.

Řekněme například, že se podíváme na následující definici třídy objektu kompatibilního s KVC:

using System;
using Foundation;

namespace MacDatabinding
{
    [Register("PersonModel")]
    public class PersonModel : NSObject
    {
        private string _name = "";

        [Export("Name")]
        public string Name {
            get { return _name; }
            set {
                WillChangeValue ("Name");
                _name = value;
                DidChangeValue ("Name");
            }
        }

        public PersonModel ()
        {
        }
    }
}

Nejprve [Register("PersonModel")] atribut zaregistruje třídu a zpřístupní ji pro Objective-C . Třída pak musí dědit od NSObject (nebo podtřídy, která dědí z NSObject ), přidá několik základních metod, které umožňují třídě KVC kompatibilní. Dále [Export("Name")] atribut zpřístupňuje Name vlastnost a definuje hodnotu klíče, která bude později použita pro přístup k vlastnosti prostřednictvím technik KVC a KVO.

Nakonec, aby bylo možné Key-Value pozorované změny hodnoty vlastnosti, přistupující objekt musí obtékat změny jeho hodnoty v WillChangeValueDidChangeValue volání a metody (určení stejného klíče jako Export atribut). Například:

set {
    WillChangeValue ("Name");
    _name = value;
    DidChangeValue ("Name");
}

Tento krok je velmi důležitý pro datové vazby v Interface Builder Xcode (jak je uvedeno dále v tomto článku).

Další informace najdete v tématu Průvodce programováním kódu pro kódspolečnosti Apple.

Klíče a cesty k klíčům

Klíč je řetězec, který identifikuje konkrétní vlastnost objektu. Klíč obvykle odpovídá názvu přístupové metody v objektu kompatibilním s kódováním klíč-hodnota. Klíče musí používat kódování ASCII, obvykle začínat malým písmenem a nesmí obsahovat prázdné znaky. V uvedeném příkladu Name by byla klíčovou hodnotou Name vlastnosti PersonModel třídy. Klíč a název vlastnosti, kterou zveřejňuje, nemusí být stejné, ale ve většině případů jsou.

Klíčovou cestou je řetězec oddělený tečkou, který slouží k určení hierarchie vlastností objektu pro procházení. Vlastnost prvního klíče v sekvenci je relativní vzhledem k přijímači a každý další klíč se vyhodnocuje relativně k hodnotě předchozí vlastnosti. Stejným způsobem, jak použijete notaci tečky k procházení objektu a jeho vlastností ve třídě C#.

Například pokud jste rozšířili PersonModel třídu a přidanou Child vlastnost:

using System;
using Foundation;

namespace MacDatabinding
{
    [Register("PersonModel")]
    public class PersonModel : NSObject
    {
        private string _name = "";
        private PersonModel _child = new PersonModel();

        [Export("Name")]
        public string Name {
            get { return _name; }
            set {
                WillChangeValue ("Name");
                _name = value;
                DidChangeValue ("Name");
            }
        }

        [Export("Child")]
        public PersonModel Child {
            get { return _child; }
            set {
                WillChangeValue ("Child");
                _child = value;
                DidChangeValue ("Child");
            }
        }

        public PersonModel ()
        {
        }
    }
}

Cesta ke klíči pro název podřízeného objektu by byla self.Child.Name nebo jednoduše Child.Name (na základě způsobu použití hodnoty klíče).

Získávání hodnot pomocí kódování klíč-hodnota

ValueForKeyMetoda vrátí hodnotu pro zadaný klíč (jako NSString ), relativní vzhledem k instanci třídy KVC, která přijímá požadavek. Například pokud Person je instancí PersonModel třídy definované výše:

// Read value
var name = Person.ValueForKey (new NSString("Name"));

To by vrátilo hodnotu Name vlastnosti pro tuto instanci PersonModel .

Nastavení hodnot pomocí kódování klíč-hodnota

Podobně SetValueForKey nastavte hodnotu pro zadaný klíč (jako NSString ), relativní vzhledem k instanci třídy KVC, která přijímá požadavek. Pak znovu s použitím instance PersonModel třídy, jak je znázorněno níže:

// Write value
Person.SetValueForKey(new NSString("Jane Doe"), new NSString("Name"));

By změnila hodnotu Name vlastnosti na Jane Doe .

Sledování změn hodnot

Pomocí zobrazení hodnoty klíč-hodnota (KVO) můžete připojit pozorovatele ke konkrétnímu klíči třídy kompatibilní s KVC a upozornit kdykoli na ni hodnotu pro tento klíč, a to buď pomocí technik KVC, nebo přímým přístupem k dané vlastnosti v kódu jazyka C#. Například:

// Watch for the name value changing
Person.AddObserver ("Name", NSKeyValueObservingOptions.New, (sender) => {
    // Inform caller of selection change
    Console.WriteLine("New Name: {0}", Person.Name)
});

Nyní, kdykoli se NamePerson změní vlastnost instance PersonModel třídy, nová hodnota je zapsána do konzoly.

Další informace najdete v úvodu od společnosti Apple až po Key-Value dodržování Průvodce programováním.

Datová vazba

V následujících částech se dozvíte, jak můžete použít kódování klíč-hodnota a kompatibilní třídu, která je znázorněná na klíčovém prostředí, pro svázání dat s prvky uživatelského rozhraní v Interface Builder Xcode namísto čtení a zápisu hodnot pomocí kódu jazyka C#. Tímto způsobem oddělíte datový model od zobrazení, která se používají k jejich zobrazení, takže je aplikace Xamarin. Mac pružnější a snazší. Také výrazně snížíte množství kódu, který je třeba zapsat.

Definování datového modelu

Než budete moct data svázat prvek uživatelského rozhraní v Interface Builder, musíte mít ve vaší aplikaci Xamarin. Mac definovanou třídu vyhovující KVC/KVO, která bude sloužit jako datový model pro vazbu. Datový model poskytuje všechna data, která se zobrazí v uživatelském rozhraní, a přijímá jakékoli úpravy dat, která uživatel provede v uživatelském rozhraní při spuštění aplikace.

Například pokud jste napsali aplikaci, která spravuje skupinu zaměstnanců, můžete k definování datového modelu použít tuto třídu:

using System;
using Foundation;
using AppKit;

namespace MacDatabinding
{
    [Register("PersonModel")]
    public class PersonModel : NSObject
    {
        #region Private Variables
        private string _name = "";
        private string _occupation = "";
        private bool _isManager = false;
        private NSMutableArray _people = new NSMutableArray();
        #endregion

        #region Computed Properties
        [Export("Name")]
        public string Name {
            get { return _name; }
            set {
                WillChangeValue ("Name");
                _name = value;
                DidChangeValue ("Name");
            }
        }

        [Export("Occupation")]
        public string Occupation {
            get { return _occupation; }
            set {
                WillChangeValue ("Occupation");
                _occupation = value;
                DidChangeValue ("Occupation");
            }
        }

        [Export("isManager")]
        public bool isManager {
            get { return _isManager; }
            set {
                WillChangeValue ("isManager");
                WillChangeValue ("Icon");
                _isManager = value;
                DidChangeValue ("isManager");
                DidChangeValue ("Icon");
            }
        }

        [Export("isEmployee")]
        public bool isEmployee {
            get { return (NumberOfEmployees == 0); }
        }

        [Export("Icon")]
        public NSImage Icon {
            get {
                if (isManager) {
                    return NSImage.ImageNamed ("group.png");
                } else {
                    return NSImage.ImageNamed ("user.png");
                }
            }
        }

        [Export("personModelArray")]
        public NSArray People {
            get { return _people; }
        }

        [Export("NumberOfEmployees")]
        public nint NumberOfEmployees {
            get { return (nint)_people.Count; }
        }
        #endregion

        #region Constructors
        public PersonModel ()
        {
        }

        public PersonModel (string name, string occupation)
        {
            // Initialize
            this.Name = name;
            this.Occupation = occupation;
        }

        public PersonModel (string name, string occupation, bool manager)
        {
            // Initialize
            this.Name = name;
            this.Occupation = occupation;
            this.isManager = manager;
        }
        #endregion

        #region Array Controller Methods
        [Export("addObject:")]
        public void AddPerson(PersonModel person) {
            WillChangeValue ("personModelArray");
            isManager = true;
            _people.Add (person);
            DidChangeValue ("personModelArray");
        }

        [Export("insertObject:inPersonModelArrayAtIndex:")]
        public void InsertPerson(PersonModel person, nint index) {
            WillChangeValue ("personModelArray");
            _people.Insert (person, index);
            DidChangeValue ("personModelArray");
        }

        [Export("removeObjectFromPersonModelArrayAtIndex:")]
        public void RemovePerson(nint index) {
            WillChangeValue ("personModelArray");
            _people.RemoveObject (index);
            DidChangeValue ("personModelArray");
        }

        [Export("setPersonModelArray:")]
        public void SetPeople(NSMutableArray array) {
            WillChangeValue ("personModelArray");
            _people = array;
            DidChangeValue ("personModelArray");
        }
        #endregion
    }
}

Většina funkcí této třídy byla pokryta v části co je kódování klíč-hodnota výše. Podívejme se ale na několik specifických prvků a některé dodatky, které udělali, aby tato třída fungovala jako datový model pro řadiče polí a řadiče stromové struktury (které budeme používat později pro zobrazení stromové strukturydat, zobrazení osnovy a zobrazení kolekcí).

Jako první, protože zaměstnanec může být manažerem, použil NSArray (a) (konkrétně NSMutableArray tak, aby bylo možné upravovat hodnoty) a umožnit jim, aby k nim byli připojeni zaměstnanci, kteří je spravují:

private NSMutableArray _people = new NSMutableArray();
...

[Export("personModelArray")]
public NSArray People {
    get { return _people; }
}

Tady si můžete všimnout dvou věcí:

1. Použili jsme NSMutableArray místo standardního pole nebo kolekce C#, protože to je požadavek na svázání dat s appkitu ovládacími prvky, jako jsou NSMutableArrayzobrazení, zobrazení osnovy a kolekce.
2. Vystavili jsme pole zaměstnanců tak, že je převedeme na NSArray datovou vazbu pro účely vazby dat a změnili jste jeho formátovaný název v jazyce C#, na to, People že datová vazba očekává, personModelArray ve tvaru NSArray (Všimněte si, že první znak byl proveden malými písmeny).

Dále je potřeba přidat některé speciálně pojmenující veřejné metody pro podporu řadičů polí a řadičů stromové struktury:

[Export("addObject:")]
public void AddPerson(PersonModel person) {
    WillChangeValue ("personModelArray");
    isManager = true;
    _people.Add (person);
    DidChangeValue ("personModelArray");
}

[Export("insertObject:inPersonModelArrayAtIndex:")]
public void InsertPerson(PersonModel person, nint index) {
    WillChangeValue ("personModelArray");
    _people.Insert (person, index);
    DidChangeValue ("personModelArray");
}

[Export("removeObjectFromPersonModelArrayAtIndex:")]
public void RemovePerson(nint index) {
    WillChangeValue ("personModelArray");
    _people.RemoveObject (index);
    DidChangeValue ("personModelArray");
}

[Export("setPersonModelArray:")]
public void SetPeople(NSMutableArray array) {
    WillChangeValue ("personModelArray");
    _people = array;
    DidChangeValue ("personModelArray");
}

Díky tomu mohou řadiče požadovat a upravit zobrazená data. Podobně jako výše vystavené NSArray mají velmi konkrétní konvence vytváření názvů (které se liší od typických konvencí vytváření názvů v jazyce C#):

• addObject: – Přidá objekt do pole.
• insertObject:in{class_name}ArrayAtIndex: – Kde {class_name} je název vaší třídy. Tato metoda vloží objekt do pole v daném indexu.
• removeObjectFrom{class_name}ArrayAtIndex: – Kde {class_name} je název vaší třídy. Tato metoda odebere objekt v poli v daném indexu.
• set{class_name}Array: – Kde {class_name} je název vaší třídy. Tato metoda umožňuje nahradit existující přenesenou novou.

Uvnitř těchto metod jsme zavedli změny do pole WillChangeValue a DidChangeValue zprávy pro KVO dodržování předpisů.

Nakonec, vzhledem k Icon tomu, že vlastnost závisí na hodnotě isManager vlastnosti, se změny isManager vlastnosti nemusí projevit v Icon prvcích uživatelského rozhraní vázaných na data (během KVO):

[Export("Icon")]
public NSImage Icon {
    get {
        if (isManager) {
            return NSImage.ImageNamed ("group.png");
        } else {
            return NSImage.ImageNamed ("user.png");
        }
    }
}

Chcete-li tento problém opravit, použijte následující kód:

[Export("isManager")]
public bool isManager {
    get { return _isManager; }
    set {
        WillChangeValue ("isManager");
        WillChangeValue ("Icon");
        _isManager = value;
        DidChangeValue ("isManager");
        DidChangeValue ("Icon");
    }
}

Všimněte si, že kromě vlastního klíče isManager přistupující objekt také posílá WillChangeValueDidChangeValue zprávy a pro klíč, aby se Icon zobrazila i tato změna.

V PersonModel celé zbývající části tohoto článku budeme používat datový model.

Jednoduchá datová vazba

S definovaným datovým modelem se podívejme na jednoduchý příklad vázání dat v Interface Builder Xcode. Řekněme například, že do naší aplikace Xamarin. Mac přidáte formulář, který se dá použít k úpravě PersonModel , kterou jsme definovali výše. Přidáme několik textových polí a zaškrtávací políčko pro zobrazení a úpravu vlastností našeho modelu.

Nejdřív přidáváme nový kontroler zobrazení do hlavního souboru . scénáře v Interface Builder a pojmenovat jeho třídu :

v dalším kroku se vraťte k Visual Studio pro Mac, upravte soubor SimpleViewController. cs (který se automaticky přidal do našeho projektu) a vystavte si instanci , kterou budeme na data svázat s formulářem. Přidejte následující kód:

private PersonModel _person = new PersonModel();
...

[Export("Person")]
public PersonModel Person {
    get {return _person; }
    set {
        WillChangeValue ("Person");
        _person = value;
        DidChangeValue ("Person");
    }
}

Po načtení zobrazení vytvoříme instanci našeho prvku PersonModel a naplníme ho tímto kódem:

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

    // Set a default person
    var Craig = new PersonModel ("Craig Dunn", "Documentation Manager");
    Craig.AddPerson (new PersonModel ("Amy Burns", "Technical Writer"));
    Craig.AddPerson (new PersonModel ("Joel Martinez", "Web & Infrastructure"));
    Craig.AddPerson (new PersonModel ("Kevin Mullins", "Technical Writer"));
    Craig.AddPerson (new PersonModel ("Mark McLemore", "Technical Writer"));
    Craig.AddPerson (new PersonModel ("Tom Opgenorth", "Technical Writer"));
    Person = Craig;

}

Nyní musíme vytvořit náš formulář, dvojitým kliknutím na hlavní soubor . scénáře ho otevřete pro úpravy v Interface Builder. Rozložení formuláře, aby vypadalo přibližně takto:

Chcete-li vytvořit datovou formu na formuláři PersonModel , který jsme prostřednictvím klíče vystavili Person , udělejte toto:

1. Vyberte textové pole název zaměstnance a přepněte se na inspektor vazby.

2. Zaškrtněte políčko vazba s a v rozevíracím seznamu vyberte možnost jednoduchý kontroler zobrazení . Další zadejte self.Person.Name pro self.Person.Name:

   

3. Vyberte textové pole povolání a zaškrtněte políčko vazba do a v rozevíracím seznamu vyberte možnost jednoduchý kontroler zobrazení . Další zadejte self.Person.Occupation pro self.Person.Occupation:

   koncovým koncovým bodem

4. Zaškrtněte políčko Zaměstnanec je vedoucí a zaškrtněte políčko vazba do a v rozevíracím seznamu vyberte možnost jednoduchý kontroler zobrazení . Další zadejte self.Person.isManager pro self.Person.isManager:

   

5. Vyberte pole počet zaměstnanců spravovaného textu a zaškrtněte políčko vazba do a v rozevíracím seznamu vyberte možnost jednoduchý kontroler zobrazení . Další zadejte self.Person.NumberOfEmployees pro self.Person.NumberOfEmployees:

   

6. Pokud zaměstnanec není manažer, chtěli bychom skrýt počet spravovaných popisků a textových polí zaměstnanců.

7. Vyberte položku počet spravovaných zaměstnanců popisek, rozbalte položku skryté turndown a zaškrtněte políčko vazba do a v rozevíracím seznamu vyberte možnost jednoduchý kontroler zobrazení . Další zadejte self.Person.isManager pro self.Person.isManager:

   

8. Vyberte NSNegateBoolean z rozevíracího seznamu NSNegateBoolean :

   

9. Tato vlastnost oznamuje datovou vazbu, že popisek bude skrytý, pokud je hodnota isManager vlastnosti false .

10. Opakujte kroky 7 a 8 pro počet spravovaných textových polí zaměstnanců.

11. uložte změny a vraťte se do Visual Studio pro Mac pro synchronizaci s Xcode.

Pokud aplikaci spustíte, hodnoty z Person Vlastnosti automaticky vyplní náš formulář:

formuláře

Všechny změny, které uživatel provede ve formuláři, se zapíší zpátky do Person vlastnosti v kontroleru zobrazení. Například zrušení výběru zaměstnance je vedoucí aktualizuje instanci našeho prvku PersonModel a PersonModel a textové pole je automaticky skrytý (prostřednictvím datové vazby):

Datová vazba zobrazení tabulky

Teď, když máme základní informace o vazbách dat, se podívejme na složitější úlohu vazby dat pomocí řadiče pole a datové vazby k zobrazení tabulky. Další informace o práci se zobrazeními tabulek najdete v dokumentaci k tabulkovým zobrazením .

Nejdřív přidáváme nový kontroler zobrazení do hlavního souboru . scénáře v Interface Builder a pojmenovat jeho třídu :

Teď provedeme úpravu souboru TableViewController. cs (který se automaticky přidal do našeho projektu) a zveřejňuje pole ( ) PersonModel tříd, na které budeme datově svázat formulář. Přidejte následující kód:

private NSMutableArray _people = new NSMutableArray();
...

[Export("personModelArray")]
public NSArray People {
    get { return _people; }
}
...

[Export("addObject:")]
public void AddPerson(PersonModel person) {
    WillChangeValue ("personModelArray");
    _people.Add (person);
    DidChangeValue ("personModelArray");
}

[Export("insertObject:inPersonModelArrayAtIndex:")]
public void InsertPerson(PersonModel person, nint index) {
    WillChangeValue ("personModelArray");
    _people.Insert (person, index);
    DidChangeValue ("personModelArray");
}

[Export("removeObjectFromPersonModelArrayAtIndex:")]
public void RemovePerson(nint index) {
    WillChangeValue ("personModelArray");
    _people.RemoveObject (index);
    DidChangeValue ("personModelArray");
}

[Export("setPersonModelArray:")]
public void SetPeople(NSMutableArray array) {
    WillChangeValue ("personModelArray");
    _people = array;
    DidChangeValue ("personModelArray");
}

Stejně jako u PersonModel třídy výše v části PersonModel jsme vystavili čtyři speciálně pojmenované veřejné metody, aby řadič pole a číst a zapisovat data z naší kolekce PersonModels .

Po načtení zobrazení musíme naplnit pole tímto kódem:

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

    // Build list of employees
    AddPerson (new PersonModel ("Craig Dunn", "Documentation Manager", true));
    AddPerson (new PersonModel ("Amy Burns", "Technical Writer"));
    AddPerson (new PersonModel ("Joel Martinez", "Web & Infrastructure"));
    AddPerson (new PersonModel ("Kevin Mullins", "Technical Writer"));
    AddPerson (new PersonModel ("Mark McLemore", "Technical Writer"));
    AddPerson (new PersonModel ("Tom Opgenorth", "Technical Writer"));
    AddPerson (new PersonModel ("Larry O'Brien", "API Documentation Manager", true));
    AddPerson (new PersonModel ("Mike Norman", "API Documenter"));

}

Nyní musíme vytvořit zobrazení tabulky, dvakrát klikněte na hlavní soubor. scénář a otevřete ho pro úpravy v Interface Builder. Rozložení tabulky, která vypadá přibližně takto:

Musíme přidat řadič pole k poskytnutí vázaných dat do tabulky, udělejte toto:

1. Přetáhněte řadič pole z inspektoru knihovny do editoru rozhraní:

   

2. V hierarchii rozhraní vyberte řadič pole a přepněte se na inspektor atributu:

   

3. Jako PersonModelPersonModelzadejte, klikněte na tlačítko plus a přidejte tři klíče. Pojmenujte je NameOccupation a isManager :

   

4. Tím se oznámí řadiči pole, co IT spravuje pole a které vlastnosti by se měly vystavovat (prostřednictvím klíčů).

5. Přepněte do nástroje pro kontrolu vazeb a v části pole obsahu vyberte možnost vytvořit vazbu k a kontroler zobrazení tabulky. Zadejte cestu k klíčovému modelu :

   ke klíči

6. Tím se řadič pole přihlásí k poli PersonModels , které jsme nastavili na našem kontroleru zobrazení.

Teď potřebujeme vytvořit vazby zobrazení tabulky k řadiči pole, udělejte toto:

1. Vyberte zobrazení tabulky a inspektor vazby:

   

2. V části obsah tabulky turndown vyberte vytvořit a řadič pole. arrangedObjectsDo pole arrangedObjects zadejte:

   

3. Vyberte buňku zobrazení tabulky pod sloupcem Zaměstnanec . V inspektoru vazeb pod hodnotou turndown vyberte vytvořit vazbu k zobrazení a buňky tabulky. Jako objectValue.Name cestu k objectValue.Namezadejte:

   

4. objectValue je aktuální PersonModel v poli spravovaném řadičem pole.

5. Vyberte buňku zobrazení tabulky pod sloupcem povolání . V inspektoru vazeb pod hodnotou turndown vyberte vytvořit vazbu k zobrazení a buňky tabulky. Jako objectValue.Occupation cestu k objectValue.Occupationzadejte:

   

6. uložte změny a vraťte se do Visual Studio pro Mac pro synchronizaci s Xcode.

Pokud aplikaci spustíme, tabulka se naplní podle našeho pole PersonModels :

zobrazení Osnova datové vazby

vazba dat na zobrazení osnovy je velmi podobná vazbě na zobrazení tabulky. Hlavním rozdílem je, že k poskytnutí vázaných dat do zobrazení osnovy použijeme kontroler stromu místo řadiče pole . Další informace o práci se zobrazeními osnovy najdete v dokumentaci k zobrazení osnovy .

Nejdřív přidáváme nový kontroler zobrazení do hlavního souboru . scénáře v Interface Builder a pojmenovat jeho třídu :

Teď provedeme úpravu souboru OutlineViewController. cs (který se automaticky přidal do našeho projektu) a zveřejňuje pole ( ) PersonModel tříd, na které budeme datově svázat formulář. Přidejte následující kód:

private NSMutableArray _people = new NSMutableArray();
...

[Export("personModelArray")]
public NSArray People {
    get { return _people; }
}
...

[Export("addObject:")]
public void AddPerson(PersonModel person) {
    WillChangeValue ("personModelArray");
    _people.Add (person);
    DidChangeValue ("personModelArray");
}

[Export("insertObject:inPersonModelArrayAtIndex:")]
public void InsertPerson(PersonModel person, nint index) {
    WillChangeValue ("personModelArray");
    _people.Insert (person, index);
    DidChangeValue ("personModelArray");
}

[Export("removeObjectFromPersonModelArrayAtIndex:")]
public void RemovePerson(nint index) {
    WillChangeValue ("personModelArray");
    _people.RemoveObject (index);
    DidChangeValue ("personModelArray");
}

[Export("setPersonModelArray:")]
public void SetPeople(NSMutableArray array) {
    WillChangeValue ("personModelArray");
    _people = array;
    DidChangeValue ("personModelArray");
}

Stejně jako u PersonModel třídy výše v části PersonModel jsme vystavili čtyři speciálně pojmenované veřejné metody, takže kontroler stromu a čtení a zápis dat z naší kolekce PersonModels .

Po načtení zobrazení musíme naplnit pole tímto kódem:

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

    // Build list of employees
    var Craig = new PersonModel ("Craig Dunn", "Documentation Manager");
    Craig.AddPerson (new PersonModel ("Amy Burns", "Technical Writer"));
    Craig.AddPerson (new PersonModel ("Joel Martinez", "Web & Infrastructure"));
    Craig.AddPerson (new PersonModel ("Kevin Mullins", "Technical Writer"));
    Craig.AddPerson (new PersonModel ("Mark McLemore", "Technical Writer"));
    Craig.AddPerson (new PersonModel ("Tom Opgenorth", "Technical Writer"));
    AddPerson (Craig);

    var Larry = new PersonModel ("Larry O'Brien", "API Documentation Manager");
    Larry.AddPerson (new PersonModel ("Mike Norman", "API Documenter"));
    AddPerson (Larry);

}

Nyní musíme vytvořit zobrazení osnovy, dvakrát klikněte na hlavní soubor. scénář a otevřete ho pro úpravy v Interface Builder. Rozložení tabulky, která vypadá přibližně takto:

Musíme přidat kontroler stromu pro poskytování vázaných dat naší osnově, postupujte následovně:

1. Přetáhněte řadič stromu z inspektoru knihovny do editoru rozhraní:

   

2. V hierarchii rozhraní vyberte kontroler stromu a přepněte se na inspektor atributů:

   

3. Jako PersonModelPersonModelzadejte, klikněte na tlačítko plus a přidejte tři klíče. Pojmenujte je NameOccupation a isManager :

   

4. Tím se řídicímu panelu zobrazí informace o tom, co spravuje pole a které vlastnosti by se měly vystavit (prostřednictvím klíčů).

5. V části kontroler stromu zadejte pro podřízené položky, do pole počet zadejte a zadejte . list:

   řadičům stromu

6. To oznamuje řadiči stromu, kde najít všechny podřízené uzly, kolik podřízených uzlů existuje a v případě, že má aktuální uzel podřízené uzly.

7. Přepněte se do nástroje pro kontrolu vazeb a v části pole obsahu vyberte vazba a vlastník souboru. Zadejte cestu k klíčovému modelu :

   

8. Tím se řadič stromu přihlásí k poli PersonModels , které jsme nastavili na našem řadiči zobrazení.

Nyní musíme vytvořit vazby zobrazení osnovy k řadiči stromové struktury, udělejte toto:

1. Vyberte zobrazení Osnova a v okně Kontrola vazeb vyberte:

   

2. V zobrazení Osnova obsahu turndown vyberte vytvořit a řadič stromu. arrangedObjectsDo pole arrangedObjects zadejte:

   

3. Vyberte buňku zobrazení tabulky pod sloupcem Zaměstnanec . V inspektoru vazeb pod hodnotou turndown vyberte vytvořit vazbu k zobrazení a buňky tabulky. Jako objectValue.Name cestu k objectValue.Namezadejte:

   

4. objectValue je aktuální PersonModel v poli spravovaném řadičem stromu.

5. Vyberte buňku zobrazení tabulky pod sloupcem povolání . V inspektoru vazeb pod hodnotou turndown vyberte vytvořit vazbu k zobrazení a buňky tabulky. Jako objectValue.Occupation cestu k objectValue.Occupationzadejte:

   

6. uložte změny a vraťte se do Visual Studio pro Mac pro synchronizaci s Xcode.

Pokud aplikaci spustíme, osnova se naplní naším polem z PersonModels :

Datová vazba zobrazení kolekce

Datová vazba se zobrazením kolekce je velmi podobná vazbě s tabulkovým zobrazením, protože se k poskytování dat pro kolekci používá řadič pole. Vzhledem k tomu, že zobrazení kolekce nemá nastavený formát zobrazení, je potřeba více práce, aby se zajistila zpětná vazba interakce s uživatelem a sledování výběru uživatele.

Ladění nativních havárií

Vytvoření chyby v datových vazbách může vést k nativnímu selhání v nespravovaném kódu a způsobit, že vaše aplikace Xamarin. Mac selže úplně, a dojde k chybě:

v

Při vytváření datových vazeb typicky existují čtyři hlavní příčiny nativních havárií:

1. Datový model nedědí od NSObject třídy nebo podtřídu NSObject .
2. Nezveřejnili jste vlastnost pro Objective-C použití [Export("key-name")] atributu.
3. Nedošlo k zalomení změn hodnoty přístupového objektu v WillChangeValueDidChangeValue voláních metody a (určení stejného klíče jako Export atributu).
4. V inspektoru vazby v Interface Builder máte nesprávný nebo nesprávně natypový klíč.

Dekódování havárie

Pojďme v naší datové vazbě způsobit nativní selhání, abychom mohli ukázat, jak ho vyhledat a opravit. V Interface Builder můžeme změnit naši vazbu prvního popisku v zobrazení kolekce z Name na Title :

pojďme tuto změnu uložit, přejít zpátky na Visual Studio pro Mac a synchronizovat se s Xcode a spustit naši aplikaci. když se zobrazí zobrazení kolekce, aplikace se v této chvíli zobrazí s SIGABRT chybou (jak je znázorněno ve SIGABRT v Visual Studio pro Mac), protože PersonModel nezveřejňuje vlastnost s klíčem Title :

Pokud se podíváme na velmi horní část chyby ve výstupu aplikace , může se vám zobrazit klíč k vyřešení problému:

chyb

Tento řádek nám oznamuje, že klíč Title neexistuje na objektu, ke kterému se odkazuje. Pokud změníme vazbu zpátky na Name v Interface Builder, uložíte, synchronizujete, znovu sestavíte a spustíte, aplikace se bude spouštět podle očekávání bez problémů.

Souhrn

V tomto článku se podrobně podíváme na práci s vytvářením datových vazeb a kódováním klíčových hodnot v aplikaci Xamarin. Mac. Nejprve se prohlédlo z Objective-C vystavení třídy jazyka C# pomocí kódování klíč-hodnota (KVC) a pozorování hodnoty klíč-hodnota (KVO). V dalším kroku jsme ukázali, jak použít třídu a data, která vyhovují KVO, na prvky uživatelského rozhraní v Interface Builderu Xcode. Nakonec ukázala složitou datovou vazbu pomocí řadičů polí a řadičů stromů.

Související odkazy

• Scénář MacDatabinding (ukázka)
• MacDatabinding XIBs (ukázka)
• Hello, Mac
• Standardní ovládací prvky
• Tabulková zobrazení
• Zobrazení osnovy
• Zobrazení kolekcí
• Průvodce programováním kódu pro kód hodnoty
• Úvod do Key-Value Pozorovatelská příručka pro programování
• Seznámení s tématy programování pro kakaové vazby
• Seznámení s odkazem na kakaové vazby
• NSCollectionView
• macOS – pokyny pro lidská rozhraní