C#

CaptainSeeSharp wrote:

I forgot that I can't even do a simple comparison between two of the same generic types. There has got to be a way don't you think?

class CellMap<TCell> where TCell : IEquatable<TCell>
{
    public void SetMap(TCell[][] newMap, bool redrawAll)
    {
        // ...
       /if (newMap[x][y].Equals(bufferMap[x][y])) continue;
        // ...
    }
}

class CellMap<TCell> where TCell : class
{
    public void SetMap(TCell[][] newMap, bool redrawAll)
    {
        // ...
        if (newMap[0][0] == newMap[0][1]) continue;
        // ...
    }
}

class CellMap<TCell> where TCell : CellBase
{
    public void SetMap(TCell[][] newMap, bool redrawAll)
    {
        // ...
        if (newMap[0][0] == newMap[0][1]) continue;
        // ...
    }
}
class CellBase
{
    // ...
}

class TCell
{
   int field1;
   string field2;

   // override equals...   
   override public bool Equals(object other)
   {
      if (!(other is TCell)) return false;
      return (field1 == other.field1 && field2 == other.field2);
   }

   // or overload the operator..
   static public bool operator ==(TCell x, TCell y) 
   {
      return (x.field1 == y.field1 && x.field2 == y.field2);
   }
}

dojohansen wrote:

I don't understand where generics enter into the problem at all. You want to compare two TCell instances, and TCell is apparently not the generic type

dojohansen wrote:

Just overriding Equals or the equals operator should suffice.

N a v a n e e t h wrote:

TCell is a generic type in the example shown by OP.

N a v a n e e t h wrote:

ou may need to override GetHashCode() as well.

class TCell<T>
{
    int n;
    string s;

    public TCell(int n, string s)
    {
        this.n = n;
        this.s = s;
    }

    public bool Equals<T2>(TCell<T2> obj)
    {
        return (obj != null && obj.n == this.n && obj.s == this.s);
    }

    public override int GetHashCode()
    {
        return s.GetHashCode();
    }
}

MyClass toBeDisposed=myAL[0];
myAL[0]=new MyClass();
toBeDisposed.Dispose();    // <<<<<<<<<<<<<<<<<<<

Trollslayer wrote:

would deriving the classes I use from IDisposable lead to significant overheads?

List<MyClass> list1;
list1 = new List<MyClass>;

list1.Add(new MyClass());
list1[0].num = 3;
list1.RemoveAt(0);    // This removes the reference but does it remove the object?

public class MyClass : Object
{
    public int num;
    public string str;
}

List list1;
list1 = new List;

list1.Add(new MyClass());
list1[0].num = 3;

list1[0] = null;      // this is not needed in this scenario since RemoveAt cuts off the reference from the object itself

list1.RemoveAt(0);    // This removes the reference but does it remove the object?

//System.GC.Collect(); //if you know when to use it "profitably".

public class MyClass : Object
{
    public int num;
    public string str;
}

class Test
{
  byte[] bigArray;

  public void Alloc()
  {
    bigArray = new byte[100000000];
  }

  public void Dealloc()
  {
    bigArray = null; //put the current byte array up for collection, free up reference for other byte arrays
    //System.GC.Collect(); //force collection now
  }
}