internal DataNodeInfo GetDataNodeInfo()
{
bool shouldSerialize = true;
if (nodeInfo != null)
{
shouldSerialize = false;
}
else
{
nodeInfo = new DataNodeInfo();
}
nodeInfo.Name = Name;
nodeInfo.Comment = Comment;
// We always serialize if this node represents a FileRef. This is because FileRef is a public property,
// so someone could have modified it.
if (shouldSerialize || FileRefFullPath != null)
{
// if we dont have a datanodeinfo it could be either
// a direct object OR a fileref
if (FileRefFullPath != null)
{
nodeInfo.ValueData = FileRef.ToString();
nodeInfo.MimeType = null;
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXFileRef), this.typeNameConverter);
}
else
{
// serialize to string inside the nodeInfo
FillDataNodeInfoFromObject(nodeInfo, value);
}
}
return(nodeInfo);
}
/// <include file='doc\ResXResourceWriter.uex' path='docs/doc[@for="ResXResourceWriter.AddResource3"]/*' />
/// <devdoc>
/// Adds a string resource to the resources.
/// </devdoc>
public void AddResource(ResXDataNode node)
{
// we're modifying the node as we're adding it to the resxwriter
// this is BAD, so we clone it. adding it to a writer doesnt change it
// we're messing with a copy
ResXDataNode nodeClone = node.DeepClone();
ResXFileRef fileRef = nodeClone.FileRef;
string modifiedBasePath = BasePath;
if (!String.IsNullOrEmpty(modifiedBasePath))
{
if (!(modifiedBasePath.EndsWith("\\")))
{
modifiedBasePath += "\\";
}
if (fileRef != null)
{
fileRef.MakeFilePathRelative(modifiedBasePath);
}
}
DataNodeInfo info = nodeClone.GetDataNodeInfo();
AddDataRow(DataStr, info.Name, info.ValueData, info.TypeName, info.MimeType, info.Comment);
}
/// <devdoc>
/// Adds a resource to the resources. If the resource is a string,
/// it will be saved that way, otherwise it will be serialized
/// and stored as in binary.
/// </devdoc>
private void AddDataRow(string elementName, string name, object value)
{
Debug.WriteLineIf(ResValueProviderSwitch.TraceVerbose, " resx: adding resource " + name);
if (value is string)
{
AddDataRow(elementName, name, (string)value);
}
else if (value is byte[])
{
AddDataRow(elementName, name, (byte[])value);
}
else if (value is ResXFileRef)
{
ResXFileRef fileRef = (ResXFileRef)value;
ResXDataNode node = new ResXDataNode(name, fileRef, this.typeNameConverter);
if (fileRef != null)
{
fileRef.MakeFilePathRelative(BasePath);
}
DataNodeInfo info = node.GetDataNodeInfo();
AddDataRow(elementName, info.Name, info.ValueData, info.TypeName, info.MimeType, info.Comment);
}
else
{
ResXDataNode node = new ResXDataNode(name, value, this.typeNameConverter);
DataNodeInfo info = node.GetDataNodeInfo();
AddDataRow(elementName, info.Name, info.ValueData, info.TypeName, info.MimeType, info.Comment);
}
}
/// <summary>
/// 删除数据
/// </summary>
/// <param name="id">需要删除的ID</param>
/// <returns></returns>
public ActionResult DelData(string id)
{
if (string.IsNullOrEmpty(id))
{
return(JsonTips("warning", "请选择一条数据"));
}
DataNodeInfo dataNodeInfoModel = new DataNodeInfo();
dataNodeInfoModel.DataID = id;
bool isRelations = dataAuthorizeManager.IsDataRelations(dataNodeInfoModel.DataID);
if (isRelations)
{
return(JsonTips("warning", "提示:您所删除的数据节点,与客户组存在数据授权关系,请先删除该数据授权关系."));
}
bool flag = dataAuthorizeManager.Delete(dataNodeInfoModel);
if (flag)
{
return(JsonTips("success", "删除成功"));
}
else
{
return(JsonTips("error", "删除失败"));
}
}
/// <summary>
/// 新增一个数据节点
/// </summary>
/// <param name="datas">数据序列</param>
/// <param name="time">产生数据序列的时间</param>
/// <param name="tag">改数据序列的标识</param>
public void AddData(float[] datas, DateTime time, object tag)
{
if (datas.Length != chartList.Count) //数据的个数必须要和图形数量一致
{
return;
}
DataNodeInfo info = new DataNodeInfo(datas, time, tag);
if (dataList.Count == 0 || dataList[dataList.Count - 1].time < time) //时间比前面的都要靠后，直接添加
{
dataList.Add(info);
for (int i = 0; i < chartList.Count; i++)
{
//chartList[i].chart.Points.AddXY(time, datas[i]);
chartList[i].chart.Points.AddXY(chartList[i].chart.Points.Count, datas[i]);
chartList[i].chart.Points[chartList[i].chart.Points.Count - 1].AxisLabel = info.time.ToString(lableFormat);
}
AdjustAxisValue();
}
else //需要清除后重新排序,再显示
{
dataList.Add(info);
ResetChartData();
}
}
/// <summary>
/// 编辑
/// </summary>
/// <param name="authTokenModel">数据节点对象</param>
/// <returns></returns>
public bool Change(DataNodeInfo dataNodeInfoModel)
{
using (_context = SiteManager.Kernel.Get <ModelContext>())
{
_context.Entry <DataNodeInfo>(dataNodeInfoModel).State = EntityState.Modified;
int res = _context.SaveChanges();
return(res >= 0 ? true : false);
}
}
public FileSender(DataNodeInfo dataNodeInfo, ReplicateFile replicateFile)
{
this.dataNodeInfo = dataNodeInfo;
this.replicateFile = replicateFile;
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
socket.Connect(
new IPEndPoint(IPAddress.Parse("127.0.0.1"), replicateFile.DestinationTcpPort));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public ActionResult Index()
{
DataNodeInfo dataNodeInfoModel = new DataNodeInfo()
{
IsvalId = 1, DataParentID = ""
};
return(View(dataNodeInfoModel));
}
/// <include file='doc\ResXDataNode.uex' path='docs/doc[@for="ResXDataNode.GetObjectData"]/*' />
/// <devdoc>
/// Get the value contained in this datanode
/// </devdoc>
// NOTE: No LinkDemand for SerializationFormatter necessary here, since this class already
// has a FullTrust LinkDemand.
void ISerializable.GetObjectData(SerializationInfo si, StreamingContext context)
{
DataNodeInfo nodeInfo = GetDataNodeInfo();
si.AddValue("Name", nodeInfo.Name, typeof(string));
si.AddValue("Comment", nodeInfo.Comment, typeof(string));
si.AddValue("TypeName", nodeInfo.TypeName, typeof(string));
si.AddValue("MimeType", nodeInfo.MimeType, typeof(string));
si.AddValue("ValueData", nodeInfo.ValueData, typeof(string));
}
/// <summary>
/// 删除一个数据
/// </summary>
/// <param name="itemTag">序列标识</param>
public void RemoveData(object itemTag)
{
DataNodeInfo info = dataList.Find(item => item.Tag == itemTag);
if (info != null)
{
dataList.Remove(info);
ResetChartData();
}
}
/// <summary>
/// 获取数据节点集合
/// </summary>
/// <returns></returns>
public ActionResult GetDataInfo(string id)
{
List <DataNodeInfo> data = dataAuthorizeManager.GetDataById(id);
DataNodeInfo dataNodeInfo = new DataNodeInfo();
if (data.Any())
{
dataNodeInfo = data[0];
}
return(JsonNT(dataNodeInfo));
}
private ResXDataNode(SerializationInfo info, StreamingContext context)
{
DataNodeInfo nodeInfo = new DataNodeInfo();
nodeInfo.Name = (string)info.GetValue("Name", typeof(string));
nodeInfo.Comment = (string)info.GetValue("Comment", typeof(string));
nodeInfo.TypeName = (string)info.GetValue("TypeName", typeof(string));
nodeInfo.MimeType = (string)info.GetValue("MimeType", typeof(string));
nodeInfo.ValueData = (string)info.GetValue("ValueData", typeof(string));
this.nodeInfo = nodeInfo;
InitializeDataNode(null);
}
internal Point ReaderPosition; //only used to track position in the reader
internal DataNodeInfo Clone()
{
DataNodeInfo result = new DataNodeInfo();
result.Name = this.Name;
result.Comment = this.Comment;
result.TypeName = this.TypeName;
result.MimeType = this.MimeType;
result.ValueData = this.ValueData;
result.ReaderPosition = new Point(this.ReaderPosition.X, this.ReaderPosition.Y);
return(result);
}
public FileReceiver(DataNodeInfo dataNodeInfo, CancellationToken token)
{
this.dataNodeInfo = dataNodeInfo;
this.token = token;
var endpoint = new IPEndPoint(IPAddress.Any, dataNodeInfo.TcpPort);
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
socket.Bind(endpoint);
socket.Listen(100);
Console.WriteLine($"start listener on {dataNodeInfo.TcpPort}");
}
/// <summary>
/// 时间排序过程
/// </summary>
private static int CompareChartTime(DataNodeInfo prev, DataNodeInfo next)
{
if (prev.time < next.time)
{
return(-1);
}
else if (prev.time == next.time)
{
return(0);
}
else
{
return(1);
}
}
/// <summary>
/// 验证数据节点id是否重复
/// 通过主键ID来确定操作是新增还是编辑状态
/// </summary>
/// <param name="authTokenModel">数据节点对象</param>
/// <returns></returns>
public bool VerifyDataNodeRepeat(DataNodeInfo dataNodeInfoModel)
{
using (_context = SiteManager.Kernel.Get <ModelContext>())
{
DataNodeInfo dataNodeInfo;
if (string.IsNullOrEmpty(dataNodeInfoModel.DataID))
{
dataNodeInfo = _context.Set <DataNodeInfo>().FirstOrDefault(o => o.DataNodeID.ToUpper() == dataNodeInfoModel.DataNodeID.ToUpper());
}
else
{
dataNodeInfo = _context.Set <DataNodeInfo>().FirstOrDefault(o => o.DataNodeID.ToUpper() == dataNodeInfoModel.DataNodeID.ToUpper() && o.DataID.ToUpper() != dataNodeInfoModel.DataID.ToUpper());
}
if (dataNodeInfo != null && !string.IsNullOrEmpty(dataNodeInfo.DataID))
{
return(false);
}
return(true);
}
}
public async void Callback(ConcurrentDictionary <int, DataNodeInfo> nodesContainer, CancellationToken token)
{
while (true)
{
var received = await udpListener.Receive();
var clientInfo = JsonConvert.DeserializeObject <ClientInfo>(received.Message);
var dataNodeMetaData = new DataNodeInfo
{
ClientInfo = clientInfo,
UdpEndpointAddres = received.From,
LastReceivedHeartBeat = DateTime.UtcNow.TimeOfDay
};
if (!nodesContainer.ContainsKey(dataNodeMetaData.ClientInfo.Id))
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"client with id {clientInfo.Id} has joined");
Console.ResetColor();
nodesContainer.TryAdd(dataNodeMetaData.ClientInfo.Id, dataNodeMetaData);
}
else
{
nodesContainer.TryUpdate(
dataNodeMetaData.ClientInfo.Id,
dataNodeMetaData,
nodesContainer[dataNodeMetaData.ClientInfo.Id]);
}
if (token.IsCancellationRequested)
{
break;
}
}
}
public ActionResult SaveForm(DataNodeInfo dataNodeInfoModel)
{
bool flag = true;
if (dataNodeInfoModel.DataParentID == dataNodeInfoModel.DataNodeID)
{
return(JsonTips("warning", FStr.ParentAndCurrentSameName));// "您所选择的上级数据节点与当前节点重名!");
}
if (dataNodeInfoModel == null)
{
return(JsonTips("error", JStr.InvalidRequestData));
}
//验证授权用户组名称或授权key是否重复
if (!dataAuthorizeManager.VerifyDataNodeRepeat(dataNodeInfoModel))
{
return(JsonTips("warning", "你设置的数据节点编码重复!"));
}
//保存或修改数据
if (string.IsNullOrEmpty(dataNodeInfoModel.DataID))
{
//新增状态设置主键以及创建日期
dataNodeInfoModel.DataID = Guid.NewGuid().ToString();
dataNodeInfoModel.CreatedDate = DateTime.Now;
dataNodeInfoModel.CreatedBy = base.CurrentUser.Name;
flag = dataAuthorizeManager.Add(dataNodeInfoModel);
}
else
{
flag = dataAuthorizeManager.Change(dataNodeInfoModel);
}
if (flag)
{
return(JsonTips("success", "保存成功", Json(new { data = dataNodeInfoModel })));
}
return(JsonTips("error", "保存失败"));
}
private void ParseDataNode(XmlTextReader reader, bool isMetaData)
{
DataNodeInfo nodeInfo = new DataNodeInfo();
nodeInfo.Name = reader[ResXResourceWriter.NameStr];
string typeName = reader[ResXResourceWriter.TypeStr];
string alias = null;
AssemblyName assemblyName = null;
if (!string.IsNullOrEmpty(typeName))
{
alias = GetAliasFromTypeName(typeName);
}
if (!string.IsNullOrEmpty(alias))
{
assemblyName = aliasResolver.ResolveAlias(alias);
}
if (assemblyName != null)
{
nodeInfo.TypeName = GetTypeFromTypeName(typeName) + ", " + assemblyName.FullName;
}
else
{
nodeInfo.TypeName = reader[ResXResourceWriter.TypeStr];
}
nodeInfo.MimeType = reader[ResXResourceWriter.MimeTypeStr];
bool finishedReadingDataNode = false;
nodeInfo.ReaderPosition = GetPosition(reader);
while (!finishedReadingDataNode && reader.Read())
{
if (reader.NodeType == XmlNodeType.EndElement && (reader.LocalName.Equals(ResXResourceWriter.DataStr) || reader.LocalName.Equals(ResXResourceWriter.MetadataStr)))
{
// we just found </data>, quit or </metadata>
finishedReadingDataNode = true;
}
else
{
// could be a <value> or a <comment>
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name.Equals(ResXResourceWriter.ValueStr))
{
WhitespaceHandling oldValue = reader.WhitespaceHandling;
try {
// based on the documentation at http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemxmlxmltextreaderclasswhitespacehandlingtopic.asp
// this is ok because:
// "Because the XmlTextReader does not have DTD information available to it,
// SignificantWhitepsace nodes are only returned within the an xml:space='preserve' scope."
// the xml:space would not be present for anything else than string and char (see ResXResourceWriter)
// so this would not cause any breaking change while reading data from Everett (we never outputed
// xml:space then) or from whidbey that is not specifically either a string or a char.
// However please note that manually editing a resx file in Everett and in Whidbey because of the addition
// of xml:space=preserve might have different consequences...
reader.WhitespaceHandling = WhitespaceHandling.Significant;
nodeInfo.ValueData = reader.ReadString();
} finally {
reader.WhitespaceHandling = oldValue;
}
}
else if (reader.Name.Equals(ResXResourceWriter.CommentStr))
{
nodeInfo.Comment = reader.ReadString();
}
}
else
{
// weird, no <xxxx> tag, just the inside of <data> as text
nodeInfo.ValueData = reader.Value.Trim();
}
}
}
if (nodeInfo.Name == null)
{
throw new ArgumentException(SR.GetString(SR.InvalidResXResourceNoName, nodeInfo.ValueData));
}
ResXDataNode dataNode = new ResXDataNode(nodeInfo, BasePath);
if (UseResXDataNodes)
{
resData[nodeInfo.Name] = dataNode;
}
else
{
IDictionary data = (isMetaData ? resMetadata : resData);
if (assemblyNames == null)
{
data[nodeInfo.Name] = dataNode.GetValue(typeResolver);
}
else
{
data[nodeInfo.Name] = dataNode.GetValue(assemblyNames);
}
}
}
public MessageReceiver(UdpUser udpUser, DataNodeInfo dataNodeInfo, CancellationToken token)
{
this.udpUser = udpUser;
this.dataNodeInfo = dataNodeInfo;
this.token = token;
}
public HeartbeatsSender(UdpUser udpUser, DataNodeInfo dataNodeInfo, CancellationToken token)
{
this.udpUser = udpUser;
this.dataNodeInfo = dataNodeInfo;
this.token = token;
}
private object GenerateObjectFromDataNodeInfo(DataNodeInfo dataNodeInfo, ITypeResolutionService typeResolver)
{
object result = null;
string mimeTypeName = dataNodeInfo.MimeType;
// default behavior: if we dont have a type name, it's a string
string typeName = (dataNodeInfo.TypeName == null || dataNodeInfo.TypeName.Length == 0 ? MultitargetUtil.GetAssemblyQualifiedName(typeof(string), this.typeNameConverter) : dataNodeInfo.TypeName);
if (mimeTypeName != null && mimeTypeName.Length > 0)
{
if (String.Equals(mimeTypeName, ResXResourceWriter.BinSerializedObjectMimeType) ||
String.Equals(mimeTypeName, ResXResourceWriter.Beta2CompatSerializedObjectMimeType) ||
String.Equals(mimeTypeName, ResXResourceWriter.CompatBinSerializedObjectMimeType))
{
string text = dataNodeInfo.ValueData;
byte[] serializedData;
serializedData = FromBase64WrappedString(text);
if (binaryFormatter == null)
{
binaryFormatter = new BinaryFormatter();
binaryFormatter.Binder = new ResXSerializationBinder(typeResolver);
}
IFormatter formatter = binaryFormatter;
if (serializedData != null && serializedData.Length > 0)
{
result = formatter.Deserialize(new MemoryStream(serializedData));
if (result is ResXNullRef)
{
result = null;
}
}
}
#if !SYSTEM_WEB // System.Web does not link with the Soap assembly
else if (String.Equals(mimeTypeName, ResXResourceWriter.SoapSerializedObjectMimeType) ||
String.Equals(mimeTypeName, ResXResourceWriter.CompatSoapSerializedObjectMimeType))
{
string text = dataNodeInfo.ValueData;
byte[] serializedData;
serializedData = FromBase64WrappedString(text);
if (serializedData != null && serializedData.Length > 0)
{
// Performance : don't inline a new SoapFormatter here. That will always bring in
// the soap assembly, which we don't want. Throw this in another
// function so the class doesn't have to get loaded.
//
IFormatter formatter = CreateSoapFormatter();
result = formatter.Deserialize(new MemoryStream(serializedData));
if (result is ResXNullRef)
{
result = null;
}
}
}
#endif
else if (String.Equals(mimeTypeName, ResXResourceWriter.ByteArraySerializedObjectMimeType))
{
if (typeName != null && typeName.Length > 0)
{
Type type = ResolveType(typeName, typeResolver);
if (type != null)
{
TypeConverter tc = TypeDescriptor.GetConverter(type);
if (tc.CanConvertFrom(typeof(byte[])))
{
string text = dataNodeInfo.ValueData;
byte[] serializedData;
serializedData = FromBase64WrappedString(text);
if (serializedData != null)
{
result = tc.ConvertFrom(serializedData);
}
}
}
else
{
string newMessage = SR.GetString(SR.TypeLoadException, typeName, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
XmlException xml = new XmlException(newMessage, null, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
TypeLoadException newTle = new TypeLoadException(newMessage, xml);
throw newTle;
}
}
}
}
else if (typeName != null && typeName.Length > 0)
{
Type type = ResolveType(typeName, typeResolver);
if (type != null)
{
if (type == typeof(ResXNullRef))
{
result = null;
}
else if (typeName.IndexOf("System.Byte[]") != -1 && typeName.IndexOf("mscorlib") != -1)
{
// Handle byte[]'s, which are stored as base-64 encoded strings.
// We can't hard-code byte[] type name due to version number
// updates & potential whitespace issues with ResX files.
result = FromBase64WrappedString(dataNodeInfo.ValueData);
}
else
{
TypeConverter tc = TypeDescriptor.GetConverter(type);
if (tc.CanConvertFrom(typeof(string)))
{
string text = dataNodeInfo.ValueData;
try {
result = tc.ConvertFromInvariantString(text);
} catch (NotSupportedException nse) {
string newMessage = SR.GetString(SR.NotSupported, typeName, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X, nse.Message);
XmlException xml = new XmlException(newMessage, nse, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
NotSupportedException newNse = new NotSupportedException(newMessage, xml);
throw newNse;
}
}
else
{
Debug.WriteLine("Converter for " + type.FullName + " doesn't support string conversion");
}
}
}
else
{
string newMessage = SR.GetString(SR.TypeLoadException, typeName, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
XmlException xml = new XmlException(newMessage, null, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
TypeLoadException newTle = new TypeLoadException(newMessage, xml);
throw newTle;
}
}
else
{
// if mimeTypeName and typeName are not filled in, the value must be a string
Debug.Assert(value is string, "Resource entries with no Type or MimeType must be encoded as strings");
}
return(result);
}
private void FillDataNodeInfoFromObject(DataNodeInfo nodeInfo, object value)
{
CultureInfo ci = value as CultureInfo;
if (ci != null) // special-case CultureInfo, cannot use CultureInfoConverter for serialization (see DevDiv#578701).
{
nodeInfo.ValueData = ci.Name;
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(CultureInfo), this.typeNameConverter);
}
else if (value is string)
{
nodeInfo.ValueData = (string)value;
if (value == null)
{
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXNullRef), this.typeNameConverter);
}
}
else if (value is byte[])
{
nodeInfo.ValueData = ToBase64WrappedString((byte[])value);
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(byte[]), this.typeNameConverter);
}
else
{
Type valueType = (value == null) ? typeof(object) : value.GetType();
if (value != null && !valueType.IsSerializable)
{
throw new InvalidOperationException(SR.GetString(SR.NotSerializableType, name, valueType.FullName));
}
TypeConverter tc = TypeDescriptor.GetConverter(valueType);
bool toString = tc.CanConvertTo(typeof(string));
bool fromString = tc.CanConvertFrom(typeof(string));
try {
if (toString && fromString)
{
nodeInfo.ValueData = tc.ConvertToInvariantString(value);
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(valueType, this.typeNameConverter);
return;
}
}
catch (Exception ex) {
// Some custom type converters will throw in ConvertTo(string)
// to indicate that this object should be serialized through ISeriazable
// instead of as a string. This is semi-wrong, but something we will have to
// live with to allow user created Cursors to be serializable.
if (ClientUtils.IsSecurityOrCriticalException(ex))
{
throw;
}
}
bool toByteArray = tc.CanConvertTo(typeof(byte[]));
bool fromByteArray = tc.CanConvertFrom(typeof(byte[]));
if (toByteArray && fromByteArray)
{
byte[] data = (byte[])tc.ConvertTo(value, typeof(byte[]));
string text = ToBase64WrappedString(data);
nodeInfo.ValueData = text;
nodeInfo.MimeType = ResXResourceWriter.ByteArraySerializedObjectMimeType;
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(valueType, this.typeNameConverter);
return;
}
if (value == null)
{
nodeInfo.ValueData = string.Empty;
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXNullRef), this.typeNameConverter);
}
else
{
if (binaryFormatter == null)
{
binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
binaryFormatter.Binder = new ResXSerializationBinder(this.typeNameConverter);
}
MemoryStream ms = new MemoryStream();
binaryFormatter.Serialize(ms, value);
string text = ToBase64WrappedString(ms.ToArray());
nodeInfo.ValueData = text;
nodeInfo.MimeType = ResXResourceWriter.DefaultSerializedObjectMimeType;
}
}
}
internal ResXDataNode(DataNodeInfo nodeInfo, string basePath)
{
this.nodeInfo = nodeInfo;
InitializeDataNode(basePath);
}
