/// <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"];
}
}
}
}
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;
}
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;
}
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);
}
}
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;
});
}
}
/// <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());
}
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);
}
}
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);
}
}
}
/// <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);
}
/// <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);
}
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);
}
}
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 + "¶m=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");
}
}
}
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();
}
}
/// <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));
}
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);
}
}
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);
}
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());
}
}
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);
}));
}
/// <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);
}
/// <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);
}
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);
}
/// <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);
}
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);
}
}
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);
}
}
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));
}
}
/// <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));
}
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);
}
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);
}
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);
}
}
}
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();
}
/// <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);
}
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);
}
/// <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);
}
}
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);
}
}
public void Init(object obj)
{
_serializer = new DataContractJsonSerializer(obj.GetType());
}
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;
}
}
/// <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);
}
