C#

teknolog123 wrote:

So what can I do to prevent this?

I are Troll

public class ColorPicker
{
    public event EventHandler ColorChanged;

    private Color color;

    public ColorPicker()
    {
        color = Control.DefaultBackColor;
    }

    public Color Color
    {
        get { return color; }
        set
        {
            if (color != value)
            {
                color = value;
                OnColorChanged(EventArgs.Empty);
            }
        }
    }

    protected virtual void OnColorChanged(EventArgs e)
    {
        EventHandler eh = ColorChanged;
        if (eh != null)
            eh(this, e);
    }
}

public partial class FormMain : Form
{
    private ColorPicker colorPicker;

    public FormMain()
    {
        InitializeComponent();
        colorPicker = new ColorPicker();
        colorPicker.ColorChanged += new EventHandler(colorPicker_ColorChanged);
        propertyGrid.SelectedObject = colorPicker;
    }

    private void colorPicker_ColorChanged(object sender, EventArgs e)
    {
        BackColor = colorPicker.Color;
    }
}

Console.WriteLine(this.Color);

Console.WriteLine(Color);

Car mine = new Car(Blue);
Car yours = new Car(Red);
Car his = new Car(Green);
mine.PrintColor();

his.PrintColor();

yours.StartEngine();

stephen.darling wrote:

(Gosh! its even complecated to simply exaplin ha)

if (typeof(T).GetInterface("ICollectable") != null)

public bool IsClassAnimal<T>()
    where T:new()
{
    T t = new T();
    return t is IAnimal;
}

public bool IsStructAnimal<T>()
{
    T t = default(T);
    if (t == null)
    {
        throw new InvalidOperationException("The type was a class.");
    }
    else
    {
        return t is IAnimal;
    }
}

public interface IAnimal
{
}
public class Dog : IAnimal
{
}
struct Cat : IAnimal
{
}

if (IsClassAnimal<Dog>())
{
    MessageBox.Show("A dog is an animal!");
}
if (IsStructAnimal<Cat>())
{
    MessageBox.Show("A cat is an animal!");
}

T myObj;

if (myObj is ICollectable)
   variance = 1.2;

depressedguy wrote:

as I am very poor in programming languages.