public void Parallel() { using (var options = new StreamOptions()) using (var eventStream = new EventStream(options)) { var tasks = new List<Task>(); for (int i = 0; i < 10; i++) { tasks.Add(Task.Factory.StartNew(() => { for (int j = 0; j < 5; j++) { eventStream.AppendAsync(new RavenJObject { { "counter", i +"-" + j } }).Wait(); } })); } foreach (var task in tasks) { while (task.IsCompleted == false && task.IsFaulted == false) { Thread.Sleep(100); } } Assert.Equal(50, eventStream.EventCount); } }
public void AndGetRightCount_Parallel() { using (var options = new StreamOptions()) using (var eventStream = new EventStream(options)) { var tasks = new List<Task>(); for (int x = 0; x < 3; x++) { for (int i = 0; i < 10; i++) { tasks.Add(Task.Factory.StartNew(() => { for (int j = 0; j < 5; j++) { eventStream.AppendAsync(new RavenJObject { { "counter", i + "-" + j } }).Wait(); } })); } foreach (var task in tasks) { while (task.IsCompleted == false && task.IsFaulted == false) { Thread.Sleep(100); } } eventStream.FlushMemTableToFiskAsync(Etag.Empty).Wait(); eventStream.FlushingMemTable.Wait(); } Assert.Equal(150, eventStream.EventCount); } }
public void CanRestart() { using (var options = new StreamOptions { Storage = new FileSystemLowLevelStorage("data") }) { using (var eventStream = new EventStream(options)) { for (int i = 0; i < 15; i++) { eventStream.AppendAsync(new RavenJObject { { "counter", i } }).Wait(); } eventStream.FlushMemTableToFiskAsync(Etag.Empty).Wait(); eventStream.FlushingMemTable.Wait(); } using (var eventStream = new EventStream(options)) { Assert.Equal(15, eventStream.EventCount); int x = 0; foreach (var it in eventStream.ReadFrom(Etag.Empty)) { Assert.Equal(x++, it.Value<int>("counter")); } } } }
public TempFile(string text = null, string extension = ".tmp", StreamOptions streamOptions = StreamOptions.None) { FileName = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()); FileName = Path.ChangeExtension(FileName, extension); if (null != text) { FileUtility.Save(FileName, text, streamOptions); } }
public void Sequence() { using (var options = new StreamOptions()) using (var eventStream = new EventStream(options)) { for (int i = 0; i < 5; i++) { eventStream.AppendAsync(new RavenJObject {{"counter", i}}).Wait(); } Assert.Equal(5, eventStream.EventCount); } }
public void AndGetRightCount_Sequence() { using (var options = new StreamOptions()) using (var eventStream = new EventStream(options)) { for (int i = 0; i < 15; i++) { eventStream.AppendAsync(new RavenJObject { { "counter", i } }).Wait(); } var list = eventStream.ReadFrom(Etag.Empty).ToList(); Assert.Equal(15, list.Count); } }
public void AndGetRightCount_Sequence() { using (var options = new StreamOptions()) using (var eventStream = new EventStream(options)) { for (int i = 0; i < 15; i++) { eventStream.AppendAsync(new RavenJObject {{"counter", i}}).Wait(); } eventStream.FlushMemTableToFiskAsync(Etag.Empty).Wait(); eventStream.FlushingMemTable.Wait(); Assert.Equal(15, eventStream.EventCount); } }
public XDocument Load(string fileName, StreamOptions streamOptions = StreamOptions.None) { return FileUtility.Load(fileName, fileStream => { using (var xmlReader = (null == _xmlReaderSettings) ? XmlReader.Create(fileStream) : XmlReader.Create(fileStream, _xmlReaderSettings)) { try { return XDocument.Load(xmlReader); } catch (XmlSchemaValidationException e) { var message = string.Format("{0}({1},{2}): {3}", fileName, e.LineNumber, e.LinePosition, e.Message); throw new XmlLoaderException(message, e); } } }, streamOptions); }
public void AndReadContentsProperly() { using (var options = new StreamOptions()) using (var eventStream = new EventStream(options)) { for (int i = 0; i < 15; i++) { eventStream.AppendAsync(new RavenJObject { { "counter", i } }).Wait(); } int x = 0; foreach (var item in eventStream.ReadFrom(Etag.Empty)) { var value = item.Value<int>("counter"); Assert.Equal(x++, value); } } }
public void StartCaptureStreaming(SearchParameters parameters) { StreamOptions options = new StreamOptions(); options.Track.Add(parameters.SearchKey); this._stopSearch = false; TwitterStream stream = new TwitterStream(tokens, "RTSearch (Dev)", options); IAsyncResult result = stream.StartPublicStream( StreamStopped, NewTweet, DeletedTweet, OtherEvent ); while (!this._stopSearch) { } stream.EndStream(StopReasons.StoppedByRequest, "Stop by user"); }
public static Stream GetWritableStream(Stream stream, string fileNameForIv, string password, StreamOptions streamOptions) { if (!IsEncryption(streamOptions)) throw new ArgumentException(); if (string.IsNullOrEmpty(password)) throw new ArgumentException("No password is specified."); if (StreamOptions.Encryption == (streamOptions & StreamOptions.Encryption)) { stream = Encrypt(stream, password); } else if (StreamOptions.Encryption2 == (streamOptions & StreamOptions.Encryption2)) { stream = Encrypt2(stream, password); } else if (StreamOptions.Encryption3 == (streamOptions & StreamOptions.Encryption3)) { stream = Encrypt3(stream, fileNameForIv, password); } else { throw new ApplicationException("never reach here"); } return stream; }
/// <summary> /// Starts collecting the twitter data /// </summary> /// <param name="track">Tilde delimeted list of items to track</param> /// <returns></returns> public void StartCollecting(string userAgent, string track, bool includeRawJsonCallback) { #region Prepare Auth Tokens for Twitter OAuthTokens tokens = new OAuthTokens() { ConsumerKey = ConsumerKey, ConsumerSecret = ConsumerSharedSecret, AccessToken = OAuthToken, AccessTokenSecret = OAuthTokenSecret }; #endregion #region Set up items we want to track StreamOptions options = new StreamOptions(); string[] trackItems = track.Split('~'); foreach (string trackItem in trackItems) { options.Track.Add(trackItem); } #endregion stream = new TwitterStream(tokens, userAgent, options); if (includeRawJsonCallback) { stream.StartUserStream(StreamInit, StreamStopped, NewTweet, DeletedTweet, NewDirectMessage, DeletedDirectMessage, OtherEvent, RawJson); } else { stream.StartUserStream(StreamInit, StreamStopped, NewTweet, DeletedTweet, NewDirectMessage, DeletedDirectMessage, OtherEvent, null); } }
public static int CreateTypedStream(ExecutionContext context, object[] values, out object[] inlineParameters) { inlineParameters = EmptyParameters; if (values.Length > 3 || values.Length < 2) { context.Error.WriteLine("Invalid syntax: CreateTypedStream NodePath TypedStream [Flags]"); return(-1); } string path = values[0].ToString(); Type type = type = Type.GetType(values[1].ToString()); StreamOptions options = StreamOptions.None; if (type == null) { context.Error.WriteLine("Type '{0}' not resolved.", values[1].ToString()); return(-1); } if (values.Length > 2) { options = (StreamOptions)Enum.Parse(typeof(StreamOptions), values[2].ToString()); } Node <object> node = context.ShellApp.WorkingDirectory.Find(path); if (node == null) { context.Error.WriteLine("Path '{0}' does not exist", path); return(-1); } node.AddTypedStream(type, options); return(1); }
static void Main(string[] args) { Console.BufferWidth = 100; Console.WindowWidth = 100; StreamOptions options = new StreamOptions(); options.Track.Add("#tallycc"); options.Track.Add("tallycc"); options.Track.Add("#tallycodecamp"); options.Track.Add("tallycodecamp"); TwitterStream stream = new TwitterStream( tokens, "Tallahassee CodeCamp2001 Example Application", options); Console.WriteLine("The stream is starting ..."); stream.StartUserStream( StreamInit, StreamStopped, NewTweet, DeletedTweet, NewDirectMessage, DeletedDirectMessage, OtherEvent, RawJson); //optional Console.WriteLine("The stream has started. Press any key to stop."); Console.ReadKey(); Console.WriteLine("Stopping the stream ..."); stream.EndStream(StopReasons.StoppedByRequest, "I'm stopping the stream."); Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
public void Test_GettersSetters() { const LogLevel level = LogLevel.Critical; var exception = new Exception("test-message"); var streamMessage1 = new StreamMessage(); var streamMessage2 = new StreamMessage(); var messages = new List <StreamMessage> { streamMessage1, streamMessage2 }; var options = new StreamOptions { Exception = exception, Level = level, Messages = messages }; Assert.Same(exception, options.Exception); Assert.Equal(level, options.Level); Assert.NotNull(options.Messages); Assert.Equal(2, options.Messages.Count()); Assert.Same(messages, options.Messages); Assert.Contains(streamMessage1, options.Messages); Assert.Contains(streamMessage2, options.Messages); }
/// <summary> /// Initializes a new instance of the <see cref="MemoryTypedStream"/> class. /// </summary> /// <param name="type">The type.</param> /// <param name="op">The options.</param> public MemoryTypedStream(string type, StreamOptions op) { this.type = type; this.options = op; }
private static void DoStream(StreamOptions x) { Console.WriteLine($"Streaming called with {x.NumberOfEvents} events, emitting to {x.EventHubConnectionString}."); var client = EventHubClient.CreateFromConnectionString(x.EventHubConnectionString); var info = client.GetRuntimeInformationAsync(); info.Wait(); // we will create as many threads as there are paritions, and just send all partitions data var threads = new Dictionary <string, SenderInfo>(); var countPerPartition = Math.Round((x.NumberOfEvents / info.Result.PartitionCount), 0); foreach (var partitionId in info.Result.PartitionIds) { threads.Add(partitionId, CreatePartitionSender(countPerPartition, x, partitionId, client.CreatePartitionSender(partitionId))); } ManualResetEvent monitoringEvent = new ManualResetEvent(false); // start monitoring thread new Thread(() => { var s = new StringBuilder(); foreach (var tx in threads.Values) { s.Append(tx.PartitionId.PadRight(PADDING_WIDTH)); } s.Append("total".PadRight(PADDING_WIDTH)); Console.WriteLine(s.ToString()); s.Clear(); Console.WriteLine("".PadRight(PADDING_WIDTH * threads.Count, '_')); while (!monitoringEvent.WaitOne(500)) { double total = 0; foreach (var tx in threads.Values) { total = total + tx.SendCount; s.Append(tx.SendCount.ToString().PadRight(PADDING_WIDTH)); } s.Append(total.ToString().PadRight(PADDING_WIDTH)); Console.WriteLine(s.ToString()); s.Clear(); } }).Start(); ManualResetEvent.WaitAll(threads.Select(y => y.Value.Event).ToArray()); monitoringEvent.Set(); Console.WriteLine("Finished on all threads."); }
private static void 複数の暗号化オプションは指定できない(StreamOptions streamOptions) { var comb = new [] { StreamOptions.Encryption | StreamOptions.Encryption2, StreamOptions.Encryption3 | StreamOptions.Encryption2, StreamOptions.Encryption3 | StreamOptions.Encryption, StreamOptions.Encryption | StreamOptions.Encryption2 | StreamOptions.Encryption3, }; if (comb.Any(x => x == (streamOptions & x))) { throw new ArgumentException("StreamOptions.Encryption and StreamOptions.Encryption2 and StreamOptions.Encryption3 must not be specified at the same time."); } }
public Node <Object> Create(string path, Type t, StreamOptions flags) { return(Root.Create(path, t, flags)); }
/// <summary> /// Creates the new database. /// </summary> /// <param name="name">The name.</param> /// <param name="type">The type of default stream.</param> /// <param name="ops">The options of default stream.</param> /// <returns></returns> public static MemoryDatabase CreateNewDatabase(string name, Type type, StreamOptions ops) { return(new MemoryDatabase(name, type.FullName, ops)); }
public IDriverNode CreateNewVersion(string defaultType, StreamOptions flags) { Operations.CreateNewVersion op = new Operations.CreateNewVersion(commonAddress, defaultType, flags); journal.Execute(op); return(new PhysicalNode(name, commonAddress, op.Version, journal)); }
public CreateStreamParameters(int aport, int vport) { this.options_ = new StreamOptions(aport, vport); }
// Static members public static bool IsEncryption(StreamOptions streamOptions) { 複数の暗号化オプションは指定できない(streamOptions); var x = StreamOptions.Encryption | StreamOptions.Encryption2 | StreamOptions.Encryption3; return 0 != (streamOptions & x); }
public static StreamInitIQ BuildDefaultStreamInitResult(StreamOptions choosenoption) { StreamInitIQ q = new StreamInitIQ(StreamInitIQType.Result); q.sid = null; q.mimetype = null; q.StreamOptions = choosenoption; return q; }
public override void ParseInnerXML(System.Xml.Linq.XElement elem) { XElement si = elem.FirstNode as XElement; if (si == null) return; if (si.Name != "{http://jabber.org/protocol/si}si") return; if (si.Attribute("id") != null) sid = si.Attribute("id").Value; if (si.Attribute("mime-type") != null) mimetype = si.Attribute("mime-type").Value; if (si.Attribute("profile") != null) profile = si.Attribute("profile").Value; StreamOptions = StreamOptions.none; foreach (XElement nextelem in si.Descendants()) { if (nextelem.Name == "{http://jabber.org/protocol/si/profile/file-transfer}file") { if (nextelem.Attribute("name") != null) filename = nextelem.Attribute("name").Value; if (nextelem.Attribute("size") != null) filesize = Convert.ToInt32(nextelem.Attribute("size").Value); if (nextelem.Attribute("hash") != null) filehash = nextelem.Attribute("hash").Value; if (nextelem.Attribute("date") != null) filedate = nextelem.Attribute("date").Value; if (nextelem.Element("{http://jabber.org/protocol/si/profile/file-transfer}desc") != null) filedesc = nextelem.Element("{http://jabber.org/protocol/si/profile/file-transfer}desc").Value; } else if (nextelem.Name == "{http://jabber.org/protocol/feature-neg}feature") { XElement x = nextelem.Element("{jabber:x:data}x"); if (x != null) { if (x.Attribute("type") != null) { if (x.Attribute("type").Value == "form") StreamInitIQType = StreamInitIQType.Offer; else if (x.Attribute("type").Value == "submit") StreamInitIQType = StreamInitIQType.Result; } XElement field = x.Element("{jabber:x:data}field"); if (field != null) { /// This may work for both form and submits, because the values are there in both cases, just wrapped in an option in form foreach (XElement nextopt in field.Descendants("{jabber:x:data}value")) { if (nextopt.Value == "http://jabber.org/protocol/bytestreams") StreamOptions |= StreamOptions.bytestreams; else if (nextopt.Value == "http://jabber.org/protocol/ibb") StreamOptions |= StreamOptions.ibb; } } } } } base.ParseInnerXML(elem); }
public IDriverNode CreateNewVersion(string defaultType, StreamOptions flags) { throw new NotSupportedException(); }
public void AddTypedStream(string type, StreamOptions flags) { throw new NotSupportedException(); }
public IDriverNode CreateChild(string name, string defaultType, StreamOptions flags) { throw new InvalidOperationException("Host file does not support children."); }
/// <summary> /// Performs the actions that this command implements. /// </summary> internal override void ExecuteInternal() { var m = Manager.MediaCore; if (m.IsDisposed || m.State.IsOpen || m.State.IsOpening) { return; } try { // TODO: Sometimes when the stream can't be read, the sample player stays as if it were trying to open // until the interrupt timeout occurs but and the Real-Time Clock continues. Strange behavior. Investigate more. // Signal the initial state m.State.ResetMediaProperties(); m.State.Source = Source; m.State.IsOpening = true; // Register FFmpeg libraries if not already done if (FFInterop.Initialize(MediaEngine.FFmpegDirectory, MediaEngine.FFmpegLoadModeFlags)) { // Set the folders and lib identifiers MediaEngine.FFmpegDirectory = FFInterop.LibrariesPath; MediaEngine.FFmpegLoadModeFlags = FFInterop.LibraryIdentifiers; // Log an init message m.Log(MediaLogMessageType.Info, $"{nameof(FFInterop)}.{nameof(FFInterop.Initialize)}: FFmpeg v{ffmpeg.av_version_info()}"); } // Create the stream container // the async protocol prefix allows for increased performance for local files. var streamOptions = new StreamOptions(); // Convert the URI object to something the Media Container understands var mediaUrl = Source.ToString(); try { if (Source.IsFile || Source.IsUnc) { // Set the default protocol Prefix mediaUrl = Source.LocalPath; streamOptions.ProtocolPrefix = "async"; } } catch { } // GDIGRAB: Example URI: device://gdigrab?desktop if (string.IsNullOrWhiteSpace(Source.Scheme) == false && (Source.Scheme.Equals("format") || Source.Scheme.Equals("device")) && string.IsNullOrWhiteSpace(Source.Host) == false && string.IsNullOrWhiteSpace(streamOptions.Input.ForcedInputFormat) && string.IsNullOrWhiteSpace(Source.Query) == false) { // Update the Input format and container input URL // It is also possible to set some input options as follows: // streamOptions.Input.Add(StreamInputOptions.Names.FrameRate, "20"); streamOptions.Input.ForcedInputFormat = Source.Host; mediaUrl = Uri.UnescapeDataString(Source.Query).TrimStart('?'); m.Log(MediaLogMessageType.Info, $"Media URI will be updated. Input Format: {Source.Host}, Input Argument: {mediaUrl}"); } // Allow the stream input options to be changed m.SendOnMediaInitializing(streamOptions, mediaUrl); // Instantiate the internal container m.Container = new MediaContainer(mediaUrl, streamOptions, m); // Reset buffering properties m.State.InitializeBufferingProperties(); // Notify the user media is opening and allow for media options to be modified // Stuff like audio and video filters and stream selection can be performed here. m.SendOnMediaOpening(); // Notify Media will start opening m.Log(MediaLogMessageType.Debug, $"{nameof(OpenCommand)}: Entered"); // Side-load subtitles if requested m.PreloadSubtitles(); // Get the main container open m.Container.Open(); // Check if we have at least audio or video here if (m.Container.Components.HasAudio == false && m.Container.Components.HasVideo == false) { throw new MediaContainerException($"Unable to initialize at least one audio or video component fron the input stream."); } // Charge! We are good to go, fire up the worker threads! m.StartWorkers(); // Set the state to stopped and exit the IsOpening state m.State.IsOpening = false; m.State.UpdateMediaState(PlaybackStatus.Stop); // Raise the opened event m.SendOnMediaOpened(); } catch (Exception ex) { try { m.Container?.Dispose(); } catch { } m.DisposePreloadedSubtitles(); m.Container = null; m.State.UpdateMediaState(PlaybackStatus.Close); m.SendOnMediaFailed(ex); } finally { // Signal we are no longer in the opening state // so we can enqueue commands in the command handler m.State.IsOpening = false; m.Log(MediaLogMessageType.Debug, $"{nameof(OpenCommand)}: Completed"); } }
/// <summary> /// Adds a new typed stream to this node /// </summary> /// <typeparam name="TData">The type of the new typed stream</typeparam> /// <param name="flags">Flags of the new typed stream</param> public void AddTypedStream <TData>(StreamOptions flags) { underNode.AddTypedStream(typeof(TData), flags); }
public void PushLine <T>(StreamOptions options) => _loggerFactory.CreateLogger <T>().Log( options.Level, options.Exception, string.Join(string.Empty, options.Messages.Select(m => m.Message)));
///// <summary> ///// Checks if a wrapper is already registered for the given scheme. ///// </summary> ///// <param name="scheme">The scheme.</param> ///// <returns><c>true</c> if exists.</returns> //public static bool Exists(string scheme) //{ // return GetWrapperInternal(scheme) != null; //} /// <summary> /// Retreive the corresponding StreamWrapper respectind the scheme portion /// of the given path. If no scheme is specified, an instance of /// FileStreamWrapper is returned. /// </summary> /// <param name="ctx">Current runtime context.</param> /// <param name="scheme">The scheme portion of an URL.</param> /// <param name="options">Additional <see cref="StreamOptions"/> having effect on the wrapper retreival.</param> /// <returns>An instance of StreamWrapper to be used to open the specified file.</returns> /// <exception cref="PhpException">In case when the required wrapper can not be found.</exception> public static StreamWrapper GetWrapper(Context ctx, string scheme, StreamOptions options) { StreamWrapper wrapper = GetWrapperInternal(ctx, scheme); if (wrapper == null) { PhpException.Throw(PhpError.Notice, ErrResources.stream_bad_wrapper, scheme); // Notice: fopen(): Unable to find the wrapper "*" - did you forget to enable it when you configured PHP? in C:\Inetpub\wwwroot\php\index.php on line 23 wrapper = GetWrapperInternal(ctx, "file"); // There should always be the FileStreamWrapper present. } // EX [GetWrapper]: check for the other StreamOptions here: for example UseUrl, IgnoreUrl //if (!ScriptContext.CurrentContext.Config.FileSystem.AllowUrlFopen) //{ // if (wrapper.IsUrl) // { // PhpException.Throw(PhpError.Warning, ErrResources.url_fopen_disabled); // return null; // } //} Debug.Assert(wrapper != null); return wrapper; }
internal MemoryDatabase(string name, string type, StreamOptions ops) { rootNode = new MemoryNode(name, type, ops); }
/// <summary> /// Creates a child node in this node /// </summary> /// <typeparam name="TNew">The default type of the new node</typeparam> /// <param name="name">The name of the new node</param> /// <param name="flags">Stream flags of the default stream of the new node</param> /// <returns>The new created node</returns> public Node <TNew> Create <TNew>(string name, StreamOptions flags) { return(new Node <TNew>(underNode.CreateChild(name, typeof(TNew), flags))); }
public void AddTypedStream(string type, StreamOptions flags) { journal.Execute(new AddTypedStream(versionAddress, type, flags)); }
/// <summary> /// Creates a child node. /// </summary> /// <param name="type"></param> /// <param name="name"></param> /// <param name="flags"></param> /// <returns></returns> public Node <object> Create(string name, Type type, StreamOptions flags) { return(new Node <object>(underNode.CreateChild(name, type, flags))); }
public SensorOptions(StreamOptions depthOptions, StreamOptions rgbOptions, StreamOptions irOptions, SensorType sensorType = SensorType.OPENNI2, FubiUtils.SkeletonProfile profile = FubiUtils.SkeletonProfile.ALL, bool mirrorStreams = true, float smoothing = 0) { m_depthOptions = depthOptions; m_irOptions = irOptions; m_rgbOptions = rgbOptions; m_profile = profile; m_mirrorStreams = mirrorStreams; m_smoothing = smoothing; m_type = sensorType; }
/// <summary> /// Creates a new version in this node /// </summary> /// <typeparam name="TNew">The new version default stream type</typeparam> /// <param name="options">Stream flags of the default stream of the new version</param> /// <returns>The new node version</returns> public Node <TNew> CreateNewVersion <TNew>(StreamOptions options) { return(new Node <TNew>(underNode.CreateNewVersion(typeof(TNew), options))); }
public Node <T> Create <T>(string path, StreamOptions flags) { return(Root.Create <T>(path, flags)); }
/// <summary> /// Creates a new vesion in this node. /// </summary> /// <param name="defaultType"></param> /// <param name="options"></param> /// <returns></returns> public Node <object> CreateNewVersion(Type defaultType, StreamOptions options) { return(new Node <object>(underNode.CreateNewVersion(defaultType, options))); }
public SensorOptions(StreamOptions depthOptions, StreamOptions rgbOptions, StreamOptions irOptions, SensorType sensorType = SensorType.OPENNI2, SkeletonProfile trackingProfile = SkeletonProfile.ALL, bool mirrorStreams = true, bool registerStreams = true) { m_depthOptions = depthOptions; m_irOptions = irOptions; m_rgbOptions = rgbOptions; m_trackingProfile = trackingProfile; m_mirrorStreams = mirrorStreams; m_registerStreams = registerStreams; m_type = sensorType; }
private IAsyncResult WithHammockStreamingImpl <T>(RestClient client, RestRequest request, StreamOptions options, Action <T, TwitterResponse> action)
public void OnMediaInitializing(MediaEngine sender, StreamOptions options, string url) { // placeholder }
private static void WithHammockStreamingImpl <T>(RestClient client, RestRequest request, StreamOptions options, Action <T, TwitterResponse> action) #endif { request.StreamOptions = options; request.Method = WebMethod.Get; #if SILVERLIGHT request.AddHeader("X-User-Agent", client.UserAgent); #endif #if !WINDOWS_PHONE return (#endif client.BeginRequest(request, new RestCallback <T>((req, resp, state) => { Exception exception; var entity = TryAsyncResponse(() => { #if !SILVERLIGHT SetResponse(resp); #endif var deserializer = new JsonSerializer(); return deserializer.DeserializeJson <T>(resp.Content); }, out exception); action(entity, new TwitterResponse(resp, exception)); }))); }
public void Push <T>(StreamOptions options) { }
private IAsyncResult WithHammockPublicStreaming <T>(StreamOptions options, Action <T, TwitterResponse> action, string path) where T : class
/// <summary> /// Adds a typed stream (non-generic version). /// </summary> /// <param name="type"></param> /// <param name="flags"></param> /// <returns></returns> public void AddTypedStream(Type type, StreamOptions flags) { underNode.AddTypedStream(type, flags); }
public TempFile(string text, StreamOptions streamOptions) : this(text, ".tmp", streamOptions) { }