/// <summary> /// 释放对象占用的所有资源。 /// </summary> public virtual void Dispose() { _wheres?.Clear(); _wheres = null; _dataContext = null; _addCommandParameter = null; _dialect = null; _layerLeft = null; }
static StackObject *Clear_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj) { ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 1); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); System.Collections.Generic.Dictionary <System.Int32, FairyGUI.GButton> instance_of_this_method = (System.Collections.Generic.Dictionary <System.Int32, FairyGUI.GButton>) typeof(System.Collections.Generic.Dictionary <System.Int32, FairyGUI.GButton>).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags) 0); __intp.Free(ptr_of_this_method); instance_of_this_method.Clear(); return(__ret); }
static StackObject *Clear_1(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj) { ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 1); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); System.Collections.Generic.Dictionary <System.Type, ILRuntime.Runtime.Intepreter.ILTypeInstance> instance_of_this_method = (System.Collections.Generic.Dictionary <System.Type, ILRuntime.Runtime.Intepreter.ILTypeInstance>) typeof(System.Collections.Generic.Dictionary <System.Type, ILRuntime.Runtime.Intepreter.ILTypeInstance>).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); instance_of_this_method.Clear(); return(__ret); }
private void removeDomains(object sender, bool forced = false) { try { // If we start getting a lot of memory pressure we should force an unload of AppDomains MEMORYSTATUSEX msEX = new MEMORYSTATUSEX(); if (GlobalMemoryStatusEx(msEX)) { forced = msEX.dwMemoryLoad > 90 ? true : false; } if (sender != null) { ((System.Timers.Timer)sender).Stop(); } // We should be a friendly here and not agressively bog the system down unless specific criteria are met // We can force the collection if we've hit our time limit, or we have another specified reason (forced) if (domainsToDie.Count > 0 && (activeAppDomains.Count == 0 || (DateTime.Now - lastAppDomainCleanup) >= maxAppDomainCleanup) || forced) { lock (objToDie) { System.Collections.Generic.List <string> remove = new System.Collections.Generic.List <string>(); foreach (var item in domainsToDie) { try { remove.Add(item.Key); AppDomain.Unload(item.Value); } catch (Exception) { /* Do Nothing */ } } // The idea here is we can only get a few exceptions; // and these exceptions are related to the domain being dead. domainsToDie.Clear(); lastAppDomainCleanup = DateTime.Now; } } } finally { if (sender != null) { ((System.Timers.Timer)sender).Start(); } } }
public override void Silence() { base.Silence(); #if ENABLE_IL2CPP && (UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN) foreach (System.Collections.Generic.KeyValuePair <string, Common.Util.CTProcess> kvp in processCreators) { if (kvp.Value.isBusy) { kvp.Value.Kill(); } } processCreators.Clear(); #endif }
public virtual void Silence() { silence = true; #if UNITY_STANDALONE || UNITY_EDITOR foreach (System.Collections.Generic.KeyValuePair <string, System.Diagnostics.Process> kvp in processes) { if (!kvp.Value.HasExited) { kvp.Value.Kill(); } } processes.Clear(); #endif }
/// <summary> /// Clean up any resources being used. /// </summary> /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param> protected override void Dispose(bool disposing) { if (disposing) { if (components != null) { components.Dispose(); } int iCount = __cSources.Count; for (int i = iCount - 1; i >= 0; i--) { Zeghs.Data.SimpleBoundList<Zeghs.Data._ProductInfo> cProducts = __cSources[i]; cProducts.Clear(); //清除分類商品資訊 __cSources.RemoveAt(i); //移除分類商品 } __cComparison.Clear(); } base.Dispose(disposing); }
void NetManager_BatchOperationCompleted(object sender, System.Collections.Generic.Dictionary <string, string> results) { if (results.ContainsKey("login")) { if (results["login"].Contains("errati") == false) { App.IsLogged = true; } else { MessageBox.Show("Impossibile effettuare il login. Controllare i dati inseriti e lo stato della rete."); } } barra.IsIndeterminate = false; results.Clear(); }
//TODO: Move to Core? Dev calls LoadShaders from Core, it analyzes shaders and tells runtime there's shaders to do //So this should be scanning for shaders and sending them to appropriate facility //todo: this side of the renderer should have separate classes for each renderer containing things like that, keep away from plugin since why would it have a xml parser. actually it's about the shadertype type, overrides should be the soluttion public static System.Collections.Generic.Dictionary <System.String, System.Collections.Generic.Dictionary <OpenTK.Graphics.OpenGL.ShaderType, System.String> > GetShaders(System.Xml.XmlDocument definitionFile) { if (definitionFile.GetElementsByTagName("shaderPackage").Count.Equals(0)) { throw new System.Exception("Invalid shader definition file."); } System.Collections.Generic.Dictionary <OpenTK.Graphics.OpenGL.ShaderType, System.String> shaderGroup = new System.Collections.Generic.Dictionary <OpenTK.Graphics.OpenGL.ShaderType, System.String>(7); System.Collections.Generic.Dictionary <System.String, System.Collections.Generic.Dictionary <OpenTK.Graphics.OpenGL.ShaderType, System.String> > shaderPackage = new System.Collections.Generic.Dictionary <System.String, System.Collections.Generic.Dictionary <OpenTK.Graphics.OpenGL.ShaderType, System.String> >(); System.Xml.XmlNodeList groups = definitionFile.GetElementsByTagName("shaderGroup"); foreach (System.Xml.XmlNode group in groups) { System.String namen = group.Attributes["name"].Value; foreach (System.Xml.XmlNode shader in group) { System.String type = shader.Attributes["type"].Value; OpenTK.Graphics.OpenGL.ShaderType shaderType = OpenTK.Graphics.OpenGL.ShaderType.VertexShader; //init to keep vs silent switch (type) { case "vertex": shaderType = OpenTK.Graphics.OpenGL.ShaderType.VertexShader; break; case "fragment": shaderType = OpenTK.Graphics.OpenGL.ShaderType.FragmentShader; break; case "geometry": shaderType = OpenTK.Graphics.OpenGL.ShaderType.GeometryShader; break; case "compute": shaderType = OpenTK.Graphics.OpenGL.ShaderType.ComputeShader; break; case "tessControl": shaderType = OpenTK.Graphics.OpenGL.ShaderType.TessControlShader; break; case "tessEval": shaderType = OpenTK.Graphics.OpenGL.ShaderType.TessEvaluationShader; break; default: throw new System.Exception("Invalid shader type."); } switch (shader.Name) { case "shaderCode": shaderGroup.Add(shaderType, shader.InnerText); break; case "shaderFile": shaderGroup.Add(shaderType, System.IO.File.ReadAllText("Shaders\\" + shader.InnerText)); break; default: throw new System.Exception("Invalid shader source designator."); } } shaderPackage.Add(namen, shaderGroup); shaderGroup.Clear(); } return(shaderPackage); }
/// <summary> /// 操作数据 /// </summary> /// <param name="parser">参数解析</param> internal override void OperationEnd(ref OperationParameter.NodeParser parser) { switch (parser.OperationType) { case OperationParameter.OperationType.Remove: remove(ref parser); return; case OperationParameter.OperationType.Clear: if (dictionary.Count != 0) { dictionary.Clear(); parser.IsOperation = true; } parser.ReturnParameter.ReturnParameterSet(true); return; } parser.ReturnParameter.ReturnType = ReturnType.OperationTypeError; }
private void ClearPools() { // Safe copy of the current pools. var innerPools = _pools.Values.Cast <ObjectPool <TValue> >().ToArray(); // Clear the main pool. lock (_pools) { _pools.Clear(); } // Then clear each pool, taking it from the safe copy. foreach (var innerPool in innerPools) { innerPool.Clear(); } }
/// <summary> /// Clean up any resources being used. /// </summary> /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param> protected override void Dispose(bool disposing) { if (disposing) { __cAllData.Clear(); __cBasicData.Clear(); __cCustomData.Clear(); __cComparison.Clear(); __cDataSources.Clear(); if (components != null) { components.Dispose(); } } base.Dispose(disposing); }
/// <summary> /// 排序并返回列表。 /// </summary> public System.Collections.Generic.List <DatabaseSchemaHandler> Sort() { System.Collections.Generic.List <DatabaseSchemaHandler> list = new System.Collections.Generic.List <DatabaseSchemaHandler>(); //foreach(AssemblyRef System.Collections.Generic.Dictionary <string, SortEntry> refOrders = new System.Collections.Generic.Dictionary <string, SortEntry>(); System.Collections.Generic.List <AssemblyRef> all = LinqHelper.ToList(_refs.Values); SortAction action = null; action = (p1, p2) => { foreach (string p11 in p1.refs) { AssemblyRef p12; if (_refs.TryGetValue(p11, out p12)) { if (all.Remove(p12)) { action(p12, p2 * 1000); } } } SortEntry p10 = new SortEntry() { item = p1, order = p2 * (refOrders.Count + 1) }; refOrders.Add(p1.fullName, p10); return(p10); }; while (all.Count > 0) { AssemblyRef item = all[0]; all.RemoveAt(0); action(item, -1); } SortFunc classOrderGetter = (p1) => p1.Attribute.Order + GetClassRef(p1.Attribute.TableName, p1.Attribute.References); foreach (SortEntry p1 in LinqHelper.OrderByDescending(refOrders.Values, p => p.order)) { list.AddRange(p1.item.SortList(classOrderGetter)); } refOrders.Clear(); refOrders = null; all = null; return(list); }
private void RefreshList() { var parser = new Cards.XMLParser(Config.DataDirectory); List <Cards.Card> list = parser.GetCards(); cards.Clear(); foreach (Cards.Card c in list) { try { cards.Add(c.Name.ToLower(), c); } catch (ArgumentException) { Console.Error.WriteLine("Multiple cards have the name \"{0}\".", c.Name); } } }
internal void Clear() { trapStartIndex = 0; rootObject = null; if (underlyingList != null) { underlyingList.Clear(); } if (stringKeys != null) { stringKeys.Clear(); } if (objectKeys != null) { objectKeys.Clear(); } }
public virtual void Close() /* throws Net.Vpc.Upa.Exceptions.UPAException */ { log.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 60, Net.Vpc.Upa.Impl.FwkConvertUtils.LogMessageExceptionFormatter("PersistenceGroup {0} Closing", null, GetName())); lock (sessions) { foreach (Net.Vpc.Upa.Session next in sessions) { next.Close(); } sessions.Clear(); } lock (persistenceUnits) { foreach (Net.Vpc.Upa.PersistenceUnit persistenceUnit in (persistenceUnits).Values) { persistenceUnit.Close(); } persistenceUnits.Clear(); } closed = true; log.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 60, Net.Vpc.Upa.Impl.FwkConvertUtils.LogMessageExceptionFormatter("PersistenceGroup {0} Closed", null, GetName())); }
static int _m_Clear(RealStatePtr L) { ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); System.Collections.Generic.Dictionary <ulong, xc.GoodsEquip> __cl_gen_to_be_invoked = (System.Collections.Generic.Dictionary <ulong, xc.GoodsEquip>)translator.FastGetCSObj(L, 1); try { { __cl_gen_to_be_invoked.Clear( ); return(0); } } catch (System.Exception __gen_e) { return(LuaAPI.luaL_error(L, "c# exception:" + __gen_e)); } }
static int _m_Clear(RealStatePtr L) { try { ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); System.Collections.Generic.Dictionary <string, UnityEngine.GameObject> gen_to_be_invoked = (System.Collections.Generic.Dictionary <string, UnityEngine.GameObject>)translator.FastGetCSObj(L, 1); { gen_to_be_invoked.Clear( ); return(0); } } catch (System.Exception gen_e) { return(LuaAPI.luaL_error(L, "c# exception:" + gen_e)); } }
public void Clear() { // Remove all paths from the render so they are not rendered any more. // We don't assume that we have full ownership of the render so we only remove the paths that we own // instead of clearing it. foreach (var path in bezierPaths.Values) { render.Children.Remove(path); } foreach (var path in selectionPaths.Values) { render.Children.Remove(path); } foreach (var path in livePaths.Values) { render.Children.Remove(path); } // Clear dictionaries bezierPaths.Clear(); selectionPaths.Clear(); livePaths.Clear(); liveStrokes.Clear(); }
private void InitializeLineTypeToPenDictionnary() { _ltToPen.Clear(); _ltToPen.Add(LT.LT_CUT, new Pen(System.Drawing.ColorTranslator.FromWin32(255), 1.0f)); _ltToPen.Add(LT.LT_PERFOCREASING, new Pen(System.Drawing.ColorTranslator.FromWin32(16711680), 1.0f)); float[] dashValuesPerfoCreasing = { 14.0f, 3.0f }; _ltToPen[LT.LT_PERFOCREASING].DashPattern = dashValuesPerfoCreasing; _ltToPen.Add(LT.LT_CONSTRUCTION, new Pen(System.Drawing.ColorTranslator.FromWin32(7798903), 1.0f)); _ltToPen.Add(LT.LT_PERFO, new Pen(System.Drawing.ColorTranslator.FromWin32(255), 1.0f)); float[] dashValuesPerfo = { 14.0f, 3.0f }; _ltToPen[LT.LT_PERFO].DashPattern = dashValuesPerfo; _ltToPen.Add(LT.LT_HALFCUT, new Pen(System.Drawing.ColorTranslator.FromWin32(16776960), 1.0f)); _ltToPen.Add(LT.LT_CREASING, new Pen(System.Drawing.ColorTranslator.FromWin32(16711680), 1.0f)); _ltToPen.Add(LT.LT_AXIS, new Pen(System.Drawing.ColorTranslator.FromWin32(16711680), 1.0f)); float[] dashValuesAxis = { 3.0f, 4.0f, 10.0f, 4.0f }; _ltToPen[LT.LT_AXIS].DashPattern = dashValuesAxis; _ltToPen.Add(LT.LT_COTATION, new Pen(System.Drawing.Color.FromArgb(0, 140, 0), 1.0f)); _ltToPen.Add(LT.LT_GRID, new Pen(System.Drawing.ColorTranslator.FromWin32(8388608), 1.0f)); // ** // (1) : spen="0,0,12,2,255,Coupant"; // (2) : spen="1,0,14,3,16711680,Perfo. Rainant"; // (3) : spen="0,1,5,6,7798903,Construction."; // (4) : spen="1,0,4,1,255,Perfo"; // (5) : spen="0,0,11,5,16776960,Mi-chair"; // (6) : spen="0,0,14,3,16711680,Rainant"; // (7) : spen="3,0,9,3,16711680,Axe"; // (8) : spen="0,0,2,4,8453888,Cotation"; // (9) : spen="0,0,7,0,8421504,Origine"; //(10) : spen="0,0,1,0,8388608,Grille"; //(11) : spen="0,0,10,0,16742777,Ponts"; //default: spen="0,0,10,0,33023,Defaut"; // ** }
private void ObtenerItemsMenu() { string s1 = GetSecurityConnectionString(); System.Data.SqlClient.SqlConnection sqlConnection = new System.Data.SqlClient.SqlConnection(s1); Menues_ = new System.Collections.Generic.Dictionary<string, IntelliTrack.Client.Application.Menues.MenuItem>(); try { sqlConnection.Open(); string s2 = "select * from sf_menu(NULL, " + NroSistema + ", '" + UserName + "') ORDER BY MEN_POSICION"; System.Data.SqlClient.SqlDataAdapter sqlDataAdapter = new System.Data.SqlClient.SqlDataAdapter(s2, sqlConnection); System.Data.DataSet dataSet = new System.Data.DataSet(); sqlDataAdapter.Fill(dataSet); System.Collections.Generic.Dictionary<string, IntelliTrack.Client.Application.Menues.MenuItem> dictionary = new System.Collections.Generic.Dictionary<string, IntelliTrack.Client.Application.Menues.MenuItem>(); foreach (System.Data.DataRow dataRow in dataSet.Tables[0].Rows) { IntelliTrack.Client.Application.Menues.MenuItem menuItem = new IntelliTrack.Client.Application.Menues.MenuItem(dataRow); dictionary[dataRow["MEN_NUMERO"].ToString()] = menuItem; } Menues_ = dictionary; } catch (System.Data.SqlClient.SqlException e) { System.Windows.Forms.MessageBox.Show("Error de conexion a la base de datos.", "Error", System.Windows.Forms.MessageBoxButtons.OK); IntelliTrack.Client.Application.Logging.logError.Error("Error al intentar acceder a la base de datos de seguridad", e); } catch (System.Exception) { Menues_.Clear(); } finally { sqlConnection.Close(); } }
public void WriteImage() { // http://www.808.dk/?code-aspnet-inline // http://www.dotnetperls.com/response-writefile System.Collections.Generic.Dictionary<string, string> dictImages = new System.Collections.Generic.Dictionary<string, string>(System.StringComparer.OrdinalIgnoreCase); if (Session["dictionary"] != null) { dictImages = (System.Collections.Generic.Dictionary<string, string>)Session["dictionary"]; } else { // Not necessary, different but similar... if (System.Environment.OSVersion.Platform == System.PlatformID.Unix) { // mono implementation incorrect... dictImages.Add("file", "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"); dictImages.Add("dir", "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"); dictImages.Add("doc", "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"); dictImages.Add("xls", "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"); dictImages.Add("txt", "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"); dictImages.Add("pdf", "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"); dictImages.Add("jpg", "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"); dictImages.Add("gif", dictImages["jpg"]); dictImages.Add("png", dictImages["jpg"]); dictImages.Add("avi", "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"); dictImages.Add("mpg", dictImages["avi"]); dictImages.Add("mpeg", dictImages["avi"]); dictImages.Add("mp3", dictImages["avi"]); dictImages.Add("rar", "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"); dictImages.Add("zip", dictImages["rar"]); dictImages.Add("cs", "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"); // Too slow... AddMimeTypes(dictImages); } else { dictImages.Add("file", "R0lGODlhEAAPAOYAAIyMlu7u9PHx9vDw9fT0+PPz97u7vvf3+vb2+d/f4vn5+/39/vv7/Pr6+/b29+3t7pCRnI6PmZOVn5ibpZWYopqeqJ2hq6KnsaClr9fZ3ff4+t/g4qSqtKmwuqeuuM3P0vHz9tze4be6vuzv8+vu8urt8eXo7Kuzva61vquyu9/k6uXp7uTo7cvU3dHZ4dDY4Nfe5d3j6dzi6Nvh5+Po7eLn7OHm69HV2ejs8Ofr7+7x9OHk597h5PT2+PP19/Hz9evt7+Lk5t3f4fr7/Pn6+/b3+PX299Tc49rh5+ru8fDz9ff5+vb4+fP19vz9/f////7+/vv7+/Pz8+/v7+zs7Orq6ubm5uHh4d7e3sDAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAFkALAAAAAAQAA8AAAevgFmCJ4SFhDuCiYIdUI1QDQ9NKCGKgh4LjQsOG0smKRmVHAxPUAtGQktLPxxTihcKjU5FQR8iBhdXihgHC05DTEA8NwkYWIoWCENEGj1KJCsIFsaJFQRMPT5KIzk2BBXTghMFIEo6JDk1MQUT4FkUAiVJOCs2MTACFO0SAyw0NiozYLgYIKEdhAAyZiCBceRFiwAQ2kUIQLFixQjtAGjcyBFAuyhSqFgZSXJklSyBAAA7"); dictImages.Add("dir", "R0lGODlhEAAOAOYAAP79uv//4/j43f//5f7+5v7+6f//7f//7//8qf/9vf/9wf/+xP/9yf793P/+4f32hP/6iv/6pP/9zP/4kf/4nP/4n/373//1jf/2nP32tvnodfzuff/xhv/3uP/revftrvz32v/ocf/odP/rhPnz0/z44+DAPOHAPe/gnPXrvv3zyM6hAMicAMeaANStJdu4PNy7RODDWN7EaOLIauLIa//10ffuzcudAMiaAMSWAMOVAMGTAL2PALqMAMilLtayPNe2TNW0TNKxTNm7V9e5V82vU9zEd+7jvurfvPXryfbu072NALiKALaIALOEALKDALGCAK+AAMinRMalRMOiRNCuTM6sTMuqTMmnTLyfUdm8ZtW9et3Kl+XUoa19AKp6AK6EG7GHIr2YNr+cQ7iXQ8akTMSjTb6jXs2waMOqbNjEkNDDpM2xctfQwPz8/Pv7+/r6+vX19fHx8ezs7Ovr6+jo6Ofn5+bm5uHh4eDg4N/f397e3t3d3cDAwAAAAAAAACH5BAEAAH0ALAAAAAAQAA4AAAe4gEkzMkNERl19iYqKMSkGjwZbRVJTVGhqijACEJwQEpCPWXKJOBYPp6ioFjh2bn06IBuys7MgOnpwfTwkGiY/QEFCVVZXWGVmYl9MNic0BwHQ0QMOBUhgT0cuJQoJ3d4LAARja15aKAwI6QgRFRQYGVxke1AvDRMXHB4iIfwjSmFt6iz50KGGwYMGVbBJgyeODxYrbrTIsYNHjyZOopzhM8fVHT17QooUmYdOrj5v4KhcyRKOqz6BAAA7"); dictImages.Add("doc", "R0lGODlhEAAQAPcAAAEyeCg+bQgviwU2ggg8iAZCmwlLsiFMmjpamDJbtipitzhhrjppuE1qp0BmtERquVVtpF11q2d+s0JuxEl0zFJ3ylV7zl99w1h+0XeKnG6Ov3KQv3KRv3aTvXqVu3uVvH6XulWAyFmBxliCxV2ExF6ExGCBzWGIw2KJw2WKwmeLwWmMwWyOwGeK1XeR1XyX2P8A/4KavIWdvoOc2oCe5oigwIuiwoyiwouk3ZGnxpesyZCu1p2xzYml6ZOr5qO20am71K260K+836q+8a/A2LPD2rfI9MnS4tbc6tLi+tTj+tbk+tfl+9zi9Nnm+9vn+9zo+97p++Dq/OHs/OPt/OXu/Obv/Ojw/erx/evy/e3z/e/0/fDy+vD2/vL3/vT4/vX5/vf6/vn7/////wCpEQAAABLs7NS5srGlQNcVPRQCgBQCQBLtDNdNrxQCgGQCeNdN4xQCgBLtFAAAAJEFyCNr8BLt4JEFURQHqJEFbRLuOAAAABLtPAAAAJEFyFiHuBLuCJEFURQHSBLtWAAAAJEFyFiHuBLuJJEFURQHSJEFbRLuaAAABAAAAOaERAAAAgAABAAAMAAAACNr+NSLsf3QAAAAMAAABBQAABLrmJD7bAAAIAAAAFiHwBLuOAAAAAAAIADwqgAAIAAAAAAAAJDnvJDVhhLuCJD7bJD7cZDVhpDnvBQAABLt5JDnyBLujJDuGJD7eAH//wAABBLtaAAAABLujJDuGJEFcP///5EFbZEJvBQAAAAAAFiHwBLuSJEJkliHwAAAABLunN3tDt3tIGKmyAABxGKm1AAAAAAAAAAAAAAAAAAAABLuaBLu7BS3YBS3YBLuoOb8I8OlLsYaoBLu2MLCzQAABMLC4xS04BS3YAAAAxSwbsXS4BSwABLu1BLupP///xLvQMNclMEgcP///8LC40SV1RS3YGMboGMboEUEtRQAABS04IoASAAAAAAAAOqG1OqG1OqG1OqG1AAC8BLvJN1sdBLvLIoASIoASObgowAACeaCsAAABCH5BAEAADAALAAAAAAQABAAAAjhAGEILALkBw8dOWzIAAFCoEMYRMSEAfPFS5ctIMY0hOHDRw8aL1pgqDBBgZaMGjmOWclypYEsKDX2GDLDBBITTSDgMICFoU8aTWZcaPKgSYMMBq5YqUJlCggXY1w8EHIAB4IjBZY2lQKixRgJDyIMSBBgTIEqO3ZIieLBwhgICIwMGBBkDIGtUaB0oDBGwAIuAxysHDAlLZQnGxi0bAlg7WEnLBQYmFygMoEBAKKkdcJEhcMbWqc4fsJ5CQqHNZimXZ12iZISDmXgfczEdRIRDmN8+NCBg4YVKU6QGBEiREAAADs="); dictImages.Add("xls", "R0lGODlhEAAQAPcAADVJGjRNGTVNGDRSFzRTFzRYFTReEzReFDVeGjNpDzNtDjRtDjRjETRkEjZjGztoHjpvHjNwDTlwHjp3GTx3Hz57HjJoKDtxIjp9Jz99IWB+XEKAJUaELEeFLUKJNUeIO02MNk+OOUiSP1OTQFKXSFiYR1qaSVieUl6YVV+hU1uiWHCbbWGiVGGgWGWnW2eqX2SoYGmtYmqsZW2wZ3SlcG6Ov3KQv3KRv3aTvXqVu3uVvH6XulWAyFmBxliCxV2ExF6ExGGIw2KJw2WKwmeLwWmMwWyOwP8A/4KavIWdvoephZC9i5ywm6Gzn4igwIuiwoyiwpGnxpesyZCu1p2xzaO20am71JPCjpPEjZbEkZrGlq/A2LPD2sDRwMzay8/dz9bi1t/p39Li+tTj+tbk+tfl+9nm+9vn+9zo+97p++Xs5eDq/OHs/OPt/OXu/Obv/Ojw/erx/evy/e3z/e/0/fD2/vL3/vT4/vX5/vf6/vn7/////xLtPAAAAJEFyCLVGBLuCJEFURQHSBLtWAAAAJEFyCLVGBLuJJEFURQHSJEFbRLuaAAABAAAAOaERAAAAgAABAAAMAAAAFeQiNSLsf3QAAAAMAAABBQAABLrmJD7bAAAIAAAACLVIBLuOAAAAAAAIADwqgAAIAAAAAAAAJDnvJDVhhLuCJD7bJD7cZDVhpDnvBQAABLt5JDnyBLujJDuGJD7eAH//wAABBLtaAAAABLujJDuGJEFcP///5EFbZEJvBQAAAAAACLVIBLuSJEJkiLVIAAAABLunN3tDt3tIGKmyAABwGKm1AAAAAAAAAAAAAAAAAAAABLuaBLu7BSuABSuABLuoOb8I8OlLsYaoBLu2MLCzQAABMLC4xSsQBSuAAAAAxSg2MXS4BSgABLu1BLupP///xLvQMNclMEgcP///8LC40SV1RSuAGMboGMboEUEtRQAABSsQKR+UAAAAAAAAOqG1OqG1OqG1OqG1AACBBLvJN1sdBLvLKR+UKR+UObgowAACeaCsAAABCH5BAEAAEcALAAAAAAQABAAAAjhAI8I5GKlChUpUZ4k2bFDoMMjW/TkwXPHTh06O/Y0PDIjhosUJkaA6LChwpyMGjnuWclyZQQ5KDXOuAKDxB4vKFAwURCHoc8XarDI8ECjxQcwCeC8cdOGzQ4We75oUYHBQpc9DJY2XbOjxJ4lJ7KouLAizAE3U6asSZMjxBIKEBwsEfGgSYGtadDg4NBSiQQEGgawSYvmjI0MLVsKWFvYjJEJERYkaGCgAIEAANKkNVOGiEMoWtkwPsOZjBCHTpimXZ2WzBggDpPgbVzGtZgeDpHo0IHjRo0iQ4L88MGDR0AAADs="); dictImages.Add("xlsx", "R0lGODlhEAAQAHAAACH5BAEAAKsALAAAAAAQABAAhwAAAACPADajAC+gADajCV+/P121NavblMTmtsbjt8PjtsTjtsjlu7vlp3bDU8PktO326ufs5uXq5ebr5ebr5ufs5+7v7+b63YLIXjmtC7PZoN7o3NDYz9nh2dTd08vWyMrVx8fTxcDNvsHLwczlw2/DTIvNa8jgvrnFtu/z6dXhxuXs3v7//+3y6+Lr3+Xs5O7w7fP67/D66v7+/qHYibfQrq/AqPn795u4e3CWUMzcw5vAjqDDmO7067TQr5a7kcniyPz9+////6PZi6rHnbDEpu3z5mSNRFODOqPFl+zz6fv8+J/CmXKlbJ7Fm/39/KTYjKDBj8DRtvH26bXRonynYjdoHpWvi+707PP37s/gysjcxOPw4f39+aTYjpO7fc7cwe/15MnduL7Xr4SldERwN7rNs+Xv3nCkZ2WdYLnZtf7+/J7UiJ7DiNLgwtTkw9flyfL36u705dLeyujt4e7057fRsKDDmtDlzZjOgLbVo9TjwpK6c4u1bs7fv6LEkIq1eLPPptflzqfHn7XQsO746fv79JbNe972zfv/7uHy0NfrxO354LjWp5K8gbbRqbnSr2GaWFmVVM7lxv7++4XIZK7clqXCk77Sr97n0vL25vb57Pb86vL85trsz8XgvPr/7/r88vDw8Pj+8vf36/z+7v7+9f//8/7+9PL15szMzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAipAFcJHEiwoMGDCFcxWIhgIYMGBhnI2GCBIkULjApa2qClgxZVYlSJEIGnoBYUFgRtEFKRooyCIi4JwXFEzA4nMgg50iJkIBEbLI8gIWJByI8mTnoK3FFDBpUqVq5YkKFFywaCOLTQEdOITJkaG9BIUkNwh5hFgkpZ0CqjkZOSAxvt4VNFzJ8+gQTZCPRyIKJSiDwxagSoRg1JkuAeLCWDsScxpRJKnkwwIAA7"); dictImages.Add("txt", "R0lGODlhEAAQAPcAAB6Kcm6Ov3KQv3KRv3aTvXqVu3uVvH6XulWAyFmBxliCxV2ExF6ExGGIw2KJw2WKwmeLwWmMwWyOwP8A/4KavIWdvoigwIuiwoyiwo+lxJGnxpKoxpWryJesyZmtypCu1p2xzaO20am71K/A2LPD2tLi+tTj+tbk+tfl+9nm+9vn+9zo+97p++Dq/OHs/OPt/OXu/Obv/Ojw/erx/evy/e3z/e/0/fD2/vL3/vT4/vX5/vf6/vn7/////xLuYAAAQAAAAAAAABLuqBLuaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBLurJDuGAAAAAAAAgAAAQACEBLuYAACEJEZcAa6SAa6KAAAAAAAAAHskAABHhLsBJDuGBLswNS5TACpEQCpERLs1NS47q0nqACpEQAAABLs7NS5sq0nqNcVPRQCgBQCQBLtDNdNrxQCgCoFBtdN4xQCgBLtFAAAAJEFyCLqgBLt4JEFURQHqJEFbRLuOAAAABLtPAAAAJEFyAcKIBLuCJEFURQHSBLtWAAAAJEFyAcKIBLuJJEFURQHSJEFbRLuaAAABAAAAOaERAAAAgAABAAAMAAAACLqiNSLsf3wAAAAMAAABBQAABLrmJD7bAAAIAAAAAcKKBLuOAAAAAAAIADwqgAAIAAAAAAAAJDnvJDVhhLuCJD7bJD7cZDVhpDnvBQAABLt5JDnyBLujJDuGJD7eAH//wAABBLtaAAAABLujJDuGJEFcP///5EFbZEJvBQAAAAAAAcKKBLuSJEJkgcKKAAAABLunN3tDt3tIGKmyAABsGKm1AAAAAAAAAAAAAAAAAAAABLuaBLu7BR5EBR5EBLuoOb8I8OlLsYaoBLu2MLCzQAABMLC4xR2sBR5EAAAAxRwicXS4BRwABLu1BLupP///xLvQMNclMEgcP///8LC40SV1RR5EGMboGMboEUEtRQAABR2sIPdOAAAAAAAAOqG1OqG1OqG1OqG1AABsBLvJN1sdBLvLIPdOIPdOObgowAACeaCsAAABCH5BAEAABMALAAAAAAQABAAAAipACcIJCEiBIgOGi5UOHBAoMMJI3js0JEDxw0bB3o0nACgo8ePHXto5CiyBwCTKEuKPBCypcmTABgybEkTJowXLljChPnSJM4WOkGCbNGCRQGHHmrQmCEjxk0XRVcQcMhh6YerWD+sUCHA4QamTn+y2JpCgsMMTbNiTYECgkMMYaGOVcH2hAOHFm6qvXrCBAOHFcSSRdG3RAKHFAwYIDAgQIQHDRYoQIAgIAA7"); dictImages.Add("pdf", "R0lGODlhEAAQAPcAAFoAAGMAAHMYGG6Ov3KQv3KRv3aTvXqVu3uVvH6XulWAyFmBxliCxV2ExF6ExGGIw2KJw2WKwmeLwWmMwWyOwIwACJQAAJwhIa0ACLUAAL05OZxCQr1KSr1SWsYAAM4ICM4QENYYGM4pMd45OecIEPcQEPcYGO85OfcpKf8xOc5KSt5KStZja+dKSu9CSu9KSudaWu9SUu9SWudaY+dzc+97e/9zc/8A/4KavIWdvoigwIuiwoyiwo+lxJGnxpKoxpWryJesyZmtypywzJ2xzaO20am71Ky+1q/A2LPD2t6EhN61veeMjO+cnO+trdLi+tTj+tbk+tfl+9nm+9vn+9zo+97p++/W1ufv9+Dq/OHs/OPt/OXu/Obv/Ojw/erx/evy/e3z/e/0/fD2/vL3/vT4/vX5/vf6/vn7/////xQCgBQCQBLtDNdNrxQCgBEGqNdN4xQCgBLtFAAAAJEFyCJ8mBLt4JEFURQHqJEFbRLuOAAAABLtPAAAAJEFyFWi2BLuCJEFURQHSBLtWAAAAJEFyFWi2BLuJJEFURQHSJEFbRLuaAAABAAAAOaERAAAAgAABAAAMAAAACJ8oNSLsf3QAAAAMAAABBQAABLrmJD7bAAAIAAAAFWi4BLuOAAAAAAAIADwqgAAIAAAAAAAAJDnvJDVhhLuCJD7bJD7cZDVhpDnvBQAABLt5JDnyBLujJDuGJD7eAH//wAABBLtaAAAABLujJDuGJEFcP///5EFbZEJvBQAAAAAAFWi4BLuSJEJklWi4AAAABLunN3tDt3tIGKmyAACvGKm1AAAAAAAAAAAAAAAAAAAABLuaBLu7BSjUBSjUBLuoOb8I8OlLsYaoBLu2MLCzQAABMLC4xSo8BSjUAAAAxSgLcXS4BSgABLu1BLupP///xLvQMNclMEgcP///8LC40SV1RSjUGMboGMboEUEtRQAABSo8KR+UAAAAAAAAOqG1OqG1OqG1OqG1AACXBLvJN1sdBLvLKR+UKR+UObgowAACeaCsAAABCH5BAEAADcALAAAAAAQABAAAAjcAG8ITGKkCJEgPnbkSJBAoMMbSNCcMVOGzBgxCdI0fHhkYsWLYTJqvNGBgwYVM2DIgOFCBBiRGm28SIHChIkSJkhg+MKw54kQIEB4+OABQ4YKXrpw2aIlgYUAAARsmLrhwgalTLNsvDFETBgwX1Zg1ZLFygGHQr5+uTKiSVYrVQw4BALWSw0sTJyUrUKFgMMfX7xcaeHEyYoWMZRMoeCwR1IYS8jCXcJCigSHPLrMYCKZ7xQpUSA41EGDRmcqn6NAceAwx1vPoKE8WeAQBwIEBgoMmBDhQQMGChQEBAA7"); dictImages.Add("jpg", "R0lGODlhEAAQAPcAAPuBhP0RI9fU1r24vL25vn+CmKSxzLfF4cPL28bO3srO1oOk4WF4opyuzpWlwpurx6i30qm30ae1zqa0zb3M57G/2Kq3z6m2zcTR6aSvw9Dd9crW7NPe8tXg88PM3OLs/tXe7+Lr/Njh8eHp98/W4wBe9Yibup+vyZemv6e2z6e2zsXW8rLC26e1zK+91Kezx8jU6Nvo/eDr/dzm9uLs/OTt/MvT4ODn897l8dvi7uvy/gxn7Keyw7K9zsTQ4uPu/t7p+dzm9c/Y5t7n9dri7svb8djh7ejw++vw9+fs87jI2+Hu/lem/vH3/lSp/uTx/vP5/snj9+33/qGoqPz+/v3+/lXSYAC1AH3GdS6qHnDIW1OmL+Hp173JqoGaKby9srurRv3slf7dbf7cc/7Xb/7QZ/3SdP7FVd6wUP7LaP6/SP68SeS7cv6vMP62QNycN+KuWOCuW/vt1fueGf6qL/6vN/6xOf65V+C/jP2XEv6eGvmeH/6gI/6iJOCSKM+WR9ScUPjEff6ZG8qELbB/ROG0f/2EAPeAAf6IAuR5BP6JCP6QENKTTdmseuC7kbBhEKlfFa5iGMR0I8d+M45aJr6BRM2VW9ikcNuugNG8pvLk1v37+f17AO1zAKlUBrNiFqBdHplZHr97PcB/Q690Pc6KTcWHT7F9T9CYY9Opg9KujN25l6NJAJJFBK5sMpNnQcqcdKaGbL+fhPfw6qpKALeDWtijebGReOC4mdm2nKuQe+XDqfjy7tm0nedXBa+ZjPjz8OfOwauSh/BvO/55QcY0AN7a2d4dA+kwFdsTBv7+/v///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAMsALAAAAAAQABAAAAj/AJcJXIbDSI6DREDAQKBs4MAgVZRJVNaEwwYbDgUaozJRGZQON46QcLgplaNLmFZpoiLDh5AKHgTuKmVJlzBVqEbBSlIEQgMTy2wxkhOFiZMFXLoQOiWCwgEHuCQ1KvRlRwkGWqxgERVrBYYHkwAF68VmSgE8Wa5sCRQqgYYTg8LEgWOGTJk0YLz8uQOJQAwDptCMEXNmjZs6dIgBGOZpwJIJs3JVeqPGDp0+c5AFSNZKwQ8JAnnV8tOGj6A8vo4VozTjg4qBwFzt0bNIESJDrH49oZHCoaxHiQ5x6kTr1QggIXoPFJCJVKRPoG4hkVJDRwSHQ5T04JHhBQsXF1pYA0AREAA7"); dictImages.Add("gif", dictImages["jpg"]); dictImages.Add("png", dictImages["jpg"]); dictImages.Add("avi", "R0lGODlhEAAQAPcAAEhHSHd2d//+/+/q9+7r9KalqPLx9NrZ3HZ1e4mJjx0dHoeHi+Dg4/n5++np6+jo6tLS1NjY2ZqamxYelholkUBHhIWGjHB2lREwshozpCdDujZPuoOEiIWNqBI7tJWWmdTV2B1NwihTuC9iyDZqzlF60X+Vw/z9/xtbyxZczvb5/h1m0EqA0EZ/z1aP3srd9h502hh24VSc6SuD3oqLjNfY2SGN70ik6cHe9ODn6urv8MTGxnG+AYTVDXiuKaPOX6DEZ+nu4XO3AWWgAU56AYypWoWWaNPcw22pAWacAVyKCTpTCm2bFF+BHHehLEVnAWGNBk9zBXWDV1BhKsbKvZm0VajRMHKKKJG5AUlaBnp9b4ulGoqMgYiIhoKCgLOzseDg325qVf/++dqvAdmvAei7As2oBtCoB8qlB+jAF+jAG6eLE5yDGezHK+fFN4RyIN7AOOTEOuPDO4BuIu3MQ+XIR+rLSuXHSOXHSu3VaO3Wc+7YeIuFa/ry0vz343lxVn16cnh2cMHAvpOOiPjx6evq6eHc2v9zTfV6WfnRxuHLxfvx7v9KG/lHG/hIG/lOIvxNI/dOJP5ZLv5aMexYMvVeOPRjPv9xTP92U/BzU/99Xet2WPKijvWvnu+unvGxofnMwNvLx/r19P////v7+/Ly8uzs7Ojo6Obm5uTk5OLi4uDg4N/f39jY2NbW1tLS0s/Pz87Ozs3NzczMzMfHx7Ozs62traenp56enpycnJqamnl5eWtra2RkZE5OTiEhIRwcHBsbGxMTEwgICAQEBP///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAMUALAAAAAAQABAAAAj/AIsJXMRpE6UtPopQMSCwYTFQlRpBeoSFxxAlRg44TBRpEiZNiKz0EJKEiBQIAkVZkoTpU6gINY78QALlCRdVxTw5utSJEK8dDggMAMIkypQCpDIxOqSIEABeu2gJCOKkyRIvq5QeMuTU169hvR5UuZJFC6wWM27kcBqMGDBYDPLAMcNnFosYNnAQUiDsFqwTfuy4OQNolokUMGToGCSowahRe+6oWWMhFggRKFa4eKFCTB89deSM+SOBVbEOHkKMIFGCDh08ccq8+WBLYKELGTBo2NCmTRoyczjkStUQTIIKFCagQcMmDA1crRwWK/WlC4JAARboqnVKekNTrmTJBnqFapTDgAA7"); dictImages.Add("mpg", dictImages["avi"]); dictImages.Add("mpeg", dictImages["avi"]); dictImages.Add("mp3", dictImages["avi"]); dictImages.Add("rar", "R0lGODlhDwAQAOYAAMjY9gRLsBJPqRZQpydpx7TP9iFbrSNfsChltixquzt6xEmH0VqU2G2h4HSk4HGc05jC9ZCz3jmF1zqA0EOK106P2JC235S335a535i531am9FOa5FOa4l2l61uZ13Cv7ne09IKx3ziZ81yr9mGz/2i3/2Go62as7XK7/26x7ni+/3W38Ha38HKx5nu88XWx5IjD84HA8oTD84vK+ZvP9YnJ963b+bzl+8fs/fT///79mf//r///uf//xPr2k//9pP/4hv/6kPr1kPr1kf/7mvfvgvPkbdm/Ktm/LPn25dm8L/vwvfvzzt61AfbNLNm3KfzUMdm3Mdu5M9q6Nd6+O/3ZR/vdZPzkhfvnl/roodq0Kv7TOP3VOf3aUfzZWPzebfvedPziffrjj/rprfrrs/juytKgB9SjCNWlC8+hDtWmEM+hENKmFNWmFtSnG9WqH9SqH9WqIdWrItiuKOjRh7J9DrR8D7mFKaptDbJ7I6ttDax0HfEZAf///wAAAAAAACH5BAEAAH0ALAAAAAAPABAAAAe8gH2CgzIxLispJyaCdGmOdCY5ODc2NDAsC31pfJxpBJ+gEyMeAWtaT0dISlFSU1R2fSEvAXI6PTw7P0RBQEZ1fRYyAW8+SWVjYmBeW02/GDMBcENMZFhhVlVQzX3P0dPV19nbF9BxQktZV19dXE7bGTUBbEVzbm1qaGdm2xEtAXd59ODZAwrUgw8dAgwStKgECRQqVHRQsHCQiQQIDhwwoLCiRxOLPA7i4KABgwoUJAgQuQFAAQggNIgYEAgAOw=="); dictImages.Add("zip", dictImages["rar"]); // string mimes = FileTypeAndIcon.RegisteredFileType.GetAllMimes(); // System.IO.File.WriteAllText(@"C:\Users\Administrator\Downloads\FileTypeAndIcon\FileTypeAndIcon\FileTypeAndIcon\obj\mim.txt", mimes, System.Text.Encoding.UTF8); FileTypeAndIcon.RegisteredFileType.AddMimes(dictImages); } Session["dictionary"] = (object)dictImages; } bool bNotFound = true; foreach (string x in Request.QueryString.AllKeys) { if (System.StringComparer.OrdinalIgnoreCase.Equals(x, "icon")) { bNotFound = false; break; } } if (bNotFound) return; string strSelectedItem = Request.QueryString["icon"]; string strBase64Content = dictImages["file"]; if (dictImages.ContainsKey(strSelectedItem)) strBase64Content = dictImages[strSelectedItem]; byte[] bt64 = System.Convert.FromBase64String(strBase64Content); string strMIME = GetImageMime(bt64); Response.ContentType = strMIME; Response.OutputStream.Write(bt64, 0, bt64.Length); Response.End(); //Response.OutputStream.Close(); dictImages.Clear(); dictImages = null; }
public void Reset() { table.Clear(); }
public static System.Collections.Generic.Dictionary <string, string> RecursivelyListKeys( string registyBase, Microsoft.Win32.RegistryKey baseKey) { System.Collections.Generic.Dictionary <string, string> ls = new System.Collections.Generic.Dictionary <string, string>(); string[] valueNames = baseKey.GetValueNames(); System.Array.Sort(valueNames, delegate(string s1, string s2) { return(s1.CompareTo(s2)); }); foreach (string valueName in valueNames) { string key = baseKey.Name + @"\" + valueName; key = key.Substring(registyBase.Length + 1); key = key.Replace('\\', ':'); try { Microsoft.Win32.RegistryValueKind rvk = baseKey.GetValueKind(valueName); string type = ToDataType(rvk); object value = baseKey.GetValue(valueName); // https://docs.microsoft.com/en-us/windows/desktop/sysinfo/registry-value-types if (rvk == Microsoft.Win32.RegistryValueKind.String) { string stringValue = System.Convert.ToString(value); ls[key] = stringValue; } else if (rvk == Microsoft.Win32.RegistryValueKind.DWord) { int dwordValue = System.Convert.ToInt32(value); ls[key] = dwordValue.ToString(System.Globalization.CultureInfo.InvariantCulture); } else if (rvk == Microsoft.Win32.RegistryValueKind.QWord) { long qwordValue = System.Convert.ToInt64(value); ls[key] = qwordValue.ToString(System.Globalization.CultureInfo.InvariantCulture); } else if (rvk == Microsoft.Win32.RegistryValueKind.Binary) { byte[] binaryValue = (byte[])value; ls[key] = System.Convert.ToBase64String(binaryValue); } else if (rvk == Microsoft.Win32.RegistryValueKind.MultiString) { string[] multiStringValue = (string[])value; ls[key] = Newtonsoft.Json.JsonConvert.SerializeObject(multiStringValue); } else if (rvk == Microsoft.Win32.RegistryValueKind.ExpandString) { string expString = System.Convert.ToString(value); ls[key] = expString; } else if (rvk == Microsoft.Win32.RegistryValueKind.None) { ls[key] = null; } else // if (rvk == Microsoft.Win32.RegistryValueKind.Unknown) { ls[key] = System.Convert.ToString(value); } } catch (System.Exception ex) { ls[key] = ex.Message; } } // Next valueName string[] subkeys = baseKey.GetSubKeyNames(); // System.Console.WriteLine(subkeys.Length); foreach (string subKey in subkeys) { string newBasePath = baseKey.Name + @"\" + subKey; newBasePath = newBasePath.Substring(registyBase.Length + 1); newBasePath = newBasePath.Replace('\\', ':'); try { Microsoft.Win32.RegistryKey sk = baseKey.OpenSubKey(subKey); // ls.Add(newBasePath); System.Collections.Generic.Dictionary <string, string> lss = RecursivelyListKeys(registyBase, sk); // ls.AddRange(lss); foreach (System.Collections.Generic.KeyValuePair <string, string> kvp in lss) { ls[kvp.Key] = kvp.Value; } lss.Clear(); lss = null; } catch (System.Exception ex) { // ls.Add(newBasePath); ls[newBasePath] = ex.Message; } } // Next subKey return(ls); } // End Function RecursivelyListKeys
public void Clear() { _lookup.Clear(); }
/// <summary> /// Load a game object prefab at the specified path. This is equivalent to Resources.Load, but it will /// also consider DataNode-exported binary assets as well, automatically loading them as if they were /// regular prefabs. /// </summary> static public GameObject LoadPrefab(string path) { if (string.IsNullOrEmpty(path)) { return(null); } if (!Application.isPlaying) { return(Resources.Load(path, typeof(GameObject)) as GameObject); } GameObject prefab = null; if (mPrefabRoot == null) { GameObject go = new GameObject("Prefabs"); Object.DontDestroyOnLoad(go); mPrefabRoot = go.transform; mPrefabs.Clear(); } // Try to get it from cache if (mPrefabs.TryGetValue(path, out prefab)) { return(prefab); } if (prefab == null) { // Load it from resources as a Game Object prefab = Resources.Load(path, typeof(GameObject)) as GameObject; if (prefab == null) { // Load it from resources as a binary asset byte[] bytes = UnityTools.LoadBinary(path); if (bytes != null) { // Parse the DataNode hierarchy DataNode data = DataNode.Read(bytes); if (data != null) { // Instantiate and immediately disable the object prefab = data.Instantiate(); if (prefab != null) { mPrefabs.Add(path, prefab); Object.DontDestroyOnLoad(prefab); prefab.transform.parent = mPrefabRoot; prefab.SetActive(false); return(prefab); } } } } } if (prefab == null) { #if UNITY_EDITOR Debug.LogError("[TNet] Attempting to create a game object that can't be found in the Resources folder: [" + path + "]"); #endif prefab = GetDummyObject(); } mPrefabs.Add(path, prefab); return(prefab); }
public void ClearTable() { tables.Clear(); tablesByName.Clear(); }
public void HyperlinkRelationshipTest() { using (var stream = new System.IO.MemoryStream(TestFileStreams.May_12_04, false)) { using (WordprocessingDocument testDocument = WordprocessingDocument.Open(stream, false)) { OpenXmlValidator validator = new OpenXmlValidator(); var errors = validator.Validate(testDocument); Assert.Equal(0, errors.Count()); var mainPart = testDocument.MainDocumentPart; Assert.Equal(0, mainPart.ExternalRelationships.Count()); Assert.Equal(71, mainPart.HyperlinkRelationships.Count()); var rid15 = mainPart.GetReferenceRelationship("rId15"); Assert.Equal("rId15", rid15.Id); Assert.Equal(new System.Uri("#_THIS_WEEK_IN", System.UriKind.Relative), rid15.Uri); Assert.False(rid15.IsExternal); var rid18 = mainPart.GetReferenceRelationship("rId18"); Assert.Equal("rId18", rid18.Id); Assert.Equal(new System.Uri("http://www.iaswresearch.org/"), rid18.Uri); Assert.True(rid18.IsExternal); } } using (System.IO.Stream stream = new System.IO.MemoryStream()) { using (var testDocument = WordprocessingDocument.Create(stream, WordprocessingDocumentType.Document)) { var mainPart = testDocument.AddMainDocumentPart(); var paragraph = new DocumentFormat.OpenXml.Wordprocessing.Paragraph(new Body()); mainPart.Document = new Document(new Body(paragraph)); mainPart.Document.Save(); var newUri = new System.Uri("#New", System.UriKind.Relative); var ridnew = mainPart.AddHyperlinkRelationship(newUri, false); var newRel = mainPart.PackagePart.GetRelationship(ridnew.Id); Assert.Equal(System.IO.Packaging.TargetMode.Internal, newRel.TargetMode); Assert.Equal(ridnew.Id, newRel.Id); Assert.Equal(newUri, newRel.TargetUri); Assert.Equal(HyperlinkRelationship.RelationshipTypeConst, newRel.RelationshipType); mainPart.DeleteReferenceRelationship(ridnew); Assert.Equal(0, mainPart.HyperlinkRelationships.Count()); newUri = new System.Uri("http://microsoft.com", System.UriKind.Absolute); ridnew = mainPart.AddHyperlinkRelationship(newUri, true, ridnew.Id); newRel = mainPart.PackagePart.GetRelationship(ridnew.Id); Assert.Equal(System.IO.Packaging.TargetMode.External, newRel.TargetMode); Assert.Equal(ridnew.Id, newRel.Id); Assert.Equal(newUri, newRel.TargetUri); Assert.Equal(HyperlinkRelationship.RelationshipTypeConst, newRel.RelationshipType); } // Test the OpenXmlPartContainer.AddSubPartFromOtherPackage(). // The method should import all hyperlink relationships. stream.Seek(0, System.IO.SeekOrigin.Begin); using (var testDocument = WordprocessingDocument.Create(stream, WordprocessingDocumentType.Document)) { using (var sourcestream = new System.IO.MemoryStream(TestFileStreams.May_12_04, false)) { using (WordprocessingDocument sourceDocument = WordprocessingDocument.Open(sourcestream, false)) { var parts = new System.Collections.Generic.Dictionary<OpenXmlPart, bool>(); sourceDocument.MainDocumentPart.FindAllReachableParts(parts); var partCounts = parts.Count; var hyperlinksBefore = sourceDocument.MainDocumentPart.HyperlinkRelationships.ToArray(); var externalRelsBefore = sourceDocument.MainDocumentPart.ExternalRelationships.ToArray(); testDocument.AddPart(sourceDocument.MainDocumentPart); parts.Clear(); testDocument.MainDocumentPart.FindAllReachableParts(parts); // all parts under the main document part should be imported. Assert.Equal(partCounts, parts.Count); var hyperlinksAfter = testDocument.MainDocumentPart.HyperlinkRelationships.ToArray(); var externalRelsAfter = testDocument.MainDocumentPart.ExternalRelationships.ToArray(); // all hyperlink relationships should be imported. Assert.Equal(hyperlinksBefore.Length, hyperlinksAfter.Length); for (int i = 0; i < hyperlinksBefore.Length; i++) { Assert.Equal(hyperlinksBefore[i].Id, hyperlinksAfter[i].Id); Assert.Equal(hyperlinksBefore[i].IsExternal, hyperlinksAfter[i].IsExternal); Assert.Equal(hyperlinksBefore[i].Uri, hyperlinksAfter[i].Uri); } // all external relationships should be improted. Assert.Equal(externalRelsBefore.Length, externalRelsAfter.Length); } } } } }
private void ObtenerItemsMenu() { try { string strConnection = GetSecurityConnectionString(); System.Data.SqlClient.SqlConnection conn = new System.Data.SqlClient.SqlConnection(strConnection); conn.Open(); string cmd = "select * from sf_menu(NULL, " + NroSistema + ", '" + UserName + "')"; System.Data.SqlClient.SqlDataAdapter da = new System.Data.SqlClient.SqlDataAdapter(cmd, conn); System.Data.DataSet ds = new System.Data.DataSet(); da.Fill(ds); System.Collections.Generic.Dictionary<string, string> menues = new System.Collections.Generic.Dictionary<string, string>(); foreach (System.Data.DataRow dr in ds.Tables[0].Rows) { menues[dr["MEN_POSICION"].ToString()] = dr["MEN_ID"].ToString(); } Menues_ = menues; } catch (Exception) { Menues_.Clear(); } }
public void Clear() { m_Dict.Clear(); }
public void HyperlinkRelationshipTest2() { using (var stream = new MemoryStream()) { using (var testDocument = WordprocessingDocument.Create(stream, WordprocessingDocumentType.Document)) { var mainPart = testDocument.AddMainDocumentPart(); var paragraph = new DocumentFormat.OpenXml.Wordprocessing.Paragraph(new Body()); mainPart.Document = new Document(new Body(paragraph)); mainPart.Document.Save(); var newUri = new System.Uri("#New", System.UriKind.Relative); var ridnew = mainPart.AddHyperlinkRelationship(newUri, false); var newRel = mainPart.PackagePart.GetRelationship(ridnew.Id); Assert.Equal(System.IO.Packaging.TargetMode.Internal, newRel.TargetMode); Assert.Equal(ridnew.Id, newRel.Id); Assert.Equal(newUri, newRel.TargetUri); Assert.Equal(HyperlinkRelationship.RelationshipTypeConst, newRel.RelationshipType); mainPart.DeleteReferenceRelationship(ridnew); Assert.Empty(mainPart.HyperlinkRelationships); newUri = new System.Uri("http://microsoft.com", System.UriKind.Absolute); ridnew = mainPart.AddHyperlinkRelationship(newUri, true, ridnew.Id); newRel = mainPart.PackagePart.GetRelationship(ridnew.Id); Assert.Equal(System.IO.Packaging.TargetMode.External, newRel.TargetMode); Assert.Equal(ridnew.Id, newRel.Id); Assert.Equal(newUri, newRel.TargetUri); Assert.Equal(HyperlinkRelationship.RelationshipTypeConst, newRel.RelationshipType); } // Test the OpenXmlPartContainer.AddSubPartFromOtherPackage(). // The method should import all hyperlink relationships. stream.Seek(0, SeekOrigin.Begin); using (var testDocument = WordprocessingDocument.Create(stream, WordprocessingDocumentType.Document)) using (var sourcestream = GetStream(TestFiles.May_12_04)) using (var sourceDocument = WordprocessingDocument.Open(sourcestream, false)) { var parts = new System.Collections.Generic.Dictionary <OpenXmlPart, bool>(); sourceDocument.MainDocumentPart.FindAllReachableParts(parts); var partCounts = parts.Count; var hyperlinksBefore = sourceDocument.MainDocumentPart.HyperlinkRelationships.ToArray(); var externalRelsBefore = sourceDocument.MainDocumentPart.ExternalRelationships.ToArray(); testDocument.AddPart(sourceDocument.MainDocumentPart); parts.Clear(); testDocument.MainDocumentPart.FindAllReachableParts(parts); // all parts under the main document part should be imported. Assert.Equal(partCounts, parts.Count); var hyperlinksAfter = testDocument.MainDocumentPart.HyperlinkRelationships.ToArray(); var externalRelsAfter = testDocument.MainDocumentPart.ExternalRelationships.ToArray(); // all hyperlink relationships should be imported. Assert.Equal(hyperlinksBefore.Length, hyperlinksAfter.Length); for (int i = 0; i < hyperlinksBefore.Length; i++) { Assert.Equal(hyperlinksBefore[i].Id, hyperlinksAfter[i].Id); Assert.Equal(hyperlinksBefore[i].IsExternal, hyperlinksAfter[i].IsExternal); Assert.Equal(hyperlinksBefore[i].Uri, hyperlinksAfter[i].Uri); } // all external relationships should be imported. Assert.Equal(externalRelsBefore.Length, externalRelsAfter.Length); } } }
private void BWorker_DoWork(object sender, DoWorkEventArgs e) { WorkerArguments args = e.Argument as WorkerArguments; if (args == null) { throw new InvalidOperationException("Something went wrong, this is out of design."); } var fileinfo = args.TranslationResource.GetCurrentLanguageFile(); string currentLanguage = args.TranslationResource.SelectedLanguage, currentRegion = args.TranslationResource.SelectedClientRegion, gamedata12 = Path.Combine(args.GameDirectory, "datas", "data12.v"), outputpath = args.OutputPath; // Directly read the game resource and make a copy of the .res file in the memory ??? if (!File.Exists(gamedata12)) { throw new FileNotFoundException("Can not find original data file.", gamedata12); } if (!fileinfo.Exists) { throw new TranslationFileNotFoundException("Can not find translation files.", fileinfo.FullName); } // Get the file password and make it as a pre-list TranslationDescription transDesc; System.Collections.Concurrent.ConcurrentDictionary <string, string> encryptions = new System.Collections.Concurrent.ConcurrentDictionary <string, string>(StringComparer.OrdinalIgnoreCase); // Read our derped translation files using (ZipFile translationzf = ZipFile.Read(fileinfo.FullName)) { // Password file using (Stream entryStream = translationzf["datas.ini"].OpenReader()) using (StreamReader sr = new StreamReader(entryStream)) { Leayal.Ini.IniFile afile = new Leayal.Ini.IniFile(sr); foreach (var keyValue in afile.GetAllValues("Zip Passwords")) { if (!keyValue.Value.IsComment) { encryptions.TryAdd(keyValue.Key, keyValue.Value.Value); } } afile.Close(); } // Translation Description file using (Stream entryStream = translationzf["TranslationPackData.ini"].OpenReader()) using (StreamReader sr = new StreamReader(entryStream)) { Leayal.Ini.IniFile afile = new Leayal.Ini.IniFile(sr); transDesc = new TranslationDescription(afile); afile.Close(); } using (FileStream fs = File.OpenRead(gamedata12)) // Wrap the FileStream in XorStream so we can use ZipFile class directly. using (XorStream xoredStream = new XorStream(fs, LionGameSecretByte)) using (ZipFile zf = ZipFile.Read(xoredStream)) { string[] splittedStr; DataFormatBuilder formatBuilder = new DataFormatBuilder(); zf.CompressionLevel = Ionic.Zlib.CompressionLevel.BestSpeed; if (encryptions.ContainsKey("data12")) { zf.Password = encryptions["data12"]; } System.Collections.Generic.Dictionary <string, Leayal.IO.RecyclableMemoryStream> somethingliawhglaihwg = new System.Collections.Generic.Dictionary <string, Leayal.IO.RecyclableMemoryStream>(StringComparer.OrdinalIgnoreCase); for (int i = 0; i < transDesc.Descriptions.Length; i++) { if (transDesc.Descriptions[i].TargetData.EndsWith("data12.v", StringComparison.OrdinalIgnoreCase)) // Build only for data12.v { formatBuilder.Clear(); if (this.bWorker.CancellationPending) { break; } this.OnBuildProgressChanged(new ProgressBarValueEventArgs(i + 1, transDesc.Descriptions.Length)); TranslationDescription.Description desc = transDesc.Descriptions[i]; this.OnBuildStepChanged(new StringEventArgs(Path.GetFileName(desc.PathTXT))); splittedStr = desc.ResourceFormat.Split(' '); formatBuilder.CountDataType = (DataType)Leayal.NumberHelper.Parse(splittedStr[1]); formatBuilder.IDIndex = Leayal.NumberHelper.Parse(splittedStr[0]); for (int splittedCount = 2; splittedCount < splittedStr.Length; splittedCount++) { if (!string.IsNullOrEmpty(splittedStr[splittedCount])) { formatBuilder.Append(splittedStr[splittedCount]); } } DataFormat readformat = formatBuilder.ToDataFormat(); TranslationDatabase translatedb; using (Stream transText = translationzf[desc.PathTXT].OpenReader()) using (StreamReader sr = new StreamReader(transText)) { translatedb = TranslationDatabase.From(sr, readformat); } // Read the source resource here. Ionic.Crc.CrcCalculatorStream dataStream; if (encryptions.ContainsKey("data12")) { dataStream = zf[desc.PathInsideArchieve].OpenReader(encryptions["data12"]); } else { dataStream = zf[desc.PathInsideArchieve].OpenReader(); } System.Collections.Generic.List <ResourceData[]> databuffer; using (dataStream) using (ResourceReader rr = new ResourceReader(dataStream, readformat, true)) databuffer = rr.ReadToEnd(); Leayal.IO.RecyclableMemoryStream memoryEntry = new Leayal.IO.RecyclableMemoryStream(desc.PathInsideArchieve); somethingliawhglaihwg.Add(Path.GetFileName(desc.PathInsideArchieve), memoryEntry); ResourceData[] currentnode; using (ResourceWriter sw = new ResourceWriter(memoryEntry, readformat, true)) for (int writeEntryCount = 0; writeEntryCount < databuffer.Count; writeEntryCount++) { currentnode = databuffer[writeEntryCount]; // Apply translation here currentnode = translatedb.ApplyTranslation(currentnode); sw.WriteEntry(currentnode); } zf.UpdateEntry(desc.PathInsideArchieve, new WriteDelegate((filename, writeStream) => { var memStream = somethingliawhglaihwg[Path.GetFileName(filename)]; writeStream.Write(memStream.GetBuffer(), 0, (int)memStream.Length); })); } } if (!this.bWorker.CancellationPending) { // Get client version (again) Leayal.Ini.IniFile inifile = new Leayal.Ini.IniFile(Path.Combine(args.GameDirectory, "ver.ini")); string clientVer = inifile.GetValue("Client", "ver", string.Empty); if (string.IsNullOrWhiteSpace(clientVer)) { clientVer = "Unknown"; } outputpath = Path.Combine(args.OutputPath, $"SoulWorker{args.TranslationResource.SelectedClientRegion.ToUpper()} {args.TranslationResource.SelectedLanguage} Patch for client v{clientVer}.zip"); inifile.Close(); Microsoft.VisualBasic.FileIO.FileSystem.CreateDirectory(args.OutputPath); File.Delete(outputpath); using (ZipFile outputzf = new ZipFile(outputpath, System.Text.Encoding.UTF8)) { outputzf.AddEntry($"{args.TranslationResource.SelectedLanguage}\\data12.v", new WriteDelegate((_entryName, _entryStream) => { using (XorStream writeout = new XorStream(_entryStream, LionGameSecretByte)) { zf.Save(writeout); } })); outputzf.AddFile(gamedata12, "original"); outputzf.AddEntry("version.txt", $"100% compatible with SoulWorker{args.TranslationResource.SelectedClientRegion.ToUpper()} client v{clientVer}", System.Text.Encoding.UTF8); outputzf.Save(); } } foreach (Leayal.IO.RecyclableMemoryStream memStream in somethingliawhglaihwg.Values) { memStream.Dispose(); } somethingliawhglaihwg.Clear(); } } if (this.bWorker.CancellationPending) { e.Cancel = true; } else { // Return the fullpath of output e.Result = new BuildResult(currentRegion, currentLanguage, "PatchVersion", outputpath); } }
/// <summary> /// Merge roots with same degrees in Forest /// </summary> private void Meld() { if (HeapForestHead == null) { maxNode = null; return; } //degree - node dictionary var mergeDictionary = new System.Collections.Generic.Dictionary <int, FibornacciHeapNode <T> >(); var current = HeapForestHead; maxNode = current; while (current != null) { current.Parent = null; var next = current.Next; //no same degree already in merge dictionary //add to hash table if (!mergeDictionary.ContainsKey(current.Degree)) { mergeDictionary.Add(current.Degree, current); if (maxNode == current) { maxNode = null; } deleteNode(ref HeapForestHead, current); current = next; } //insert back to forest by merging current tree //with existing tree in merge dictionary else { var currentDegree = current.Degree; var existing = mergeDictionary[currentDegree]; if (existing.Value.CompareTo(current.Value) > 0) { current.Parent = existing; deleteNode(ref HeapForestHead, current); var childHead = existing.ChildrenHead; insertNode(ref childHead, current); existing.ChildrenHead = childHead; existing.Degree++; insertNode(ref HeapForestHead, existing); current = existing; current.Next = next; } else { existing.Parent = current; var childHead = current.ChildrenHead; insertNode(ref childHead, existing); current.ChildrenHead = childHead; current.Degree++; } if (maxNode == null || maxNode.Value.CompareTo(current.Value) < 0) { maxNode = current; } mergeDictionary.Remove(currentDegree); } } //insert back trees with unique degrees to forest if (mergeDictionary.Count > 0) { foreach (var node in mergeDictionary) { insertNode(ref HeapForestHead, node.Value); if (maxNode == null || maxNode.Value.CompareTo(node.Value.Value) < 0) { maxNode = node.Value; } } mergeDictionary.Clear(); } }
public override void Clear() { base.Clear(); identifiedLocatables.Clear(); }