C#

using System;

namespace RemoteNamespace
{
	public class RemoteObject : MarshalByRefObject
	{
		public string MyTypeString()
		{
			return this.GetType().ToString();
		}
	}
}

using System;
using System.Runtime.Remoting;


namespace RemoteServer
{

	class Server
	{
		/// <summary>
		/// The main entry point for the application.
		/// </summary>
		[STAThread]
		static void Main(string[] args)
		{
			RemotingConfiguration.Configure("RemoteServer.exe.config");
			Console.WriteLine("Hit <ENTER> to exit.");

			Console.ReadLine();
		}
	}
}

using System;
using System.Runtime.Remoting;
using System.Reflection;
using RemoteNamespace;

namespace RemoteTest
{
	public delegate string del_void();

	class Client
	{
		/// <summary>
		/// The main entry point for the application.
		/// </summary>
		[STAThread]
		static void Main(string[] args)
		{
			RemotingConfiguration.Configure("RemoteTest.exe.config");
			RemoteObject ro = new RemoteObject();

			// To get the list of all methods
			// MethodInfo[] methods = ro.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod);

			MethodInfo m = ro.GetType().GetMethod("MyTypeString",BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod);

			try
			{
				Delegate d = Delegate.CreateDelegate(typeof(del_void),ro,m.Name);
				object o = d.DynamicInvoke(null);
				Console.WriteLine(o);
			}
			catch(TargetInvocationException tie)
			{
				Console.WriteLine(tie.StackTrace);
			}
			catch(Exception e)
			{
				Console.WriteLine(e.StackTrace);
			}
						
			Console.ReadLine();
		}
	}
}

<configuration>
   <system.runtime.remoting>
      <application>
         <service>
            <wellknown 
               mode="SingleCall" objectUri="RemoteObject.rem"
               type="RemoteNamespace.RemoteObject, RemoteLibrary"/>
         </service>
         <channels>
            <channel ref="tcp" port="8080"/>
         </channels>
      </application>
   </system.runtime.remoting>
</configuration>

<configuration>
   <system.runtime.remoting>
      <application>
         <channels>
            <channel ref="tcp" port="0">
               <clientProviders>
                  <formatter 
                     ref="binary"
                  />
               </clientProviders>
            </channel>
         </channels>
         <client>
            <wellknown 
               url="tcp://localhost:8080/RemoteObject.rem"
               type="RemoteNamespace.RemoteObject, RemoteLibrary"
            />
         </client>
      </application>
   </system.runtime.remoting>
</configuration>

MethodInfo m = ro.GetType().GetMethod("MyTypeString",BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod);

using System;
using System.Drawing;
using System.IO;
using System.Runtime.InteropServices;
using System.Windows.Forms;
 
class Example : Form
{
  Example()
  {
    SetStyle(ControlStyles.AllPaintingInWmPaint
      | ControlStyles.ResizeRedraw, true);
 
    using (Image bg = Image.FromStream(
      GetType().Assembly.GetManifestResourceStream("Example.jpg")))
    {
      BackgroundImage = (Image)bg.Clone();
      Size = bg.Size;
    }
 
    FormBorderStyle = FormBorderStyle.None;
  }
 
  void SetTransparentColor(Color c)
  {
    int key = ColorTranslator.ToWin32(c);
    SetLayeredWindowAttributes(Handle, key, 0, LWA_COLORKEY);
  }
 
  protected override System.Windows.Forms.CreateParams CreateParams
  {
    get
    {
      System.Windows.Forms.CreateParams cp = base.CreateParams;
      cp.ExStyle = WS_EX_LAYERED;
      return cp;
    }
  }
 
  protected override void OnHandleCreated(EventArgs e)
  {
    base.OnHandleCreated(e);
    SetTransparentColor(Color.White);
  }
 
  protected override void OnClick(EventArgs e)
  {
    base.OnClick(e);
    Close();
  }
 
  const int LWA_COLORKEY = 0x1;
  const int WS_EX_LAYERED = 0x00080000;
 
  [DllImport("user32.dll")]
  static extern bool SetLayeredWindowAttributes(IntPtr hwnd,
    [MarshalAs(UnmanagedType.U4)] int crKey, byte bAlpha,
    [MarshalAs(UnmanagedType.U4)] int dwFlags);
 
  static void Main()
  {
    Application.Run(new Example());
  }
}

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
 
using AS = System.Windows.Forms.AnchorStyles;
 
class Test : Form
{
  static void Main()
  {
    Application.Run(new Test());
  }
 
  Test()
  {
    Text = "Triangle Example";
 
    Triangle t = new Triangle();
    Controls.Add(t);
    t.Dock = DockStyle.Fill;
 
    BackColor = Color.White;
  }
}
 
class Triangle : Control
{
  public Triangle()
  {
    SetStyle(ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint
      | ControlStyles.DoubleBuffer | ControlStyles.ResizeRedraw, true);
 
    UpdatePath();
  }
 
  protected override void OnPaint(PaintEventArgs e)
  {
    base.OnPaint(e);
 
    if (!init)
    {
      UpdateBrush();
      init = true;
    }
 
    Graphics g = e.Graphics;
    g.Clip = region;
    g.CompositingQuality = CompositingQuality.AssumeLinear;
    g.SmoothingMode = SmoothingMode.AntiAlias;
 
    g.FillPath(brush, path);
  }
 
  protected override void OnResize(EventArgs e)
  {
    base.OnResize(e);
    UpdatePath();
  }
 
  bool drag;
  protected override void OnMouseDown(MouseEventArgs e)
  {
    drag = true;
    SetCenter(e.X, e.Y);
 
    base.OnMouseDown(e);
  }
 
  protected override void OnMouseMove(MouseEventArgs e)
  {
    if (drag)
      SetCenter(e.X, e.Y);
 
    base.OnMouseMove(e);
  }
 
  protected override void OnMouseUp(MouseEventArgs e)
  {
    drag = false;
    base.OnMouseUp(e);
  }
 
  protected override void Dispose(bool disposing)
  {
    if (disposing)
    {
      if (path != null) path.Dispose();
      if (region != null) region.Dispose();
      if (brush != null) brush.Dispose();
    }
  }
 
  void SetCenter(int x, int y)
  {
    if (brush != null)
    {
      brush.CenterPoint = new PointF(x, y);
      Invalidate();
    }
  }
 
  GraphicsPath path;
  Region region;
  void UpdatePath()
  {
    if (Width == 0 || Bottom == 0) return;
 
    PointF p1 = new PointF(Width / 2, Top);
    PointF p2 = new PointF(0, Bottom);
    PointF p3 = new PointF(Width, Bottom);
 
    if (path != null)
    {
      path.Dispose();
      path = null;
    }
 
    if (region != null)
    {
      region.Dispose();
      region = null;
    }
 
    path = new GraphicsPath();
    path.AddPolygon(new PointF[] {p1, p2, p3});
    region = new Region(path);
 
    if (init) UpdateBrush();
  }
 
  PathGradientBrush brush;
  bool init = false;
  void UpdateBrush()
  {
    PointF point = PointF.Empty;
    if (brush != null)
    {
      point = brush.CenterPoint;
      brush.Dispose();
    }
 
    brush = new PathGradientBrush(path);
    brush.CenterColor = Color.Gray;
    if (point != PointF.Empty)
      brush.CenterPoint = point;
    brush.SurroundColors = new Color[] {c1, c2, c3};
  }
 
  Color c1 = Color.Red, c2 = Color.Green, c3 = Color.Blue;
  public Color C1
  {
    get { return c1; }
    set { c1 = value; UpdateBrush(); }
  }
 
  public Color C2
  {
    get { return c2; }
    set { c2 = value; UpdateBrush(); }
  }
 
  public Color C3
  {
    get { return c3; }
    set { c3 = value; UpdateBrush(); }
  }
}