The Weird and The Wonderful

Sub Main()
    Dim arg1 As Object = True
    Dim arg2 As Object = True

    Dim collection As New List(Of Object)() From { _
     arg1 _
    }

    Dim first As Boolean = (collection.Contains(arg1))
    Dim second As Boolean = (collection.Contains(arg2))
    Console.WriteLine(String.Format("{0} {1}", first, second))

    first = False
    second = False

    For i As Integer = 0 To collection.Count - 1
        If collection(i) = arg1 Then
            first = True
        End If
        If collection(i) = arg2 Then
            second = True
        End If
    Next

    Console.WriteLine(String.Format("{0} {1}", first, second))

    Console.ReadKey()
End Sub

_Maxxx_ wrote:

If each object had two booleans, would it act the same?

_Maxxx_ wrote:

The fact that the Contains method works inconsistently depending on the contents of objects is the problem.

_Maxxx_ wrote:

And I expect the answer to be yes or no - and not 'well, if it's an object containing only a value type, then the collection contains at least one similar Object where the value type has the same value, but if it's a reference type then that instance exists I the collection'

BobJanova wrote:

Depends if it's a value type, and whether Equals is overridden.

BobJanova wrote:

and it's usually much more useful than checking for reference equality.

BobJanova wrote:

Choosing which constructor to use based on the values of parameters, instead of the types of parameters, is a WTF all to itself.

1. For Each parameter in the constructor it is checking
2.  For each argument in the collection
3.    If THIS ARGUMENT is already in our output collection, continue
4.    If this argument is of the same type (or subtype etc) as the current parameter, add it to the output collection
5.  Next Argument
6. Next parameter

_Maxxx_ wrote:

An object with two boolean properties is not a value type

struct MyType { public bool a, b; } // value type
class MyType { public bool a, b; } // reference type

_Maxxx_ wrote:

If I want to check if two objects are the same object, i would like to be able to do so in a consistent manner, without having to check to see if the object is a value-type wrapper. similarly, if I want to check if the value of two objects are the same, I would expect to be able to use the same methods

_Maxxx_ wrote:

The AIM of the method in question was was to decide on the constructor based upon the TYPES of parameter vs TYPES of arguments.

BobJanova wrote:

Then why is it using the values?

BobJanova wrote:

Capital letters don't change what you are actually coding

BobJanova wrote:

(or what your pseudo-code does).

BobJanova wrote:

Line 3 is where the issue arises because you shouldn't be doing that;

BobJanova wrote:

the value of an argument is irrelevant to the parameter matching to find a method.

_Maxxx_ wrote:

An object with two boolean properties is not a value type

using System;

namespace ClassVsStruct
{
    class Program
    {
        class CBool
        {
            public bool Value1;
            public bool Value2;
        }

        struct SBool
        {
            public bool Value1;
            public bool Value2;
        }

        static void Main(string[] args)
        {
            var c1 = new CBool { Value1 = true, Value2 = true };
            var c2 = new CBool { Value1 = true, Value2 = true };
            Console.WriteLine("Equals: {0}", c1.Equals(c2));

            var s1 = new SBool { Value1 = true, Value2 = true };
            var s2 = new SBool { Value1 = true, Value2 = true };
            Console.WriteLine("Equals: {0}", s1.Equals(s2));
        }
    }
}

Mathlab wrote:

you'd think they'd both be "true true"

object arg1 = true;
object arg2 = true;
List<object> collection = new List<object>() { arg1 };

bool first = (collection.Contains(arg1));
bool second = (collection.Contains(arg2));

int a = 1;
int b = 1;

List<int> intcollection = new List<int>() {a };
bool first = (intcollection.Contains(a));
bool second = (intcollection.Contains(b));
Console.WriteLine(string.Format("{0} {1}", first, second));

TheCoolCoder wrote:

whoever coded it dint realize this beforehand.

TheCoolCoder wrote:

the tendency to assume object arg1 and object arg2 as reference types.