C#

// Range.cs
using System;

namespace DaveyM69
{
    [Serializable]
    public struct Range : IEquatable<Range>
    {
        // ToDo: Make struct designer friendly!

        public static readonly Range Empty = new Range();
        public static readonly Range MaxRange = new Range(int.MinValue, int.MaxValue);
        public static readonly Range Percentage = new Range(0, 100);

        private int lower;
        private int upper;

        public Range(int lower, int upper)
        {
            if (lower > upper)
            {
                int newUpper = lower;
                lower = upper;
                upper = newUpper;
            }
            this.lower = lower;
            this.upper = upper;
        }

        public static bool operator ==(Range rangeA, Range rangeB)
        {
            return (rangeA.lower == rangeB.lower) && (rangeA.upper == rangeB.upper);
        }
        public static bool operator !=(Range rangeA, Range rangeB)
        {
            return !(rangeA == rangeB);
        }

        public int Lower
        {
            get { return lower; }
        }
        public int Upper
        {
            get { return upper; }
        }

        public Range Adjust(int offset)
        {
            return new Range(lower + offset, upper + offset);
        }
        public int Contain(int value)
        {
            return Contain(value, false);
        }
        public int Contain(int value, bool excludeExtremities)
        {
            Range testRange = excludeExtremities ? this.Expand(-1) : this;
            if (value < testRange.lower)
                return testRange.lower;
            if (value > testRange.upper)
                return testRange.upper;
            return value;
        }
        public Range Contain(Range range)
        {
            return Contain(range, false);
        }
        public Range Contain(Range range, bool excludeExtremities)
        {
            if (Contains(range, excludeExtremities))
                return range;
            int newLower = range.lower;
            int newUpper = range.upper;
            if (!Contains(range.lower, excludeExtremities))
            {
                newLower = lower;
                if (excludeExtremities)
                    newLower++;
            }
            if (!Contains(range.upper, excludeExtremities))
            {
                newUpper = upper;
                if (excludeExtremities)
                    newUpper--;
            }
            Range result = new Range(newLower, newUpper);
            if (!Contains(result, excludeExtremities))
                throw new InvalidOperationException("The span of this range is too small to contain another range");
            return result;
        }
        public bool Contains(Range range)
        {
            return Contains(range, false);
        }
        public bool Contains(Range range, bool excludeExtremities)
        {
            return Contains(range.lower, excludeExtremities) && Contains(range.upper, excludeExtremities);
        }
        public bool Contains(int value)
        {
            return Contains(value, false);
        }
        public bool Contains(int value, bool excludeExtremities)
        {
            Range testRange = excludeExtremities ? this.Expand(-1) : this;
            if (testRange.lower < lower)
                throw new InvalidOperationException("The span of the specified range is too small to contain another range");
            return (value >= testRange.lower) && (value <= testRange.upper);
        }
        public Range Expand()
        {
            return Expand(1);
        }
        public Range Expand(int value)
        {
            return new Range(lower - value, upper + value);
        }
        public override bool Equals(object obj)
        {
            return obj is Range && this == (Range)obj;
        }
        public bool Equals(Range other)
        {
            return this == other;
        }
        public override int GetHashCode()
        {
            return lower ^ upper;
        }
        public override string ToString()
        {
            return string.Format("{0}, {1}", lower, upper);
        }
    }
}

// RangeControl.cs
using System;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;

namespace DaveyM69.Windows.Forms
{
    public class RangeControl : Control
    {
        private static readonly Size Default_Size = new Size(200, 50);

        [Category("Range")]
        public event EventHandler ExcludeExtremitiesChanged;
        [Category("Range")]
        public event EventHandler InnerRangeChanged;
        [Category("Range")]
        public event EventHandler OuterRangeChanged;
        [Category("Range")]
        public event EventHandler ValueChanged;
        
        private bool excludeExtremities;
        private Range innerRange;
        private Range outerRange;
        private int value;

        public RangeControl()
        {
            SetStyle(
                ControlStyles.AllPaintingInWmPaint |
                ControlStyles.OptimizedDoubleBuffer |
                ControlStyles.ResizeRedraw |
                ControlStyles.Selectable |
                ControlStyles.SupportsTransparentBackColor |
                ControlStyles.UserPaint, true);
            excludeExtremities = false;
            innerRange = new Range(25, 75);
            outerRange = Range.Percentage;
            value = 50;
        }

        protected override Size DefaultSize
        {
            get { return Default_Size; }
        }
        [Category("Range"),
        DefaultValue(false)]
        public bool ExcludeExtremities
        {
            get { return excludeExtremities; }
            set
            {
                if (excludeExtremities != value)
                {
                    excludeExtremities = value;
                    OnExcludeExtremitiesChanged(EventArgs.Empty);
                    InnerRange = innerRange; // Force refresh
                    Value = this.value; // Force refresh. This needs refactoring as if InnerRange changes this will have already been done!
                }
            }
        }
        [Category("Range"),
        DefaultValue(typeof(Range), "25, 75")]
        public Range InnerRange
        {
            get { return innerRange; }
            set
            {
                value = outerRange.Contain(value, excludeExtremities);
                if (innerRange != value)
                {
                    innerRange = value;
                    Invalidate();
                    OnInnerRangeChanged(EventArgs.Empty);
                    Value = this.value; // Force refresh
                }
            }
        }
        [Category("Range"),
        DefaultValue(typeof(Range), "0, 100")]
        public Range OuterRange
        {
            get { return outerRange; }
            set
            {
                if (outerRange != value)
                {
                    outerRange = value;
                    OnOuterRangeChanged(EventArgs.Empty);
                    InnerRange = innerRange; // Force refresh
                }
            }
        }
        [Category("Range"),
        DefaultValue(50)]
        public int Value
        {
            get { return value; }
            set
            {
                value = innerRange.Contain(value, excludeExtremities);
                if (this.value != value)
                {
                    this.value = value;
                    Invalidate();
                    OnValueChanged(EventArgs.Empty);
                }
            }
        }

        protected virtual void OnExcludeExtremitiesChanged(EventArgs e)
        {
            EventHandler eh = ExcludeExtremitiesChanged;
            if (eh != null)
                eh(this, e);
        }
        protected virtual void OnInnerRangeChanged(EventArgs e)
        {
            EventHandler eh = InnerRangeChanged;
            if (eh != null)
                eh(this, e);
        }
        protected override void OnMouseDown(MouseEventArgs e)
        {
            // ToDo: MouseDown
            base.OnMouseDown(e);
        }
        protected override void OnMouseUp(MouseEventArgs e)
        {
            // ToDo: MouseUp
            base.OnMouseUp(e);
        }
        protected virtual void OnOuterRangeChanged(EventArgs e)
        {
            EventHandler eh = OuterRangeChanged;
            if (eh != null)
                eh(this, e);
        }
        protected override void OnPaint(PaintEventArgs e)
        {
            // ToDo: Paint
            base.OnPaint(e);
        }
        protected virtual void OnValueChanged(EventArgs e)
        {
            EventHandler eh = ValueChanged;
            if (eh != null)
                eh(this, e);
        }
    }
}

DaveyM69 wrote:

Ah, I hadn't reread the P/Invoke one

Al Beback wrote:

that article doesn't address my specific example where a variable is not explicitly declared inside the using statement.

public static void Main(string[] args)
{
    using (new SomeIDisposableClass())
    {
        Console.WriteLine("Hello World!");
    }
    Console.ReadKey(true);
}

.method public hidebysig static 
  void Main(string[] args) cil managed
{
    .entrypoint
    .maxstack 2
    .locals init (
        [0] class using_test.SomeIDisposableClass CS$3$0000,
        [1] bool CS$4$0001)
    L_0000: nop 
    L_0001: newobj instance void 
              using_test.SomeIDisposableClass::.ctor()
    L_0006: stloc.0 
    L_0007: nop 
    L_0008: ldstr "Hello World!"
    L_000d: call void [mscorlib]System.Console::WriteLine(string)
    L_0012: nop 
    L_0013: nop 
    L_0014: leave.s L_0026
    L_0016: ldloc.0 
    L_0017: ldnull 
    L_0018: ceq 
    L_001a: stloc.1 
    L_001b: ldloc.1 
    L_001c: brtrue.s L_0025
    L_001e: ldloc.0 
    L_001f: callvirt instance void 
              [mscorlib]System.IDisposable::Dispose()
    L_0024: nop 
    L_0025: endfinally 
    L_0026: nop 
    L_0027: ldc.i4.1 
    L_0028: call valuetype 
              [mscorlib]System.ConsoleKeyInfo 
              [mscorlib]System.Console::ReadKey(bool)
    L_002d: pop 
    L_002e: ret 
    .try L_0007 to L_0016 finally handler L_0016 to L_0026
}

I are Troll

IDisposable disposable = null;
try
{
 disposable =  new SomeIDisposableClass()
 SomeCode();
}
finally
{
 disposable.Dispose();
}

d@nish wrote:

Why and when would you write a code like that?

d@nish wrote:

Why and when would you write a code like that?

I are Troll

public class AppCursor : IDisposable
    {

        Cursor _currentCursor = null;
        bool _setDefault;

        public AppCursor(Cursor cursor, bool setDefault)
        {
            _currentCursor = Cursor.Current;
            _setDefault = setDefault;
            Cursor.Current = cursor;
        }

        #region IDisposable Members

        public void Dispose()
        {
            Cursor.Current = (_setDefault) ? Cursors.Default : _currentCursor;
            
            // Even with disposing the cursor object, form works but am not sure whether it should be there or not.
            _currentCursor.Dispose();
            _currentCursor = null;
        }

        #endregion
    }