int bytesTotal = 0;
int bytesPerSecond = 0;
DateTime startTime = DateTime.Now;
	
do {
  bytesRead = receiveStream.Read( ... );
  bytesTotal += bytesRead;
  bytesPerSecond = bytesTotal / (DateTime.Now - startTime).TotalSeconds;
	
  ...
} while(bytesRead > 0);

public class RunningAverage {
  public RunningAverage(int samplesCount) {
    samples = new Sample[samplesCount];
    for (int i = 0; i < samplesCount; i++)
      samples[i] = new Sample( );
    currentSample = 0;
  }
	
  class Sample {
    public Sample( ) { }
	
    public Sample(double weighting, double measuredValue) {
      Set(weighting, measuredValue);
    }
	
    public void Set(double weighting, double measuredValue) {
      this.weighting = weighting;
      this.measuredValue = measuredValue;
      isValid = true;
    }
	
    private double weighting;
    public double Weighting { get { return weighting; } }
	
    private double measuredValue;
    public double MeasuredValue { get { return measuredValue; } }
	
    private bool isValid;
    public bool IsValid { get { return isValid; } }
  }
	
  Sample[] samples;
  int currentSample;
	
  public void AddSample(double weighting, double measuredValue) {
    samples[currentSample++].Set(weighting, measuredValue);
    if (currentSample >= samples.Length)
      currentSample = 0;
  }
	
  public double GetCurrentAverage( ) {
    double totalValue = 0;
    double totalWeighting = 0;
    foreach (Sample sample in samples)
      if (sample.IsValid) {
        totalValue += sample.MeasuredValue;
        totalWeighting += sample.Weighting;
      }
    return totalValue / totalWeighting;
  }
}

RunningAverage average = new RunningAverage(100);
DateTime timeStamp = DateTime.Now;
	
do {
  bytesRead = receiveStream.Read( ... );
  DateTime newTimeStamp = DateTime.Now;
  average.AddSample(newTimeStamp.TotalSeconds - timeStamp.TotalSeconds, bytesRead);
  timeStamp = newTimeStamp;
  // access average.GetCurrentAverage() if needed
	
  ...
} while(bytesRead > 0);

private string performanceCategoryName;
/// <summary>
/// Gets or sets a value indicating the name of the performance counter category.
/// </summary>
public string PerformanceCategoryName {
  get {
    return performanceCategoryName;
  }
  set {
    if (performanceCategoryName != value) {
      performanceCategoryName = value;
      InvalidateCounters( );
    }
  }
}
	
private string performanceCounterNamePrefix;
/// <summary>
/// Gets or sets a value indicating a prefix that is used for all the performance
/// counters of this pool instance.
/// </summary>
public string PerformanceCounterNamePrefix {
  get {
    return performanceCounterNamePrefix;
  }
  set {
    if (performanceCounterNamePrefix != value) {
      performanceCounterNamePrefix = value;
      InvalidateCounters( );
    }
  }
}
	
/// <summary>
/// Set the properties PerformanceCategoryName and PerformanceCounterNamePrefix to the values
/// passed in to the categoryName and counterNamePrefix parameters, then calls InitializeCounters().
/// </summary>
public void InitializeCounters(string categoryName, string counterNamePrefix) {
  performanceCategoryName = categoryName;
  performanceCounterNamePrefix = counterNamePrefix;
  InitializeCounters( );
}
	
private const string STR_Poolsize = "Pool size";
private const string STR_PoolsizeHelp = "The current number of poolable objects.";
private const string STR_ObjectsInUse = "Objects in use";
private const string STR_ObjectsInUseHelp =
  "The number of objects that are currently allocated to a pool user.";
	
PerformanceCounter poolSizeCounter;
PerformanceCounter inUseCounter;
	
/// <summary>
/// Initializes the performance counters according to the settings of the PerformanceCategoryName
/// and PerformanceCounterNamePrefix properties.
/// </summary>
public void InitializeCounters( ) {
  if (PerformanceCounterCategory.Exists(performanceCategoryName))
    PerformanceCounterCategory.Delete(performanceCategoryName);
	
  CounterCreationDataCollection counters = new CounterCreationDataCollection( );
	
  counters.Add(new CounterCreationData(performanceCounterNamePrefix + STR_Poolsize,
    STR_PoolsizeHelp, PerformanceCounterType.NumberOfItems32));
  counters.Add(new CounterCreationData(performanceCounterNamePrefix + STR_ObjectsInUse,
    STR_ObjectsInUseHelp, PerformanceCounterType.NumberOfItems32));
	
  PerformanceCounterCategory.Create(performanceCategoryName, "",
    PerformanceCounterCategoryType.SingleInstance, counters);
	
  poolSizeCounter = new PerformanceCounter(performanceCategoryName,
    performanceCounterNamePrefix + STR_Poolsize, false);
  inUseCounter = new PerformanceCounter(performanceCategoryName,
    performanceCounterNamePrefix + STR_ObjectsInUse, false);
}
	
void InvalidateCounter(ref PerformanceCounter counter) {
  if (counter != null) {
    counter.Dispose( );
    counter = null;
  }
}
	
void InvalidateCounters( ) {
  InvalidateCounter(ref poolSizeCounter);
  InvalidateCounter(ref inUseCounter);
}

  . . .
  lock (poolLock) {
    count = Math.Min(maxPoolSize - pool.Count, count);
	
    for (int i = 0; i < count; i++) {
      Slot slot = delayObjectCreation ? new Slot(objectFactory) :
        new Slot(objectFactory.CreateObject( ));
      pool.Add(slot);
    }
	
    if (poolSizeCounter != null)
      poolSizeCounter.RawValue = pool.Count;
  }
  . . .

  . . .
  if (poolSizeCounter != null)
    poolSizeCounter.RawValue = pool.Count;
  . . .

[Serializable]
public class Test {
  string name;
  public string Name {
    get { return name; }
    set { name = value; }
  }
}

[Serializable]
public class Test {
  string name;
  public string Name {
    get { return name; }
    set { name = value; }
  }
	
  int newVal;
  [OptionalField]
  public int NewVal {
    get { return newVal; }
    set { newVal = value; }
  }
	
  bool marker;
  [OptionalField]
  public bool Marker {
    get { return marker; }
    set { marker = value; }
  }
	
  [OnDeserializing]
  void Deserializing(StreamingContext context) {
    // We get here before data is actually written to our properties
    // So we set some default values for the optional properties.
	
    newVal = 42;
    marker = false;
  }
	
  [OnDeserialized]
  void Deserialized(StreamingContext context) {
    // We get here when data has been written to all the properties
    // that were found during deserialization, which may not have been
    // all we have in case an old storage format was used.
    // So we can now analyze what's happened and fix up what's necessary.
	
    if (!marker) {
      // . . .
    }
  }
}

textBox1.DataBindings.Add("Text", myObject, "MyProperty", true);

  public enum HLineType {
    Etched,
    Single
  }
	
  public class HorizontalLine : Control {
    public HorizontalLine( ) {
      SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.FixedHeight |
        ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw |
          ControlStyles.SupportsTransparentBackColor | ControlStyles.UserPaint, true);
        lineType = HLineType.Etched;
    }
	
    public override System.Drawing.Size GetPreferredSize(Size proposedSize) {
      if (proposedSize == Size.Empty)
        return new Size(150, 10);
      return proposedSize;
    }
	
    private HLineType lineType;
    [DefaultValue(HLineType.Etched)]
    public HLineType LineType {
      get {
        return lineType;
      }
      set {
        if (lineType != value) {
          lineType = value;
            CreatePen( );
            Invalidate( );
        }
      }
    }
	
    public override Color ForeColor {
      get {
        return base.ForeColor;
      }
      set {
        base.ForeColor = value;
        CreatePen();
      }
    }
	
    Pen pen;
    void CreatePen( ) {
      if (pen != null) {
        pen.Dispose( );
        pen = null;
      }
	
      if (lineType == HLineType.Single)
        pen = new Pen(ForeColor);
    }
	
    protected override void OnPaint(PaintEventArgs e) {
      base.OnPaint(e);
      switch (lineType) {
        case HLineType.Etched:
          ControlPaint.DrawBorder3D(e.Graphics, ClientRectangle,
            Border3DStyle.Etched, Border3DSide.Top);
          break;
        case HLineType.Single:
          e.Graphics.DrawLine(pen, 0, 0, Width - 1, 0);
          break;
      }
    }
  }