static void TenderCard(Transaction transaction)
{
try
{
Dictionary <string, object> transactionInfo = new Dictionary <string, object>();
transactionInfo[Constants.WALLET_DATA_TYPE_TINY_KEY] = ((int)eWalletDataTypes.TransactionNotification).ToString();
transactionInfo[Constants.WALLET_TRANSACTION_ID_TINY_KEY] = transaction.ID.ToString();
transactionInfo[Constants.WALLET_MERCHANT_ID_TINY_KEY] = transaction.Merchant.ID.ToString();
transactionInfo[Constants.WALLET_TRANSACTION_REMAINING_AMOUNT_TINY_KEY] = transaction.RemainingAmount.ToString("0.00");
var data = DictionarySerializer.SerializeToByteArray(transactionInfo);
if (data != null)
{
Console.WriteLine("Tendering card for transaction {0}.", transaction.ID);
_selectedBeacon.SendDataBlocks(0, 0, 255, data);
}
else
{
Console.WriteLine("Serializing transaction {0} failed.", transaction.ID);
}
}
catch (CommandTimeoutException ex)
{
Console.WriteLine("{0} is busy. Wait a moment and try again.", _selectedBeacon);
Debug.Print("Command Timeout: {0}", ex.GetBaseException().Message);
}
catch (Exception ex)
{
Debug.Print("Error occurred while tendering card with merchant {0}: {1}", _selectedBeacon, ex.GetBaseException().Message);
Environment.Exit(1);
}
}
static void RespondToBleDataRequestWithErrors(SerialBeacon beacon, Dictionary <string, object> requestInfo, List <byte> errors)
{
requestInfo[Constants.WALLET_ERRORS_TINY_KEY] = errors;
var responseData = DictionarySerializer.SerializeToByteArray(requestInfo);
beacon.RespondToBleDataRequest(responseData);
}
///// <summary>
///// Is payment method active?
///// </summary>
///// <param name="paymentMethod">Payment method</param>
///// <param name="paymentSettings">Payment settings</param>
///// <returns>Result</returns>
//public static bool IsPaymentMethodActive(this IPaymentMethod paymentMethod, PaymentSettings paymentSettings)
//{
// if (paymentMethod == null)
// throw new ArgumentNullException("paymentMethod");
// if (paymentSettings == null)
// throw new ArgumentNullException("paymentSettings");
// if (paymentSettings.ActivePaymentMethodSystemNames == null)
// return false;
// foreach (string activeMethodSystemName in paymentSettings.ActivePaymentMethodSystemNames)
// if (paymentMethod.PluginDescriptor.SystemName.Equals(activeMethodSystemName, StringComparison.InvariantCultureIgnoreCase))
// return true;
// return false;
//}
///// <summary>
///// Calculate payment method fee
///// </summary>
///// <param name="paymentMethod">Payment method</param>
///// <param name="orderTotalCalculationService">Order total calculation service</param>
///// <param name="cart">Shopping cart</param>
///// <param name="fee">Fee value</param>
///// <param name="usePercentage">Is fee amount specified as percentage or fixed value?</param>
///// <returns>Result</returns>
//public static decimal CalculateAdditionalFee(this IPaymentMethod paymentMethod,
// IOrderTotalCalculationService orderTotalCalculationService, IList<ShoppingCartItem> cart,
// decimal fee, bool usePercentage)
//{
// if (paymentMethod == null)
// throw new ArgumentNullException("paymentMethod");
// if (fee <= 0)
// return fee;
// decimal result;
// if (usePercentage)
// {
// //percentage
// var orderTotalWithoutPaymentFee = orderTotalCalculationService.GetShoppingCartTotal(cart, usePaymentMethodAdditionalFee: false);
// result = (decimal)((((float)orderTotalWithoutPaymentFee) * ((float)fee)) / 100f);
// }
// else
// {
// //fixed value
// result = fee;
// }
// return result;
//}
/// <summary>
/// Serialize CustomValues of ProcessPaymentRequest
/// </summary>
/// <param name="request">Request</param>
/// <returns>Serialized CustomValues</returns>
public static string SerializeCustomValues(this ProcessPaymentRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
if (!request.CustomValues.Any())
{
return(null);
}
//XmlSerializer won't serialize objects that implement IDictionary by default.
//http://msdn.microsoft.com/en-us/magazine/cc164135.aspx
//also see http://ropox.ru/tag/ixmlserializable/ (Russian language)
var ds = new DictionarySerializer(request.CustomValues);
var xs = new XmlSerializer(typeof(DictionarySerializer));
using (var textWriter = new StringWriter())
{
using (var xmlWriter = XmlWriter.Create(textWriter))
{
xs.Serialize(xmlWriter, ds);
}
var result = textWriter.ToString();
return(result);
}
}
public IEnumerable <SagaDataSnapshot> GetAllSnapshots()
{
using (var connection = PostgreSqlTestHelper.ConnectionHelper.GetConnection().Result)
{
using (var command = connection.CreateCommand())
{
command.CommandText = $@"SELECT ""data"", ""metadata"" FROM ""{TableName}""";
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var data = (byte[])reader["data"];
var metadataString = (string)reader["metadata"];
var objectSerializer = new ObjectSerializer();
var dictionarySerializer = new DictionarySerializer();
var sagaData = objectSerializer.Deserialize(data);
var metadata = dictionarySerializer.DeserializeFromString(metadataString);
yield return(new SagaDataSnapshot
{
SagaData = (ISagaData)sagaData,
Metadata = metadata
});
}
}
}
}
}
// Update is called once per frame
void FixedUpdate()
{
RPC rpc = this.socket.PopRPC();
while (rpc != null)
{
if (rpc.Equals(RPCName.JoinGame))
{
this.SpawnPlayer(rpc);
}
else if (rpc.Equals(RPCName.Move))
{
this.Move(rpc);
}
LoggerManager.Instance.Info(
string.Format(
"receivedAt: {6}<br />executedAt: {0}<br />timestamp: {1}<br />clientID: {2}<br/>sequenceID: {3}<br />rpcName: {4}<br />parameters: {5}",
this.socket.GetTime(),
rpc.Timestamp,
rpc.ClientID,
rpc.SequenceID,
rpc.Name,
DictionarySerializer.ToJSON(rpc.Parameters),
rpc.ReceivedAt
)
);
rpc = this.socket.PopRPC();
}
}
public override void Initialize(SerializerSelector serializerSelector)
{
cacheSerializer = MemberSerializer <NavigationMeshCache> .Create(serializerSelector, false);
layersSerializer = new DictionarySerializer <Guid, NavigationMeshLayer>();
layersSerializer.Initialize(serializerSelector);
}
public override void Initialize(SerializerSelector serializerSelector)
{
boundingBoxSerializer = MemberSerializer <BoundingBox> .Create(serializerSelector, false);
tilesSerializer = new DictionarySerializer <Point, NavigationMeshTile>();
tilesSerializer.Initialize(serializerSelector);
}
/// <summary>
/// Decoding of encoded bytes by Huffman algorithm.
/// </summary>
/// <param name="bytes"> Encoded bytes</param>
/// <returns> Decoded bytes</returns>
public static byte[] Decode(byte[] bytes)
{
var result = DictionarySerializer.Deserialize(bytes);
return(Decode(bytes,
result.SizeOfBytes,
TreeBuilder.BuildTree(new TreeBuilderQueue(result.Dictionary))));
}
protected SocketAction action(string actionName, Dictionary <string, object> parameters)
{
string payload = DictionarySerializer.ToJSON(parameters);
SocketAction action = new SocketAction(this, actionName, payload);
return(action);
}
public void DictionaryTest3()
{
var a = new TestStruct {
a = 3, b = "testString"
};
var serializedData = DictionarySerializer.Serialize(a);
var a_deserialized = DictionarySerializer.Deserialize <TestStruct>(serializedData);
}
internal void SendMessage(In data)
{
sender.SendMessage(packer.Pack(DictionarySerializer.AsDictionary(new Message <In>()
{
cmd = cmd,
data = data
})));
}
public void DictionaryDictionaryTest()
{
var a = new DictionaryClass();
a.SetValues();
var serializedData = DictionarySerializer.Serialize(a);
var a1 = DictionarySerializer.Deserialize <DictionaryClass>(serializedData);
}
public static Dictionary <Tkey, Tvalue> AsDictionary <Tkey, Tvalue>(this BsonValue bsonValue)
{
using (var reader = BsonReader.Create(bsonValue.ToJson()))
{
var dictionarySerializer = new DictionarySerializer <Tkey, Tvalue>();
var result = dictionarySerializer.Deserialize(reader, typeof(Dictionary <Tkey, Tvalue>), new DictionarySerializationOptions());
return((Dictionary <Tkey, Tvalue>)result);
}
}
public void DictionaryTest2()
{
var a = new DerivedA();
a.SetValues();
var serializedData = DictionarySerializer.Serialize(a);
var a1 = DictionarySerializer.Deserialize <Interface>(serializedData);
}
/// <summary>
/// Encoding bytes to huffman algorithm.
/// </summary>
/// <param name="bytes"> Source bytes </param>
/// <returns> Encoded bytes </returns>
public static byte[] Encode(byte[] bytes)
{
var dictionary = BytesCalculator.Calculate(bytes);
var header = DictionarySerializer.Serialize(dictionary);
var body = Encode(bytes,
BitTable.BuildTable(TreeBuilder.BuildTree(new TreeBuilderQueue(dictionary))));
return(Merage(header, body));
}
} // default is move only
public override string ToString()
{
var op = new Dictionary <string, object>();
if (Copy)
{
op["copy"] = Copy;
}
return(DictionarySerializer <object> .Serialize((IDictionary <string, object>) op, separator : '|', assignment : ':'));
}
static void Main(string[] args)
{
List <string> level1 = new List <string> {
"Hey",
"I am",
"Level One",
};
var lstSeri = level1.Serialize();
var lvl1de = lstSeri.DeSerialize <string>();
lvl1de.DoSerializion();
//Let's create a dummy dictionary with some entities
Dictionary <string, string> myDictionary = new Dictionary <string, string>();
myDictionary["HalloWelt"] = "lola";
myDictionary["HalloWelt1"] = "lola2";
//Serialize the dictionary to a byte array
var serialized = myDictionary.Serialize();
//Deserialize that byte array to a dictionary<string,string>
var deseri = serialized.DeSerialize <string, string>();
Console.WriteLine(deseri["HalloWelt"]);
//Same, but not as pretty as the previous example
serialized = DictionarySerializer <string, string> .Serialize(myDictionary);
deseri = DictionarySerializer <string, string> .Deserialize(serialized);
var myDictionary1 = new Dictionary <string, Dictionary <string, string> >
{
["HalloWelt"] = new Dictionary <string, string>
{
["a"] = "b",
["c"] = "ba",
["d"] = "bs",
["e"] = "bfa",
},
["HalloWelt1"] = new Dictionary <string, string>
{
["xa"] = "xb",
["xc"] = "xba",
["xd"] = "xbs",
["xe"] = "xbfa",
},
};
serialized = myDictionary1.Serialize();
var deserialized = serialized.DeSerialize <string, Dictionary <string, Dictionary <string, int> > >();
Console.ReadLine();
}
public void ReadonlyListTest()
{
//var lIn = new ListClass();
var lIn = new ListContainerClassReadonly();
lIn.list.Add("Hello");
lIn.list.Add("My name is");
lIn.list.Add("Bob!");
var serializedData = DictionarySerializer.Serialize(lIn);
var lOut = DictionarySerializer.Deserialize <ListContainerClassReadonly>(serializedData);
}
protected SocketAction rpcAction(string rpcName, Dictionary <string, object> parameters)
{
Dictionary <string, object> rpcParameters = new Dictionary <string, object>();
rpcParameters["rpcName"] = rpcName;
rpcParameters["parameters"] = parameters;
string payload = DictionarySerializer.ToJSON(rpcParameters);
SocketAction action = new SocketAction(this, "rpc", payload);
return(action);
}
static void RespondToBleDataRequest(SerialBeacon beacon, byte[] requestData)
{
try
{
var requestInfo = DictionarySerializer.DeserializeFromByteArray(requestData);
if (requestInfo != null)
{
var dataTypeString = (string)requestInfo[Constants.WALLET_DATA_TYPE_TINY_KEY];
if (!string.IsNullOrEmpty(dataTypeString))
{
Console.WriteLine("Received data request {0}.", JsonConvert.SerializeObject(requestInfo));
if (string.Compare(dataTypeString, ((byte)eWalletDataTypes.CardBalanceRequest).ToString(), true) == 0)
{
RespondToCardBalanceRequest(beacon, requestInfo);
}
else if (string.Compare(dataTypeString, ((byte)eWalletDataTypes.CardRedmeptionRequest).ToString(), true) == 0)
{
RespondToCardRedemptionRequest(beacon, requestInfo);
}
else
{
Console.WriteLine("BLE data request type {0} not supported.", dataTypeString);
RespondToBleDataRequestWithErrors(beacon, requestInfo, new List <byte> {
(byte)eWalletErrors.RequestTypeNotSupported
});
}
}
else
{
Console.WriteLine("BLE data request JSON invalid.");
RespondToBleDataRequestWithErrors(beacon, requestInfo, new List <byte> {
(byte)eWalletErrors.JSONInvalid
});
}
}
else
{
Console.WriteLine("LE data request type missing.");
RespondToBleDataRequestWithErrors(beacon, requestInfo, new List <byte> {
(byte)eWalletErrors.RequestTypeMissing
});
}
}
catch (Exception ex)
{
Debug.Print("Exception in RespondToBleDataRequest: {0}", ex.GetBaseException().Message);
}
}
public override string ToString()
{
var op = new Dictionary <string, object>();
if (Overwrite)
{
op["overwrite"] = Overwrite;
}
if (NewParentId.HasValue)
{
op["pid"] = NewParentId;
}
return(DictionarySerializer <object> .Serialize((IDictionary <string, object>) op, separator : '|', assignment : ':'));
}
public void ListTest()
{
//var lIn = new ListClass();
var lIn = new ListContainerClass {
list = new List <string>()
};
lIn.list.Add("Hello");
lIn.list.Add("My name is");
lIn.list.Add("Bob!");
var serializedData = DictionarySerializer.Serialize(lIn);
DictionarySerializer.DeserializeList <ListClass>(new object[] { serializedData });
//var lOut = DictionarySerializer.Deserialize<ListClass>(serializedData);
var lOut = DictionarySerializer.Deserialize <ListContainerClass>(serializedData);
}
protected void Page_Load(object sender, EventArgs e)
{
Person objP = new Person();
objP.FirstName = "John";
objP.LastName = "Doe";
objP.Attributes = new Dictionary <string, string>();
objP.Attributes.Add("PhoneNumber", "12345");
objP.Attributes.Add("StreetName", "StackOverFlow Street");
objP.Attributes.Add("StreetNumber", "51");
DictionarySerializer ds = new DictionarySerializer();
string val = ds.WriteXml(objP);
}
public TypeSerializer GetSerializerForType(Type valueType)
{
if (valueType == null)
{
throw new ArgumentNullException("valueType");
}
if (valueType.BaseType == typeof(MulticastDelegate) || valueType.BaseType == typeof(Delegate))
{
throw new InvalidOperationException(string.Format("Unable to serialize delegate type '{0}'.", valueType));
}
var serializer = default(TypeSerializer);
if (this.serializers.TryGetValue(valueType, out serializer))
{
return(serializer);
}
var typeSerializerAttribute = valueType.GetCustomAttributes(typeof(TypeSerializerAttribute), inherit: false).FirstOrDefault() as TypeSerializerAttribute;
if (typeSerializerAttribute != null)
{
serializer = this.CreateCustomSerializer(valueType, typeSerializerAttribute);
}
else if (valueType.IsEnum)
{
serializer = this.CreateEnumSerializer(valueType);
}
else if (typeof(IDictionary).IsAssignableFrom(valueType) &&
(!valueType.IsInstanceOfType(typeof(IDictionary <,>)) || DictionarySerializer.IsStringKeyType(valueType.GetInstantiationArguments(typeof(IDictionary <,>))[0])))
{
serializer = this.CreateDictionarySerializer(valueType);
}
else if (valueType.IsArray || typeof(IEnumerable).IsAssignableFrom(valueType))
{
serializer = this.CreateArraySerializer(valueType);
}
else
{
serializer = (this.SerializerFactory != null ? this.SerializerFactory(valueType) : null) ?? this.CreateObjectSerializer(valueType);
}
this.serializers.Add(valueType, serializer);
return(serializer);
}
public void Can_round_trip()
{
var before = new Dictionary <string, string>
{
{ "key1", "value1" },
{ "key2", "value2" },
{ "keyWithNull", null },
{ "keyWithEmpty", "" }
};
var serialize = DictionarySerializer.Serialize(before);
Approver.Verify(serialize);
var after = DictionarySerializer.DeSerialize(serialize);
AssertDictionariesAreTheSame(before, after);
}
internal void SendMessage(In data, MessageCallback callback)
{
var packageId = id.GetNext();
if (callbacks.ContainsKey(packageId))
{
callbacks[packageId](ParseMessage <Error>(MessageSerializer.createErrorMessage("Message timed out", packageId)), null);
callbacks.Remove(packageId);
}
callbacks.Add(packageId, callback);
sender.SendMessage(packer.Pack(DictionarySerializer.AsDictionary(new Message <In>()
{
id = packageId,
cmd = cmd,
data = data
})));
}
public void DictionaryTest1()
{
var a = new TestClassA();
a.SetValues();
var serializedData_noMask = DictionarySerializer.Serialize(a);
var a_NoMask = DictionarySerializer.Deserialize <TestClassA>(serializedData_noMask);
var serializedData_Mask_1 = DictionarySerializer.Serialize(a, SerializationMaskType.Public);
var a_Mask_1 = DictionarySerializer.Deserialize <TestClassA>(serializedData_Mask_1);
var serializedData_Mask_2 = DictionarySerializer.Serialize(a, SerializationMaskType.Private);
var a_Mask_2 = DictionarySerializer.Deserialize <TestClassA>(serializedData_Mask_2);
var serializedData_Mask_1_2 = DictionarySerializer.Serialize(a, SerializationMaskType.Public | SerializationMaskType.Private);
var a_Mask_1_2 = DictionarySerializer.Deserialize <TestClassA>(serializedData_Mask_1_2);
}
public void InterfaceTest()
{
var interfaceList = new List <Interface>();
interfaceList.Add(new DerivedA {
a = "a1"
});
interfaceList.Add(new DerivedA {
a = "a2"
});
interfaceList.Add(new DerivedB {
b = "b1"
});
var serializedData = DictionarySerializer.Serialize(interfaceList);
var interfaceListOut = DictionarySerializer.Deserialize <List <Interface> >(serializedData);
Assert.AreEqual(interfaceList.Count, interfaceListOut.Count);
}
public TEntity Create(Dictionary <string, object> dictionary)
{
try
{
using (var unitOfWork = _manager.Begin())
{
var entity = new DictionarySerializer <TEntity>(CompareWay.ToLower)
.Deserialize(dictionary);
_repository.Add(entity);
unitOfWork.Complete();
return(entity);
}
}
catch (Exception e)
{
_logger.LogError(e, $"Action {nameof(this.Create)} Error");
throw e;
}
}
public static void DeleteConfiguration(string ConnectionName)
{
#if !IPHONE
try
{
DictionarySerializer <String, PLCConnectionConfiguration> ConnectionsDicSer = new DictionarySerializer <string, PLCConnectionConfiguration>();
Dictionary <String, PLCConnectionConfiguration> Connections = null;
if (File.Exists(ConfigurationPathAndFilename))
{
StreamReader strm = new StreamReader(ConfigurationPathAndFilename);
Connections = ConnectionsDicSer.Deserialize(strm);
//string txt = strm.ReadToEnd();
strm.Close();
//Connections = General.SerializeToString<Dictionary<String, PLCConnectionConfiguration>>.DeSerialize(txt);
}
if (Connections == null)
{
Connections = new Dictionary <string, PLCConnectionConfiguration>();
}
if (Connections.ContainsKey(ConnectionName))
{
Connections.Remove(ConnectionName);
}
Directory.CreateDirectory(Path.GetDirectoryName(ConfigurationPathAndFilename));
StreamWriter sstrm = new StreamWriter(ConfigurationPathAndFilename, false);
ConnectionsDicSer.Serialize(Connections, sstrm);
//sstrm.Write(stxt);
//sstrm.Flush();
sstrm.Close();
return;
Registry.CurrentUser.DeleteSubKeyTree(
"Software\\JFKSolutions\\WPFToolboxForSiemensPLCs\\Connections\\" + ConnectionName);
}
catch (Exception)
{ }
#endif
}
public void Init()
{
Configuration = new uSyncCoreConfig();
ContentTypeSerializer = new ContentTypeSerializer(Constants.Packaging.DocumentTypeNodeName);
MediaTypeSerializer = new MediaTypeSerializer("MediaType");
MemberTypeSerializer = new MemberTypeSerializer("MemberType");
TemplateSerializer = new TemplateSerializer(Constants.Packaging.TemplateNodeName);
LanguageSerializer = new LanguageSerializer("Language");
DictionarySerializer = new DictionarySerializer(Constants.Packaging.DictionaryItemNodeName);
MacroSerializer = new MacroSerializer(Constants.Packaging.MacroNodeName);
DataTypeSerializer = new DataTypeSerializer(Constants.Packaging.DataTypeNodeName);
ContentSerializer = new ContentSerializer();
MediaSerializer = new MediaSerializer();
MediaFileMover = new uSyncMediaFileMover();
}
public void SaveConfiguration()
{
if (ConfigurationType == LibNodaveConnectionConfigurationType.RegistrySavedConfiguration)
{
#if !IPHONE
DictionarySerializer<String, PLCConnectionConfiguration> ConnectionsDicSer = new DictionarySerializer<string, PLCConnectionConfiguration>();
Dictionary<String, PLCConnectionConfiguration> Connections = null;
if (File.Exists(ConfigurationPathAndFilename))
{
StreamReader strm = new StreamReader(ConfigurationPathAndFilename);
Connections = ConnectionsDicSer.Deserialize(strm);
//string txt = strm.ReadToEnd();
strm.Close();
//Connections = General.SerializeToString<Dictionary<String, PLCConnectionConfiguration>>.DeSerialize(txt);
}
if (Connections == null)
Connections = new Dictionary<string, PLCConnectionConfiguration>();
if (Connections.ContainsKey(ConnectionName))
Connections.Remove(ConnectionName);
Connections.Add(ConnectionName, this);
Directory.CreateDirectory(Path.GetDirectoryName(ConfigurationPathAndFilename));
StreamWriter sstrm = new StreamWriter(ConfigurationPathAndFilename, false);
ConnectionsDicSer.Serialize(Connections, sstrm);
//sstrm.Write(stxt);
//sstrm.Flush();
sstrm.Close();
return;
RegistryKey myConnectionKey =
Registry.CurrentUser.CreateSubKey(
"Software\\JFKSolutions\\WPFToolboxForSiemensPLCs\\Connections\\" + ConnectionName);
if (myConnectionKey != null)
{
myConnectionKey.SetValue("EntryPoint", this.EntryPoint);
myConnectionKey.SetValue("CpuRack", this.CpuRack);
myConnectionKey.SetValue("CpuSlot", this.CpuSlot);
myConnectionKey.SetValue("CpuMpi", this.CpuMpi);
myConnectionKey.SetValue("CpuIP", this.CpuIP);
myConnectionKey.SetValue("LokalMpi", this.LokalMpi);
myConnectionKey.SetValue("ComPort", this.ComPort);
myConnectionKey.SetValue("ConnectionType", this.ConnectionType);
myConnectionKey.SetValue("BusSpeed", this.BusSpeed);
myConnectionKey.SetValue("NetLinkReset", this.NetLinkReset);
myConnectionKey.SetValue("ComPortSpeed", this.ComPortSpeed);
myConnectionKey.SetValue("ComPortParity", this.ComPortParity);
myConnectionKey.SetValue("Routing", this.Routing);
myConnectionKey.SetValue("RoutingDestinationRack", this.RoutingDestinationRack);
myConnectionKey.SetValue("RoutingDestinationSlot", this.RoutingDestinationSlot);
myConnectionKey.SetValue("RoutingSubnet1", this.RoutingSubnet1);
myConnectionKey.SetValue("RoutingSubnet2", this.RoutingSubnet2);
myConnectionKey.SetValue("RoutingDestination", this.RoutingDestination);
myConnectionKey.SetValue("Port", this.Port);
myConnectionKey.SetValue("PLCConnectionType", this.PLCConnectionType);
myConnectionKey.SetValue("RoutingPLCConnectionType", this.RoutingPLCConnectionType);
myConnectionKey.SetValue("Timeout", this.Timeout);
myConnectionKey.SetValue("TimeoutIPConnect", this.TimeoutIPConnect);
}
#endif
}
}
public static void DeleteConfiguration(string ConnectionName)
{
#if !IPHONE
try
{
DictionarySerializer<String, PLCConnectionConfiguration> ConnectionsDicSer = new DictionarySerializer<string, PLCConnectionConfiguration>();
Dictionary<String, PLCConnectionConfiguration> Connections = null;
if (File.Exists(ConfigurationPathAndFilename))
{
StreamReader strm = new StreamReader(ConfigurationPathAndFilename);
Connections = ConnectionsDicSer.Deserialize(strm);
//string txt = strm.ReadToEnd();
strm.Close();
//Connections = General.SerializeToString<Dictionary<String, PLCConnectionConfiguration>>.DeSerialize(txt);
}
if (Connections == null)
Connections = new Dictionary<string, PLCConnectionConfiguration>();
if (Connections.ContainsKey(ConnectionName))
Connections.Remove(ConnectionName);
Directory.CreateDirectory(Path.GetDirectoryName(ConfigurationPathAndFilename));
StreamWriter sstrm = new StreamWriter(ConfigurationPathAndFilename, false);
ConnectionsDicSer.Serialize(Connections, sstrm);
//sstrm.Write(stxt);
//sstrm.Flush();
sstrm.Close();
return;
Registry.CurrentUser.DeleteSubKeyTree(
"Software\\JFKSolutions\\WPFToolboxForSiemensPLCs\\Connections\\" + ConnectionName);
}
catch (Exception)
{ }
#endif
}
public void ReloadConfiguration()
{
if (ConfigurationType == LibNodaveConnectionConfigurationType.RegistrySavedConfiguration)
{
#if !IPHONE
if (File.Exists(ConfigurationPathAndFilename))
{
DictionarySerializer<String, PLCConnectionConfiguration> ConnectionsDicSer = new DictionarySerializer<string, PLCConnectionConfiguration>();
Dictionary<String, PLCConnectionConfiguration> Connections = null;
StreamReader strm = new StreamReader(ConfigurationPathAndFilename);
Connections = ConnectionsDicSer.Deserialize(strm);
//string txt = strm.ReadToEnd();
strm.Close();
//Connections = General.SerializeToString<Dictionary<String, PLCConnectionConfiguration>>.DeSerialize(txt);
if (Connections != null && Connections.ContainsKey(ConnectionName))
{
PLCConnectionConfiguration akConf = Connections[ConnectionName];
this.EntryPoint = akConf.EntryPoint;
this.CpuRack = akConf.CpuRack;
this.CpuSlot = akConf.CpuSlot;
this.CpuMpi = akConf.CpuMpi;
this.CpuIP = akConf.CpuIP;
this.LokalMpi = akConf.LokalMpi;
this.ComPort = akConf.ComPort;
this.ConnectionType = akConf.ConnectionType;
this.BusSpeed = akConf.BusSpeed;
this.NetLinkReset = akConf.NetLinkReset;
this.ComPortSpeed = akConf.ComPortSpeed;
this.ComPortParity = akConf.ComPortParity;
this.Routing = akConf.Routing;
this.RoutingDestinationRack = akConf.RoutingDestinationRack;
this.RoutingDestinationSlot = akConf.RoutingDestinationSlot;
this.RoutingSubnet1 = akConf.RoutingSubnet1;
this.RoutingSubnet2 = akConf.RoutingSubnet2;
this.RoutingDestination = akConf.RoutingDestination;
this.Port = akConf.Port;
this.PLCConnectionType = akConf.PLCConnectionType;
this.RoutingPLCConnectionType = akConf.RoutingPLCConnectionType;
this.Timeout = akConf.Timeout;
this.TimeoutIPConnect = akConf.TimeoutIPConnect;
}
}
return;
RegistryKey myConnectionKey =
Registry.CurrentUser.CreateSubKey(
"Software\\JFKSolutions\\WPFToolboxForSiemensPLCs\\Connections\\" + ConnectionName);
if (myConnectionKey != null)
{
this.EntryPoint = (String)myConnectionKey.GetValue("EntryPoint", "S7ONLINE");
this.CpuRack = Convert.ToInt32(myConnectionKey.GetValue("CpuRack", "0"));
this.CpuSlot = Convert.ToInt32(myConnectionKey.GetValue("CpuSlot", "2"));
this.CpuMpi = Convert.ToInt32(myConnectionKey.GetValue("CpuMpi", "2"));
this.CpuIP = (String)myConnectionKey.GetValue("CpuIP", "192.168.1.1");
this.LokalMpi = Convert.ToInt32(myConnectionKey.GetValue("LokalMpi", "0"));
this.ComPort = (String)myConnectionKey.GetValue("ComPort", "");
this.ConnectionType = Convert.ToInt32(myConnectionKey.GetValue("ConnectionType", "1"));
this.BusSpeed = Convert.ToInt32(myConnectionKey.GetValue("BusSpeed", "2"));
this.NetLinkReset = Convert.ToBoolean(myConnectionKey.GetValue("NetLinkReset", "false"));
this.ComPortSpeed = (String)myConnectionKey.GetValue("ComPortSpeed", "38400");
this.ComPortParity = Convert.ToInt32(myConnectionKey.GetValue("ComPortParity", "1"));
this.Routing = Convert.ToBoolean(myConnectionKey.GetValue("Routing", "false"));
this.RoutingDestinationRack =
Convert.ToInt32(myConnectionKey.GetValue("RoutingDestinationRack", "0"));
this.RoutingDestinationSlot =
Convert.ToInt32(myConnectionKey.GetValue("RoutingDestinationSlot", "2"));
this.RoutingSubnet1 = Convert.ToInt32(myConnectionKey.GetValue("RoutingSubnet1", "0"));
this.RoutingSubnet2 = Convert.ToInt32(myConnectionKey.GetValue("RoutingSubnet2", "0"));
this.RoutingDestination = Convert.ToString(myConnectionKey.GetValue("RoutingDestination", "2"));
this.Port = Convert.ToInt32(myConnectionKey.GetValue("Port", "102"));
this.PLCConnectionType = Convert.ToInt32(myConnectionKey.GetValue("PLCConnectionType", "1"));
this.RoutingPLCConnectionType = Convert.ToInt32(myConnectionKey.GetValue("RoutingPLCConnectionType", "1"));
this.Timeout = Convert.ToInt32(myConnectionKey.GetValue("Timeout", "5000000"));
this.TimeoutIPConnect = Convert.ToInt32(myConnectionKey.GetValue("TimeoutIPConnect", "5000"));
}
#endif
}
else
{
if (!_initDone)
{
this.ConnectionType = 122;
this.CpuMpi = 2;
this.EntryPoint = "S7ONLINE";
this.CpuIP = "192.168.1.1";
this.CpuRack = 0;
this.CpuSlot = 2;
this.Port = 102;
this.TimeoutIPConnect = 5000;
this.Timeout = 5000000;
_initDone = true;
}
}
}
public static String[] GetConfigurationNames()
{
#if !IPHONE
if (File.Exists(ConfigurationPathAndFilename))
{
DictionarySerializer<String, PLCConnectionConfiguration> ConnectionsDicSer = new DictionarySerializer<string, PLCConnectionConfiguration>();
Dictionary<String, PLCConnectionConfiguration> Connections = null;
StreamReader strm = new StreamReader(ConfigurationPathAndFilename);
Connections = ConnectionsDicSer.Deserialize(strm);
//string txt = strm.ReadToEnd();
strm.Close();
//Connections = General.SerializeToString<Dictionary<String, PLCConnectionConfiguration>>.DeSerialize(txt);
if (Connections != null)
{
string[] Names = new string[Connections.Count];
Connections.Keys.CopyTo(Names, 0);
return Names;
}
}
return new string[0];
RegistryKey myConnectionKey =
Registry.CurrentUser.CreateSubKey("Software\\JFKSolutions\\WPFToolboxForSiemensPLCs\\Connections");
return myConnectionKey.GetSubKeyNames();
#else
return null;
#endif
}
/// <summary>
/// Serialize CustomValues of ProcessPaymentRequest
/// </summary>
/// <param name="request">Request</param>
/// <returns>Serialized CustomValues</returns>
public static string SerializeCustomValues(this ProcessPaymentRequest request)
{
if (request == null)
throw new ArgumentNullException("request");
if (request.CustomValues.Count == 0)
return null;
//XmlSerializer won't serialize objects that implement IDictionary by default.
//http://msdn.microsoft.com/en-us/magazine/cc164135.aspx
//also see http://ropox.ru/tag/ixmlserializable/ (Russian language)
var ds = new DictionarySerializer(request.CustomValues);
var xs = new XmlSerializer(typeof(DictionarySerializer));
using (var textWriter = new StringWriter())
{
using (var xmlWriter = XmlWriter.Create(textWriter))
{
xs.Serialize(xmlWriter, ds);
}
var result = textWriter.ToString();
return result;
}
}
