C#

dummyColl = SampleColl as T;

private static T InitData<T>(T dummyColl, int value) where T: class

Rob Philpott wrote:

T could be anything and so casting from SampleColl to T may very well not work

Rob Philpott wrote:

private static T InitData<t>(T dummyColl, int value) where T: class

int i=2;
(T)Convert.ChangeType(i, dummyColl.GetType())

Spunky Coder wrote:

but at the calling site itself I have confined T for only two data types

Spunky Coder wrote:

So whether I use this constraint or not it throws the error at runtime only.Can you please let me know why is it happening?

 int i=2;
(T)Convert.ChangeType(i, dummyColl.GetType())

dojohansen wrote:

Since A implements SomeInterface, Field is of course assignable to A, but nevertheless it does not build.

interface ISome {}
class SomeA : ISome {}
class SomeB : ISome {}

void Method()
{
   SomeA a = new SomeA();
   OutMethod(out a);
}

void OutMethod(out ISome some)
{
   some = new SomeB();
}

void Method()
{
   SomeA a = Method2();
}

ISome Method2()
{
   return new SomeB();
}

dojohansen wrote:

and it would not compile if you did the same assignment using return values instead of output parameters.

SomeA a = (SomeA) Method2();

dojohansen wrote:

But in my original code the assignment I'm trying to do is known to be safe, as you can verify since the same assignment done from a return value rather than an out parameter builds just fine (and indeed runs fine).

interface ISome {}
class SomeA : ISome {}
class SomeB : ISome {}

void Method()
{
   ISome some = SomeB();
   Method2(out some);
} 

void Method2(out SomeA some) // ISome is NOT SomeA
{
   some = new SomeA();
}

public interface SomeInterface { }

class A : SomeInterface
{
    public SomeInterface Field;

    void foo() 
    { 
        Parse(out this.Field); 
    }

    static public void Parse(out A something)
    {
        something = new A();
    }
}

dojohansen wrote:

Again, if you simply frame the issue as "why should (output/ref) parameters have different assignability compared to return values?"

ISomeInterface isi = Parse(...);

<Any_Type_That_Implements_ISomeInterface> Parse(...) {}

Parse(this.Field);

void Parse(<ISomeInterface_Or_Any_Class/Interface_ISomeInterface_derived_from> something){}

ISomeInterface isi = new A(); // OK
A a = isi; // NOT OK

class EggSample
{
   // miss loads

   void Method()
   {
      // Method with nothing
   }

   void Method(string param)
   {
      // Overloading Method with a string
   }

   void Method(int count, string param)
   {
      // Overloading Method with a number and a string
   }
}

class HenOther : EggSample
{
   // miss loads

   void Method(string param)
   {
      // Overrides the Method with a string from EggSample
   }

}

EggSample obj = new HenOther();
obj.Method("param");

abstract public class ProcessingNode
{
   public List<processingnode> Children = new List<processingnode>();

   virtual public void PreProcess(Data d) {}
   virtual public void PostProcess(Data d) {}
  
   public void Execute(Data d)
   {
      PreProcess(d);
      foreach (ProcessingNode node in Children) node.Execute(d);
      PostProcess(d);
   }
}

public class Upper : ProcessingNode
{
   override public void PreProcess(Data d)
   {
      d.Selection.Text = d.Selection.Text.ToUpper();
   }
}

public class A 
{
   public void M1() { Debug.WriteLine("A.M1()"); }
   virtual public void M2() { Debug.WriteLine("A.M2()"); } 
}

public class B : A
{
   new public void M1() { Debug.WriteLine("B.M1()"); }      // Hiding - not polymorphic
   virtual public void M2() { Debug.WriteLine("B.M2()"); }  // Virtual - polymorphic
}

class Program
{
   static public void Main(string[] args)
   {
      B b = new B();
      A b_declared_as_a = b; 
      
      b.M1();
      b.M2();
      b_declared_as_a.M1();
      b_declared_as_a.M2();
   }
}