objetos para registrar usuarios

#varios codigos del programa con distintos objetos pero los coloco aqui todos juntos
# la idea es llamar es poder de momento registrar usuarios y llamar al metodo de CryptoPassHttp.registeruser que por cierto lo  # # tengo que desarrollar
#este fichero es el register.xaml.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Navigation;
using Microsoft.Phone.Controls;
using Microsoft.Phone.Shell;
using PlanningActivitiesWP8.Entidades;
using System.Text.RegularExpressions;
using System.Security.Cryptography;
using System.Threading.Tasks;
using Windows.Web.Http;
using Windows.Data.Json;

namespace PlanningActivitiesWP8
{
    public partial class Register : PhoneApplicationPage
    {



        //comporobar si un mail es valido o no en formato
        public Register()
        {
            InitializeComponent();
        }

        private async void ButtonRegister_Click(object sender, RoutedEventArgs e)
        {
            bool isValid = false;

            //comprobacion de si la clave tiene un minimo de 3 caracteres comn un if
            if (PasswordBoxPass.Password.Length >= 3)
            {
                //aqui se hace otra comprobacion con otro if para ver si los password coinciden
                if (PasswordBoxPass.Password == PasswordBoxConfirmation.Password)
                {

                    //comprobnar que el texto puesto en la textbox es un correo electronico y si no lo es no dejar seguir el proceso de registro y dar un error con un mensaje

                    //aqui lo que hago una vez ya conectado con Windowsazure es introducir datos una vez que el usuario le al boton register
                    string password = PasswordBoxPass.Password;

                    RegexUtil RegexUtil = new RegexUtil();
                    //el metodo isValidEmail me devolvera false o true dependiendo de si la cadena la toma como buena o mala si tiene o no formato de email
                    isValid = RegexUtil.IsValidEmail(TextBoxEmail.Text);
                    if (isValid == true)
                    {
                        //para introducir el dato del usuario en el servicio movil
                        try
                        {
                            //aqui probaremos tambien a cifrar la clave
                            //lo que haremos sera el metodo parse para transformar la string en Byte
                            //byte password = byte.Parse(PasswordBoxPass.Password);ç
                            /* este codigo no me sirve para generar el hash de la clave que es lo que vamos a almacenar junto con el codigo salt
                            byte[] password = new byte[PasswordBoxPass.Password.Length];
                            for (int i = 0; i < PasswordBoxPass.Password.Length; i++)//haz un ciclo para llenar el arreglo
                            {
                                password[i] = byte.Parse(PasswordBoxPass.Password[i].ToString());//conversion!!! la variable i representa la posicion en k se encuentra
                            }
                            */
                            byte[] salt = CryptoPassHttp.GetSalt();
                            byte[] hash = CryptoPassHttp.GenerateHash(PasswordBoxPass.Password, salt);
                            //en este metodo lo que estoy obteniendo es el usuario para insertarlo en la base de datos

                            usuarios user = CryptoPassHttp.GetSecureUserModel(TextBoxName.Text, password, TextBoxEmail.Text, salt);
                            //realizar el salvado de datos del usuario a registrar con los datos que tenemos


                            //await userTable.InsertAsync(user);
                            //sincronizar los elementos de la tabla
                            //este elemento es el que falla
                            //items = await userTable.ToCollectionAsync();
                            //user.Id = items.Count + 1;
                            //para actualizar la tabla
                            //await userTable.UpdateAsync(user);
                            JsonObject jsonObject = new JsonObject();
                            //vamos a ver la forma de trabajar con texto con json segun el ejemplo de Microsoft y adaprlo a mi codigo segun lo que tenga que enviar
                            jsonObject["nombre"] = JsonValue.CreateStringValue(TextBoxName.Text);
                            jsonObject["email"] = JsonValue.CreateStringValue(TextBoxEmail.Text);
                            jsonObject["hash"] = JsonValue.CreateStringValue(user.hash);
                            jsonObject["salt"] = JsonValue.CreateStringValue(user.salt);
                            string jsonString = jsonObject.Stringify();
                            HttpResponseMessage response = new HttpResponseMessage();
                            Uri uri = new Uri("http://192.168.1.2/laravelplan/public/api/rest/users");
                            HttpClient httpClient = new HttpClient();
                            // aqui haremos la comprobacion de si esta o no el servicio disponible en el caso de que no este disponible dar un mensaje

                            try
                            {
                                response = await httpClient.GetAsync(uri).GetResults();
                            }
                            //var resultado = JsonConvert.DeserializeObject(response.Content.ReadAsStringAsync());
                            //Resultado contiene el Json ;)

                            catch (Exception ex)
                            {
                                MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK);
                            }

                            /*
                            Task<bool> Resultado = CryptoPassHttp.GetUserFromDatabase(TextBoxEmail.Text, jsonObject);
                            if (Resultado.Result)
                            {

                            }
                            else
                            {

                            }
                            */
                            Task<bool> users = CryptoPassHttp.RegisterUser(user, jsonString);
                             //aqui ya se va al otro XAML en la finalizacion del programa se ira al de aceptarlos terminos y condiciones del programa
                            /*
                            Task<usuarios> userpass = CryptoPassHttp.VerifyLogin(user.email, password);
                            //
                            if (users.Result == false)
                            {
                                MessageBox.Show("user exist in the database, choose other user", "Information", MessageBoxButton.OK);
                            }
                            else if (userpass == null)
                            {
                                MessageBox.Show("Password incorrect", "Information", MessageBoxButton.OK);
                            }
                            */
                            //aqui ya te lleva a la ventana para trabajar con el programa
                            NavigationService.Navigate(new Uri("/PivotProgram.xaml" + TextBoxEmail.Text, UriKind.Relative));





                            //usuarios usuario = new usuarios { usuario = TextBoxUser.Text, hash = PasswordBoxPass.Password, email = TextBoxEmail.Text };
                            //App.MobileService.GetTable<usuarios>().InsertAsync(usuario);

                        }
                        catch (Exception ex)
                        {
                            MessageBox.Show(ex.Message);
                        }

                    }
                    else
                    {
                        MessageBox.Show("the format e-mail is not correct", "Information", MessageBoxButton.OK);
                    }
                }
                else
                {
                    MessageBox.Show("password fail must be equal", "Information", MessageBoxButton.OK);
                    PasswordBoxPass.SelectAll();
                    PasswordBoxConfirmation.Password = "";
                    PasswordBoxPass.Focus();

                }
            }
            //comprobar primero que sean la misma clave en las 2 passwordbox

        }
    }
}
/*
 *
 *  aqui coloco el fichero con el que estoy trabajando otro objeto que hace otras cosas llamado CryptoPassHttp.cs
 *
/*
using System;
using System.Windows;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Security.Cryptography;
using PlanningActivitiesWP8.Entidades;
using Microsoft.WindowsAzure.MobileServices;
using Windows.Web.Http;
using Windows.Data.Json;
using Windows.Web.Http.Filters;
using Newtonsoft.Json;

namespace PlanningActivitiesWP8
{
    public class CryptoPassHttp
    {
        #region propiedades o autopropiedades

        #endregion

        #region constructor
        public CryptoPassHttp()
        {
        }
        #endregion
        #region metodos para cifrar datos
        /* GenerateHash es para generar el hash de la clave y necesito el codigo salt
         */

        public static byte[] GenerateHash(string password, byte[] salt)
        {
            byte[] passwordData = Encoding.UTF8.GetBytes(password);

            byte[] composite = new byte[passwordData.Length + 32];

            Array.Copy(passwordData, composite, passwordData.Length);
            Array.Copy(salt, 0, composite, passwordData.Length, salt.Length);

            SHA256 hashFunction = new SHA256Managed();
            byte[] hash = hashFunction.ComputeHash(composite);

            return hash;
        }

        // obtener salt como dice el nombre del metodo que es lo primero que hay que hacer

        public static byte[] GetSalt()
        {
            byte[] rngContainer = new byte[32];
            RNGCryptoServiceProvider rngProvider = new RNGCryptoServiceProvider();
            rngProvider.GetBytes(rngContainer);

            return rngContainer;
        }

        public static byte[] GetSaltFromString(string source)
        {
            string[] raw = source.Split('-');
            byte[] result = new byte[raw.Length];
            for (int i = 0; i < raw.Length; i++)
            {
                result[i] = Convert.ToByte(raw[i], 16);
            }
            return result;
        }
        #endregion
        /* aqui tengo que hacer modificacions en el codigo del metodo para que funcione como es debido
         */
        //aqui definimos el user que vamos a añadir luego con el comando RegisterUser
        public static usuarios GetSecureUserModel(string name, string password, string email = "", byte[] customSalt = null)
        {
            byte[] hash;

            usuarios user = new usuarios();
            user.nombre = name;
            user.email = email;

            if (customSalt == null)
            {
                byte[] salt = GetSalt();
                user.salt = BitConverter.ToString(salt);

                hash = GenerateHash(password, salt);

            }
            else
            {
                hash = GenerateHash(password, customSalt);
            }

            user.hash = BitConverter.ToString(hash);
            user.salt = BitConverter.ToString(customSalt);
            return user;
        }

        public async static Task<bool> RegisterUser(usuarios user, string jsonString)
        {
            /*
            aqui tendremos que crear el objeto httpclient y mandarle por post el objeto json
            */
             // Add a user-agent header
            //encapsular en un formato de texto valido el jsonObject



            //HttpResponseMessage httpResponseMessage = new HttpResponseMessage();

            //var headers = httpClient.DefaultRequestHeaders;
            //headers.UserAgent.ParseAdd("ie");
            //headers.UserAgent.ParseAdd("Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)");
            //comprobaamos que la conexion existe y que el servidor funciona basicamente usamos esa direccion para ver si nos responde algo
            //var headers = httpClient.DefaultRequestHeaders;
            //headers.UserAgent.ParseAdd("ie");
            //headers.UserAgent.ParseAdd("Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)");
            //comprobacion a ver si funciona el servicio REST

            //httpResponseMessage = await httpClient.GetAsync(uri);

            //client.DefaultRequestHeaders.Authorization = new HttpCredentialsHeaderValue("Basic", token);

            //var data = await client.GetAsync(new Uri("https://mytestdomain/v2/apikey?format=Json"));

            /*
            if (httpResponseMessage.IsSuccessStatusCode)
            {
                //aqui ya mando el jsonString al servicio REST
                Uri uristore = new Uri("http://192.168.1.2/laravelplan/public/api/rest/users/store");
                HttpStringContent httpStringContent = new HttpStringContent(jsonString);
                try
                {
                    httpResponseMessage = await httpClient.PostAsync(uri, httpStringContent);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }

            }
            else
            {
                return false;
            }
            */




            //creamoms el jaon object
            return true;
        }
        //obten4er usuario de la base de datos
        /*
        public static async Task<bool> GetUserFromDatabase(string email, JsonObject jsonObject)
        {
            //mandaremos un objeto json al servidor REST para recuperar un usuario si se recupera es que existe y habra que decirselo al usuario si no existe se sigue con el
            //proceso de registro de usuario
            Uri uri = new Uri("http://192.168.1.2/laravelplan/public/api/rest/users/");
            string jsonString = jsonObject.Stringify();
            HttpClient httpClient = new HttpClient();
            HttpResponseMessage httpResponseMessage = new HttpResponseMessage();
            //httpResponseMessage = httpClient.GetStringAsync(uri);
            /*
            try
            {
                //httpResponseMessage = await httpClient.PostAsync()
            }
            catch (Exception ex)
            {

            }

            return true;
        }
        */
        public async static Task<usuarios> VerifyLogin(string username, string password)
        {

            /*
            if (dbUser != null)
            {
                usuarios localUser = GetSecureUserModel(username, password, "",
                    GetSaltFromString(dbUser.salt));
                if (dbUser.hash == localUser.hash)
                    return dbUser;
            }
            */
            return null;
        }





    }
}