Read this article in your language | | |

Nella prima parte di questa mini serie abbiamo visto cos'è e come funziona, in maniera molto basilare, un'estensione di BlogEngine. In questa seconda parte tratteremo i Settings relativi alle estensioni che scriviamo.

Per imparare ad utilizzare i Settings nelle nostre estensioni amplieremo l'esempio della prima parte. Daremo dunque la possibilità all'utente di scegliere se impostare il testo del nostro post in caratteri maiuscoli, minuscoli o lasciarlo inalterato. Di seguito vi mostro il codice e poi andrò a spiegarlo in dettaglio.

   1: #region Using

   2:  

   3: using System;

   4: using BlogEngine.Core.Web.Controls;

   5: using BlogEngine.Core;

   6:  

   7: #endregion

   8:  

   9: #region Code

  10:  

  11: /// <summary>

  12: /// Simple HelloWorld Extension. Make your post body UpperCase

  13: /// </summary>

  14: [Extension("HelloWorldExt", "1.0", "dextr")]

  15: public class HelloWorldExt

  16: {

  17:     // ExtensionSettings used to manage the settings of our extension

  18:     static protected ExtensionSettings _settings = null;

  19:  

  20:     public HelloWorldExt()

  21:     {

  22:         Post.Serving += new EventHandler<ServingEventArgs>(ServingHandler);

  23:         InitSettings();

  24:     }

  25:  

  26:     private void ServingHandler(object sender, ServingEventArgs e)

  27:     {

  28:         if (_settings.GetSingleValue("Case") == "upper")

  29:         {

  30:             // The Body of our post is rendered in UPPER case

  31:             e.Body = e.Body.ToUpper();

  32:         }

  33:         else if (_settings.GetSingleValue("Case") == "lower")

  34:         {

  35:             // The Body of our post is rendered in LOWER case

  36:             e.Body = e.Body.ToLower(); 

  37:         }

  38:         else if (_settings.GetSingleValue("Case") == "normal")

  39:         { 

  40:             // Do Nothing. The Body of our post is rendered normally

  41:         }

  42:  

  43:     }

  44:  

  45:     private void InitSettings()

  46:     {

  47:         ExtensionSettings settings = new ExtensionSettings(this);

  48:         settings.IsScalar = true;

  49:         settings.AddParameter("Case");

  50:         settings.AddValue("Case", "upper");

  51:         _settings = ExtensionManager.InitSettings("HelloWorldExt", settings);

  52:     }

  53:  

  54: }

  55:  

  56: #endregion

Per lavorare con i Settings dobbiamo prima di tutto dichiare un oggetto ExtensionSettings. Esso è capace di gestire le impostazioni dei Settings. Qundi di leggerli e scriverli.
Dopo averlo dichiarato andremo a creare un metodo che verrà richiamato ogni volta che viene avviata l'estensione che controllerà i Settings, nel nostro caso è il metodo InitSettings. Questo metodo inizializza l'oggeto ExtensionSettings passandogli il riferimento alla classe che definisce l'estensione. Imposta tramite la proprietà IsScalar se il nostro paremtro è un parametro scalare o meno; questo significa se è un parametro singolo o se sono una serie di parametri. Nel nostro caso tale proprietà è impostata a True perchè vogliamo un singolo parametro. Aggiungiamo poi il parametro e secondariamente gli impostiamo il valore di default tramite AddValue. Inizializziamo infine i Settings tramite l'ExtensionManager. I due parametri che richiede tale metodo sono semplicemente il nome della nostra estensione ed i valori dei settaggi veri e propri che sono salvati nell'oggetto settings. L'ultima modifica da fare è quella di andare nel costruttore della nostra estensione e come ultima istruzione richiamare il metodo InitSettings. Per ovvi motivi nel nostro handler dell'evento scatenante, e cioè nel metodo ServingHandler, dovremo andare a leggere i valori dei Settings ed eseguire la giusta azione in base al settaggio prescelto. Nel nostro semplicissimo caso abbiamo tre possibilità: Case = upper, Case = lower, Case = normal. Tale valore, se la nostra estensione funziona correttamente, lo andremo a impostare direttamente in una textbox che sarà "magicamente" apparsa nella pagina dei Settings dell'estensione.

Verifichiamo il funzionamento dell'estensione

Come dicevo poche righe fa se l'estensione funziona in maniera corretta avremo la seguente situazione a disposizione nella lista delle estensioni installate. Cliccando sulla voce Modifica che si trova alla fine della riga, andremo direttamente alla pagina che ci permette di impostare i Settings della nostra estensione.

In questa pagina avremo a disposizione una semplice textbox che ci permette di impostare il valore della proprietà Case. Se facciamo qualche prova con i vari valori che possiamo inserire vedremo i tre risultati diversi.

Case = normal	Case = upper	Case = lower

Come mostrano le immagini l'estensione di volta in volta si comporta in maniera diversa. E come sempre è tutto davvero semplice!!

Addentriamoci un pò in qualche dettaglio avanzato.

Sicuramente mentre leggete vi starete dicendo "Ok, ma se io devo mettere dieci parametri? E se questi dieci parametri hanno valori differenti, e non voglio usare solo le caselle di testo? E' possibile?". Beh è ovvio che è possibile. Dovete sapere che BlogEngine supporta una serie di valori per le estensioni e come per il campo di testo precedente esso genera in maniera automatica i vari controlli che servono per gestire tali valori.

Prima di tutto direi che è d'obbligo una lista dei valori possibili:

• Stringa - ParameterType.String
• Booleano (checkbox singola) - ParameterType.Boolean 
• Intero - ParameterType.Integer
• Intero Lungo - ParameterType.Long
• Float - ParameterType.Float
• Double - ParameterType.Double
• Decimal - ParameterType.Decimal
• Dropdown - ParameterType.DropDown 
• ListBox - ParameterType.ListBox
• RadioGroup - ParameterType.RadioGroup

Per capire al meglio come utilizzare tutti questi valori direi che è dobbligo un secondo esempio. Al solito prima il codice e poi la spiegazione.

   1: #region Using

   2:  

   3: using System;

   4: using BlogEngine.Core.Web.Controls;

   5: using BlogEngine.Core;

   6: using System.Collections.Generic;

   7: using System.Collections.Specialized;

   8:  

   9: #endregion

  10:  

  11: #region Code

  12:  

  13: [Extension("MultiParamExt", "1.0", "<a href=\"http://espertini.com\">dextr</a>")]

  14: public class MultiParamExt

  15: {

  16:     static protected ExtensionSettings _settings = null;

  17:  

  18:     public MultiParamExt()

  19:     {

  20:         Comment.Serving += new EventHandler<ServingEventArgs>(Post_CommentServing);

  21:         InitSettings();

  22:     }

  23:  

  24:  

  25:     private void Post_CommentServing(object sender, ServingEventArgs e)

  26:     {

  27:         Comment comment = (Comment)sender;

  28:         if (comment.Author != "typetest")

  29:             return;

  30:  

  31:         foreach (ExtensionParameter p in _settings.Parameters)

  32:         {

  33:             if (string.IsNullOrEmpty(p.SelectedValue))

  34:                 e.Body += "<br/>" + p.Name + ": " + p.Values[0];

  35:             else

  36:                 e.Body += "<br/>" + p.Name + ": " + p.SelectedValue;

  37:         }

  38:     }

  39:  

  40:     private void InitSettings()

  41:     {

  42:         ExtensionSettings settings = new ExtensionSettings(this);

  43:         settings.IsScalar = true;

  44:  

  45:         // define parameters

  46:         settings.AddParameter("TheString");

  47:         settings.AddParameter("TheBoolean", "The boolean");

  48:         settings.AddParameter("TheInteger", "The integer", 10);

  49:         settings.AddParameter("TheLong", "The Long", 20, false);

  50:         settings.AddParameter("TheFloat", "The Float", 10, false, false, ParameterType.Float);

  51:         settings.AddParameter("TheDouble", "The Double", 15, false, false, ParameterType.Double);

  52:         settings.AddParameter("TheDecimal", "The Decimal", 20, false, false, ParameterType.Decimal);

  53:  

  54:         // lists

  55:         settings.AddParameter("TheDropdown");

  56:         settings.AddParameter("TheListBox", "The ListBox", 20, false, false, ParameterType.ListBox);

  57:         settings.AddParameter("TheRadioGroup", "The RadioGroup", 20, false, false, ParameterType.RadioGroup);

  58:  

  59:         // set default values

  60:         settings.AddValue("TheString", "Test string");

  61:         settings.AddValue("TheBoolean", true);

  62:         settings.AddValue("TheInteger", 25);

  63:         settings.AddValue("TheLong", 9223372036854);

  64:         settings.AddValue("TheFloat", 25.7);

  65:         settings.AddValue("TheDouble", 523456789.35);

  66:         settings.AddValue("TheDecimal", decimal.Parse("9223372036854342342.345"));

  67:  

  68:         // lists

  69:         StringCollection dd = new StringCollection();

  70:         dd.AddRange(new string[] { "One", "Two", "Three" });

  71:         settings.AddValue("TheDropdown", dd, "Three");

  72:         settings.AddValue("TheListBox", new string[] { "List1", "List2", "List3" }, "List2");

  73:         settings.AddValue("TheRadioGroup", new string[] { "Radio1", "Radio2", "Radio3" }, "Radio1");

  74:  

  75:         _settings = ExtensionManager.InitSettings(this.GetType().Name, settings);

  76:     }

  77:  

  78: }

  79:  

  80: #endregion

Come si nota dal codice, il nostro nuovo esempio, utilizza l'evento CommentServing per mostrarci i valori dei vari parametri. Ma li mostrerà solo ed esclusivamente se il nome dell'autore del commento è uguale al valore typetest altrimenti l'estensione non verrà eseguita.

Notiamo nel metodo InitSettings come sia semplice impostare i valori dei Settings e come impostargli il tipo. Prestando attenzione possiamo vedere che se non tipizziamo il parametro il core di BlogEngine sarà in grado di tipizzarlo in maniera del tutto automatica grazie al riconoscimento del tipo di parametro che noi gli passiamo. Nell'esempio possiamo prendere in considerazione il valore del parametro TheBoolean, TheString e TheInteger che vengono tipizzati all'assegnazione dei valori di default. Semplice e pulito non pensate?

Le due immagini che seguono presantano la parte di assegnazione dei parametri ed il risultato nella preview del nostro commento.

Un ultimo appunto, ma non per questo meno importante, è la possibiltà di recuperare un parametro in maniera tipizzata. Per esempio se vogliamo recuperare il valore di un intero scriveremo:

   1: int i = int.Parse(p.Values[0]);

Bene, anche la seconda parte del mini tutorial si è conclusa. Spero di essere stato chiaro. Nella prossima parte parleremo dell'ExtensionManager di BlogEngine e di come utlizzarlo al meglio.