C#

public static class ExtMethods
{
    public static string RemoveFirst(this string str)
    {
        return str.Remove(0,1);
    }
}
  class ExtMethodDemo
    {
        static void Main(string[] args)
        {
            string r1 = "12345".RemoveFirst();
            Console.WriteLine(r1);
            Console.ReadLine();
        }
    }

betonglasermur.FeedDwarf(pur_is, 17);
ProcessStartupInfo.AintNotCreateNoWindow = (false && !true) != (true || false) ? false == true ? true : false : (true != false && false);

buchstaben wrote:

In effect, extension methods make it possible

PIEBALDconsult wrote:

buchstaben wrote:
In effect, extension methods make it possible


make it appear possible, when in fact it isn't.

George_George wrote:

I understand there is no need to call Dispose explicitly when dealing with StreamReader/StreamWriter object instances

using (StreamReader sr = new StreamReader(someStream))
{
  ...
}

George_George wrote:

What is the benefit?

George_George wrote:

when the Http Service stops (process stops or terminations), all resources like native handle wrapped by StreamReader could be released automatically.

What is the benefit of using "using" statement?

using(Stream str = new FileStream(..))
{
   // Use str here
}

Stream str = null;
try
{
   str = new FileStream(..);
}
finally
{
   if(str != null)
     ((IDisposable)str).Dispose();
}

George_George wrote:

In the C# compiler expanded code, no catch block? Just a finally block?

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Xml;

class Test
{

    class MyException : ApplicationException
    {
        public MyException (string message)
            : base(message)
        {

        }
    }

    class MyObject : IDisposable
    {
        public virtual void Dispose()
        {
            Console.WriteLine("Disposed ");
            throw new MyException("Disposed exception. ");
        }

    }

    public static void Main()
    {
        try
        {
            using (MyObject myobj = new MyObject())
            {
                throw new MyException("Hello World");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
    }
}

try
        {
            MyObject myobj = new MyObject();
            try
            {
                throw new MyException("Hello World");
            }
            finally
            {
                myobj.Dispose();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }

George_George wrote:

It is in theory that the information of MyException("Hello World") is missing when there is exception in Dispose, right?

George_George wrote:

when there is exception and we are in finally block because of the exception

George_George wrote:

How can you write a common finally block, to handle exception at first, then Dispose?

public static void Main()
    {
        try
        {
            using (MyObject myobj = new MyObject())
            {
                try{
                   throw new MyException("Hello World");
                }
                catch(MyException)
                {
                     
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
    }