Conversione tra intero ed esadecimale [c#]

In questo post vediamo le varie modalità con cui si può convertire un valore numerico intero nel corrispondente esadecimale in c#.

Convertire un Intero in un Esadecimale in c#

Metodo Convert.ToString
Il primo metodo è quello di usare il metodo integrato Convert.ToString  specificando il valore da convertire e la base da utilizzare.
Di seguito un esempio :

using System;

public class Example
{
    public static void Main()
    {
        int value = 1000;
        int toBase = 16;

        string hex = Convert.ToString(value, toBase);
        Console.WriteLine(hex);
    }
}

/*
    Output: 3e8
*/

Metodo Int32.ToString
Il metodo successivo è quello di usare il metodo ToString   in questo caso della classe Int32 (ma presente quasi tutti i tipi) specificando il formato da utilizzare.

Nel nostro caso dovremo usare l’identificatore di formato numerico standard esadecimale “X” o “x”.
Di seguito un esempio :

using System;

public class Example
{
    public static void Main()
    {
        int value = 1000;

        string specifier = "X";
        string hex = value.ToString(specifier);
        Console.WriteLine(hex);
    }
}

/*
    Output: 3E8
*/

Metodo String.Format
Un ulteriore metodo sfrutta la classe String e precisamente il metodo Format.

using System;

public class Example
{
    public static void Main()
    {
        int num = 1000;

        string hex = String.Format("{0:X}", num);
        Console.WriteLine(hex);
    }
}

/*
    Output: 3E8
*/

 

Convertire un esadecimale in un numero Intero in c#

I metodi usati sono gli analoghi dei precedenti richiamati con gli opportuni parametri.

Metodo Int32.Parse

using System;

public class Example
{
    public static void Main()
    {
        string hex = "3E8";
        int value = Int32.Parse(hex, System.Globalization.NumberStyles.HexNumber);

        Console.WriteLine(value);
    }
}

/*
    Output: 1000
*/

 

Metodo Convert.ToInt32

using System;

public class Example
{
    public static void Main()
    {
        string hex = "3E8";
        int value = Convert.ToInt32(hex, 16);

        Console.WriteLine(value);
    }
}

/*
    Output: 1000
*/

Casting in [C#]: implicit, explicit e utilizzo delle keyword as e is

c sharp

In C#, ma in genere in tutti i linguaggi di programmazione che lo permettono, il casting è un operazione che consente di convertire un valore di un determinato tipo in un altro tipo di dati in modo che possa essere utilizzato in un calcolo o metodo o in qualsiasi altra situazione in cui il tipo di dati corrente del valore non è adatto.

Conversioni Implicite ed esplicite

La conversione dei tipi di dati forniti dal casting può essere implicita o esplicita. Un cast implicito si verifica automaticamente quando è stato definito un operatore di conversione implicito e i due tipi di dati sono compatibili.

Un cast esplicito viene utilizzato quando i due tipi di dati non sono completamente compatibili e richiede il prefisso del tipo di origine con un operatore di cast. Questo operatore è il tipo di dati desiderato racchiuso tra parentesi ().

L’esempio seguente mostra  le conversioni utilizzando cast impliciti ed espliciti per tipi di dati numerici di base.

Nota il requisito per l’operatore di cast per la seconda conversione.

uint integer = 100;
long longInteger;
 
// Implicit cast
longInteger = integer;
 
// Explicit cast
integer = (uint)longInteger;

Con le classiche conversioni viste fin ora se il cast fallisce, viene generata un’eccezione che può essere gestita o meno a secondo delle esigenze.

Utilizzo della keyword as

In c# è comunque possibile gestire la conversione di tipi con la keyword as.

Utilizzando la keyword as se la conversione di tipo non va a buon fine, viene restituito un null, che può essere verificato ed evitare che venga generata un’eccezione. E’ evidente che questa metodologia può essere utiliizata solo con  i tipi a cui è possibile assegnare un valore null.

Il concetto di tipo di dato nullable è stato introdotto a partire da .NET 2.0. Poiché a questi tipi è possibile assegnare un valore nullo, sono validi per l’uso con la keyword as.

// Esempio di conversione explicit  generica
private void button1_Click(object sender, EventArgs e)
{
    Button button = (Button)sender; // explicit cast here
    button.Text = "Processing...";
}

In questo esempio se la variabile sender non è di tipo Button il sistema non sa come gestirla e viene generata una eccezione InvalidCastException.

// Conversione usanto as
private void button1_Click(object sender, EventArgs e)
{
    Button button = sender as Button;

    if (button != null)
    {
        button.Text = "Processing...";
    }
    else
    {
        //Do what you need to do here
    }
}

In questo caso si dice al compilatore di considerare la variabile sender come un Button e di assegnarla alla variabile button.

Tuttavia in questo caso se sender è di un tipo non compatibile con button, l’assegnazione a button verrà assegnato il valore null.

Utilizzo della keyword is

Un altro modo per evitare problemi di casting è l’utilizzo della keyword is.

Questa parola chiave permette di stabilire il tipo di dato con cui si ha a che fare prima di utilizzarlo prevenendo quindi eventuali problematiche.

Rimanendo nello stesso esempio

private void button1_Click(object sender, EventArgs e)
{
    if (sender is Button)
    {
        Button button = (Button)sender;
        button.Text = "Processing...";
    }
    else
    {
        //Do what you need to do here
    }
}

Prima di assegnare ed utilizzare la variabile sender verifichiamo se è o meno di tipo Button. In questo modo siamo certi che l’assegnazione non genererà alcun problema.

Leggi tutto “Casting in [C#]: implicit, explicit e utilizzo delle keyword as e is”

Ottenere informazioni sul metodo chiamante [C#]

Può essere utile in certe situazione conoscere il nome della funzione o metodo che ha richiamato una certa funzionalità. Ad esempio se stiamo loggando delle informazioni per il debug della nostra applicazione è importante sapere l’operazione che si sta eseguendo  ma anche il flusso che ha portato ad essa.

Metodo 1 : StackTrace

Un modo per ottenere il nome del metodo di chiamata è usare il metodo StackTrace.GetFrame(). In particolare per ottenere la prima funzione precedente in ordine di chiamata basta creare una nuova istanza di StackTrace e chiamare il metodo GetFrame  con parametro 1.

Il parametro appunto è l’indice della chiamata del metodo nello stack di chiamate. L’indice della prima chiamata del metodo (il più vicino) è “1”, quindi restituisce uno StackFrame del metodo chiamante  cioè il metodo che ha chiamato direttamente il metodo corrente.

La sintassi corretta è la seguente :

using System.Diagnostics;
// Get call stack

// Get calling class name
string classe = (new StackTrace()).GetFrame(1).GetMethod().DeclaringType.Name 
// Get calling method name 
string metodo =  (new StackTrace()).GetFrame(1).GetMethod().Name;

Per ottenere il nome del metodo, utilizzare StackFrame.GetMethod () e quindi recuperare il valore della proprietà Name mentre per recuperare il nome della classe chiamante si usa DeclaringType.Name.

Metodo 2 : Reserved attributes

Da c# 5 è possibile dichiarare degli attributi riservati come parametri di una funzione per ottenere determinate informazioni.

Utilizzando gli attributi info, si ottengono informazioni sul chiamante per un metodo. È possibile ottenere il percorso del file del codice sorgente, il numero di riga nel codice sorgente e il nome del membro del chiamante. Per ottenere informazioni sul chiamante del membro, utilizzare gli attributi applicati ai parametri opzionali. Ogni parametro facoltativo specifica un valore predefinito.

Nella tabella seguente sono elencati gli attributi Informazioni sul chiamante definiti nello spazio dei nomi System.Runtime.CompilerServices

CallerFilePathAttribute Percorso completo del file di origine che contiene il chiamante. Il percorso completo è il percorso al momento della compilazione.
CallerLineNumberAttribute Numero di riga nel file di origine da cui viene chiamato il metodo.
CallerMemberNameAttribute Nome del metodo o nome della proprietà del chiamante.

 

public void funzioneDiTest() 
{ 

funzioneDaTracciare("messaggio."); 
}

public void funzioneDaTracciare(string message,
        [CallerMemberName] string memberName = "",
        [CallerFilePath] string sourceFilePath = "",
        [CallerLineNumber] int sourceLineNumber = 0)
{
    Console.WriteLine("message: " + message);
    Console.WriteLine("member name: " + memberName);
    Console.WriteLine("source file path: " + sourceFilePath);
    Console.WriteLine("source line number: " + sourceLineNumber);
}


// Output:
//  message:messaggio.
//  member name: funzioneDiTest
//  source file path: c:\percorso-completo\Form1.cs
//  source line number: 31

 

 

Serializzare / Deserializzare una data Nullable [c#]

Lavorando con file XML che vengono serializzati e deserializzati si a ha spesso a che fare con campi di tipo date con valori nullable o più semplicemente con valori non presenti per un qualsiasi motivo.

La situazione è gestita come eccezione durante la lettura e può causare problemi.

Usando lo spazio dei nomi System.Xml.Serialization si può incontrare e risolvere il problema durante il processo di serializzazione e deserializzazione.

Ecco il problema, il codice seguente è un datetime nullable, che va bene in .NET

private DateTime? _nullableData;

[XmlAttribute] public DateTime? nullableData 
{ 
     get { 
            return _nullableData; 
      } 

     set { 
           _nullableData= value; 
      } 
}

 

Quando si arriva alla serializzazione / deserializzazione, si riscontra un errore di:

System.InvalidOperationException: Cannot serialize member ‘DOB’ of type System.Nullable`1[System.DateTime]. XmlAttribute/XmlText cannot be used to encode complex types.

Un modo per risolvere il problema è quello di memorizzare la data usando una stringa e poi pre-elaborare la data e quindi memorizzarla nel campo della data nullable, in questo modo:

private DateTime? _nullableData; 

[XmlIgnore] 
public DateTime? nullableData 
{ 
    get { return _nullableData; } 
    set { _nullableData = value; } 
} 

[XmlAttribute(“nullableData”)] 
public string nullableDataString 
{ 
    get { 
        return nullableData.HasValue ? XmlConvert.ToString(nullableData.Value, XmlDateTimeSerializationMode.Unspecified) : string.Empty; 
        } 
    
    set { 
        nullableData = !string.IsNullOrEmpty(value) ? XmlConvert.ToDateTime(value, XmlDateTimeSerializationMode.Unspecified) : (DateTime?) null; 
    } 
}

 

Base64 Encode e Decode di una stringa [c#]

Encode

public static string Base64Encode(string plainText) 
{
  var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(plainText);
  return System.Convert.ToBase64String(plainTextBytes);
}

Decode

public static string Base64Decode(string base64EncodedData) 
{
  var base64EncodedBytes = System.Convert.FromBase64String(base64EncodedData);
  return System.Text.Encoding.UTF8.GetString(base64EncodedBytes);
}

Leggi tutto “Base64 Encode e Decode di una stringa [c#]”

Problemi tecnici per Binance

Binance Giù per giorni

Se siete utilizzatori di Binance sicuramente avete notato che il noto exchange da alcuni giorni non stava funzionando correttamente. In realtà il sito è giù da diverso tempo.

Viste le brutte esperienze avute in passato in molti, soprattutto chi ha degli account con un certo valore, ha temuto un possibile attacco hacker con conseguente perdita dei depositi degli utenti. Leggi tutto “Problemi tecnici per Binance”

Amazon ed il brevetto sui braccialetti elettronici

Magazzino Amazon

In questi giorni i titoli di blog e giornali sono tutti per la notizia secondo la quale Amazon avrebbe pensato di utilizzare per i suoi dipendenti dei braccialetti elettronici appositamente brevettati che ne traccerebbero gli spostamenti in palese violazione di qualsiasi legge sulla privacy e qualsiasi accordo sui diritti dei lavoratori. I titoloni parlano chiaro Leggi tutto “Amazon ed il brevetto sui braccialetti elettronici”