コード例 #1
0
ファイル: OAuth.cs プロジェクト: Letractively/urlme-cc
        /// <summary>
        /// Exchange the "code" for an access token.
        /// </summary>
        /// <param name="authToken">The oauth_token or "code" is supplied by Facebook's authorization page following the callback.</param>
        public void AccessTokenGet(string authToken)
        {
            //this.Token = authToken;
            string accessTokenUrl = string.Format(TokenLinkFormat, TokenEndpoint, ClientId, RedirectUri, ClientSecret, authToken);

            string response = WebRequest(Enumerations.Method.Get, accessTokenUrl, String.Empty);

            if (response.Length > 0)
            {
                if (this.ResponseType == "application/json;charset=UTF-8")
                {
                    var dataContractJsonSerializer = new DataContractJsonSerializer(typeof(AccessToken));
                    var stream = new MemoryStream(Encoding.UTF8.GetBytes(response));
                    var readObject = dataContractJsonSerializer.ReadObject(stream);
                    stream.Close();
                    AccessToken accessToken = (AccessToken)readObject;
                    if (accessToken != null)
                    {
                        this.Token = accessToken.access_token;
                    }

                }
                else
                {
                    //Store the returned access_token
                    NameValueCollection qs = HttpUtility.ParseQueryString(response);

                    if (qs["access_token"] != null)
                    {
                        this.Token = qs["access_token"];
                    }
                }
            }
        }
コード例 #2
0
ファイル: test.cs プロジェクト: mono/gert
		static int Main (string [] args)
		{
			JsonObject obj = new JsonObject ();
			string json;

#if !MONO
			MemoryStream ms = new MemoryStream ();
			DataContractJsonSerializer dcSerializer = new DataContractJsonSerializer (typeof (JsonObject));
			dcSerializer.WriteObject (ms, obj);
			ms.Position = 0;

			StreamReader sr = new StreamReader (ms);
			json = sr.ReadToEnd ();
			Assert.AreEqual ("{\"int_key\":null}", json, "#1");

			ms = new MemoryStream ();
			StreamWriter sw = new StreamWriter (ms);
			sw.Write (json);
			sw.Flush ();
			ms.Position = 0;

			obj = (JsonObject) dcSerializer.ReadObject (ms);
			Assert.IsNull (obj.int_key, "#2");
#endif

			json = "{\"int_key\":null}";

			JavaScriptSerializer jsSerializer = new JavaScriptSerializer ();
			obj = jsSerializer.Deserialize<JsonObject> (json);
			Assert.IsNull (obj.int_key, "#3");

			json = "{\"int_key\" : \"\"}";

#if !MONO
			ms = new MemoryStream ();
			sw = new StreamWriter (ms);
			sw.Write (json);
			sw.Flush ();
			ms.Position = 0;

			try {
				obj = (JsonObject) dcSerializer.ReadObject (ms);
				Assert.Fail ("#4");
			} catch (SerializationException) {
			}
#endif

			obj = jsSerializer.Deserialize<JsonObject> (json);
			Assert.IsNull (obj.int_key, "#5");

			return 0;
		}
コード例 #3
0
        public static void End()
        {
            switch (Mode)
            {
            case MockContextMode.Run:
                break;

            case MockContextMode.Record:

                var serializer = new DataContractJsonSerializer(typeof(Session));

                Directory.CreateDirectory(RecordingDirectoryName);
                session.Data.TrimExcess();
                session.Recordings.TrimExcess();

                using (var stream = new FileStream(RecordingFilename, FileMode.Create))
                {
                    using (var compressedStream = new GZipStream(stream, CompressionLevel.Optimal))
                    {
                        serializer.WriteObject(compressedStream, session);
                    }
                }

                break;

            case MockContextMode.Playback:

                Debug.Assert(session.Data.Count == 0);
                Debug.Assert(session.Recordings.Count == 0);
                break;

            default: throw new InvalidOperationException();
            }

            session = null;
        }
コード例 #4
0
        public void SerializeTest()
        {
            var quota1 = new TenantQuota(Tenant)
            {
                AvangateId   = "1",
                Features     = "trial,year",
                Name         = "quota1",
                Price        = 12.5m,
                Price2       = 45.23m,
                Visible      = true,
                MaxFileSize  = 3,
                MaxTotalSize = 4,
                ActiveUsers  = 30,
            };

            var serializer = new DataContractJsonSerializer(quota1.GetType());

            using (var ms = new MemoryStream())
            {
                serializer.WriteObject(ms, quota1);
                var json = Encoding.UTF8.GetString(ms.ToArray());
                Assert.AreEqual("{\"Id\":1024,\"Name\":\"quota1\",\"MaxFileSize\":3,\"MaxTotalSize\":4,\"ActiveUsers\":30,\"Features\":\"trial,year\",\"Price\":12.5,\"Price2\":45.23,\"AvangateId\":\"1\",\"Visible\":true}", json);
            }
        }
コード例 #5
0
ファイル: Login.xaml.cs プロジェクト: ipy/MDWinPhone
 public void GetUserTokenResult(string response)
 {
     //成功
     if (response.IndexOf("access_token") > -1)
     {
         UserInfo     token             = new UserInfo();
         MemoryStream ms                = new MemoryStream(Encoding.UTF8.GetBytes(response));
         DataContractJsonSerializer ser = new DataContractJsonSerializer(token.GetType());
         token = ser.ReadObject(ms) as UserInfo;
         ms.Close();
         ms.Dispose();
         Dispatcher.BeginInvoke(() =>
         {
             UserInfo user  = UserDataManager.LoadUserSettings();
             user.UserEmail = txtUserEmail.Text.Trim();
             user.UserPwd   = txtPasswrod.Password.Trim();
             user.Token     = token.access_token;
             App.Token      = token.access_token;
             if (rememberPwd.IsChecked == true)
             {
                 user.RememberPwd = true;
             }
             UserDataManager.SaveUserInformation(user);
             NavigationService.Navigate(new Uri("/View/MainPost.xaml", UriKind.Relative));
         });
     }
     else
     {
         //失败
         Dispatcher.BeginInvoke(() =>
         {
             MessageBox.Show(response);
             loginAnimate.Visibility = Visibility.Collapsed;
         });
     }
 }
コード例 #6
0
        /// <inheritdoc />
        public override IEnumerable <IIssue> ReadIssues(
            MarkdownlintIssuesProvider issueProvider,
            IssueCommentFormat format,
            RepositorySettings repositorySettings,
            MarkdownlintIssuesSettings markdownlintIssuesSettings)
        {
            issueProvider.NotNull(nameof(issueProvider));
            repositorySettings.NotNull(nameof(repositorySettings));
            markdownlintIssuesSettings.NotNull(nameof(markdownlintIssuesSettings));

            Dictionary <string, IEnumerable <Issue> > logFileEntries;

            using (var ms = new MemoryStream(markdownlintIssuesSettings.LogFileContent.RemovePreamble()))
            {
                var jsonSerializer = new DataContractJsonSerializer(
                    typeof(Dictionary <string, IEnumerable <Issue> >),
                    settings: new DataContractJsonSerializerSettings {
                    UseSimpleDictionaryFormat = true
                });

                logFileEntries = jsonSerializer.ReadObject(ms) as Dictionary <string, IEnumerable <Issue> >;
            }

            return
                (from file in logFileEntries
                 from entry in file.Value
                 let
                 rule = entry.ruleName
                        select
                        IssueBuilder
                        .NewIssue(entry.ruleDescription, issueProvider)
                        .InFile(file.Key, entry.lineNumber)
                        .WithPriority(IssuePriority.Warning)
                        .OfRule(rule, MarkdownlintRuleUrlResolver.Instance.ResolveRuleUrl(rule))
                        .Create());
        }
コード例 #7
0
        public static string SerializeItem(string name, string value)
        {
            PowerShellVariablesDC powerShellVariable = new PowerShellVariablesDC(name, value);

            try
            {
                using (MemoryStream stream = new MemoryStream())
                {
                    DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(PowerShellVariablesDC));

                    jsonSerializer.WriteObject(stream, powerShellVariable);

                    stream.Position = 0;
                    using (StreamReader streamReader = new StreamReader(stream))
                    {
                        return(streamReader.ReadToEnd());
                    }
                }
            }
            catch (Exception e)
            {
                throw new Exception(string.Format("Failed to serialize property: {0}", e.Message), e);
            }
        }
コード例 #8
0
        public ReCaptchaResponse Validate(string response, string remoteIp)
        {
            if (string.IsNullOrEmpty(response))
            {
                throw new ArgumentNullException(nameof(response));
            }

            var endPointUrl = string.Format(_googleVerificationEndpoint, _privateKey, response);

            if (!string.IsNullOrEmpty(remoteIp))
            {
                endPointUrl = string.Concat(endPointUrl, "&remoteip=", remoteIp);
            }

            using (var client = new WebClient())
            {
                var verifyResult = client.DownloadString(endPointUrl);
                var deserializer = new DataContractJsonSerializer(typeof(ReCaptchaResponse));
                using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(verifyResult)))
                {
                    return(deserializer.ReadObject(ms) as ReCaptchaResponse);
                }
            }
        }
コード例 #9
0
ファイル: JSON.cs プロジェクト: LyxInChina/GitHelloWorld
        /// <summary>
        /// JSON反序列化字符串到类
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="jsonStr"></param>
        /// <param name="t"></param>
        /// <returns></returns>
        public static bool Deserialize <T>(string jsonStr, out T t)
        {
            var result = false;

            t = default(T);
            if (string.IsNullOrEmpty(jsonStr))
            {
                return(false);
            }
            try
            {
                using (var ms = new MemoryStream(Encoding.Unicode.GetBytes(jsonStr)))
                {
                    var js = new DataContractJsonSerializer(typeof(T));
                    t      = (T)js.ReadObject(ms);
                    result = true;
                }
            }
            catch (Exception ex)
            {
                System.Diagnostics.Trace.Fail(ex.Message, ex.StackTrace);
            }
            return(result);
        }
コード例 #10
0
        /// <summary>
        /// Метод обновляет заданную сущность в базе данных,
        /// оправляя асинхронный PUT-запрос к REST-сервису.
        /// </summary>
        /// <typeparam name="T">
        /// По типу сущности определяется, какой необходимо отправить запрос к REST-сервису.
        /// </typeparam>
        protected void UpdateAsync <T>(T entity)
        {
            var serializer = new DataContractJsonSerializer(typeof(T));

            string         entityName     = typeof(T).Name;
            HttpWebRequest httpWebRequest = WebRequest.CreateHttp(RestServiceAddress + entityName);

            httpWebRequest.Method      = "PUT";
            httpWebRequest.ContentType = "application/json; charset=utf-8";
            httpWebRequest.BeginGetRequestStream(asyncResultRequest =>
            {
                var request          = (HttpWebRequest)asyncResultRequest.AsyncState;
                Stream requestStream = request.EndGetRequestStream(asyncResultRequest);
                serializer.WriteObject(requestStream, entity);
                requestStream.Close();

                request.BeginGetResponse(asyncResultResponse =>
                {
                    var response = (HttpWebResponse)request.EndGetResponse(asyncResultResponse);
                    HttpStatusCode statusCode = response.StatusCode;
                }, request);
                RaisePropertyChanged("UpdateAsyncCompleted");
            }, httpWebRequest);
        }
コード例 #11
0
        public static T Deserialize <T>(string SerializedString, SerializerType UseSerializer)
        {
            // Get a Stream representation of the string.
            using (Stream s = new MemoryStream(UTF8Encoding.UTF8.GetBytes(SerializedString)))
            {
                T item;
                switch (UseSerializer)
                {
                case SerializerType.Json:
                    // Declare Serializer with the Type we're dealing with.
                    var serJson = new DataContractJsonSerializer(typeof(T));
                    // Read(Deserialize) with Serializer and cast
                    item = (T)serJson.ReadObject(s);
                    break;

                case SerializerType.Xml:
                default:
                    var serXml = new DataContractSerializer(typeof(T));
                    item = (T)serXml.ReadObject(s);
                    break;
                }
                return(item);
            }
        }
コード例 #12
0
 private void DesiredYieldBox_KeyUp(object sender, KeyEventArgs e)
 {
     if (e.Key == System.Windows.Input.Key.Enter)
     {
         try
         {
             var client = new WebClient();
             client.Proxy = null;
             Stream stream = client.OpenRead("http://192.168.137.158:8080/EbondSharkWeb/rest/ebonds/bonddetails?ISIN=" +
                                             bond.isin.ToString() + "&Qty=" + QuantityBox.Text + "&param=Yield&value=" + DesiredYieldBox.Text.ToString());
             DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(ComputationResult));
             ComputationResult          result     = (ComputationResult)serializer.ReadObject(stream);
             DesiredYieldBox.Text          = result.desiredYield.ToString();
             CleanPriceBox.Text            = result.cleanPrice.ToString();
             DirtyPriceBox.Text            = result.dirtyPrice.ToString();
             AccruedAmountLabel.Content    = result.accruedAmount.ToString();
             SettlementAmountLabel.Content = result.settlementAmount.ToString();
         }
         catch
         {
             MessageBox.Show("Overflow error");
         }
     }
 }
コード例 #13
0
        private void GetRequestStreamCallback(IAsyncResult asynchronousResult)
        {
            try
            {
                var request    = (HttpWebRequest)asynchronousResult.AsyncState;
                var postStream = request.EndGetRequestStream(asynchronousResult);

                var serializer = new DataContractJsonSerializer(typeof(List <Activity>));
                serializer.WriteObject(postStream, Activities);
                postStream.Close();

                var response = (HttpWebResponse)request.GetResponse();

                _sending = false;
                _succeed = (response.StatusCode == HttpStatusCode.Created);
                _allDone.Set();
            }
            catch (Exception e)
            {
                LogManager.GetInstance().Debug(e.Message);
                _sending = false;
                _allDone.Set();
            }
        }
コード例 #14
0
        /// <inheritdoc/>
        public async Task <Uri> UploadMessageAsync(Stream content, DateTime expirationUtc, string contentType = null, string contentEncoding = null, IProgress <int> bytesCopiedProgress = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            var httpContent = new StreamContent(content.ReadStreamWithProgress(bytesCopiedProgress));

            if (contentType != null)
            {
                httpContent.Headers.ContentType = new MediaTypeHeaderValue(contentType);
            }

            if (contentEncoding != null)
            {
                httpContent.Headers.ContentEncoding.Add(contentEncoding);
            }

            int lifetime = expirationUtc == DateTime.MaxValue ? int.MaxValue : (int)(expirationUtc - DateTime.UtcNow).TotalMinutes;
            var response = await this.HttpClient.PostAsync(this.BlobPostUrl.AbsoluteUri + "?lifetimeInMinutes=" + lifetime, httpContent);

            response.EnsureSuccessStatusCode();

            var serializer = new DataContractJsonSerializer(typeof(string));
            var location   = (string)serializer.ReadObject(await response.Content.ReadAsStreamAsync());

            return(new Uri(location, UriKind.Absolute));
        }
コード例 #15
0
ファイル: RedisConnector.cs プロジェクト: sormita/ARCGitOps
        public static List <T> GetComplexList <T>(string objName)
        {
            //Getting a list of complex objects from Redis
            if (RedisConnector.GetDatabase() != null)
            {
                var      lstObj          = (List <string>)RedisConnector.Get(objName);
                List <T> lstRetrievedObj = new List <T>();
                var      ser             = new DataContractJsonSerializer(typeof(T));

                foreach (string str in lstObj)
                {
                    using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(str)))
                    {
                        var processedObj = (T)ser.ReadObject(ms);
                        lstRetrievedObj.Add(processedObj);
                    }
                }
                return(lstRetrievedObj);
            }
            else
            {
                return(null);
            }
        }
コード例 #16
0
        public static string JsonfyWebAuthenticateUser(string authToken)
        {
            //var authToken = "asdasdasd";
            var oV = new PocoO()
            {
                SessionToken = authToken
            };
            Request r = new Request()
            {
                m = 0,
                i = 0,
                n = "WebAuthenticateUser",
                o = oV
            };

            DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(Request));
            MemoryStream stream           = new MemoryStream();

            js.WriteObject(stream, r);
            stream.Position = 0;
            var result = new StreamReader(stream).ReadToEnd();

            return(result);
        }
コード例 #17
0
        public static async Task <Tuple <string, IReadOnlyList <YouTubeVideo> > > LoadVideosAsync(string q, string orderBy, string pageToken, int maxResults, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (q == null)
            {
                q = "";
            }

            var youtubeUrl = string.Format("https://www.googleapis.com/youtube/v3/search?part=snippet&type=video&q={0}&order={1}&maxResults={2}{3}&key={4}", Uri.EscapeUriString(q), orderBy, maxResults, string.IsNullOrWhiteSpace(pageToken) ? "" : "&pageToken=" + pageToken, "AIzaSyCGIvlreIsHaOVVoR2JAPJnbHkSUv3v4y0");

            var client   = new HttpClient();
            var response = await client.GetAsync(youtubeUrl, cancellationToken);

            if (response.IsSuccessStatusCode)
            {
                var videos     = new List <YouTubeVideo>();
                var serializer = new DataContractJsonSerializer(typeof(YouTubeSearchResult));
                var result     = serializer.ReadObject(await response.Content.ReadAsStreamAsync()) as YouTubeSearchResult;
                foreach (var item in result.Items)
                {
                    var video = new YouTubeVideo()
                    {
                        Title        = item.Snippet.Title,
                        Description  = item.Snippet.Description,
                        Thumbnail    = item.Snippet.Thumbnails.Default.Url,
                        Link         = "http://www.youtube.com/watch?v=" + item.Id.VideoId,
                        ChannelTitle = item.Snippet.ChannelTitle,
                    };
                    videos.Add(video);
                }
                return(new Tuple <string, IReadOnlyList <YouTubeVideo> >(result.NextPageToken, videos));
            }
            else
            {
                throw new Exception(await response.Content.ReadAsStringAsync());
            }
        }
コード例 #18
0
ファイル: FileManager.cs プロジェクト: narekhay/Diplomayin
        static Task SerializeAndSaveFile <T>(T source, string path)
        {
            return(Task.Run(async() =>
            {
                DataContractJsonSerializer jserializer = new DataContractJsonSerializer(typeof(T));
                Stream destination = new MemoryStream();
                Stream tempStream = new MemoryStream();
                jserializer.WriteObject(tempStream, source);

                //Write length
                int jsonPartSize = (int)tempStream.Position;
                byte [] jsonLengthArray = BitConverter.GetBytes(jsonPartSize);
                await destination.WriteAsync(jsonLengthArray, 0, jsonLengthArray.Length);
                tempStream.Seek(0, SeekOrigin.Begin);

                //Write PFile
                await tempStream.CopyToAsync(destination);

                //Write image
                (source as PFile).Data.Seek(0, SeekOrigin.Begin);
                await(source as PFile).Data.CopyToAsync(destination);
                return SaveFileAsync(path, destination);
            }));
        }
コード例 #19
0
        /// <inheritdoc/>
        public async Task <AltinnCore.RepositoryClient.Model.User> GetCurrentUser()
        {
            AltinnCore.RepositoryClient.Model.User user       = null;
            DataContractJsonSerializer             serializer = new DataContractJsonSerializer(typeof(AltinnCore.RepositoryClient.Model.User));
            Uri endpointUrl = new Uri(GetApiBaseUrl() + "/user");

            using (HttpClient client = GetApiClient())
            {
                HttpResponseMessage response = await client.GetAsync(endpointUrl);

                if (response.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    Stream stream = await response.Content.ReadAsStreamAsync();

                    user = serializer.ReadObject(stream) as AltinnCore.RepositoryClient.Model.User;
                }
                else
                {
                    _logger.LogError("User " + AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext) + " Get current user failed with statuscode " + response.StatusCode);
                }
            }

            return(user);
        }
コード例 #20
0
        /// <inheritdoc />
        public async Task <Branch> GetBranch(string owner, string repository, string branch)
        {
            Branch branchinfo = null;
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Branch));
            Uri giteaUrl = new Uri($"{GetApiBaseUrl()}/repos/{owner}/{repository}/branches/{branch}");

            using (HttpClient client = GetApiClient())
            {
                HttpResponseMessage response = await client.GetAsync(giteaUrl);

                if (response.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    Stream stream = await response.Content.ReadAsStreamAsync();

                    branchinfo = serializer.ReadObject(stream) as Branch;
                }
                else
                {
                    _logger.LogError("User " + AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext) + " GetBranch response failed with statuscode " + response.StatusCode + " for " + owner + " / " + repository + " branch: " + branch);
                }
            }

            return(branchinfo);
        }
コード例 #21
0
        private DataContractJsonSerializer CreateDataContractSerializer(Type type, bool throwOnError)
        {
            Contract.Assert(type != null);

            DataContractJsonSerializer serializer = null;
            Exception exception = null;

            try
            {
                // Verify that type is a valid data contract by forcing the serializer to try to create a data contract
                FormattingUtilities.XsdDataContractExporter.GetRootElementName(type);
                serializer = CreateDataContractSerializer(type);
            }
            catch (Exception caught)
            {
                exception = caught;
            }

            if (serializer == null && throwOnError)
            {
                if (exception != null)
                {
                    throw Error.InvalidOperation(exception, Properties.Resources.SerializerCannotSerializeType,
                                                 typeof(DataContractJsonSerializer).Name,
                                                 type.Name);
                }
                else
                {
                    throw Error.InvalidOperation(Properties.Resources.SerializerCannotSerializeType,
                                                 typeof(DataContractJsonSerializer).Name,
                                                 type.Name);
                }
            }

            return(serializer);
        }
コード例 #22
0
        /// <summary>
        /// Returns all branch information for a repository
        /// </summary>
        /// <param name="owner">The owner</param>
        /// <param name="repo">The name of the repo</param>
        /// <returns>The branches</returns>
        public async Task <List <Branch> > GetBranches(string owner, string repo)
        {
            List <Branch> branches = null;
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(List <Branch>));
            Uri giteaUrl = new Uri(GetApiBaseUrl() + "/repos/" + owner + "/" + repo + "/branches");

            using (HttpClient client = GetApiClient())
            {
                HttpResponseMessage response = await client.GetAsync(giteaUrl);

                if (response.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    Stream stream = await response.Content.ReadAsStreamAsync();

                    branches = serializer.ReadObject(stream) as List <Branch>;
                }
                else
                {
                    _logger.LogError("User " + AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext) + " GetBranches response failed with statuscode " + response.StatusCode + " for " + owner + " " + repo);
                }
            }

            return(branches);
        }
コード例 #23
0
ファイル: GalleryServer.cs プロジェクト: lazlojuly/nuget
        private void PublishPackage(PublishState state)
        {
            var url = new Uri(String.Format(CultureInfo.InvariantCulture, "{0}/{1}", _baseGalleryServerUrl, PublishPackageService));

            using (Stream requestStream = new MemoryStream()) {
                var data = new PublishData {
                    Key     = state.PublishKey,
                    Id      = state.PackageMetadata.Id,
                    Version = state.PackageMetadata.Version.ToString()
                };

                var jsonSerializer = new DataContractJsonSerializer(typeof(PublishData));
                jsonSerializer.WriteObject(requestStream, data);
                requestStream.Seek(0, SeekOrigin.Begin);

                WebClient client = new WebClient();
                client.Proxy = _cachedProxy;
                client.Headers[HttpRequestHeader.ContentType] = "application/json";
                client.Headers[HttpRequestHeader.UserAgent]   = _userAgent;
                client.UploadProgressChanged += OnUploadProgressChanged;
                client.UploadDataCompleted   += OnPublishPackageCompleted;
                client.UploadDataAsync(url, "POST", requestStream.ReadAllBytes(), state);
            }
        }
コード例 #24
0
        public static void GetMatch(int fromId, string[] data)
        {
            try
            {
                // values
                string roomName = data[1];
                if (!RoomManager.GetInstance().TryGetRoom(roomName, out Room room))
                {
                    throw new MyException(string.Format("Room {0} not found", roomName));
                }
                Match match = room.GetMatch();
                if (match == null)
                {
                    throw new MyException(string.Format("Room {0} has no match", roomName));
                }

                // serialization
                DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Match));
                MemoryStream stream            = new MemoryStream();
                ser.WriteObject(stream, match);
                stream.Position = 0;
                StreamReader sr = new StreamReader(stream);

                string json = sr.ReadToEnd();
                Send(fromId, "getMatch;;success;;" + json);
            }
            catch (MyException e)
            {
                Send(fromId, "getMatch;;failed;;" + e.Message);
            }
            catch (Exception e)
            {
                Send(fromId, "getMatch;;failed;;server error");
                Console.WriteLine(e.Message + " -- " + e.StackTrace);
            }
        }
コード例 #25
0
        public T SendRequest <T>()
        {
            string rawResponse = string.Empty;

            try
            {
                HttpWebRequest httpWebRequest = WebRequest.Create(string.Format("{0}/json", _uri)) as HttpWebRequest;

                using (StreamReader streamReader = new StreamReader(httpWebRequest.GetResponse().GetResponseStream()))
                {
                    rawResponse = streamReader.ReadToEnd();
                }

                using (MemoryStream memoryStream = new MemoryStream(Encoding.Unicode.GetBytes(rawResponse)))
                {
                    DataContractJsonSerializer dataContractSerializer = new DataContractJsonSerializer(typeof(T));
                    return((T)dataContractSerializer.ReadObject(memoryStream));
                }
            }
            catch (Exception ex)
            {
                return(default(T));
            }
        }
コード例 #26
0
        /// <summary> Serialize a given object to a JSON stream (i.e., take a given object and convert it to JSON ) </summary>
        /// <param name="obj"> An object; typically a JObject (not certain how it deals with objects besides JObjects) </param>
        /// <returns></returns>
        public string ReturnJsonFromObject(object obj)
        {
            //Create a stream to serialize the object to.
            MemoryStream mS = new MemoryStream();

            Type objType = obj.GetType();
            // Console.WriteLine($"ApiSerializer > ReturnJsonFromObject.objType: {objType}");

            // Serializer the given object to the stream
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(objType);

            serializer.WriteObject(mS, obj);
            byte[] json = mS.ToArray();
            mS.Position = 0;

            StreamReader sR = new StreamReader(mS);

            // this prints all object content in json format
            // Console.WriteLine($"Streamreader: {sR.ReadToEnd()}");
            sR.Dispose();

            mS.Close();
            return(Encoding.UTF8.GetString(json, 0, json.Length));
        }
コード例 #27
0
        public static string RestaurauntToString(Restauraunt target)
        {
            MemoryStream ms = new MemoryStream();
            string       jsonString;

            try
            {
                DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Restauraunt));
                ms.Position = 0;
                StreamReader sr = new StreamReader(ms);
                ser.WriteObject(ms, target);
                ms.Position = 0;
                jsonString  = sr.ReadToEnd();
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                ms.Close();
            }
            return(jsonString);
        }
コード例 #28
0
        public static Restauraunt StringToRestauraunt(string jsonString)
        {
            //deserializer goes here
            Restauraunt  deserializedRestauraunt;
            MemoryStream ms = new MemoryStream();

            try
            {
                DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Restauraunt));
                byte[] bytes = Encoding.ASCII.GetBytes(jsonString);
                ms.Write(bytes, 0, Encoding.ASCII.GetByteCount(jsonString));
                ms.Position             = 0;
                deserializedRestauraunt = (Restauraunt)ser.ReadObject(ms);
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                ms.Close();
            }
            return(deserializedRestauraunt);
        }
コード例 #29
0
        public void DataContractJsonSerializerTest()
        {
            var        serialzer = new DataContractJsonSerializer(typeof(TestObject));
            TestObject input     = TestObject.Generater();

            using (MemoryStream msr = new MemoryStream()) {
                serialzer.WriteObject(msr, input);
                msr.Flush();
                msr.Seek(0, SeekOrigin.Begin);
                StreamReader sr = new StreamReader(msr);
                string       s  = sr.ReadToEnd();

                using (MemoryStream msw = new MemoryStream()) {
                    StreamWriter sw = new StreamWriter(msw);
                    sw.Write(s);
                    sw.Flush();
                    msw.Position = 0;
                    TestObject output = (TestObject)serialzer.ReadObject(msw);
                    bool       value  = TestObject.IsEquals(input, output);

                    Assert.IsTrue(value);
                }
            }
        }
コード例 #30
0
 private void CreateAzureADApplication(string accessToken, AADApplication app)
 {
     string url = string.Format(GraphUrl, "myorganization/applications/");
     string postData;
     DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(AADApplication));
     using (MemoryStream stream = new MemoryStream())
     {
         ser.WriteObject(stream, app);
         postData = Encoding.Default.GetString(stream.ToArray());
     }
     HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
     System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
     byte[] data = encoding.GetBytes(postData);
     request.Method = "POST";
     request.Headers.Add(HttpRequestHeader.Authorization, string.Format("{0} {1}", "Bearer", accessToken));
     request.ContentType = "application/json";
     request.ContentLength = data.Length;
     request.UserAgent = "http://www.vipswapper.com/cloudstack";
     using (Stream stream = request.GetRequestStream())
     {
         stream.Write(data, 0, data.Length);
     }
     WebResponse response = request.GetResponse();
 }
コード例 #31
0
        /// <summary>
        /// Returns information about a organization based on name
        /// </summary>
        /// <param name="name">The name of the organization</param>
        /// <returns>The organization</returns>
        public async Task <AltinnCore.RepositoryClient.Model.Organization> GetOrganization(string name)
        {
            AltinnCore.RepositoryClient.Model.Organization organization = null;
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(AltinnCore.RepositoryClient.Model.Organization));
            Uri giteaUrl = new Uri(GetApiBaseUrl() + "/orgs/" + name);

            using (HttpClient client = GetApiClient())
            {
                HttpResponseMessage response = await client.GetAsync(giteaUrl);

                if (response.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    Stream stream = await response.Content.ReadAsStreamAsync();

                    organization = serializer.ReadObject(stream) as AltinnCore.RepositoryClient.Model.Organization;
                }
                else
                {
                    _logger.LogError("User " + AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext) + " GetOrganization failed with statuscode " + response.StatusCode + "for " + name);
                }
            }

            return(organization);
        }
コード例 #32
0
        public virtual string SerializeJSon <T>(T t)
        {
            DataContractJsonSerializerSettings settings = new DataContractJsonSerializerSettings()
            {
                DateTimeFormat            = new DateTimeFormat(DateTimeFormat),
                UseSimpleDictionaryFormat = true
            };

            MemoryStream stream           = new MemoryStream();
            DataContractJsonSerializer ds = new DataContractJsonSerializer(t.GetType(), settings);

            ds.WriteObject(stream, t);
            byte[] data       = stream.ToArray();
            string jsonString = Encoding.UTF8.GetString(data, 0, data.Length);

            if (IsLegacy)
            {
                if (typeof(T).IsArray)
                {
                    jsonString = "{\"" + typeof(T).Name.ToLower().Replace("[]", "s") + "\":" + jsonString + "}";
                }
                else
                {
                    jsonString = "{\"" + typeof(T).Name.ToLower() + "\":" + jsonString + "}";
                }
            }

            stream.Dispose();

            if (jsonSeFilter != null)
            {
                jsonString = jsonSeFilter.Invoke(jsonString);
            }

            return(jsonString);
        }
コード例 #33
0
        /// <summary>
        /// Sends an event into the instance.
        /// </summary>
        /// <param name="instanceId">The instance id.</param>
        /// <param name="event">The <see cref="JsonEvent"/> instance containing the event data.</param>
        public void SendJsonEvent(string instanceId, JsonEvent @event)
        {
            try {
                var instance = GetInstanceOrFault(instanceId);
                var fabricator = instance.SchemaFabricator;
                var eventBytes = System.Text.Encoding.UTF8.GetBytes(@event.EventData);
                var dictionaryReader = JsonReaderWriterFactory.CreateJsonReader(
                        eventBytes, 0, eventBytes.Length, new XmlDictionaryReaderQuotas());

                var fabricatorType = fabricator.GetType(@event.EventType);
                if (fabricatorType != null)
                {
                    var serializer = new DataContractJsonSerializer(fabricatorType);
                    var trueEntity = serializer.ReadObject(dictionaryReader);
                    instance.SendEvent(trueEntity);
                }
                else
                {
                    var dictionaryDocument = XDocument.Load(dictionaryReader);
                    dictionaryDocument.Root.Name = @event.EventType;
                    instance.SendEvent(dictionaryDocument.Root);
                }
            }
            catch (EPException e) {
                Log.Warn("SendJsonEvent: BadRequest returned: {0}", e.Message);
                throw new WebFaultException<string>(e.Message, HttpStatusCode.BadRequest);
            }
        }
コード例 #34
0
ファイル: MapPage.xaml.cs プロジェクト: JLBR/School-Projects
        private void parseResponseData(String aResponse)
        {
            placesListObj = new PlacesList();

            MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(aResponse));
            DataContractJsonSerializer ser = new DataContractJsonSerializer(placesListObj.GetType());
            placesListObj = ser.ReadObject(ms) as PlacesList;
            ms.Close();

            // updating UI
            if (placesListObj != null)
            {
                updateMap(placesListObj);
            }
        }
コード例 #35
0
ファイル: DcjsPerformanceTest.cs プロジェクト: ESgarbi/corefx
 public void Init(object obj)
 {
     _serializer = new DataContractJsonSerializer(obj.GetType());
 }
コード例 #36
0
 private AdmAccessToken HttpPost(string DatamarketAccessUri, string requestDetails)
 {
     System.Net.ServicePointManager.ServerCertificateValidationCallback +=
         delegate(object sender, System.Security.Cryptography.X509Certificates.X509Certificate certificate,
             System.Security.Cryptography.X509Certificates.X509Chain chain,
             System.Net.Security.SslPolicyErrors sslPolicyErrors)
     {
         return true; // **** Always accept
     };
     //Prepare OAuth request
     WebRequest webRequest = WebRequest.Create(DatamarketAccessUri);
     webRequest.ContentType = "application/x-www-form-urlencoded";
     webRequest.Method = "POST";
     byte[] bytes = Encoding.ASCII.GetBytes(requestDetails);
     webRequest.ContentLength = bytes.Length;
     using (Stream outputStream = webRequest.GetRequestStream())
     {
         outputStream.Write(bytes, 0, bytes.Length);
     }
     using (WebResponse webResponse = webRequest.GetResponse())
     {
         DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(AdmAccessToken));
         //Get deserialized object from JSON stream
         AdmAccessToken token = (AdmAccessToken)serializer.ReadObject(webResponse.GetResponseStream());
         return token;
     }
 }
コード例 #37
0
ファイル: ClassWebAPI.cs プロジェクト: Qrain/photo-tool
 /// <summary>
 /// Return JSON value as object
 /// </summary>
 /// <param name="resStream"></param>
 /// <param name="t"></param>
 /// <returns></returns>
 public static object getObjectFromJson(System.IO.Stream resStream, Type t)
 {
     var serializer = new DataContractJsonSerializer(t);
     return serializer.ReadObject(resStream);
 }