private string TranslateMethod(string authToken, string text)
        {
            string translation = string.Empty;
            string from = "en";
            string to = "ja";

            string uri = "http://api.microsofttranslator.com/v2/Http.svc/Translate?text="
                + System.Web.HttpUtility.UrlEncode(text) + "&from=" + from + "&to=" + to;

            HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(uri);
            httpWebRequest.Headers.Add("Authorization", authToken);
            WebResponse response = null;
            try
            {
                response = httpWebRequest.GetResponse();
                using (Stream stream = response.GetResponseStream())
                {
                    System.Runtime.Serialization.DataContractSerializer dcs =
                        new System.Runtime.Serialization.DataContractSerializer(Type.GetType("System.String"));
                    translation = (string)dcs.ReadObject(stream);
                }
            }
            finally
            {
                if (response != null)
                {
                    response.Close();
                    response = null;
                }
            }

            return translation;
        }

        public static string TranslateMethod(string authToken, string originalS, string from, string to)
        {
            string text = originalS; //"你能听见我";
            //string from = "en";
            //string to = "zh-CHS";
            //string from = Constants.from;// "zh-CHS";
            //string to = Constants.to; // "en";

            string transuri = ConstantParam.ApiUri + System.Net.WebUtility.UrlEncode(text) + "&from=" + from + "&to=" + to;

            HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(transuri);
            //  httpWebRequest.ContentType = "application/x-www-form-urlencoded";
            httpWebRequest.Headers["Authorization"] = authToken;
            //httpWebRequest.Method = "GET";
            string trans;

            Task<WebResponse> response = httpWebRequest.GetResponseAsync();

            using (Stream stream = response.Result.GetResponseStream())
            {
                System.Runtime.Serialization.DataContractSerializer dcs = new System.Runtime.Serialization.DataContractSerializer(Type.GetType("System.String"));
                //DataContractJsonSerializer dcs = new DataContractJsonSerializer(Type.GetType("System.String"));
                trans = (string)dcs.ReadObject(stream);
                return trans;

            }
        }

        public override string Translate(string text)
        {
            string result = "nothing yet...";

            Stream stream = null;

            try
            {
                using (stream = GetResponse(text).GetResponseStream())
                {
                    var dataContractSerializer
                        = new System.Runtime.Serialization.DataContractSerializer(Type.GetType("System.String"));
                    result = (string) dataContractSerializer.ReadObject(stream);
                }
            }
            catch (WebException e)
            {
                result = e.Message;
            }
            finally
            {
                if (stream != null)
                {
                    stream.Dispose();
                }
            }

            return result;
        }

        public object Deserialize(string serializedObject, Type type)
        {
            using (var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(serializedObject)))
            {
                var serializer = new System.Runtime.Serialization.DataContractSerializer(type, null, Int32.MaxValue, false, false, null, _dataContractResolver);

                return serializer.ReadObject(memoryStream);
            }
        }

 /// <summary>
 /// Creates a new object that is a copy of the current instance.
 /// </summary>
 /// <returns>
 /// A new object that is a copy of this instance.
 /// </returns>
 object ICloneable.Clone()
 {
     var serializer = new System.Runtime.Serialization.DataContractSerializer(GetType());
     using (var ms = new System.IO.MemoryStream())
     {
         serializer.WriteObject(ms, this);
         ms.Position = 0;
         return serializer.ReadObject(ms);
     }
 }

 internal static string GetXml(object o) {
   var formatter = new System.Runtime.Serialization.DataContractSerializer(o.GetType());
   using (var stringWriter = new StringWriter())
   using (var xmlWriter = new XmlTextWriter(stringWriter)) {
     xmlWriter.Formatting = Formatting.Indented;
     xmlWriter.QuoteChar = '\'';
     formatter.WriteObject(xmlWriter, o);
     return stringWriter.ToString();
   }
 }

        public void TestSer()
        {
            var f = new SomeTestingViewModel() {  Result="hahahaha"};

            var dx = new System.Runtime.Serialization.DataContractSerializer(typeof(SomeTestingViewModel));
            var s = new MemoryStream();
            dx.WriteObject(s, f);
            s.Position = 0;
            var s2 = dx.ReadObject(s) as SomeTestingViewModel;
            Assert.AreEqual(s2.Result, f.Result);
        }

 internal async Task<IEnumerable> InternalLoadSnapshotAsync()
 {
     var f = await workingFile;
     var sl = new System.Runtime.Serialization.DataContractSerializer(typeof(PicLibFolder[]));
     var ms = new MemoryStream();
     using (var inps = (await f.OpenReadAsync()).GetInputStreamAt(0).AsStreamForRead())
     {
         await inps.CopyToAsync(ms);
         ms.Position = 0;
     }
     var r = sl.ReadObject(ms) as PicLibFolder[];
     return r;
 }

 /// <summary>
 /// Returns a byte array that represents the current <see cref="T:System.Object"/>. 
 /// </summary>
 /// <returns>A byte array that represents the current <see cref="T:System.Object"/>.</returns>
 public virtual byte[] ToBinary()
 {
     byte[] buffer;
     using (var ms = new System.IO.MemoryStream())
     using (var writer = System.Xml.XmlDictionaryWriter.CreateBinaryWriter(ms))
     {
         var serializer = new System.Runtime.Serialization.DataContractSerializer(GetType());
         serializer.WriteObject(writer, this);
         writer.Flush();
         buffer = ms.ToArray();
     }
     return buffer;
 }

        public static object DataContractDeserialize(string buffer, bool compress)
        {
            if (!string.IsNullOrEmpty(buffer))
            {
                int idx = buffer.IndexOf('@');
                string assemblyQualifiedName = buffer.Substring(0, idx);
                string objBuffer = buffer.Substring(idx + 1);
                Type objType = Type.GetType(assemblyQualifiedName, true);

                System.Runtime.Serialization.DataContractSerializer aa = new System.Runtime.Serialization.DataContractSerializer(objType);
                XmlReader reader = XmlReader.Create(new StringReader(objBuffer));
                return aa.ReadObject(reader);
            }
            else
                return null;
        }

        /// <summary>
        /// Used to perform the actual translation
        /// </summary>
        /// <param name="InputString"></param>
        /// <returns></returns>
        public override string TranslateString(string InputString)
        {
            Console.WriteLine("Processing: " + InputString);
            string result = "";

            using (WebClient client = new WebClient())
            {
                using (Stream data = client.OpenRead(this.BuildRequestString(InputString)))
                {
                    System.Runtime.Serialization.DataContractSerializer dcs = new System.Runtime.Serialization.DataContractSerializer(Type.GetType("System.String"));
                    result = (string)dcs.ReadObject(data);

                    data.Close();
                }
            }

            return result;
        }

        public static string[] GetLanguageNames(string[] languageCodes)
        {
            string uri = "http://api.microsofttranslator.com/v2/Http.svc/GetLanguageNames?locale=" + languageCodes[0] + "&appId=" + appId;
            HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(uri);
            httpWebRequest.ContentType = "text/xml";
            httpWebRequest.Method = "POST";
            System.Runtime.Serialization.DataContractSerializer dcs = new System.Runtime.Serialization.DataContractSerializer(Type.GetType("System.String[]"));
            using (System.IO.Stream stream = httpWebRequest.GetRequestStream())
            {
                dcs.WriteObject(stream, languageCodes);
            }

            WebResponse response = null;
            try
            {
                response = httpWebRequest.GetResponse();
                using (Stream stream = response.GetResponseStream())
                {
                    return (string[])dcs.ReadObject(stream);
                }
            }
            catch (WebException)
            {
                if (languageCodes.Length == 1 && languageCodes[0] == "en")
                    return new string[] { "English" };
                else
                    throw;
            }
            catch
            {
                throw;
            }
            finally
            {
                if (response != null)
                {
                    response.Close();
                    response = null;
                }
            }
        }

        public string Serialize(object serializableObject)
        {
            using (var memoryStream = new MemoryStream())
            {
                var serializer = new System.Runtime.Serialization.DataContractSerializer(serializableObject.GetType(),
                                                                                         null,
                                                                                         Int32.MaxValue,
                                                                                         false,
                                                                                         false,
                                                                                         null,
                                                                                         _dataContractResolver);

                serializer.WriteObject(memoryStream, serializableObject);
                memoryStream.Seek(0, SeekOrigin.Begin);

                using (var streamReader = new StreamReader(memoryStream))
                {
                    return streamReader.ReadToEnd();
                }
            }
        }

        public static string DataContractSerialize(Object obj, bool compress)
        {
            if (obj != null)
            {
                Type objType = obj.GetType();
                System.Runtime.Serialization.DataContractSerializer aa = new System.Runtime.Serialization.DataContractSerializer(objType);
                StringBuilder sb = new StringBuilder();

                // Inserisce l'assembly qualified name nello stream del buffer come primo elemento separato dalla @
                sb.Append(objType.AssemblyQualifiedName);
                sb.Append('@');

                XmlWriter writer = XmlWriter.Create(sb);
                aa.WriteObject(writer, obj);
                writer.Close();

                return sb.ToString();
            }
            else
                return null;
        }

        public static string TranslateMethod(string authToken, string originalS, string from, string to)
        {
            string text = originalS; 
            string transuri = ConstantParam.ApiUri + System.Net.WebUtility.UrlEncode(text) + "&from=" + from + "&to=" + to;

            HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(transuri);

            httpWebRequest.Headers["Authorization"] = authToken;
            string trans;

            Task<WebResponse> response = httpWebRequest.GetResponseAsync();

            using (Stream stream = response.Result.GetResponseStream())
            {
                System.Runtime.Serialization.DataContractSerializer dcs = new System.Runtime.Serialization.DataContractSerializer(Type.GetType("System.String"));

                trans = (string)dcs.ReadObject(stream);
                return trans;

            }
        }

        /// <summary> Get object from isolated storage file.</summary>
        /// <param name="fullpath"> file name to retreive</param>
        /// <param name="type"> type of object to read</param>
        /// <returns> a <c>object</c> instance, or null if the operation failed.</returns>
        private async Task<object> GetObjectByType(string filepath, Type type)
        {
            object retVal = null;
            try
            {
                using (var releaser = await internalManifestDiskLock.ReaderLockAsync())
                {
                    System.Diagnostics.Debug.WriteLine(string.Format("{0:d/M/yyyy HH:mm:ss.fff}", DateTime.Now) + " internalManifestDiskLock Reader Enter for Uri: " + filepath.ToString());

                    byte[] bytes = await Restore(filepath);
                    if (bytes != null)
                    {
                        try
                        {
                            using (MemoryStream ms = new MemoryStream(bytes))
                            {
                                if (ms != null)
                                {
                                    System.Runtime.Serialization.DataContractSerializer ser = new System.Runtime.Serialization.DataContractSerializer(type);
                                    retVal = ser.ReadObject(ms);
                                }
                            }
                        }
                        catch(Exception e)
                        {

                            System.Diagnostics.Debug.WriteLine(string.Format("{0:d/M/yyyy HH:mm:ss.fff}", DateTime.Now) + " internalManifestDiskLock Reader Exception for Uri: " + filepath.ToString() + " Exception: " + e.Message);
                        }
                    }
                    System.Diagnostics.Debug.WriteLine(string.Format("{0:d/M/yyyy HH:mm:ss.fff}", DateTime.Now) + " internalManifestDiskLock Reader Exit for Uri: " + filepath.ToString());

                }
            }
            catch(Exception)
            {

            }
            return retVal;
        }

        public void Search1Delegate(object frpair)
        {
            FederateRecord fr = ((SearchStart)frpair).fed;
            List<SearchResult> results = ((SearchStart)frpair).results;
            string terms = ((SearchStart)frpair).terms;

            System.Net.WebClient wc = GetWebClient();
            wc.Headers["Authorization"] = ((SearchStart)frpair).Authorization;

            System.Runtime.Serialization.DataContractSerializer xmls = new System.Runtime.Serialization.DataContractSerializer(typeof(List<SearchResult>));

            if (fr.ActivationState == FederateState.Active && fr.AllowFederatedSearch == true)
            {
                try
                {
                    byte[] data = wc.DownloadData(fr.RESTAPI + "/Search/" + terms + "/xml?ID=00-00-00");
                    List<SearchResult> fed_results = (List<SearchResult>)xmls.ReadObject(new MemoryStream(data));

                    lock (((System.Collections.IList)results).SyncRoot)
                    {
                        foreach (SearchResult sr in fed_results)
                            results.Add(sr);
                    }

                }
                catch (System.Exception e)
                {
                   // throw e;
                    fr.ActivationState = FederateState.Offline;
                    mFederateRegister.UpdateFederateRecord(fr);
                    return;
                }
            }
        }

 public DataContractSerializerWorker(Type t)
 {
     Serializer = new DCSerializer(t);
 }

        private void OnSaveAs(object sender, ExecuteEventArgs e)
        {
            using (SaveFileDialog dialog = new SaveFileDialog())
            {
                dialog.Filter = "Shader file (*.sh)|*.sh|All files (*.*)|*.*";
                dialog.FilterIndex = 0;
                dialog.RestoreDirectory = true;

                if (dialog.ShowDialog() == DialogResult.OK)
                {
                    using (var stream = dialog.OpenFile())
                    {
                        using (var xmlStream = new System.IO.MemoryStream())
                        {
                            var nodeGraph = ModelConversion.ToShaderPatcherLayer(graphControl);
                            var serializer = new System.Runtime.Serialization.DataContractSerializer(
                                typeof(ShaderPatcherLayer.NodeGraph));
                            var settings = new System.Xml.XmlWriterSettings()
                            {
                                Indent = true,
                                IndentChars = "\t",
                                Encoding = System.Text.Encoding.ASCII
                            };

                                // write the xml to a memory stream to begin with
                            using (var writer = System.Xml.XmlWriter.Create(xmlStream, settings))
                            {
                                serializer.WriteObject(writer, nodeGraph);
                            }

                                // we hide the memory stream within a comment, and write
                                // out a hlsl shader file
                                // The HLSL compiler doesn't like UTF files... It just wants plain ASCII encoding

                            using (var sw = new System.IO.StreamWriter(stream, System.Text.Encoding.ASCII))
                            {
                                var shader = ShaderPatcherLayer.NodeGraph.GenerateShader(nodeGraph, System.IO.Path.GetFileNameWithoutExtension(dialog.FileName));
                                sw.Write(shader);

                                sw.Write("/* **** **** NodeEditor **** **** \r\nNEStart{");
                                sw.Flush();
                                xmlStream.WriteTo(stream);
                                sw.Write("}NEEnd\r\n **** **** */\r\n");
                            }

                        }
                    }
                }
            }
        }

 async private Task RestoreMediaFilesAsync()
 {
     string fullPath = "mediafiles.xml";
     ulong size = 0;
     try
     {
         Windows.Storage.StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync(fullPath);
         if (file != null)
         {
             var prop = await file.GetBasicPropertiesAsync();
             if (prop != null)
                 size = prop.Size;
         }
         var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
         if (stream != null)
         {
             using (var inputStream = stream.GetInputStreamAt(0))
             {
                 System.Runtime.Serialization.DataContractSerializer sessionSerializer = new System.Runtime.Serialization.DataContractSerializer(typeof(Dictionary<string, MediaLibraryItem>));
                 defaultMediaDictionary = (Dictionary<string, MediaLibraryItem>)sessionSerializer.ReadObject(inputStream.AsStreamForRead());
                 fileDiscovered = (uint)defaultMediaDictionary.Count();
             }
         }            
     }
     catch (Exception e)
     {
         LogMessage("Exception while restoring mediafiles:" + e.Message);
     }
 }