Creare Classi Statiche e Singleton in Objective C

Lascia una risposta

Per creare una classe che sia raggiungibile da ogni parte del nostro codice, abbiamo due alternative: realizzare una classe statica con metodi e attributi statici, oppure implementare il pattern del Singleton.
Preferisco generalmente la seconda scelta più orientata ad un design pulito del nostro codice e rimanendo legato alla programmazione ad oggetti.

Per creare una classe statica, con attributi e metodi statici definiamo l’interfaccia:

1
2
3
4
@interface MyStaticClass : NSObject
+ (int)getIntMethod;
+ (void)setIntMethod:(int)value;
@end

e poi implementiamola:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#import "MyStaticClass.h"

@implementation MyStaticClass

static int staticValue = 1;

+ (int)getIntMethod {
  return staticValue;
}

+ (void)setIntMethod:(int)value {
  staticValue = value;
}

+ (id)alloc {
  [NSException raise:@"Non può essere istanziata format:@"Static class 'ClassName' non può essere instanziato"];
  return nil;
}

@end

importante l’override dell’alloc per non permettere alla classe di essere istanziata.

Per un approccio più elegante e sicuramente più riusabile, implementiamo invece il Design Pattern del Singleton:

1
2
3
4
5
6
7
8
9
@interface MySingleton : NSObject
{
}
-(int)getIntMethod;
-(void)setIntMethod:(int)value;

+ (MySingleton *) m_MySingleton;
 
@end

Implementiamo la nostra interfaccia:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#import "MySingleton.h"
 
@implementation MySingleton
 
static MySingleton *m_MySingleton =nil;
static int staticValue = 1;


+ (MySingleton *) m_MySingleton
{
  if (m_MySingleton == nil)
  {
    //creo l'istanza
    m_MySingleton = [[super allocWithZone:NULL] init];
  }
  return m_MySingleton;
}
 
- (int)getIntMethod {
  return staticValue;
}

- (void)setIntMethod:(int)value {
  staticValue = value;
}
+ (id)allocWithZone:(NSZone *)zone
{
 //sincronizzo in modo da rendere la fase di allocazione ThreadSafe
 //in modo da gestire più thread che richiedono contemporaneamente il Singleton
 @synchronized(self)
 {
   if (m_MySingleton == nil)
   {
     m_MySingleton = [super allocWithZone:zone];
     return m_MySingleton;
   }
 }
 return nil;
}
 
- (id)copyWithZone:(NSZone *)zone
{
 //non e' possibile clonarlo e quindi ritorna sempre la stessa istanza.
 return self;
}
 
- (id)retain
{
 return self;
}
 
- (NSUInteger)retainCount
{
 //in questo modo il suo refCount non scenderà mai a zero.
 return NSUIntegerMax;
}
 
- (void) release
{
  //non fa nulla.
}
 
- (id)autorelease
{
 return self;
}
 
@end

Piccola correzione. I metodi nel singleton ovviamente non devono essere statici (tranne il metodo che permette l’accesso all’istanza).

G.r.a. Capitolo 6: Il miglio verde

Lascia una risposta

E’ quello che ti frega.
Quello che ti illude.
Quell’ultima fottuta chilometrata e mezza o giu di li..
un solo miglio..
il miglio verde..l’ultimo tratto di strada, due fottuti chilometri scarsi, che ti separano dal punto di contatto Tango, il Target.. il bersaglio, la destinazione finale.. generalmente coincidente con un pallosissimo ma retribuito posto di lavoro in cui non riesci a dare il meglio di te stesso, se non in bagno.

Dopo essere partiti da casa base, e aver transitato per Alpha 24 (la spettacolare opera antagonista della viabilità chiamata a24), Charlie 1.80 (il casello e il suo fottuto costo), e aver costeggiato tutta la Echo 80 (il raccordo), fino all’uscita Lima 25 (la cazzosissima uscita Laurentina), ti trovi dinanzi al muro della morte. Se fossi in un blindato ONU alla ricerca di superstiti senzienti in questo mondo di zombie da traffico, adesso mi attaccherei alla radio gridando “Fuori Fuori Fuori.. Contatto Sierra Rosso Fuori a destra”.. Cercando di evitare quel cazzo di semaforo perennemente rosso all’inizio di Via Laurentina appena usciti dal raccordo..
Ma dalla base mi risponderebbe quell’occhialuto del cazzo che risponde al nome di Jolly Bravo Hotel che con voce alla Ralph di Happy Days mi intimerebbe di andare avanti verso Tango ,che sta per scadere il tempo di contatto a disposizione, prima che passino le 6.45 Zulu (le 7.45 italiane).
E cosi armato di pazienza, metto in coda il blindato, armando gli spara imprecazioni di costruzione bulgara, e gli scudi antiscommessa con tecnologia israeliana. Questi ultimi sono un meccanismo unico nel suo genere, in grado di evitare di fare pronostici sull’orario di arrivo, puntualmente sovvertito dalla polarità avversa della sfiga.

Evito un Sierra November Charlie , una svolta non conforme, e tra un Papa in idle (un pedone frastornato in mezzo alla strada), e un Mike 150 (uno scooter con motorizzazione indecisa) , arrivo finalmente a Tango, in perfetto orario. Non sono un papero e non salverò il mondo, ma anche oggi il mio blindato Renault 1200 del 98 mi ha portato sano e salvo a destinazione.. Partono le note dell’HomeRun, da casa base arrivano i complimenti, e un “ci sentiamo tra 9 ore ,Kilo (pare fatto apposta che pure il mio soprannome in alfabeto nato sia in sovrappeso), passo e chiudo”..
Tiro su la felpa con il camo da ufficio, cerco un posto dove nascondere il blindato, lo mimetizzo (mettendo vecchie multe sul parabrezza), lo sporco un po per nasconderlo agli indigeni del luogo, e mi incammino, a testa bassa, per difendere ancora una volta, con dignità, la mia postazione..

Estendere il WebClient per gestire un CookieStore

Lascia una risposta

In C# , le system.net mettono a disposizione un oggetto chiamato WebClient per fare delle chiamate http in post a risorse identificate da un URI.

Nel mio caso l’ho utilizzato per fare delle chiamate dal CodeBehind di un applicazione web, per interrogare dei servizi web esposti in maniera restfull che accettavano dati in POST.

Dovendo gestire la sessione con questi servizi di backend e a volte avendo la necessità di dovergli pasare dei Cookie di autenticazione o altri cookie , mi sono trovato a doverlo estendere (per non lavorare direttamente con il WebRequest, oggetto su cui poggia il WebClient).

Il webclient offre pochissime funzionalità, ma estenderlo è molto facile.

In questo esempio aggiungiamo la possibilità di creare un proprio CookieStore, prima di una chiamata, in modo da potergli passare tutti i cookie (presi ad esempio dalla Request arrivata alla nostra pagina aspx) necessari al servizio che risponde all’URI interrogata.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
using System;

using System.Net;

using System.Web;

public class ExtendedWebClient : WebClient

{

    private CookieContainer m_container = new CookieContainer();

    protected override WebRequest GetWebRequest(Uri address)

    {

        WebRequest request = base.GetWebRequest(address);
        HttpWebRequest webRequest = request as HttpWebRequest;
        if (webRequest!=null){
            webRequest.CookieContainer = m_container;
        }
        return request;
    }

    public void SetCookies(HttpCookieCollection collection,string domain){
        m_container = new CookieStore();
        for (int j=0;j<collection.Count;j++){
            HttpCookie httpCookie = collection.Get(j);
            Cookie cookie = new Cookie();
            cookie.Domain = domain;
            cookie.Expires = httpCookie.Expires;  
            cookie.Name = httpCookie.Name;
            cookie.Path = httpCookie.Path;
            cookie.Secure = httpCookie.Secure;
            cookie.Value = httpCookie.Value;
            m_container.Add(cookie);
        }
    }
}

Oltre a gestire il cookieStore, dobbiamo preoccuparci della conversione dei cookies da HttpCookie (arrivati dalla Request) a quelli più dettagliati della System.Net.

Per utilizzare il nostro nuovo webclient e passargli i cookie possiamo fare in questo modo:

1
2
3
4
5
    ExtendendWebClient client = new ExtendedWebClient();
    client.SetCookies(request.Cookies,request.Url.Host);
    byte[] data = client.DownloadData("http://www.google.it");
    System.Text.Encoding enc = System.Text.Encoding.UTF8;
    string output = enc.GetString(data);

In questo modo tutti i cookie vengono impostati nel webclient prima di eseguire la webRequest.

Giocando con il parametro Domain, possiamo andare a filtrare i cookie che ci interessano per la chiamata in questione.