# Zk. 16.2.2012

<{ForumPost(poster="Karel_Proted", timestamp=2012-02-17 19:32:17)}>
Co se vypise?

    class A<T>
    {
        public class B : A<int>
        {
            public void m()
            {
                Console.WriteLine(typeof(T).ToString());
            }
            public class C : A<int>.B { }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            var x = new A<string>.B.C();
            x.m();
        }
    }
    

  
1. Muze se vypsat "x"?  
2. Muze se vypsat neco jineho nez "x", "y" nebo "z"?  
dal bych tipoval

    class X {
        public static volatile int a;
        public static string b = "x";
        public static int c;
    
        public void T1() {
            ...
            b = "y";
            ...
        }
    
        public void T2() {
            ...
            b = "z";
            System.Console.WriteLine(b);
        }
    }
    

1. ne  
2. ne (string je asi atomicky)  
Snad to reknu dobre..  
\[*]volatile write - vsechny operace s pameti pred volatile writem se provedou pred nim.  
\[*]volatile read - vsechny operace s pameti po volatile readu se provedou po nem.  
  
  
Pouziva se S<T>\[] a T\[]. Pri jakych typech se mohou tyto dva pristupy chovat jinak?

    struct S<T> {
        public T item;
        public static implicit operator T(S<T> s){
            return s.item;
        }
    
        public static implicit operator S<T>(T item){
            S<T> s;
            s.item = item;
            return s;
        }
    }
    

Pri referencnich typech, ktere nejsou sealed.  
  
  
Co se vypise?

    class Program
    {
        static Func<int, Func<int, int>> f = x => (((Func<int, int>)(y => x++ + y++)) + (y => x++ + y++));
        static void Main(string[] args)
        {
            Console.WriteLine(f(10)(20));
        }
    }
    

Ostatni myslim byli otazky, ktere jsou na foru jiz zminene. Tak hodne stesti :)
<{/ForumPost}>