public void Install(IWindsorContainer container, IConfigurationStore store)
{
container.Register(
Component.For<Project>().UsingFactoryMethod<Project>(kernel => {
var args = Environment.GetCommandLineArgs();
var assembler = kernel.Resolve<ProjectAssembler>();
var deserializer = new System.Xml.Serialization.XmlSerializer(typeof(ProjectDTO));
ProjectDTO dto = null;
try
{
using (TextReader reader = new StreamReader(args[1]))
dto = (ProjectDTO)deserializer.Deserialize(reader);
}
catch (Exception ex)
{
// halt application (not currently in a message loop)
// TODO: need to inform the user that we couldn't load the project: this is why
// we shouldn't have this logic in the installer, we need to farm it out to something
// else (plus we'll get a more responsive application as it'll load the UI immediately)
Environment.Exit(-1);
}
return assembler.Restore(dto);
}),
Component.For<IConfiguration>()
.UsingFactoryMethod<IConfiguration>(kernel => kernel.Resolve<Project>().Configuration),
Component.For<IList<ISubject>>()
.UsingFactoryMethod(kernel => kernel.Resolve<IConfiguration>())
);
}
public UnityEditor.EditorBuildSettingsScene[] GetPreviousScenesToRestore()
{
string text = null;
if (Application.isEditor)
{
text = GetTextFromTempFile(previousScenes);
}
if(text != null)
{
var serializer = new System.Xml.Serialization.XmlSerializer(typeof(UnityEditor.EditorBuildSettingsScene[]));
using(var textReader = new StringReader(text))
{
try
{
return (UnityEditor.EditorBuildSettingsScene[] )serializer.Deserialize(textReader);
}
catch (System.Xml.XmlException e)
{
Debug.Log (e);
return null;
}
}
}
return null;
}
private static object DeserializeMessage_XML(string cmd, Type cmdType) {
using( StringReader stringReader = new StringReader(cmd) )
using( XmlTextReader xmlTextReader = new XmlTextReader(stringReader) ) {
System.Xml.Serialization.XmlSerializer x = new System.Xml.Serialization.XmlSerializer(cmdType);
return x.Deserialize(xmlTextReader);
}
}
public void InitializeTwitter()
{
try
{
System.Xml.Serialization.XmlSerializer serializer =
new System.Xml.Serialization.XmlSerializer(typeof(saveSettings));
System.IO.FileStream fs = new System.IO.FileStream(
@"settings.xml", System.IO.FileMode.Open);
saveSettings setting = (saveSettings)serializer.Deserialize(fs);
fs.Close();
textBox1.Enabled = false;
//accToken = setting.AccToken;
token.AccessToken = setting.AccToken;
//accTokenSec = setting.AccTokenSec;
token.AccessTokenSecret = setting.AccTokenSec;
var Stream = new TwitterStream(token, "Feedertter", null);
StatusCreatedCallback statusCreatedCallback = new StatusCreatedCallback(StatusCreatedCallback);
RawJsonCallback rawJsonCallback = new RawJsonCallback(RawJsonCallback);
Stream.StartUserStream(null, null,
/*(x) => { label1.Text += x.Text; }*/
statusCreatedCallback,
null, null, null, null, rawJsonCallback);
}
catch
{
Process.Start(OAuthUtility.BuildAuthorizationUri(req.Token).ToString());
}
//Process.Start(OAuthUtility.BuildAuthorizationUri(req.Token).ToString());
}
public Chomper(RoomNew room, ContentManager Content, Enumeration.TileType tileType, Enumeration.StateTile state, Enumeration.TileType NextTileType__1)
{
base.room = room;
nextTileType = NextTileType__1;
System.Xml.Serialization.XmlSerializer ax = new System.Xml.Serialization.XmlSerializer(tileSequence.GetType());
Stream txtReader = Microsoft.Xna.Framework.TitleContainer.OpenStream(PrinceOfPersiaGame.CONFIG_PATH_CONTENT + PrinceOfPersiaGame.CONFIG_PATH_SEQUENCES + tileType.ToString().ToUpper() + "_sequence.xml");
tileSequence = (List<Sequence>)ax.Deserialize(txtReader);
foreach (Sequence s in tileSequence)
{
s.Initialize(Content);
}
//Search in the sequence the right type
//Sequence result = tileSequence.Find((Sequence s) => s.name.ToUpper() == state.ToString().ToUpper());
Sequence result = tileSequence.Find((Sequence s) => s.name == state.ToString().ToUpper());
if (result != null)
{
result.frames[0].SetTexture(Content.Load<Texture2D>(PrinceOfPersiaGame.CONFIG_TILES[0] + result.frames[0].value));
collision = result.collision;
Texture = result.frames[0].texture;
}
Type = tileType;
//change statetile element
tileState.Value().state = state;
tileAnimation.PlayAnimation(tileSequence, tileState.Value());
}
public static AltaCache Read(string file)
{
if (!File.Exists(file))
{
Write(file, new AltaCache());
return new AltaCache();
}
else
{
FileInfo inf = new FileInfo(file);
while (inf.IsFileLocked()) { Console.WriteLine("Wait..."); };
try
{
using (Stream s = File.Open(file, FileMode.Open))
{
System.Xml.Serialization.XmlSerializer reader = new System.Xml.Serialization.XmlSerializer(typeof(AltaCache));
return (AltaCache)reader.Deserialize(s);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.GetBaseException().ToString());
return new AltaCache();
}
}
}
//[DebuggerHidden]
public override bool Init()
{
loopratehz = 1;
if (File.Exists(statsfile))
{
try
{
System.Xml.Serialization.XmlSerializer reader = new System.Xml.Serialization.XmlSerializer(statsoverall.GetType());
var file = new System.IO.StreamReader(statsfile);
statsoverall = (whattostat)reader.Deserialize(file);
file.Close();
}
catch { }
}
MainV2.instance.Invoke((Action)
delegate
{
System.Windows.Forms.ToolStripMenuItem men = new System.Windows.Forms.ToolStripMenuItem() { Text = "Stats" };
men.Click += men_Click;
Host.FDMenuMap.Items.Add(men);
});
statsoverall.appstarts++;
return true;
}
public object Deserialize(System.IO.Stream stream, Type type)
{
System.Xml.Serialization.XmlSerializer serializer =
new System.Xml.Serialization.XmlSerializer(type);
stream.Position = 0;
return serializer.Deserialize(stream);
}
public static object deserializeXml(byte[] xmldata)
{
if (!validateXml(xmldata))
{
return null;
}
MemoryStream ms = new MemoryStream();
ms.Read(xmldata, 0, xmldata.Length);
XDocument doc = XDocument.Load(ms);
string msgtype = doc.Root.Attribute("messageType").Value;
object msg = null;
switch (msgtype)
{
case "register":
msg = new registerMessageType();
break;
case "login":
break;
case "newfile":
break;
case "filepatch":
break;
case "filecontent":
break;
}
StreamReader sr = new StreamReader(ms);
System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(msg.GetType());
msg = xs.Deserialize(sr);
return msg;
}
private void LoadXMLMunicipios()
{
System.Xml.Serialization.XmlSerializer reader = new System.Xml.Serialization.XmlSerializer(typeof(Brasil));
System.IO.StreamReader file = new System.IO.StreamReader(@"MunicipioBR.xml");
brasil = (Brasil)reader.Deserialize(file);
file.Close();
}
public static Settings DeserializeFromSelf(string xmlData)
{
System.Xml.Serialization.XmlSerializer xmlSerializer =
new System.Xml.Serialization.XmlSerializer(typeof (Settings));
MemoryStream memoryStream = new MemoryStream(StringToUTF8ByteArray(xmlData));
return (Settings) xmlSerializer.Deserialize(memoryStream);
}
public static object DeSerialize(string sXML, Type ObjectType)
{
System.IO.StringReader oStringReader = null;
System.Xml.Serialization.XmlSerializer oXmlSerializer = null;
object oObject = null;
// -----------------------------------------------------------------------------------------------------------------------
// Hvis mangler info, lage tom
// -----------------------------------------------------------------------------------------------------------------------
if (sXML == string.Empty)
{
Type[] types = new Type[-1 + 1];
System.Reflection.ConstructorInfo info = ObjectType.GetConstructor(types);
object targetObject = info.Invoke(null);
if (targetObject == null)
return null;
return targetObject;
}
// -----------------------------------------------------------------------------------------------------------------------
// Gjøre om fra XML til objekt
// -----------------------------------------------------------------------------------------------------------------------
oStringReader = new System.IO.StringReader(sXML);
oXmlSerializer = new System.Xml.Serialization.XmlSerializer(ObjectType);
oObject = oXmlSerializer.Deserialize(oStringReader);
return oObject;
}
public static List<SolutionInfo> GetSolutionPriorityList()
{
var dte = XFeaturesPackage.DTE();
var slnpriorityfile = dte.Solution.FullName + ".xml";
var newlist = new List<SolutionInfo>();
if(File.Exists(slnpriorityfile))
{
using (System.IO.StreamReader reader = new System.IO.StreamReader(slnpriorityfile))
{
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(Container));
var cnt = (Container)serializer.Deserialize(reader);
if (cnt != null)
{
GetValidProjects(cnt.Items,ref newlist);
if (newlist.Any() == false)
{
return cnt.Items;
}
}
}
}
else
{
GetValidProjects(new List<SolutionInfo>(),ref newlist);
}
return newlist;
}
private List<Record> GetHigtscore()
{
System.Xml.Serialization.XmlSerializer reader = new System.Xml.Serialization.XmlSerializer(typeof(List<Record>));
System.IO.StreamReader file = new System.IO.StreamReader("Records.xml");
_records = (List<Record>)reader.Deserialize(file);
return _records;
}
//Loads a environment from an XML file and initializes it
public static ExperimentWrapper load(string name)
{
System.Xml.Serialization.XmlSerializer x = new System.Xml.Serialization.XmlSerializer(typeof(ExperimentWrapper));
TextReader infile = new StreamReader(name);
ExperimentWrapper e = (ExperimentWrapper)x.Deserialize(infile);
infile.Close();
//TODO include LEO
//Determine the number of CPPN inputs and outputs automatically
//if (e.experiment.homogeneousTeam)
// e.experiment.inputs = 4;
//else
// e.experiment.inputs = 5;
//if (e.experiment.adaptableANN)
//{
// if (e.experiment.modulatoryANN) e.experiment.outputs = 8; else e.experiment.outputs = 7;
//}
//else
// e.experiment.outputs = 2;
//TODO maybe include e.experiment.initialize();
return e;
}
private void LoadTestCredential()
{
string path = @"C:\Temp\AmazonAwsS3Test.xml";
Models.AwsCredential credential;
var xmlSerializer = new System.Xml.Serialization.XmlSerializer(typeof(Models.AwsCredential));
if (!System.IO.File.Exists(path))
{
//Cria um arquivo xml novo, se já não existir um
credential = new Models.AwsCredential();
credential.User = string.Empty;
credential.AccessKeyId = string.Empty;
credential.SecretAccessKey = string.Empty;
credential.Region = string.Empty;
using (var streamWriter = new System.IO.StreamWriter(path))
{
xmlSerializer.Serialize(streamWriter, credential);
}
}
//Carrega o xml
using (var streamReader = new System.IO.StreamReader(path))
{
credential = (Models.AwsCredential)xmlSerializer.Deserialize(streamReader);
}
txtAccessKeyId.Text = credential.AccessKeyId;
txtSecretAccessKey.Text = credential.SecretAccessKey;
txtRegion.Text = credential.Region;
}
static void Main()
{
/// <summary>
/// XML設定ファイル
/// </summary>
const string FILE_NAME = @"homeAppManager.xml";
try
{
using (System.IO.TextReader reader = new System.IO.StreamReader(FILE_NAME, Encoding.UTF8, false))
{
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(Config));
Config.init = (Config)serializer.Deserialize(reader);
}
}
catch (System.IO.FileNotFoundException ex)
{
//XmlSerializerオブジェクトを作成
using (System.IO.TextWriter writer = new System.IO.StreamWriter(FILE_NAME, false, Encoding.UTF8))
{
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(Config.init.GetType());
serializer.Serialize(writer, Config.init);
}
}
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new frm_Main());
}
/// <summary>
/// 通过类型获取 配置信息类 对象
/// </summary>
/// <paramKey name="type">可序列化的类类型</paramKey>
/// <returns></returns>
public static object LoadConfigByType(Type type)
{
try
{
//配置文件
fileName = System.IO.Path.Combine(ConfigDirectory, fileName);
string fname = type.FullName;
//去掉+ ,当是内部类时会出现加号
fname = fname.Replace("+", ".");
//找到对应节点
string value = GetObjString(fname);
if (value.Equals(string.Empty))
{
return new object();
}
//找对应字符串
System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(type);
//System.IO.StreamReader sr = new System.IO.StreamReader(localConfigPath);
System.IO.StringReader sr = new System.IO.StringReader(value);
object obj = xs.Deserialize(sr);
//反序列化
return obj;
}
catch
{
return new object();
}
}
public virtual void Load(string filename)
{
System.Xml.Serialization.XmlSerializer serialize = new System.Xml.Serialization.XmlSerializer(this.GetType());
System.IO.StreamReader sr = new System.IO.StreamReader(filename, new System.Text.UTF8Encoding(false));
this.setData((AData)serialize.Deserialize(sr));
sr.Close();
}
public Flask(ContentManager Content)
{
System.Xml.Serialization.XmlSerializer ax = new System.Xml.Serialization.XmlSerializer(ItemSequence.GetType());
Stream txtReader = Microsoft.Xna.Framework.TitleContainer.OpenStream(PrinceOfPersiaGame.CONFIG_PATH_CONTENT + PrinceOfPersiaGame.CONFIG_PATH_SEQUENCES + Enumeration.Items.flask.ToString().ToUpper() + "_sequence.xml");
//TextReader txtReader = File.OpenText(PrinceOfPersiaGame.CONFIG_PATH_CONTENT + PrinceOfPersiaGame.CONFIG_PATH_SEQUENCES + tileType.ToString().ToUpper() + "_sequence.xml");
ItemSequence = (List<Sequence>)ax.Deserialize(txtReader);
foreach (Sequence s in ItemSequence)
{
s.Initialize(Content);
}
//Search in the sequence the right type
Sequence result = ItemSequence.Find((Sequence s) => s.name == Enumeration.StateTile.normal.ToString().ToUpper());
if (result != null)
{
//AMF to be adjust....
result.frames[0].SetTexture(Content.Load<Texture2D>(PrinceOfPersiaGame.CONFIG_ITEMS + result.frames[0].value));
Texture = result.frames[0].texture;
}
//change statetile element
StateTileElement stateTileElement = new StateTileElement();
stateTileElement.state = Enumeration.StateTile.normal;
itemState.Add(stateTileElement);
itemAnimation.PlayAnimation(ItemSequence, itemState.Value());
}
public object GetEntityData(Type entityType, StreamReader reader)
{
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(entityType);
object obj = serializer.Deserialize(reader);
return obj;
}
public static RSAParameters ReadKeyFromString(string key)
{
StringReader sr = new System.IO.StringReader(key);
var xs = new System.Xml.Serialization.XmlSerializer(typeof(RSAParameters));
RSAParameters k = (RSAParameters)xs.Deserialize(sr);
return k;
}
public MainWindow()
{
InitializeComponent();
List<CsvDataTable> myList = new List<CsvDataTable>() { };
///起動時にデータベースがあるかどうか。無ければ作成する
if (System.IO.File.Exists(db_file)){}
else
{
createDataBase();
}
///起動時にXMLがあるかどうか。あれば読み込む
if (System.IO.File.Exists(SaveDataPath))
{
//XmlSerializerオブジェクトを作成
System.Xml.Serialization.XmlSerializer serializer =new System.Xml.Serialization.XmlSerializer(typeof(TreeViewClass));
//読み込むファイルを開く
System.IO.StreamReader sr = new System.IO.StreamReader(SaveDataPath, new System.Text.UTF8Encoding(false));
//XMLファイルから読み込み、逆シリアル化する
root_ = (TreeViewClass)serializer.Deserialize(sr);
//ファイルを閉じる
sr.Close();
///ステータスバーに次の指示を描写
StatusLabel.Content = "TreeViewの項目をクリックすることでCSVDataViewにデータを表示することが出来ます";
}else{
root_ = new TreeViewClass("root");
}
///root_をXAMLから読み込ませるためにDataContextを使用
DataContext = root_;
dataGrid1.ItemsSource = GetDataBaseTable(myList).DefaultView;
}
static void Main(string[] args)
{
System.Xml.Serialization.XmlSerializer sr = new System.Xml.Serialization.XmlSerializer(typeof(Config));
if (!System.IO.File.Exists(AppDomain.CurrentDomain.BaseDirectory + "config.xml"))
{
Config config = new Config() {id=1, WirelessComPort = "Com14", TouhPanelComPort = "Com18",IOComPort="Com12" };
sr.Serialize(System.IO.File.Create(AppDomain.CurrentDomain.BaseDirectory + "config.xml"), config);
Console.WriteLine("please modify the config.xml");
// Console.ReadKey();
Environment.Exit(-1);
}
else
{
config = sr.Deserialize(System.IO.File.OpenRead(AppDomain.CurrentDomain.BaseDirectory + "config.xml")) as Config;
if (config == null)
{
Console.WriteLine("config.xml reading error!");
Environment.Exit(-1);
}
}
controller = new Controller(config.id,config.WirelessComPort,config.TouhPanelComPort,config.IOComPort);
}
// called after the authentication stage
public bool Evaluate(EvaluationContext evaluationContext, ref object state)
{
IList<IIdentity> idents;
object identsObject;
if (evaluationContext.Properties.TryGetValue(
"Identities", out identsObject) && (idents =
identsObject as IList<IIdentity>) != null)
{
foreach (IIdentity ident in idents)
{
if (ident.IsAuthenticated &&
ident.AuthenticationType == "BiometricValidator")
{
StringReader reader = new StringReader(ident.Name);
System.Xml.Serialization.XmlSerializer deserializer = new System.Xml.Serialization.XmlSerializer(typeof(SecureContextCredentials));
SecureContextCredentials credentials = (SecureContextCredentials)deserializer.Deserialize(reader);
IdsIdentity i = new IdsIdentity(ident.IsAuthenticated, AuthenticationType.Bioemtrics, credentials.IdentityUid);
IdsPrincipal p = new IdsPrincipal(i, new List<string> { "LoggedIn" });
evaluationContext.Properties["Principal"] = p;
return true;
}
else
{
string userId = OperationContext.Current.IncomingMessageHeaders.GetHeader<string>("userId", "http://www.identitystream.com");
IdsIdentity i = new IdsIdentity(ident.IsAuthenticated, AuthenticationType.Certificate, userId);
IdsPrincipal p = new IdsPrincipal(i, new List<string> { "LoggedIn" });
evaluationContext.Properties["Principal"] = p;
return true;
}
}
}
return false;
}
protected override void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);
//
// Get the person object from the intent
//
Person person;
if (Intent.HasExtra ("Person")) {
var serializer = new System.Xml.Serialization.XmlSerializer (typeof (Person));
var personBytes = Intent.GetByteArrayExtra ("Person");
person = (Person)serializer.Deserialize (new MemoryStream (personBytes));
} else {
person = new Person ();
}
//
// Load the View Model
//
viewModel = new PersonViewModel (person, Android.Application.SharedFavoritesRepository);
viewModel.PropertyChanged += HandleViewModelPropertyChanged;
//
// Setup the UI
//
ListView.Divider = null;
ListAdapter = new PersonAdapter (viewModel);
Title = person.SafeDisplayName;
}
public static User FromString(String XmlString, ref string TargetString)
{
System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(typeof(User));
MemoryStream memoryStream = new MemoryStream(Serialize.StringToUTF8ByteArray(XmlString));
XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8);
return (User)xs.Deserialize(memoryStream);
}
public static object Deserialize(string xmlContent, string serializerType)
{
object returnValue = null;
SerializerTypes serializerTypeValue;
Type instanceType;
GetSerializerDetails(serializerType, out serializerTypeValue, out instanceType);
if (serializerTypeValue == SerializerTypes.XmlSerializer)
{
StringReader sww = new StringReader(xmlContent);
XmlReader reader = XmlReader.Create(sww);
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(instanceType);
returnValue = serializer.Deserialize(reader);
}
else if (serializerTypeValue == SerializerTypes.XmlObjectSerializer)
{
XmlObjectSerializer serializer = new XmlObjectSerializer();
returnValue = serializer.Deserialize(xmlContent, true);
}
else
{
if (instanceType == typeof(string))
{
returnValue = xmlContent;
}
else
{
var method = instanceType.GetMethod("Parse", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
returnValue = method.Invoke(null, new object[] { xmlContent });
}
}
return returnValue;
}
/// <summary>
/// Loads ClientSettings from a file.
/// </summary>
/// <param name="file">File path to load from.</param>
/// <returns>An instance of ClientSettings class.</returns>
public static ClientSettings Load(string file)
{
if (!File.Exists(file))
{
ClientSettings cfg = new ClientSettings();
Save(file, cfg);
return cfg;
}
// TODO: MAke this binary
System.Xml.Serialization.XmlSerializer xs
= new System.Xml.Serialization.XmlSerializer(
typeof(ClientSettings));
StreamReader reader = File.OpenText(file);
ClientSettings c = new ClientSettings();
try
{
c = (ClientSettings)xs.Deserialize(reader);
}
catch (Exception)
{
}
reader.Close();
return c;
}
void LoadFromFile()
{
var reader = new System.Xml.Serialization.XmlSerializer(typeof(List<string>));
var file = new System.IO.StreamReader(@"words.xml");
words = new List<string>();
words = (List<string>)reader.Deserialize(file);
}
public void UpdateList()
{
listBox.ItemsSource = null;
listBox.Items.Clear();
if (!(File.Exists("Notes.xml")))
{
File.Create("Notes.xml");
}
using (System.IO.StreamReader myStreamReader = new StreamReader("Notes.xml"))
{
System.Xml.Serialization.XmlSerializer myXML = new System.Xml.Serialization.XmlSerializer(typeof(ObservableCollection <String>));
Notes = (ObservableCollection <String>)myXML.Deserialize(myStreamReader);
}
Notes.Reverse();
listBox.ItemsSource = Notes;
}
/// Loads the player sprite sheet and sounds.
/// </summary>
/// <note>i will add a parameter read form app.config</note>
///
///
private void LoadContent()
{
spriteSequence = new List <Sequence>();
System.Xml.Serialization.XmlSerializer ax = new System.Xml.Serialization.XmlSerializer(spriteSequence.GetType());
Stream txtReader = Microsoft.Xna.Framework.TitleContainer.OpenStream(PoP.CONFIG_PATH_CONTENT + PoP.CONFIG_PATH_SEQUENCES + fileSequence);
//TextReader txtReader = File.OpenText(PrinceOfPersiaGame.CONFIG_PATH_CONTENT + PrinceOfPersiaGame.CONFIG_PATH_SEQUENCES + "KID_sequence.xml");
//Stream astream = this.GetType().Assembly.GetManifestResourceStream("PrinceOfPersia.resources.KID_sequence.xml");
spriteSequence = (List <Sequence>)ax.Deserialize(txtReader);
foreach (Sequence s in spriteSequence)
{
s.Initialize();
}
// Calculate bounds within texture size.
localBounds = new Rectangle(0, 0, SPRITE_SIZE_X, SPRITE_SIZE_Y);
}
public void LoadGrid()
{
System.Xml.Serialization.XmlSerializer reader = new System.Xml.Serialization.XmlSerializer(typeof(GridData));
using (OpenFileDialog ofd = new OpenFileDialog())
{
ofd.Filter = "*.grid|*.grid";
ofd.ShowDialog();
if (File.Exists(ofd.FileName))
{
using (StreamReader sr = new StreamReader(ofd.FileName))
{
var test = (GridData)reader.Deserialize(sr);
loadgriddata(test);
}
}
}
}
private void GetContentKinds()
{
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(ContentKind[]));
using (var reader = System.Xml.XmlReader.Create(KindsConfigXMLPath))
{
kindsCache = serializer.Deserialize(reader) as ContentKind[];
}
if (kindsCache == null)
{
kindsCache = new ContentKind[0];
}
foreach (ContentKind k in kindsCache)
{
if (k.Browsable == null)
{
k.Browsable = true;
}
if (k.CaptureController == null)
{
k.CaptureController = "~/cms_contents";
}
if (k.FriendlyPluralName == null)
{
k.FriendlyPluralName = k.FriendlyName + "s";
}
if (k.CaptureDetailView == null)
{
k.CaptureDetailView = k.Kind;
}
if (k.RequiredRolesToEdit == null || k.RequiredRolesToEdit.Length == 0)
{
k.RequiredRolesToEdit = new string[] { ADM_CMS_GROUP.UserGroupUId }
}
;
if (k.Tags == null)
{
k.Tags = new string[0];
}
}
}
public ContentSlide(int SlideSerial)
{
_SlideSerial = SlideSerial;
using (SqlConnection cn = new SqlConnection(ConfigurationManager.ConnectionStrings["ApplicationServices"].ConnectionString)) {
string SQL = "SELECT [ModuleID], [SlideTitle], [SlideContents], [SlideImage], [SlideLink], [SortOrder] " +
"FROM [cms_Slideshow] " +
"WHERE SlideSerial = @SlideSerial";
using (SqlCommand cmd = new SqlCommand(SQL, cn)) {
cmd.CommandType = CommandType.Text;
cmd.Parameters.Add("SlideSerial", SqlDbType.Int).Value = SlideSerial;
cmd.Connection.Open();
SqlDataReader dr = cmd.ExecuteReader(CommandBehavior.SingleRow);
if (dr.HasRows)
{
dr.Read();
_ModuleID = dr.GetGuid(0);
_SlideTitle = dr[1].ToString();
_SlideContents = dr[2].ToString();
_SlideImage = dr[3].ToString();
_SlideLink = dr[4].ToString();
_SortOrder = dr.GetInt32(5);
}
cmd.Connection.Close();
}
if (!string.IsNullOrEmpty(_SlideImage))
{
ImageSaveModel imageSaveModel = new ImageSaveModel();
System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
doc.LoadXml(_SlideImage);
System.Xml.XmlNodeReader reader = new System.Xml.XmlNodeReader(doc.DocumentElement);
System.Xml.Serialization.XmlSerializer ser = new System.Xml.Serialization.XmlSerializer(imageSaveModel.GetType());
imageSaveModel = (ImageSaveModel)ser.Deserialize(reader);
_SlideImageFile = imageSaveModel.Src;
_DimHeight = Convert.ToInt32(imageSaveModel.Height);
_DimWidth = Convert.ToInt32(imageSaveModel.Width);
}
}
}
public void LoadSettings()
{
// Unregister and clear all existing hotkeys
foreach (Hotkey hotkey in Hotkeys)
{
hotkey.UnregisterHotkey(this);
}
Hotkeys.Clear();
// Loading the xml file
if (!File.Exists(SettingsFileFromName("Hotkeys")))
{
return;
}
System.Xml.Serialization.XmlSerializer readerHotkey = new System.Xml.Serialization.XmlSerializer(typeof(Hotkey));
try
{
XmlReader xml = XmlReader.Create(SettingsFileFromName("Hotkeys"));
xml.Read();
while (true)
{
if ((xml.Name.CompareTo("Hotkey") == 0) && (xml.IsStartElement()))
{
Hotkey hotkey = (Hotkey)readerHotkey.Deserialize(xml);
Hotkeys.Add(hotkey);
continue;
}
if (!xml.Read())
{
break;
}
}
xml.Close();
}
catch
{
}
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
protected virtual async void GetAesKeyRequestHandler(IIncomingMessage message)
{
var extension = message.Peer.GetExtension <SecurityInfoPeerExtension>();
var encryptedKey = extension.AesKeyEncrypted;
if (encryptedKey != null)
{
logger.Debug("There's already a key generated");
// There's already a key generated
message.Respond(encryptedKey, ResponseStatus.Success);
return;
}
// Generate a random key
var aesKey = Mst.Helper.CreateRandomAlphanumericString(8);
var clientsPublicKeyXml = message.AsString();
// Deserialize public key
var sr = new System.IO.StringReader(clientsPublicKeyXml);
var xs = new System.Xml.Serialization.XmlSerializer(typeof(RSAParameters));
var clientsPublicKey = (RSAParameters)xs.Deserialize(sr);
byte[] encryptedAes = await Task.Run(() =>
{
using (var csp = new RSACryptoServiceProvider())
{
csp.ImportParameters(clientsPublicKey);
encryptedAes = csp.Encrypt(Encoding.Unicode.GetBytes(aesKey), false);
// Save keys for later use
extension.AesKeyEncrypted = encryptedAes;
extension.AesKey = aesKey;
return(encryptedAes);
}
});
message.Respond(encryptedAes, ResponseStatus.Success);
}
public Category(string inputPath)
{
path = inputPath;
// Use application's absolute path; (grabs the .exe)
// Gets the parent folder of the exe and concats the rest of the path
string fullPath;
// Check if path is a full directory or part of a file name
// Passed from the main shortcut client and the config client
// This if won't ever be true, because the path passed in is a full path to a folder.
/*
* if (System.IO.File.Exists(@Paths.path + @"\" + path + @"\ObjectData.xml"))
* {
* fullPath = @Paths.path + @"\" + path + @"\ObjectData.xml";
* }
* else
* {
*/
fullPath = Path.GetFullPath(Path.Combine(inputPath, "ObjectData.xml"));
/*
* }
*/
System.Xml.Serialization.XmlSerializer reader =
new System.Xml.Serialization.XmlSerializer(typeof(Category));
using (StreamReader file = new StreamReader(fullPath))
{
Category category = (Category)reader.Deserialize(file);
this.Name = category.Name;
this.ShortcutList = category.ShortcutList;
this.Width = category.Width;
this.ColorString = category.ColorString;
this.Opacity = category.Opacity;
this.allowOpenAll = category.allowOpenAll;
this.HoverColor = category.HoverColor;
}
}
public bool checkLogin(string name, string password, bool first)
{
try
{
connectToServer(Dns.GetHostName(), 1234);
//sending login request to the server: ("c100" is a code for login request comand)
if (first)
{
writeToServer("c100");
}
//recieving server's public key as string:
String serverPubKeyString = readFromServer();
//converting server's public key (string) to server key (RSAPARAM):
var sr = new System.IO.StringReader(serverPubKeyString);
var xs = new System.Xml.Serialization.XmlSerializer(typeof(RSAParameters));
serverPubKey = (RSAParameters)xs.Deserialize(sr);
//sending ecrypted mail and password:
var cypherText = EncryptData(name + "$" + password, serverPubKey);
writeToServer(cypherText);
//now waiting for response. Am I logged in?
String loginStatus = readFromServer();
if (String.Equals(loginStatus, "c105"))
{
this.usrMail = this.inpMail.Text;
this.usrPassword = this.inpPw.Text;
this.Opacity = 0;
this.ShowInTaskbar = false;
appForm aForm = new appForm(this);
aForm.Show();
return(true);
}
}
catch (Exception e) { MessageBox.Show(e.ToString()); }
return(false);
}
public Loose(Room room, Enumeration.TileType tileType, Enumeration.StateTile state, Enumeration.TileType NextTileType)
{
base.room = room;
nextTileType = NextTileType;
//this.switchButton = switchButton;
System.Xml.Serialization.XmlSerializer ax = new System.Xml.Serialization.XmlSerializer(tileSequence.GetType());
Stream txtReader = Microsoft.Xna.Framework.TitleContainer.OpenStream(PoP.CONFIG_PATH_CONTENT + PoP.CONFIG_PATH_SEQUENCES + tileType.ToString() + "_sequence.xml");
//TextReader txtReader = File.OpenText(PrinceOfPersiaGame.CONFIG_PATH_CONTENT + PrinceOfPersiaGame.CONFIG_PATH_SEQUENCES + tileType.ToString() + "_sequence.xml");
tileSequence = (List <Sequence>)ax.Deserialize(txtReader);
foreach (Sequence s in tileSequence)
{
s.Initialize();
}
//Search in the sequence the right type
Sequence result = tileSequence.Find(delegate(Sequence s)
{
//return s.name == tileType.ToString();
return(s.name.ToUpper() == state.ToString().ToUpper());
});
if (result != null)
{
//AMF to be adjust....
result.frames[0].SetTexture((Texture2D)Maze.Content[PoP.CONFIG_TILES + result.frames[0].value]);
//result.frames[0].SetTexture(Content.Load<Texture2D>(PrinceOfPersiaGame.CONFIG_TILES + result.frames[0].value));
collision = result.collision;
Texture = result.frames[0].texture;
}
Type = tileType;
//change statetile element
tileState.Value().state = state;
tileAnimation.PlayAnimation(tileSequence, tileState);
}
public int LaunchVisionWindow(int dbId, int left, int top, int width, int height)
{
if (left == 0 &&
top == 0 &&
width == 0 &&
height == 0)
{
// no window stored
return(LaunchVisionWindow(dbId));
}
// get the info from db
var result = ServerDbHelper.GetInstance().GetAllVisionInputs().First(t => t.id == dbId);
if (result == null)
{
Trace.WriteLine("unable to launch vision window with db id and rect: " + dbId);
return(0);
}
// create the lauching parameters
System.Xml.Serialization.XmlSerializer wndSerializer = new System.Xml.Serialization.XmlSerializer(typeof(Window));
TextReader wndReader = new StringReader(result.windowStr);
Window window = (Window)wndSerializer.Deserialize(wndReader);
// modify to match latest position
window.WndPostLeft = left;
window.WndPosTop = top;
window.WndPostWidth = width;
window.WndPosHeight = height;
System.Xml.Serialization.XmlSerializer inputSerializer = new System.Xml.Serialization.XmlSerializer(typeof(Input));
TextReader inputReader = new StringReader(result.inputStr);
Input input = (Input)inputSerializer.Deserialize(inputReader);
System.Xml.Serialization.XmlSerializer osdSerializer = new System.Xml.Serialization.XmlSerializer(typeof(OnScreenDisplay));
TextReader osdReader = new StringReader(result.osdStr);
OnScreenDisplay osd = (OnScreenDisplay)osdSerializer.Deserialize(osdReader);
return(launchVisionWindow(window, input, osd));
}
/// <summary>
/// 共通設定読み込み
/// </summary>
/// /// <returns>true:読込み成功、false:読込み失敗</returns>
private Boolean CommonSettingRead()
{
clsCommonSettting = new CommonSettings();
try
{
// 共通設定ファイルパス作成
string strCommonSettingFilePath = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) + "\\" + COMMON_SETFOLDERNAME + "\\" + COMMON_SETFILENAME;
// 共通設定ファイルが存在しない場合はデフォルト設定を書き込む
if (File.Exists(strCommonSettingFilePath) == false)
{
this.CommonSettingWrite();
return(false);
}
//XmlSerializerオブジェクトの作成
System.Xml.Serialization.XmlSerializer serXmlCommonRead = new System.Xml.Serialization.XmlSerializer(typeof(CommonSettings));
//ファイルを開く
System.IO.StreamReader stmCommonReader = new System.IO.StreamReader(strCommonSettingFilePath, Encoding.GetEncoding("shift_jis"));
//XMLファイルから読み込み、逆シリアル化する
clsCommonSettting = (CommonSettings)serXmlCommonRead.Deserialize(stmCommonReader);
//閉じる
stmCommonReader.Close();
return(true);
}
catch (Exception ex)
{
// 原因不明のエラー
MessageBox.Show(ex.ToString(),
Resources.msgError,
MessageBoxButtons.OK,
MessageBoxIcon.Hand);
}
return(false);
}
public static void load()
{
string propertyPath;
try
{
propertyPath = Properties.Settings.Default.Path;
}
catch
{
propertyPath = "";
}
if (String.IsNullOrWhiteSpace(propertyPath))
{
propertyPath = System.Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + saveFolder;
}
//load persistent data
if (System.IO.File.Exists(propertyPath + fileName))
{
try
{
System.IO.StreamReader file = System.IO.File.OpenText(propertyPath + fileName);
Type fileType = data.GetType();
var xmlSerial = new System.Xml.Serialization.XmlSerializer(fileType);
data = xmlSerial.Deserialize(file) as Data;
file.Close();
}
catch { data = null; }
}
if (data == null)
{
data = new Data();
}
data.SettingsPath = propertyPath;
}
/// <summary>
/// Constructs experiment node from given xml xpath navigator to the node.
/// </summary>
/// <param name="reader">The reader with a root to the node.</param>
/// <returns>Experiment Node</returns>
public ExperimentNode NodeFactory(XPathNavigator reader)
{
string id = reader.GetAttribute("id", String.Empty);
SerializedVertexData nodeData = null;
XPathNavigator serializedNodeData = reader.SelectSingleNode("SerializedVertexData");
if (serializedNodeData != null)
{
nodeData = (SerializedVertexData)m_nodeSerializer.Deserialize(serializedNodeData.ReadSubtree());
nodeData.PostProcessReadXml(m_library, m_experimentLocationRoot);
}
else
{
//it may be serialized vertex data with size
serializedNodeData = reader.SelectSingleNode("SerializedVertexDataWithSize");
if (serializedNodeData != null)
{
nodeData = (SerializedVertexDataWithSize)m_nodeSerializerWithSize.Deserialize(serializedNodeData.ReadSubtree());
nodeData.PostProcessReadXml(m_library, m_experimentLocationRoot);
}
}
ExperimentNode vert = null;
if (nodeData != null)
{
vert = NodeGenerator(id, nodeData);
if (nodeData.Metadata != null)
{
if (nodeData.Metadata.HasDeserializationError)
{
vert.SetError(nodeData.Metadata.DeserializationErrorMessage);
}
}
m_vertices[id] = vert;
}
return(vert);
}
public string ReadFromFile()
{
// WriteToFile();
String path = @"C:\Users\1\Documents\Visual Studio 2012\Projects\HelloWorldCsharp\FilmRentalService\bin\Debug\database2.xml";
List <Rental> nArray = new List <Rental>();
System.Xml.Serialization.XmlSerializer reader =
new System.Xml.Serialization.XmlSerializer(typeof(List <Rental>));
System.IO.StreamReader file = new System.IO.StreamReader(path);
nArray = (List <Rental>)reader.Deserialize(file);
file.Close();
StringBuilder build = new StringBuilder();
string s;
foreach (Rental ren in nArray)
{
build.AppendLine(ren.ToString());
}
s = build.ToString();
return(s);
}
public List <string> Get(string adres)
{
List <string> mes;
try
{
System.Xml.Serialization.XmlSerializer reader = new System.Xml.Serialization.XmlSerializer(typeof(Message <string>));
using (StreamReader file = new StreamReader(adres))
{
Message <string> overview = (Message <string>)reader.Deserialize(file);
mes = overview.list;
}
}
catch (FileNotFoundException)
{
mes = new List <string>();
mes.Add("FileNotFoundException...........Place create file");
}
return(mes);
}
/// <summary>
/// Loads animation collection from given zipfile and entry.
/// </summary>
/// <param name="zipFile"></param>
/// <param name="entry"></param>
/// <returns></returns>
private AnimationCollection LoadAnimationCollectionFrom(ZipFile zipFile, ZipEntry entry)
{
string ResourceName = Path.GetFileNameWithoutExtension(entry.Name).ToLowerInvariant();
var byteBuffer = new byte[zipBufferSize];
Stream zipStream = zipFile.GetInputStream(entry);
//Will throw exception is missing or wrong password. Handle this.
System.Xml.Serialization.XmlSerializer serializer =
new System.Xml.Serialization.XmlSerializer(typeof(AnimationCollection));
var animationCollection = (AnimationCollection)serializer.Deserialize(zipStream);
zipStream.Close();
zipStream.Dispose();
return(animationCollection);
}
/// <summary>
/// Returns the collection created with SaveAsXml.
/// </summary>
/// <param name="path">The filename including the folder where the Xml file is located.</param>
/// <returns>The content of the Xml file or an empty colletion</returns>
/// <remarks>Best practice: Never return null!</remarks>
public T ReadXml(string path)
{
T result = default(T);
try
{
using (var reader = new System.IO.StreamReader(path))
{
var serializer = new System.Xml.Serialization.XmlSerializer(typeof(T));
result = (T)serializer.Deserialize(reader);
}
}
catch (System.Exception ex)
{
result = new T();
this.OnErrorOccurred(new ErrorOccurredEventArgs(ex));
}
return(result);
}
/// <summary>
/// 从某一XML文件反序列化到某一类型
/// </summary>
/// <param name="filePath">待反序列化的XML文件名称</param>
/// <param name="type">反序列化出的</param>
/// <returns></returns>
public static T DeserializeFromXml <T>(string filePath)
{
try
{
if (!System.IO.File.Exists(filePath))
{
throw new ArgumentNullException(filePath + " not Exists");
}
using (System.IO.StreamReader reader = new System.IO.StreamReader(filePath))
{
System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(typeof(T));
T ret = (T)xs.Deserialize(reader);
return(ret);
}
}
catch (Exception ex)
{
return(default(T));
}
}
/// <summary>
/// LoadListFromXml
/// Load a list from a Xml file
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
static public System.Collections.Generic.List <T> LoadListFromXml <T>(string file)
{
System.Collections.Generic.List <T> list = null;
try
{
System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(typeof(System.Collections.Generic.List <T>));
//XmlSerializer xs = XmlSerializer.FromTypes(new[] { typeof(List<T>) })[0];
using (System.IO.StreamReader rd = new System.IO.StreamReader(file))
{
list = xs.Deserialize(rd) as System.Collections.Generic.List <T>;
}
}
catch (System.Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.ToString());
list = new System.Collections.Generic.List <T>();
}
return(list);
}
public static WorkOrderParsed LoadXMLFromFile(string Source)
{
System.IO.TextReader reader = null;
WorkOrderParsed wop = new WorkOrderParsed();
try
{
reader = new System.IO.StreamReader(Source);
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(WorkOrderParsed));
wop = (WorkOrderParsed)serializer.Deserialize(reader);
}
catch { }
finally
{
if (reader != null)
{
reader.Close();
}
}
return(wop);
}
public bool GetFilmByName(string filmName)
{
// WriteToFile();
String path = @"C:\Users\1\Documents\Visual Studio 2012\Projects\HelloWorldCsharp\FilmRentalService\bin\Debug\database2.xml";
nArray = new List <Rental>();
System.Xml.Serialization.XmlSerializer reader =
new System.Xml.Serialization.XmlSerializer(typeof(List <Rental>));
System.IO.StreamReader file = new System.IO.StreamReader(path);
nArray = (List <Rental>)reader.Deserialize(file);
file.Close();
nArray = DeleteFromList(nArray, deleter);
foreach (Rental ren in nArray)
{
if (ren.film.Name.IndexOf(filmName, StringComparison.OrdinalIgnoreCase) >= 0) //case insensitive
{
return(true);
}
}
return(false);
}
public string EncryptString(string input, string PubKey)
{
//get a stream from the string
var sr = new StringReader(PubKey);
//we need a deserializer
var xs = new System.Xml.Serialization.XmlSerializer(typeof(RSAParameters));
//get the object back from the stream
RSACryptoServiceProvider csp = new RSACryptoServiceProvider();
csp.ImportParameters((RSAParameters)xs.Deserialize(sr));
byte[] bytesPlainTextData = Encoding.ASCII.GetBytes(input);
//apply pkcs#1.5 padding and encrypt our data
var bytesCipherText = csp.Encrypt(bytesPlainTextData, false);
//we might want a string representation of our cypher text... base64 will do
string encryptedText = Convert.ToBase64String(bytesCipherText);
return(encryptedText);
}
public static ControlColors LoadXMLFromFile(string Source)
{
System.IO.TextReader reader = null;
ControlColors wop = new ControlColors();
try
{
reader = new System.IO.StreamReader(Source);
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(ControlColors));
wop = (ControlColors)serializer.Deserialize(reader);
}
catch { }
finally
{
if (reader != null)
{
reader.Close();
}
}
return(wop);
}
public Settings LoadSettings()
{
var result = new Settings();
try
{
var folderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), SettingsPath);
var filePath = Path.Combine(folderPath, SettingsFileName);
System.Xml.Serialization.XmlSerializer reader = new System.Xml.Serialization.XmlSerializer(typeof(Settings));
var file = new StreamReader(filePath);
var settings = (Settings)reader.Deserialize(file);
result = settings;
file.Close();
}
catch (Exception e)
{
Debug.Log(e.Message);
//Failed
}
return(result);
}
/// <summary>
/// Deserializes the file located at path.
/// </summary>
public static T Deserialize <T>(string path)
{
try
{
if (!path.EndsWith(".xml"))
{
path += ".xml";
}
var serializer = new System.Xml.Serialization.XmlSerializer(typeof(T));
FileStream stream = new FileStream(path, FileMode.Open);
T obj = (T)serializer.Deserialize(stream);
stream.Close();
return(obj);
}
catch (Exception e)
{
Debug.LogError(e.Message + e.StackTrace);
return(default(T));
}
}
protected U postXml <T, U>(string resource, T data, PreProcessString preprocessor = null)
{
var c = createRestClient();
var req = createRestRequest(resource, null);
req.RequestFormat = DataFormat.Xml;
req.XmlSerializer = new RestXmlSerializer <T>();
req.AddXmlBody(data);
var response = c.Post(req);
throwWhenErrResponse(response, resource);
string processedContent = preprocessor != null?preprocessor(response.Content) : response.Content;
using (MemoryStream reader = new MemoryStream(Encoding.UTF8.GetBytes(processedContent)))
{
System.Xml.Serialization.XmlSerializer respSer = new System.Xml.Serialization.XmlSerializer(typeof(U));
return((U)respSer.Deserialize(reader));
}
}
//UIと他の実装の分離化が出来ていないための暫定的な実装です
String getTweetText()
{
//設定を読み出す
Core.ApplicationSetting.SettingClass set;
if (System.IO.File.Exists(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location) + @"\setting.xml"))
{
//XmlSerializerオブジェクトを作成
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(Core.ApplicationSetting.SettingClass));
//読み込むファイルを開く
System.IO.FileStream fs = new System.IO.FileStream(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location) + @"\setting.xml", System.IO.FileMode.Open);
//XMLファイルから読み込み、逆シリアル化する
set = (Core.ApplicationSetting.SettingClass)serializer.Deserialize(fs);
//ファイルを閉じる
fs.Close();
}
else
{
set = new Core.ApplicationSetting.SettingClass();
}
return(set.TweetText);
}
/// ----------------------------------------------------------------------------------------------------
/// <summary>
/// Deserializes the saved virtual-key.
/// </summary>
/// ----------------------------------------------------------------------------------------------------
/// <returns>
/// The virtual-key.
/// </returns>
/// ----------------------------------------------------------------------------------------------------
public static VirtualKeys Deserialize()
{
string assemblyPath = Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location);
string assemblyName = System.Reflection.Assembly.GetExecutingAssembly().GetName().Name;
string xmlPath = Path.Combine(assemblyPath, "Plugins", "WalkingBreak", "VirtualKey.xml");
FileInfo file = new FileInfo(xmlPath);
if (file.Exists)
{
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(VirtualKeys));
try {
using (FileStream sr = file.Open(FileMode.Open, FileAccess.Read, FileShare.Read)) {
return((VirtualKeys)serializer.Deserialize(sr));
}
} catch (Exception ex) {
}
}
return(VirtualKeys.MouseButtonMiddle);
}
public static object ParseSoapResponse(string response)
{
XmlDocument responseDoc = new XmlDocument();
responseDoc.LoadXml(response);
if (responseDoc.GetElementsByTagName("freightRate:FreightRateResponse") != null && responseDoc.GetElementsByTagName("freightRate:FreightRateResponse").Count > 0)
{
XmlNode node = responseDoc.GetElementsByTagName("freightRate:FreightRateResponse").Item(0);
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(FreightRateResponse));
FreightRateResponse freightRateResponse = (FreightRateResponse)serializer.Deserialize(new StringReader(node.OuterXml.ToString()));
return(freightRateResponse);
}
else
{
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(Envelope));
Envelope errorResponse = (Envelope)serializer.Deserialize(new StringReader(responseDoc.OuterXml));
return(errorResponse);
}
}