C#

public interface ITest
{
    bool PTest
    {
        get;
        set;
    }
}

public class CTest_A : System.Windows.Forms.Control, ITest
{
    public CTest_A()
    {
    }
    #region ITest Member
    private bool _ptest=false;
    public bool PTest
    {
        get
        {
            return _ptest;
        }
        set
        {
            _ptest = value;
        }
    }
    #endregion

    private bool _padditional_A=false;
    public bool PAdditional_A
    {
        get
        {
            return _padditional_A;
        }
        set
        {
            _padditional_A = value;
        }
    }
}

public class CTest_B : System.Windows.Forms.Control, ITest
{
    public CTest_B()
    {
    }

    #region ITest Member
    private bool _ptest=false;
    public bool PTest
    {
        get
        {
            return _ptest;
        }
        set
        {
            _ptest = value;
        }
    }
    #endregion

    private bool _padditional_B=false;
    public bool PAdditional_B
    {
        get
        {
            return _padditional_B;
        }
        set
        {
            _padditional_B = value;
        }
    }
}

CTest_B C_B = new CTest_B();

private ITest GetIReference()
{
    return C_B as ITest;
}

public Form1()
{
    InitializeComponent();

    CTest_A C_A = (CTest_A)GetIReference(); //Throws an invalid cast exception here
        }

Vikram A Punathambekar wrote:

you are essentially trying to cast a CTest_B object to a CTest_A reference. This will work only if CTest_A is an ancestor of CTest_B or a cast is defined. You haven't, so it bombs.

Vikram A Punathambekar wrote:

Try making GetIReference() return an instance of CTest_A (don't change the sig!) and you will see what I meant

Vikram A Punathambekar wrote:

Greetings to Österreich.

Type1 reference1 = new Type2();

Type1 reference2 = reference1;

Vikram A Punathambekar wrote:

I'm sure you know this; it's probably just that you weren't using the correct terminology.

Vikram A Punathambekar wrote:

Don't worry, your English is far better than my German

Vikram A Punathambekar wrote:

Second, when you say
Type1 reference1 = new Type2();

Vikram A Punathambekar wrote:

Therefore, assuming Type2 inherits from Type1 (directly or indirectly, it doesn't matter), a subsequent cast like
Type1 reference2 = reference1;
will always work. (You don't even need a cast!)

Martin# wrote:

Vikram A Punathambekar wrote:
Second, when you say
Type1 reference1 = new Type2();

Did I?

Vikram A Punathambekar wrote:

Hee hee, when I said "When you say..." I did not imply that you said those words. I was presenting a hypothetical scenario, not saying you said something.

Vikram A Punathambekar wrote:

About the casting, I think there's just a misunderstanding. Forget all we talked about in this thread and keep up the good work.

Vikram A Punathambekar wrote:

Forget all we talked about in this thread and keep up the good work.

Vikram A Punathambekar wrote:

BTW, there are far too many languages spoken in India to list

Martin# wrote:

This perfectly fitts to you Signature (Which allways make me laugh when reading)

Martin# wrote:

I choosed the one with the most percentage

Martin# wrote:

Here is the link to the German Wikipedia page, for your training.

Vikram A Punathambekar wrote:

Is it true that there is no neuter gender in German and everything is male/female?

Keys actKey = (Keys)Enum.Parse(typeof(Keys), stringarray[x], true);

int work=val;  // copy the int whose bits need to be enumerated
while (work!=0) {
    int singleBit=work & -work; // this has the lowest bit of work set
    work=work^singleBit;        // removes work's lowest bit set
    ... do whatever you need to do with singleBit
}

[Flags]
enum myFlags {a=1, b=2, c=4, d=8}
 
public void Run() {
	myFlags flags=myFlags.a | myFlags.c | myFlags.d;
	int work=(int)flags;  // copy the int whose bits need to be enumerated
	while (work!=0) {
	    int singleBit=work & -work;   // this has the lowest bit of work set
		work=work^singleBit;      // removes work's lowest bit set
		myFlags mySingleFlag=(myFlags)singleBit;
		log(mySingleFlag.ToString());
	}
}

shyagam wrote:

Why didn't Microsoft implement this kind of iteration too??

Luc Pattyn wrote:

But they didnt.

Luc Pattyn wrote:

(and hence
it better have the [Flags] attribute).

Martin# wrote:

So your solution would mean to iterate threw the enum members and do the bit test?

Keys keys = Keys.Control | Keys.A;
foreach(Keys key in POSSIBLEVALUES){ //however you're managing that
   if(keys & key) == key){ //the key contains this one!

    }
}

enum Keys
        {
            A = 1,
            B = 2,
            C = 4,
            D = 8
        }

        static void Main(string[] args)
        {
            Keys keys = Keys.A | Keys.B | Keys.D;
            if ((keys & Keys.A) == Keys.A)
            {
                Console.WriteLine("A");
            }
            if ((keys & Keys.B) == Keys.B)
            {
                Console.WriteLine("B");
            }
            if ((keys & Keys.C) == Keys.C)
            {
                Console.WriteLine("C");
            }
            if ((keys & Keys.D) == Keys.D)
            {
                Console.WriteLine("D");
            }