I'm doing a class that gets a string of a JSON (that represents an object) and I'm deserializing it using JSON.NET from Newtonsoft. As I don't know exactly the object that I need to serialize what I'm doing with the JSON.NET library is to get a Dictionary.
The thing is that I'm processing each property differently depending of its type. I can recognize without problems the date or intes by comparing the parsed object JToken.Type with for instance JTokenType.Date.
However the type JTokenType.Bytes, seem to not be working. Then I have this problem, I have a string that represents a normal string an a string that represents a byte[]. How can I distinguish them? Either by using the JTokenType class or other types? Any idea?
Lot of thanks
Best regards
I attach here an example of the JSON that I'm parsing:
{"firstName":"Mario","lastName":"Bross","users":[{"name":"Tony","country":"UK","telephone":"663242342"},{"name":"Ahmed","country":"UAE","telephone":"66934534"},{"name":"Alejandro","country":"ES","telephone":"666243098"}],"firstTable":true,"secondTable":false,"greeting":false,"headerInfo":"This is a test document","footerInfo":"This page ends here","date":"2016-03-29T00:00:00+02:00","remark":"Here we have some remarks","logo":"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...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"}
The last property is a picture (byte[])
Given a string of printable characters, you want to determine whether that string has been base64 encoded or not. This is not possible. You can determine if a string may have been base64 encoded:
How to check whether the string is base64 encoded or not
But it is possible for a user to construct a string that looks as if it was base64 encoded, but in fact was not.
If you have control over the data source, you should add an extra metadata field to indicate whether a field is bas64 encoded or not.
Related
I'm trying to deserialize json into a C# object. The json basically looks like this:
{ "hexValue": "0x9a7f" }
My POCO looks like this:
public class HexTest
{
public int hexValue;
}
I've read in a link from this question that Newtonsoft supports deserializing hex values. But in all fairness, those release notes were published a decade ago. I've even read in some source code on github
published here what appears to be code to deserialize a hex formatted string that starts with "0x". Yet, when I try to deserialize a hex value, I always get the following exception:
Could not convert string to int: 0x9a7f.
It doesn't matter what type I try. I've tried using int long decimal Decimal, etc... From reading the source it looked like the Decimal type should have worked but nothing works. Does Newtonsoft really have support for converting hex values defined as strings into a numeric data type of some kind?
Sure, I know I can use the information in the question I linked to above to implement custom support for it but I'd really rather use the built-in support if it's there.
Thanks to the comments to my original question above by Fildor, I was able to resolve the problem by removing quotes around the value in the JSON so it now read like this:
{ "hexValue": 0x9a7f }
Also, further testing reveals that any of the numeric data types work for this in the POCO including int, long, and decimal. It is probably worth noting that (not sure about the latest standard) most if not all JSON validators will consider this invalid JSON because hexadecimal is not a valid JSON numeric data type.
Taking another look at the source, it's clear why this works and not the string. The parser will only call the method that detects the 0x prefix if it recognizes the json value token as a numeric type which, if quoted, it cannot do because by definition, that is a string.
I was CBOR serializing a JSON object in C++ with nlohmann::json library and my use case involves reading the cbor byte string output in c#. I've noticed that, whereas when dumping a json object to a string in C++ with nlohmann::json library, json string values (i.e., case value_t::string) are escaped (a call to escape_string is made), no such call is made when json values are string values in the CBOR approach.
I was reading the CBOR CRF 7049 and it seems that strings do not need to be escaped when serializing to CBOR.
The behavior in the nlohmann::json library is consistent: strings are not escaped when serializing, nor excepted to be escaped when de-serializing.
But it appears that Newtonsoft.Json (C# library), expects that. Is it a valid expectation? Or am I doing something wrong in the process?
C++ side:
nlohmann::json json_doc;
json_doc["characters"] = nlohmann::json::array();
for (int i = 0; i < characters.size(); i++) {
json_doc["characters"][i]["name"] = (characters[i] != nullptr) ? characters[i]->name() : "";
}
std::vector<uint8_t> cbor = nlohmann::json::to_cbor(json_doc);
output->assign((char*)&cbor[0], cbor.size());
C# side. cbor_bytes is the cbor byte string (c++ output vector)
CBORObject cbor = CBORObject.DecodeFromBytes(cbor_bytes);
output = cbor.ToString();
Such output string by then, is wrongly formed:
{"characters": [{"name": "Clara Oswald"}, {"name": "Kensi Blye"}, {"name": "Temperance "Bones" Brennan"}]}
and cannot, obviously be parsed:
JObject output_obj = JObject.Parse(output);
CBOR (Concise Binary Object Representation) is not JSON (JavaScript Object Notation). Although CBOR may have borrowed some concepts from JSON, it is clearly a different format with different rules and goals. CBOR is a binary format; JSON is text. In CBOR, strings have length prefixes, whereas they do not in JSON. Furthermore, CBOR does not allow arbitrary whitespace between elements (it wouldn't make sense for a binary format), whereas JSON does (for human readability). Ultimately, CBOR does not need a mechanism to escape strings because it does not require delimiters to tell where a string starts and ends. JSON, on the other hand, requires double quotes to mark the beginning and end of each string. As a consequence, quotes and control characters within strings must be escaped with backslashes in JSON, as well as literal backslashes themselves. There is no getting around this rule if you want to ensure the JSON will be parsable.
In your code above you are using the CBORObject.ToString() method to turn the object into a string. If this CBORObject is from a third-party library, does the documentation state that ToString() will produce valid JSON? If so, then it definitely has a bug; it should be doing the proper escaping as required by the JSON spec. If there is no such promise of valid JSON, then you can't expect that Json.Net will be able to parse the string, even if it sort of looks like JSON. (You might check to see whether the CBORObject has some other dedicated method like ToJson() for performing this conversion.) If CBORObject is your own code, then it is on you to escape the strings properly when converting from CBOR to JSON.
I have large amount of data which consists of tables,font,bold,size,etc. Those data will be stored as byte[] in Database.
when i retrieve those data i need to convert byte[] into string,because i need to some find & replace from this string,after i convert this string into byte[],am losing the original data structure which means, i can't able to see any tables,font,bold etc. properly. So how can i find and replace in byte[] by converting string and also to keep remain the data in original format.
The short answer is don't. Figure out the format of the data and see what you can do to do the manipulation. If the data is actually text, just stored as byte[], your approach would work, provided you encode the string correctly (ie. if your DB expects UTF-8, use UTF-8 encoding, if it's windows-1251, use that).
If you have a structure where a part of it is a string, what you're doing can't really work well. First, you probably want to modify just the relevant parts of the field. On MS SQL, you have handy functions for that. But even then, you should know what's actually stored there, not just assume that a string replace will magically work.
Now, a hack could be to use an explicit encoding that doesn't break the non-string data. That would be some single-byte encoding that doesn't do anything fancy. This is OK as long as you use the same encoding while reading the text data - however, if you use any variant of unicode, you're out of luck; due to features like string normalization, you can't really guarantee that what comes in comes out the same way, per-byte. It's generally a bad practice anyway.
Don't forget that it's quite possible the string you are looking for is actually somewhere outside of the text fields - even by pure chance, it can happen, and certain practices make that even more likely.
Again: figure out the data format inside that data field - then you can decide how to do what you want.
Try this
string result = System.Text.Encoding.UTF8.GetString(byteArray)
To make Byte[] to String
byte[] byteArray = new byte[10]; // put your byte array here
public void byteToString()
{
stringTemp = "";
stringTemp = BitConverter.ToString(byteArray).Replace("-", "");
}
And your data still in byteArray.. :)
If the byte Array contains binary data and is no string, try to convert it to base64:
Convert.ToBase64String(yourByteArray);
I have a text that is a property of an object.The object gets XmlSerialized and after that there is an element in the XML call Text that represents the text from the object.I am wondering how to turn it back to string.
THE TYPE OF SERIALIZATION: XmlSerializer serizlizer = new XmlSerializer(typeof(Act));
THE PROPERTY IN THE CLASS :
[System.Runtime.Serialization.OptionalFieldAttribute()]
private byte[] ActTextField;
In the xml file it looks something like that:
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
I can not even suppose what is its encoding and how to decode it.I tried to read it into byte array but it didn't actualy work after applying few decodings Encode.UTF8 , Encode.ASCII,
That looks like Base64 to me - just use
byte[] data = Convert.FromBase64String(base64Text);
It's odd that it's using base64 at all if this is really a text property though. I'd expect just the text.
To convert that binary data back to text you would need to know which encoding was used to convert it to the binary data to start with - and UTF-8 is the most likely - but all the repeated AAAAA... parts in there make this look pretty unlike text, to be honest.
EDIT: Now that we've seen the field declaration, we can see that it was a byte[] to start with, so that makes sense for it to be encoded in this way. Judging by comments, it sounds like it's actually a Word file - at which point extracting the text is a very separate problem.
I'm using .NET 4.5 and I'm trying to parse a URI query string into a NameValueCollection. The right way seems to be to use HttpUtility.ParseQueryString(string query) which takes the string obtained from Uri.Queryand returns a NameValueCollection. Uri.Query returns a string that is escaped according to RFC 2396, and HttpUtility.ParseQueryString(string query) expects a string that is URL-encoded. Assuming RFC 2396 and URL-encoding are the same thing, this should work fine.
However, the documentation for ParseQueryString claims that it "uses UTF8 format to parse the query string". There is also an overloaded method which takes a System.Text.Encoding and then uses that instead of UTF8.
My question is: what does it mean to use UTF8 as the encoding? The input is a string, which by definition (in C#) is UTF-16. How is that interpreted as UTF-8? What is the difference between using UTF8 and UTF16 as the encoding in this case? My concern is that since I'm accepting arbitrary user input, there might be some security risk if I botch the encoding (i.e. the user might be able to slip through some script exploit).
There is a previous question on this topic (How to parse a query string into a NameValueCollection in .NET) but it doesn't specifically adress the encoding problem.
When parsing encoded values, it treats those values as UTF-8. Take the character ยข, for example. The UTF-8 encoding is C2 A2. So if it were in a query string, it would be encoded as %C2%A2.
Now, when ParseQueryString is decoding, it needs to know what encoding to use. The default is UTF-8, meaning that the character would be decoded correctly. But perhaps the user was using Microsoft's Cyrillic code page (Windows-1251), where C2 and A2 are two different characters. In that case, interpreting it as UTF-8 would be an error.
If this is a user interface application (i.e. the user is entering data directly), then you probably want to use whatever encoding is defined for the current UI culture. If you're getting this information from Web pages, then you'll want to use whatever encoding the page uses. And if you're writing a Web service then you can tell the users that their input has to be UTF-8 encoded.