C#

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

Stopwatch w;

static void time(string msg)
{
   Console.WriteLine(msg + ", elapsed time = " + w.Elapsed.ToString());
   w = Stopwatch.StartNew();
}

static void Main(string[] args)
{
   int count = 1000*1000; 
   string s = "";
   StringBuilder sb = new StringBuilder();
   
   w = Stopwatch.StartNew();
   for (int i=0; i < count; i++) s += ".";
   time("Using string");
   for (int i=0; i < count; i++) sb.Append(".");
   time("Using StringBuilder");
}

private void ProcessMessage(string CommandPool)
{
    RawResponseReceived(CommandPool);
    StringBuilder sbCommandPool = new StringBuilder(CommandPool);

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

            //
            // Get the length of the command

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

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

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

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

            //
            // get the individual command
            string command = sbCommandPool.ToString().Substring(0, RequestSize); //It breaks here

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

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

class Program
{
    static void Main(string[] args)
    {
        int size = 30000;
        int take = 28000;

        char[] chars = new char[size];
        for (int i = 0; i < size; i++) chars[i] = '.';
        
        string s = new String(chars);
        Stopwatch w = Stopwatch.StartNew();
        s = s.Substring(0, take);
        Console.WriteLine(w.Elapsed);
        Console.ReadKey(true);
    }
}

void substring(char[] src, char[] dest, int startIndex, int count)
{
   for (int i=0; i < count; i++)
     dest[i] = src[i + startIndex];
}

try 
{
    .... 
}
catch (Exception ex)
{
   Debug.WriteLine(ex.ToString());
   Debugger.Break();
}