C# Class.Call方法代码示例

    public void FromManaged()
    {
        NSObject s = new Class("Subclass1").Call("alloc").Call("init").To<NSObject>();

        try
        {
            Managed.LogException = (e) => {};
            s.Call("BadValue");
            Assert.Fail("should have been an exception");
        }
        catch (TargetInvocationException e)
        {
            Assert.IsTrue(e.Message.Contains("Exception has been thrown by the (managed) target of an Objective-C method call"));
            Assert.IsNotNull(e.InnerException);

            ArgumentException ae = e.InnerException as ArgumentException;
            Assert.IsNotNull(ae);
            Assert.IsTrue(ae.Message.Contains("my error"));
            Assert.IsTrue(ae.Message.Contains("alpha"));
            Assert.AreEqual("alpha", ae.ParamName);
        }
        finally
        {
            Managed.LogException = null;
        }
    }

    public void ArrayArg()
    {
        NSObject pool = new NSObject(NSObject.AllocAndInitInstance("NSAutoreleasePool"));
        Class nsData = new Class("NSData");
        long bytes = DoGetMemory();

        for (int j = 1; j < 100; ++j)
        {
            for (int i = 0; i < NumIterations/100; ++i)
            {
                byte[] data = new byte[]{2, 5, 6, 3};

                NSObject d = new NSObject(nsData.Call("alloc"));
                NSObject e = (NSObject) d.Call("initWithBytes:length:", data, data.Length);
                e.release();
            }
            GC.Collect();
        }

        pool.release();
        GC.Collect();
        GC.WaitForPendingFinalizers();

        long delta = DoGetMemory() - bytes;
        if (delta/NumIterations > 4)
            Assert.Fail("ArrayArg used {0}K of memory ({1} bytes per iteration)!", delta/1024, delta/NumIterations);
    }

    public App(string nibName)
    {
        NSObject app = (NSObject) new Class("NSApplication").Call("sharedApplication");

        // Load our nib. This will instantiate all of the native objects and wire them together.
        // The C# SimpleLayoutView will be created the first time Objective-C calls one of the
        // methods SimpleLayoutView added or overrode.
        NSObject dict = new Class("NSMutableDictionary").Call("alloc").Call("init").To<NSObject>();
        NSObject key = new Class("NSString").Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto("NSOwner")).To<NSObject>();
        dict.Call("setObject:forKey:", app, key);

        NSObject bundle = new Class("NSBundle").Call("mainBundle").To<NSObject>();

        NSObject nib = new Class("NSString").Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto(nibName)).To<NSObject>();
        sbyte loaded = (sbyte) bundle.Call("loadNibFile:externalNameTable:withZone:", nib, dict, null);
        if (loaded != 1)
            throw new InvalidOperationException("Couldn't load the nib file");

        // We need an NSAutoreleasePool to do Native.Call, but we don't want to have one
        // hanging around while we're in the main event loop because that may hide bugs.
        // So, we'll instantiate a Native instance here and call Invoke later which can
        // be done without an NSAutoreleasePool.
        m_run = new Native(app, new Selector("run"));

        dict.release();
    }

    public void BadStruct()
    {
        NSObject str = new Class("NSString").Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto("the quick brown fox")).To<NSObject>();

        NSRect r = new NSRect();
        str.Call("substringWithRange:", r);
    }

    public void BadUInt16To()
    {
        Class klass = new Class("NSNumber");

        NSObject num = klass.Call("alloc").To<NSObject>();
        num = num.Call("initWithInt:", 5000).To<NSObject>();

        num.Call("unsignedShortValue").To<Int32>();
    }

    public void BadFloatTo()
    {
        Class klass = new Class("NSNumber");

        NSObject num = klass.Call("alloc").To<NSObject>();
        num = num.Call("initWithInt:", 5000).To<NSObject>();

        num.Call("floatValue").To<double>();
    }

    public void BadLongTo()
    {
        Class klass = new Class("NSNumber");

        NSObject num = klass.Call("alloc").To<NSObject>();
        num = num.Call("initWithInt:", 5000).To<NSObject>();

        num.Call("longValue").To<Int64>();
    }

    public void Time()
    {
        Class klass = new Class("NSString");
        NSObject str1 = (NSObject) klass.Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto("hello world"));
        NSObject str2 = (NSObject) klass.Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto("100"));
        NSObject str3 = (NSObject) klass.Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto("foo"));

        Stopwatch timer = Stopwatch.StartNew();
        for (int i = 0; i < 10000; ++i)
        {
            str3.Call("hasPrefix:", str1);
        }
        Console.WriteLine("{0}	{1:0.0} secs", new Native(str3, new Selector("hasPrefix:")), timer.ElapsedMilliseconds/1000.0);

        timer = Stopwatch.StartNew();
        for (int i = 0; i < 10000; ++i)
        {
            str2.Call("intValue");
        }
        Console.WriteLine("{0}	{1:0.0} secs", new Native(str2, new Selector("intValue")), timer.ElapsedMilliseconds/1000.0);

        timer = Stopwatch.StartNew();
        for (int i = 0; i < 10000; ++i)
        {
            str1.Call("uppercaseString");
        }
        Console.WriteLine("{0}	{1:0.0} secs", new Native(str1, new Selector("uppercaseString")), timer.ElapsedMilliseconds/1000.0);

        Native native = new Native(str1, new Selector("uppercaseString"));
        timer = Stopwatch.StartNew();
        for (int i = 0; i < 10000; ++i)
        {
            native.Invoke();
        }
        Console.WriteLine("Native {0}	{1:0.0} secs", native, timer.ElapsedMilliseconds/1000.0);

        string s = "hello world";
        timer = Stopwatch.StartNew();
        for (int i = 0; i < 10000; ++i)
        {
            s.ToUpper();
        }
        Console.WriteLine("Managed ToUpper: {0:0.0} secs", timer.ElapsedMilliseconds/1000.0);
    }

    public void BoolWithTo()
    {
        Class klass = new Class("NSNumber");

        NSObject num = klass.Call("alloc").To<NSObject>();
        num = num.Call("initWithBool:", (sbyte) 1).To<NSObject>();

        sbyte result = num.Call("boolValue").To<sbyte>();
        Assert.AreEqual(1, result);
    }

    public void ChainedCallTest()
    {
        NSObject pool = new NSObject(NSObject.AllocAndInitInstance("NSAutoreleasePool"));

        Class nsString = new Class("NSMutableString");
        NSObject str = (NSObject) nsString.Call("alloc").Call("initWithUTF8String:", Marshal.StringToHGlobalAuto("chained!"));

        string result = Marshal.PtrToStringAuto((IntPtr) str.Call("UTF8String"));
        Assert.AreEqual("chained!", result);

        pool.release();
    }

    public void Block()
    {
        if (ExtendedBlock.HasBlocks())
        {
            NSObject s = new Class("NSString").Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto("hello\nthere")).To<NSObject>();

            var lines = new List<string>();
            Enumerator e = (IntPtr context, IntPtr line, ref byte stop) =>
            {
                lines.Add(new NSObject(line).Call("description").ToString());
            };
            var block = new ExtendedBlock(e);
            s.Call("enumerateLinesUsingBlock:", block);

            Assert.AreEqual(2, lines.Count);
            Assert.AreEqual("hello", lines[0]);
            Assert.AreEqual("there", lines[1]);
        }
    }

    public void RefCount1Test()
    {
        NSObject pool = new NSObject(NSObject.AllocAndInitInstance("NSAutoreleasePool"));

        // If we use alloc the object will have a ref count of one.
        NSObject instance = (NSObject) new Class("NSHashTable").Call("alloc").Call("init");
        Assert.AreEqual(1L, instance.retainCount());

        // Classes always have a very high retain count (because they
        // are not supposed to go away).
        Class nsSignature = new Class("NSMethodSignature");
        Assert.IsTrue(nsSignature.retainCount() > 1000);

        // If alloc, new, or copy aren't used then the pool owns the object.
        Class nsString = new Class("NSString");
        NSObject str = (NSObject) nsString.Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto("hello"));
        Assert.AreEqual(1L, str.retainCount());

        // We can have two managed instances on the same native instance
        // and the ref count doesn't change.
        NSObject copy = new NSObject((IntPtr) instance);
        Assert.AreEqual(1L, copy.retainCount());

        // If we send a message to an object its retain count doesn't change.
        instance.Call("description");
        Assert.AreEqual(1L, instance.retainCount());

        pool.release();

        // Verify our counts after we empty the release pool.
        Assert.AreEqual(1L, instance.retainCount());
        Assert.AreEqual(1L, copy.retainCount());
    }

    public void DerivedWithTo()
    {
        NSObject o = new Class("Subclass1").Call("alloc").Call("initValue").To<NSObject>();

        NSObject p = o.Call("Clone").To<NSObject>();
        Assert.IsTrue((IntPtr) o != (IntPtr) p);
        Assert.AreEqual(100, (int) p.Call("getValue"));

        Subclass1 q = o.Call("Clone").To<Subclass1>();
        Assert.IsTrue((IntPtr) o != (IntPtr) q);
        Assert.AreEqual(100, q.GetValue());
    }

    public void IntArg()
    {
        NSObject pool = new NSObject(NSObject.AllocAndInitInstance("NSAutoreleasePool"));
        long bytes = DoGetMemory();

        Class nsString = new Class("NSString");
        NSObject str = (NSObject) nsString.Call("stringWithUTF8String:", Marshal.StringToHGlobalAuto("hello world"));

        for (int j = 1; j < 100; ++j)
        {
            for (int i = 0; i < NumIterations/100; ++i)
            {
                str.Call("characterAtIndex:", 2);
            }
            GC.Collect();
        }

        pool.release();
        GC.Collect();
        GC.WaitForPendingFinalizers();

        long delta = DoGetMemory() - bytes;
        if (delta/NumIterations > 4)
            Assert.Fail("IntArg used {0}K of memory ({1} bytes per iteration)!", delta/1024, delta/NumIterations);
    }

 private NSObject DoCreateStr(string s)
 {
     Class nsString = new Class("NSMutableString");
     NSObject str = (NSObject) nsString.Call("alloc");
     return (NSObject) str.Call("initWithUTF8String:", Marshal.StringToHGlobalAuto(s));
 }