C#

public class AnyDamnList<T> : List<T>
{
    public AnyDamnList()
        : base()
    { }
    public AnyDamnList(int capacity)
        : base(capacity)
    { }
    public AnyDamnList(IEnumerable<T> collection)
        : base(collection)
    { }
}

AnyDamnList<int> anyDamnList = new AnyDamnList<int>((new List<int>() { 1, 2, 3 }));
List<int> list = new List<int>() { 1, 2, 3 };
anyDamnList = new AnyDamnList<int>(list);

// I've renamed your class anyDamnList2
            anyDamnList2<int> aYIntList = new anyDamnList2<int>();

            aYIntList.Add(100);
            aYIntList.Add(200);

            Console.WriteLine(aYIntList[1]);

            List<int> intList3 = new List<int> { 9, 19, 22, 44 };

            aYIntList = intList3;

            Console.WriteLine(aYIntList[3]);

anyDamnList = new AnyDamnList<int>(list);

BillWoodruff wrote:

I am using C#4

Gideon Engelberth wrote:

There's nothing new or LINQish about the explicit cast its talking about. That is just the standard cast to derived. It's not implicit for the same reason you could not assign a Mammal varaible into a Cat variable even if the Mammal variable is holding a Cat.

BillWoodruff wrote:

Here's the question : is there any other way than using 'Clear() and then 'AddRange
to replace the "virtual inner list" <t> "embodied" via inheritance in the class ?

public class anyDamnList
{
  private List<int> _InnerList;

  public void ReplaceInnerList( List<int> newList )
  {
    _InnerList = newList;
  }
}

int count = myAnyDamnList.Count;

public class anyDamnList : IList<int>

int Count { get { return _InnerList.Count; } }

public class anyDamnList : IList<int>
{
  IList<int> implementedBy _InnerList;
}

----------------------------------
Be excellent to each other

public class anyDamnList<T> : List<T> {}

anyDamnList<int> myIntList = new anyDamnList<int> { 12, 21, 32 };

Nick Butler wrote:

I didn't mean to "short change" LINQ at all. I love it. IMHO, it should have been introduced earlier ( with generics in .NET 2.0 ) as it is just so useful.

Nick Butler wrote:

You don't lose LINQ if you derive from IList because IList derives from IEnumerable and LINQ is implemented as extension methods on IEnumerable. You can use LINQ on List objects for the same reason: List derives from IEnumerable.

Your original question was about deriving from List and then replacing the "virtual" List object. I just suggested composition as a possible solution for you. If you're happy with using Clear and AddRange then that's good, but then you aren't changing the inner List, you're just changing it's contents.

Nick Butler wrote:

Your original question was about deriving from List and then replacing the "virtual" List object. I just suggested composition as a possible solution for you. If you're happy with using Clear and AddRange then that's good, but then you aren't changing the inner List, you're just changing it's contents.

public class anyDamnList3<T> : List<int>
{
    public List<int> innerList
    {
        set
        {
            this.Clear();
            this.AddRange(value);
        }
    }
}

anyDamnList3<int> myList5 = new anyDamnList3<int> { 12, 21, 32 };

anyDamnList3<int> myList6 = new anyDamnList3<int> { 42, 53, 66 };

myList6.innerList = new List<int> { 33, 44, 55 };

public class anyDamnList<T> : List<T>
{

    public List<int> innerList
    {
        set
        {
            this.Clear();
            this.AddRange(value as List<T>);
        }
    }
}

DevonDaDude wrote:

GetY(out yQ, out yTotal);

static double yQ;<br />
static double yTotal;

Abhinav S wrote:

And if he wants to declare them in the class (as class variables) he would have to declare them as static (otherwise the project would not even build)

public class myClass
{
   public myClass()
   {
      str = "This has a string";
   }

   public void WhatIsInString()
   {
      MessageBox.Show(str);
   }
   public String str;
}

Saksida Bojan wrote:

public String str;

double yQ;
double yTotal;
double zQ;
double zTotal;

zQ += Convert.ToDouble(Console.ReadLine());

--------
|0|0||0|
|0|1||1|
|1|0||1|
|1|1||1|
--------

1001cccc : byte0 = status (c = channel)
0nnnnnnn : byte1 = note number
0vvvvvvv : byte2 = velocity

As an Int32: xxxxxxxx0vvvvvvv0nnnnnnn1001cccc

Int32 intStatus = status;
Int32 intNote = (note << 8);
Int32 intVelocity = (velocity << 16);
Int32 packet = intStatus | intNote | intVelocity;

Int32 statusMask = 0x000000FF;
Int32 noteMask = 0x00007F00;
Int32 velocityMask = 0x007F0000;

byte status = (byte)(packet & statusMask);
byte note = (byte)((packet & noteMask) >> 8);
byte velocity = (byte)((packet & velocityMask) >> 16;