//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void buildNonRotatingLog() throws java.io.IOException private void BuildNonRotatingLog() { Stream logOutputStream = createOrOpenAsOutputStream(_fileSystem, _currentQueryLogFile, true); _log = _logBuilder.toOutputStream(logOutputStream); _closable = logOutputStream; }
private void SingletonDomainUnload(object source, System.EventArgs arguments) { bool mustReleaseLock = false; System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegions(); try { System.Runtime.CompilerServices.RuntimeHelpers.PrepareConstrainedRegions(); System.Threading.Monitor.Enter(ModuleUninitializer.@lock, ref mustReleaseLock); System.Collections.IEnumerator enumerator = this.GetEnumerator(); try { while (enumerator.MoveNext()) { ((System.EventHandler)enumerator.Current)(source, arguments); } } finally { System.IDisposable source2 = enumerator as System.IDisposable; if (source2 != null) { source2.Dispose(); } } } finally { if (mustReleaseLock) { System.Threading.Monitor.Exit(ModuleUninitializer.@lock); } } }
/// <summary> /// Initializes a <see cref="DeviceContext9">Direct3D9 device context</see> according to the specified settings. /// The base class retains ownership of the context and will dispose of it when appropriate. /// </summary> /// <param name="settings">The settings.</param> /// <returns>The initialized device context.</returns> protected void InitializeDevice(DeviceSettings9 settings) { var result = new DeviceContext9(Form, settings); apiContext = result; Context9 = result; }
protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e) { if (this.trackItemsPropChanges) { switch (e.Action) { case NotifyCollectionChangedAction.Add: { System.Collections.IEnumerator enumerator = e.NewItems.GetEnumerator(); try { while (enumerator.MoveNext()) { T item = (T)((object)enumerator.Current); item.PropertyChanged += new PropertyChangedEventHandler(this.item_PropertyChanged); } } finally { System.IDisposable disposable = enumerator as System.IDisposable; if (disposable != null) { disposable.Dispose(); } } break; } case NotifyCollectionChangedAction.Remove: { System.Collections.IEnumerator enumerator = e.OldItems.GetEnumerator(); try { while (enumerator.MoveNext()) { T item = (T)((object)enumerator.Current); item.PropertyChanged -= new PropertyChangedEventHandler(this.item_PropertyChanged); } } finally { System.IDisposable disposable = enumerator as System.IDisposable; if (disposable != null) { disposable.Dispose(); } } break; } case NotifyCollectionChangedAction.Reset: foreach (T item in base.Items) { item.PropertyChanged += new PropertyChangedEventHandler(this.item_PropertyChanged); } break; } } base.OnCollectionChanged(e); }
// Foreach is readonly since foreach is syntactic sugar for the following logic. // If change reference, then enumerator won't be able to find the next object in the collection - // hence the object reference is readonly. public static void TestEnumeratorForEach() { var people = new List <Person> { new Person() { FirstName = "John", LastName = "Doe" }, new Person() { FirstName = "Jane", LastName = "Doe" }, }; List <Person> .Enumerator e = people.GetEnumerator(); try { Person v; while (e.MoveNext()) { v = e.Current; // If change value for v, then enumerator will not be able to locate next object in the collection. } } finally { System.IDisposable d = e as System.IDisposable; if (d != null) { d.Dispose(); } } }
static StackObject *AssignFromStack_staticField_1(ref object o, ILIntepreter __intp, StackObject *ptr_of_this_method, IList <object> __mStack) { ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; System.IDisposable @staticField = (System.IDisposable) typeof(System.IDisposable).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags) 0); ILRuntimeTest.TestFramework.ClassInheritanceTest.staticField = @staticField; return(ptr_of_this_method); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void buildRotatingLog(long rotationThreshold, int maxArchives) throws java.io.IOException private void BuildRotatingLog(long rotationThreshold, int maxArchives) { RotatingFileOutputStreamSupplier rotatingSupplier = new RotatingFileOutputStreamSupplier(_fileSystem, _currentQueryLogFile, rotationThreshold, 0, maxArchives, _scheduler.executor(Group.LOG_ROTATION)); _log = _logBuilder.toOutputStream(rotatingSupplier); _closable = rotatingSupplier; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static void closeIfNotNull(java.io.Closeable closeable) throws java.io.IOException private static void CloseIfNotNull(System.IDisposable closeable) { if (closeable != null) { closeable.Dispose(); } }
protected override void Start() { base.Start(); playerTransform = GetPlayer().transform; topTransform = GetTopTransform(); anim = enemyAnimation.anim; System.Type type = EnemyAttackTypeDictionary.typeDictionary[attackType]; var attackHook = GetComponentInParent(type) as IEventHook; if (attackHook == null) { Debug.Log("type: " + type.Name); } this.observer = attackHook.trigger.Subscribe((e) => { if (e) { AttackStart(); } else { AttackEnd(); } }); rotateTime = RotationTime(); }
public SaiHistoryHandler(SmartScriptBase script, ISmartFactory smartFactory) { this.script = script; this.smartFactory = smartFactory; this.script.Events.CollectionChanged += Events_CollectionChanged; this.script.BulkEditingStarted += OnBulkEditingStarted; this.script.BulkEditingFinished += OnBulkEditingFinished; variablesDisposable = this.script.GlobalVariables.ToStream().Subscribe(e => { if (e.Type == CollectionEventType.Add) { e.Item.CommentChanged += OnGlobalVariableCommentChanged; e.Item.VariableTypeChanged += OnGlobalVariableTypeChanged; e.Item.NameChanged += OnGlobalVariableNameChanged; e.Item.KeyChanged += OnGlobalVariableKeyChanged; } else { e.Item.CommentChanged -= OnGlobalVariableCommentChanged; e.Item.VariableTypeChanged -= OnGlobalVariableTypeChanged; e.Item.NameChanged -= OnGlobalVariableNameChanged; e.Item.KeyChanged -= OnGlobalVariableKeyChanged; } }); script.GlobalVariables.CollectionChanged += GlobalVariablesOnCollectionChanged; foreach (SmartEvent ev in this.script.Events) { BindEvent(ev); } }
static void Main(string[] args) { var people = new List <Person> { new Person() { FirstName = "Willamar", LastName = "Fernandes" }, new Person() { FirstName = "Willian", LastName = "Fernandes" } }; List <Person> .Enumerator e = people.GetEnumerator(); try { Person v; while (e.MoveNext()) { v = e.Current; Console.WriteLine(v.FirstName); } } finally { System.IDisposable d = e as System.IDisposable; if (d != null) { d.Dispose(); } } Console.Read(); }
private bool validata(string theme) { DropdownColumn dropdownColumn = (DropdownColumn)this.grdTopCategries.Columns[1]; System.Collections.IEnumerator enumerator = this.grdTopCategries.Rows.GetEnumerator(); bool result; try { while (enumerator.MoveNext()) { System.Web.UI.WebControls.GridViewRow gridViewRow = (System.Web.UI.WebControls.GridViewRow)enumerator.Current; string a = dropdownColumn.SelectedValues[gridViewRow.RowIndex]; if (a == theme) { result = false; return(result); } } return(true); } finally { System.IDisposable disposable = enumerator as System.IDisposable; if (disposable != null) { disposable.Dispose(); } } return(result); }
public static void ForeachCompilerCodeDemo() { var people = new List <Person> { new Person() { FirstName = "John", LastName = "Doe" }, new Person() { FirstName = "Jane", LastName = "Doe" }, }; List <Person> .Enumerator e = people.GetEnumerator(); try { Person v; while (e.MoveNext()) { v = e.Current; } } finally { System.IDisposable d = e as System.IDisposable; if (d != null) { d.Dispose(); } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static void confirmTargetDirectoryIsWritable(org.neo4j.io.layout.StoreLayout storeLayout) throws CannotWriteException, java.io.IOException private static void ConfirmTargetDirectoryIsWritable(StoreLayout storeLayout) { using (System.IDisposable ignored = StoreLockChecker.Check(storeLayout)) { // empty } }
public void TimerStart() { TimerStop(); TimerReset(); if (OnStart != null) { OnStart.Invoke(currentTime); } subscribe = Observable.Interval(System.TimeSpan.FromSeconds(1)).Select(_ => currentTime).Where(_ => _ > 0).Subscribe(_ => { currentTime--; if (OnUpdate != null) { OnUpdate.Invoke(currentTime); } if (currentTime == 0) { subscribe.Dispose(); if (OnOver != null) { OnOver.Invoke(); } } }); }
protected void Start() { rigidbody2D = GetComponent <Rigidbody2D>(); disposable = this.UpdateAsObservable() .Subscribe(_ => CheckLifeTime()); }
public void Dispose() { truthSub?.Dispose(); tickSub?.Dispose(); truthSub = null; tickSub = null; }
static StackObject *AddTo_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, 2); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); UnityEngine.GameObject @gameObject = (UnityEngine.GameObject) typeof(UnityEngine.GameObject).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); ptr_of_this_method = ILIntepreter.Minus(__esp, 2); System.IDisposable @disposable = (System.IDisposable) typeof(System.IDisposable).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); var result_of_this_method = UniRx.DisposableExtensions.AddTo <System.IDisposable>(@disposable, @gameObject); object obj_result_of_this_method = result_of_this_method; if (obj_result_of_this_method is CrossBindingAdaptorType) { return(ILIntepreter.PushObject(__ret, __mStack, ((CrossBindingAdaptorType)obj_result_of_this_method).ILInstance)); } return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method)); }
protected internal ThreadAhead(System.IDisposable actual) { this._actual = actual; Name = this.GetType().Name + " for " + actual; this._owner = Thread.CurrentThread; Daemon = true; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private StoreLogService(org.neo4j.logging.LogProvider userLogProvider, org.neo4j.io.fs.FileSystemAbstraction fileSystem, java.io.File internalLog, java.util.Map<String, org.neo4j.logging.Level> logLevels, org.neo4j.logging.Level defaultLevel, java.time.ZoneId logTimeZone, long internalLogRotationThreshold, long internalLogRotationDelay, int maxInternalLogArchives, java.util.concurrent.Executor rotationExecutor, final System.Action<org.neo4j.logging.LogProvider> rotationListener) throws java.io.IOException //JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected: private StoreLogService(LogProvider userLogProvider, FileSystemAbstraction fileSystem, File internalLog, IDictionary <string, Level> logLevels, Level defaultLevel, ZoneId logTimeZone, long internalLogRotationThreshold, long internalLogRotationDelay, int maxInternalLogArchives, Executor rotationExecutor, System.Action <LogProvider> rotationListener) { if (!internalLog.ParentFile.exists()) { fileSystem.Mkdirs(internalLog.ParentFile); } //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.logging.FormattedLogProvider.Builder internalLogBuilder = org.neo4j.logging.FormattedLogProvider.withZoneId(logTimeZone).withDefaultLogLevel(defaultLevel).withLogLevels(logLevels); FormattedLogProvider.Builder internalLogBuilder = FormattedLogProvider.withZoneId(logTimeZone).withDefaultLogLevel(defaultLevel).withLogLevels(logLevels); FormattedLogProvider internalLogProvider; if (internalLogRotationThreshold == 0) { Stream outputStream = createOrOpenAsOutputStream(fileSystem, internalLog, true); internalLogProvider = internalLogBuilder.ToOutputStream(outputStream); rotationListener(internalLogProvider); this._closeable = outputStream; } else { RotatingFileOutputStreamSupplier rotatingSupplier = new RotatingFileOutputStreamSupplier(fileSystem, internalLog, internalLogRotationThreshold, internalLogRotationDelay, maxInternalLogArchives, rotationExecutor, new RotationListenerAnonymousInnerClass(this, rotationListener, internalLogBuilder)); internalLogProvider = internalLogBuilder.ToOutputStream(rotatingSupplier); this._closeable = rotatingSupplier; } this._logService = new SimpleLogService(userLogProvider, internalLogProvider); }
private System.Collections.IEnumerator ActionNode14_Tick() { ActionNode14_Result = ActionNode14.Result; // GetRandomListItem while (this.DebugInfo("68961abd-e820-48aa-a995-9cc061db72e3", "b41bbe7f-ce36-4757-a82f-262a4ca53efb", this) == 1) { yield return(null); } GetRandomListItem15_Result = Group.Items[UnityEngine.Random.Range(0, Group.Items.Count)]; ActionNode16_gameObject = GetRandomListItem15_Result; // ActionNode while (this.DebugInfo("b41bbe7f-ce36-4757-a82f-262a4ca53efb", "fedb37d4-17d7-448b-aacc-80a004c7dcf3", this) == 1) { yield return(null); } // Visit uFrame.ECS.Actions.GameObjects.Instantiate ActionNode16_Result = uFrame.ECS.Actions.GameObjects.Instantiate(ActionNode16_gameObject, ActionNode16_position, ActionNode16_rotation); // SetVariableNode while (this.DebugInfo("fedb37d4-17d7-448b-aacc-80a004c7dcf3", "0f5e4b94-6070-4ecd-8398-9b080c87ab8f", this) == 1) { yield return(null); } ActionNode16_Result.transform.parent = (UnityEngine.Transform)Group.Parent; yield break; }
protected void btnDel_Click(object sender, System.EventArgs e) { System.Collections.IEnumerator enumerator = this.gvResource.Rows.GetEnumerator(); try { while (enumerator.MoveNext()) { GridViewRow gridViewRow = (GridViewRow)enumerator.Current; CheckBox cb = gridViewRow.FindControl("cbBox") as CheckBox; if (cb != null && cb.Checked) { using (pm2Entities pm2Entities = new pm2Entities()) { if (base.Request["num"] == "1") { Res_Template res_Template = ( from m in pm2Entities.Res_Template where m.TemplateId == cb.ToolTip select m).FirstOrDefault <Res_Template>(); if (res_Template != null) { res_Template.IsValid = new bool?(false); pm2Entities.SaveChanges(); } } else { IQueryable <Res_TemplateItem> queryable = from m in pm2Entities.Res_TemplateItem where m.Res_Template.TemplateId == cb.ToolTip select m; foreach (Res_TemplateItem current in queryable) { pm2Entities.DeleteObject(current); } Res_Template res_Template2 = ( from m in pm2Entities.Res_Template where m.TemplateId == cb.ToolTip select m).FirstOrDefault <Res_Template>(); if (res_Template2 != null) { pm2Entities.DeleteObject(res_Template2); pm2Entities.SaveChanges(); } } } } } } finally { System.IDisposable disposable = enumerator as System.IDisposable; if (disposable != null) { disposable.Dispose(); } } base.RegisterScript("location.href=location.href;"); }
public virtual void ResetPosition() { if (_PositionDisposable != null) { _PositionDisposable.Dispose(); } _PositionDisposable = GetPositionObservable().Subscribe(Entity.PositionProperty).DisposeWith(this); }
public InProcessServerControls(File serverFolder, File userLogFile, File internalLogFile, NeoServer server, System.IDisposable additionalClosable) { this._serverFolder = serverFolder; this._userLogFile = userLogFile; this._internalLogFile = internalLogFile; this._server = server; this._additionalClosable = additionalClosable; }
private void RemoveFromMapOverlay() { if (_overlayObject != null) { _overlayObject.Dispose(); _overlayObject = null; } }
public virtual void ResetIsNameFrank() { if (_IsNameFrankDisposable != null) { _IsNameFrankDisposable.Dispose(); } _IsNameFrankDisposable = _IsNameFrankProperty.ToComputed(ComputeIsNameFrank, this.GetIsNameFrankDependents().ToArray()).DisposeWith(this); }
public FileResponse(int statusCode, System.Collections.Generic.Dictionary <string, System.Collections.Generic.IEnumerable <string> > headers, System.IO.Stream stream, System.IDisposable client, System.IDisposable response) { StatusCode = statusCode; Headers = headers; Stream = stream; _client = client; _response = response; }
private void ClearOverlay() { if (_overlayObject != null) { _overlayObject.Dispose(); _overlayObject = null; } }
public void AddPrice() { string id = this.hdGuid.Value; if (!string.IsNullOrEmpty(this.resourceId)) { id = this.resourceId; } using (pm2Entities pm2Entities = new pm2Entities()) { IQueryable <Res_Price> queryable = from m in pm2Entities.Res_Price where m.ResourceId == id select m; foreach (Res_Price current in queryable) { pm2Entities.DeleteObject(current); } pm2Entities.SaveChanges(); } System.Collections.IEnumerator enumerator2 = this.gvwPriceType.Rows.GetEnumerator(); try { while (enumerator2.MoveNext()) { GridViewRow gridViewRow = (GridViewRow)enumerator2.Current; TextBox tb = gridViewRow.FindControl("txtPrice") as TextBox; using (pm2Entities pm2Entities2 = new pm2Entities()) { Res_Price res_Price = new Res_Price(); if (!string.IsNullOrEmpty(tb.Text)) { res_Price.PriceValue = System.Convert.ToDecimal(tb.Text); } Res_PriceType res_PriceType = ( from m in pm2Entities2.Res_PriceType where m.PriceTypeId == tb.ToolTip select m).First <Res_PriceType>(); res_PriceType.Res_Price.Add(res_Price); Res_Resource res_Resource = ( from m in pm2Entities2.Res_Resource where m.ResourceId == id select m).First <Res_Resource>(); res_Resource.Res_Price.Add(res_Price); pm2Entities2.AddToRes_Price(res_Price); pm2Entities2.SaveChanges(); } } } finally { System.IDisposable disposable = enumerator2 as System.IDisposable; if (disposable != null) { disposable.Dispose(); } } }
private void TryStopSeLoop() { if (seLoopDisposable == null) { return; } seLoopDisposable.Dispose(); seLoopDisposable = null; }
private void ActionNode3_Tick() { ActionNode3_Result = ActionNode3.Result; ActionNode1_gameObject = Group.Prefab; // ActionNode // Visit uFrame.Actions.GameObjects.Instantiate ActionNode1_Result = uFrame.Actions.GameObjects.Instantiate(ActionNode1_gameObject, ActionNode1_position, ActionNode1_rotation); // SetVariableNode ActionNode1_Result.transform.parent = (UnityEngine.Transform)Group.Parent; }
public virtual void Execute() { ActionNode3_Seconds = Group.Speed; // ActionNode // Visit uFrame.Actions.IntervalBySeconds ActionNode3.Seconds = ActionNode3_Seconds; ActionNode3.System = System; ActionNode3.Tick = ActionNode3_Tick; ActionNode3.Execute(); ActionNode3_Result = ActionNode3.Result; }
private void ActionNode22_Tick() { ActionNode22_Result = ActionNode22.Result; // GetRandomListItem GetRandomListItem8_Result = Group.Items[UnityEngine.Random.Range(0, Group.Items.Count)]; ActionNode2_gameObject = GetRandomListItem8_Result; // ActionNode // Visit uFrame.Actions.GameObjects.Instantiate ActionNode2_Result = uFrame.Actions.GameObjects.Instantiate(ActionNode2_gameObject, ActionNode2_position, ActionNode2_rotation); // SetVariableNode ActionNode2_Result.transform.parent = (UnityEngine.Transform)Group.Parent; }
public virtual void Execute() { ActionNode22_Seconds = Group.SpawnSpeed; ActionNode22_DisposeWith = Group; // ActionNode // Visit uFrame.Actions.IntervalBySeconds ActionNode22.Seconds = ActionNode22_Seconds; ActionNode22.DisposeWith = ActionNode22_DisposeWith; ActionNode22.System = System; ActionNode22.Tick = ActionNode22_Tick; ActionNode22.Execute(); ActionNode22_Result = ActionNode22.Result; }
private async void OnFlashPointCommand(object obj) { CoordinateDD dd; var ctvm = CTView.Resources["CTViewModel"] as CoordinateToolViewModel; if (ctvm != null) { if (!CoordinateDD.TryParse(ctvm.InputCoordinate, out dd)) return; } else { return; } ArcGIS.Core.CIM.CIMPointSymbol symbol = null; var point = await QueuedTask.Run(() => { ArcGIS.Core.Geometry.SpatialReference sptlRef = SpatialReferenceBuilder.CreateSpatialReference(4326); return MapPointBuilder.CreateMapPoint(dd.Lon, dd.Lat, sptlRef); }); await QueuedTask.Run(() => { // Construct point symbol symbol = SymbolFactory.ConstructPointSymbol(ColorFactory.Red, 10.0, SimpleMarkerStyle.Star); }); //Get symbol reference from the symbol CIMSymbolReference symbolReference = symbol.MakeSymbolReference(); await QueuedTask.Run(() => { ClearOverlay(); _overlayObject = MapView.Active.AddOverlay(point, symbolReference); MapView.Active.ZoomToAsync(point, new TimeSpan(2500000), true); }); }
public virtual void ResetShouldDestroy() { if (_ShouldDestroyDisposable != null) { _ShouldDestroyDisposable.Dispose(); } _ShouldDestroyDisposable = _ShouldDestroyProperty.ToComputed(ComputeShouldDestroy, this.GetShouldDestroyDependents().ToArray()).DisposeWith(this); }
public virtual void ResetShouldCreateAndDrop() { if (_ShouldCreateAndDropDisposable != null) { _ShouldCreateAndDropDisposable.Dispose(); } _ShouldCreateAndDropDisposable = _ShouldCreateAndDropProperty.ToComputed(ComputeShouldCreateAndDrop, this.GetShouldCreateAndDropDependents().ToArray()).DisposeWith(this); }
public virtual void ResetCanTap() { if (_CanTapDisposable != null) { _CanTapDisposable.Dispose(); } _CanTapDisposable = _CanTapProperty.ToComputed(ComputeCanTap, this.GetCanTapDependents().ToArray()).DisposeWith(this); }