Как мне конвертировать binary в bytes []?

Question

[XDecent]

Для сохранений в моей игре я использую BinarySerializer,но для сохранений в Google Play Games мне нужно как-то конвертировать мои сохранения в массив bytes []

using UnityEngine;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

public class BinarySerializer
{
	static string folderName = "GameData";

	static string persistentDataPath = Application.persistentDataPath;
	static SurrogateSelector surrogateSelector = GetSurrogateSelector ();

	/// <summary>
	/// Save data to disk.
	/// </summary>
	/// <param name="data">your dataClass instance.</param>
	/// <param name="filename">the file where you want to save data.</param>
	/// <returns></returns>
	public static void Save <T> (T data, string filename)
	{
		if (IsSerializable <T> ()) {
			if (!Directory.Exists (GetDirectoryPath ()))
				Directory.CreateDirectory (GetDirectoryPath ());

			BinaryFormatter formatter = new BinaryFormatter ();

			formatter.SurrogateSelector = surrogateSelector;

			FileStream file = File.Create (GetFilePath (filename));

			formatter.Serialize (file, data);

			file.Close ();
		}
	}

	/// <summary>
	/// Save data to disk.
	/// </summary>
	/// <param name="filename">the file where you saved data.</param>
	/// <returns></returns>
	public static T Load<T> (string filename)
	{
		T data = System.Activator.CreateInstance <T> ();

		if (IsSerializable <T> ()) {
			if (HasSaved (filename)) {
				
				BinaryFormatter formatter = new BinaryFormatter ();

				formatter.SurrogateSelector = surrogateSelector;

				FileStream file = File.Open (GetFilePath (filename), FileMode.Open);

				data = (T)formatter.Deserialize (file);

				file.Close ();
			}
		}

		return data;
	}

	static bool IsSerializable<T> ()
	{
		bool isSerializable = typeof(T).IsSerializable;
		if (!isSerializable) {
			string type = typeof(T).ToString ();
			Debug.LogError (
				"Class <b><color=white>" + type + "</color></b> is not marked as Serializable, "
				+ "make sure to add <b><color=white>[System.Serializable]</color></b> at the top of your " + type + " class."
			);
		}

		return isSerializable;
	}


	/// <summary>
	/// Check if data is saved.
	/// </summary>
	/// <param name="filename">the file where you saved data</param>
	/// <returns></returns>
	public static bool HasSaved (string filename)
	{
		return File.Exists (GetFilePath (filename));
	}

	static string GetDirectoryPath ()
	{
		return persistentDataPath + "/" + folderName;
	}

	static string GetFilePath (string filename)
	{
		return  GetDirectoryPath () + "/" + filename;
	}


	//Other non-serialized types /// SS: Serialization Surrogate
	//Vector2 , Vector3 , Vector4 , Color , Quaternion.

	static SurrogateSelector GetSurrogateSelector ()
	{
		SurrogateSelector surrogateSelector = new SurrogateSelector ();

		Vector2_SS v2_ss = new Vector2_SS ();
		Vector3_SS v3_ss = new Vector3_SS (); 
		Vector4_SS v4_ss = new Vector4_SS (); 
		Color_SS co_ss = new Color_SS ();
		Quaternion_SS qu_ss = new Quaternion_SS ();

		surrogateSelector.AddSurrogate (typeof(Vector2), new StreamingContext (StreamingContextStates.All), v2_ss);
		surrogateSelector.AddSurrogate (typeof(Vector3), new StreamingContext (StreamingContextStates.All), v3_ss);
		surrogateSelector.AddSurrogate (typeof(Vector4), new StreamingContext (StreamingContextStates.All), v4_ss);
		surrogateSelector.AddSurrogate (typeof(Color), new StreamingContext (StreamingContextStates.All), co_ss);
		surrogateSelector.AddSurrogate (typeof(Quaternion), new StreamingContext (StreamingContextStates.All), qu_ss);

		return surrogateSelector;
	}

	class Vector2_SS: ISerializationSurrogate
	{
		//Serialize Vector2
		public void GetObjectData (System.Object obj, SerializationInfo info, StreamingContext context)
		{
			Vector2 v2 = (Vector2)obj;
			info.AddValue ("x", v2.x);
			info.AddValue ("y", v2.y);
		}
		//Deserialize Vector2
		public System.Object SetObjectData (System.Object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
		{
			Vector2 v2 = (Vector2)obj;

			v2.x = (float)info.GetValue ("x", typeof(float));
			v2.y = (float)info.GetValue ("y", typeof(float));

			obj = v2;
			return obj;
		}
	}

	class Vector3_SS: ISerializationSurrogate
	{
		//Serialize Vector3
		public void GetObjectData (System.Object obj, SerializationInfo info, StreamingContext context)
		{
			Vector3 v3 = (Vector3)obj;
			info.AddValue ("x", v3.x);
			info.AddValue ("y", v3.y);
			info.AddValue ("z", v3.z);
		}
		//Deserialize Vector3
		public System.Object SetObjectData (System.Object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
		{
			Vector3 v3 = (Vector3)obj;

			v3.x = (float)info.GetValue ("x", typeof(float));
			v3.y = (float)info.GetValue ("y", typeof(float));
			v3.z = (float)info.GetValue ("z", typeof(float));

			obj = v3;
			return obj;
		}
	}

	class Vector4_SS: ISerializationSurrogate
	{
		//Serialize Vector4
		public void GetObjectData (System.Object obj, SerializationInfo info, StreamingContext context)
		{
			Vector4 v4 = (Vector4)obj;
			info.AddValue ("x", v4.x);
			info.AddValue ("y", v4.y);
			info.AddValue ("z", v4.z);
			info.AddValue ("w", v4.w);
		}
		//Deserialize Vector4
		public System.Object SetObjectData (System.Object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
		{
			Vector4 v4 = (Vector4)obj;

			v4.x = (float)info.GetValue ("x", typeof(float));
			v4.y = (float)info.GetValue ("y", typeof(float));
			v4.z = (float)info.GetValue ("z", typeof(float));
			v4.w = (float)info.GetValue ("w", typeof(float));

			obj = v4;
			return obj;
		}

	}

	class Color_SS: ISerializationSurrogate
	{
		//Serialize Color
		public void GetObjectData (System.Object obj, SerializationInfo info, StreamingContext context)
		{
			Color color = (Color)obj;
			info.AddValue ("r", color.r);
			info.AddValue ("g", color.g);
			info.AddValue ("b", color.b);
			info.AddValue ("a", color.a);
		}
		//Deserialize Color
		public System.Object SetObjectData (System.Object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
		{
			Color color = (Color)obj;

			color.r = (float)info.GetValue ("r", typeof(float));
			color.g = (float)info.GetValue ("g", typeof(float));
			color.b = (float)info.GetValue ("b", typeof(float));
			color.a = (float)info.GetValue ("a", typeof(float));

			obj = color;
			return obj;
		}
	}

	class Quaternion_SS: ISerializationSurrogate
	{
		//Serialize Quaternion
		public void GetObjectData (System.Object obj, SerializationInfo info, StreamingContext context)
		{
			Quaternion qua = (Quaternion)obj;
			info.AddValue ("x", qua.x);
			info.AddValue ("y", qua.y);
			info.AddValue ("z", qua.z);
			info.AddValue ("w", qua.w);
		}
		//Deserialize Quaternion
		public System.Object SetObjectData (System.Object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
		{
			Quaternion qua = (Quaternion)obj;

			qua.x = (float)info.GetValue ("x", typeof(float));
			qua.y = (float)info.GetValue ("y", typeof(float));
			qua.z = (float)info.GetValue ("z", typeof(float));
			qua.w = (float)info.GetValue ("w", typeof(float));

			obj = qua;
			return obj;
		}
	}
}

Answer 1

[Алексей Березников]

Так сериализуйте не в FileStream а в MemoryStream, оттуда вытащить байты проще простого

Comments

[XDecent]

как вытащить байты?я в этом очень слабо разбираюсь(

[Василий Банников]

XDecent, так вот из MemoryStream и можно вытащить - там для этого толи метод толи свойство есть.

[Алексей Березников]

Хорошее правило - сначала спросить у гугла. Открываете гугл, пишете:
C# How to get bytes array from MemoryStream
Где-то на первом экране можно увидеть ссылку на MSDN: MemoryStream.ToArray Method
Это совсем не сложно, не нужно быть экспертом в программировании.
Готовый код выглядит примерно так:

byte[] buffer = null;
using (var ms = new MemoryStream())
{
    formatter.Serialize(ms, data);
    buffer = ms.ToArray();
}

[XDecent]

Алексей Березников, не могу нормально добавить в этот код (

[Алексей Березников]

XDecent, Что именно идёт не так?

[XDecent]

Алексей Березников,

public static void SavePlayerData()
    {
        BinarySerializer.Save(playerData ,"player-data.txt");
        UnityEngine.Debug.Log("<color=green>[PlayerData] Loaded.</color>");
        GPGSManager.WriteSavedData(BinarySerializer.Load<PlayerData>); (Аргумент 1: не удается преобразовать из "группа методов" в "byte[]".)
)
    }

public static T Load<T> (string filename)
	{
		T data = System.Activator.CreateInstance <T> ();

		if (IsSerializable <T> ()) {
			if (HasSaved (filename)) {
				
				BinaryFormatter formatter = new BinaryFormatter ();

				formatter.SurrogateSelector = surrogateSelector;

				FileStream file = File.Open (GetFilePath (filename), FileMode.Open);

				data = (T)formatter.Deserialize (file);
                byte[] buffer = null;
                using (var ms = new MemoryStream())
                {
                    formatter.Serialize(ms, data);
                    buffer = ms.ToArray();
                }
                file.Close ();
            }
		}
		return data;
	}

[Алексей Березников]

Всё равно непонятно, в чём проблема, сделайте отдельные методы, которые будут сохранять/загружать не в файл, а в массив байтов.
Правильно было бы иметь методы Save/Load, которые работают вообще с Stream, тогда там где вам нужно использовать файлы вы сможете передать FileStream, а там, где нужны байты - передать MemoryStream и вызвать ToArray().

[Алексей Березников]

XDecent,
(BinarySerializer.Load<PlayerData>)

Вам же компилятор говорит, где ошибка. В C# при вызове метода обязательны скобки.

[Алексей Березников]

К тому же ToArray() относится к сериализации, а не десериализации. Для десериализации вам наоборот нужно создать MemoryStream, передав в конструктор ваш массив байт, и десериализовывать уже из него.

[Алексей Березников]

Также в духе стековерфлоу будет не лишним добавить, что BinaryFormatter удобен только малым объёмом кода для сериализации. Его не рекомендуется использовать по многим причинам, и если мне не изменяет память, его методы помечены как устаревшие в последних релизах .Net. Топ-2 причины:
1. Как только вы хоть как-то измените структуру сериализуемых данных, у вас всё сломается (есть способы это обойти, но зачем?)
2. Проблемы с безопасностью - фактически при десериализации BinaryFormatter создает экземпляр указанного типа, можно так сформировать массив байт, чтобы выполнить +- произвольный код при десериализации.
Сериализуйте в Json :)

[Борис Животное]

XDecent, в using оберни всё, что реализует интерфейс IDisposable. Так, просто заметил ошибки в коде. Например:

FileStream file = File.Open (GetFilePath (filename), FileMode.Open)

После того как обернул, метод Close вызывать не нужно.