private void SendData(string Message, int AvailablePort)
{
try
{
byte[] data = new byte[BufferSize];
data = Encoding.Unicode.GetBytes(Message);
//Remote Endpoint
IPEndPoint ip = new IPEndPoint(IPAddress.Broadcast, 8001);
//Local udp Socket
m_udpClientSock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
m_udpClientSock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, 1);
//Listen to the port as a Tcp Server
DataItems DIs = new DataItems();
DIs.Name = "ListenToPort";
DIs.AddItem("Port").Value = AvailablePort;
RaiseEvent(DIs);
//Send Message to Server
m_udpClientSock.SendTo(data, data.Length, SocketFlags.None, ip);
logger.Logline("Send Udp broadcast : \n" + Message + "\n");
}
catch (Exception ex)
{
logger.Logline(">>>Error Occur in SendData:" + ex.Message + "\nStack Trace:\n" + ex.StackTrace + "\n");
}
}
public override XElement AsXElement(XNamespace ns)
{
if (ns == null)
{
ns = string.Empty;
}
var element = new XElement(ns + XmlNodeName);
foreach (var prop in Properties)
{
// component type does not get serialized out, it becomes the node name
if (prop.Key == CommonProperties.Type)
{
continue;
}
element.AddAttributeIfHasValue(prop.Key, prop.Value);
}
element
.AddChildElement(DataItems.AsXElement(ns))
.AddChildElement(Components.AsXElement(ns));
return(element);
}
public static void WriteLogToFile(DataItems gameData)
{
//step through the events and write to file
try
{
StreamWriter eventLogWriter = new StreamWriter(File.Open(gameData.folderLocation + gameData.folderDivider + "EventLog.txt", FileMode.Create));
try
{
foreach (EventLog eventItem in gameData.eventList)
{
eventLogWriter.WriteLine(eventItem.EventItem());
}
eventLogWriter.Dispose();
}
catch
{
eventLogWriter.Dispose();
}
}
catch
{
}
}
public Device(string name, string uuid, string id, bool createAvailability)
: base(new PropertyCollection())
{
OpenNETCF.Validate
.Begin()
.IsNotNullOrEmpty(name)
.IsNotNullOrEmpty(uuid)
.IsNotNullOrEmpty(id)
.Check();
Name = name;
UUID = uuid;
ID = id;
if (createAvailability)
{
m_available = new DataItem(DataItemCategory.Event, DataItemType.AVAILABILITY, "Available", AvailabilityDataItemID)
{
Device = this
};
DataItems.Add(m_available);
SetAvailability(true);
}
}
/// <summary>
/// Returns the value margins for the data points of the series.
/// </summary>
/// <param name="valueMarginConsumer">Consumer of the value margins.</param>
/// <returns>Sequence of value margins.</returns>
protected override IEnumerable <ValueMargin> IValueMarginProviderGetValueMargins(IValueMarginConsumer valueMarginConsumer)
{
if (IsStacked100 && (valueMarginConsumer == ActualDependentAxis))
{
return(Enumerable.Empty <ValueMargin>());
}
else if ((valueMarginConsumer == ActualDependentAxis) || (valueMarginConsumer == ActualIndependentAxis))
{
Range <IComparable> range = IRangeProviderGetRange((IRangeConsumer)valueMarginConsumer);
double margin = DataItems
.Select(di =>
{
return((null != di.DataPoint) ?
(valueMarginConsumer == ActualDependentAxis) ? di.DataPoint.ActualHeight : di.DataPoint.ActualWidth :
0);
})
.Average() * (3.0 / 4.0);
return(new ValueMargin[]
{
new ValueMargin(range.Minimum, margin, margin),
new ValueMargin(range.Maximum, margin, margin),
});
}
else
{
return(base.IValueMarginProviderGetValueMargins(valueMarginConsumer));
}
}
public override string ToString()
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("File Type: " + Type);
builder.AppendLine("String Section Length: " + StringTable.Length);
if (StringTable.Length > 0)
{
builder.AppendLine();
for (int i = 0; i < StringTable.Length; i++)
{
builder.AppendFormat("{0} - {1}\n", i, StringTable[i]);
}
}
builder.AppendLine("\n");
builder.AppendLine("Data Entries Count: " + DataItems.Length);
builder.AppendLine();
foreach (audDataBase dataEntry in DataItems.OrderBy(x => x.FileOffset))
{
builder.AppendFormat("\n[{0}] {1} @ 0x{2:X}-0x{3:X}\n{4}\n", dataEntry.Name, dataEntry.GetType().Name, dataEntry.FileOffset, dataEntry.FileOffset + dataEntry.Serialize().Length, dataEntry);
}
builder.AppendLine();
return(builder.ToString());
}
private void InsertGroups(DataTable dataTable)
{
try
{
var fieldNames = $"{DestinationDbField},";
var columnDictionary = new Dictionary <string, string>();
// make "field1,field2,..."
var i = 0;
foreach (var item in DataItems)
{
columnDictionary.Add(((DBFieldBindingItem)item).DBFieldName,
((DBFieldBindingItem)item).DBFieldType.ToLower());
fieldNames += ((DBFieldBindingItem)item).DBFieldName;
if (i == DataItems.Count() - 1)
{
continue;
}
fieldNames += ",";
i++;
}
var strSql = string.Empty;
foreach (DataRow dataTableRow in dataTable.Rows)
{
var fieldValues = DestinationBindingFieldType == "int"
? $"{dataTableRow[DestinationDbField]},"
: $"'{dataTableRow[DestinationDbField]}',";
i = 0;
foreach (var columnInfo in columnDictionary)
{
if (columnInfo.Value == "string" || columnInfo.Value == "datetime")
{
fieldValues += $"'{dataTableRow[columnInfo.Key]}'";
}
else
{
fieldValues += $"{dataTableRow[columnInfo.Key]}";
}
if (i != DataItems.Count() - 1)
{
fieldValues += ",";
}
i++;
}
strSql += $"insert into {TableName}({fieldNames}) values({fieldValues});\n";
}
var db = new DataBaseHelper(DbType, ConnectionString);
db.ExecuteNonQuery(CommandType.Text, strSql);
}
catch (Exception ex)
{
Log.Error("GroupBindingDBFields插入记录失败", ex);
throw new Exception("BindingDBFields写入失败");
}
}
internal void AddDataItem(string s)
{
DataItems.Add(new RequestDataItem()
{
Type = "string", Data = BinarySerializer.ToArray(s)
});
}
protected void WriteWaveTracks(RageDataFileWriteReference file)
{
if (this is RageAudioMetadata5)
{
var items = DataItems
.OfType <audSoundBase>()
.SelectMany(x => x.AudioTracks.BaseList.Select(y => x.FileOffset + y.Offset)).ToArray();
file.Write(items.Length);
foreach (var offset in items)
{
file.Write(offset + 8);
}
}
else
{
file.Write(WaveTracks.Length);
foreach (var item in WaveTracks)
{
file.Write(item.FileOffset + 8);
}
}
}
internal void AddDataItem(int i)
{
DataItems.Add(new RequestDataItem()
{
Type = "int", Data = BinarySerializer.ToArray(i)
});
}
internal void AddDataItem(long l)
{
DataItems.Add(new RequestDataItem()
{
Type = "long", Data = BinarySerializer.ToArray(l)
});
}
internal void AddDataItem(byte[] b)
{
DataItems.Add(new RequestDataItem()
{
Type = "bytes", Data = b
});
}
internal void AddDataItem(byte b)
{
DataItems.Add(new RequestDataItem()
{
Type = "byte", Data = BinarySerializer.ToArray(b)
});
}
private async Task loadDataAsync()
{
var items = await DataItems.GetItemsAsync(pageIndex : 0, pageSize : PageSize);
Items.AddRange(items);
ListsingleItems.ItemsSource = Items;
}
public static bool RenameObjectsInList(DataItems gameData, List <ProceduresAndFunctions> SortedList)
{
//rename each item in the list
int renameCount = 0;
int numberOfLetters = 1;
string newName = "";
foreach (ProceduresAndFunctions s in SortedList)
{
newName += newName.PadLeft(numberOfLetters, Convert.ToChar(65 + renameCount));
gameData.procList[s.IDNumber() - 1].ReplaceNameText = newName;
gameData.eventList.Add(new EventLog("Replacing " + gameData.procList[s.IDNumber() - 1].FunctionName() + "() with " + newName));
renameCount++;
if (renameCount == 26)
{
renameCount = 32;
}
if (renameCount == 60)
{
numberOfLetters++;
renameCount = 0;
}
newName = "";
}
return(true);
}
private DataItems GetDataObjects(string context, string endpoint, string graph, DataFilter dataFilter, int start, int limit, string baseurl)
{
DataItems dataItems = null;
try
{
dataItems = Repository.GetDataItems(endpoint, context, graph, dataFilter, start, limit);
}
catch (Exception ex)
{
if (ex.InnerException != null)
{
_logger.Error("Error deserializing filtered data objects: " + ex);
}
if (_response != "success")
{
_response = ex.Message.ToString();
if (ex.InnerException.Message != null)
{
_response = _response + " " + ex.InnerException.Message.ToString();
}
}
}
return(dataItems);
}
public void TestItemsToJsonSpeed()
{
Log("-----------开始测试数据Json格式化速度----------------");
int count = 100000;
IDataItems items = new DataItems <MessageCore>(@"C:\Users\fhjun\Desktop\123.db");
for (int i = 0; i < count; i++)
{
items.Add(new MessageCore()
{
Content = "发送的消息的内容是的俄日文2342！32<>^*", Date = DateTime.Now.AddDays(i), SenderName = "张三", MessageType = "文本"
});
}
items.Commit();
items.Filter();
Stopwatch t = new Stopwatch();
t.Start();
using (StreamWriter sw = new StreamWriter(@"C:\Users\fhjun\Desktop\123.js", false, Encoding.UTF8))
{
sw.Write("var __data = [");
int r = 0;
foreach (var c in items.View)
{
if (r != 0)
{
sw.Write(",");
}
sw.Write(Serializer.JsonSerilize(c));
r++;
}
sw.Write("];");
}
Log($"执行时间：{t.ElapsedMilliseconds}ms");//6.5s--100000数据
}
/// <summary>
/// create the AsParallel expression
/// </summary>
/// <param name="paramDictionary"></param>
/// <returns></returns>
private MethodCallExpression DataItems_AsParallel(ParameterExpression paramDictionary)
{
//get dataitems type
var dictionaryType = DataItems.GetType();
//get the generic arguments for the type
var genericArguments = dictionaryType.GetGenericArguments();
var keyType = genericArguments[0];
var elementType = genericArguments[1];
//create the generic KeyValuePair type
var keyvalueType = typeof(KeyValuePair <,>).MakeGenericType(keyType, elementType);
//get the as parallel method info
var mi = typeof(ParallelEnumerable).GetMethods().Where(x => x.Name == "AsParallel" && x.IsGenericMethod && x.GetParameters().Length == 1).FirstOrDefault();
//make the generic method
var gen_mi = mi.MakeGenericMethod(keyvalueType);
//create the call expression
var call = Expression.Call
(
method: gen_mi,
arg0: paramDictionary
);
return(call);
}
/// <summary>
/// Creates a volume model
/// </summary>
public VolumeModel()
{
// Create the input items of the volume model
basin = new DrainageBasin();
precipitation = new TimeSeries {
Components = { new Variable <double>("Precipitation") }
};
// Declare a two dimensional array.
//double[,] array1 = new double[2, 3];
// Create the output item of the volume model
volume = new FeatureCoverage("Output data")
{
IsTimeDependent = true,
Arguments = { new Variable <IFeature>("Catchment")
{
FixedSize = 0
} },
Components = { new Variable <double>("Volume") }
};
// Wrap fields as input/output data items
DataItems.Add(new DataItem(precipitation, "Precipitation", typeof(TimeSeries), DataItemRole.Input, "PrecipitationTag"));
DataItems.Add(new DataItem(basin, "Basin", typeof(DrainageBasin), DataItemRole.Input, "BasinTag"));
DataItems.Add(new DataItem(volume, "NIWA_model_value", typeof(FeatureCoverage), DataItemRole.Output, "VolumeTag"));
}
/// <summary>
/// create the take expression
/// </summary>
/// <param name="ParentExp"></param>
/// <param name="take"></param>
/// <returns></returns>
private MethodCallExpression DataItems_Take(MethodCallExpression ParentExp, int take)
{
//get dataitems type
var dictionaryType = DataItems.GetType();
//get the generic arguments for the type
var genericArguments = dictionaryType.GetGenericArguments();
var keyType = genericArguments[0];
var elementType = genericArguments[1];
//get the method info
var mi = typeof(ParallelEnumerable).GetMethods().Where(x => x.Name == "Take" && x.IsGenericMethod && x.GetParameters().Length == 2).FirstOrDefault();
//create the generic method info
var gen_mi = mi.MakeGenericMethod(elementType);
//create the constant expression
var param = Expression.Constant(take, take.GetType());
//create the call
var call = Expression.Call
(
method: gen_mi,
arg0: ParentExp,
arg1: param
);
return(call);
//return null;
}
public override XElement AsXElement(XNamespace ns)
{
if (ns == null)
{
ns = string.Empty;
}
var element = new XElement(ns + NodeNames.Device);
foreach (var prop in Properties)
{
element.AddAttributeIfHasValue(prop.Key, prop.Value);
}
var dataItemElement = DataItems.AsXElement(ns);
//foreach(var condition in Conditions.AsXElement(ns).Elements(ns + NodeNames.DataItem))
//{
// dataItemElement.Add(condition);
//}
element
.AddChildElement(dataItemElement)
.AddChildElement(Components.AsXElement(ns));
return(element);
}
/// <summary>
/// creates the full expression to return items to purge
/// </summary>
/// <param name="order_by_field"></param>
/// <param name="order_asc"></param>
/// <param name="take"></param>
/// <returns></returns>
private Expression GetPurgeItemsExpression(string order_by_field, bool order_asc, int take)
{
//get info for expression generation
var dic_type = DataItems.GetType();
var genericArguments = dic_type.GetGenericArguments();
var keyType = genericArguments[0];
var elementType = genericArguments[1];
var paramDictionary = Expression.Parameter(dic_type, "d");
//create the expression
var parallelDictionaryExpression = DataItems_AsParallel(paramDictionary);
var selectCallExpression = DataItems_Select_Value(parallelDictionaryExpression);
var OrderByCallExpression = DataItems_OrderBy(selectCallExpression, order_by_field, order_asc);
var TakeCallExpression = DataItems_Take(OrderByCallExpression, take);
//var MergeCallExpression = DataItems_WithMergeOptions(LimitCallExpression, ParallelMergeOptions.NotBuffered);
//create the lambda
return(Expression.Lambda
(
delegateType: typeof(Func <,>).MakeGenericType(dic_type, typeof(IEnumerable <>).MakeGenericType(elementType)),
body: TakeCallExpression,
parameters: paramDictionary
));
}
/// <summary>
/// Acquires an independent axis suitable for use with the data values of the series.
/// </summary>
/// <returns>Axis instance.</returns>
protected override IAxis AcquireIndependentAxis()
{
IAxis independentAxis = SeriesHost.Axes
.Where(a => (a.Orientation == AxisOrientation.X) && ((a is IRangeAxis) || (a is ICategoryAxis)) && DataItems.Any() && (a.CanPlot(DataItems.First().ActualIndependentValue)))
.FirstOrDefault();
if (null == independentAxis)
{
object probeValue = DataItems.Any() ? DataItems.First().ActualIndependentValue : null;
double convertedDouble;
DateTime convertedDateTime;
if ((null != probeValue) && ValueHelper.TryConvert(probeValue, out convertedDouble))
{
independentAxis = new LinearAxis();
}
else if ((null != probeValue) && ValueHelper.TryConvert(probeValue, out convertedDateTime))
{
independentAxis = new DateTimeAxis();
}
else
{
independentAxis = new CategoryAxis();
}
independentAxis.Orientation = AxisOrientation.X;
}
return(independentAxis);
}
public int DistinctTakeRates()
{
var takeRates = DataItems.Where(p => !p.IsStandardFeatureInGroup && !p.IsNonApplicableFeatureInGroup && !p.IsOptionalFeatureInGroup)
.Select(p => p.PercentageTakeRate);
return(takeRates.Distinct().Count());
}
public static bool ItemAlreadyExists(DataItems gameData, string IDString)
{
//check to see if this @ is in use anywhere else
int foundNumber;
foundNumber = DataHelpers.VerbNumber(gameData.verbList, IDString);
if (foundNumber > -1)
{
gameData.eventList.Add(new EventLog("The item '" + IDString + "' already exists as a Verb"));
return(true);
}
foundNumber = DataHelpers.ObjectFound(gameData.objectList, IDString);
if (foundNumber > -1)
{
gameData.eventList.Add(new EventLog("The item '" + IDString + "' already exists as an Object"));
return(true);
}
foundNumber = DataHelpers.NounNumber(gameData.nounList, IDString);
if (foundNumber > -1)
{
gameData.eventList.Add(new EventLog("The item '" + IDString + "' already exists as a Noun"));
return(true);
}
foundNumber = DataHelpers.AdverbNumber(gameData.adverbList, IDString);
if (foundNumber > -1)
{
gameData.eventList.Add(new EventLog("The item '" + IDString + "' already exists as an Adverb"));
return(true);
}
return(false);
}
public static bool WriteProgramToFile(DataItems gameData)
{
try
{
int iNumLines = gameData.TargetBBCBasicProgram.Count;
{
using System.IO.StreamWriter file = new System.IO.StreamWriter(gameData.folderLocation + gameData.folderDivider + gameData.outputFile, false, Encoding.ASCII);
if (gameData.folderDivider == "/")
{
file.NewLine = "\r";
}
else
{
file.NewLine = "\r\n";
}
for (int i = 0; i < iNumLines; i++)
{
file.WriteLine(gameData.TargetBBCBasicProgram[i].NewLineNumber().ToString() + gameData.TargetBBCBasicProgram[i].LineText());
gameData.eventList.Add(new EventLog((gameData.TargetBBCBasicProgram[i].NewLineNumber().ToString() + gameData.TargetBBCBasicProgram[i].LineText())));
}
}
return(true);
}
catch (Exception e)
{
gameData.eventList.Add(new EventLog(e.Message));
return(false);
}
}
public void UpdateItem(string project, string app, string resource, string id, string format, Stream stream)
{
Response response = new Response();
try
{
format = "jsonld";
DataItems dataItems = _abstractPrivder.FormatIncomingMessage(stream);
if (dataItems != null && dataItems.items != null && dataItems.items.Count > 0)
{
dataItems.items[0].id = id;
XElement xElement = dataItems.ToXElement();
response = _abstractPrivder.Update(project, app, resource, format, new XDocument(xElement));
}
else
{
throw new Exception("No items to update or invalid payload.");
}
}
catch (Exception e)
{
response.Level = StatusLevel.Error;
response.Messages.Add(e.Message);
}
PrepareResponse(ref response);
_abstractPrivder.FormatOutgoingMessage <Response>(response, format, false);
}
public void SendMessage(string ipaddress, string body)
{
try
{
DataItems DIs = XmlHelper.GetAllElements(1);
DIs.Item(0).Children.Item(0).Value = m_machineName;
DIs.Item(0).Children.Item(1).Value = body;
string msg = XmlHelper.GetXml(DIs);
byte[] buffer = Encoding.Unicode.GetBytes(msg);
TcpSocketDic[ipaddress].Send(buffer);
logger.Logline(msg + "\nis sent to " + TcpSocketDic[ipaddress].RemoteEndPoint);
}
catch (Exception ex)
{
logger.Logline(">>>Error Occur in SendMessage:" + ex.Message + "\nStack Trace:\n" + ex.StackTrace + "\n");
var Win32ex = ex as Win32Exception;
if (Win32ex != null)
{
if (Win32ex.ErrorCode == 0x2746 || Win32ex.ErrorCode == 0x2745)
{
CloseSocket(TcpSocketDic[ipaddress]);
}
}
}
}
public void Add(String _DataType, String _DataField, FieldTypes _FieldType, Object _DataValue, String _Expression)
{
DataItems fField = new DataItems();
if (_DataType.ToUpper() == "NUMBER")
{
fField.DataType = DataTypes.Number;
}
else if (_DataType.ToUpper() == "NVARCHAR")
{
fField.DataType = DataTypes.NVarchar;
}
else if (_DataType.ToUpper() == "DATETIME")
{
fField.DataType = DataTypes.DateTime;
}
else
{
fField.DataType = DataTypes.Undefined;
}
fField.FieldType = _FieldType;
fField.DataValue = _DataValue;
fField.DataField = _DataField;
fField.Expression = _Expression;
base.List.Add(fField);
}
private void beginListen(DataItems udpDIs)
{
Socket socket = null;
try
{
int BuildPort;
bool IsInt = int.TryParse(udpDIs.Item("Port").Value.ToString(), out BuildPort);
if (IsInt)
{
IPEndPoint point = new IPEndPoint(IPAddress.Any, BuildPort);
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Bind(point);
socket.Listen(100);
Task Accept = new Task(ListenAccept, socket);
Accept.Start();
}
else
{
logger.Logline(">>>Error Occur in beginListen: int.TryParse fail");
}
}
catch (Exception ex)
{
logger.Logline(">>>Error Occur in beginListen:" + ex.Message + "\nStack Trace:\n" + ex.StackTrace + "\n");
}
}
public DataItems GetModel()
{
if ( model == null )
{
model = new DataItems();
model.Add( new DataItem() { Id = "1", CatalogRef = "#31245-1111", SKU = "923-25-3412", InStock = false } );
model.Add( new DataItem() { Id = "2", CatalogRef = "#89324-9314", SKU = "943-55-2212", InStock = true } );
model.Add( new DataItem() { Id = "3", CatalogRef = "#11262-7312", SKU = "623-26-3892", InStock = false } );
model.Add( new DataItem() { Id = "4", CatalogRef = "#38257-2214", SKU = "823-21-2412", InStock = true } );
}
return model;
}
public DataItems GetModel()
{
if ( model == null )
{
model = new DataItems();
// Dummy Data.
model.Add( new DataItem() { Id = "1", Name = "Item 1", Description = "Description 1" } );
model.Add( new DataItem() { Id = "2", Name = "Item 2", Description = "Description 2" } );
model.Add( new DataItem() { Id = "3", Name = "Item 3", Description = "Description 3" } );
model.Add( new DataItem() { Id = "4", Name = "Item 4", Description = "Description 4" } );
}
return model;
}
public MasterViewModel( IDataService dataService, IEventAggregator eventAggregator, IRegionManager regionManager )
{
_dataService = dataService;
_eventAggregator = eventAggregator;
_regionManager = regionManager;
// Get the data model from the data service.
_model = dataService.GetModel();
// Initialize the CollectionView for the underlying model.
DataItemsCV = new ListCollectionView( _model );
// Track the current selection.
DataItemsCV.CurrentChanged += new EventHandler( SelectedItemChanged );
// Initialize the commands.
NavigateToViewCommand = new DelegateCommand<string>( NavigateToView );
SyncViewCommand = new DelegateCommand<string>( SyncView );
}
public void SetDataValue(DataItems Item, string value)
{
switch (Item)
{
case DataItems.HDG:
this.labelEXT_HDG.Text = value;
break;
case DataItems.TRK:
this.labelEXT_TRK.Text = value;
break;
case DataItems.IAS:
this.labelEXT_IAS.Text = value;
break;
case DataItems.MACH:
this.labelEXT_MCH.Text = value;
break;
case DataItems.TAS:
this.labelEXT_TAS.Text = value;
break;
case DataItems.Roll_Angle:
this.labelRoll_Angle.Text = value;
break;
case DataItems.Selected_Altitude:
this.labelSelectedAltitude.Text = value;
break;
case DataItems.Selected_Altitude_F:
this.labeSelAltFinal.Text = value;
break;
case DataItems.RateOfClimb:
this.labelRateOfClimb.Text = value;
break;
case DataItems.BaroSetting:
this.labelBaroSettings.Text = value;
break;
case DataItems.Mode_S_Addr:
this.lblMode_S_Addr.Text = value;
break;
}
}
private void SendAsyncData()
{
if (!CurrentScriptManager.IsInAsyncPostBack)
{
return;
}
var dataItems = new DataItems { PositionElementID = PositionControlClientID, Visible = UpdatePanelVisible };
DataContractJsonSerializer serializer = new DataContractJsonSerializer(dataItems.GetType());
MemoryStream ms = new MemoryStream();
serializer.WriteObject(ms, dataItems);
string serializedString = Encoding.Default.GetString(ms.ToArray());
CurrentScriptManager.RegisterDataItem(this, serializedString);
}
