public void CanAddNonDisposableCasted() { object toAdd = new object(); var toTest = new Disposer(); toTest.AddIfDisposable(toAdd); toTest.Dispose(); }
public void AddDisposeClosure() { var ran = false; var toTest = new Disposer(); toTest.AddAsDisposable(() => { ran = true; }); toTest.Dispose(); Assert.IsTrue(ran); }
public SynchronizedClock(IBus bus) { m_Bus = bus; m_Disposer = new Disposer(); m_Bus.Subscribe<TimeUpdateMessage>(OnTimeUpdate).AddTo(m_Disposer); m_NextSync = m_SyncRate; }
public ClickMarker(SceneNode marker, IBus bus) { m_Marker = marker; m_Bus = bus; m_Disposer = new Disposer(); m_Bus.Subscribe<SetPathToTargetMessage>(MoveMarker).AddTo(m_Disposer); m_Bus.Subscribe<SelectObjectAtMessage>(MoveMarker).AddTo(m_Disposer); }
public void AddCasted() { var toCheck = new AssertDisposable(); object toAdd = toCheck; var toTest = new Disposer(); toTest.AddIfDisposable(toAdd); toTest.Dispose(); toCheck.AssertDisposed(); }
public static IDisposable Create(Func<IDictionary<string, object>, Task> app, IDictionary<string, object> properties) { if (app == null) { throw new ArgumentNullException("app"); } if (properties == null) { throw new ArgumentNullException("properties"); } var capabilities = properties.Get<IDictionary<string, object>>(OwinKeys.ServerCapabilitiesKey) ?? new Dictionary<string, object>(); var addresses = properties.Get<IList<IDictionary<string, object>>>("host.Addresses") ?? new List<IDictionary<string, object>>(); var servers = new List<INowinServer>(); var endpoints = new List<IPEndPoint>(); foreach (var address in addresses) { var builder = ServerBuilder.New().SetOwinApp(app); int port; if (!int.TryParse(address.Get<string>("port"), out port)) throw new ArgumentException("port must be number from 0 to 65535"); builder.SetPort(port); builder.SetOwinCapabilities(capabilities); var certificate = address.Get<X509Certificate>("certificate"); if (certificate != null) builder.SetCertificate(certificate); servers.Add(builder.Build()); endpoints.Add(new IPEndPoint(IPAddress.Loopback,port)); } var disposer = new Disposer(servers.Cast<IDisposable>().ToArray()); try { foreach (var nowinServer in servers) { nowinServer.Start(); } // This is workaround to Windows Server 2012 issue by calling ReadLine after AcceptAsync, by making one bogus connection this problem goes away foreach (var ipEndPoint in endpoints) { var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); socket.Connect(ipEndPoint); socket.Close(); } } catch (Exception) { disposer.Dispose(); throw; } return disposer; }
public Path(double maximumAcceleration, IMotion startingMotion, IBus bus) { m_Bus = bus; m_Disposer = new Disposer(); m_Bus.Subscribe<SetPathToTarget>(OnSetPathToTarget).AddTo(m_Disposer); m_Acceleration = maximumAcceleration; m_Path = new List<IMotion>(); m_Path.Add(startingMotion); }
public DeviceDescription DeserializeDescription(Uri url) { if (url == null) throw new ArgumentNullException ("url"); if (disposer != null) throw new InvalidOperationException ( "Deserializers can only be used to deserialize one device description once."); disposer = new Disposer (url); UrlBase = url; return DeserializeDescriptionCore (url); }
public Scene(IBus bus, SceneManager sceneManager) { m_Bus = bus; m_SceneManager = sceneManager; m_SceneNodes = new List<NodeWithPosition>(); m_Disposer = new Disposer(); m_Bus.Subscribe<PathMessage>(UpdateMotion).AddTo(m_Disposer); m_Bus.Subscribe<SelectedObjectMessage>(OnSelected).AddTo(m_Disposer); m_Bus.Subscribe<DeselectedObjectMessage>(OnDeselected).AddTo(m_Disposer); }
public void SetDisposesIfShouldDispose() { bool disposed = false; var disposable = new DisposableAction(() => { disposed = true; }); var disposer = new Disposer(); Assert.False(disposed); disposer.Dispose(); disposer.Set(disposable); Assert.True(disposed); }
public void Dispose() { Disposer temp; lock (this) { temp = disposer; disposer = null; } if (temp != null) temp(); }
public FieldDisplay(IBus bus, ISelectableObjectRepository selectableRepo, IRenderer renderer, IPlayerId id, ITargetedVesselRenderer _) { m_Bus = bus; m_Renderer = renderer; m_SelectableRepo = selectableRepo; m_Id = id; m_Disposer = new Disposer(); m_Bus.Subscribe<AddObjectMessage>(OnAdd).AddTo(m_Disposer); }
public void EventAsDisposable() { var eventObject = new EventObject(); var toTest = new Disposer(); toTest.Event<Action<string>>(e => Assert.Fail("Unexpected"), e => eventObject.AEvent += e, e => eventObject.AEvent -= e); toTest.Event<Action<string, string>>((f, s) => Assert.Fail("Unexpected"), e => eventObject.OtherEvent += e, e => eventObject.OtherEvent -= e); toTest.Event<Action<string, string, string>>((f, s, t) => Assert.Fail("Unexpected"), e => eventObject.ThirdEvent += e, e => eventObject.ThirdEvent -= e); toTest.Dispose(); eventObject.Raise(); }
public SelectableObjectRepository(IBus bus, IPlayerId id, IVesselRepository vesselRepository) { m_Bus = bus; m_Id = id; m_VesselRepository = vesselRepository; m_Objects = new List< SelectableObject>(); m_Disposer = new Disposer(); m_Bus.Subscribe<SelectObjectAtMessage>(OnSelectObject).AddTo(m_Disposer); m_Bus.Subscribe<RequestPathMessage>(OnPathRequest).AddTo(m_Disposer); m_Bus.Subscribe<SetPathToTargetMessage>(OnSetPath).AddTo(m_Disposer); }
public TargetedVesselRenderer(IBus bus, ISelectableObjectRepository targets, IRenderer renderer, IPlayerId id, IVesselRepository vesselRepository) { m_Disposer = new Disposer(); m_Bus = bus; m_Targets = targets; m_Renderer = renderer; m_Id = id; m_VesselRepository = vesselRepository; m_Attacks = new List<Attack>(); m_Bus.Subscribe<HighlightTargetMessage>(OnHighlight).AddTo(m_Disposer); m_Bus.Subscribe<AttackTargetMessage>(OnAttack).AddTo(m_Disposer); m_Bus.Subscribe<SelectedObjectMessage>(OnSelection).AddTo(m_Disposer); m_Bus.Subscribe<TimeUpdateMessage>(OnTick).AddTo(m_Disposer); }
public InputController(string windowHandle, Camera camera, IBus bus, IClock clock, IPlayerId id) { m_Camera = camera; m_Bus = bus; m_Clock = clock; m_PlayerId = id; ParamList pl = new ParamList(); pl.Insert("WINDOW", windowHandle); pl.Insert("w32_mouse", "DISCL_FOREGROUND"); pl.Insert("w32_mouse", "DISCL_NONEXCLUSIVE"); pl.Insert("w32_keyboard", "DISCL_FOREGROUND"); pl.Insert("w32_keyboard", "DISCL_NONEXCLUSIVE"); m_Disposer = new Disposer(); bus.Subscribe<ChangeInputModeMessage>(OnModeChanged).AddTo(m_Disposer); }
protected override void Dispose(bool disposing) { Disposer.Dispose(ref _timer); base.Dispose(); }
public static void Run(Options options) { //In order to playback video opencv_ffmpeg*.dll must be found. string includePath = Environment.Is64BitProcess ? @".\dll\x64" : @".\dll\x86"; foreach (string file in Directory.EnumerateFiles(includePath, "*.dll")) { File.Copy(file, Path.GetFileName(file), true); } //define the upper and lower boundaries of the HSV pixel //intensities to be considered 'skin' var lower = new Scalar(0, 48, 80); var upper = new Scalar(20, 255, 255); //if a video path was not supplied, grab the reference //to the gray //otherwise, load the video VideoCapture camera = string.IsNullOrEmpty(options.Video) ? VideoCapture.FromCamera(CaptureDevice.Any) : new VideoCapture(Path.GetFullPath(options.Video)); if (!camera.IsOpened()) { Console.WriteLine("Failed to initialize video"); return; } using (camera) { //keep looping over the frames in the video while (true) { //grab the current frame using (var frame = new Mat()) using (var disposer = new Disposer()) { bool grabbed = camera.Read(frame); //if we are viewing a video and we did not grab a //frame, then we have reached the end of the video if (!grabbed || frame.Width == 0 || frame.Height == 0) { if (!string.IsNullOrEmpty(options.Video)) { break; } continue; } //resize the frame, convert it to the HSV color space, //and determine the HSV pixel intensities that fall into //the speicifed upper and lower boundaries Mat resizedFrame = ImageUtil.Resize(frame, width: 400); disposer.Add(resizedFrame); Mat converted = resizedFrame.CvtColor(ColorConversionCodes.BGR2HSV); disposer.Add(converted); Mat skinMask = new Mat(); disposer.Add(skinMask); Cv2.InRange(converted, lower, upper, skinMask); //apply a series of erosions and dilations to the mask //using an elliptical kernel using (Mat kernel = Cv2.GetStructuringElement(MorphShapes.Ellipse, new Size(11, 11))) { skinMask = skinMask.Erode(kernel, iterations: 2); disposer.Add(skinMask); skinMask = skinMask.Dilate(kernel, iterations: 2); disposer.Add(skinMask); } //blur the mask to help remove noise, then apply the //mask to the frame skinMask = skinMask.GaussianBlur(new Size(3, 3), 0); disposer.Add(skinMask); Mat skin = new Mat(); disposer.Add(skin); Cv2.BitwiseAnd(resizedFrame, resizedFrame, skin, skinMask); //show the skin in the image along with the mask Cv2.ImShow("images", resizedFrame); Cv2.ImShow("mask", skin); //if the 'q' key is pressed, stop the loop if ((Cv2.WaitKey(1) & 0xff) == 'q') { break; } } } } Cv2.DestroyAllWindows(); }
protected virtual void DeferRestoreStateOnLevel(Disposer disposer) { }
public ExampleDerived() { // IDisposable を継承するクラスの派生クラスでは、ベースクラスの // Dispose 実行、マネージドリソース及びアンマネージドリソースの // 解放を行う private メソッドを用意して Disposer コンストラクタに渡す。 disposer = new Disposer(this, ReleaseBase, ReleaseManaged, ReleaseUnmanaged); }
public SubscriptionDisposerContext(Disposer disposer, IDisposable subscription) { _disposer = disposer; _supscription = subscription; }
/**************************************************************************************************** * ****************************************************************************************************/ public Demo() { _disposer = new Disposer(); RenderHandle = _disposer.Add(new AutoResetEvent(false)); }
public void Dispose() { Disposer.Dispose(certificate); Disposer.Close(listener); Disposer.Dispose(accepter); }
public static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); // Create main disposer var mainDisposer = new Disposer(); // var random = new Random(1415926535); #region demo setup // show setup dialog and get setup values var title = "Mash Room by Jolt"; var setupView = new StartupView(title); var setupModel = new SetupModel(); var presenter = new SetupPresenter(setupView, setupModel); setupModel.TryLoadSettings(); setupModel.SelectAdapter(0); var dialogResult = setupView.ShowDialog(); if (dialogResult != DialogResult.OK) return; #if DEBUG setupModel.SaveSettings(); // todo: remove save in release mode #endif #endregion // Create Device and SwapChain var demo = new Demo().Init(setupModel, title); var inputHandler = new InputHandler().Bind(demo); #region audio // var audioDeviceType = (setupModel.UseAudio) ? AudioDeviceType.Bass : AudioDeviceType.Silent; var audioDeviceManager = new AudioDeviceManager(); var audioDevice = mainDisposer.Add(audioDeviceManager.CreateDevice(audioDeviceType)); // if (setupModel.UseAudio) { // BassNet.Registration( setupModel.BassRegistrationEmail ?? "", setupModel.BassRegistrationKey ?? ""); // 140 bpm // delay 3.428 (dvs 2 takter i 140 bpm) var bpm = 140; var audioName = "Mashup_v1.00.mp3"; var audioAsset = mainDisposer.Add(demo.AudioManager[audioName]); // init and load audio audioDevice.Init(); audioDevice.Load(audioAsset.Value); audioDevice.PlayPosition = setupModel.StartTime; audioDevice.Bpm = bpm; // use the audio device as timer demo.Timer = audioDevice; } #endregion #region sync demo.SyncManager = new SyncManager().Init(setupModel.SyncRecordMode, demo.Timer.Bpm, 4); demo.SyncManager.TimerDevice = demo.Timer; #endregion #region shaders var planeVertexShader = demo.ShaderManager["plane.vs.cso"].VertexShader; var planePixelShader = demo.ShaderManager["plane.ps.cso"].PixelShader; var postPixelShader = demo.ShaderManager["post.ps.cso"].PixelShader; var postVertexShader = demo.ShaderManager["post.vs.cso"].VertexShader; var vanillaEffect = mainDisposer.Add(new VanillaEffect(demo).Init()); var vanillaLayout = mainDisposer.Add(vanillaEffect.InputLayout.InputLayout); #endregion #region models // load all models demo.ModelManager.LoadAll(); // make all models white (todo: why) foreach (var model in demo.ModelManager) { model.Color = new Color(255, 255, 255, 255); model.ReCreateBuffer(demo.Device); } #endregion #region textures Texture2D backBuffer = null; Texture2D depthBuffer = null; DepthStencilView depthView = null; // 1D texture for scanline distortion var distortionTexture = new Texture1D(demo.Device, new Texture1DDescription { CpuAccessFlags = CpuAccessFlags.None, Format = Format.R8G8B8A8_UNorm, Usage = ResourceUsage.Default, Width = 1080, ArraySize = 1, MipLevels = 1, BindFlags = BindFlags.ShaderResource, OptionFlags = ResourceOptionFlags.None }); var distortionData = new byte[4 * distortionTexture.Description.Width]; var distortionSRV = new ShaderResourceView(demo.Device, distortionTexture); // foreground texture var foregroundTexture = new Texture2D(demo.Device, new Texture2DDescription { CpuAccessFlags = CpuAccessFlags.None, Format = Format.R8_UNorm, Usage = ResourceUsage.Default, Width = 1920, Height = 1080, ArraySize = 1, MipLevels = 1, BindFlags = BindFlags.ShaderResource, OptionFlags = ResourceOptionFlags.None, SampleDescription = new SampleDescription(1, 0), }); var foregroundSRV = new ShaderResourceView(demo.Device, foregroundTexture); var foregroundData = new byte[foregroundTexture.Description.Width * foregroundTexture.Description.Height]; // noise texture var noiseTexture = new Texture2D(demo.Device, new Texture2DDescription { CpuAccessFlags = CpuAccessFlags.None, Format = Format.R8_UNorm, Usage = ResourceUsage.Default, Width = 1920 / 5, Height = 1080 / 5, ArraySize = 1, MipLevels = 1, BindFlags = BindFlags.ShaderResource, OptionFlags = ResourceOptionFlags.None, SampleDescription = new SampleDescription(1, 0), }); var noiseSRV = new ShaderResourceView(demo.Device, noiseTexture); var noiseData = new byte[noiseTexture.Description.Width * noiseTexture.Description.Height]; #endregion #region acts var act0 = mainDisposer.Add(new Act0(demo).Init()); #endregion #region effects //var fractalCityEffect = mainDisposer.Add(new FractalCityEffect(demo).Init()); //var oceanEffect = mainDisposer.Add(new OceanEffect(demo).Init()); //var dustEffect = mainDisposer.Add(new DustEffect(demo).Init()); //var cloudEffect = mainDisposer.Add(new CloudEffect(demo).Init()); //var mandelbulbEffect = mainDisposer.Add(new MandelbulbEffect(demo).Init()); //var redPlanetEffect = mainDisposer.Add(new Effect(demo).Init(new EffectDescription //{ // PixelShaderName = "redPlanet.ps.cso", // TextureNames = "redPlanet0.png,redPlanet1.jpg".Split(',') //})); //var pseudoKleinianEffect = mainDisposer.Add(new Effect(demo).Init(new EffectDescription //{ // PixelShaderName = "pseudoKleinian.ps.cso", //})); //var nonameEffect00 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname00.ps.cso", TextureNames = "tex09.jpg".Split(',') })); //var nonameEffect01 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname01.ps.cso" })); //var nonameEffect02 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname02.ps.cso", TextureNames = "tex09.jpg,tex07.jpg".Split(',') })); //var nonameEffect03 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname03.ps.cso" })); //var nonameEffect04 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname04.ps.cso", TextureNames = "noise256.png".Split(',') })); //var nonameEffect05 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname05.ps.cso" })); //var nonameEffect06 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname06.ps.cso" })); //var nonameEffect07 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname07.ps.cso" })); //var nonameEffect08 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname08.ps.cso" })); //var nonameEffect09 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname09.ps.cso" })); //var nonameEffect10 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname10.ps.cso" })); #endregion var fillStateMsaadesc = RasterizerStateDescription.Default(); fillStateMsaadesc.IsMultisampleEnabled = true; var msaaFillState = new RasterizerState(demo.Device, fillStateMsaadesc); var fillState = new RasterizerState(demo.Device, RasterizerStateDescription.Default()); var vanillaRenderContext = null as RenderContext; var postRenderContext = null as RenderContext; var planeRenderContext = null as RenderContext; // Main loop using (var renderDisposer = new Disposer()) { RenderLoop.Run(demo.Form, () => { if (demo.SyncManager.RowIndex == 0x000006d0) { demo.Form.Close(); return; } // TODO refactor: move the resize code #region resize if (demo.OutputWasResized) { demo.OutputWasResized = false; renderDisposer.DisposeAll(); // dispose old swapchain if (demo.SwapChain != null) { demo.SwapChain.Dispose(); } // create new swapchain demo.SwapChain = renderDisposer.Add(new SwapChain(setupModel.Factory, demo.Device, new SwapChainDescription { BufferCount = 1, ModeDescription = setupModel.Mode, IsWindowed = !setupModel.FullScreen, OutputHandle = demo.Form.Handle, //SampleDescription = new SampleDescription(setupModel.MultiSampleCount, setupModel.MultiSampleQuality), SampleDescription = new SampleDescription(1, 0), SwapEffect = SwapEffect.Discard, Usage = Usage.RenderTargetOutput })); if (setupModel.FullScreen) { demo.SwapChain.SetFullscreenState(true, setupModel.Output); } // var postOutputRenderTarget = new RenderTarget(demo.Device, demo.SwapChain); // Get the backbuffer from the swapchain backBuffer = renderDisposer.Add(demo.SwapChain.GetBackBuffer<Texture2D>(0)); // Setup targets and viewport for rendering var postInputRenderTarget = new RenderTarget( device: demo.Device, width: setupModel.Mode.Width / 1, // todo: introduce a scalefactor height: setupModel.Mode.Height / 1, // todo: introduce a scalefactor sampleCount: 1, // todo: use setupModel.MultiSampleCount, sampleQuality: 0, // todo: use setupModel.MultiSampleQuality, format: Format.R8G8B8A8_UNorm // todo: use setupModel.Format ); // Create the depth buffer depthBuffer = renderDisposer.Add(new Texture2D(demo.Device, new Texture2DDescription { Format = Format.D32_Float_S8X24_UInt, ArraySize = 1, MipLevels = 1, Width = postInputRenderTarget.Width, Height = postInputRenderTarget.Height, SampleDescription = postInputRenderTarget.Texture.Description.SampleDescription, Usage = ResourceUsage.Default, BindFlags = BindFlags.DepthStencil, CpuAccessFlags = CpuAccessFlags.None, OptionFlags = ResourceOptionFlags.None })); // Create the depth buffer view depthView = renderDisposer.Add(new DepthStencilView(demo.Device, depthBuffer)); vanillaRenderContext = renderDisposer.Add(new RenderContext { PrimitiveTopology = PrimitiveTopology.TriangleList, InputLayout = vanillaLayout, VertexShader = null, PixelShader = null, RasterizerState = msaaFillState, DepthStencilView = depthView, RenderTarget = postInputRenderTarget, }); postRenderContext = renderDisposer.Add(new RenderContext { PrimitiveTopology = PrimitiveTopology.TriangleList, InputLayout = vanillaLayout, VertexShader = postVertexShader, PixelShader = postPixelShader, RasterizerState = fillState, DepthStencilView = null, RenderTarget = postOutputRenderTarget, }); planeRenderContext = new RenderContext { PrimitiveTopology = PrimitiveTopology.TriangleList, InputLayout = vanillaLayout, VertexShader = planeVertexShader, PixelShader = planePixelShader, RasterizerState = fillState, DepthStencilView = null, RenderTarget = postOutputRenderTarget, }; // todo: remove this hack if (!setupModel.SyncRecordMode) { demo.Timer.StartPlaying(); } if (setupModel.FullScreen) { Cursor.Hide(); } } #endregion // todo: remove demo.SyncManager.Update(demo.Timer.Time); var syncRow = new { demo.SyncManager.Data.Part, demo.SyncManager.Data.Lead, }; // Present! // a crash here is quite common when VertexShader or PixelShader is null demo.SwapChain.Present(setupModel.UseVerticalSync ? 1 : 0, PresentFlags.None); // horizontal distortion and color separation random.NextBytes(distortionData); demo.DeviceContext.UpdateSubresource(distortionData, distortionTexture); // static noise random.NextBytes(noiseData); demo.DeviceContext.UpdateSubresource(noiseData, noiseTexture, 0, noiseTexture.Description.Width); // setup for normal rendering { // use normal rendering demo.DeviceContext.PixelShader.SetShaderResource(0, null); demo.RenderContext = vanillaRenderContext; // clear demo.DeviceContext.ClearDepthStencilView(demo.RenderContext.DepthStencilView, DepthStencilClearFlags.Depth, 1.0f, 0); demo.DeviceContext.ClearRenderTargetView(demo.RenderContext.RenderTarget.RenderTargetView, Color.Black); } // render act act0.Render(); // demo.DeviceContext.ClearRenderTargetView(postRenderContext.RenderTarget.RenderTargetView, Color.Black); // render plane to screen if (true) { // TODO is this really needed ? demo.DeviceContext.OutputMerger.ResetTargets(); demo.DeviceContext.VertexShader.SetConstantBuffer(0, null); // use post rendering demo.RenderContext = postRenderContext; // set textures demo.DeviceContext.PixelShader.SetShaderResource(0, vanillaRenderContext.RenderTarget.ShaderResourceView); demo.DeviceContext.PixelShader.SetShaderResource(1, distortionSRV); demo.DeviceContext.PixelShader.SetShaderResource(2, noiseSRV); // use plane model var model = demo.ModelManager["plane2"]; // todo: make sure we have no z-buffer conflicts (might be hw dependent) var camera = new NoCamera(); demo.Draw(model, camera); } }); } // dispose Disposer.Dispose(ref mainDisposer); }
/**************************************************************************************************** * ****************************************************************************************************/ private RenderTarget() { _disposer = new Disposer(); }
protected virtual void DeferRestoreStateOnLevel( Disposer disposer ) { }
public DelegateDisposable(Disposer disposer) { this.disposer = disposer; }
public void Init() { displays = new List<Display>(); disposer = new Disposer(); int numberOfAdapters = 0; Adl.AdlMainControlCreate(Adl.AdlMainMemoryAlloc, 1); if (Adl.AdlAdapterNumberOfAdaptersGet != null) { Adl.AdlAdapterNumberOfAdaptersGet(ref numberOfAdapters); } Adl.AdlMainControlCreate(Adl.AdlMainMemoryAlloc, 1); if (numberOfAdapters > 0) { AdlAdapterInfoArray osAdapterInfoData = new AdlAdapterInfoArray(); if (Adl.AdlAdapterAdapterInfoGet != null) { int size = Marshal.SizeOf(osAdapterInfoData); IntPtr adapterBuffer = Marshal.AllocCoTaskMem(size); Marshal.StructureToPtr(osAdapterInfoData, adapterBuffer, false); int adlRet = Adl.AdlAdapterAdapterInfoGet(adapterBuffer, size); if (adlRet == Adl.AdlSuccess) { osAdapterInfoData = (AdlAdapterInfoArray)Marshal.PtrToStructure(adapterBuffer, osAdapterInfoData.GetType()); int isActive = 0; for (int i = 0; i < numberOfAdapters; i++) { AdlAdapterInfo adlAdapterInfo = osAdapterInfoData.ADLAdapterInfo[i]; int adapterIndex = adlAdapterInfo.AdapterIndex; if (Adl.AdlAdapterActiveGet != null) { adlRet = Adl.AdlAdapterActiveGet(adlAdapterInfo.AdapterIndex, ref isActive); } if (Adl.AdlSuccess == adlRet) { AdlDisplayInfo oneDisplayInfo = new AdlDisplayInfo(); if (Adl.AdlDisplayDisplayInfoGet != null) { IntPtr displayBuffer = IntPtr.Zero; int numberOfDisplays = 0; adlRet = Adl.AdlDisplayDisplayInfoGet(adlAdapterInfo.AdapterIndex, ref numberOfDisplays, out displayBuffer, 1); if (Adl.AdlSuccess == adlRet) { List<AdlDisplayInfo> displayInfoData = new List<AdlDisplayInfo>(); for (int j = 0; j < numberOfDisplays; j++) { oneDisplayInfo = (AdlDisplayInfo)Marshal.PtrToStructure(new IntPtr(displayBuffer.ToInt64() + j * Marshal.SizeOf(oneDisplayInfo)), oneDisplayInfo.GetType()); displayInfoData.Add(oneDisplayInfo); } for (int j = 0; j < numberOfDisplays; j++) { AdlDisplayInfo adlDisplayInfo = displayInfoData[j]; if (adlDisplayInfo.DisplayID.DisplayLogicalAdapterIndex == -1) { continue; } displays.Add(new Display { DisplayInfo = adlDisplayInfo, AdapterInfo = adlAdapterInfo, Index = adapterIndex, }); } } disposer.DisplayBufferList.Add(displayBuffer); } } } } disposer.AdapterBuffer = adapterBuffer; } } }
public void Dispose() { CurrentProcess = Disposer.Null(CurrentProcess); }
public void Deinitialize() { Disposer.RemoveAndDispose(ref _effect); Disposer.RemoveAndDispose(ref _inputLayout); }
static void Main(string[] args) { ProgramTools.Setup(); var config = new Config(); //args will always log to stderr because trace flag not loaded yet ExecutableTools.LogArgs(new StderrWriteLine(), args, (arg) => { ConfigTools.SetProperty(config, arg); }); AssertTools.NotEmpty(config.EndPoint, "Missing EndPoint"); AssertTools.NotEmpty(config.Root, "Missing Root"); if (!config.Daemon) { Logger.TRACE = new StderrWriteLine(); } var uri = string.Format("http://{0}/", config.EndPoint); var http = new HttpListener(); http.Prefixes.Add(uri); http.Start(); var accepter = new Runner(new Runner.Args { ThreadName = "Accepter" }); var handler = new Runner(new Runner.Args { ThreadName = "Handler" }); accepter.Run(() => { while (http.IsListening) { var ctx = http.GetContext(); handler.Run(() => { var request = ctx.Request; var response = ctx.Response; var pass = true; var file = ctx.Request.RawUrl.Substring(1); //remove leading / if (!PathTools.IsChildPath(config.Root, file)) { pass = false; } var path = PathTools.Combine(config.Root, file); Logger.Trace("File {0} {1}", file, path); if (!File.Exists(path)) { pass = false; } if (ctx.Request.HttpMethod != "GET") { pass = false; } if (pass) { var fi = new FileInfo(path); var fs = new FileStream(path, FileMode.Open, FileAccess.Read); ctx.Response.StatusCode = (int)HttpStatusCode.OK; ctx.Response.ContentLength64 = fi.Length; ctx.Response.ContentType = "application/octet-stream"; var data = new byte[1024]; var count = fs.Read(data, 0, data.Length); while (count > 0) { ctx.Response.OutputStream.Write(data, 0, count); count = fs.Read(data, 0, data.Length); } } else { ctx.Response.StatusCode = (int)HttpStatusCode.NotFound; ctx.Response.ContentLength64 = 0; } ctx.Response.Close(); }); } }); Stdio.SetStatus("Listeninig on {0}", uri); using (var disposer = new Disposer()) { disposer.Push(handler); disposer.Push(accepter); disposer.Push(http.Stop); var line = Stdio.ReadLine(); while (line != null) { line = Stdio.ReadLine(); } } Logger.Trace("Stdin closed"); Environment.Exit(0); }
public void Dispose() { Disposer.TryDisposeAll(Adapter, Device, OutputDuplication, Texture2D); GC.SuppressFinalize(this); }
private void CreateAndBindTargets() { this.D3DSurface.SetRenderTargetDX10(null); Disposer.RemoveAndDispose(ref this.RenderTargetView); Disposer.RemoveAndDispose(ref this.RenderTarget1View); Disposer.RemoveAndDispose(ref this.RenderTarget2View); Disposer.RemoveAndDispose(ref this.OutputRenderTargetView); Disposer.RemoveAndDispose(ref this.DepthStencilView); Disposer.RemoveAndDispose(ref this.BlendingState); Disposer.RemoveAndDispose(ref this.OutputRenderTarget); Disposer.RemoveAndDispose(ref this.RenderTarget); Disposer.RemoveAndDispose(ref this.RenderTarget1); Disposer.RemoveAndDispose(ref this.RenderTarget2); Disposer.RemoveAndDispose(ref this.ShaderTargetView); Disposer.RemoveAndDispose(ref this.ShaderTarget1View); Disposer.RemoveAndDispose(ref this.ShaderTarget2View); Disposer.RemoveAndDispose(ref this.DepthStencil); width = Math.Max((int)base.ActualWidth, 100); height = Math.Max((int)base.ActualHeight, 100); SampleDescription quality = new SampleDescription(1, 0); Texture2DDescription colordesc = new Texture2DDescription { BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource, Format = Format.B8G8R8A8_UNorm, Width = (int)width, Height = (int)height, MipLevels = 1, SampleDescription = quality, Usage = ResourceUsage.Default, OptionFlags = ResourceOptionFlags.Shared, CpuAccessFlags = CpuAccessFlags.None, ArraySize = 1 }; Texture2DDescription depthdesc = new Texture2DDescription { BindFlags = BindFlags.DepthStencil, Format = Format.D32_Float_S8X24_UInt, Width = (int)width, Height = (int)height, MipLevels = 1, SampleDescription = quality, Usage = ResourceUsage.Default, OptionFlags = ResourceOptionFlags.None, CpuAccessFlags = CpuAccessFlags.None, ArraySize = 1 }; this.RenderTarget = new Texture2D(this.Device, colordesc); this.OutputRenderTarget = new Texture2D(this.Device, colordesc); this.DepthStencil = new Texture2D(this.Device, depthdesc); RenderTarget1 = new Texture2D(this.Device, new Texture2DDescription { ArraySize = 1, BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource, CpuAccessFlags = CpuAccessFlags.None, Format = Format.B8G8R8A8_UNorm, Width = (int)width / 2, Height = (int)height / 2, MipLevels = 1, OptionFlags = ResourceOptionFlags.Shared, SampleDescription = new SampleDescription(1, 0), Usage = ResourceUsage.Default }); RenderTarget2 = new Texture2D(this.Device, new Texture2DDescription { ArraySize = 1, BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource, CpuAccessFlags = CpuAccessFlags.None, Format = Format.B8G8R8A8_UNorm, Width = (int)width / 2, Height = (int)height / 2, MipLevels = 1, OptionFlags = ResourceOptionFlags.Shared, SampleDescription = new SampleDescription(1, 0), Usage = ResourceUsage.Default }); BlendStateDescription stateDesc = new BlendStateDescription { SourceBlend = BlendOption.One, DestinationBlend = BlendOption.One, BlendOperation = BlendOperation.Add, SourceAlphaBlend = BlendOption.One, DestinationAlphaBlend = BlendOption.One, AlphaBlendOperation = BlendOperation.Add }; stateDesc.IsBlendEnabled[0] = true; stateDesc.RenderTargetWriteMask[0] = ColorWriteMaskFlags.All; stateDesc.IsAlphaToCoverageEnabled = false; BlendingState = new BlendState(Device, ref stateDesc); this.DepthStencilView = new DepthStencilView(this.Device, this.DepthStencil); this.RenderTargetView = new RenderTargetView(this.Device, this.RenderTarget); this.RenderTarget1View = new RenderTargetView(this.Device, this.RenderTarget1); this.RenderTarget2View = new RenderTargetView(this.Device, this.RenderTarget2); this.OutputRenderTargetView = new RenderTargetView(this.Device, this.OutputRenderTarget); this.ShaderTargetView = new ShaderResourceView(this.Device, this.RenderTarget); this.ShaderTarget1View = new ShaderResourceView(this.Device, this.RenderTarget1); this.ShaderTarget2View = new ShaderResourceView(this.Device, this.RenderTarget2); try { this.D3DSurface.SetRenderTargetDX10(this.OutputRenderTarget); } catch { } }
public void Dispose() { Disposer.Dispose(serial); Disposer.Dispose(reader); }
protected static void DeferRestoreStateOnLevel( Disposer disposer, DataGridContext dataGridContext ) { ToggleColumnSortCommand.ThrowIfNull( disposer, "disposer" ); ToggleColumnSortCommand.ThrowIfNull( dataGridContext, "dataGridContext" ); var parentDataGridContext = dataGridContext.ParentDataGridContext; // Defer the RestoreState of each DataGridContext of the same level // to ensure all the DataGridContext will be correctly restored once // all of them are completely resorted if( parentDataGridContext != null ) { foreach( var childContext in parentDataGridContext.GetChildContexts() ) { disposer.Add( childContext.DeferRestoreState(), DisposableType.DeferRestoreState ); } } }
public DisposerEditViewModel(Disposer disposer, IWasteRepository repository, IContainerViewModelFactory containerViewModelFactory, Action removeDisposerAction) : base(disposer, repository, containerViewModelFactory) { DisplayName = TranslationProvider.Translate("TitleDisposerEditViewModel"); m_RemoveDisposer = removeDisposerAction; }
public ExampleBase() { // IDisposable を直接継承するクラスでは、マネージドリソース及び // アンマネージドリソースの解放を行う private メソッドを用意して // Disposer コンストラクタに渡す。 disposer = new Disposer(this, ReleaseManaged, ReleaseUnmanaged); }
/// <summary> /// Must release swapchain at last after all its created resources have been released. /// </summary> public override void DisposeAndClear() { base.DisposeAndClear(); Disposer.RemoveAndDispose(ref swapChain); }
public static IDisposable Create(Func <IDictionary <string, object>, Task> app, IDictionary <string, object> properties) { if (app == null) { throw new ArgumentNullException("app"); } if (properties == null) { throw new ArgumentNullException("properties"); } var capabilities = properties.Get <IDictionary <string, object> >(OwinKeys.ServerCapabilitiesKey) ?? new Dictionary <string, object>(); var addresses = properties.Get <IList <IDictionary <string, object> > >("host.Addresses") ?? new List <IDictionary <string, object> >(); var servers = new List <INowinServer>(); var endpoints = new List <IPEndPoint>(); foreach (var address in addresses) { var builder = ServerBuilder.New().SetOwinApp(app); int port; if (!int.TryParse(address.Get <string>("port"), out port)) { throw new ArgumentException("port must be number from 0 to 65535"); } builder.SetPort(port); builder.SetOwinCapabilities(capabilities); var certificate = address.Get <X509Certificate>("certificate"); if (certificate != null) { builder.SetCertificate(certificate); } servers.Add(builder.Build()); endpoints.Add(new IPEndPoint(IPAddress.Loopback, port)); } var disposer = new Disposer(servers.Cast <IDisposable>().ToArray()); try { foreach (var nowinServer in servers) { nowinServer.Start(); } // This is workaround to Windows Server 2012 issue by calling ReadLine after AcceptAsync, by making one bogus connection this problem goes away foreach (var ipEndPoint in endpoints) { var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); socket.Connect(ipEndPoint); socket.Close(); } } catch (Exception) { disposer.Dispose(); throw; } return(disposer); }
private bool ToggleColumnSort(ColumnBase column, bool resetSort) { ToggleColumnSortCommand.ThrowIfNull(column, "column"); this.ValidateToggleColumnSort(); using (var synchronizationContext = this.StartSynchronizing(this.GetSortDescriptionsSyncContext())) { this.ValidateSynchronizationContext(synchronizationContext); using (var disposer = new Disposer()) { this.DeferRestoreStateOnLevel(disposer); // This will ensure that all DataGridCollectionViews mapped to the SortDescriptions collection will only refresh their sorting once! var sortDescriptions = this.SortDescriptions; disposer.Add(this.DeferResortHelper(sortDescriptions), DisposableType.DeferResort); var newSortDirection = ToggleColumnSortCommand.GetNextSortDirection(column.SortDirection); string columnName = column.FieldName; int insertionIndex; if ((resetSort) && ((column.SortIndex == -1) || (sortDescriptions.Count > 1))) { insertionIndex = 0; if (sortDescriptions.Count > 0) { sortDescriptions.Clear(); } Debug.Assert(sortDescriptions.Count == 0); } else { for (insertionIndex = 0; insertionIndex < sortDescriptions.Count; insertionIndex++) { if (sortDescriptions[insertionIndex].PropertyName == columnName) { break; } } } if (insertionIndex < sortDescriptions.Count) { if (newSortDirection == SortDirection.None) { sortDescriptions.RemoveAt(insertionIndex); } else { sortDescriptions[insertionIndex] = new SortDescription(columnName, ToggleColumnSortCommand.Convert(newSortDirection)); } } else if (newSortDirection != SortDirection.None) { sortDescriptions.Add(new SortDescription(columnName, ToggleColumnSortCommand.Convert(newSortDirection))); } } } return(true); }
public ActionResult Timer(long? timestamp) { string title = null; try { byte[] output = null; using (MemoryStream stream = new MemoryStream()) { int repeatCount = 0; //repeat forever DateTime end = Epoch.AddSeconds(timestamp ?? 0); title = end.ToString(); TimeSpan remaining = end - DateTime.UtcNow; if (remaining.TotalSeconds < 0) { remaining = TimeSpan.FromSeconds(0); } if (remaining.TotalSeconds <= 60) { repeatCount = -1; //don't repeat } using (Image background = Image.FromFile(Server.MapPath(BackgroundPath))) { using (Font font = new Font(FontName, FontSize, FontBold ? FontStyle.Bold : FontStyle.Regular, GraphicsUnit.Pixel)) { using (var disposer = new Disposer()) { var target = new SynchronizeInvokeStub(); AnimatedGifEncoder encoder = new AnimatedGifEncoder(target); encoder.RepeatCount = repeatCount; encoder.OutputStream = stream; encoder.QuantizerType = GifComponents.Quantizing.QuantizerType.Octree; { int count = 0; while (remaining.TotalSeconds >= 0 && count < 60) { Bitmap bitmap = disposer.Track(new Bitmap(background)); using (Graphics g = Graphics.FromImage(bitmap)) { StringFormat format = new StringFormat(); format.Alignment = StringAlignment.Center; format.LineAlignment = StringAlignment.Center; g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit; string days, hours, minutes, seconds; if (remaining.Days > 99) { days = "--"; hours = "--"; minutes = "--"; seconds = "--"; count = 99; //causes the loop to end after this one } else { days = remaining.Days.ToString("00"); hours = remaining.Hours.ToString("00"); minutes = remaining.Minutes.ToString("00"); seconds = remaining.Seconds.ToString("00"); } g.DrawString(days, font, Brushes.White, new RectangleF(ImageX, ImageY, ImageWidth / 4, ImageHeight), format); g.DrawString(hours, font, Brushes.White, new RectangleF(ImageX + (ImageWidth / 4), ImageY, ImageWidth / 4, ImageHeight), format); g.DrawString(minutes, font, Brushes.White, new RectangleF(ImageX + (2 * ImageWidth / 4), ImageY, ImageWidth / 4, ImageHeight), format); g.DrawString(seconds, font, Brushes.White, new RectangleF(ImageX + (3 * ImageWidth / 4), ImageY, ImageWidth / 4, ImageHeight), format); g.DrawString(":", font, Brushes.White, new RectangleF(ImageX + (ImageWidth / 4) - ImageWidth / 8, ImageY, ImageWidth / 4, ImageHeight), format); g.DrawString(":", font, Brushes.White, new RectangleF(ImageX + (2 * ImageWidth / 4) - ImageWidth / 8, ImageY, ImageWidth / 4, ImageHeight), format); g.DrawString(":", font, Brushes.White, new RectangleF(ImageX + (3 * ImageWidth / 4) - ImageWidth / 8, ImageY, ImageWidth / 4, ImageHeight), format); } var frame = new GifFrame(bitmap); frame.Delay = 100; encoder.AddFrame(frame); count++; remaining = remaining.Subtract(OneSecond); } } encoder.Start(); encoder.WaitUntilDone(); } } } output = stream.ToArray(); } return new FileContentResult(output, "image/gif"); } catch { return new FilePathResult(Server.MapPath(BackgroundPath), "image/gif"); } finally { Clicky.TrackRequest(Request, ActionType.PageView, "Timer: " + title); } }
public void Dispose() { Disposer.RemoveAndDispose(ref _model); }
private IDisposable DeferResortHelper( DetailConfiguration detailConfiguration ) { ColumnSortCommand.ThrowIfNull( detailConfiguration, "detailConfiguration" ); IDisposable defer; if( this.TryDeferResort( detailConfiguration, out defer ) ) return defer; var disposer = new Disposer(); foreach( var dataGridContext in DetailConfigurationUpdateColumnSortCommand.GetDataGridContexts( detailConfiguration ) ) { disposer.Add( this.DeferResortHelper( dataGridContext.ItemsSourceCollection, dataGridContext.Items ), DisposableType.DeferResort ); } return disposer; }
//[/LockPositions] public SimWindow() : base(800, 600, GraphicsMode.Default, "Gravitational n-body simulation") { _numBodies = 256*64; const float clusterScale = 1.0f; const float velocityScale = 1.0f; _deltaTime = 0.001f; _softeningSquared = 0.00125f; _damping = 0.9995f; //[CreateWorker] _worker = Worker.CreateByFunc(Generate); //[/CreateWorker] _stopwatch = Stopwatch.StartNew(); _fpsCalcLag = 128; _frameCounter = 0; //[CreateSimulatros] _simulators = new Queue<ISimulator>(); var target = GPUModuleTarget.Worker(_worker); var simulatorGpuDynamicBlockSizeModule = new GpuDynamicSimulatorModule(target); // need dispose var simulatorGpuDynamicBlockSize64 = simulatorGpuDynamicBlockSizeModule.Create(64); var simulatorGpuDynamicBlockSize128 = simulatorGpuDynamicBlockSizeModule.Create(128); var simulatorGpuDynamicBlockSize256 = simulatorGpuDynamicBlockSizeModule.Create(256); var simulatorGpuDynamicBlockSize512 = simulatorGpuDynamicBlockSizeModule.Create(512); var simulatorGpuStaticBlockSizeModule64 = new GpuStaticSimulatorModule64(target); // need dispose var simulatorGpuStaticBlockSizeModule128 = new GpuStaticSimulatorModule128(target); // need dispose var simulatorGpuStaticBlockSizeModule256 = new GpuStaticSimulatorModule256(target); // need dispose var simulatorGpuStaticBlockSizeModule512 = new GpuStaticSimulatorModule512(target); // need dispose // First, enquene one simulator which is 256 blocksize so we can compare with C code for performance. _simulators.Enqueue(simulatorGpuStaticBlockSizeModule256); // Enqueue several dynamic block size simulators. _simulators.Enqueue(simulatorGpuDynamicBlockSize64); _simulators.Enqueue(simulatorGpuDynamicBlockSize128); _simulators.Enqueue(simulatorGpuDynamicBlockSize256); _simulators.Enqueue(simulatorGpuDynamicBlockSize512); // Enqueue several static block size simulators. _simulators.Enqueue(simulatorGpuStaticBlockSizeModule64); _simulators.Enqueue(simulatorGpuStaticBlockSizeModule128); _simulators.Enqueue(simulatorGpuStaticBlockSizeModule256); _simulators.Enqueue(simulatorGpuStaticBlockSizeModule512); // We do not enqueue any cpu simulator as it is much too slow. //_simulators.Enqueue(new CpuSimulator(_worker, _numBodies)); _disposeSimulators = () => { simulatorGpuDynamicBlockSizeModule.Dispose(); simulatorGpuStaticBlockSizeModule64.Dispose(); simulatorGpuStaticBlockSizeModule128.Dispose(); simulatorGpuStaticBlockSizeModule256.Dispose(); simulatorGpuStaticBlockSizeModule512.Dispose(); }; _simulator = _simulators.Dequeue(); //[/CreateSimulatros] //[CreateBuffers] _buffers = new uint[2]; for (var i = 0; i < _buffers.Length; i++) { _buffers[i] = 0; } GL.GenBuffers(_buffers.Length, _buffers); foreach (var buffer in _buffers) { GL.BindBuffer(BufferTarget.ArrayBuffer, buffer); GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr) (Microsoft.FSharp.Core.Operators.SizeOf<float4>()*_numBodies), IntPtr.Zero, BufferUsageHint.DynamicDraw); var size = 0; unsafe { GL.GetBufferParameter(BufferTarget.ArrayBuffer, BufferParameterName.BufferSize, &size); } if (size != Microsoft.FSharp.Core.Operators.SizeOf<float4>()*_numBodies) { throw new Exception("Pixel Buffer Object allocation failed!"); } GL.BindBuffer(BufferTarget.ArrayBuffer, 0); CUDAInterop.cuSafeCall(CUDAInterop.cuGLRegisterBufferObject(buffer)); } _resources = new IntPtr[_buffers.Length]; for (var i = 0; i < _buffers.Length; i++) { var res = IntPtr.Zero; unsafe { CUDAInterop.cuSafeCall(CUDAInterop.cuGraphicsGLRegisterBuffer(&res, _buffers[i], 0u)); } _resources[i] = res; } //[/CreateBuffers] //[FinalizeGL] _vel = _worker.Malloc<float4>(_numBodies); float4[] hpos, hvel; BodyInitializer.Initialize(new BodyInitializer3(), clusterScale, velocityScale, _numBodies, out hpos, out hvel); _worker.Scatter(hvel, _vel.Ptr, Microsoft.FSharp.Core.FSharpOption<int>.None, Microsoft.FSharp.Core.FSharpOption<int>.None); LockPos( (pos0, pos1) => _worker.Scatter(hpos, pos1, Microsoft.FSharp.Core.FSharpOption<int>.None, Microsoft.FSharp.Core.FSharpOption<int>.None)); Help(); Description(); //[/FinalizeGL] }
protected RaceChecker() { lockObject = new object(); lockRelease = new Disposer(lockObject); }
static void Main(string[] args) { ProgramTools.Setup(); var config = new Config(); config.IP = "0.0.0.0"; config.Port = 22333; config.Delay = 5000; config.Timeout = 5000; config.Root = ExecutableTools.Relative("Root"); //args will always log to stderr because daemon flag not loaded yet ExecutableTools.LogArgs(new StderrWriteLine(), args, (arg) => { ConfigTools.SetProperty(config, arg); }); AssertTools.NotEmpty(config.Root, "Missing Root path"); AssertTools.NotEmpty(config.IP, "Missing IP"); AssertTools.Ip(config.IP, "Invalid IP"); var pid = Process.GetCurrentProcess().Id; var writers = new WriteLineCollection(); if (!config.Daemon) { writers.Add(new StderrWriteLine()); Logger.TRACE = new TimedWriter(writers); } Logger.Trace("Root {0}", config.Root); var dbpath = Path.Combine(config.Root, "SharpDaemon.LiteDb"); var logpath = Path.Combine(config.Root, "SharpDaemon.Log.txt"); var eppath = Path.Combine(config.Root, "SharpDaemon.Endpoint.txt"); var downloads = Path.Combine(config.Root, "Downloads"); Directory.CreateDirectory(downloads); //creates root as well //acts like mutex for the workspace var log = new StreamWriter(logpath, true); writers.Add(new TextWriterWriteLine(log)); ExecutableTools.LogArgs(new TextWriterWriteLine(log), args); var instance = new Instance(new Instance.Args { DbPath = dbpath, RestartDelay = config.Delay, Downloads = downloads, EndPoint = new IPEndPoint(IPAddress.Parse(config.IP), config.Port), }); Stdio.SetStatus("Listening on {0}", instance.EndPoint); using (var disposer = new Disposer()) { //wrap to add to disposable count disposer.Push(new Disposable.Wrapper(log)); disposer.Push(instance); disposer.Push(() => Disposing(config.Timeout)); if (config.Daemon) { Logger.Trace("Stdin loop..."); var line = Stdio.ReadLine(); while (line != null) { Logger.Trace("> {0}", line); if ("exit!" == line) { break; } line = Stdio.ReadLine(); } Logger.Trace("Stdin closed"); } else { Logger.Trace("Stdin loop..."); var shell = instance.CreateShell(); var stream = new ShellStream(new StdoutWriteLine(), new ConsoleReadLine()); //disposer.Push(stream); //stdin.readline wont return even after close/dispose call var line = stream.ReadLine(); while (line != null) { if ("exit!" == line) { break; } Shell.ParseAndExecute(shell, stream, line); line = stream.ReadLine(); } Logger.Trace("Stdin closed"); } } Environment.Exit(0); }
/**************************************************************************************************** * ****************************************************************************************************/ public Effect(Demo demo) { _demo = demo; _disposer = new Disposer(); }
protected override void OnDispose() { Disposer.Dispose(ref _particleRenderer); base.OnDispose(); }
/// <summary> /// /// </summary> public virtual void Dispose() { Disposer.RemoveAndDispose(ref _mContext); }
private void IoDispose() { Disposer.Dispose(master); }
public void Dispose() { Disposer.Dispose(_shader); }
public override void Render(RenderContext context, DeviceContextProxy deviceContext) { if (!enableReflector) { return; } if (CreateCubeMapResources()) { RaiseInvalidateRender(); return; // Skip this frame if texture resized to reduce latency. } else if(!(IsDynamicScene || context.UpdateSceneGraphRequested || context.UpdatePerFrameRenderableRequested)) { return; } context.IsInvertCullMode = true; var camLook = Vector3.Normalize(context.Camera.LookDirection); Exception exception = null; #if TEST for (int index = 0; index < 6; ++index) #else Parallel.For(0, 6, (index) => #endif { try { var ctx = contextPool.Get(); ctx.ClearRenderTargetView(cubeRTVs[index], context.RenderHost.ClearColor); ctx.ClearDepthStencilView(cubeDSVs[index], DepthStencilClearFlags.Depth, 1, 0); ctx.SetRenderTarget(cubeDSVs[index], cubeRTVs[index]); ctx.SetViewport(ref viewport); ctx.SetScissorRectangle(0, 0, FaceSize, FaceSize); var transforms = new GlobalTransformStruct(); transforms.Projection = cubeFaceCameras.Cameras[index].Projection; transforms.View = cubeFaceCameras.Cameras[index].View; transforms.Viewport = new Vector4(FaceSize, FaceSize, 1/FaceSize, 1/FaceSize); transforms.ViewProjection = transforms.View * transforms.Projection; modelCB.Upload(ctx, ref transforms); var frustum = new BoundingFrustum(transforms.ViewProjection); //Render opaque for (int i = 0; i < context.RenderHost.PerFrameOpaqueNodes.Count; ++i) { var node = context.RenderHost.PerFrameOpaqueNodes[i]; if (node.GUID != this.GUID && !IgnoredGuid.Contains(node.GUID) && node.TestViewFrustum(ref frustum)) { node.Render(context, ctx); } } //Render particle for (int i = 0; i < context.RenderHost.PerFrameParticleNodes.Count; ++i) { var node = context.RenderHost.PerFrameParticleNodes[i]; if (node.GUID != this.GUID && !IgnoredGuid.Contains(node.GUID) && node.TestViewFrustum(ref frustum)) { node.Render(context, ctx); } } commands[index] = ctx.FinishCommandList(true); contextPool.Put(ctx); } catch(Exception ex) { exception = ex; } } #if !TEST ); #endif context.IsInvertCullMode = false; if (exception != null) { throw exception; } for (int i = 0; i < commands.Length; ++i) { if (commands[i] != null) { Device.ImmediateContext.ExecuteCommandList(commands[i], true); Disposer.RemoveAndDispose(ref commands[i]); } } deviceContext.GenerateMips(CubeMap); context.UpdatePerFrameData(true, false, deviceContext); }
private void OpenConnection(IConnection connection, string data, CancellationToken disconnectToken, Action initializeCallback, Action <Exception> errorCallback) { // If we're reconnecting add /connect to the url bool reconnecting = initializeCallback == null; var callbackInvoker = new ThreadSafeInvoker(); var requestDisposer = new Disposer(); var url = (reconnecting ? connection.Url : connection.Url + "connect") + GetReceiveQueryString(connection, data); connection.Trace(TraceLevels.Events, "SSE: GET {0}", url); HttpClient.Get(url, req => { _request = req; connection.PrepareRequest(_request); _request.Accept = "text/event-stream"; }).ContinueWith(task => { if (task.IsFaulted) { Exception exception = task.Exception.Unwrap(); if (!ExceptionHelper.IsRequestAborted(exception)) { if (errorCallback != null) { callbackInvoker.Invoke((cb, ex) => cb(ex), errorCallback, exception); } else if (reconnecting) { // Only raise the error event if we failed to reconnect connection.OnError(exception); Reconnect(connection, data, disconnectToken); } } requestDisposer.Dispose(); } else { var response = task.Result; Stream stream = response.GetStream(); var eventSource = new EventSourceStreamReader(connection, stream); bool retry = true; var esCancellationRegistration = disconnectToken.SafeRegister(state => { retry = false; ((IRequest)state).Abort(); }, _request); eventSource.Opened = () => { // If we're not reconnecting, then we're starting the transport for the first time. Trigger callback only on first start. if (!reconnecting) { callbackInvoker.Invoke(initializeCallback); } else if (connection.ChangeState(ConnectionState.Reconnecting, ConnectionState.Connected)) { // Raise the reconnect event if the connection comes back up connection.OnReconnected(); } }; eventSource.Message = sseEvent => { if (sseEvent.EventType == EventType.Data) { if (sseEvent.Data.Equals("initialized", StringComparison.OrdinalIgnoreCase)) { return; } bool timedOut; bool disconnected; TransportHelper.ProcessResponse(connection, sseEvent.Data, out timedOut, out disconnected); if (disconnected) { retry = false; connection.Disconnect(); } } }; eventSource.Closed = exception => { if (exception != null) { // Check if the request is aborted bool isRequestAborted = ExceptionHelper.IsRequestAborted(exception); if (!isRequestAborted) { // Don't raise exceptions if the request was aborted (connection was stopped). connection.OnError(exception); } } requestDisposer.Dispose(); esCancellationRegistration.Dispose(); response.Dispose(); if (AbortResetEvent != null) { AbortResetEvent.Set(); } else if (retry) { Reconnect(connection, data, disconnectToken); } }; eventSource.Start(); } }); var requestCancellationRegistration = disconnectToken.SafeRegister(state => { if (state != null) { // This will no-op if the request is already finished. ((IRequest)state).Abort(); } if (errorCallback != null) { callbackInvoker.Invoke((cb, token) => { #if NET35 || WINDOWS_PHONE cb(new OperationCanceledException(Resources.Error_ConnectionCancelled)); #else cb(new OperationCanceledException(Resources.Error_ConnectionCancelled, token)); #endif }, errorCallback, disconnectToken); } }, _request); requestDisposer.Set(requestCancellationRegistration); if (errorCallback != null) { TaskAsyncHelper.Delay(ConnectionTimeout).Then(() => { callbackInvoker.Invoke((conn, cb) => { // Abort the request before cancelling _request.Abort(); // Connection timeout occurred cb(new TimeoutException()); }, connection, errorCallback); }); } }
private void OpenConnection(IConnection connection, string data, CancellationToken disconnectToken, Action initializeCallback, Action <Exception> errorCallback) { // If we're reconnecting add /connect to the url bool reconnecting = initializeCallback == null; var callbackInvoker = new ThreadSafeInvoker(); var requestDisposer = new Disposer(); Action initializeInvoke = () => { callbackInvoker.Invoke(initializeCallback); }; var url = connection.Url + (reconnecting ? "reconnect" : "connect") + GetReceiveQueryString(connection, data); connection.Trace(TraceLevels.Events, "SSE: GET {0}", url); HttpClient.Get(url, req => { _request = req; _request.Accept = "text/event-stream"; connection.PrepareRequest(_request); }, isLongRunning: true).ContinueWith(task => { if (task.IsFaulted || task.IsCanceled) { Exception exception; if (task.IsCanceled) { exception = new OperationCanceledException(Resources.Error_TaskCancelledException); } else { exception = task.Exception.Unwrap(); } if (errorCallback != null) { callbackInvoker.Invoke((cb, ex) => cb(ex), errorCallback, exception); } else if (!_stop && reconnecting) { // Only raise the error event if we failed to reconnect connection.OnError(exception); Reconnect(connection, data, disconnectToken); } requestDisposer.Dispose(); } else { // If the disconnect token is canceled the response to the task doesn't matter. if (disconnectToken.IsCancellationRequested) { return; } var response = task.Result; Stream stream = response.GetStream(); var eventSource = new EventSourceStreamReader(connection, stream); var esCancellationRegistration = disconnectToken.SafeRegister(state => { _stop = true; ((IRequest)state).Abort(); }, _request); eventSource.Opened = () => { // This will noop if we're not in the reconnecting state if (connection.ChangeState(ConnectionState.Reconnecting, ConnectionState.Connected)) { // Raise the reconnect event if the connection comes back up connection.OnReconnected(); } }; eventSource.Message = sseEvent => { if (sseEvent.EventType == EventType.Data) { if (sseEvent.Data.Equals("initialized", StringComparison.OrdinalIgnoreCase)) { return; } bool shouldReconnect; bool disconnected; TransportHelper.ProcessResponse(connection, sseEvent.Data, out shouldReconnect, out disconnected, initializeInvoke); if (disconnected) { _stop = true; connection.Disconnect(); } } }; eventSource.Closed = exception => { if (exception != null) { // Check if the request is aborted bool isRequestAborted = ExceptionHelper.IsRequestAborted(exception); if (!isRequestAborted) { // Don't raise exceptions if the request was aborted (connection was stopped). connection.OnError(exception); } } requestDisposer.Dispose(); esCancellationRegistration.Dispose(); response.Dispose(); if (_stop) { AbortHandler.CompleteAbort(); } else if (AbortHandler.TryCompleteAbort()) { // Abort() was called, so don't reconnect } else { Reconnect(connection, data, disconnectToken); } }; eventSource.Start(); } }); var requestCancellationRegistration = disconnectToken.SafeRegister(state => { if (state != null) { // This will no-op if the request is already finished. ((IRequest)state).Abort(); } if (errorCallback != null) { callbackInvoker.Invoke((cb, token) => { #if !NET35 cb(new OperationCanceledException(Resources.Error_ConnectionCancelled, token)); #else cb(new OperationCanceledException(Resources.Error_ConnectionCancelled)); #endif }, errorCallback, disconnectToken); } }, _request); requestDisposer.Set(requestCancellationRegistration); }
private bool ToggleColumnSort( ColumnBase column, bool resetSort ) { ToggleColumnSortCommand.ThrowIfNull( column, "column" ); this.ValidateToggleColumnSort(); using( var synchronizationContext = this.StartSynchronizing( this.GetSortDescriptionsSyncContext() ) ) { this.ValidateSynchronizationContext( synchronizationContext ); using( var disposer = new Disposer() ) { this.DeferRestoreStateOnLevel( disposer ); // This will ensure that all DataGridCollectionViews mapped to the SortDescriptions collection will only refresh their sorting once! var sortDescriptions = this.SortDescriptions; disposer.Add( this.DeferResortHelper( sortDescriptions ), DisposableType.DeferResort ); var newSortDirection = ToggleColumnSortCommand.GetNextSortDirection( column.SortDirection ); string columnName = column.FieldName; int insertionIndex; if( ( resetSort ) && ( ( column.SortIndex == -1 ) || ( sortDescriptions.Count > 1 ) ) ) { insertionIndex = 0; if( sortDescriptions.Count > 0 ) { sortDescriptions.Clear(); } Debug.Assert( sortDescriptions.Count == 0 ); } else { for( insertionIndex = 0; insertionIndex < sortDescriptions.Count; insertionIndex++ ) { if( sortDescriptions[ insertionIndex ].PropertyName == columnName ) break; } } if( insertionIndex < sortDescriptions.Count ) { if( newSortDirection == SortDirection.None ) { sortDescriptions.RemoveAt( insertionIndex ); } else { sortDescriptions[ insertionIndex ] = new SortDescription( columnName, ToggleColumnSortCommand.Convert( newSortDirection ) ); } } else if( newSortDirection != SortDirection.None ) { sortDescriptions.Add( new SortDescription( columnName, ToggleColumnSortCommand.Convert( newSortDirection ) ) ); } } } return true; }
protected override void OnDispose() { base.OnDispose(); Disposer.Dispose(ref _wellMaterial); }
private Task ProcessMessages(ITransportConnection connection, Func <Task> initialize) { var disposer = new Disposer(); if (BeforeCancellationTokenCallbackRegistered != null) { BeforeCancellationTokenCallbackRegistered(); } var cancelContext = new ForeverTransportContext(this, disposer); // Ensure delegate continues to use the C# Compiler static delegate caching optimization. IDisposable registration = ConnectionEndToken.SafeRegister(state => Cancel(state), cancelContext); var lifetime = new RequestLifetime(this, _requestLifeTime); var messageContext = new MessageContext(this, lifetime, registration); if (BeforeReceive != null) { BeforeReceive(); } try { // Ensure we enqueue the response initialization before any messages are received EnqueueOperation(state => InitializeResponse((ITransportConnection)state), connection) .Catch((ex, state) => OnError(ex, state), messageContext); // Ensure delegate continues to use the C# Compiler static delegate caching optimization. IDisposable subscription = connection.Receive(LastMessageId, (response, state) => OnMessageReceived(response, state), MaxMessages, messageContext); disposer.Set(subscription); if (AfterReceive != null) { AfterReceive(); } // Ensure delegate continues to use the C# Compiler static delegate caching optimization. initialize().Then(tcs => tcs.TrySetResult(null), InitializeTcs) .Catch((ex, state) => OnError(ex, state), messageContext); } catch (OperationCanceledException ex) { InitializeTcs.TrySetCanceled(); lifetime.Complete(ex); } catch (Exception ex) { InitializeTcs.TrySetCanceled(); lifetime.Complete(ex); } return(_requestLifeTime.Task); }
public override void Dispose() { base.Dispose(); Disposer.DisposeAll(ParallaxAnimation, SampleState, TextureResources); }
private void PollingSetup(IConnection connection, string data, CancellationToken disconnectToken, PollingRequestHandler requestHandler) { // These are created new on each poll var reconnectInvoker = new ThreadSafeInvoker(); var requestDisposer = new Disposer(); requestHandler.ResolveUrl = () => { var url = connection.Url; if (connection.MessageId == null) { url += "connect"; } else if (IsReconnecting(connection)) { url += "reconnect"; } else { url += "poll"; } url += GetReceiveQueryString(connection, data); return(url); }; requestHandler.PrepareRequest += req => { connection.PrepareRequest(req); }; requestHandler.OnMessage += message => { var shouldReconnect = false; var disconnectedReceived = false; connection.Trace(TraceLevels.Messages, "LP: OnMessage({0})", message); TransportHelper.ProcessResponse(connection, message, out shouldReconnect, out disconnectedReceived); if (IsReconnecting(connection)) { // If the timeout for the reconnect hasn't fired as yet just fire the // event here before any incoming messages are processed TryReconnect(connection, reconnectInvoker); } if (shouldReconnect) { // Transition into reconnecting state connection.EnsureReconnecting(); } if (AbortResetEvent != null) { AbortResetEvent.Set(); } else if (disconnectedReceived) { connection.Disconnect(); } }; requestHandler.OnError += exception => { reconnectInvoker.Invoke(); // Transition into reconnecting state connection.EnsureReconnecting(); // Sometimes a connection might have been closed by the server before we get to write anything // so just try again and raise OnError. if (!ExceptionHelper.IsRequestAborted(exception) && !(exception is IOException)) { connection.OnError(exception); } else { // If we aborted purposely then we need to stop the request handler requestHandler.Stop(); } }; requestHandler.OnPolling += () => { // Capture the cleanup within a closure so it can persist through multiple requests TryDelayedReconnect(connection, reconnectInvoker); requestDisposer.Set(disconnectToken.SafeRegister(state => { reconnectInvoker.Invoke(); requestHandler.Stop(); }, null)); }; requestHandler.OnAfterPoll = exception => { requestDisposer.Dispose(); requestDisposer = new Disposer(); reconnectInvoker = new ThreadSafeInvoker(); if (exception != null) { // Delay polling by the error delay return(TaskAsyncHelper.Delay(ErrorDelay)); } return(TaskAsyncHelper.Empty); }; }