NSObject Classe

Definição

[Foundation.Register("NSObject", true)]
public class NSObject : Foundation.INSObjectProtocol, IDisposable, IEquatable<Foundation.NSObject>

type NSObject = class
    interface INSObjectProtocol
    interface INativeObject
    interface IDisposable
    interface IEquatable<NSObject>

Herança

Object

NSObject

Derivado

Accounts.ACAccount

Accounts.ACAccountCredential

Accounts.ACAccountStore

Accounts.ACAccountType

AddressBookUI.ABNewPersonViewControllerDelegate

Mais…

Atributos

RegisterAttribute

Implementações

INSObjectProtocol INativeObject IDisposable IEquatable<NSObject>

Comentários

Essa é a classe base usada para associar classes Objective-C a classes C#. Apenas a subclasse de NSObject produzirá uma classe que pode ser passada para Objective-C.

A classe NSObject do C# e suas subclasses são representações gerenciadas das instâncias Objective-C subjacentes. O ponteiro para o objeto Objective-C de código não gerenciado é armazenado na Handle propriedade .

É importante observar que, atualmente, o compilador não dá suporte a subclasses genéricas de NSObject.

Registro de Classe

Quando você cria uma subclasse de NSObject, essa subclasse é registrada com o runtime Objective-C com um nome baseado no nome de tipo completo do .NET, que é um detalhe de implementação. Se você precisar garantir que uma classe C# seja exposta com um nome específico no runtime Objective-C, você poderá aplicar o T:ObjCRuntime.RegisterAttribute à classe e especificar o nome que deseja que sua classe tenha.

O acima normalmente é usado em casos em que você deseja fazer referência à classe por nome em algum código Objective-C, ao usar arquivos XIB e Storyboard do Construtor de Interfaces ou quando você estiver usando uma configuração de serialização Objective-C (por exemplo, ao usar NSCoder).

//
// This exposes the C# class _MySampleView as the Objective-C MyView
//
[Export ("MyView")]
public class _MySampleView : UIView {

}

Métodos Objective-C

Em geral, as classes MonoTouch mapeiam uma para uma para as classes Objective-C subjacentes. Por exemplo, a classe C# "MonoTouch.Foundation.NSObject" é mapeada para a classe Objective-C "NSObject". Mas os métodos são diferentes. Os métodos Objective-C não se traduzem bem em métodos C#, portanto, eles foram, em geral, alterados para corresponder à linguagem C#, aos idiomas C# e às diretrizes de design do .NET Framework.

Os métodos Objective-C são apresentados ao C# como métodos virtuais que têm o T:ObjCRuntime.ExportAttribute especial aplicado a eles. Esse atributo é usado pelo compilador para mapear nomes C# para nomes Objective-C. Esses atributos são mostrados na documentação da API sobre cada função, para ajudá-lo a identificar qual método Objective-C um método C# específico está chamando.

Para alterar o comportamento de uma classe, use os idiomas padrão do C#: crie uma subclasse e substitua os métodos que deseja alterar e usar a "base". recurso de linguagem para chamar opcionalmente em sua classe base.

public class MyView : UISlider {
	public override void Draw (RectangleF rect)
	{
		// Let the base class draw first
		base.Draw (rect);

		// Our custom code
		var ctx = UIGraphics.GetCurrentContext ();
		UIColor.Gray.SetColor ();
		ctx.StrokeEllipseInRect (rect);
	}
}

Por padrão, somente os métodos que foram substituídos serão expostos ao mundo Objective-C. Se você quiser expor um método C# arbitrário ao mundo Objective-C, será necessário aplicar o T:ObjCRuntime.ExportAttribute ao seu método público. E isso pode ser feito com métodos estáticos e de instância. Depois que o atributo for aplicado, o método será exposto a Objective-C e as operações de marshalling de tipo de dados padrão compatíveis com o runtime serão disponibilizadas para esses métodos.

//
// Exposes the class StringUtilities to Objective-C with the 
// method:
//    - (NSString *) joinArray:(NSArray *) stringArray withSeparator:(NSString *sep);
//
// Used like this:
//   id utilities = [[StringUtilities alloc] init];
//   NSLog (@"Joined: %@", [utilities joinArray:users withSeparator:@", "]);
//
public class StringUtilities : NSObject {
	[Export ("joinArray:withSeparator:")]
	public string Join (string [] array, string separator)
	{
		return string.Join (separator, array);
	}
}

Ciclo de vida

O NSObject C# e suas subclasses são wrappers gerenciados para o objeto Objective-C subjacente. Eles são criados a partir de C#, quando você cria uma nova instância usando o operador "novo" ou quando um objeto não gerenciado existente é exibido para o mundo C#.

Quando você cria um objeto do C# usando o operador "new", o objeto inicialmente pertencerá ao C#e o C# manterá uma referência ao objeto . Essa referência só será descartada quando o coletor de lixo determinar que não há referências gerenciadas pendentes a ela ou quando você chamar manualmente o método Dispose no objeto .

NSObjects C# também são criados sob demanda quando você invoca um método ou uma propriedade que retorna um NSObject. Neste ponto, o runtime examinará um cache de objetos e determinará se um determinado Objective-C NSObject já foi exibido para o mundo gerenciado ou não. Se o objeto tiver sido exibido, o objeto existente será retornado, caso contrário, um construtor que usa um IntPtr como um parâmetro é invocado para construir o objeto.

Os "pares" puros para objetos de estrutura (aqueles que são meramente representações C# de um objeto Objective-C e não têm nenhum estado associado gerenciado extra) podem ser recriados pelo runtime sob demanda usando o construtor mencionado antes.

As subclasses de usuário de NSObjects geralmente contêm o estado C#, portanto, sempre que o runtime Objective-C executa uma operação de "retenção" em um desses objetos, o runtime cria um GCHandle que mantém o objeto gerenciado ativo, mesmo que não haja referências visíveis de C# ao objeto. Isso simplifica muito a reserva, pois o estado será preservado automaticamente para você.

A operação Dispose em um NSObject sempre removerá a referência ao objeto Objective-C subjacente, mas não destruirá o estado gerenciado, isso só acontecerá quando o código gerenciado e o código não gerenciado tiverem ambos liberado os objetos. Isso é um pouco diferente do .NET, pois no .NET depois que um objeto é descartado, não é possível invocar nenhum método no objeto, pois ele é considerado inútil. Esse não é o caso de NSObjects.

Adotando protocolos

No MonoTouch, a maioria dos protocolos Objective-C são mapeados para classes que têm o T:ObjCRuntime.ModelAttribute aplicado a eles. E a maneira como você adota um protocolo é subclasse e substituição dos métodos que deseja adotar.

Há alguns casos raros em que você deseja adotar um protocolo ad hoc por conta própria. Se você precisar adotar um protocolo Objective-C, deverá usar o AdoptsAttribute em sua classe e fornecer o nome do protocolo que deseja adotar. Normalmente, ao adotar um protocolo, você também precisará listar todos os seletores Objective-C que você está adotando usando o T:ObjCRuntime.ExportAttribute.

[Adopts ("NSLocking")]
public class MyLockeingObject : NSObject {
	[Export ("lock")]
	public void Lock ()
	{
		// ...
	}

	[Export ("unlock")]
	public void Unlock ()
	{
		// ...
	}
}

Codificação de valor de chave

A codificação key value é um mecanismo que permite acessar as propriedades de um objeto pelo nome, em vez de acessá-las diretamente com um método C#.

Para expor uma propriedade C# ao sistema de codificação Key-Value tudo o que você precisa fazer é adicionar t T:ObjCRuntime.ExportAttribute à sua propriedade. Os nomes devem conter apenas caracteres ASCII, começar com uma letra minúscula e não devem conter espaços.

public class CircleLayer : CALayer {
	[Export ("radius")]
	public double Radius { get; set; }

	// ...
}

Use os métodos M:Foundation.ValueForKey(Foundation.NSString);* para pesquisar uma propriedade usando um nome e usar as funções M:Foundation.SetValueForKey(Foundation.NSObject, Foundation.NSString);*" para definir o valor da propriedade especificada. Por exemplo, você pode chamar foo. ValueForKey ("user") para obter o valor da propriedade de usuário em um objeto .

Além disso, você pode usar caminhos de chave para que o runtime chame repetidamente ValueForKey ou SetValueForKey para você. Você separa as chaves usando um ponto. Por exemplo, o keypath "user.address.phone.mobile" solicitaria a propriedade do usuário e, em seguida, solicitaria a propriedade de endereço no usuário e, em seguida, solicitaria a propriedade do telefone no endereço e, por fim, solicitaria a propriedade móvel no telefone e finalmente usaria o resultado como o valor. Você usa o M:Foundation.ValueForKeyPath(Foundation.NSString);* para pesquisar uma propriedade usando um keypath, e você usa o M:Foundation.SetValueForKeyPath(Foundation.NSObject, Foundation.NSString);* para definir um valor usando um keypath.

Ao usar keypaths, se uma pesquisa falhar, o SetValueForUndefinedKey(NSObject, NSString) será invocado ao definir um valor e o ValueForUndefinedKey(NSString) será invocado ao pesquisar um valor. Por padrão, ambos os métodos geram uma exceção Objective-C, você pode alterar esse comportamento substituindo os métodos.

Observação do valor da chave

A observação de valor de chave é um mecanismo implementado pelo NSObject que pode ser usado para monitorar alterações feitas em um NSObject por meio do sistema de Codificação de Valor de Chave.

Para que sua classe observe uma notificação, você deve substituir o ObserveValue(NSString, NSObject, NSDictionary, IntPtr) método que será invocado com as informações sobre as alterações de valor para um keypath específico. Em seguida, você usa o AddObserver(NSObject, NSString, NSKeyValueObservingOptions, IntPtr) para começar a observar as alterações e o RemoveObserver(NSObject, NSString, IntPtr) método para parar de receber notificações.

Construtores

Campos

Propriedades

Métodos

Métodos de Extensão

Aplica-se a

Confira também

• Documentação da Apple para NSObject