////////////////////////////////////////////////////////////////////////////////
using IntPtr_NumType         =System.Int64;
using IntPtr_UnsignedNumType =System.UInt64;
////////////////////////////////////////////////////////////////////////////////
//class intptr_utils

public static class intptr_utils
{
 private const ste_err_src_id c_src_id=ste_err_src_id.intptr_utils;

 //-----------------------------------------------------------------------
 public static readonly IntPtr_NumType Zero
  =0;

 public static readonly IntPtr_NumType MaxValue
  =t_intptr_utils__data.GetProvider().MaxValue;

 public static readonly IntPtr_NumType MinValue
  =t_intptr_utils__data.GetProvider().MinValue;

 //-----------------------------------------------------------------------
 public static IntPtr_NumType ToNumeric(IntPtr x)
 {
  return x.ToInt64();
 }//ToNumeric

 //-----------------------------------------------------------------------
 public static IntPtr ToIntPtr(IntPtr_NumType x)
 {
  if(!(MinValue<=x && x<=MaxValue))
   throw_sys_error.arithmetic_overflow(c_src_id,"ToIntPtr__NumType",x);

  return (IntPtr)x;
 }//ToIntPtr

 //IntPtr+UInt32 ---------------------------------------------------------
 public static IntPtr Add(IntPtr a,UInt32 b)
 {
  Debug.Assert(MinValue<0);
  Debug.Assert(MaxValue>0);

  var a1=ToNumeric(a);
  var b1=b;

  while(b1>MaxValue)
  {
   if(a1>0)
    throw_sys_error.arithmetic_overflow(c_src_id,"Add__IntPtr_UInt32",a,b);

   a1+=MaxValue;
   b1-=(UInt32)MaxValue;
  }//while b1>MaxValue

  Debug.Assert(b1>=0);
  Debug.Assert(b1<=MaxValue);

  Debug.Assert(a1>=MinValue);
  Debug.Assert(a1<=MaxValue);

  if(a1>=0)
  {
   if((MaxValue-a1)<b1)
    throw_sys_error.arithmetic_overflow(c_src_id,"Add__IntPtr_UInt32",a,b);
  }//a1>=0

  return (IntPtr)(a1+((IntPtr_NumType)b1));
 }//Add - IntPtr+UInt32

 //-----------------------------------------------------------------------
 public static IntPtr Add(UInt32 a,IntPtr b)
 {
  return Add(b,a);
 }//Add - UInt32+IntPtr

 //IntPtr+UInt64 ---------------------------------------------------------
 public static IntPtr Add(IntPtr a,UInt64 b)
 {
  Debug.Assert(MinValue<0);
  Debug.Assert(MaxValue>0);

  var a1=ToNumeric(a);
  var b1=b;

  while(b1>((IntPtr_UnsignedNumType)MaxValue))
  {
   if(a1>0)
    throw_sys_error.arithmetic_overflow(c_src_id,"Add__IntPtr_UInt64",a,b);

   a1+=MaxValue;
   b1-=(IntPtr_UnsignedNumType)MaxValue;
  }//while b1>MaxValue

  Debug.Assert(b1>=0);
  Debug.Assert(b1<=((IntPtr_UnsignedNumType)MaxValue));

  Debug.Assert(a1>=MinValue);
  Debug.Assert(a1<=MaxValue);

  if(a1>=0)
  {
   if(((IntPtr_UnsignedNumType)(MaxValue-a1))<b1)
    throw_sys_error.arithmetic_overflow(c_src_id,"Add__IntPtr_UInt64",a,b);
  }//a1>=0

  return (IntPtr)(a1+((IntPtr_NumType)b1));
 }//Add - IntPtr+UInt64

 //-----------------------------------------------------------------------
 public static IntPtr Add(UInt64 a,IntPtr b)
 {
  return Add(b,a);
 }//Add - UInt64+IntPtr
 
 //IntPtr+Int32 ----------------------------------------------------------
 public static IntPtr Add(IntPtr a,Int32 b)
 {
  Debug.Assert(MinValue<0);
  Debug.Assert(MaxValue>0);

  if(b>=0)
   return Add(a,(UInt32)b);

  return Sub(a,remove_numeric_sign.exec(b));
 }//Add - IntPtr+Int32

 //-----------------------------------------------------------------------
 public static IntPtr Add(Int32 a,IntPtr b)
 {
  return Add(b,a);
 }//Add - Int32+IntPtr

 //IntPtr+UIntPtr --------------------------------------------------------
 public static IntPtr Add(IntPtr a,UIntPtr b)
 {
  Debug.Assert(MinValue<0);
  Debug.Assert(MaxValue>0);

  var a1=ToNumeric(a);
  var b1=uintptr_utils.ToNumeric(b);

  while(b1>((IntPtr_UnsignedNumType)MaxValue))
  {
   if(a1>0)
    throw_sys_error.arithmetic_overflow(c_src_id,"Add__IntPtr_UIntPtr",a,b);

   a1+=MaxValue;
   b1-=(IntPtr_UnsignedNumType)MaxValue;
  }//while b1>MaxValue

  Debug.Assert(b1>=0);
  Debug.Assert(b1<=((IntPtr_UnsignedNumType)MaxValue));

  Debug.Assert(a1>=MinValue);
  Debug.Assert(a1<=MaxValue);

  if(a1>=0)
  {
   if(((IntPtr_UnsignedNumType)(MaxValue-a1))<b1)
    throw_sys_error.arithmetic_overflow(c_src_id,"Add__IntPtr_UIntPtr",a,b);
  }//a1>=0

  return (IntPtr)(a1+((IntPtr_NumType)b1));
 }//Add - IntPtr+UIntPtr

 //-----------------------------------------------------------------------
 public static IntPtr Add(UIntPtr a,IntPtr b)
 {
  return Add(b,a);
 }//Add - UIntPtr, IntPtr

 //-----------------------------------------------------------------------
 public static IntPtr Sub(IntPtr a,UInt32 b)
 {
  Debug.Assert(MinValue<0);
  Debug.Assert(MaxValue>0);
  Debug.Assert(MaxValue==-(MinValue+1));

  var a1=ToNumeric(a);
  var b1=b;

  if(a1>=0)
  {
   if(a1>=b1)
    return (IntPtr)(a1-((IntPtr_NumType)b1));

   b1-=(UInt32)a1;
   a1=0;
  }//if a1>0

  Debug.Assert(a1<=0);

  while(b1>MaxValue)
  {
   Debug.Assert(a1>=MinValue);
   Debug.Assert(a1<=MaxValue);

   if(a1<0)
    throw_sys_error.arithmetic_overflow(c_src_id,"Sub__IntPtr_UInt32",a,b);

   a1-=MaxValue;
   b1-=(UInt32)MaxValue;
  }//while b>MaxValue

  Debug.Assert(a1<=0);
  Debug.Assert(a1>=MinValue);
  Debug.Assert(b1<=MaxValue);

  if(a1<0)
  {
   if((a1-MinValue)<b1)
    throw_sys_error.arithmetic_overflow(c_src_id,"Sub__IntPtr_UInt32",a,b);
  }//if a1<0

  return (IntPtr)(a1-((IntPtr_NumType)b1));
 }//Sub - IntPtr, UInt32

 //private data ----------------------------------------------------------
 private static readonly t_intptr_utils__provider
  sm_Impl=t_intptr_utils__data.GetProvider();
}//class intptr_utils

public static class serialization_utils
{
 public static void read_value<T>(SerializationInfo si,string name,out T value)
 {
  Debug.Assert(si!=null);
  Debug.Assert(name!=null);
  Debug.Assert(name!="");

  value=(T)si.GetValue(name,typeof(T));
 }//read_value

 //-----------------------------------------------------------------------
 public static void write_value<T>(SerializationInfo si,string name,T value)
 {
  Debug.Assert(si!=null);
  Debug.Assert(name!=null);
  Debug.Assert(name!="");

  si.AddValue(name,value,typeof(T));
 }//write_value
}//class serialization_utils

using System;
using System.Collections.Generic;

////////////////////////////////////////////////////////////////////////////////

interface IProcessor2<T1,T2>
{
};

////////////////////////////////////////////////////////////////////////////////
//class utils

class utils
{
 public static void exec<T1,T2>(IList<T1> list,T2 key,IProcessor2<T1,T2> proc)
 {
 }
}//utils

////////////////////////////////////////////////////////////////////////////////
//processors

class TProcessor:IProcessor2<string,int>,IProcessor2<Guid,int>
{
};//class TProcessor

////////////////////////////////////////////////////////////////////////////////

class Program
{
 static int Main()
 {
  var list_str=new List<string>();
  var list_guid=new List<Guid>();

  var proc=new TProcessor();

  int n=0;
  
  //VS2010 - ok.
  
  //VS2008 - fail
  //Ошибка    1    Аргументы-типы для метода
  //"utils.exec<T1,T2>(System.Collections.Generic.IList<T1>, T2, IProcessor2<T1,T2>)"
  //не должны определяться по использованию. Попытайтесь явно определить аргументы-типы.
  
  utils.exec/*<string,int>*/(list_str,n,proc);
  utils.exec/*<Guid,int>*/(list_guid,n,proc);
  
  return 0;
 }//Main
}//class Program