signed char: -127 to 127 (note, not -128 to 127; this accommodates 1's-complement platforms)unsigned char: 0 to 255- "plain"
char: -127 to 127 or 0 to 255 (depends on default char signedness) signed short: -32767 to 32767unsigned short: 0 to 65535signed int: -32767 to 32767unsigned int: 0 to 65535signed long: -2147483647 to 2147483647unsigned long: 0 to 4294967295signed long long: -9223372036854775807 to 9223372036854775807unsigned long long: 0 to 18446744073709551615
пятница, 29 ноября 2013 г.
C++ Types
пятница, 15 ноября 2013 г.
Blocking Collection
http://msdn.microsoft.com/en-us/library/dd460684(v=vs.110).aspx
http://msdn.microsoft.com/ru-ru/library/dd460684(v=vs.110).aspx
How to: Use ForEach to Remove Items in a BlockingCollection
In addition to taking items from a BlockingCollection<T> by using the Take and TryTake method, you can also use a foreach (For Each in Visual Basic) to remove items until adding is completed and the collection is empty. This is called a mutating enumeration or consuming enumeration because, unlike a typical foreach(For Each) loop, this enumerator modifies the source collection by removing items.
The following example shows how to remove all the items in a BlockingCollection<T> by using a foreach (For Each) loop.
namespace EnumerateBlockingCollection
{
using System;
using System.Collections.Concurrent;
using System.Diagnostics;
class Program
{
// Limit the collection size to 2000 items
// at any given time. Set itemsToProduce to >500
// to hit the limit.
const int upperLimit = 1000;
// Adjust this number to see how it impacts
// the producing-consuming pattern.
const int itemsToProduce = 100;
static BlockingCollection<long> collection = new BlockingCollection<long>(upperLimit);
// Variables for diagnostic output only.
static Stopwatch sw = new Stopwatch();
static int totalAdditions = 0;
// Counter for synchronizing producers.
static int producersStillRunning = 2;
static void Main(string[] args)
{
// Start the stopwatch.
sw.Start();
// Queue the Producer threads. Store in an array
// for use with ContinueWhenAll
Task[] producers = new Task[2];
producers[0] = Task.Run(() => RunProducer("A", 0));
producers[1] = Task.Run(() => RunProducer("B", itemsToProduce));
// Create a cleanup task that will call CompleteAdding after
// all producers are done adding items.
Task cleanup = Task.Factory.ContinueWhenAll(producers, (p) => collection.CompleteAdding());
// Queue the Consumer thread. Put this call
// before Parallel.Invoke to begin consuming as soon as
// the producers add items.
Task.Run(() => RunConsumer());
// Keep the console window open while the
// consumer thread completes its output.
Console.ReadKey();
}
static void RunProducer(string ID, int start)
{
int additions = 0;
for (int i = start; i < start + itemsToProduce; i++)
{
// The data that is added to the collection.
long ticks = sw.ElapsedTicks;
// Display additions and subtractions.
Console.WriteLine("{0} adding tick value {1}. item# {2}", ID, ticks, i);
if(!collection.IsAddingCompleted)
collection.Add(ticks);
// Counter for demonstration purposes only.
additions++;
// Uncomment this line to
// slow down the producer threads ing.
Thread.SpinWait(100000);
}
Interlocked.Add(ref totalAdditions, additions);
Console.WriteLine("{0} is done adding: {1} items", ID, additions);
}
static void RunConsumer()
{
// GetConsumingEnumerable returns the enumerator for the
// underlying collection.
int subtractions = 0;
foreach (var item in collection.GetConsumingEnumerable())
{
Console.WriteLine("Consuming tick value {0} : item# {1} : current count = {2}",
item.ToString("D18"), subtractions++, collection.Count);
}
Console.WriteLine("Total added: {0} Total consumed: {1} Current count: {2} ",
totalAdditions, subtractions, collection.Count());
sw.Stop();
Console.WriteLine("Press any key to exit");
}
}
}
This example uses a foreach loop with the BlockingCollection<T>.GetConsumingEnumerable method in the consuming thread, which causes each item to be removed from the collection as it is enumerated. System.Collections.Concurrent.BlockingCollection<T> limits the maximum number of items that are in the collection at any time. Enumerating the collection in this way blocks the consumer thread if no items are available or if the collection is empty. In this example blocking is not a concern because the producer thread adds items faster than they can be consumed.
There is no guarantee that the items are enumerated in the same order in which they are added by the producer threads.
To enumerate the collection without modifying it, just use foreach (For Each) without the GetConsumingEnumerable method. However, it is important to understand that this kind of enumeration represents a snapshot of the collection at a precise point in time. If other threads are adding or removing items concurrently while you are executing the loop, then the loop might not represent the actual state of the collection.
In addition to taking items from a BlockingCollection<T> by using the Take and TryTake method, you can also use a foreach (For Each in Visual Basic) to remove items until adding is completed and the collection is empty. This is called a mutating enumeration or consuming enumeration because, unlike a typical foreach(For Each) loop, this enumerator modifies the source collection by removing items.
The following example shows how to remove all the items in a BlockingCollection<T> by using a foreach (For Each) loop.
namespace EnumerateBlockingCollection { using System; using System.Collections.Concurrent; using System.Diagnostics; class Program { // Limit the collection size to 2000 items // at any given time. Set itemsToProduce to >500 // to hit the limit. const int upperLimit = 1000; // Adjust this number to see how it impacts // the producing-consuming pattern. const int itemsToProduce = 100; static BlockingCollection<long> collection = new BlockingCollection<long>(upperLimit); // Variables for diagnostic output only. static Stopwatch sw = new Stopwatch(); static int totalAdditions = 0; // Counter for synchronizing producers. static int producersStillRunning = 2; static void Main(string[] args) { // Start the stopwatch. sw.Start(); // Queue the Producer threads. Store in an array // for use with ContinueWhenAll Task[] producers = new Task[2]; producers[0] = Task.Run(() => RunProducer("A", 0)); producers[1] = Task.Run(() => RunProducer("B", itemsToProduce)); // Create a cleanup task that will call CompleteAdding after // all producers are done adding items. Task cleanup = Task.Factory.ContinueWhenAll(producers, (p) => collection.CompleteAdding()); // Queue the Consumer thread. Put this call // before Parallel.Invoke to begin consuming as soon as // the producers add items. Task.Run(() => RunConsumer()); // Keep the console window open while the // consumer thread completes its output. Console.ReadKey(); } static void RunProducer(string ID, int start) { int additions = 0; for (int i = start; i < start + itemsToProduce; i++) { // The data that is added to the collection. long ticks = sw.ElapsedTicks; // Display additions and subtractions. Console.WriteLine("{0} adding tick value {1}. item# {2}", ID, ticks, i); if(!collection.IsAddingCompleted) collection.Add(ticks); // Counter for demonstration purposes only. additions++; // Uncomment this line to // slow down the producer threads ing. Thread.SpinWait(100000); } Interlocked.Add(ref totalAdditions, additions); Console.WriteLine("{0} is done adding: {1} items", ID, additions); } static void RunConsumer() { // GetConsumingEnumerable returns the enumerator for the // underlying collection. int subtractions = 0; foreach (var item in collection.GetConsumingEnumerable()) { Console.WriteLine("Consuming tick value {0} : item# {1} : current count = {2}", item.ToString("D18"), subtractions++, collection.Count); } Console.WriteLine("Total added: {0} Total consumed: {1} Current count: {2} ", totalAdditions, subtractions, collection.Count()); sw.Stop(); Console.WriteLine("Press any key to exit"); } } }
This example uses a foreach loop with the BlockingCollection<T>.GetConsumingEnumerable method in the consuming thread, which causes each item to be removed from the collection as it is enumerated. System.Collections.Concurrent.BlockingCollection<T> limits the maximum number of items that are in the collection at any time. Enumerating the collection in this way blocks the consumer thread if no items are available or if the collection is empty. In this example blocking is not a concern because the producer thread adds items faster than they can be consumed.
There is no guarantee that the items are enumerated in the same order in which they are added by the producer threads.
To enumerate the collection without modifying it, just use foreach (For Each) without the GetConsumingEnumerable method. However, it is important to understand that this kind of enumeration represents a snapshot of the collection at a precise point in time. If other threads are adding or removing items concurrently while you are executing the loop, then the loop might not represent the actual state of the collection.
четверг, 7 ноября 2013 г.
Ticks in long to DateTime
http://stackoverflow.com/questions/1129410/format-from-ticks-to-date
DateTime date = new DateTime(long.Parse(logText));
Or
DateTime logDate = new DateTime(logText);
DateTime date = new DateTime(long.Parse(logText));OrDateTime logDate = new DateTime(logText);вторник, 5 ноября 2013 г.
Task.Run - Method
http://msdn.microsoft.com/en-us/library/hh195051(v=vs.110).aspx
using System; using System.Collections.Concurrent; using System.Collections.Generic; using System.IO; using System.Threading.Tasks; public class Example { public static void Main() { var list = new ConcurrentBag<string>(); string[] dirNames = { ".", ".." }; List<Task> tasks = new List<Task>(); foreach (var dirName in dirNames) { Task t = Task.Run( () => { foreach(var path in Directory.GetFiles(dirName)) list.Add(path); } ); tasks.Add(t); } Task.WaitAll(tasks.ToArray()); foreach (Task t in tasks) Console.WriteLine("Task {0} Status: {1}", t.Id, t.Status); Console.WriteLine("Number of files read: {0}", list.Count); } } // The example displays output like the following: // Task 1 Status: RanToCompletion // Task 2 Status: RanToCompletion // Number of files read: 23
async, await
http://stackoverflow.com/questions/14455293/async-and-await
The following Windows Forms example illustrates the use of await in an async method, WaitAsynchronouslyAsync. Contrast the behavior of that method with the behavior of WaitSynchronously. Without an await operator applied to a task, WaitSynchronously runs synchronously despite the use of the async modifier in its definition and a call to Thread.Sleep in its body.
private async void button1_Click(object sender, EventArgs e)
{
// Call the method that runs asynchronously.
string result = await WaitAsynchronouslyAsync();
// Call the method that runs synchronously.
//string result = await WaitSynchronously ();
// Display the result.
textBox1.Text += result;
}
// The following method runs asynchronously. The UI thread is not
// blocked during the delay. You can move or resize the Form1 window
// while Task.Delay is running.
public async Task<string> WaitAsynchronouslyAsync()
{
await Task.Delay(10000);
return "Finished";
}
// The following method runs synchronously, despite the use of async.
// You cannot move or resize the Form1 window while Thread.Sleep
// is running because the UI thread is blocked.
public async Task<string> WaitSynchronously()
{
// Add a using directive for System.Threading.
Thread.Sleep(10000);
return "Finished";
}async await
http://habrahabr.ru/post/162353/
12 декабря 2012 в 16:07Использование async и await в C# — лучшие практикиперевод tutorial
Подписаться на:
Сообщения (Atom)