C#

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();
   }
}

Rob Philpott wrote:

I can offer no solution to that, but might suggest that rather than 'Removing' parts from such a huge string you either iterate over it to get what you need or just copy substrings.

// This method is called from a different thread
private void ProcessMessage(string CommandPool)
{
    RawResponseReceived(CommandPool);

    while (CommandPool != string.Empty)
    {
        //
        // If the command starts with a ln=
        if (CommandPool.StartsWith("ln="))
        {
            //
            // Remove the ln=
            CommandPool = CommandPool.Remove(0, 3);

            //
            // Get the length of the command

            int RequestSize = -1;
            string FinalLength = string.Empty;

            while (Int32.TryParse(CommandPool[0].ToString(), out RequestSize))
            {
                FinalLength += RequestSize.ToString();
                CommandPool = CommandPool.Remove(0, 1);
            }

            //
            // Parse the request size
            RequestSize = Int32.Parse(FinalLength);

            //
            // remove the terminator at the start
            CommandPool = CommandPool.Remove(0, 1);

            //
            // get the individual command
            string command = CommandPool.Substring(0, RequestSize);

            //
            // remove command from the command pool
            CommandPool = CommandPool.Remove(0, RequestSize);

            //
            // send command away for proccessing
            ProcessCommand(command);
        }
        else
        {
            Console.Write("Char removed - " + CommandPool[0]);
            CommandPool = CommandPool.Remove(0, 1);
        }
    }
}